1#![allow(
9 unused_imports,
10 non_camel_case_types,
11 clippy::large_enum_variant,
12 clippy::enum_variant_names,
13 clippy::empty_docs
14)]
15
16use serde::{Deserialize, Serialize};
17use serde_json::Value;
18
19#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
23#[serde(transparent)]
24pub struct AbsolutePathBuf(pub String);
25
26#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
27#[serde(tag = "type", rename_all = "camelCase")]
28pub enum Account {
29 #[serde(rename = "apiKey")]
30 ApiKey,
31 Chatgpt {
32 #[serde(default, skip_serializing_if = "Option::is_none")]
33 email: Option<String>,
34 #[serde(rename = "planType")]
35 plan_type: PlanType,
36 #[serde(
38 rename = "workspaceName",
39 default,
40 skip_serializing_if = "Option::is_none"
41 )]
42 workspace_name: Option<String>,
43 },
44 #[serde(rename = "amazonBedrock")]
45 AmazonBedrock {
46 #[serde(
47 rename = "usesCodexManagedCredentials",
48 default,
49 skip_serializing_if = "Option::is_none"
50 )]
51 uses_codex_managed_credentials: Option<bool>,
52 },
53 #[serde(rename = "gcp")]
55 Gcp,
56}
57
58#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
59#[serde(rename_all = "camelCase")]
60pub struct AccountLoginCompletedNotification {
61 #[serde(default, skip_serializing_if = "Option::is_none")]
62 pub error: Option<String>,
63 #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
64 pub login_id: Option<String>,
65 #[serde(
66 rename = "onboardingEntrypoint",
67 default,
68 skip_serializing_if = "Option::is_none"
69 )]
70 pub onboarding_entrypoint: Option<DesktopOnboardingEntrypoint>,
71 #[serde(default)]
72 pub success: bool,
73}
74
75#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
76#[serde(rename_all = "camelCase")]
77pub struct AccountRateLimitsUpdatedNotification {
78 #[serde(rename = "rateLimits")]
79 pub rate_limits: RateLimitSnapshot,
80}
81
82#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
83#[serde(rename_all = "camelCase")]
84pub struct AccountTokenUsageDailyBucket {
85 #[serde(rename = "startDate", default)]
86 pub start_date: String,
87 #[serde(default)]
88 pub tokens: i64,
89}
90
91#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
92#[serde(rename_all = "camelCase")]
93pub struct AccountTokenUsageSummary {
94 #[serde(
95 rename = "currentStreakDays",
96 default,
97 skip_serializing_if = "Option::is_none"
98 )]
99 pub current_streak_days: Option<i64>,
100 #[serde(
101 rename = "lifetimeTokens",
102 default,
103 skip_serializing_if = "Option::is_none"
104 )]
105 pub lifetime_tokens: Option<i64>,
106 #[serde(
107 rename = "longestRunningTurnSec",
108 default,
109 skip_serializing_if = "Option::is_none"
110 )]
111 pub longest_running_turn_sec: Option<i64>,
112 #[serde(
113 rename = "longestStreakDays",
114 default,
115 skip_serializing_if = "Option::is_none"
116 )]
117 pub longest_streak_days: Option<i64>,
118 #[serde(
119 rename = "peakDailyTokens",
120 default,
121 skip_serializing_if = "Option::is_none"
122 )]
123 pub peak_daily_tokens: Option<i64>,
124}
125
126#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
127#[serde(rename_all = "camelCase")]
128pub struct AccountUpdatedNotification {
129 #[serde(rename = "authMode", default, skip_serializing_if = "Option::is_none")]
130 pub auth_mode: Option<AuthMode>,
131 #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
132 pub plan_type: Option<PlanType>,
133 #[serde(default, skip_serializing_if = "Option::is_none")]
136 pub reason: Option<AccountUpdateReason>,
137}
138
139#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
141pub enum AccountUpdateReason {
142 #[serde(rename = "workspaceRoutingReady")]
143 WorkspaceRoutingReady,
144 #[serde(rename = "unknown", other)]
146 Unknown,
147}
148
149#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
150#[serde(rename_all = "camelCase")]
151pub struct ActivePermissionProfile {
152 #[serde(default, skip_serializing_if = "Option::is_none")]
153 pub extends: Option<String>,
154 #[serde(default)]
155 pub id: String,
156}
157
158#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
159pub enum AddCreditsNudgeCreditType {
160 #[serde(rename = "credits")]
161 Credits,
162 #[serde(rename = "usage_limit")]
163 Usage_limit,
164}
165
166#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
167pub enum AddCreditsNudgeEmailStatus {
168 #[serde(rename = "sent")]
169 Sent,
170 #[serde(rename = "cooldown_active")]
171 Cooldown_active,
172}
173
174#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
175#[serde(rename_all = "camelCase")]
176pub struct AdditionalFileSystemPermissions {
177 #[serde(default, skip_serializing_if = "Option::is_none")]
178 pub entries: Option<Vec<FileSystemSandboxEntry>>,
179 #[serde(
180 rename = "globScanMaxDepth",
181 default,
182 skip_serializing_if = "Option::is_none"
183 )]
184 pub glob_scan_max_depth: Option<i64>,
185 #[serde(default, skip_serializing_if = "Option::is_none")]
186 pub read: Option<Vec<LegacyAppPathString>>,
187 #[serde(default, skip_serializing_if = "Option::is_none")]
188 pub write: Option<Vec<LegacyAppPathString>>,
189}
190
191#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
192#[serde(rename_all = "camelCase")]
193pub struct AdditionalNetworkPermissions {
194 #[serde(default, skip_serializing_if = "Option::is_none")]
195 pub enabled: Option<bool>,
196}
197
198#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
199#[serde(rename_all = "camelCase")]
200pub struct AgentMessageDeltaNotification {
201 #[serde(default)]
202 pub delta: String,
203 #[serde(rename = "itemId", default)]
204 pub item_id: String,
205 #[serde(rename = "threadId", default)]
206 pub thread_id: String,
207 #[serde(rename = "turnId", default)]
208 pub turn_id: String,
209}
210
211#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
212#[serde(transparent)]
213pub struct AgentPath(pub String);
214
215#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
216#[serde(rename_all = "snake_case")]
217pub struct AnalyticsConfig {
218 #[serde(default, skip_serializing_if = "Option::is_none")]
219 pub enabled: Option<bool>,
220 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
221 pub additional: serde_json::Map<String, Value>,
222}
223
224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
225#[serde(rename_all = "camelCase")]
226pub struct AppBranding {
227 #[serde(default, skip_serializing_if = "Option::is_none")]
228 pub category: Option<String>,
229 #[serde(default, skip_serializing_if = "Option::is_none")]
230 pub developer: Option<String>,
231 #[serde(rename = "isDiscoverableApp", default)]
232 pub is_discoverable_app: bool,
233 #[serde(
234 rename = "privacyPolicy",
235 default,
236 skip_serializing_if = "Option::is_none"
237 )]
238 pub privacy_policy: Option<String>,
239 #[serde(
240 rename = "termsOfService",
241 default,
242 skip_serializing_if = "Option::is_none"
243 )]
244 pub terms_of_service: Option<String>,
245 #[serde(default, skip_serializing_if = "Option::is_none")]
246 pub website: Option<String>,
247}
248
249#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
250#[serde(rename_all = "camelCase")]
251pub struct AppInfo {
252 #[serde(
253 rename = "appMetadata",
254 default,
255 skip_serializing_if = "Option::is_none"
256 )]
257 pub app_metadata: Option<AppMetadata>,
258 #[serde(default, skip_serializing_if = "Option::is_none")]
259 pub branding: Option<AppBranding>,
260 #[serde(default, skip_serializing_if = "Option::is_none")]
261 pub description: Option<String>,
262 #[serde(
263 rename = "distributionChannel",
264 default,
265 skip_serializing_if = "Option::is_none"
266 )]
267 pub distribution_channel: Option<String>,
268 #[serde(
269 rename = "iconAssets",
270 default,
271 skip_serializing_if = "Option::is_none"
272 )]
273 pub icon_assets: Option<std::collections::BTreeMap<String, String>>,
274 #[serde(
275 rename = "iconDarkAssets",
276 default,
277 skip_serializing_if = "Option::is_none"
278 )]
279 pub icon_dark_assets: Option<std::collections::BTreeMap<String, String>>,
280 #[serde(default)]
281 pub id: String,
282 #[serde(
283 rename = "installUrl",
284 default,
285 skip_serializing_if = "Option::is_none"
286 )]
287 pub install_url: Option<String>,
288 #[serde(
289 rename = "isAccessible",
290 default,
291 skip_serializing_if = "Option::is_none"
292 )]
293 pub is_accessible: Option<bool>,
294 #[serde(rename = "isEnabled", default, skip_serializing_if = "Option::is_none")]
295 pub is_enabled: Option<bool>,
296 #[serde(default, skip_serializing_if = "Option::is_none")]
297 pub labels: Option<std::collections::BTreeMap<String, String>>,
298 #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
299 pub logo_url: Option<String>,
300 #[serde(
301 rename = "logoUrlDark",
302 default,
303 skip_serializing_if = "Option::is_none"
304 )]
305 pub logo_url_dark: Option<String>,
306 #[serde(default)]
307 pub name: String,
308 #[serde(
309 rename = "pluginDisplayNames",
310 default,
311 skip_serializing_if = "Option::is_none"
312 )]
313 pub plugin_display_names: Option<Vec<String>>,
314}
315
316#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
317#[serde(rename_all = "camelCase")]
318pub struct AppListUpdatedNotification {
319 #[serde(default)]
320 pub data: Vec<AppInfo>,
321}
322
323#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
324#[serde(rename_all = "camelCase")]
325pub struct AppMetadata {
326 #[serde(default, skip_serializing_if = "Option::is_none")]
327 pub categories: Option<Vec<String>>,
328 #[serde(default, skip_serializing_if = "Option::is_none")]
329 pub developer: Option<String>,
330 #[serde(
331 rename = "firstPartyRequiresInstall",
332 default,
333 skip_serializing_if = "Option::is_none"
334 )]
335 pub first_party_requires_install: Option<bool>,
336 #[serde(default, skip_serializing_if = "Option::is_none")]
337 pub review: Option<AppReview>,
338 #[serde(default, skip_serializing_if = "Option::is_none")]
339 pub screenshots: Option<Vec<AppScreenshot>>,
340 #[serde(
341 rename = "seoDescription",
342 default,
343 skip_serializing_if = "Option::is_none"
344 )]
345 pub seo_description: Option<String>,
346 #[serde(
347 rename = "showInComposerWhenUnlinked",
348 default,
349 skip_serializing_if = "Option::is_none"
350 )]
351 pub show_in_composer_when_unlinked: Option<bool>,
352 #[serde(
353 rename = "subCategories",
354 default,
355 skip_serializing_if = "Option::is_none"
356 )]
357 pub sub_categories: Option<Vec<String>>,
358 #[serde(default, skip_serializing_if = "Option::is_none")]
359 pub version: Option<String>,
360 #[serde(rename = "versionId", default, skip_serializing_if = "Option::is_none")]
361 pub version_id: Option<String>,
362 #[serde(
363 rename = "versionNotes",
364 default,
365 skip_serializing_if = "Option::is_none"
366 )]
367 pub version_notes: Option<String>,
368}
369
370#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
371#[serde(rename_all = "camelCase")]
372pub struct AppReview {
373 #[serde(default)]
374 pub status: String,
375}
376
377#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
378#[serde(rename_all = "camelCase")]
379pub struct AppScreenshot {
380 #[serde(rename = "fileId", default, skip_serializing_if = "Option::is_none")]
381 pub file_id: Option<String>,
382 #[serde(default, skip_serializing_if = "Option::is_none")]
383 pub url: Option<String>,
384 #[serde(rename = "userPrompt", default)]
385 pub user_prompt: String,
386}
387
388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
389#[serde(rename_all = "camelCase")]
390pub struct AppSummary {
391 #[serde(default, skip_serializing_if = "Option::is_none")]
392 pub category: Option<String>,
393 #[serde(default, skip_serializing_if = "Option::is_none")]
394 pub description: Option<String>,
395 #[serde(default)]
396 pub id: String,
397 #[serde(
398 rename = "installUrl",
399 default,
400 skip_serializing_if = "Option::is_none"
401 )]
402 pub install_url: Option<String>,
403 #[serde(default)]
404 pub name: String,
405}
406
407#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
408#[serde(rename_all = "camelCase")]
409pub struct AppTemplateSummary {
410 #[serde(
411 rename = "canonicalConnectorId",
412 default,
413 skip_serializing_if = "Option::is_none"
414 )]
415 pub canonical_connector_id: Option<String>,
416 #[serde(default, skip_serializing_if = "Option::is_none")]
417 pub category: Option<String>,
418 #[serde(default, skip_serializing_if = "Option::is_none")]
419 pub description: Option<String>,
420 #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
421 pub logo_url: Option<String>,
422 #[serde(
423 rename = "logoUrlDark",
424 default,
425 skip_serializing_if = "Option::is_none"
426 )]
427 pub logo_url_dark: Option<String>,
428 #[serde(rename = "materializedAppIds", default)]
429 pub materialized_app_ids: Vec<String>,
430 #[serde(default)]
431 pub name: String,
432 #[serde(default, skip_serializing_if = "Option::is_none")]
433 pub reason: Option<AppTemplateUnavailableReason>,
434 #[serde(rename = "templateId", default)]
435 pub template_id: String,
436}
437
438#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
439pub enum AppTemplateUnavailableReason {
440 #[serde(rename = "NOT_CONFIGURED_FOR_WORKSPACE")]
441 NOT_CONFIGURED_FOR_WORKSPACE,
442 #[serde(rename = "NO_ACTIVE_WORKSPACE")]
443 NO_ACTIVE_WORKSPACE,
444}
445
446#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
447#[serde(rename_all = "camelCase")]
448pub struct AppToolSummary {
449 #[serde(default)]
450 pub description: String,
451 #[serde(
452 rename = "disabledReason",
453 default,
454 skip_serializing_if = "Option::is_none"
455 )]
456 pub disabled_reason: Option<String>,
457 #[serde(rename = "isEnabled", default, skip_serializing_if = "Option::is_none")]
458 pub is_enabled: Option<bool>,
459 #[serde(
460 rename = "isReadOnly",
461 default,
462 skip_serializing_if = "Option::is_none"
463 )]
464 pub is_read_only: Option<bool>,
465 #[serde(default)]
466 pub name: String,
467 #[serde(default, skip_serializing_if = "Option::is_none")]
468 pub title: Option<String>,
469}
470
471#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
472#[serde(rename_all = "camelCase")]
473pub struct ApplyPatchApprovalParams {
474 #[serde(rename = "callId", default)]
475 pub call_id: String,
476 #[serde(rename = "conversationId")]
477 pub conversation_id: ThreadId,
478 #[serde(rename = "fileChanges", default)]
479 pub file_changes: std::collections::BTreeMap<String, FileChange>,
480 #[serde(rename = "grantRoot", default, skip_serializing_if = "Option::is_none")]
481 pub grant_root: Option<String>,
482 #[serde(default, skip_serializing_if = "Option::is_none")]
483 pub reason: Option<String>,
484}
485
486#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
487#[serde(rename_all = "camelCase")]
488pub struct ApplyPatchApprovalResponse {
489 #[serde()]
490 pub decision: ReviewDecision,
491}
492
493#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
494pub enum ApprovalsReviewer {
495 #[serde(rename = "user")]
496 User,
497 #[serde(rename = "auto_review")]
498 Auto_review,
499 #[serde(rename = "guardian_subagent")]
500 Guardian_subagent,
501}
502
503#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
504#[serde(rename_all = "camelCase")]
505pub struct AppsInstalledParams {
506 #[serde(
507 rename = "forceRefresh",
508 default,
509 skip_serializing_if = "Option::is_none"
510 )]
511 pub force_refresh: Option<bool>,
512 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
513 pub thread_id: Option<String>,
514}
515
516#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
517#[serde(rename_all = "camelCase")]
518pub struct AppsInstalledResponse {
519 #[serde(default)]
520 pub apps: Vec<InstalledApp>,
521}
522
523#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
524#[serde(rename_all = "camelCase")]
525pub struct AppsListParams {
526 #[serde(default, skip_serializing_if = "Option::is_none")]
527 pub cursor: Option<String>,
528 #[serde(
529 rename = "forceRefetch",
530 default,
531 skip_serializing_if = "Option::is_none"
532 )]
533 pub force_refetch: Option<bool>,
534 #[serde(default, skip_serializing_if = "Option::is_none")]
535 pub limit: Option<i64>,
536 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
537 pub thread_id: Option<String>,
538}
539
540#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
541#[serde(rename_all = "camelCase")]
542pub struct AppsListResponse {
543 #[serde(default)]
544 pub data: Vec<AppInfo>,
545 #[serde(
546 rename = "nextCursor",
547 default,
548 skip_serializing_if = "Option::is_none"
549 )]
550 pub next_cursor: Option<String>,
551}
552
553#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
554#[serde(rename_all = "camelCase")]
555pub struct AppsReadParams {
556 #[serde(rename = "appIds", default)]
557 pub app_ids: Vec<String>,
558 #[serde(
559 rename = "includeTools",
560 default,
561 skip_serializing_if = "Option::is_none"
562 )]
563 pub include_tools: Option<bool>,
564 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
565 pub thread_id: Option<String>,
566}
567
568#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
569#[serde(rename_all = "camelCase")]
570pub struct AppsReadResponse {
571 #[serde(default)]
572 pub apps: Vec<ConnectorMetadata>,
573 #[serde(rename = "missingAppIds", default)]
574 pub missing_app_ids: Vec<String>,
575}
576
577#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
578pub enum AskForApproval {
579 #[serde(rename = "untrusted")]
580 Untrusted,
581 #[serde(rename = "on-request")]
582 OnRequest,
583 #[serde(rename = "never")]
584 Never,
585 #[serde(rename = "granular")]
586 Granular {
587 mcp_elicitations: bool,
588 #[serde(default, skip_serializing_if = "Option::is_none")]
589 request_permissions: Option<bool>,
590 rules: bool,
591 sandbox_approval: bool,
592 #[serde(default, skip_serializing_if = "Option::is_none")]
593 skill_approval: Option<bool>,
594 },
595}
596
597#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
600#[serde(rename_all = "camelCase")]
601pub struct AsyncUserInputQuestion {
602 #[serde(default, skip_serializing_if = "Option::is_none")]
603 pub options: Option<Vec<String>>,
604 #[serde(default)]
605 pub title: String,
606}
607
608#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
609#[serde(rename_all = "camelCase")]
610pub struct AttestationGenerateParams {
611 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
612 pub extra: serde_json::Map<String, Value>,
613}
614
615#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
616#[serde(rename_all = "camelCase")]
617pub struct AttestationGenerateResponse {
618 #[serde(default)]
619 pub token: String,
620}
621
622#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
626#[serde(rename_all = "camelCase")]
627pub struct AuthRecoveryNotification {
628 #[serde(default)]
629 pub message: String,
630 #[serde(default)]
631 pub provider: String,
632 #[serde(rename = "threadId", default)]
633 pub thread_id: String,
634 #[serde(rename = "turnId", default)]
635 pub turn_id: String,
636}
637
638#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
639pub enum AuthMode {
640 #[serde(rename = "apikey")]
641 Apikey,
642 #[serde(rename = "chatgpt")]
643 Chatgpt,
644 #[serde(rename = "chatgptAuthTokens")]
645 ChatgptAuthTokens,
646 #[serde(rename = "headers")]
647 Headers,
648 #[serde(rename = "agentIdentity")]
649 AgentIdentity,
650 #[serde(rename = "personalAccessToken")]
651 PersonalAccessToken,
652 #[serde(rename = "bedrockApiKey")]
653 BedrockApiKey,
654 #[serde(rename = "bedrockAccessKeys")]
655 BedrockAccessKeys,
656}
657
658#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
659pub enum AutoCompactTokenLimitScope {
660 #[serde(rename = "total")]
661 Total,
662 #[serde(rename = "body_after_prefix")]
663 BodyAfterPrefix,
664}
665
666#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
667pub enum AutoReviewDecisionSource {
668 #[serde(rename = "agent")]
669 Agent,
670}
671
672#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
673#[serde(rename_all = "camelCase")]
674pub struct AutoReviewRequirements {
675 #[serde(
676 rename = "ignoreRules",
677 default,
678 skip_serializing_if = "Option::is_none"
679 )]
680 pub ignore_rules: Option<Vec<String>>,
681 #[serde(
682 rename = "requiredOnModels",
683 default,
684 skip_serializing_if = "Option::is_none"
685 )]
686 pub required_on_models: Option<Vec<String>>,
687}
688
689#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
690#[serde(rename_all = "camelCase")]
691pub struct BrowserUseRequirements {
692 #[serde(
695 rename = "allowWebmcp",
696 default,
697 skip_serializing_if = "Option::is_none"
698 )]
699 pub allow_webmcp: Option<bool>,
700 #[serde(
701 rename = "allowGlobalPersistentApproval",
702 default,
703 skip_serializing_if = "Option::is_none"
704 )]
705 pub allow_global_persistent_approval: Option<bool>,
706 #[serde(
707 rename = "allowHistoryAccess",
708 default,
709 skip_serializing_if = "Option::is_none"
710 )]
711 pub allow_history_access: Option<bool>,
712 #[serde(
713 rename = "defaultOriginPolicy",
714 default,
715 skip_serializing_if = "Option::is_none"
716 )]
717 pub default_origin_policy: Option<BrowserUseOriginPolicy>,
718 #[serde(default, skip_serializing_if = "Option::is_none")]
719 pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicy>>,
720 #[serde(
721 rename = "disableAutoReview",
722 default,
723 skip_serializing_if = "Option::is_none"
724 )]
725 pub disable_auto_review: Option<bool>,
726 #[serde(default, skip_serializing_if = "Option::is_none")]
728 pub extension: Option<BrowserUseExtensionRequirements>,
729}
730
731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
734#[serde(rename_all = "camelCase")]
735pub struct BrowserUseExtensionRequirements {
736 #[serde(
738 rename = "requestHeaders",
739 default,
740 skip_serializing_if = "Option::is_none"
741 )]
742 pub request_headers: Option<Vec<RequestHeader>>,
743}
744
745#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
748#[serde(rename_all = "camelCase")]
749pub struct RequestHeader {
750 #[serde(default)]
751 pub name: String,
752 #[serde(default)]
753 pub value: String,
754}
755
756#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
757#[serde(rename_all = "camelCase")]
758pub struct ByteRange {
759 #[serde(default)]
760 pub end: i64,
761 #[serde(default)]
762 pub start: i64,
763}
764
765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
766#[serde(rename_all = "camelCase")]
767pub struct CancelLoginAccountParams {
768 #[serde(rename = "loginId", default)]
769 pub login_id: String,
770}
771
772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
773#[serde(rename_all = "camelCase")]
774pub struct CancelLoginAccountResponse {
775 #[serde()]
776 pub status: CancelLoginAccountStatus,
777}
778
779#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
780pub enum CancelLoginAccountStatus {
781 #[serde(rename = "canceled")]
782 Canceled,
783 #[serde(rename = "notFound")]
784 NotFound,
785}
786
787#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
788#[serde(rename_all = "camelCase")]
789pub struct ChatgptAuthTokensRefreshParams {
790 #[serde(
791 rename = "previousAccountId",
792 default,
793 skip_serializing_if = "Option::is_none"
794 )]
795 pub previous_account_id: Option<String>,
796 #[serde()]
797 pub reason: ChatgptAuthTokensRefreshReason,
798}
799
800#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
801pub enum ChatgptAuthTokensRefreshReason {
802 #[serde(rename = "unauthorized")]
803 Unauthorized,
804}
805
806#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
807#[serde(rename_all = "camelCase")]
808pub struct ChatgptAuthTokensRefreshResponse {
809 #[serde(rename = "accessToken", default)]
810 pub access_token: String,
811 #[serde(rename = "chatgptAccountId", default)]
812 pub chatgpt_account_id: String,
813 #[serde(
814 rename = "chatgptPlanType",
815 default,
816 skip_serializing_if = "Option::is_none"
817 )]
818 pub chatgpt_plan_type: Option<String>,
819}
820
821#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
822#[serde(rename_all = "camelCase")]
823pub struct ClientInfo {
824 #[serde(default)]
825 pub name: String,
826 #[serde(default, skip_serializing_if = "Option::is_none")]
827 pub title: Option<String>,
828 #[serde(default)]
829 pub version: String,
830}
831
832#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
833pub enum CodexErrorInfo {
834 #[serde(rename = "contextWindowExceeded")]
835 ContextWindowExceeded,
836 #[serde(rename = "sessionBudgetExceeded")]
837 SessionBudgetExceeded,
838 #[serde(rename = "usageLimitExceeded")]
839 UsageLimitExceeded,
840 #[serde(rename = "apiKeySpendLimitExceeded")]
842 ApiKeySpendLimitExceeded,
843 #[serde(rename = "projectSpendLimitExceeded")]
845 ProjectSpendLimitExceeded,
846 #[serde(rename = "organizationSpendLimitExceeded")]
848 OrganizationSpendLimitExceeded,
849 #[serde(rename = "rateLimitExceeded")]
850 RateLimitExceeded,
851 #[serde(rename = "flexUnavailable")]
852 FlexUnavailable,
853 #[serde(rename = "serverOverloaded")]
854 ServerOverloaded,
855 #[serde(rename = "modelNotFound")]
858 ModelNotFound,
859 #[serde(rename = "policyCapacityUnavailable")]
862 PolicyCapacityUnavailable,
863 #[serde(rename = "inferenceHookDenied")]
866 InferenceHookDenied,
867 #[serde(rename = "cyberPolicy")]
868 CyberPolicy,
869 #[serde(rename = "bioPolicy")]
870 BioPolicy,
871 #[serde(rename = "misalignmentPolicyViolation")]
872 MisalignmentPolicyViolation,
873 #[serde(rename = "tooManyDenials")]
876 TooManyDenials,
877 #[serde(rename = "internalServerError")]
878 InternalServerError,
879 #[serde(rename = "unauthorized")]
880 Unauthorized,
881 #[serde(rename = "badRequest")]
882 BadRequest,
883 #[serde(rename = "threadRollbackFailed")]
884 ThreadRollbackFailed,
885 #[serde(rename = "sandboxError")]
886 SandboxError,
887 #[serde(rename = "httpConnectionFailed")]
888 HttpConnectionFailed {
889 #[serde(
890 rename = "httpStatusCode",
891 default,
892 skip_serializing_if = "Option::is_none"
893 )]
894 http_status_code: Option<i64>,
895 },
896 #[serde(rename = "responseStreamConnectionFailed")]
897 ResponseStreamConnectionFailed {
898 #[serde(
899 rename = "httpStatusCode",
900 default,
901 skip_serializing_if = "Option::is_none"
902 )]
903 http_status_code: Option<i64>,
904 },
905 #[serde(rename = "responseStreamDisconnected")]
906 ResponseStreamDisconnected {
907 #[serde(
908 rename = "httpStatusCode",
909 default,
910 skip_serializing_if = "Option::is_none"
911 )]
912 http_status_code: Option<i64>,
913 },
914 #[serde(rename = "responseTooManyFailedAttempts")]
915 ResponseTooManyFailedAttempts {
916 #[serde(
917 rename = "httpStatusCode",
918 default,
919 skip_serializing_if = "Option::is_none"
920 )]
921 http_status_code: Option<i64>,
922 },
923 #[serde(rename = "activeTurnNotSteerable")]
924 ActiveTurnNotSteerable {
925 #[serde(rename = "turnKind")]
926 turn_kind: NonSteerableTurnKind,
927 },
928 #[serde(
934 untagged,
935 serialize_with = "serialize_other_codex_error_info",
936 deserialize_with = "deserialize_other_codex_error_info"
937 )]
938 Other,
939}
940
941fn serialize_other_codex_error_info<S>(serializer: S) -> Result<S::Ok, S::Error>
942where
943 S: serde::Serializer,
944{
945 serializer.serialize_str("other")
946}
947
948fn deserialize_other_codex_error_info<'de, D>(deserializer: D) -> Result<(), D::Error>
949where
950 D: serde::Deserializer<'de>,
951{
952 match Value::deserialize(deserializer)? {
953 Value::String(_) | Value::Object(_) => Ok(()),
954 _ => Err(serde::de::Error::custom(
955 "expected an error string or object",
956 )),
957 }
958}
959
960#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
961#[serde(rename_all = "camelCase")]
962pub struct CollabAgentState {
963 #[serde(default, skip_serializing_if = "Option::is_none")]
964 pub message: Option<String>,
965 #[serde()]
966 pub status: CollabAgentStatus,
967}
968
969#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
970pub enum CollabAgentStatus {
971 #[serde(rename = "pendingInit")]
972 PendingInit,
973 #[serde(rename = "running")]
974 Running,
975 #[serde(rename = "interrupted")]
976 Interrupted,
977 #[serde(rename = "completed")]
978 Completed,
979 #[serde(rename = "errored")]
980 Errored,
981 #[serde(rename = "shutdown")]
982 Shutdown,
983 #[serde(rename = "notFound")]
984 NotFound,
985}
986
987#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
988pub enum CollabAgentTool {
989 #[serde(rename = "spawnAgent")]
990 SpawnAgent,
991 #[serde(rename = "sendInput")]
992 SendInput,
993 #[serde(rename = "resumeAgent")]
994 ResumeAgent,
995 #[serde(rename = "wait")]
996 Wait,
997 #[serde(rename = "closeAgent")]
998 CloseAgent,
999 #[serde(rename = "sendMessage")]
1000 SendMessage,
1001 #[serde(rename = "followupTask")]
1002 FollowupTask,
1003 #[serde(rename = "interruptAgent")]
1004 InterruptAgent,
1005 #[serde(rename = "listAgents")]
1006 ListAgents,
1007}
1008
1009#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1010pub enum CollabAgentToolCallStatus {
1011 #[serde(rename = "inProgress")]
1012 InProgress,
1013 #[serde(rename = "completed")]
1014 Completed,
1015 #[serde(rename = "failed")]
1016 Failed,
1017 #[serde(rename = "interrupted")]
1018 Interrupted,
1019}
1020
1021#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1024pub enum CyberAccessProgram {
1025 #[serde(rename = "standard")]
1026 Standard,
1027 #[serde(rename = "daybreakBlue")]
1028 DaybreakBlue,
1029 #[serde(rename = "daybreakRed")]
1030 DaybreakRed,
1031}
1032
1033#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1034#[serde(rename_all = "camelCase")]
1035pub struct CollaborationMode {
1036 #[serde()]
1037 pub mode: ModeKind,
1038 #[serde()]
1039 pub settings: Settings,
1040}
1041
1042#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1043#[serde(tag = "type", rename_all = "camelCase")]
1044pub enum CommandAction {
1045 Read {
1046 command: String,
1047 name: String,
1048 path: LegacyAppPathString,
1049 },
1050 #[serde(rename = "listFiles")]
1051 ListFiles {
1052 command: String,
1053 #[serde(default, skip_serializing_if = "Option::is_none")]
1054 path: Option<String>,
1055 },
1056 Search {
1057 command: String,
1058 #[serde(default, skip_serializing_if = "Option::is_none")]
1059 path: Option<String>,
1060 #[serde(default, skip_serializing_if = "Option::is_none")]
1061 query: Option<String>,
1062 },
1063 Unknown {
1064 command: String,
1065 },
1066}
1067
1068#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1069#[serde(rename_all = "camelCase")]
1070pub struct CommandExecOutputDeltaNotification {
1071 #[serde(rename = "capReached", default)]
1072 pub cap_reached: bool,
1073 #[serde(rename = "deltaBase64", default)]
1074 pub delta_base64: String,
1075 #[serde(rename = "processId", default)]
1076 pub process_id: String,
1077 #[serde(default)]
1078 pub stream: Value,
1079}
1080
1081#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
1082pub enum CommandExecOutputStream {
1083 #[serde(rename = "stdout")]
1084 Stdout,
1085 #[serde(rename = "stderr")]
1086 Stderr,
1087}
1088
1089#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1090#[serde(rename_all = "camelCase")]
1091pub struct CommandExecParams {
1092 #[serde(default)]
1093 pub command: Vec<String>,
1094 #[serde(default, skip_serializing_if = "Option::is_none")]
1095 pub cwd: Option<String>,
1096 #[serde(
1097 rename = "disableOutputCap",
1098 default,
1099 skip_serializing_if = "Option::is_none"
1100 )]
1101 pub disable_output_cap: Option<bool>,
1102 #[serde(
1103 rename = "disableTimeout",
1104 default,
1105 skip_serializing_if = "Option::is_none"
1106 )]
1107 pub disable_timeout: Option<bool>,
1108 #[serde(default, skip_serializing_if = "Option::is_none")]
1109 pub env: Option<std::collections::BTreeMap<String, Option<String>>>,
1110 #[serde(
1111 rename = "outputBytesCap",
1112 default,
1113 skip_serializing_if = "Option::is_none"
1114 )]
1115 pub output_bytes_cap: Option<i64>,
1116 #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
1117 pub process_id: Option<String>,
1118 #[serde(
1119 rename = "sandboxPolicy",
1120 default,
1121 skip_serializing_if = "Option::is_none"
1122 )]
1123 pub sandbox_policy: Option<SandboxPolicy>,
1124 #[serde(default, skip_serializing_if = "Option::is_none")]
1125 pub size: Option<CommandExecTerminalSize>,
1126 #[serde(
1127 rename = "streamStdin",
1128 default,
1129 skip_serializing_if = "Option::is_none"
1130 )]
1131 pub stream_stdin: Option<bool>,
1132 #[serde(
1133 rename = "streamStdoutStderr",
1134 default,
1135 skip_serializing_if = "Option::is_none"
1136 )]
1137 pub stream_stdout_stderr: Option<bool>,
1138 #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
1139 pub timeout_ms: Option<i64>,
1140 #[serde(default, skip_serializing_if = "Option::is_none")]
1141 pub tty: Option<bool>,
1142}
1143
1144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1145#[serde(rename_all = "camelCase")]
1146pub struct CommandExecResizeParams {
1147 #[serde(rename = "processId", default)]
1148 pub process_id: String,
1149 #[serde(default)]
1150 pub size: Value,
1151}
1152
1153#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1154#[serde(rename_all = "camelCase")]
1155pub struct CommandExecResizeResponse {
1156 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1157 pub extra: serde_json::Map<String, Value>,
1158}
1159
1160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1161#[serde(rename_all = "camelCase")]
1162pub struct CommandExecResponse {
1163 #[serde(rename = "exitCode", default)]
1164 pub exit_code: i64,
1165 #[serde(default)]
1166 pub stderr: String,
1167 #[serde(default)]
1168 pub stdout: String,
1169}
1170
1171#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1172#[serde(rename_all = "camelCase")]
1173pub struct CommandExecTerminalSize {
1174 #[serde(default)]
1175 pub cols: i64,
1176 #[serde(default)]
1177 pub rows: i64,
1178}
1179
1180#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1181#[serde(rename_all = "camelCase")]
1182pub struct CommandExecTerminateParams {
1183 #[serde(rename = "processId", default)]
1184 pub process_id: String,
1185}
1186
1187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1188#[serde(rename_all = "camelCase")]
1189pub struct CommandExecTerminateResponse {
1190 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1191 pub extra: serde_json::Map<String, Value>,
1192}
1193
1194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1195#[serde(rename_all = "camelCase")]
1196pub struct CommandExecWriteParams {
1197 #[serde(
1198 rename = "closeStdin",
1199 default,
1200 skip_serializing_if = "Option::is_none"
1201 )]
1202 pub close_stdin: Option<bool>,
1203 #[serde(
1204 rename = "deltaBase64",
1205 default,
1206 skip_serializing_if = "Option::is_none"
1207 )]
1208 pub delta_base64: Option<String>,
1209 #[serde(rename = "processId", default)]
1210 pub process_id: String,
1211}
1212
1213#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1214#[serde(rename_all = "camelCase")]
1215pub struct CommandExecWriteResponse {
1216 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1217 pub extra: serde_json::Map<String, Value>,
1218}
1219
1220#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1221pub enum CommandExecutionApprovalDecision {
1222 #[serde(rename = "accept")]
1223 Accept,
1224 #[serde(rename = "acceptForSession")]
1225 AcceptForSession,
1226 #[serde(rename = "acceptWithExecpolicyAmendment")]
1227 AcceptWithExecpolicyAmendment { execpolicy_amendment: Vec<String> },
1228 #[serde(rename = "applyNetworkPolicyAmendment")]
1229 ApplyNetworkPolicyAmendment {
1230 network_policy_amendment: NetworkPolicyAmendment,
1231 },
1232 #[serde(rename = "decline")]
1233 Decline,
1234 #[serde(rename = "cancel")]
1235 Cancel,
1236}
1237
1238#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1241pub enum CommandExecutionApprovalKind {
1242 #[serde(rename = "command")]
1243 Command,
1244 #[serde(rename = "humanCommand")]
1249 HumanCommand,
1250 #[serde(rename = "writeStdin")]
1251 WriteStdin,
1252}
1253
1254#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1255#[serde(rename_all = "camelCase")]
1256pub struct CommandExecutionOutputDeltaNotification {
1257 #[serde(default)]
1258 pub delta: String,
1259 #[serde(rename = "itemId", default)]
1260 pub item_id: String,
1261 #[serde(rename = "threadId", default)]
1262 pub thread_id: String,
1263 #[serde(rename = "turnId", default)]
1264 pub turn_id: String,
1265}
1266
1267#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1268#[serde(rename_all = "camelCase")]
1269pub struct CommandExecutionRequestApprovalParams {
1270 #[serde(
1271 rename = "approvalId",
1272 default,
1273 skip_serializing_if = "Option::is_none"
1274 )]
1275 pub approval_id: Option<String>,
1276 #[serde(default, skip_serializing_if = "Option::is_none")]
1277 pub command: Option<String>,
1278 #[serde(
1279 rename = "commandActions",
1280 default,
1281 skip_serializing_if = "Option::is_none"
1282 )]
1283 pub command_actions: Option<Vec<CommandAction>>,
1284 #[serde(default, skip_serializing_if = "Option::is_none")]
1285 pub cwd: Option<LegacyAppPathString>,
1286 #[serde(
1287 rename = "environmentId",
1288 default,
1289 skip_serializing_if = "Option::is_none"
1290 )]
1291 pub environment_id: Option<String>,
1292 #[serde(rename = "itemId", default)]
1293 pub item_id: String,
1294 #[serde(default, skip_serializing_if = "Option::is_none")]
1297 pub kind: Option<CommandExecutionApprovalKind>,
1298 #[serde(
1299 rename = "networkApprovalContext",
1300 default,
1301 skip_serializing_if = "Option::is_none"
1302 )]
1303 pub network_approval_context: Option<NetworkApprovalContext>,
1304 #[serde(
1305 rename = "proposedExecpolicyAmendment",
1306 default,
1307 skip_serializing_if = "Option::is_none"
1308 )]
1309 pub proposed_execpolicy_amendment: Option<Vec<String>>,
1310 #[serde(
1311 rename = "proposedNetworkPolicyAmendments",
1312 default,
1313 skip_serializing_if = "Option::is_none"
1314 )]
1315 pub proposed_network_policy_amendments: Option<Vec<NetworkPolicyAmendment>>,
1316 #[serde(default, skip_serializing_if = "Option::is_none")]
1317 pub reason: Option<String>,
1318 #[serde(rename = "startedAtMs", default)]
1319 pub started_at_ms: i64,
1320 #[serde(rename = "threadId", default)]
1321 pub thread_id: String,
1322 #[serde(rename = "turnId", default)]
1323 pub turn_id: String,
1324}
1325
1326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1327#[serde(rename_all = "camelCase")]
1328pub struct CommandExecutionRequestApprovalResponse {
1329 #[serde()]
1330 pub decision: CommandExecutionApprovalDecision,
1331}
1332
1333#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1334pub enum CommandExecutionSource {
1335 #[serde(rename = "agent")]
1336 Agent,
1337 #[serde(rename = "userShell")]
1338 UserShell,
1339 #[serde(rename = "unifiedExecStartup")]
1340 UnifiedExecStartup,
1341 #[serde(rename = "unifiedExecInteraction")]
1342 UnifiedExecInteraction,
1343}
1344
1345#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1346pub enum CommandExecutionStatus {
1347 #[serde(rename = "inProgress")]
1348 InProgress,
1349 #[serde(rename = "completed")]
1350 Completed,
1351 #[serde(rename = "failed")]
1352 Failed,
1353 #[serde(rename = "declined")]
1354 Declined,
1355}
1356
1357#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1358#[serde(rename_all = "camelCase")]
1359pub struct CommandMigration {
1360 #[serde(default)]
1361 pub name: String,
1362}
1363
1364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1365#[serde(rename_all = "camelCase")]
1366pub struct ComputerUseRequirements {
1367 #[serde(
1368 rename = "allowPersistentApproval",
1369 default,
1370 skip_serializing_if = "Option::is_none"
1371 )]
1372 pub allow_persistent_approval: Option<bool>,
1373 #[serde(
1374 rename = "defaultAppAccess",
1375 default,
1376 skip_serializing_if = "Option::is_none"
1377 )]
1378 pub default_app_access: Option<AllowDenyRequirement>,
1379 #[serde(default, skip_serializing_if = "Option::is_none")]
1380 pub macos: Option<ComputerUseMacosRequirements>,
1381 #[serde(default, skip_serializing_if = "Option::is_none")]
1382 pub windows: Option<ComputerUseWindowsRequirements>,
1383 #[serde(
1384 rename = "allowLockedComputerUse",
1385 default,
1386 skip_serializing_if = "Option::is_none"
1387 )]
1388 pub allow_locked_computer_use: Option<bool>,
1389}
1390
1391#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1392#[serde(rename_all = "snake_case")]
1393pub struct Config {
1394 #[serde(default, skip_serializing_if = "Option::is_none")]
1395 pub analytics: Option<AnalyticsConfig>,
1396 #[serde(default, skip_serializing_if = "Option::is_none")]
1397 pub browser_use: Option<BrowserUseConfig>,
1398 #[serde(default, skip_serializing_if = "Option::is_none")]
1399 pub computer_use: Option<ComputerUseConfig>,
1400 #[serde(default, skip_serializing_if = "Option::is_none")]
1401 pub approval_policy: Option<AskForApproval>,
1402 #[serde(default, skip_serializing_if = "Option::is_none")]
1403 pub approvals_reviewer: Option<ApprovalsReviewer>,
1404 #[serde(default, skip_serializing_if = "Option::is_none")]
1407 pub client_search_provider: Option<WebSearchProvider>,
1408 #[serde(default, skip_serializing_if = "Option::is_none")]
1409 pub compact_prompt: Option<String>,
1410 #[serde(default, skip_serializing_if = "Option::is_none")]
1411 pub desktop: Option<Value>,
1412 #[serde(default, skip_serializing_if = "Option::is_none")]
1413 pub developer_instructions: Option<String>,
1414 #[serde(default, skip_serializing_if = "Option::is_none")]
1415 pub forced_chatgpt_workspace_id: Option<ForcedChatgptWorkspaceIds>,
1416 #[serde(default, skip_serializing_if = "Option::is_none")]
1417 pub forced_login_method: Option<ForcedLoginMethod>,
1418 #[serde(default, skip_serializing_if = "Option::is_none")]
1419 pub instructions: Option<String>,
1420 #[serde(default, skip_serializing_if = "Option::is_none")]
1421 pub model: Option<String>,
1422 #[serde(default, skip_serializing_if = "Option::is_none")]
1423 pub model_auto_compact_token_limit: Option<i64>,
1424 #[serde(default, skip_serializing_if = "Option::is_none")]
1425 pub model_auto_compact_token_limit_scope: Option<AutoCompactTokenLimitScope>,
1426 #[serde(default, skip_serializing_if = "Option::is_none")]
1427 pub model_context_window: Option<i64>,
1428 #[serde(default, skip_serializing_if = "Option::is_none")]
1429 pub model_provider: Option<String>,
1430 #[serde(default, skip_serializing_if = "Option::is_none")]
1431 pub model_reasoning_effort: Option<ReasoningEffort>,
1432 #[serde(default, skip_serializing_if = "Option::is_none")]
1433 pub model_reasoning_summary: Option<ReasoningSummary>,
1434 #[serde(default, skip_serializing_if = "Option::is_none")]
1435 pub model_verbosity: Option<Verbosity>,
1436 #[serde(default, skip_serializing_if = "Option::is_none")]
1437 pub review_model: Option<String>,
1438 #[serde(default, skip_serializing_if = "Option::is_none")]
1439 pub sandbox_mode: Option<SandboxMode>,
1440 #[serde(default, skip_serializing_if = "Option::is_none")]
1441 pub sandbox_workspace_write: Option<SandboxWorkspaceWrite>,
1442 #[serde(default, skip_serializing_if = "Option::is_none")]
1443 pub service_tier: Option<String>,
1444 #[serde(default, skip_serializing_if = "Option::is_none")]
1445 pub tools: Option<ToolsV2>,
1446 #[serde(default, skip_serializing_if = "Option::is_none")]
1447 pub web_search: Option<WebSearchMode>,
1448 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1449 pub additional: serde_json::Map<String, Value>,
1450}
1451
1452#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1453#[serde(rename_all = "camelCase")]
1454pub struct ConfigBatchWriteParams {
1455 #[serde(default)]
1456 pub edits: Vec<ConfigEdit>,
1457 #[serde(
1458 rename = "expectedVersion",
1459 default,
1460 skip_serializing_if = "Option::is_none"
1461 )]
1462 pub expected_version: Option<String>,
1463 #[serde(rename = "filePath", default, skip_serializing_if = "Option::is_none")]
1464 pub file_path: Option<String>,
1465 #[serde(
1466 rename = "reloadUserConfig",
1467 default,
1468 skip_serializing_if = "Option::is_none"
1469 )]
1470 pub reload_user_config: Option<bool>,
1471}
1472
1473#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1474#[serde(rename_all = "camelCase")]
1475pub struct ConfigEdit {
1476 #[serde(rename = "keyPath", default)]
1477 pub key_path: String,
1478 #[serde(rename = "mergeStrategy")]
1479 pub merge_strategy: MergeStrategy,
1480 #[serde(default)]
1481 pub value: Value,
1482}
1483
1484#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1485#[serde(rename_all = "camelCase")]
1486pub struct ConfigLayer {
1487 #[serde(default)]
1488 pub config: Value,
1489 #[serde(
1490 rename = "disabledReason",
1491 default,
1492 skip_serializing_if = "Option::is_none"
1493 )]
1494 pub disabled_reason: Option<String>,
1495 #[serde()]
1496 pub name: ConfigLayerSource,
1497 #[serde(default)]
1498 pub version: String,
1499}
1500
1501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1502#[serde(rename_all = "camelCase")]
1503pub struct ConfigLayerMetadata {
1504 #[serde()]
1505 pub name: ConfigLayerSource,
1506 #[serde(default)]
1507 pub version: String,
1508}
1509
1510#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1511#[serde(tag = "type", rename_all = "camelCase")]
1512pub enum ConfigLayerSource {
1513 #[serde(rename = "packagedDefaults")]
1514 PackagedDefaults {
1515 file: Value,
1516 },
1517 Mdm {
1518 domain: String,
1519 key: String,
1520 },
1521 System {
1522 file: Value,
1523 },
1524 #[serde(rename = "enterpriseManaged")]
1525 EnterpriseManaged {
1526 id: String,
1527 name: String,
1528 },
1529 User {
1530 file: Value,
1531 #[serde(default, skip_serializing_if = "Option::is_none")]
1532 profile: Option<String>,
1533 },
1534 Project {
1535 #[serde(rename = "dotCodexFolder")]
1536 dot_codex_folder: AbsolutePathBuf,
1537 },
1538 #[serde(rename = "sessionFlags")]
1539 SessionFlags,
1540 #[serde(rename = "legacyManagedConfigTomlFromFile")]
1541 LegacyManagedConfigTomlFromFile {
1542 file: AbsolutePathBuf,
1543 },
1544 #[serde(rename = "legacyManagedConfigTomlFromMdm")]
1545 LegacyManagedConfigTomlFromMdm,
1546}
1547
1548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1549#[serde(rename_all = "camelCase")]
1550pub struct ConfigReadParams {
1551 #[serde(default, skip_serializing_if = "Option::is_none")]
1552 pub cwd: Option<String>,
1553 #[serde(
1554 rename = "includeLayers",
1555 default,
1556 skip_serializing_if = "Option::is_none"
1557 )]
1558 pub include_layers: Option<bool>,
1559}
1560
1561#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1562#[serde(rename_all = "camelCase")]
1563pub struct ConfigReadResponse {
1564 #[serde()]
1565 pub config: Config,
1566 #[serde(default, skip_serializing_if = "Option::is_none")]
1567 pub layers: Option<Vec<ConfigLayer>>,
1568 #[serde(default)]
1569 pub origins: std::collections::BTreeMap<String, ConfigLayerMetadata>,
1570}
1571
1572#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1573#[serde(rename_all = "camelCase")]
1574pub struct ConfigRequirements {
1575 #[serde(
1576 rename = "allowBrowserAndComputerUse",
1577 default,
1578 skip_serializing_if = "Option::is_none"
1579 )]
1580 pub allow_browser_and_computer_use: Option<bool>,
1581 #[serde(
1582 rename = "additionalDeveloperInstructions",
1583 default,
1584 skip_serializing_if = "Option::is_none"
1585 )]
1586 pub additional_developer_instructions: Option<String>,
1587 #[serde(
1588 rename = "inAppBrowser",
1589 default,
1590 skip_serializing_if = "Option::is_none"
1591 )]
1592 pub in_app_browser: Option<InAppBrowserRequirements>,
1593 #[serde(
1594 rename = "chatgptBaseUrl",
1595 default,
1596 skip_serializing_if = "Option::is_none"
1597 )]
1598 pub chatgpt_base_url: Option<String>,
1599 #[serde(
1600 rename = "cliAuthCredentialsStore",
1601 default,
1602 skip_serializing_if = "Option::is_none"
1603 )]
1604 pub cli_auth_credentials_store: Option<CliAuthCredentialsStoreMode>,
1605 #[serde(
1606 rename = "allowAppshots",
1607 default,
1608 skip_serializing_if = "Option::is_none"
1609 )]
1610 pub allow_appshots: Option<bool>,
1611 #[serde(
1612 rename = "allowLoginShell",
1613 default,
1614 skip_serializing_if = "Option::is_none"
1615 )]
1616 pub allow_login_shell: Option<bool>,
1617 #[serde(
1618 rename = "allowManagedHooksOnly",
1619 default,
1620 skip_serializing_if = "Option::is_none"
1621 )]
1622 pub allow_managed_hooks_only: Option<bool>,
1623 #[serde(
1624 rename = "allowRemoteControl",
1625 default,
1626 skip_serializing_if = "Option::is_none"
1627 )]
1628 pub allow_remote_control: Option<bool>,
1629 #[serde(
1630 rename = "allowedApprovalPolicies",
1631 default,
1632 skip_serializing_if = "Option::is_none"
1633 )]
1634 pub allowed_approval_policies: Option<Vec<AskForApproval>>,
1635 #[serde(
1636 rename = "allowedPermissionProfiles",
1637 default,
1638 skip_serializing_if = "Option::is_none"
1639 )]
1640 pub allowed_permission_profiles: Option<std::collections::BTreeMap<String, bool>>,
1641 #[serde(
1642 rename = "allowedSandboxModes",
1643 default,
1644 skip_serializing_if = "Option::is_none"
1645 )]
1646 pub allowed_sandbox_modes: Option<Vec<SandboxMode>>,
1647 #[serde(
1648 rename = "allowedWebSearchModes",
1649 default,
1650 skip_serializing_if = "Option::is_none"
1651 )]
1652 pub allowed_web_search_modes: Option<Vec<WebSearchMode>>,
1653 #[serde(
1654 rename = "allowedWindowsSandboxImplementations",
1655 default,
1656 skip_serializing_if = "Option::is_none"
1657 )]
1658 pub allowed_windows_sandbox_implementations: Option<Vec<WindowsSandboxImplementation>>,
1659 #[serde(
1663 rename = "allowedLoginMethods",
1664 default,
1665 skip_serializing_if = "Option::is_none"
1666 )]
1667 pub allowed_login_methods: Option<Vec<ForcedLoginMethod>>,
1668 #[serde(
1669 rename = "autoReview",
1670 default,
1671 skip_serializing_if = "Option::is_none"
1672 )]
1673 pub auto_review: Option<AutoReviewRequirements>,
1674 #[serde(
1675 rename = "browserUse",
1676 default,
1677 skip_serializing_if = "Option::is_none"
1678 )]
1679 pub browser_use: Option<BrowserUseRequirements>,
1680 #[serde(
1681 rename = "checkForUpdateOnStartup",
1682 default,
1683 skip_serializing_if = "Option::is_none"
1684 )]
1685 pub check_for_update_on_startup: Option<bool>,
1686 #[serde(
1687 rename = "computerUse",
1688 default,
1689 skip_serializing_if = "Option::is_none"
1690 )]
1691 pub computer_use: Option<ComputerUseRequirements>,
1692 #[serde(
1693 rename = "defaultPermissions",
1694 default,
1695 skip_serializing_if = "Option::is_none"
1696 )]
1697 pub default_permissions: Option<String>,
1698 #[serde(
1699 rename = "enforceResidency",
1700 default,
1701 skip_serializing_if = "Option::is_none"
1702 )]
1703 pub enforce_residency: Option<ResidencyRequirement>,
1704 #[serde(
1705 rename = "featureRequirements",
1706 default,
1707 skip_serializing_if = "Option::is_none"
1708 )]
1709 pub feature_requirements: Option<std::collections::BTreeMap<String, bool>>,
1710 #[serde(default, skip_serializing_if = "Option::is_none")]
1711 pub feedback: Option<FeedbackRequirements>,
1712 #[serde(rename = "logDir", default, skip_serializing_if = "Option::is_none")]
1713 pub log_dir: Option<String>,
1714 #[serde(
1715 rename = "modelCatalogJson",
1716 default,
1717 skip_serializing_if = "Option::is_none"
1718 )]
1719 pub model_catalog_json: Option<String>,
1720 #[serde(
1722 rename = "modelProvider",
1723 default,
1724 skip_serializing_if = "Option::is_none"
1725 )]
1726 pub model_provider: Option<String>,
1727 #[serde(
1729 rename = "modelProviders",
1730 default,
1731 skip_serializing_if = "Option::is_none"
1732 )]
1733 pub model_providers: Option<serde_json::Map<String, Value>>,
1734 #[serde(default, skip_serializing_if = "Option::is_none")]
1735 pub models: Option<ModelsRequirements>,
1736 #[serde(default, skip_serializing_if = "Option::is_none")]
1737 pub otel: Option<OtelRequirements>,
1738 #[serde(
1739 rename = "sqliteHome",
1740 default,
1741 skip_serializing_if = "Option::is_none"
1742 )]
1743 pub sqlite_home: Option<String>,
1744}
1745
1746#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1747#[serde(rename_all = "camelCase")]
1748pub struct ConfigRequirementsReadResponse {
1749 #[serde(default, skip_serializing_if = "Option::is_none")]
1750 pub requirements: Option<ConfigRequirements>,
1751 #[serde(
1754 rename = "supportsIndependentSpeedModes",
1755 default,
1756 skip_serializing_if = "Option::is_none"
1757 )]
1758 pub supports_independent_speed_modes: Option<bool>,
1759}
1760
1761#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1762#[serde(rename_all = "camelCase")]
1763pub struct ConfigValueWriteParams {
1764 #[serde(
1765 rename = "expectedVersion",
1766 default,
1767 skip_serializing_if = "Option::is_none"
1768 )]
1769 pub expected_version: Option<String>,
1770 #[serde(rename = "filePath", default, skip_serializing_if = "Option::is_none")]
1771 pub file_path: Option<String>,
1772 #[serde(rename = "keyPath", default)]
1773 pub key_path: String,
1774 #[serde(rename = "mergeStrategy")]
1775 pub merge_strategy: MergeStrategy,
1776 #[serde(default)]
1777 pub value: Value,
1778}
1779
1780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1781#[serde(rename_all = "camelCase")]
1782pub struct ConfigWarningNotification {
1783 #[serde(default, skip_serializing_if = "Option::is_none")]
1784 pub details: Option<String>,
1785 #[serde(default, skip_serializing_if = "Option::is_none")]
1786 pub path: Option<String>,
1787 #[serde(default, skip_serializing_if = "Option::is_none")]
1788 pub range: Option<TextRange>,
1789 #[serde(default)]
1790 pub summary: String,
1791}
1792
1793#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1794#[serde(rename_all = "camelCase")]
1795pub struct ConfigWriteResponse {
1796 #[serde(rename = "filePath", default)]
1797 pub file_path: Value,
1798 #[serde(
1799 rename = "overriddenMetadata",
1800 default,
1801 skip_serializing_if = "Option::is_none"
1802 )]
1803 pub overridden_metadata: Option<OverriddenMetadata>,
1804 #[serde()]
1805 pub status: WriteStatus,
1806 #[serde(default)]
1807 pub version: String,
1808}
1809
1810#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1811#[serde(rename_all = "camelCase")]
1812pub struct ConnectorMetadata {
1813 #[serde(default, skip_serializing_if = "Option::is_none")]
1814 pub description: Option<String>,
1815 #[serde(
1816 rename = "distributionChannel",
1817 default,
1818 skip_serializing_if = "Option::is_none"
1819 )]
1820 pub distribution_channel: Option<String>,
1821 #[serde(rename = "iconUrl", default, skip_serializing_if = "Option::is_none")]
1822 pub icon_url: Option<String>,
1823 #[serde(
1824 rename = "iconUrlDark",
1825 default,
1826 skip_serializing_if = "Option::is_none"
1827 )]
1828 pub icon_url_dark: Option<String>,
1829 #[serde(default)]
1830 pub id: String,
1831 #[serde(
1832 rename = "installUrl",
1833 default,
1834 skip_serializing_if = "Option::is_none"
1835 )]
1836 pub install_url: Option<String>,
1837 #[serde(default)]
1838 pub name: String,
1839 #[serde(
1840 rename = "pluginDisplayNames",
1841 default,
1842 skip_serializing_if = "Option::is_none"
1843 )]
1844 pub plugin_display_names: Option<Vec<String>>,
1845 #[serde(
1846 rename = "toolSummaries",
1847 default,
1848 skip_serializing_if = "Option::is_none"
1849 )]
1850 pub tool_summaries: Option<Vec<AppToolSummary>>,
1851}
1852
1853#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
1854pub enum ConsumeAccountRateLimitResetCreditOutcome {
1855 #[serde(rename = "reset")]
1856 Reset,
1857 #[serde(rename = "nothingToReset")]
1858 NothingToReset,
1859 #[serde(rename = "noCredit")]
1860 NoCredit,
1861 #[serde(rename = "alreadyRedeemed")]
1862 AlreadyRedeemed,
1863}
1864
1865#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1866#[serde(rename_all = "camelCase")]
1867pub struct ConsumeAccountRateLimitResetCreditParams {
1868 #[serde(rename = "creditId", default, skip_serializing_if = "Option::is_none")]
1869 pub credit_id: Option<String>,
1870 #[serde(rename = "idempotencyKey", default)]
1871 pub idempotency_key: String,
1872}
1873
1874#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1875#[serde(rename_all = "camelCase")]
1876pub struct ConsumeAccountRateLimitResetCreditResponse {
1877 #[serde()]
1878 pub outcome: ConsumeAccountRateLimitResetCreditOutcome,
1879}
1880
1881#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1882#[serde(rename_all = "camelCase")]
1883pub struct ContextCompactedNotification {
1884 #[serde(rename = "threadId", default)]
1885 pub thread_id: String,
1886 #[serde(rename = "turnId", default)]
1887 pub turn_id: String,
1888}
1889
1890#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1891#[serde(rename_all = "camelCase")]
1892pub struct CreditsSnapshot {
1893 #[serde(default, skip_serializing_if = "Option::is_none")]
1894 pub balance: Option<String>,
1895 #[serde(rename = "hasCredits", default)]
1896 pub has_credits: bool,
1897 #[serde(default)]
1898 pub unlimited: bool,
1899}
1900
1901#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1902#[serde(rename_all = "camelCase")]
1903pub struct DeprecationNoticeNotification {
1904 #[serde(default, skip_serializing_if = "Option::is_none")]
1905 pub details: Option<String>,
1906 #[serde(default)]
1907 pub summary: String,
1908}
1909
1910#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1911pub enum DesktopOnboardingEntrypoint {
1912 #[serde(rename = "life_sciences")]
1913 Life_sciences,
1914}
1915
1916#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1917#[serde(tag = "type", rename_all = "camelCase")]
1918pub enum DynamicToolCallOutputContentItem {
1919 #[serde(rename = "inputText")]
1920 InputText { text: String },
1921 #[serde(rename = "inputImage")]
1922 InputImage {
1923 #[serde(rename = "imageUrl")]
1924 image_url: String,
1925 },
1926 #[serde(rename = "inputAudio")]
1927 InputAudio {
1928 #[serde(rename = "audioUrl")]
1929 audio_url: String,
1930 },
1931}
1932
1933#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1934#[serde(rename_all = "camelCase")]
1935pub struct DynamicToolCallParams {
1936 #[serde(default)]
1937 pub arguments: Value,
1938 #[serde(rename = "callId", default)]
1939 pub call_id: String,
1940 #[serde(default, skip_serializing_if = "Option::is_none")]
1941 pub namespace: Option<String>,
1942 #[serde(rename = "threadId", default)]
1943 pub thread_id: String,
1944 #[serde(default)]
1945 pub tool: String,
1946 #[serde(rename = "turnId", default)]
1947 pub turn_id: String,
1948}
1949
1950#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1951#[serde(rename_all = "camelCase")]
1952pub struct DynamicToolCallResponse {
1953 #[serde(rename = "contentItems", default)]
1954 pub content_items: Vec<DynamicToolCallOutputContentItem>,
1955 #[serde(default)]
1956 pub success: bool,
1957}
1958
1959#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1960pub enum DynamicToolCallStatus {
1961 #[serde(rename = "inProgress")]
1962 InProgress,
1963 #[serde(rename = "completed")]
1964 Completed,
1965 #[serde(rename = "failed")]
1966 Failed,
1967}
1968
1969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1970#[serde(rename_all = "camelCase")]
1971pub struct EnvironmentConnectionNotification {
1972 #[serde(rename = "environmentId", default)]
1973 pub environment_id: String,
1974 #[serde(rename = "threadId", default)]
1975 pub thread_id: String,
1976}
1977
1978#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1979#[serde(rename_all = "camelCase")]
1980pub struct ErrorNotification {
1981 #[serde()]
1982 pub error: TurnError,
1983 #[serde(rename = "threadId", default)]
1984 pub thread_id: String,
1985 #[serde(rename = "turnId", default)]
1986 pub turn_id: String,
1987 #[serde(rename = "willRetry", default)]
1988 pub will_retry: bool,
1989}
1990
1991#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1992#[serde(rename_all = "camelCase")]
1993pub struct ExecCommandApprovalParams {
1994 #[serde(
1995 rename = "approvalId",
1996 default,
1997 skip_serializing_if = "Option::is_none"
1998 )]
1999 pub approval_id: Option<String>,
2000 #[serde(rename = "callId", default)]
2001 pub call_id: String,
2002 #[serde(default)]
2003 pub command: Vec<String>,
2004 #[serde(rename = "conversationId")]
2005 pub conversation_id: ThreadId,
2006 #[serde(default)]
2007 pub cwd: String,
2008 #[serde(rename = "parsedCmd", default)]
2009 pub parsed_cmd: Vec<ParsedCommand>,
2010 #[serde(default, skip_serializing_if = "Option::is_none")]
2011 pub reason: Option<String>,
2012}
2013
2014#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2015#[serde(rename_all = "camelCase")]
2016pub struct ExecCommandApprovalResponse {
2017 #[serde()]
2018 pub decision: ReviewDecision,
2019}
2020
2021#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2022#[serde(rename_all = "camelCase")]
2023pub struct ExperimentalFeature {
2024 #[serde(default, skip_serializing_if = "Option::is_none")]
2025 pub announcement: Option<String>,
2026 #[serde(rename = "defaultEnabled", default)]
2027 pub default_enabled: bool,
2028 #[serde(default, skip_serializing_if = "Option::is_none")]
2029 pub description: Option<String>,
2030 #[serde(
2031 rename = "displayName",
2032 default,
2033 skip_serializing_if = "Option::is_none"
2034 )]
2035 pub display_name: Option<String>,
2036 #[serde(default)]
2037 pub enabled: bool,
2038 #[serde(default)]
2039 pub name: String,
2040 #[serde(default)]
2041 pub stage: Value,
2042}
2043
2044#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2045#[serde(rename_all = "camelCase")]
2046pub struct ExperimentalFeatureEnablementSetParams {
2047 #[serde(default)]
2048 pub enablement: std::collections::BTreeMap<String, bool>,
2049}
2050
2051#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2052#[serde(rename_all = "camelCase")]
2053pub struct ExperimentalFeatureEnablementSetResponse {
2054 #[serde(default)]
2055 pub enablement: std::collections::BTreeMap<String, bool>,
2056}
2057
2058#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2059#[serde(rename_all = "camelCase")]
2060pub struct ExperimentalFeatureListParams {
2061 #[serde(default, skip_serializing_if = "Option::is_none")]
2062 pub cursor: Option<String>,
2063 #[serde(default, skip_serializing_if = "Option::is_none")]
2064 pub limit: Option<i64>,
2065 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
2066 pub thread_id: Option<String>,
2067}
2068
2069#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2070#[serde(rename_all = "camelCase")]
2071pub struct ExperimentalFeatureListResponse {
2072 #[serde(default)]
2073 pub data: Vec<ExperimentalFeature>,
2074 #[serde(
2075 rename = "nextCursor",
2076 default,
2077 skip_serializing_if = "Option::is_none"
2078 )]
2079 pub next_cursor: Option<String>,
2080}
2081
2082#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
2083pub enum ExperimentalFeatureStage {
2084 #[serde(rename = "beta")]
2085 Beta,
2086 #[serde(rename = "underDevelopment")]
2087 UnderDevelopment,
2088 #[serde(rename = "stable")]
2089 Stable,
2090 #[serde(rename = "deprecated")]
2091 Deprecated,
2092 #[serde(rename = "removed")]
2093 Removed,
2094}
2095
2096#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2097#[serde(rename_all = "camelCase")]
2098pub struct ExternalAgentConfigDetectParams {
2099 #[serde(default, skip_serializing_if = "Option::is_none")]
2100 pub cwds: Option<Vec<String>>,
2101 #[serde(
2102 rename = "includeHome",
2103 default,
2104 skip_serializing_if = "Option::is_none"
2105 )]
2106 pub include_home: Option<bool>,
2107 #[serde(
2108 rename = "maxSessionAgeDays",
2109 default,
2110 skip_serializing_if = "Option::is_none"
2111 )]
2112 pub max_session_age_days: Option<i64>,
2113 #[serde(
2114 rename = "maxSessions",
2115 default,
2116 skip_serializing_if = "Option::is_none"
2117 )]
2118 pub max_sessions: Option<i64>,
2119 #[serde(
2120 rename = "migrationSource",
2121 default,
2122 skip_serializing_if = "Option::is_none"
2123 )]
2124 pub migration_source: Option<String>,
2125 #[serde(default, skip_serializing_if = "Option::is_none")]
2126 pub source: Option<String>,
2127}
2128
2129#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2130#[serde(rename_all = "camelCase")]
2131pub struct ExternalAgentConfigDetectResponse {
2132 #[serde(default, skip_serializing_if = "Option::is_none")]
2133 pub connectors: Option<Vec<ExternalAgentDetectedConnectorCandidate>>,
2134 #[serde(default)]
2135 pub items: Vec<ExternalAgentConfigMigrationItem>,
2136}
2137
2138#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2139#[serde(rename_all = "camelCase")]
2140pub struct ExternalAgentConfigImportCompletedNotification {
2141 #[serde(rename = "importId", default)]
2142 pub import_id: String,
2143 #[serde(rename = "itemTypeResults", default)]
2144 pub item_type_results: Vec<ExternalAgentConfigImportTypeResult>,
2145}
2146
2147#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2148#[serde(rename_all = "camelCase")]
2149pub struct ExternalAgentConfigImportHistoriesReadResponse {
2150 #[serde(default)]
2151 pub connectors: Vec<ExternalAgentImportedConnectorCandidate>,
2152 #[serde(default)]
2153 pub data: Vec<ExternalAgentConfigImportHistory>,
2154}
2155
2156#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2157#[serde(rename_all = "camelCase")]
2158pub struct ExternalAgentConfigImportHistory {
2159 #[serde(rename = "completedAtMs", default)]
2160 pub completed_at_ms: i64,
2161 #[serde(default)]
2162 pub failures: Vec<ExternalAgentConfigImportItemTypeFailure>,
2163 #[serde(rename = "importId", default)]
2164 pub import_id: String,
2165 #[serde(
2166 rename = "providerId",
2167 default,
2168 skip_serializing_if = "Option::is_none"
2169 )]
2170 pub provider_id: Option<String>,
2171 #[serde(default)]
2172 pub successes: Vec<ExternalAgentConfigImportItemTypeSuccess>,
2173}
2174
2175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2176#[serde(rename_all = "camelCase")]
2177pub struct ExternalAgentConfigImportHistoryRecordParams {
2178 #[serde(rename = "itemTypeResults", default)]
2179 pub item_type_results: Vec<ExternalAgentConfigImportHistoryRecordTypeResultParams>,
2180 #[serde(rename = "providerId", default)]
2181 pub provider_id: String,
2182}
2183
2184#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2185#[serde(rename_all = "camelCase")]
2186pub struct ExternalAgentConfigImportHistoryRecordResponse {
2187 #[serde(rename = "importId", default)]
2188 pub import_id: String,
2189}
2190
2191#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2192#[serde(rename_all = "camelCase")]
2193pub struct ExternalAgentConfigImportHistoryRecordSuccessParams {
2194 #[serde(default, skip_serializing_if = "Option::is_none")]
2195 pub cwd: Option<String>,
2196 #[serde(rename = "itemType")]
2197 pub item_type: ExternalAgentConfigMigrationItemType,
2198 #[serde(default, skip_serializing_if = "Option::is_none")]
2199 pub source: Option<String>,
2200 #[serde(default, skip_serializing_if = "Option::is_none")]
2201 pub target: Option<String>,
2202 #[serde(default, skip_serializing_if = "Option::is_none")]
2203 pub title: Option<String>,
2204}
2205
2206#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2207#[serde(rename_all = "camelCase")]
2208pub struct ExternalAgentConfigImportHistoryRecordTypeResultParams {
2209 #[serde(default)]
2210 pub failures: Vec<ExternalAgentConfigImportItemTypeFailure>,
2211 #[serde(rename = "itemType")]
2212 pub item_type: ExternalAgentConfigMigrationItemType,
2213 #[serde(default)]
2214 pub successes: Vec<ExternalAgentConfigImportHistoryRecordSuccessParams>,
2215}
2216
2217#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2218#[serde(rename_all = "camelCase")]
2219pub struct ExternalAgentConfigImportItemTypeFailure {
2220 #[serde(default, skip_serializing_if = "Option::is_none")]
2221 pub cwd: Option<String>,
2222 #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
2223 pub error_type: Option<String>,
2224 #[serde(rename = "failureStage", default)]
2225 pub failure_stage: String,
2226 #[serde(rename = "itemType")]
2227 pub item_type: ExternalAgentConfigMigrationItemType,
2228 #[serde(default)]
2229 pub message: String,
2230 #[serde(default, skip_serializing_if = "Option::is_none")]
2231 pub source: Option<String>,
2232 #[serde(
2233 rename = "subErrorType",
2234 default,
2235 skip_serializing_if = "Option::is_none"
2236 )]
2237 pub sub_error_type: Option<String>,
2238}
2239
2240#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2241#[serde(rename_all = "camelCase")]
2242pub struct ExternalAgentConfigImportItemTypeSuccess {
2243 #[serde(default, skip_serializing_if = "Option::is_none")]
2244 pub cwd: Option<String>,
2245 #[serde(rename = "itemType")]
2246 pub item_type: ExternalAgentConfigMigrationItemType,
2247 #[serde(default, skip_serializing_if = "Option::is_none")]
2248 pub source: Option<String>,
2249 #[serde(default, skip_serializing_if = "Option::is_none")]
2250 pub target: Option<String>,
2251 #[serde(default, skip_serializing_if = "Option::is_none")]
2252 pub title: Option<String>,
2253}
2254
2255#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2256#[serde(rename_all = "camelCase")]
2257pub struct ExternalAgentConfigImportParams {
2258 #[serde(rename = "migrationItems", default)]
2259 pub migration_items: Vec<ExternalAgentConfigMigrationItem>,
2260 #[serde(
2261 rename = "migrationSource",
2262 default,
2263 skip_serializing_if = "Option::is_none"
2264 )]
2265 pub migration_source: Option<String>,
2266 #[serde(
2267 rename = "providerId",
2268 default,
2269 skip_serializing_if = "Option::is_none"
2270 )]
2271 pub provider_id: Option<String>,
2272 #[serde(default, skip_serializing_if = "Option::is_none")]
2273 pub source: Option<String>,
2274}
2275
2276#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2277#[serde(rename_all = "camelCase")]
2278pub struct ExternalAgentConfigImportProgressNotification {
2279 #[serde(rename = "importId", default)]
2280 pub import_id: String,
2281 #[serde(rename = "itemTypeResults", default)]
2282 pub item_type_results: Vec<ExternalAgentConfigImportTypeResult>,
2283}
2284
2285#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2286#[serde(rename_all = "camelCase")]
2287pub struct ExternalAgentConfigImportResponse {
2288 #[serde(rename = "importId", default)]
2289 pub import_id: String,
2290}
2291
2292#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2293#[serde(rename_all = "camelCase")]
2294pub struct ExternalAgentConfigImportTypeResult {
2295 #[serde(default)]
2296 pub failures: Vec<ExternalAgentConfigImportItemTypeFailure>,
2297 #[serde(rename = "itemType")]
2298 pub item_type: ExternalAgentConfigMigrationItemType,
2299 #[serde(default)]
2300 pub successes: Vec<ExternalAgentConfigImportItemTypeSuccess>,
2301}
2302
2303#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2304#[serde(rename_all = "camelCase")]
2305pub struct ExternalAgentConfigMigrationItem {
2306 #[serde(default, skip_serializing_if = "Option::is_none")]
2307 pub cwd: Option<String>,
2308 #[serde(default)]
2309 pub description: String,
2310 #[serde(default, skip_serializing_if = "Option::is_none")]
2311 pub details: Option<MigrationDetails>,
2312 #[serde(rename = "itemType")]
2313 pub item_type: ExternalAgentConfigMigrationItemType,
2314}
2315
2316#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2317pub enum ExternalAgentConfigMigrationItemType {
2318 #[serde(rename = "AGENTS_MD")]
2319 AGENTS_MD,
2320 #[serde(rename = "CONFIG")]
2321 CONFIG,
2322 #[serde(rename = "SKILLS")]
2323 SKILLS,
2324 #[serde(rename = "PLUGINS")]
2325 PLUGINS,
2326 #[serde(rename = "MCP_SERVER_CONFIG")]
2327 MCP_SERVER_CONFIG,
2328 #[serde(rename = "SUBAGENTS")]
2329 SUBAGENTS,
2330 #[serde(rename = "HOOKS")]
2331 HOOKS,
2332 #[serde(rename = "COMMANDS")]
2333 COMMANDS,
2334 #[serde(rename = "MEMORY")]
2335 MEMORY,
2336 #[serde(rename = "SESSIONS")]
2337 SESSIONS,
2338}
2339
2340#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2341#[serde(rename_all = "camelCase")]
2342pub struct ExternalAgentDetectedConnectorCandidate {
2343 #[serde(default)]
2344 pub name: String,
2345 #[serde(rename = "sessionCount", default)]
2346 pub session_count: i64,
2347 #[serde()]
2348 pub source: ExternalAgentDetectedConnectorSource,
2349}
2350
2351#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2352pub enum ExternalAgentDetectedConnectorSource {
2353 #[serde(rename = "remoteMcpServersConfig")]
2354 RemoteMcpServersConfig,
2355 #[serde(rename = "sessionToolUse")]
2356 SessionToolUse,
2357}
2358
2359#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2360#[serde(rename_all = "camelCase")]
2361pub struct ExternalAgentImportedConnectorCandidate {
2362 #[serde(default)]
2363 pub name: String,
2364 #[serde(rename = "sessionCount", default)]
2365 pub session_count: i64,
2366 #[serde()]
2367 pub source: ExternalAgentImportedConnectorSource,
2368}
2369
2370#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2371pub enum ExternalAgentImportedConnectorSource {
2372 #[serde(rename = "remoteMcpServersConfig")]
2373 RemoteMcpServersConfig,
2374}
2375
2376#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2377#[serde(rename_all = "camelCase")]
2378pub struct FeedbackRequirements {
2379 #[serde(default, skip_serializing_if = "Option::is_none")]
2380 pub enabled: Option<bool>,
2381}
2382
2383#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2386#[serde(rename_all = "camelCase")]
2387pub struct FeedbackSaveParams {
2388 #[serde(flatten)]
2389 pub feedback: FeedbackUploadParams,
2390 #[serde(rename = "savePath")]
2393 pub save_path: LegacyAppPathString,
2394}
2395
2396#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2397#[serde(rename_all = "camelCase")]
2398pub struct FeedbackSaveResponse {
2399 #[serde(rename = "savedPath")]
2400 pub saved_path: LegacyAppPathString,
2401 #[serde(rename = "threadId", default)]
2402 pub thread_id: String,
2403 #[serde(
2406 rename = "promptHash",
2407 default,
2408 skip_serializing_if = "Option::is_none"
2409 )]
2410 pub prompt_hash: Option<String>,
2411}
2412
2413#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2414#[serde(rename_all = "camelCase")]
2415pub struct FeedbackUploadParams {
2416 #[serde(default)]
2417 pub classification: String,
2418 #[serde(
2419 rename = "extraLogFiles",
2420 default,
2421 skip_serializing_if = "Option::is_none"
2422 )]
2423 pub extra_log_files: Option<Vec<String>>,
2424 #[serde(
2425 rename = "includeLogs",
2426 default,
2427 skip_serializing_if = "Option::is_none"
2428 )]
2429 pub include_logs: Option<bool>,
2430 #[serde(default, skip_serializing_if = "Option::is_none")]
2431 pub reason: Option<String>,
2432 #[serde(default, skip_serializing_if = "Option::is_none")]
2433 pub tags: Option<std::collections::BTreeMap<String, String>>,
2434 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
2435 pub thread_id: Option<String>,
2436}
2437
2438#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2439#[serde(rename_all = "camelCase")]
2440pub struct FeedbackUploadResponse {
2441 #[serde(rename = "threadId", default)]
2442 pub thread_id: String,
2443 #[serde(
2447 rename = "promptHash",
2448 default,
2449 skip_serializing_if = "Option::is_none"
2450 )]
2451 pub prompt_hash: Option<String>,
2452}
2453
2454#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2455#[serde(tag = "type", rename_all = "camelCase")]
2456pub enum FileChange {
2457 Add {
2458 content: String,
2459 },
2460 Delete {
2461 content: String,
2462 },
2463 Update {
2464 #[serde(default, skip_serializing_if = "Option::is_none")]
2465 move_path: Option<String>,
2466 unified_diff: String,
2467 },
2468}
2469
2470#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
2471pub enum FileChangeApprovalDecision {
2472 #[serde(rename = "accept")]
2473 Accept,
2474 #[serde(rename = "acceptForSession")]
2475 AcceptForSession,
2476 #[serde(rename = "decline")]
2477 Decline,
2478 #[serde(rename = "cancel")]
2479 Cancel,
2480}
2481
2482#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2483#[serde(rename_all = "camelCase")]
2484pub struct FileChangeOutputDeltaNotification {
2485 #[serde(default)]
2486 pub delta: String,
2487 #[serde(rename = "itemId", default)]
2488 pub item_id: String,
2489 #[serde(rename = "threadId", default)]
2490 pub thread_id: String,
2491 #[serde(rename = "turnId", default)]
2492 pub turn_id: String,
2493}
2494
2495#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2496#[serde(rename_all = "camelCase")]
2497pub struct FileChangePatchUpdatedNotification {
2498 #[serde(default)]
2499 pub changes: Vec<FileUpdateChange>,
2500 #[serde(rename = "itemId", default)]
2501 pub item_id: String,
2502 #[serde(rename = "threadId", default)]
2503 pub thread_id: String,
2504 #[serde(rename = "turnId", default)]
2505 pub turn_id: String,
2506}
2507
2508#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2509#[serde(rename_all = "camelCase")]
2510pub struct FileChangeRequestApprovalParams {
2511 #[serde(rename = "grantRoot", default, skip_serializing_if = "Option::is_none")]
2512 pub grant_root: Option<String>,
2513 #[serde(rename = "itemId", default)]
2514 pub item_id: String,
2515 #[serde(default, skip_serializing_if = "Option::is_none")]
2516 pub reason: Option<String>,
2517 #[serde(rename = "startedAtMs", default)]
2518 pub started_at_ms: i64,
2519 #[serde(rename = "threadId", default)]
2520 pub thread_id: String,
2521 #[serde(rename = "turnId", default)]
2522 pub turn_id: String,
2523}
2524
2525#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2526#[serde(rename_all = "camelCase")]
2527pub struct FileChangeRequestApprovalResponse {
2528 #[serde()]
2529 pub decision: FileChangeApprovalDecision,
2530}
2531
2532#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2533pub enum FileSystemAccessMode {
2534 #[serde(rename = "read")]
2535 Read,
2536 #[serde(rename = "write")]
2537 Write,
2538 #[serde(rename = "deny")]
2539 Deny,
2540}
2541
2542#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2543#[serde(tag = "type", rename_all = "camelCase")]
2544pub enum FileSystemPath {
2545 Path { path: LegacyAppPathString },
2546 Glob_pattern { pattern: String },
2547 Special { value: FileSystemSpecialPath },
2548}
2549
2550#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2551#[serde(rename_all = "camelCase")]
2552pub struct FileSystemSandboxEntry {
2553 #[serde()]
2554 pub access: FileSystemAccessMode,
2555 #[serde()]
2556 pub path: FileSystemPath,
2557}
2558
2559#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2560#[serde(tag = "kind", rename_all = "camelCase")]
2561pub enum FileSystemSpecialPath {
2562 Root,
2563 Minimal,
2564 ProjectRoots {
2565 #[serde(default, skip_serializing_if = "Option::is_none")]
2566 subpath: Option<LegacyAppPathString>,
2567 },
2568 Tmpdir,
2569 SlashTmp,
2570 Unknown {
2571 path: String,
2572 #[serde(default, skip_serializing_if = "Option::is_none")]
2573 subpath: Option<LegacyAppPathString>,
2574 },
2575}
2576
2577#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2578#[serde(rename_all = "camelCase")]
2579pub struct FileUpdateChange {
2580 #[serde(default)]
2581 pub diff: String,
2582 #[serde()]
2583 pub kind: PatchChangeKind,
2584 #[serde(default)]
2585 pub path: String,
2586}
2587
2588#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2589#[serde(untagged)]
2590pub enum ForcedChatgptWorkspaceIds {
2591 Variant0(String),
2592 Variant1(Vec<String>),
2593}
2594
2595#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2596pub enum ForcedLoginMethod {
2597 #[serde(rename = "chatgpt")]
2598 Chatgpt,
2599 #[serde(rename = "api")]
2600 Api,
2601}
2602
2603#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2604#[serde(rename_all = "camelCase")]
2605pub struct FsChangedNotification {
2606 #[serde(rename = "changedPaths", default)]
2607 pub changed_paths: Vec<AbsolutePathBuf>,
2608 #[serde(rename = "watchId", default)]
2609 pub watch_id: String,
2610}
2611
2612#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2613#[serde(rename_all = "camelCase")]
2614pub struct FsCopyParams {
2615 #[serde(rename = "destinationPath", default)]
2616 pub destination_path: Value,
2617 #[serde(default, skip_serializing_if = "Option::is_none")]
2618 pub recursive: Option<bool>,
2619 #[serde(rename = "sourcePath", default)]
2620 pub source_path: Value,
2621}
2622
2623#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2624#[serde(rename_all = "camelCase")]
2625pub struct FsCopyResponse {
2626 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2627 pub extra: serde_json::Map<String, Value>,
2628}
2629
2630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2631#[serde(rename_all = "camelCase")]
2632pub struct FsCreateDirectoryParams {
2633 #[serde(default)]
2634 pub path: Value,
2635 #[serde(default, skip_serializing_if = "Option::is_none")]
2636 pub recursive: Option<bool>,
2637}
2638
2639#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2640#[serde(rename_all = "camelCase")]
2641pub struct FsCreateDirectoryResponse {
2642 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2643 pub extra: serde_json::Map<String, Value>,
2644}
2645
2646#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2647#[serde(rename_all = "camelCase")]
2648pub struct FsGetMetadataParams {
2649 #[serde(default)]
2650 pub path: Value,
2651}
2652
2653#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2654#[serde(rename_all = "camelCase")]
2655pub struct FsGetMetadataResponse {
2656 #[serde(rename = "createdAtMs", default)]
2657 pub created_at_ms: i64,
2658 #[serde(rename = "isDirectory", default)]
2659 pub is_directory: bool,
2660 #[serde(rename = "isFile", default)]
2661 pub is_file: bool,
2662 #[serde(rename = "isSymlink", default)]
2663 pub is_symlink: bool,
2664 #[serde(rename = "modifiedAtMs", default)]
2665 pub modified_at_ms: i64,
2666}
2667
2668#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2669#[serde(rename_all = "camelCase")]
2670pub struct FsReadDirectoryEntry {
2671 #[serde(rename = "fileName", default)]
2672 pub file_name: String,
2673 #[serde(rename = "isDirectory", default)]
2674 pub is_directory: bool,
2675 #[serde(rename = "isFile", default)]
2676 pub is_file: bool,
2677}
2678
2679#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2680#[serde(rename_all = "camelCase")]
2681pub struct FsReadDirectoryParams {
2682 #[serde(default)]
2683 pub path: Value,
2684}
2685
2686#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2687#[serde(rename_all = "camelCase")]
2688pub struct FsReadDirectoryResponse {
2689 #[serde(default)]
2690 pub entries: Vec<FsReadDirectoryEntry>,
2691}
2692
2693#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2694#[serde(rename_all = "camelCase")]
2695pub struct FsReadFileParams {
2696 #[serde(default)]
2697 pub path: Value,
2698}
2699
2700#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2701#[serde(rename_all = "camelCase")]
2702pub struct FsReadFileResponse {
2703 #[serde(rename = "dataBase64", default)]
2704 pub data_base64: String,
2705}
2706
2707#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2708#[serde(rename_all = "camelCase")]
2709pub struct FsRemoveParams {
2710 #[serde(default, skip_serializing_if = "Option::is_none")]
2711 pub force: Option<bool>,
2712 #[serde(default)]
2713 pub path: Value,
2714 #[serde(default, skip_serializing_if = "Option::is_none")]
2715 pub recursive: Option<bool>,
2716}
2717
2718#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2719#[serde(rename_all = "camelCase")]
2720pub struct FsRemoveResponse {
2721 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2722 pub extra: serde_json::Map<String, Value>,
2723}
2724
2725#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2726#[serde(rename_all = "camelCase")]
2727pub struct FsUnwatchParams {
2728 #[serde(rename = "watchId", default)]
2729 pub watch_id: String,
2730}
2731
2732#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2733#[serde(rename_all = "camelCase")]
2734pub struct FsUnwatchResponse {
2735 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2736 pub extra: serde_json::Map<String, Value>,
2737}
2738
2739#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2740#[serde(rename_all = "camelCase")]
2741pub struct FsWatchParams {
2742 #[serde(default)]
2743 pub path: Value,
2744 #[serde(rename = "watchId", default)]
2745 pub watch_id: String,
2746}
2747
2748#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2749#[serde(rename_all = "camelCase")]
2750pub struct FsWatchResponse {
2751 #[serde(default)]
2752 pub path: Value,
2753}
2754
2755#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2756#[serde(rename_all = "camelCase")]
2757pub struct FsWriteFileParams {
2758 #[serde(rename = "dataBase64", default)]
2759 pub data_base64: String,
2760 #[serde(default)]
2761 pub path: Value,
2762}
2763
2764#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2765#[serde(rename_all = "camelCase")]
2766pub struct FsWriteFileResponse {
2767 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2768 pub extra: serde_json::Map<String, Value>,
2769}
2770
2771#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2772pub enum FuzzyFileSearchMatchType {
2773 #[serde(rename = "file")]
2774 File,
2775 #[serde(rename = "directory")]
2776 Directory,
2777}
2778
2779#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2780#[serde(rename_all = "camelCase")]
2781pub struct FuzzyFileSearchParams {
2782 #[serde(
2783 rename = "cancellationToken",
2784 default,
2785 skip_serializing_if = "Option::is_none"
2786 )]
2787 pub cancellation_token: Option<String>,
2788 #[serde(default)]
2789 pub query: String,
2790 #[serde(default)]
2791 pub roots: Vec<String>,
2792}
2793
2794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2795#[serde(rename_all = "camelCase")]
2796pub struct FuzzyFileSearchResponse {
2797 #[serde(default)]
2798 pub files: Vec<FuzzyFileSearchResult>,
2799}
2800
2801#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2804#[serde(untagged)]
2805pub enum FunctionCallOutputBody {
2806 Text(String),
2807 Items(Vec<FunctionCallOutputContentItem>),
2808}
2809
2810#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2814#[serde(tag = "type")]
2815pub enum FunctionCallOutputContentItem {
2816 #[serde(rename = "input_text")]
2817 InputText { text: String },
2818 #[serde(rename = "input_image")]
2819 InputImage {
2820 #[serde(default, skip_serializing_if = "Option::is_none")]
2821 detail: Option<ImageDetail>,
2822 #[serde(flatten)]
2823 image: ImageReference,
2824 },
2825 #[serde(rename = "input_audio")]
2826 InputAudio {
2827 #[serde(flatten)]
2828 audio: AudioReference,
2829 },
2830 #[serde(rename = "encrypted_content")]
2831 EncryptedContent { encrypted_content: String },
2832}
2833
2834#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2839#[serde(untagged)]
2840pub enum AudioReference {
2841 Inline { audio_url: String },
2842 File { file_id: String },
2843}
2844
2845#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2850#[serde(untagged)]
2851pub enum ImageReference {
2852 Inline { image_url: String },
2853 File { file_id: String },
2854}
2855
2856#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2857#[serde(rename_all = "camelCase")]
2858pub struct FuzzyFileSearchResult {
2859 #[serde(default)]
2860 pub file_name: String,
2861 #[serde(default, skip_serializing_if = "Option::is_none")]
2862 pub indices: Option<Vec<i64>>,
2863 #[serde()]
2864 pub match_type: FuzzyFileSearchMatchType,
2865 #[serde(default)]
2866 pub path: String,
2867 #[serde(default)]
2868 pub root: String,
2869 #[serde(default)]
2870 pub score: i64,
2871}
2872
2873#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2874#[serde(rename_all = "camelCase")]
2875pub struct FuzzyFileSearchSessionCompletedNotification {
2876 #[serde(rename = "sessionId", default)]
2877 pub session_id: String,
2878}
2879
2880#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2881#[serde(rename_all = "camelCase")]
2882pub struct FuzzyFileSearchSessionUpdatedNotification {
2883 #[serde(default)]
2884 pub files: Vec<FuzzyFileSearchResult>,
2885 #[serde(default)]
2886 pub query: String,
2887 #[serde(rename = "sessionId", default)]
2888 pub session_id: String,
2889}
2890
2891#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2892#[serde(rename_all = "camelCase")]
2893pub struct GatewayOAuthCancelResponse {}
2894
2895#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2898#[serde(rename_all = "camelCase")]
2899pub struct GatewayOAuthChangedNotification {
2900 #[serde(rename = "authUrl", default, skip_serializing_if = "Option::is_none")]
2903 pub auth_url: Option<String>,
2904 #[serde(default, skip_serializing_if = "Option::is_none")]
2905 pub error: Option<String>,
2906 #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
2908 pub login_id: Option<String>,
2909 #[serde(rename = "providerId", default)]
2910 pub provider_id: String,
2911 pub status: GatewayOAuthStatus,
2912}
2913
2914#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2917#[serde(rename_all = "camelCase")]
2918pub struct GatewayOAuthLoginParams {
2919 #[serde(
2922 rename = "deviceAuth",
2923 default,
2924 skip_serializing_if = "std::ops::Not::not"
2925 )]
2926 pub device_auth: bool,
2927 #[serde(
2929 rename = "modelProvider",
2930 default,
2931 skip_serializing_if = "Option::is_none"
2932 )]
2933 pub model_provider: Option<String>,
2934}
2935
2936#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2937#[serde(rename_all = "camelCase")]
2938pub struct GatewayOAuthLoginResponse {
2939 #[serde(default, skip_serializing_if = "Option::is_none")]
2942 pub prompt: Option<GatewayOAuthPrompt>,
2943}
2944
2945#[derive(Clone, PartialEq, Serialize, Deserialize, Default)]
2949#[serde(rename_all = "camelCase")]
2950pub struct GatewayOAuthPrompt {
2951 #[serde(rename = "loginId", default)]
2952 pub login_id: String,
2953 #[serde(rename = "userCode", default)]
2954 pub user_code: String,
2955 #[serde(rename = "verificationUrl", default)]
2956 pub verification_url: String,
2957}
2958
2959impl std::fmt::Debug for GatewayOAuthPrompt {
2961 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2962 f.debug_struct("GatewayOAuthPrompt")
2963 .field("login_id", &self.login_id)
2964 .finish_non_exhaustive()
2965 }
2966}
2967
2968#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2971#[serde(rename_all = "camelCase")]
2972pub struct GatewayOAuthReadParams {
2973 #[serde(
2975 rename = "modelProvider",
2976 default,
2977 skip_serializing_if = "Option::is_none"
2978 )]
2979 pub model_provider: Option<String>,
2980}
2981
2982#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2985#[serde(rename_all = "camelCase")]
2986pub struct GatewayOAuthReadResponse {
2987 #[serde(default, skip_serializing_if = "Option::is_none")]
2988 pub error: Option<String>,
2989 #[serde(rename = "providerId", default)]
2990 pub provider_id: String,
2991 #[serde(rename = "providerName", default)]
2992 pub provider_name: String,
2993 #[serde(default)]
2996 pub required: bool,
2997 #[serde(default, skip_serializing_if = "Option::is_none")]
2999 pub status: Option<GatewayOAuthStatus>,
3000 #[serde(rename = "supportsDeviceAuth", default)]
3003 pub supports_device_auth: bool,
3004}
3005
3006#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
3007pub enum GatewayOAuthStatus {
3008 #[serde(rename = "notReady")]
3009 NotReady,
3010 #[serde(rename = "started")]
3011 Started,
3012 #[serde(rename = "succeeded")]
3013 Succeeded,
3014 #[serde(rename = "failed")]
3015 Failed,
3016}
3017
3018#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3019#[serde(rename_all = "camelCase")]
3020pub struct GetAccountParams {
3021 #[serde(
3022 rename = "refreshToken",
3023 default,
3024 skip_serializing_if = "Option::is_none"
3025 )]
3026 pub refresh_token: Option<bool>,
3027}
3028
3029#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
3033#[serde(rename_all = "camelCase")]
3034pub struct GetAccountSecuritySetupResponse {
3035 #[serde(default)]
3036 pub notice: Option<AccountSecuritySetupNotice>,
3037}
3038
3039#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
3041#[serde(rename_all = "camelCase")]
3042pub struct AccountSecuritySetupNotice {
3043 pub account_id: String,
3044 pub user_id: String,
3045 pub title: String,
3046 pub description: String,
3047 pub action: AccountSecuritySetupAction,
3048}
3049
3050#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
3052#[serde(rename_all = "camelCase")]
3053pub struct AccountSecuritySetupAction {
3054 pub label: String,
3055 pub url: String,
3056}
3057
3058#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
3062#[serde(rename_all = "camelCase")]
3063pub struct GetAccountRateLimitsParams {
3064 #[serde(
3068 rename = "excludeResetCreditDetails",
3069 default,
3070 skip_serializing_if = "std::ops::Not::not"
3071 )]
3072 pub exclude_reset_credit_details: bool,
3073 #[serde(
3077 rename = "supportsLunaReserve",
3078 default,
3079 skip_serializing_if = "std::ops::Not::not"
3080 )]
3081 pub supports_luna_reserve: bool,
3082}
3083
3084#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3085#[serde(rename_all = "camelCase")]
3086pub struct GetAccountRateLimitsResponse {
3087 #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
3088 pub account_id: Option<String>,
3089 #[serde(
3093 rename = "ordinaryUsageAllowed",
3094 default,
3095 skip_serializing_if = "Option::is_none"
3096 )]
3097 pub ordinary_usage_allowed: Option<bool>,
3098 #[serde(
3099 rename = "rateLimitResetCredits",
3100 default,
3101 skip_serializing_if = "Option::is_none"
3102 )]
3103 pub rate_limit_reset_credits: Option<RateLimitResetCreditsSummary>,
3104 #[serde(
3105 rename = "rateLimitUpsell",
3106 default,
3107 skip_serializing_if = "Option::is_none"
3108 )]
3109 pub rate_limit_upsell: Option<Value>,
3110 #[serde(rename = "rateLimits", default)]
3111 pub rate_limits: Value,
3112 #[serde(
3113 rename = "rateLimitsByLimitId",
3114 default,
3115 skip_serializing_if = "Option::is_none"
3116 )]
3117 pub rate_limits_by_limit_id: Option<std::collections::BTreeMap<String, RateLimitSnapshot>>,
3118}
3119
3120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3121#[serde(rename_all = "camelCase")]
3122pub struct GetAccountResponse {
3123 #[serde(default, skip_serializing_if = "Option::is_none")]
3124 pub account: Option<Account>,
3125 #[serde(rename = "requiresOpenaiAuth", default)]
3126 pub requires_openai_auth: bool,
3127 #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
3129 pub user_id: Option<String>,
3130}
3131
3132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3133#[serde(rename_all = "camelCase")]
3134pub struct GetAccountTokenUsageResponse {
3135 #[serde(
3136 rename = "dailyUsageBuckets",
3137 default,
3138 skip_serializing_if = "Option::is_none"
3139 )]
3140 pub daily_usage_buckets: Option<Vec<AccountTokenUsageDailyBucket>>,
3141 #[serde()]
3142 pub summary: AccountTokenUsageSummary,
3143 #[serde(
3144 rename = "threadUsage",
3145 default,
3146 skip_serializing_if = "Option::is_none"
3147 )]
3148 pub thread_usage: Option<ThreadUsage>,
3149}
3150
3151#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3152#[serde(rename_all = "camelCase")]
3153pub struct GetAccountTokenUsageParams {
3154 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3155 pub thread_id: Option<String>,
3156}
3157
3158#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3159#[serde(rename_all = "camelCase")]
3160pub struct ThreadUsage {
3161 #[serde(rename = "estimatedUsageCreditsMicros", default)]
3162 pub estimated_usage_credits_micros: i64,
3163 #[serde(
3164 rename = "estimatedUsageUsdMicros",
3165 default,
3166 skip_serializing_if = "Option::is_none"
3167 )]
3168 pub estimated_usage_usd_micros: Option<i64>,
3169 #[serde(
3172 rename = "nativeUsageUsdMicros",
3173 default,
3174 skip_serializing_if = "Option::is_none"
3175 )]
3176 pub native_usage_usd_micros: Option<i64>,
3177 #[serde(default)]
3178 pub groups: Vec<ThreadUsageBreakdownGroup>,
3179 #[serde(rename = "threadId", default)]
3180 pub thread_id: String,
3181}
3182
3183#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3184#[serde(rename_all = "camelCase")]
3185pub struct ThreadUsageBreakdownGroup {
3186 #[serde(
3187 rename = "cachedInputTokens",
3188 default,
3189 skip_serializing_if = "Option::is_none"
3190 )]
3191 pub cached_input_tokens: Option<i64>,
3192 #[serde(rename = "estimatedUsageCreditsMicros", default)]
3193 pub estimated_usage_credits_micros: i64,
3194 #[serde(
3195 rename = "inputTokens",
3196 default,
3197 skip_serializing_if = "Option::is_none"
3198 )]
3199 pub input_tokens: Option<i64>,
3200 #[serde(default, skip_serializing_if = "Option::is_none")]
3201 pub model: Option<String>,
3202 #[serde(
3203 rename = "netNewInputTokens",
3204 default,
3205 skip_serializing_if = "Option::is_none"
3206 )]
3207 pub net_new_input_tokens: Option<i64>,
3208 #[serde(
3209 rename = "outputTokens",
3210 default,
3211 skip_serializing_if = "Option::is_none"
3212 )]
3213 pub output_tokens: Option<i64>,
3214 #[serde(
3215 rename = "reasoningEffort",
3216 default,
3217 skip_serializing_if = "Option::is_none"
3218 )]
3219 pub reasoning_effort: Option<String>,
3220 #[serde(default, skip_serializing_if = "Option::is_none")]
3221 pub speed: Option<String>,
3222 #[serde(
3223 rename = "totalTokens",
3224 default,
3225 skip_serializing_if = "Option::is_none"
3226 )]
3227 pub total_tokens: Option<i64>,
3228}
3229
3230#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3235#[serde(untagged)]
3236pub enum GeneratedImageRef {
3237 File {
3238 #[serde(rename = "fileId")]
3239 file_id: String,
3240 },
3241 Inline {
3242 result: String,
3243 },
3244}
3245
3246#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3248pub struct ImageGenerationInputImage {
3249 pub path: AbsolutePathBuf,
3250 pub sha256: String,
3252}
3253
3254#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3255#[serde(tag = "type", rename_all = "camelCase")]
3256pub enum ImageGenerationFailure {
3257 #[serde(rename = "usageLimitExceeded")]
3258 UsageLimitExceeded {
3259 #[serde(rename = "limitId")]
3260 limit_id: String,
3261 #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
3262 resets_at: Option<i64>,
3263 },
3264}
3265
3266#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3267#[serde(rename_all = "lowercase")]
3268pub enum McpServerOauthClientRegistration {
3269 Auto,
3270 Cimd,
3271 Dcr,
3272}
3273
3274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3275#[serde(rename_all = "camelCase")]
3276pub struct GetWorkspaceMessagesResponse {
3277 #[serde(rename = "featureEnabled", default)]
3278 pub feature_enabled: bool,
3279 #[serde(default)]
3280 pub messages: Vec<WorkspaceMessage>,
3281}
3282
3283#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3284#[serde(rename_all = "camelCase")]
3285pub struct GitInfo {
3286 #[serde(default, skip_serializing_if = "Option::is_none")]
3287 pub branch: Option<String>,
3288 #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
3289 pub origin_url: Option<String>,
3290 #[serde(default, skip_serializing_if = "Option::is_none")]
3291 pub sha: Option<String>,
3292}
3293
3294#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3295#[serde(rename_all = "camelCase")]
3296pub struct GrantedPermissionProfile {
3297 #[serde(
3298 rename = "fileSystem",
3299 default,
3300 skip_serializing_if = "Option::is_none"
3301 )]
3302 pub file_system: Option<AdditionalFileSystemPermissions>,
3303 #[serde(default, skip_serializing_if = "Option::is_none")]
3304 pub network: Option<AdditionalNetworkPermissions>,
3305}
3306
3307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3308#[serde(rename_all = "camelCase")]
3309pub struct GuardianApprovalReview {
3310 #[serde(default, skip_serializing_if = "Option::is_none")]
3311 pub rationale: Option<String>,
3312 #[serde(rename = "riskLevel", default, skip_serializing_if = "Option::is_none")]
3313 pub risk_level: Option<GuardianRiskLevel>,
3314 #[serde()]
3315 pub status: GuardianApprovalReviewStatus,
3316 #[serde(
3317 rename = "userAuthorization",
3318 default,
3319 skip_serializing_if = "Option::is_none"
3320 )]
3321 pub user_authorization: Option<GuardianUserAuthorization>,
3322}
3323
3324#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3325#[serde(tag = "type", rename_all = "camelCase")]
3326pub enum GuardianApprovalReviewAction {
3327 Command {
3328 command: String,
3329 cwd: LegacyAppPathString,
3330 source: GuardianCommandSource,
3331 },
3332 Execve {
3333 argv: Vec<String>,
3334 cwd: AbsolutePathBuf,
3335 program: String,
3336 source: GuardianCommandSource,
3337 },
3338 #[serde(rename = "writeStdin")]
3339 WriteStdin {
3340 #[serde(rename = "approvalId")]
3341 approval_id: String,
3342 cwd: LegacyAppPathString,
3343 #[serde(rename = "processId")]
3344 process_id: String,
3345 stdin: String,
3346 },
3347 #[serde(rename = "applyPatch")]
3348 ApplyPatch {
3349 cwd: LegacyAppPathString,
3350 files: Vec<LegacyAppPathString>,
3351 },
3352 #[serde(rename = "networkAccess")]
3353 NetworkAccess {
3354 host: String,
3355 port: i64,
3356 protocol: NetworkApprovalProtocol,
3357 target: String,
3358 },
3359 #[serde(rename = "mcpToolCall")]
3360 McpToolCall {
3361 #[serde(
3362 rename = "connectorId",
3363 default,
3364 skip_serializing_if = "Option::is_none"
3365 )]
3366 connector_id: Option<String>,
3367 #[serde(
3368 rename = "connectorName",
3369 default,
3370 skip_serializing_if = "Option::is_none"
3371 )]
3372 connector_name: Option<String>,
3373 server: String,
3374 #[serde(rename = "toolName")]
3375 tool_name: String,
3376 #[serde(rename = "toolTitle", default, skip_serializing_if = "Option::is_none")]
3377 tool_title: Option<String>,
3378 },
3379 #[serde(rename = "requestPermissions")]
3380 RequestPermissions {
3381 permissions: RequestPermissionProfile,
3382 #[serde(default, skip_serializing_if = "Option::is_none")]
3383 reason: Option<String>,
3384 },
3385}
3386
3387#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3388pub enum GuardianApprovalReviewStatus {
3389 #[serde(rename = "inProgress")]
3390 InProgress,
3391 #[serde(rename = "approved")]
3392 Approved,
3393 #[serde(rename = "denied")]
3394 Denied,
3395 #[serde(rename = "timedOut")]
3396 TimedOut,
3397 #[serde(rename = "aborted")]
3398 Aborted,
3399}
3400
3401#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3402pub enum GuardianCommandSource {
3403 #[serde(rename = "shell")]
3404 Shell,
3405 #[serde(rename = "unifiedExec")]
3406 UnifiedExec,
3407}
3408
3409#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3410pub enum GuardianRiskLevel {
3411 #[serde(rename = "low")]
3412 Low,
3413 #[serde(rename = "medium")]
3414 Medium,
3415 #[serde(rename = "high")]
3416 High,
3417 #[serde(rename = "critical")]
3418 Critical,
3419}
3420
3421#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3422pub enum GuardianUserAuthorization {
3423 #[serde(rename = "unknown")]
3424 Unknown,
3425 #[serde(rename = "low")]
3426 Low,
3427 #[serde(rename = "medium")]
3428 Medium,
3429 #[serde(rename = "high")]
3430 High,
3431}
3432
3433#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3434#[serde(rename_all = "camelCase")]
3435pub struct GuardianWarningNotification {
3436 #[serde(default)]
3437 pub message: String,
3438 #[serde(rename = "threadId", default)]
3439 pub thread_id: String,
3440}
3441
3442#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3443#[serde(rename_all = "camelCase")]
3444pub struct HookCompletedNotification {
3445 #[serde()]
3446 pub run: HookRunSummary,
3447 #[serde(rename = "threadId", default)]
3448 pub thread_id: String,
3449 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
3450 pub turn_id: Option<String>,
3451}
3452
3453#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3454#[serde(rename_all = "camelCase")]
3455pub struct HookErrorInfo {
3456 #[serde(default)]
3457 pub message: String,
3458 #[serde(default)]
3459 pub path: String,
3460}
3461
3462#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3463pub enum HookEventName {
3464 #[serde(rename = "preModelRequest")]
3465 PreModelRequest,
3466 #[serde(rename = "postModelRequest")]
3467 PostModelRequest,
3468 #[serde(rename = "preToolUse")]
3469 PreToolUse,
3470 #[serde(rename = "permissionRequest")]
3471 PermissionRequest,
3472 #[serde(rename = "postToolUse")]
3473 PostToolUse,
3474 #[serde(rename = "preCompact")]
3475 PreCompact,
3476 #[serde(rename = "postCompact")]
3477 PostCompact,
3478 #[serde(rename = "sessionStart")]
3479 SessionStart,
3480 #[serde(rename = "sessionEnd")]
3481 SessionEnd,
3482 #[serde(rename = "userPromptSubmit")]
3483 UserPromptSubmit,
3484 #[serde(rename = "subagentStart")]
3485 SubagentStart,
3486 #[serde(rename = "subagentStop")]
3487 SubagentStop,
3488 #[serde(rename = "stop")]
3489 Stop,
3490 #[serde(rename = "interrupt")]
3491 Interrupt,
3492}
3493
3494#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3495pub enum HookExecutionMode {
3496 #[serde(rename = "sync")]
3497 Sync,
3498 #[serde(rename = "async")]
3499 Async,
3500}
3501
3502#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3503pub enum HookHandlerType {
3504 #[serde(rename = "command")]
3505 Command,
3506 #[serde(rename = "mcpTool")]
3507 McpTool,
3508 #[serde(rename = "prompt")]
3509 Prompt,
3510 #[serde(rename = "agent")]
3511 Agent,
3512}
3513
3514#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3515#[serde(rename_all = "camelCase")]
3516pub struct HookMetadata {
3517 #[serde(
3518 rename = "additionalContextLimit",
3519 default,
3520 skip_serializing_if = "Option::is_none"
3521 )]
3522 pub additional_context_limit: Option<i64>,
3523 #[serde(rename = "async", default, skip_serializing_if = "Option::is_none")]
3524 pub is_async: Option<bool>,
3525 #[serde(default, skip_serializing_if = "Option::is_none")]
3526 pub command: Option<String>,
3527 #[serde(rename = "currentHash", default)]
3528 pub current_hash: String,
3529 #[serde(default, skip_serializing_if = "Option::is_none")]
3531 pub server: Option<String>,
3532 #[serde(default, skip_serializing_if = "Option::is_none")]
3534 pub tool: Option<String>,
3535 #[serde(rename = "displayOrder", default)]
3536 pub display_order: i64,
3537 #[serde(default)]
3538 pub enabled: bool,
3539 #[serde(
3541 rename = "environmentId",
3542 default,
3543 skip_serializing_if = "Option::is_none"
3544 )]
3545 pub environment_id: Option<String>,
3546 #[serde(rename = "eventName")]
3547 pub event_name: HookEventName,
3548 #[serde(
3549 rename = "executionMode",
3550 default,
3551 skip_serializing_if = "Option::is_none"
3552 )]
3553 pub execution_mode: Option<Value>,
3554 #[serde(rename = "handlerType")]
3555 pub handler_type: HookHandlerType,
3556 #[serde(rename = "isManaged", default)]
3557 pub is_managed: bool,
3558 #[serde(default)]
3559 pub key: String,
3560 #[serde(default, skip_serializing_if = "Option::is_none")]
3561 pub matcher: Option<String>,
3562 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
3563 pub plugin_id: Option<String>,
3564 #[serde()]
3565 pub source: HookSource,
3566 #[serde(rename = "sourcePath")]
3567 pub source_path: AbsolutePathBuf,
3568 #[serde(
3569 rename = "statusMessage",
3570 default,
3571 skip_serializing_if = "Option::is_none"
3572 )]
3573 pub status_message: Option<String>,
3574 #[serde(rename = "timeoutSec", default)]
3575 pub timeout_sec: i64,
3576 #[serde(rename = "trustStatus")]
3577 pub trust_status: HookTrustStatus,
3578}
3579
3580#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3581#[serde(rename_all = "camelCase")]
3582pub struct HookMigration {
3583 #[serde(default)]
3584 pub name: String,
3585}
3586
3587#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3588#[serde(rename_all = "camelCase")]
3589pub struct HookOutputEntry {
3590 #[serde()]
3591 pub kind: HookOutputEntryKind,
3592 #[serde(default)]
3593 pub text: String,
3594}
3595
3596#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3597pub enum HookOutputEntryKind {
3598 #[serde(rename = "warning")]
3599 Warning,
3600 #[serde(rename = "stop")]
3601 Stop,
3602 #[serde(rename = "feedback")]
3603 Feedback,
3604 #[serde(rename = "context")]
3605 Context,
3606 #[serde(rename = "error")]
3607 Error,
3608}
3609
3610#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3611#[serde(rename_all = "camelCase")]
3612pub struct HookPromptFragment {
3613 #[serde(rename = "hookRunId", default)]
3614 pub hook_run_id: String,
3615 #[serde(default)]
3616 pub text: String,
3617}
3618
3619#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3620pub enum HookRunStatus {
3621 #[serde(rename = "running")]
3622 Running,
3623 #[serde(rename = "completed")]
3624 Completed,
3625 #[serde(rename = "failed")]
3626 Failed,
3627 #[serde(rename = "blocked")]
3628 Blocked,
3629 #[serde(rename = "stopped")]
3630 Stopped,
3631}
3632
3633#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3634#[serde(rename_all = "camelCase")]
3635pub struct HookRunSummary {
3636 #[serde(
3637 rename = "completedAt",
3638 default,
3639 skip_serializing_if = "Option::is_none"
3640 )]
3641 pub completed_at: Option<i64>,
3642 #[serde(rename = "displayOrder", default)]
3643 pub display_order: i64,
3644 #[serde(
3645 rename = "durationMs",
3646 default,
3647 skip_serializing_if = "Option::is_none"
3648 )]
3649 pub duration_ms: Option<i64>,
3650 #[serde(default)]
3651 pub entries: Vec<HookOutputEntry>,
3652 #[serde(rename = "eventName")]
3653 pub event_name: HookEventName,
3654 #[serde(rename = "executionMode")]
3655 pub execution_mode: HookExecutionMode,
3656 #[serde(rename = "handlerType")]
3657 pub handler_type: HookHandlerType,
3658 #[serde(default)]
3659 pub id: String,
3660 #[serde()]
3661 pub scope: HookScope,
3662 #[serde(default, skip_serializing_if = "Option::is_none")]
3663 pub source: Option<Value>,
3664 #[serde(rename = "sourcePath")]
3665 pub source_path: LegacyAppPathString,
3666 #[serde(rename = "startedAt", default)]
3667 pub started_at: i64,
3668 #[serde()]
3669 pub status: HookRunStatus,
3670 #[serde(
3671 rename = "statusMessage",
3672 default,
3673 skip_serializing_if = "Option::is_none"
3674 )]
3675 pub status_message: Option<String>,
3676}
3677
3678#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3679pub enum HookScope {
3680 #[serde(rename = "thread")]
3681 Thread,
3682 #[serde(rename = "turn")]
3683 Turn,
3684}
3685
3686#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3687pub enum HookSource {
3688 #[serde(rename = "system")]
3689 System,
3690 #[serde(rename = "user")]
3691 User,
3692 #[serde(rename = "project")]
3693 Project,
3694 #[serde(rename = "mdm")]
3695 Mdm,
3696 #[serde(rename = "sessionFlags")]
3697 SessionFlags,
3698 #[serde(rename = "plugin")]
3699 Plugin,
3700 #[serde(rename = "cloudRequirements")]
3701 CloudRequirements,
3702 #[serde(rename = "cloudManagedConfig")]
3703 CloudManagedConfig,
3704 #[serde(rename = "legacyManagedConfigFile")]
3705 LegacyManagedConfigFile,
3706 #[serde(rename = "legacyManagedConfigMdm")]
3707 LegacyManagedConfigMdm,
3708 #[serde(rename = "unknown")]
3709 Unknown,
3710}
3711
3712#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3713#[serde(rename_all = "camelCase")]
3714pub struct HookStartedNotification {
3715 #[serde()]
3716 pub run: HookRunSummary,
3717 #[serde(rename = "threadId", default)]
3718 pub thread_id: String,
3719 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
3720 pub turn_id: Option<String>,
3721}
3722
3723#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3724pub enum HookTrustStatus {
3725 #[serde(rename = "managed")]
3726 Managed,
3727 #[serde(rename = "untrusted")]
3728 Untrusted,
3729 #[serde(rename = "trusted")]
3730 Trusted,
3731 #[serde(rename = "modified")]
3732 Modified,
3733}
3734
3735#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3736#[serde(rename_all = "camelCase")]
3737pub struct HooksListEntry {
3738 #[serde(default)]
3739 pub cwd: String,
3740 #[serde(default)]
3741 pub errors: Vec<HookErrorInfo>,
3742 #[serde(default)]
3743 pub hooks: Vec<HookMetadata>,
3744 #[serde(default)]
3745 pub warnings: Vec<String>,
3746}
3747
3748#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3749#[serde(rename_all = "camelCase")]
3750pub struct HooksListParams {
3751 #[serde(default, skip_serializing_if = "Option::is_none")]
3753 pub cwds: Option<Vec<String>>,
3754 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3756 pub thread_id: Option<String>,
3757}
3758
3759#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3760#[serde(rename_all = "camelCase")]
3761pub struct HooksListResponse {
3762 #[serde(default)]
3763 pub data: Vec<HooksListEntry>,
3764}
3765
3766#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3767pub enum ImageDetail {
3768 #[serde(rename = "auto")]
3769 Auto,
3770 #[serde(rename = "low")]
3771 Low,
3772 #[serde(rename = "high")]
3773 High,
3774 #[serde(rename = "original")]
3775 Original,
3776}
3777
3778#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3779#[serde(rename_all = "camelCase")]
3780pub struct InitializeCapabilities {
3781 #[serde(
3782 rename = "experimentalApi",
3783 default,
3784 skip_serializing_if = "Option::is_none"
3785 )]
3786 pub experimental_api: Option<bool>,
3787 #[serde(
3791 rename = "explicitGatewayOauth",
3792 default,
3793 skip_serializing_if = "Option::is_none"
3794 )]
3795 pub explicit_gateway_oauth: Option<bool>,
3796 #[serde(default, skip_serializing_if = "Option::is_none")]
3797 pub extensions: Option<Value>,
3798 #[serde(
3799 rename = "mcpServerOpenaiFormElicitation",
3800 default,
3801 skip_serializing_if = "Option::is_none"
3802 )]
3803 pub mcp_server_openai_form_elicitation: Option<bool>,
3804 #[serde(
3805 rename = "optOutNotificationMethods",
3806 default,
3807 skip_serializing_if = "Option::is_none"
3808 )]
3809 pub opt_out_notification_methods: Option<Vec<String>>,
3810 #[serde(
3811 rename = "requestAttestation",
3812 default,
3813 skip_serializing_if = "Option::is_none"
3814 )]
3815 pub request_attestation: Option<bool>,
3816 #[serde(
3820 rename = "requiredHumanApproval",
3821 default,
3822 skip_serializing_if = "Option::is_none"
3823 )]
3824 pub required_human_approval: Option<bool>,
3825}
3826
3827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3828#[serde(rename_all = "camelCase")]
3829pub struct InitializeParams {
3830 #[serde(default, skip_serializing_if = "Option::is_none")]
3831 pub capabilities: Option<InitializeCapabilities>,
3832 #[serde(rename = "clientInfo")]
3833 pub client_info: ClientInfo,
3834}
3835
3836#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3837#[serde(rename_all = "camelCase")]
3838pub struct InitializeResponse {
3839 #[serde(rename = "codexHome", default)]
3840 pub codex_home: Value,
3841 #[serde(rename = "platformFamily", default)]
3842 pub platform_family: String,
3843 #[serde(rename = "platformOs", default)]
3844 pub platform_os: String,
3845 #[serde(rename = "userAgent", default)]
3846 pub user_agent: String,
3847}
3848
3849#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
3850pub enum InputModality {
3851 #[serde(rename = "text")]
3852 Text,
3853 #[serde(rename = "image")]
3854 Image,
3855 #[serde(rename = "audio")]
3856 Audio,
3857}
3858
3859#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3860#[serde(rename_all = "camelCase")]
3861pub struct InstalledApp {
3862 #[serde(default)]
3863 pub callable: bool,
3864 #[serde(default)]
3865 pub enabled: bool,
3866 #[serde(default)]
3867 pub id: String,
3868 #[serde(
3869 rename = "runtimeName",
3870 default,
3871 skip_serializing_if = "Option::is_none"
3872 )]
3873 pub runtime_name: Option<String>,
3874}
3875
3876#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3877#[serde(rename_all = "camelCase")]
3878pub struct ItemCompletedNotification {
3879 #[serde(rename = "completedAtMs", default)]
3880 pub completed_at_ms: i64,
3881 #[serde(
3885 rename = "contentTokenCount",
3886 default,
3887 skip_serializing_if = "Option::is_none"
3888 )]
3889 pub content_token_count: Option<i64>,
3890 #[serde()]
3891 pub item: ThreadItem,
3892 #[serde(rename = "threadId", default)]
3893 pub thread_id: String,
3894 #[serde(rename = "turnId", default)]
3895 pub turn_id: String,
3896}
3897
3898#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3899#[serde(rename_all = "camelCase")]
3900pub struct ItemGuardianApprovalReviewCompletedNotification {
3901 #[serde()]
3902 pub action: GuardianApprovalReviewAction,
3903 #[serde(rename = "completedAtMs", default)]
3904 pub completed_at_ms: i64,
3905 #[serde(rename = "decisionSource")]
3906 pub decision_source: AutoReviewDecisionSource,
3907 #[serde()]
3908 pub review: GuardianApprovalReview,
3909 #[serde(rename = "reviewId", default)]
3910 pub review_id: String,
3911 #[serde(rename = "startedAtMs", default)]
3912 pub started_at_ms: i64,
3913 #[serde(
3914 rename = "targetItemId",
3915 default,
3916 skip_serializing_if = "Option::is_none"
3917 )]
3918 pub target_item_id: Option<String>,
3919 #[serde(rename = "threadId", default)]
3920 pub thread_id: String,
3921 #[serde(rename = "turnId", default)]
3922 pub turn_id: String,
3923}
3924
3925#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3926#[serde(rename_all = "camelCase")]
3927pub struct ItemGuardianApprovalReviewStartedNotification {
3928 #[serde()]
3929 pub action: GuardianApprovalReviewAction,
3930 #[serde()]
3931 pub review: GuardianApprovalReview,
3932 #[serde(rename = "reviewId", default)]
3933 pub review_id: String,
3934 #[serde(rename = "startedAtMs", default)]
3935 pub started_at_ms: i64,
3936 #[serde(
3937 rename = "targetItemId",
3938 default,
3939 skip_serializing_if = "Option::is_none"
3940 )]
3941 pub target_item_id: Option<String>,
3942 #[serde(rename = "threadId", default)]
3943 pub thread_id: String,
3944 #[serde(rename = "turnId", default)]
3945 pub turn_id: String,
3946}
3947
3948#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3949#[serde(rename_all = "camelCase")]
3950pub struct ItemStartedNotification {
3951 #[serde()]
3952 pub item: ThreadItem,
3953 #[serde(rename = "startedAtMs", default)]
3954 pub started_at_ms: i64,
3955 #[serde(rename = "threadId", default)]
3956 pub thread_id: String,
3957 #[serde(rename = "turnId", default)]
3958 pub turn_id: String,
3959}
3960
3961#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3962#[serde(rename_all = "camelCase")]
3963pub struct JSONRPCResponse {
3964 #[serde()]
3965 pub id: RequestId,
3966 #[serde(default)]
3967 pub result: Value,
3968}
3969
3970#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
3971#[serde(transparent)]
3972pub struct LegacyAppPathString(pub String);
3973
3974#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3975#[serde(rename_all = "camelCase")]
3976pub struct ListMcpServerStatusParams {
3977 #[serde(default, skip_serializing_if = "Option::is_none")]
3978 pub cursor: Option<String>,
3979 #[serde(default, skip_serializing_if = "Option::is_none")]
3980 pub detail: Option<McpServerStatusDetail>,
3981 #[serde(
3985 rename = "environmentId",
3986 default,
3987 skip_serializing_if = "Option::is_none"
3988 )]
3989 pub environment_id: Option<String>,
3990 #[serde(default, skip_serializing_if = "Option::is_none")]
3991 pub limit: Option<i64>,
3992 #[serde(
3995 rename = "serverName",
3996 default,
3997 skip_serializing_if = "Option::is_none"
3998 )]
3999 pub server_name: Option<String>,
4000 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4001 pub thread_id: Option<String>,
4002}
4003
4004#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4005#[serde(rename_all = "camelCase")]
4006pub struct ListMcpServerStatusResponse {
4007 #[serde(default)]
4008 pub data: Vec<McpServerStatus>,
4009 #[serde(
4010 rename = "nextCursor",
4011 default,
4012 skip_serializing_if = "Option::is_none"
4013 )]
4014 pub next_cursor: Option<String>,
4015}
4016
4017#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4018#[serde(tag = "type", rename_all = "camelCase")]
4019pub enum LoginAccountParams {
4020 #[serde(rename = "apiKey")]
4021 ApiKey {
4022 #[serde(rename = "apiKey")]
4023 api_key: String,
4024 },
4025 Chatgpt {
4026 #[serde(rename = "appBrand", default, skip_serializing_if = "Option::is_none")]
4027 app_brand: Option<LoginAppBrand>,
4028 #[serde(
4029 rename = "codexStreamlinedLogin",
4030 default,
4031 skip_serializing_if = "Option::is_none"
4032 )]
4033 codex_streamlined_login: Option<bool>,
4034 #[serde(
4035 rename = "useHostedLoginSuccessPage",
4036 default,
4037 skip_serializing_if = "Option::is_none"
4038 )]
4039 use_hosted_login_success_page: Option<bool>,
4040 },
4041 #[serde(rename = "chatgptDeviceCode")]
4042 ChatgptDeviceCode,
4043 #[serde(rename = "chatgptAuthTokens")]
4044 ChatgptAuthTokens {
4045 #[serde(rename = "accessToken")]
4046 access_token: String,
4047 #[serde(rename = "chatgptAccountId")]
4048 chatgpt_account_id: String,
4049 #[serde(
4050 rename = "chatgptPlanType",
4051 default,
4052 skip_serializing_if = "Option::is_none"
4053 )]
4054 chatgpt_plan_type: Option<String>,
4055 },
4056 #[serde(rename = "amazonBedrock")]
4057 AmazonBedrock {
4058 #[serde(rename = "apiKey")]
4059 api_key: String,
4060 #[serde(
4062 rename = "providerId",
4063 default,
4064 skip_serializing_if = "Option::is_none"
4065 )]
4066 provider_id: Option<BedrockProviderId>,
4067 region: String,
4068 },
4069 #[serde(rename = "amazonBedrockAccessKeys")]
4070 AmazonBedrockAccessKeys {
4071 #[serde(rename = "accessKeyId")]
4072 access_key_id: String,
4073 #[serde(
4075 rename = "providerId",
4076 default,
4077 skip_serializing_if = "Option::is_none"
4078 )]
4079 provider_id: Option<BedrockProviderId>,
4080 region: String,
4081 #[serde(rename = "secretAccessKey")]
4082 secret_access_key: String,
4083 #[serde(
4084 rename = "sessionToken",
4085 default,
4086 skip_serializing_if = "Option::is_none"
4087 )]
4088 session_token: Option<String>,
4089 },
4090}
4091
4092#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4093#[serde(tag = "type", rename_all = "camelCase")]
4094pub enum LoginAccountResponse {
4095 #[serde(rename = "apiKey")]
4096 ApiKey,
4097 Chatgpt {
4098 #[serde(rename = "authUrl")]
4099 auth_url: String,
4100 #[serde(rename = "loginId")]
4101 login_id: String,
4102 },
4103 #[serde(rename = "chatgptDeviceCode")]
4104 ChatgptDeviceCode {
4105 #[serde(rename = "loginId")]
4106 login_id: String,
4107 #[serde(rename = "userCode")]
4108 user_code: String,
4109 #[serde(rename = "verificationUrl")]
4110 verification_url: String,
4111 },
4112 #[serde(rename = "chatgptAuthTokens")]
4113 ChatgptAuthTokens,
4114 #[serde(rename = "amazonBedrock")]
4115 AmazonBedrock,
4116}
4117
4118#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4119pub enum LoginAppBrand {
4120 #[serde(rename = "codex")]
4121 Codex,
4122 #[serde(rename = "chatgpt")]
4123 Chatgpt,
4124}
4125
4126#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4127#[serde(rename_all = "camelCase")]
4128pub struct LogoutAccountResponse {
4129 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4130 pub extra: serde_json::Map<String, Value>,
4131}
4132
4133#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4134#[serde(rename_all = "camelCase")]
4135pub struct MarketplaceAddParams {
4136 #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
4137 pub ref_name: Option<String>,
4138 #[serde(default)]
4139 pub source: String,
4140 #[serde(
4141 rename = "sparsePaths",
4142 default,
4143 skip_serializing_if = "Option::is_none"
4144 )]
4145 pub sparse_paths: Option<Vec<String>>,
4146}
4147
4148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4149#[serde(rename_all = "camelCase")]
4150pub struct MarketplaceAddResponse {
4151 #[serde(rename = "alreadyAdded", default)]
4152 pub already_added: bool,
4153 #[serde(rename = "installedRoot")]
4154 pub installed_root: AbsolutePathBuf,
4155 #[serde(rename = "marketplaceName", default)]
4156 pub marketplace_name: String,
4157}
4158
4159#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4160#[serde(rename_all = "camelCase")]
4161pub struct MarketplaceInterface {
4162 #[serde(
4163 rename = "displayName",
4164 default,
4165 skip_serializing_if = "Option::is_none"
4166 )]
4167 pub display_name: Option<String>,
4168}
4169
4170#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4171#[serde(rename_all = "camelCase")]
4172pub struct MarketplaceLoadErrorInfo {
4173 #[serde(rename = "marketplacePath")]
4174 pub marketplace_path: AbsolutePathBuf,
4175 #[serde(default)]
4176 pub message: String,
4177}
4178
4179#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4180#[serde(rename_all = "camelCase")]
4181pub struct MarketplaceRemoveParams {
4182 #[serde(rename = "marketplaceName", default)]
4183 pub marketplace_name: String,
4184}
4185
4186#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4187#[serde(rename_all = "camelCase")]
4188pub struct MarketplaceRemoveResponse {
4189 #[serde(
4190 rename = "installedRoot",
4191 default,
4192 skip_serializing_if = "Option::is_none"
4193 )]
4194 pub installed_root: Option<AbsolutePathBuf>,
4195 #[serde(rename = "marketplaceName", default)]
4196 pub marketplace_name: String,
4197}
4198
4199#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4200#[serde(rename_all = "camelCase")]
4201pub struct MarketplaceUpgradeErrorInfo {
4202 #[serde(rename = "marketplaceName", default)]
4203 pub marketplace_name: String,
4204 #[serde(default)]
4205 pub message: String,
4206}
4207
4208#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4209#[serde(rename_all = "camelCase")]
4210pub struct MarketplaceUpgradeParams {
4211 #[serde(
4212 rename = "marketplaceName",
4213 default,
4214 skip_serializing_if = "Option::is_none"
4215 )]
4216 pub marketplace_name: Option<String>,
4217}
4218
4219#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4220#[serde(rename_all = "camelCase")]
4221pub struct MarketplaceUpgradeResponse {
4222 #[serde(default)]
4223 pub errors: Vec<MarketplaceUpgradeErrorInfo>,
4224 #[serde(rename = "selectedMarketplaces", default)]
4225 pub selected_marketplaces: Vec<String>,
4226 #[serde(rename = "upgradedRoots", default)]
4227 pub upgraded_roots: Vec<AbsolutePathBuf>,
4228}
4229
4230#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4231pub enum McpAuthStatus {
4232 #[serde(rename = "unknown")]
4233 Unknown,
4234 #[serde(rename = "unsupported")]
4235 Unsupported,
4236 #[serde(rename = "notLoggedIn")]
4237 NotLoggedIn,
4238 #[serde(rename = "bearerToken")]
4239 BearerToken,
4240 #[serde(rename = "oAuth")]
4241 OAuth,
4242}
4243
4244#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4245pub enum McpElicitationArrayType {
4246 #[serde(rename = "array")]
4247 Array,
4248}
4249
4250#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4251#[serde(rename_all = "camelCase")]
4252pub struct McpElicitationBooleanSchema {
4253 #[serde(default, skip_serializing_if = "Option::is_none")]
4254 pub default: Option<bool>,
4255 #[serde(default, skip_serializing_if = "Option::is_none")]
4256 pub description: Option<String>,
4257 #[serde(default, skip_serializing_if = "Option::is_none")]
4258 pub title: Option<String>,
4259 #[serde(rename = "type")]
4260 pub type_: McpElicitationBooleanType,
4261}
4262
4263#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4264pub enum McpElicitationBooleanType {
4265 #[serde(rename = "boolean")]
4266 Boolean,
4267}
4268
4269#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4270#[serde(rename_all = "camelCase")]
4271pub struct McpElicitationConstOption {
4272 #[serde(rename = "const", default)]
4273 pub const_: String,
4274 #[serde(default)]
4275 pub title: String,
4276}
4277
4278#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4279#[serde(untagged)]
4280pub enum McpElicitationEnumSchema {
4281 McpElicitationSingleSelectEnumSchema(McpElicitationSingleSelectEnumSchema),
4282 McpElicitationMultiSelectEnumSchema(McpElicitationMultiSelectEnumSchema),
4283 McpElicitationLegacyTitledEnumSchema(McpElicitationLegacyTitledEnumSchema),
4284}
4285
4286#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4287#[serde(rename_all = "camelCase")]
4288pub struct McpElicitationLegacyTitledEnumSchema {
4289 #[serde(default, skip_serializing_if = "Option::is_none")]
4290 pub default: Option<String>,
4291 #[serde(default, skip_serializing_if = "Option::is_none")]
4292 pub description: Option<String>,
4293 #[serde(rename = "enum", default)]
4294 pub enum_: Vec<String>,
4295 #[serde(rename = "enumNames", default, skip_serializing_if = "Option::is_none")]
4296 pub enum_names: Option<Vec<String>>,
4297 #[serde(default, skip_serializing_if = "Option::is_none")]
4298 pub title: Option<String>,
4299 #[serde(rename = "type")]
4300 pub type_: McpElicitationStringType,
4301}
4302
4303#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4304#[serde(untagged)]
4305pub enum McpElicitationMultiSelectEnumSchema {
4306 McpElicitationUntitledMultiSelectEnumSchema(McpElicitationUntitledMultiSelectEnumSchema),
4307 McpElicitationTitledMultiSelectEnumSchema(McpElicitationTitledMultiSelectEnumSchema),
4308}
4309
4310#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4311#[serde(rename_all = "camelCase")]
4312pub struct McpElicitationNumberSchema {
4313 #[serde(default, skip_serializing_if = "Option::is_none")]
4314 pub default: Option<f64>,
4315 #[serde(default, skip_serializing_if = "Option::is_none")]
4316 pub description: Option<String>,
4317 #[serde(default, skip_serializing_if = "Option::is_none")]
4318 pub maximum: Option<f64>,
4319 #[serde(default, skip_serializing_if = "Option::is_none")]
4320 pub minimum: Option<f64>,
4321 #[serde(default, skip_serializing_if = "Option::is_none")]
4322 pub title: Option<String>,
4323 #[serde(rename = "type")]
4324 pub type_: McpElicitationNumberType,
4325}
4326
4327#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4328pub enum McpElicitationNumberType {
4329 #[serde(rename = "number")]
4330 Number,
4331 #[serde(rename = "integer")]
4332 Integer,
4333}
4334
4335#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4336pub enum McpElicitationObjectType {
4337 #[serde(rename = "object")]
4338 Object,
4339}
4340
4341#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4342#[serde(untagged)]
4343pub enum McpElicitationPrimitiveSchema {
4344 McpElicitationEnumSchema(McpElicitationEnumSchema),
4345 McpElicitationStringSchema(McpElicitationStringSchema),
4346 McpElicitationNumberSchema(McpElicitationNumberSchema),
4347 McpElicitationBooleanSchema(McpElicitationBooleanSchema),
4348}
4349
4350#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4351#[serde(rename_all = "camelCase")]
4352pub struct McpElicitationSchema {
4353 #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
4354 pub schema: Option<String>,
4355 #[serde(default)]
4356 pub properties: std::collections::BTreeMap<String, McpElicitationPrimitiveSchema>,
4357 #[serde(default, skip_serializing_if = "Option::is_none")]
4358 pub required: Option<Vec<String>>,
4359 #[serde(rename = "type")]
4360 pub type_: McpElicitationObjectType,
4361}
4362
4363#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4364#[serde(untagged)]
4365pub enum McpElicitationSingleSelectEnumSchema {
4366 McpElicitationUntitledSingleSelectEnumSchema(McpElicitationUntitledSingleSelectEnumSchema),
4367 McpElicitationTitledSingleSelectEnumSchema(McpElicitationTitledSingleSelectEnumSchema),
4368}
4369
4370#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4371pub enum McpElicitationStringFormat {
4372 #[serde(rename = "email")]
4373 Email,
4374 #[serde(rename = "uri")]
4375 Uri,
4376 #[serde(rename = "date")]
4377 Date,
4378 #[serde(rename = "date-time")]
4379 Date_time,
4380}
4381
4382#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4383#[serde(rename_all = "camelCase")]
4384pub struct McpElicitationStringSchema {
4385 #[serde(default, skip_serializing_if = "Option::is_none")]
4386 pub default: Option<String>,
4387 #[serde(default, skip_serializing_if = "Option::is_none")]
4388 pub description: Option<String>,
4389 #[serde(default, skip_serializing_if = "Option::is_none")]
4390 pub format: Option<McpElicitationStringFormat>,
4391 #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
4392 pub max_length: Option<i64>,
4393 #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
4394 pub min_length: Option<i64>,
4395 #[serde(default, skip_serializing_if = "Option::is_none")]
4396 pub title: Option<String>,
4397 #[serde(rename = "type")]
4398 pub type_: McpElicitationStringType,
4399}
4400
4401#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4402pub enum McpElicitationStringType {
4403 #[serde(rename = "string")]
4404 String,
4405}
4406
4407#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4408#[serde(rename_all = "camelCase")]
4409pub struct McpElicitationTitledEnumItems {
4410 #[serde(rename = "anyOf", default)]
4411 pub any_of: Vec<McpElicitationConstOption>,
4412}
4413
4414#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4415#[serde(rename_all = "camelCase")]
4416pub struct McpElicitationTitledMultiSelectEnumSchema {
4417 #[serde(default, skip_serializing_if = "Option::is_none")]
4418 pub default: Option<Vec<String>>,
4419 #[serde(default, skip_serializing_if = "Option::is_none")]
4420 pub description: Option<String>,
4421 #[serde()]
4422 pub items: McpElicitationTitledEnumItems,
4423 #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4424 pub max_items: Option<i64>,
4425 #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4426 pub min_items: Option<i64>,
4427 #[serde(default, skip_serializing_if = "Option::is_none")]
4428 pub title: Option<String>,
4429 #[serde(rename = "type")]
4430 pub type_: McpElicitationArrayType,
4431}
4432
4433#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4434#[serde(rename_all = "camelCase")]
4435pub struct McpElicitationTitledSingleSelectEnumSchema {
4436 #[serde(default, skip_serializing_if = "Option::is_none")]
4437 pub default: Option<String>,
4438 #[serde(default, skip_serializing_if = "Option::is_none")]
4439 pub description: Option<String>,
4440 #[serde(rename = "oneOf", default)]
4441 pub one_of: Vec<McpElicitationConstOption>,
4442 #[serde(default, skip_serializing_if = "Option::is_none")]
4443 pub title: Option<String>,
4444 #[serde(rename = "type")]
4445 pub type_: McpElicitationStringType,
4446}
4447
4448#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4449#[serde(rename_all = "camelCase")]
4450pub struct McpElicitationUntitledEnumItems {
4451 #[serde(rename = "enum", default)]
4452 pub enum_: Vec<String>,
4453 #[serde(rename = "type")]
4454 pub type_: McpElicitationStringType,
4455}
4456
4457#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4458#[serde(rename_all = "camelCase")]
4459pub struct McpElicitationUntitledMultiSelectEnumSchema {
4460 #[serde(default, skip_serializing_if = "Option::is_none")]
4461 pub default: Option<Vec<String>>,
4462 #[serde(default, skip_serializing_if = "Option::is_none")]
4463 pub description: Option<String>,
4464 #[serde()]
4465 pub items: McpElicitationUntitledEnumItems,
4466 #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4467 pub max_items: Option<i64>,
4468 #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4469 pub min_items: Option<i64>,
4470 #[serde(default, skip_serializing_if = "Option::is_none")]
4471 pub title: Option<String>,
4472 #[serde(rename = "type")]
4473 pub type_: McpElicitationArrayType,
4474}
4475
4476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4477#[serde(rename_all = "camelCase")]
4478pub struct McpElicitationUntitledSingleSelectEnumSchema {
4479 #[serde(default, skip_serializing_if = "Option::is_none")]
4480 pub default: Option<String>,
4481 #[serde(default, skip_serializing_if = "Option::is_none")]
4482 pub description: Option<String>,
4483 #[serde(rename = "enum", default)]
4484 pub enum_: Vec<String>,
4485 #[serde(default, skip_serializing_if = "Option::is_none")]
4486 pub title: Option<String>,
4487 #[serde(rename = "type")]
4488 pub type_: McpElicitationStringType,
4489}
4490
4491#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4492#[serde(rename_all = "camelCase")]
4493pub struct McpResourceReadParams {
4494 #[serde(rename = "_meta", default, skip_serializing_if = "Option::is_none")]
4496 pub meta: Option<serde_json::Map<String, Value>>,
4497 #[serde(
4498 rename = "connectorId",
4499 default,
4500 skip_serializing_if = "Option::is_none"
4501 )]
4502 pub connector_id: Option<String>,
4503 #[serde(
4505 rename = "environmentId",
4506 default,
4507 skip_serializing_if = "Option::is_none"
4508 )]
4509 pub environment_id: Option<String>,
4510 #[serde(
4512 rename = "originCallId",
4513 default,
4514 skip_serializing_if = "Option::is_none"
4515 )]
4516 pub origin_call_id: Option<String>,
4517 #[serde(default)]
4518 pub server: String,
4519 #[serde(default, skip_serializing_if = "Option::is_none")]
4521 pub target: Option<McpResourceReadTarget>,
4522 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4523 pub thread_id: Option<String>,
4524 #[serde(default)]
4525 pub uri: String,
4526}
4527
4528#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4530#[serde(rename_all = "camelCase")]
4531pub struct McpResourceReadTarget {
4532 #[serde(rename = "connectorId", default)]
4533 pub connector_id: String,
4534 #[serde(rename = "linkId", default)]
4537 pub link_id: Option<String>,
4538}
4539
4540#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4541#[serde(rename_all = "camelCase")]
4542pub struct McpResourceReadResponse {
4543 #[serde(default)]
4544 pub contents: Vec<ResourceContent>,
4545 #[serde(
4548 rename = "originCallId",
4549 default,
4550 skip_serializing_if = "Option::is_none"
4551 )]
4552 pub origin_call_id: Option<String>,
4553}
4554
4555#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4556pub enum McpServerElicitationAction {
4557 #[serde(rename = "accept")]
4558 Accept,
4559 #[serde(rename = "decline")]
4560 Decline,
4561 #[serde(rename = "cancel")]
4562 Cancel,
4563}
4564
4565#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4566#[serde(tag = "mode", rename_all = "camelCase")]
4567pub enum McpServerElicitationRequestParams {
4568 Form {
4569 #[serde(default, skip_serializing_if = "Option::is_none")]
4570 _meta: Option<Value>,
4571 message: String,
4572 #[serde(rename = "requestedSchema")]
4573 requested_schema: McpElicitationSchema,
4574 },
4575 #[serde(rename = "openai/form")]
4576 OpenaiForm {
4577 #[serde(default, skip_serializing_if = "Option::is_none")]
4578 _meta: Option<Value>,
4579 message: String,
4580 #[serde(rename = "requestedSchema")]
4581 requested_schema: Value,
4582 },
4583 #[serde(rename = "openaiForm")]
4584 OpenAiElicitationForm {
4585 #[serde(default, skip_serializing_if = "Option::is_none")]
4586 _meta: Option<Value>,
4587 message: String,
4588 #[serde(rename = "requestedSchema")]
4589 requested_schema: Value,
4590 },
4591 Url {
4592 #[serde(default, skip_serializing_if = "Option::is_none")]
4593 _meta: Option<Value>,
4594 #[serde(rename = "elicitationId")]
4595 elicitation_id: String,
4596 message: String,
4597 url: String,
4598 },
4599}
4600
4601#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4602#[serde(rename_all = "camelCase")]
4603pub struct McpServerElicitationRequestResponse {
4604 #[serde(default, skip_serializing_if = "Option::is_none")]
4605 pub _meta: Option<Value>,
4606 #[serde()]
4607 pub action: McpServerElicitationAction,
4608 #[serde(default, skip_serializing_if = "Option::is_none")]
4609 pub content: Option<Value>,
4610}
4611
4612#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4613#[serde(rename_all = "camelCase")]
4614pub struct McpServerInfo {
4615 #[serde(default, skip_serializing_if = "Option::is_none")]
4616 pub description: Option<String>,
4617 #[serde(default, skip_serializing_if = "Option::is_none")]
4618 pub icons: Option<Vec<Value>>,
4619 #[serde(default)]
4620 pub name: String,
4621 #[serde(default, skip_serializing_if = "Option::is_none")]
4622 pub title: Option<String>,
4623 #[serde(default)]
4624 pub version: String,
4625 #[serde(
4626 rename = "websiteUrl",
4627 default,
4628 skip_serializing_if = "Option::is_none"
4629 )]
4630 pub website_url: Option<String>,
4631}
4632
4633#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4634#[serde(rename_all = "camelCase")]
4635pub struct McpServerMigration {
4636 #[serde(default)]
4637 pub name: String,
4638}
4639
4640#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4641#[serde(rename_all = "camelCase")]
4642pub struct McpServerOauthLoginCompletedNotification {
4643 #[serde(default, skip_serializing_if = "Option::is_none")]
4644 pub error: Option<String>,
4645 #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4647 pub login_id: Option<String>,
4648 #[serde(default)]
4649 pub name: String,
4650 #[serde(default)]
4651 pub success: bool,
4652 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4653 pub thread_id: Option<String>,
4654}
4655
4656#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4657#[serde(rename_all = "camelCase")]
4658pub struct McpServerOauthLoginParams {
4659 #[serde(
4660 rename = "clientRegistration",
4661 default,
4662 skip_serializing_if = "Option::is_none"
4663 )]
4664 pub client_registration: Option<McpServerOauthClientRegistration>,
4665 #[serde(
4667 rename = "environmentId",
4668 default,
4669 skip_serializing_if = "Option::is_none"
4670 )]
4671 pub environment_id: Option<String>,
4672 #[serde(default)]
4673 pub name: String,
4674 #[serde(default, skip_serializing_if = "Option::is_none")]
4675 pub scopes: Option<Vec<String>>,
4676 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4677 pub thread_id: Option<String>,
4678 #[serde(
4679 rename = "timeoutSecs",
4680 default,
4681 skip_serializing_if = "Option::is_none"
4682 )]
4683 pub timeout_secs: Option<i64>,
4684}
4685
4686#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4687#[serde(rename_all = "camelCase")]
4688pub struct McpServerOauthLoginResponse {
4689 #[serde(rename = "authorizationUrl", default)]
4690 pub authorization_url: String,
4691 #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4695 pub login_id: Option<String>,
4696}
4697
4698#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4699#[serde(rename_all = "camelCase")]
4700pub struct McpServerRefreshResponse {
4701 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4702 pub extra: serde_json::Map<String, Value>,
4703}
4704
4705#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4706pub enum McpServerStartupFailureReason {
4707 #[serde(rename = "reauthenticationRequired")]
4708 ReauthenticationRequired,
4709}
4710
4711#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4712pub enum McpServerStartupState {
4713 #[serde(rename = "starting")]
4714 Starting,
4715 #[serde(rename = "ready")]
4716 Ready,
4717 #[serde(rename = "failed")]
4718 Failed,
4719 #[serde(rename = "cancelled")]
4720 Cancelled,
4721}
4722
4723#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4724#[serde(rename_all = "camelCase")]
4725pub struct McpServerStatus {
4726 #[serde(rename = "authStatus")]
4727 pub auth_status: McpAuthStatus,
4728 #[serde(
4731 rename = "environmentId",
4732 default,
4733 skip_serializing_if = "Option::is_none"
4734 )]
4735 pub environment_id: Option<String>,
4736 #[serde(
4740 rename = "httpOrigin",
4741 default,
4742 skip_serializing_if = "Option::is_none"
4743 )]
4744 pub http_origin: Option<String>,
4745 #[serde(
4747 rename = "runtimeStatus",
4748 default,
4749 skip_serializing_if = "Option::is_none"
4750 )]
4751 pub runtime_status: Option<McpServerConnectionStatus>,
4752 #[serde(default)]
4753 pub name: String,
4754 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
4755 pub plugin_id: Option<String>,
4756 #[serde(rename = "resourceTemplates", default)]
4757 pub resource_templates: Vec<ResourceTemplate>,
4758 #[serde(default)]
4759 pub resources: Vec<Resource>,
4760 #[serde(
4763 rename = "serverCapabilities",
4764 default,
4765 skip_serializing_if = "Option::is_none"
4766 )]
4767 pub server_capabilities: Option<Value>,
4768 #[serde(
4769 rename = "serverInfo",
4770 default,
4771 skip_serializing_if = "Option::is_none"
4772 )]
4773 pub server_info: Option<McpServerInfo>,
4774 #[serde(
4777 rename = "toolListMeta",
4778 default,
4779 skip_serializing_if = "Option::is_none"
4780 )]
4781 pub tool_list_meta: Option<Value>,
4782 #[serde(default)]
4783 pub tools: std::collections::BTreeMap<String, Tool>,
4784 #[serde(
4787 rename = "toolsError",
4788 default,
4789 skip_serializing_if = "Option::is_none"
4790 )]
4791 pub tools_error: Option<String>,
4792}
4793
4794#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4795pub enum McpServerStatusDetail {
4796 #[serde(rename = "full")]
4797 Full,
4798 #[serde(rename = "toolsAndAuthOnly")]
4799 ToolsAndAuthOnly,
4800}
4801
4802#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4803#[serde(rename_all = "camelCase")]
4804pub struct McpServerStatusUpdatedNotification {
4805 #[serde(
4807 rename = "environmentId",
4808 default,
4809 skip_serializing_if = "Option::is_none"
4810 )]
4811 pub environment_id: Option<String>,
4812 #[serde(default, skip_serializing_if = "Option::is_none")]
4813 pub error: Option<String>,
4814 #[serde(
4815 rename = "failureReason",
4816 default,
4817 skip_serializing_if = "Option::is_none"
4818 )]
4819 pub failure_reason: Option<McpServerStartupFailureReason>,
4820 #[serde(default)]
4821 pub name: String,
4822 #[serde()]
4823 pub status: McpServerStartupState,
4824 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4825 pub thread_id: Option<String>,
4826}
4827
4828#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4829#[serde(rename_all = "camelCase")]
4830pub struct McpServerToolCallParams {
4831 #[serde(default, skip_serializing_if = "Option::is_none")]
4832 pub _meta: Option<Value>,
4833 #[serde(default, skip_serializing_if = "Option::is_none")]
4834 pub arguments: Option<Value>,
4835 #[serde(
4837 rename = "environmentId",
4838 default,
4839 skip_serializing_if = "Option::is_none"
4840 )]
4841 pub environment_id: Option<String>,
4842 #[serde(default)]
4843 pub server: String,
4844 #[serde(rename = "threadId", default)]
4845 pub thread_id: String,
4846 #[serde(default)]
4847 pub tool: String,
4848}
4849
4850#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4851#[serde(rename_all = "camelCase")]
4852pub struct McpServerToolCallResponse {
4853 #[serde(default, skip_serializing_if = "Option::is_none")]
4854 pub _meta: Option<Value>,
4855 #[serde(default)]
4856 pub content: Vec<Value>,
4857 #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
4858 pub is_error: Option<bool>,
4859 #[serde(
4860 rename = "structuredContent",
4861 default,
4862 skip_serializing_if = "Option::is_none"
4863 )]
4864 pub structured_content: Option<Value>,
4865}
4866
4867#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
4870#[serde(rename_all = "camelCase")]
4871pub struct McpAppUi {
4872 #[serde(rename = "resourceUri")]
4873 pub resource_uri: String,
4874 #[serde(rename = "preferredModelDisplayMode")]
4875 pub preferred_model_display_mode: McpAppDisplayMode,
4876}
4877
4878#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4879pub enum McpAppDisplayMode {
4880 #[serde(rename = "inline")]
4881 Inline,
4882 #[serde(rename = "fullscreen")]
4883 Fullscreen,
4884}
4885
4886#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4887#[serde(rename_all = "camelCase")]
4888pub struct McpToolCallAppContext {
4889 #[serde(
4890 rename = "actionName",
4891 default,
4892 skip_serializing_if = "Option::is_none"
4893 )]
4894 pub action_name: Option<String>,
4895 #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
4896 pub app_name: Option<String>,
4897 #[serde(rename = "connectorId", default)]
4898 pub connector_id: String,
4899 #[serde(rename = "linkId", default, skip_serializing_if = "Option::is_none")]
4900 pub link_id: Option<String>,
4901 #[serde(
4902 rename = "resourceUri",
4903 default,
4904 skip_serializing_if = "Option::is_none"
4905 )]
4906 pub resource_uri: Option<String>,
4907}
4908
4909#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4910#[serde(rename_all = "camelCase")]
4911pub struct McpToolCallError {
4912 #[serde(default)]
4913 pub message: String,
4914}
4915
4916#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4917#[serde(rename_all = "camelCase")]
4918pub struct McpToolCallProgressNotification {
4919 #[serde(rename = "itemId", default)]
4920 pub item_id: String,
4921 #[serde(default)]
4922 pub message: String,
4923 #[serde(rename = "threadId", default)]
4924 pub thread_id: String,
4925 #[serde(rename = "turnId", default)]
4926 pub turn_id: String,
4927}
4928
4929#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4930#[serde(rename_all = "camelCase")]
4931pub struct McpToolCallResult {
4932 #[serde(default, skip_serializing_if = "Option::is_none")]
4933 pub _meta: Option<Value>,
4934 #[serde(default)]
4935 pub content: Vec<Value>,
4936 #[serde(
4937 rename = "structuredContent",
4938 default,
4939 skip_serializing_if = "Option::is_none"
4940 )]
4941 pub structured_content: Option<Value>,
4942}
4943
4944#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4945pub enum McpToolCallStatus {
4946 #[serde(rename = "inProgress")]
4947 InProgress,
4948 #[serde(rename = "completed")]
4949 Completed,
4950 #[serde(rename = "failed")]
4951 Failed,
4952}
4953
4954#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4955#[serde(rename_all = "camelCase")]
4956pub struct MemoryCitation {
4957 #[serde(default)]
4958 pub entries: Vec<MemoryCitationEntry>,
4959 #[serde(rename = "threadIds", default)]
4960 pub thread_ids: Vec<String>,
4961}
4962
4963#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4964#[serde(rename_all = "camelCase")]
4965pub struct MemoryCitationEntry {
4966 #[serde(rename = "lineEnd", default)]
4967 pub line_end: i64,
4968 #[serde(rename = "lineStart", default)]
4969 pub line_start: i64,
4970 #[serde(default)]
4971 pub note: String,
4972 #[serde(default)]
4973 pub path: String,
4974}
4975
4976#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4977pub enum MergeStrategy {
4978 #[serde(rename = "replace")]
4979 Replace,
4980 #[serde(rename = "upsert")]
4981 Upsert,
4982}
4983
4984#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4985pub enum MessagePhase {
4986 #[serde(rename = "commentary")]
4987 Commentary,
4988 #[serde(rename = "partial_answer")]
4991 PartialAnswer,
4992 #[serde(rename = "final_answer")]
4993 FinalAnswer,
4994}
4995
4996#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4997#[serde(rename_all = "camelCase")]
4998pub struct MigrationDetails {
4999 #[serde(default, skip_serializing_if = "Option::is_none")]
5000 pub commands: Option<Vec<CommandMigration>>,
5001 #[serde(default, skip_serializing_if = "Option::is_none")]
5002 pub hooks: Option<Vec<HookMigration>>,
5003 #[serde(
5004 rename = "mcpServers",
5005 default,
5006 skip_serializing_if = "Option::is_none"
5007 )]
5008 pub mcp_servers: Option<Vec<McpServerMigration>>,
5009 #[serde(default, skip_serializing_if = "Option::is_none")]
5010 pub memory: Option<Vec<String>>,
5011 #[serde(default, skip_serializing_if = "Option::is_none")]
5012 pub plugins: Option<Vec<PluginsMigration>>,
5013 #[serde(default, skip_serializing_if = "Option::is_none")]
5014 pub sessions: Option<Vec<SessionMigration>>,
5015 #[serde(default, skip_serializing_if = "Option::is_none")]
5016 pub skills: Option<Vec<SkillMigration>>,
5017 #[serde(default, skip_serializing_if = "Option::is_none")]
5018 pub subagents: Option<Vec<SubagentMigration>>,
5019}
5020
5021#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5024#[serde(rename_all = "camelCase")]
5025pub struct MisalignmentErrorDetails {
5026 #[serde(
5027 rename = "detailedExplanation",
5028 default,
5029 skip_serializing_if = "Option::is_none"
5030 )]
5031 pub detailed_explanation: Option<String>,
5032 #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
5034 pub error_type: Option<String>,
5035 #[serde(
5038 rename = "reviewTarget",
5039 default,
5040 skip_serializing_if = "Option::is_none"
5041 )]
5042 pub review_target: Option<String>,
5043 #[serde(default, skip_serializing_if = "Option::is_none")]
5046 pub steer: Option<MisalignmentSteer>,
5047}
5048
5049#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5051#[serde(rename_all = "camelCase")]
5052pub struct MisalignmentSteer {
5053 #[serde(default)]
5054 pub message: String,
5055}
5056
5057#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5058pub enum ModeKind {
5059 #[serde(rename = "plan")]
5060 Plan,
5061 #[serde(rename = "default")]
5062 Default,
5063}
5064
5065#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5066#[serde(rename_all = "camelCase")]
5067pub struct Model {
5068 #[serde(
5069 rename = "additionalSpeedTiers",
5070 default,
5071 skip_serializing_if = "Option::is_none"
5072 )]
5073 pub additional_speed_tiers: Option<Vec<String>>,
5074 #[serde(
5075 rename = "availabilityNux",
5076 default,
5077 skip_serializing_if = "Option::is_none"
5078 )]
5079 pub availability_nux: Option<ModelAvailabilityNux>,
5080 #[serde(
5082 rename = "availableAccessPrograms",
5083 default,
5084 skip_serializing_if = "Option::is_none"
5085 )]
5086 pub available_access_programs: Option<ModelAccessPrograms>,
5087 #[serde(rename = "defaultReasoningEffort")]
5088 pub default_reasoning_effort: ReasoningEffort,
5089 #[serde(
5090 rename = "defaultServiceTier",
5091 default,
5092 skip_serializing_if = "Option::is_none"
5093 )]
5094 pub default_service_tier: Option<String>,
5095 #[serde(default)]
5096 pub description: String,
5097 #[serde(rename = "displayName", default)]
5098 pub display_name: String,
5099 #[serde(default)]
5100 pub hidden: bool,
5101 #[serde(default)]
5102 pub id: String,
5103 #[serde(
5104 rename = "inputModalities",
5105 default,
5106 skip_serializing_if = "Option::is_none"
5107 )]
5108 pub input_modalities: Option<Vec<InputModality>>,
5109 #[serde(rename = "isDefault", default)]
5110 pub is_default: bool,
5111 #[serde(default)]
5112 pub model: String,
5113 #[serde(
5114 rename = "modelSpecialty",
5115 default,
5116 skip_serializing_if = "Option::is_none"
5117 )]
5118 pub model_specialty: Option<String>,
5119 #[serde(
5120 rename = "multiAgentVersion",
5121 default,
5122 skip_serializing_if = "Option::is_none"
5123 )]
5124 pub multi_agent_version: Option<MultiAgentVersion>,
5125 #[serde(
5126 rename = "serviceTiers",
5127 default,
5128 skip_serializing_if = "Option::is_none"
5129 )]
5130 pub service_tiers: Option<Vec<ModelServiceTier>>,
5131 #[serde(rename = "supportedReasoningEfforts", default)]
5132 pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
5133 #[serde(
5136 rename = "supportsPersonality",
5137 default,
5138 skip_serializing_if = "Option::is_none"
5139 )]
5140 pub supports_personality: Option<bool>,
5141 #[serde(default, skip_serializing_if = "Option::is_none")]
5142 pub upgrade: Option<String>,
5143 #[serde(
5144 rename = "upgradeInfo",
5145 default,
5146 skip_serializing_if = "Option::is_none"
5147 )]
5148 pub upgrade_info: Option<ModelUpgradeInfo>,
5149}
5150
5151#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5153#[serde(rename_all = "camelCase")]
5154pub struct ModelAccessPrograms {
5155 #[serde(default)]
5157 pub cyber: Vec<CyberAccessProgram>,
5158}
5159
5160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5161#[serde(rename_all = "camelCase")]
5162pub struct ModelAvailabilityNux {
5163 #[serde(default)]
5164 pub message: String,
5165}
5166
5167#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5168#[serde(rename_all = "camelCase")]
5169pub struct ModelListParams {
5170 #[serde(default, skip_serializing_if = "Option::is_none")]
5171 pub cursor: Option<String>,
5172 #[serde(
5173 rename = "includeHidden",
5174 default,
5175 skip_serializing_if = "Option::is_none"
5176 )]
5177 pub include_hidden: Option<bool>,
5178 #[serde(default, skip_serializing_if = "Option::is_none")]
5179 pub limit: Option<i64>,
5180 #[serde(
5183 rename = "modelProvider",
5184 default,
5185 skip_serializing_if = "Option::is_none"
5186 )]
5187 pub model_provider: Option<String>,
5188}
5189
5190#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5191#[serde(rename_all = "camelCase")]
5192pub struct ModelListResponse {
5193 #[serde(default)]
5194 pub data: Vec<Model>,
5195 #[serde(
5196 rename = "nextCursor",
5197 default,
5198 skip_serializing_if = "Option::is_none"
5199 )]
5200 pub next_cursor: Option<String>,
5201}
5202
5203#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5204#[serde(rename_all = "camelCase")]
5205pub struct ModelProviderCapabilitiesReadParams {
5206 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5207 pub extra: serde_json::Map<String, Value>,
5208}
5209
5210#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5211#[serde(rename_all = "camelCase")]
5212pub struct ModelProviderCapabilitiesReadResponse {
5213 #[serde(rename = "imageGeneration", default)]
5214 pub image_generation: bool,
5215 #[serde(rename = "webSearch", default)]
5216 pub web_search: bool,
5217}
5218
5219#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5221#[serde(rename_all = "camelCase")]
5222pub struct ModelProviderListParams {
5223 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5224 pub extra: serde_json::Map<String, Value>,
5225}
5226
5227#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5229#[serde(rename_all = "camelCase")]
5230pub struct ModelProviderListResponse {
5231 pub data: Vec<ModelProviderSummary>,
5232 #[serde(rename = "defaultProviderId")]
5233 pub default_provider_id: String,
5234 #[serde(rename = "canChangeDefault")]
5235 pub can_change_default: bool,
5236}
5237
5238#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5240#[serde(rename_all = "camelCase")]
5241pub struct ModelProviderSummary {
5242 pub id: String,
5243 pub name: String,
5244 #[serde(rename = "canEdit")]
5246 pub can_edit: bool,
5247 #[serde(rename = "baseUrl", default)]
5249 pub base_url: Option<String>,
5250 pub settings: ProviderSettings,
5251}
5252
5253#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5255#[serde(tag = "type", rename_all = "camelCase")]
5256pub enum ProviderSettings {
5257 #[serde(rename = "openai")]
5258 OpenAi,
5259 #[serde(rename = "customGateway")]
5260 CustomGateway { auth: GatewayAuth },
5261 #[serde(rename = "bedrock")]
5262 Bedrock {
5263 #[serde(default)]
5264 profile: Option<String>,
5265 #[serde(default)]
5266 region: Option<String>,
5267 },
5268 #[serde(rename = "gcp")]
5269 Gcp {
5270 #[serde(rename = "projectId", default)]
5271 project_id: Option<String>,
5272 #[serde(default)]
5273 location: Option<String>,
5274 #[serde(rename = "credentialFile", default)]
5276 credential_file: Option<String>,
5277 },
5278}
5279
5280#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5282#[serde(tag = "mode", rename_all = "camelCase")]
5283pub enum GatewayAuth {
5284 #[serde(rename = "none")]
5285 None,
5286 #[serde(rename = "environmentVariable")]
5287 EnvironmentVariable {
5288 #[serde(rename = "envKey")]
5289 env_key: String,
5290 },
5291 #[serde(rename = "externallyConfigured")]
5293 ExternallyConfigured {
5294 #[serde(rename = "envKey", default)]
5295 env_key: Option<String>,
5296 },
5297}
5298
5299#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5301#[serde(rename_all = "camelCase")]
5302pub struct ModelProviderConfigWriteParams {
5303 pub settings: ProviderSettingsPatch,
5304}
5305
5306#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5309#[serde(rename_all = "camelCase")]
5310pub struct ModelProviderDefaultSetParams {
5311 pub provider_id: String,
5314}
5315
5316#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5318#[serde(rename_all = "camelCase")]
5319pub struct ModelProviderConfigWriteResponse {
5320 pub provider: ModelProviderSummary,
5321}
5322
5323#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5328#[serde(tag = "type", rename_all = "camelCase")]
5329pub enum ProviderSettingsPatch {
5330 #[serde(rename = "customGateway")]
5331 CustomGateway {
5332 #[serde(
5334 rename = "providerId",
5335 default,
5336 skip_serializing_if = "Option::is_none"
5337 )]
5338 provider_id: Option<String>,
5339 #[serde(
5341 default,
5342 deserialize_with = "deserialize_patch_name",
5343 skip_serializing_if = "Option::is_none"
5344 )]
5345 name: Option<String>,
5346 #[serde(
5347 rename = "baseUrl",
5348 default,
5349 deserialize_with = "deserialize_patch_field",
5350 skip_serializing_if = "Option::is_none"
5351 )]
5352 base_url: Option<Option<String>>,
5353 #[serde(
5354 rename = "envKey",
5355 default,
5356 deserialize_with = "deserialize_patch_field",
5357 skip_serializing_if = "Option::is_none"
5358 )]
5359 env_key: Option<Option<String>>,
5360 },
5361 #[serde(rename = "bedrock")]
5363 Bedrock {
5364 #[serde(rename = "providerId")]
5365 provider_id: BedrockProviderId,
5366 #[serde(
5367 default,
5368 deserialize_with = "deserialize_patch_field",
5369 skip_serializing_if = "Option::is_none"
5370 )]
5371 profile: Option<Option<String>>,
5372 #[serde(
5373 default,
5374 deserialize_with = "deserialize_patch_field",
5375 skip_serializing_if = "Option::is_none"
5376 )]
5377 region: Option<Option<String>>,
5378 },
5379 #[serde(rename = "gcp")]
5381 Gcp {
5382 #[serde(rename = "providerId")]
5383 provider_id: GcpProviderId,
5384 #[serde(
5385 rename = "projectId",
5386 default,
5387 deserialize_with = "deserialize_patch_field",
5388 skip_serializing_if = "Option::is_none"
5389 )]
5390 project_id: Option<Option<String>>,
5391 #[serde(
5392 default,
5393 deserialize_with = "deserialize_patch_field",
5394 skip_serializing_if = "Option::is_none"
5395 )]
5396 location: Option<Option<String>>,
5397 #[serde(
5398 rename = "credentialFile",
5399 default,
5400 deserialize_with = "deserialize_patch_field",
5401 skip_serializing_if = "Option::is_none"
5402 )]
5403 credential_file: Option<Option<String>>,
5404 },
5405}
5406
5407fn deserialize_patch_field<'de, D>(deserializer: D) -> Result<Option<Option<String>>, D::Error>
5409where
5410 D: serde::Deserializer<'de>,
5411{
5412 Option::<String>::deserialize(deserializer).map(Some)
5413}
5414
5415fn deserialize_patch_name<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
5417where
5418 D: serde::Deserializer<'de>,
5419{
5420 String::deserialize(deserializer).map(Some)
5421}
5422
5423#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
5425pub enum BedrockProviderId {
5426 #[serde(rename = "amazon-bedrock")]
5427 AmazonBedrock,
5428 #[serde(rename = "amazon-bedrock-runtime")]
5429 AmazonBedrockRuntime,
5430}
5431
5432#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
5434pub enum GcpProviderId {
5435 #[serde(rename = "gcp")]
5436 Gcp,
5437}
5438
5439#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5444#[serde(tag = "type", rename_all = "camelCase")]
5445pub enum ModelProviderError {
5446 #[serde(rename = "modelProviderMismatch")]
5447 ModelProviderMismatch {
5448 #[serde(rename = "modelProvider")]
5449 model_provider: String,
5450 #[serde(rename = "currentModelProvider")]
5451 current_model_provider: String,
5452 },
5453 #[serde(rename = "modelProviderNotConfigured")]
5454 ModelProviderNotConfigured {
5455 #[serde(rename = "modelProvider")]
5456 model_provider: String,
5457 },
5458 #[serde(rename = "modelProviderPolicyConflict")]
5459 ModelProviderPolicyConflict {
5460 #[serde(rename = "modelProvider")]
5461 model_provider: String,
5462 #[serde(rename = "requiredModelProvider")]
5463 required_model_provider: String,
5464 },
5465}
5466
5467#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5468pub enum ModelRerouteReason {
5469 #[serde(rename = "highRiskCyberActivity")]
5470 HighRiskCyberActivity,
5471}
5472
5473#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5474#[serde(rename_all = "camelCase")]
5475pub struct ModelReroutedNotification {
5476 #[serde(rename = "fromModel", default)]
5477 pub from_model: String,
5478 #[serde()]
5479 pub reason: ModelRerouteReason,
5480 #[serde(rename = "threadId", default)]
5481 pub thread_id: String,
5482 #[serde(rename = "toModel", default)]
5483 pub to_model: String,
5484 #[serde(rename = "turnId", default)]
5485 pub turn_id: String,
5486}
5487
5488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5489#[serde(rename_all = "camelCase")]
5490pub struct ModelSafetyBufferingUpdatedNotification {
5491 #[serde(
5492 rename = "fasterModel",
5493 default,
5494 skip_serializing_if = "Option::is_none"
5495 )]
5496 pub faster_model: Option<String>,
5497 #[serde(default)]
5498 pub model: String,
5499 #[serde(default)]
5500 pub reasons: Vec<String>,
5501 #[serde(rename = "showBufferingUi", default)]
5502 pub show_buffering_ui: bool,
5503 #[serde(rename = "threadId", default)]
5504 pub thread_id: String,
5505 #[serde(rename = "turnId", default)]
5506 pub turn_id: String,
5507 #[serde(rename = "useCases", default)]
5508 pub use_cases: Vec<String>,
5509}
5510
5511#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5512#[serde(rename_all = "camelCase")]
5513pub struct ModelServiceTier {
5514 #[serde(default)]
5515 pub description: String,
5516 #[serde(default)]
5517 pub id: String,
5518 #[serde(default)]
5519 pub name: String,
5520}
5521
5522#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5523#[serde(rename_all = "camelCase")]
5524pub struct ModelUpgradeInfo {
5525 #[serde(
5526 rename = "migrationMarkdown",
5527 default,
5528 skip_serializing_if = "Option::is_none"
5529 )]
5530 pub migration_markdown: Option<String>,
5531 #[serde(default)]
5532 pub model: String,
5533 #[serde(
5536 rename = "retirementAt",
5537 default,
5538 skip_serializing_if = "Option::is_none"
5539 )]
5540 pub retirement_at: Option<i64>,
5541 #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
5542 pub model_link: Option<String>,
5543 #[serde(
5544 rename = "upgradeCopy",
5545 default,
5546 skip_serializing_if = "Option::is_none"
5547 )]
5548 pub upgrade_copy: Option<String>,
5549}
5550
5551#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5552pub enum ModelVerification {
5553 #[serde(rename = "trustedAccessForCyber")]
5554 TrustedAccessForCyber,
5555}
5556
5557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5558#[serde(rename_all = "camelCase")]
5559pub struct ModelVerificationNotification {
5560 #[serde(rename = "threadId", default)]
5561 pub thread_id: String,
5562 #[serde(rename = "turnId", default)]
5563 pub turn_id: String,
5564 #[serde(default)]
5565 pub verifications: Vec<ModelVerification>,
5566}
5567
5568#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5569#[serde(rename_all = "camelCase")]
5570pub struct ModelsRequirements {
5571 #[serde(rename = "newThread", default, skip_serializing_if = "Option::is_none")]
5572 pub new_thread: Option<NewThreadModelDefaults>,
5573}
5574
5575#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5576pub enum MultiAgentVersion {
5577 #[serde(rename = "disabled")]
5578 Disabled,
5579 #[serde(rename = "v1")]
5580 V1,
5581 #[serde(rename = "v2")]
5582 V2,
5583}
5584
5585#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5586pub enum NetworkAccess {
5587 #[serde(rename = "restricted")]
5588 Restricted,
5589 #[serde(rename = "enabled")]
5590 Enabled,
5591}
5592
5593#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5594#[serde(rename_all = "camelCase")]
5595pub struct NetworkApprovalContext {
5596 #[serde(default)]
5597 pub host: String,
5598 #[serde()]
5599 pub protocol: NetworkApprovalProtocol,
5600}
5601
5602#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5603pub enum NetworkApprovalProtocol {
5604 #[serde(rename = "http")]
5605 Http,
5606 #[serde(rename = "https")]
5607 Https,
5608 #[serde(rename = "socks5Tcp")]
5609 Socks5Tcp,
5610 #[serde(rename = "socks5Udp")]
5611 Socks5Udp,
5612}
5613
5614#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5615#[serde(rename_all = "camelCase")]
5616pub struct NetworkPolicyAmendment {
5617 #[serde()]
5618 pub action: NetworkPolicyRuleAction,
5619 #[serde(default)]
5620 pub host: String,
5621}
5622
5623#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5624pub enum NetworkPolicyRuleAction {
5625 #[serde(rename = "allow")]
5626 Allow,
5627 #[serde(rename = "deny")]
5628 Deny,
5629}
5630
5631#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5632#[serde(rename_all = "camelCase")]
5633pub struct NewThreadModelDefaults {
5634 #[serde(default, skip_serializing_if = "Option::is_none")]
5635 pub model: Option<String>,
5636 #[serde(
5637 rename = "modelReasoningEffort",
5638 default,
5639 skip_serializing_if = "Option::is_none"
5640 )]
5641 pub model_reasoning_effort: Option<ReasoningEffort>,
5642 #[serde(
5643 rename = "serviceTier",
5644 default,
5645 skip_serializing_if = "Option::is_none"
5646 )]
5647 pub service_tier: Option<String>,
5648}
5649
5650#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5651pub enum NonSteerableTurnKind {
5652 #[serde(rename = "review")]
5653 Review,
5654 #[serde(rename = "compact")]
5655 Compact,
5656}
5657
5658#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5660#[serde(rename_all = "kebab-case")]
5661pub enum OtelExporter {
5662 None,
5663 Statsig,
5664 OtlpHttp {
5665 endpoint: String,
5666 headers: std::collections::BTreeMap<String, String>,
5668 protocol: OtelHttpProtocol,
5669 #[serde(default, skip_serializing_if = "Option::is_none")]
5670 tls: Option<OtelTlsConfig>,
5671 },
5672 OtlpGrpc {
5673 endpoint: String,
5674 headers: std::collections::BTreeMap<String, String>,
5676 #[serde(default, skip_serializing_if = "Option::is_none")]
5677 tls: Option<OtelTlsConfig>,
5678 },
5679}
5680
5681#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5682#[serde(rename_all = "kebab-case")]
5683pub enum OtelHttpProtocol {
5684 Binary,
5685 Json,
5686}
5687
5688#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5691#[serde(rename_all = "snake_case")]
5692pub struct OtelRequirements {
5693 #[serde(default, skip_serializing_if = "Option::is_none")]
5697 pub headers_helper: Option<String>,
5698 #[serde(default, skip_serializing_if = "Option::is_none")]
5701 pub headers_helper_refresh_interval_ms: Option<std::num::NonZeroU64>,
5702 #[serde(default, skip_serializing_if = "Option::is_none")]
5703 pub tool_result: Option<OtelToolResultLogConfig>,
5704 #[serde(default, skip_serializing_if = "Option::is_none")]
5705 pub log_sse_deltas: Option<bool>,
5706 #[serde(default, skip_serializing_if = "Option::is_none")]
5707 pub log_user_prompt: Option<bool>,
5708 #[serde(default, skip_serializing_if = "Option::is_none")]
5709 pub log_agent_responses: Option<bool>,
5710 #[serde(default, skip_serializing_if = "Option::is_none")]
5711 pub log_guardian_assessments: Option<bool>,
5712 #[serde(default, skip_serializing_if = "Option::is_none")]
5713 pub environment: Option<String>,
5714 #[serde(default, skip_serializing_if = "Option::is_none")]
5715 pub exporter: Option<OtelExporter>,
5716 #[serde(default, skip_serializing_if = "Option::is_none")]
5717 pub trace_exporter: Option<OtelExporter>,
5718 #[serde(default, skip_serializing_if = "Option::is_none")]
5719 pub metrics_exporter: Option<OtelExporter>,
5720 #[serde(default, skip_serializing_if = "Option::is_none")]
5721 pub span_attributes: Option<std::collections::BTreeMap<String, String>>,
5722 #[serde(default, skip_serializing_if = "Option::is_none")]
5723 pub tracestate:
5724 Option<std::collections::BTreeMap<String, std::collections::BTreeMap<String, String>>>,
5725}
5726
5727#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
5728#[serde(rename_all = "kebab-case")]
5729pub struct OtelTlsConfig {
5730 #[serde(default, skip_serializing_if = "Option::is_none")]
5731 pub ca_certificate: Option<String>,
5732 #[serde(default, skip_serializing_if = "Option::is_none")]
5733 pub client_certificate: Option<String>,
5734 #[serde(default, skip_serializing_if = "Option::is_none")]
5735 pub client_private_key: Option<String>,
5736}
5737
5738#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
5739#[serde(rename_all = "snake_case")]
5740pub struct OtelToolResultLogConfig {
5741 pub max_bytes: u64,
5742}
5743
5744#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5745#[serde(rename_all = "camelCase")]
5746pub struct OverriddenMetadata {
5747 #[serde(rename = "effectiveValue", default)]
5748 pub effective_value: Value,
5749 #[serde(default)]
5750 pub message: String,
5751 #[serde(rename = "overridingLayer")]
5752 pub overriding_layer: ConfigLayerMetadata,
5753}
5754
5755#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5756#[serde(tag = "type", rename_all = "camelCase")]
5757pub enum ParsedCommand {
5758 Read {
5759 cmd: String,
5760 name: String,
5761 path: String,
5762 },
5763 List_files {
5764 cmd: String,
5765 #[serde(default, skip_serializing_if = "Option::is_none")]
5766 path: Option<String>,
5767 },
5768 Search {
5769 cmd: String,
5770 #[serde(default, skip_serializing_if = "Option::is_none")]
5771 path: Option<String>,
5772 #[serde(default, skip_serializing_if = "Option::is_none")]
5773 query: Option<String>,
5774 },
5775 Unknown {
5776 cmd: String,
5777 },
5778}
5779
5780#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5781pub enum PatchApplyStatus {
5782 #[serde(rename = "inProgress")]
5783 InProgress,
5784 #[serde(rename = "completed")]
5785 Completed,
5786 #[serde(rename = "failed")]
5787 Failed,
5788 #[serde(rename = "declined")]
5789 Declined,
5790}
5791
5792#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5793#[serde(tag = "type", rename_all = "camelCase")]
5794pub enum PatchChangeKind {
5795 Add,
5796 Delete,
5797 Update {
5798 #[serde(default, skip_serializing_if = "Option::is_none")]
5799 move_path: Option<String>,
5800 },
5801}
5802
5803#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5804pub enum PermissionGrantScope {
5805 #[serde(rename = "turn")]
5806 Turn,
5807 #[serde(rename = "session")]
5808 Session,
5809}
5810
5811#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5812#[serde(rename_all = "camelCase")]
5813pub struct PermissionProfileListParams {
5814 #[serde(default, skip_serializing_if = "Option::is_none")]
5815 pub cursor: Option<String>,
5816 #[serde(default, skip_serializing_if = "Option::is_none")]
5817 pub cwd: Option<String>,
5818 #[serde(default, skip_serializing_if = "Option::is_none")]
5819 pub limit: Option<i64>,
5820}
5821
5822#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5823#[serde(rename_all = "camelCase")]
5824pub struct PermissionProfileListResponse {
5825 #[serde(default)]
5826 pub data: Vec<PermissionProfileSummary>,
5827 #[serde(
5828 rename = "nextCursor",
5829 default,
5830 skip_serializing_if = "Option::is_none"
5831 )]
5832 pub next_cursor: Option<String>,
5833}
5834
5835#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5836#[serde(rename_all = "camelCase")]
5837pub struct PermissionProfileSummary {
5838 #[serde(default)]
5839 pub allowed: bool,
5840 #[serde(default, skip_serializing_if = "Option::is_none")]
5841 pub description: Option<String>,
5842 #[serde(default)]
5843 pub id: String,
5844}
5845
5846#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5847#[serde(rename_all = "camelCase")]
5848pub struct PermissionsRequestApprovalParams {
5849 #[serde()]
5850 pub cwd: LegacyAppPathString,
5851 #[serde(
5852 rename = "environmentId",
5853 default,
5854 skip_serializing_if = "Option::is_none"
5855 )]
5856 pub environment_id: Option<String>,
5857 #[serde(rename = "itemId", default)]
5858 pub item_id: String,
5859 #[serde()]
5860 pub permissions: RequestPermissionProfile,
5861 #[serde(default, skip_serializing_if = "Option::is_none")]
5862 pub reason: Option<String>,
5863 #[serde(rename = "startedAtMs", default)]
5864 pub started_at_ms: i64,
5865 #[serde(rename = "threadId", default)]
5866 pub thread_id: String,
5867 #[serde(rename = "turnId", default)]
5868 pub turn_id: String,
5869}
5870
5871#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5872#[serde(rename_all = "camelCase")]
5873pub struct PermissionsRequestApprovalResponse {
5874 #[serde()]
5875 pub permissions: GrantedPermissionProfile,
5876 #[serde(default, skip_serializing_if = "Option::is_none")]
5877 pub scope: Option<Value>,
5878 #[serde(
5879 rename = "strictAutoReview",
5880 default,
5881 skip_serializing_if = "Option::is_none"
5882 )]
5883 pub strict_auto_review: Option<bool>,
5884}
5885
5886#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5891pub enum Personality {
5892 #[serde(rename = "none")]
5893 None,
5894 #[serde(rename = "friendly")]
5895 Friendly,
5896 #[serde(rename = "pragmatic")]
5897 Pragmatic,
5898}
5899
5900#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5901#[serde(rename_all = "camelCase")]
5902pub struct PlanDeltaNotification {
5903 #[serde(default)]
5904 pub delta: String,
5905 #[serde(rename = "itemId", default)]
5906 pub item_id: String,
5907 #[serde(rename = "threadId", default)]
5908 pub thread_id: String,
5909 #[serde(rename = "turnId", default)]
5910 pub turn_id: String,
5911}
5912
5913#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5914pub enum PlanType {
5915 #[serde(rename = "free")]
5916 Free,
5917 #[serde(rename = "go")]
5918 Go,
5919 #[serde(rename = "plus")]
5920 Plus,
5921 #[serde(rename = "pro")]
5922 Pro,
5923 #[serde(rename = "prolite")]
5924 Prolite,
5925 #[serde(rename = "promax")]
5926 Promax,
5927 #[serde(rename = "edu_plus")]
5928 Edu_plus,
5929 #[serde(rename = "edu_pro")]
5930 Edu_pro,
5931 #[serde(rename = "team")]
5932 Team,
5933 #[serde(rename = "self_serve_business_prolite")]
5934 Self_serve_business_prolite,
5935 #[serde(rename = "self_serve_business_usage_based")]
5936 Self_serve_business_usage_based,
5937 #[serde(rename = "business")]
5938 Business,
5939 #[serde(rename = "ent26")]
5940 Ent26,
5941 #[serde(rename = "enterprise_cbp_automation")]
5942 Enterprise_cbp_automation,
5943 #[serde(rename = "enterprise_cbp_usage_based")]
5944 Enterprise_cbp_usage_based,
5945 #[serde(rename = "enterprise")]
5946 Enterprise,
5947 #[serde(rename = "edu")]
5948 Edu,
5949 #[serde(rename = "sci")]
5950 Sci,
5951 #[serde(rename = "sci_plus")]
5952 Sci_plus,
5953 #[serde(rename = "unknown")]
5954 Unknown,
5955}
5956
5957#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5958pub enum PluginAuthPolicy {
5959 #[serde(rename = "ON_INSTALL")]
5960 ON_INSTALL,
5961 #[serde(rename = "ON_USE")]
5962 ON_USE,
5963}
5964
5965#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5966pub enum PluginAvailability {
5967 #[serde(rename = "DISABLED_BY_ADMIN")]
5968 DISABLEDBYADMIN,
5969 AVAILABLE,
5970}
5971
5972#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5973#[serde(rename_all = "camelCase")]
5974pub struct PluginDetail {
5975 #[serde(rename = "appTemplates", default)]
5976 pub app_templates: Vec<AppTemplateSummary>,
5977 #[serde(default)]
5978 pub apps: Vec<AppSummary>,
5979 #[serde(default, skip_serializing_if = "Option::is_none")]
5980 pub description: Option<String>,
5981 #[serde(default)]
5982 pub hooks: Vec<PluginHookSummary>,
5983 #[serde(rename = "marketplaceName", default)]
5984 pub marketplace_name: String,
5985 #[serde(
5986 rename = "marketplacePath",
5987 default,
5988 skip_serializing_if = "Option::is_none"
5989 )]
5990 pub marketplace_path: Option<AbsolutePathBuf>,
5991 #[serde(rename = "mcpServers", default)]
5992 pub mcp_servers: Vec<String>,
5993 #[serde(
5995 rename = "onboardingSkill",
5996 default,
5997 skip_serializing_if = "Option::is_none"
5998 )]
5999 pub onboarding_skill: Option<SkillSummary>,
6000 #[serde(
6001 rename = "scheduledTasks",
6002 default,
6003 skip_serializing_if = "Option::is_none"
6004 )]
6005 pub scheduled_tasks: Option<Vec<ScheduledTaskSummary>>,
6006 #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
6007 pub share_url: Option<String>,
6008 #[serde(default)]
6009 pub skills: Vec<SkillSummary>,
6010 #[serde()]
6011 pub summary: PluginSummary,
6012}
6013
6014#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6015pub enum PluginDisabledReason {
6016 #[serde(rename = "disabled_by_admin")]
6017 Disabled_by_admin,
6018 #[serde(rename = "plan_not_eligible")]
6019 Plan_not_eligible,
6020 #[serde(rename = "required_app_unavailable")]
6021 Required_app_unavailable,
6022 #[serde(rename = "unknown")]
6023 Unknown,
6024}
6025
6026#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6027#[serde(rename_all = "camelCase")]
6028pub struct PluginHookSummary {
6029 #[serde(rename = "eventName")]
6030 pub event_name: HookEventName,
6031 #[serde(default)]
6032 pub key: String,
6033}
6034
6035#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6036#[serde(rename_all = "camelCase")]
6037pub struct PluginInstallParams {
6038 #[serde(
6039 rename = "installAttemptId",
6040 default,
6041 skip_serializing_if = "Option::is_none"
6042 )]
6043 pub install_attempt_id: Option<String>,
6044 #[serde(
6045 rename = "marketplacePath",
6046 default,
6047 skip_serializing_if = "Option::is_none"
6048 )]
6049 pub marketplace_path: Option<AbsolutePathBuf>,
6050 #[serde(rename = "pluginName", default)]
6051 pub plugin_name: String,
6052 #[serde(
6053 rename = "remoteMarketplaceName",
6054 default,
6055 skip_serializing_if = "Option::is_none"
6056 )]
6057 pub remote_marketplace_name: Option<String>,
6058}
6059
6060#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6061pub enum PluginInstallPolicy {
6062 #[serde(rename = "NOT_AVAILABLE")]
6063 NOT_AVAILABLE,
6064 #[serde(rename = "AVAILABLE")]
6065 AVAILABLE,
6066 #[serde(rename = "INSTALLED_BY_DEFAULT")]
6067 INSTALLED_BY_DEFAULT,
6068}
6069
6070#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6071pub enum PluginInstallPolicySource {
6072 #[serde(rename = "WORKSPACE_SETTING")]
6073 WORKSPACE_SETTING,
6074 #[serde(rename = "IMPLICIT_CANONICAL_APP")]
6075 IMPLICIT_CANONICAL_APP,
6076}
6077
6078#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6079#[serde(rename_all = "camelCase")]
6080pub struct PluginInstallResponse {
6081 #[serde(rename = "appsNeedingAuth", default)]
6082 pub apps_needing_auth: Vec<AppSummary>,
6083 #[serde(rename = "authPolicy")]
6084 pub auth_policy: PluginAuthPolicy,
6085}
6086
6087#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6088#[serde(rename_all = "camelCase")]
6089pub struct PluginInstalledParams {
6090 #[serde(default, skip_serializing_if = "Option::is_none")]
6091 pub cwds: Option<Vec<AbsolutePathBuf>>,
6092 #[serde(
6093 rename = "installSuggestionPluginNames",
6094 default,
6095 skip_serializing_if = "Option::is_none"
6096 )]
6097 pub install_suggestion_plugin_names: Option<Vec<String>>,
6098}
6099
6100#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6101#[serde(rename_all = "camelCase")]
6102pub struct PluginInstalledResponse {
6103 #[serde(
6104 rename = "marketplaceLoadErrors",
6105 default,
6106 skip_serializing_if = "Option::is_none"
6107 )]
6108 pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
6109 #[serde(default)]
6110 pub marketplaces: Vec<PluginMarketplaceEntry>,
6111}
6112
6113#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6114#[serde(rename_all = "camelCase")]
6115pub struct PluginInterface {
6116 #[serde(
6117 rename = "brandColor",
6118 default,
6119 skip_serializing_if = "Option::is_none"
6120 )]
6121 pub brand_color: Option<String>,
6122 #[serde(default)]
6123 pub capabilities: Vec<String>,
6124 #[serde(default, skip_serializing_if = "Option::is_none")]
6125 pub category: Option<String>,
6126 #[serde(
6127 rename = "composerIcon",
6128 default,
6129 skip_serializing_if = "Option::is_none"
6130 )]
6131 pub composer_icon: Option<AbsolutePathBuf>,
6132 #[serde(
6133 rename = "composerIconUrl",
6134 default,
6135 skip_serializing_if = "Option::is_none"
6136 )]
6137 pub composer_icon_url: Option<String>,
6138 #[serde(
6139 rename = "defaultPrompt",
6140 default,
6141 skip_serializing_if = "Option::is_none"
6142 )]
6143 pub default_prompt: Option<Vec<String>>,
6144 #[serde(
6145 rename = "developerName",
6146 default,
6147 skip_serializing_if = "Option::is_none"
6148 )]
6149 pub developer_name: Option<String>,
6150 #[serde(
6151 rename = "displayName",
6152 default,
6153 skip_serializing_if = "Option::is_none"
6154 )]
6155 pub display_name: Option<String>,
6156 #[serde(default, skip_serializing_if = "Option::is_none")]
6157 pub logo: Option<AbsolutePathBuf>,
6158 #[serde(rename = "logoDark", default, skip_serializing_if = "Option::is_none")]
6159 pub logo_dark: Option<AbsolutePathBuf>,
6160 #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
6161 pub logo_url: Option<String>,
6162 #[serde(
6163 rename = "logoUrlDark",
6164 default,
6165 skip_serializing_if = "Option::is_none"
6166 )]
6167 pub logo_url_dark: Option<String>,
6168 #[serde(
6169 rename = "longDescription",
6170 default,
6171 skip_serializing_if = "Option::is_none"
6172 )]
6173 pub long_description: Option<String>,
6174 #[serde(
6175 rename = "privacyPolicyUrl",
6176 default,
6177 skip_serializing_if = "Option::is_none"
6178 )]
6179 pub privacy_policy_url: Option<String>,
6180 #[serde(rename = "screenshotUrls", default)]
6181 pub screenshot_urls: Vec<String>,
6182 #[serde(default)]
6183 pub screenshots: Vec<AbsolutePathBuf>,
6184 #[serde(
6185 rename = "shortDescription",
6186 default,
6187 skip_serializing_if = "Option::is_none"
6188 )]
6189 pub short_description: Option<String>,
6190 #[serde(
6191 rename = "termsOfServiceUrl",
6192 default,
6193 skip_serializing_if = "Option::is_none"
6194 )]
6195 pub terms_of_service_url: Option<String>,
6196 #[serde(
6197 rename = "websiteUrl",
6198 default,
6199 skip_serializing_if = "Option::is_none"
6200 )]
6201 pub website_url: Option<String>,
6202}
6203
6204#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6205pub enum PluginListMarketplaceKind {
6206 #[serde(rename = "local")]
6207 Local,
6208 #[serde(rename = "vertical")]
6209 Vertical,
6210 #[serde(rename = "workspace-directory")]
6211 Workspace_directory,
6212 #[serde(rename = "shared-with-me")]
6213 Shared_with_me,
6214 #[serde(rename = "created-by-me-remote")]
6215 Created_by_me_remote,
6216}
6217
6218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6219#[serde(rename_all = "camelCase")]
6220pub struct PluginListParams {
6221 #[serde(default, skip_serializing_if = "Option::is_none")]
6222 pub cwds: Option<Vec<AbsolutePathBuf>>,
6223 #[serde(
6224 rename = "forceRefetch",
6225 default,
6226 skip_serializing_if = "Option::is_none"
6227 )]
6228 pub force_refetch: Option<bool>,
6229 #[serde(
6230 rename = "marketplaceKinds",
6231 default,
6232 skip_serializing_if = "Option::is_none"
6233 )]
6234 pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
6235}
6236
6237#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6238#[serde(rename_all = "camelCase")]
6239pub struct PluginListResponse {
6240 #[serde(
6241 rename = "featuredPluginIds",
6242 default,
6243 skip_serializing_if = "Option::is_none"
6244 )]
6245 pub featured_plugin_ids: Option<Vec<String>>,
6246 #[serde(
6247 rename = "marketplaceLoadErrors",
6248 default,
6249 skip_serializing_if = "Option::is_none"
6250 )]
6251 pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
6252 #[serde(default)]
6253 pub marketplaces: Vec<PluginMarketplaceEntry>,
6254}
6255
6256#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6257#[serde(rename_all = "camelCase")]
6258pub struct PluginMarketplaceEntry {
6259 #[serde(default, skip_serializing_if = "Option::is_none")]
6260 pub interface: Option<MarketplaceInterface>,
6261 #[serde(default)]
6262 pub name: String,
6263 #[serde(default, skip_serializing_if = "Option::is_none")]
6264 pub path: Option<AbsolutePathBuf>,
6265 #[serde(default)]
6266 pub plugins: Vec<PluginSummary>,
6267}
6268
6269#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6270#[serde(rename_all = "camelCase")]
6271pub struct PluginReadParams {
6272 #[serde(
6273 rename = "marketplacePath",
6274 default,
6275 skip_serializing_if = "Option::is_none"
6276 )]
6277 pub marketplace_path: Option<AbsolutePathBuf>,
6278 #[serde(rename = "pluginName", default)]
6279 pub plugin_name: String,
6280 #[serde(
6281 rename = "remoteMarketplaceName",
6282 default,
6283 skip_serializing_if = "Option::is_none"
6284 )]
6285 pub remote_marketplace_name: Option<String>,
6286}
6287
6288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6289#[serde(rename_all = "camelCase")]
6290pub struct PluginReadResponse {
6291 #[serde()]
6292 pub plugin: PluginDetail,
6293}
6294
6295#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6301#[serde(rename_all = "camelCase")]
6302pub struct PluginReconcileChangedPlugin {
6303 #[serde(rename = "hasApps", default)]
6304 pub has_apps: bool,
6305 #[serde(rename = "hasHooks", default)]
6306 pub has_hooks: bool,
6307 #[serde(rename = "hasMcps", default)]
6308 pub has_mcps: bool,
6309 #[serde(rename = "hasSkills", default)]
6312 pub has_skills: bool,
6313 #[serde(default)]
6315 pub id: String,
6316}
6317
6318#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6319#[serde(rename_all = "camelCase")]
6320pub struct PluginReconcileParams {
6321 #[serde(default, skip_serializing_if = "Option::is_none")]
6324 pub reason: Option<String>,
6325}
6326
6327#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6331#[serde(rename_all = "camelCase")]
6332pub struct PluginReconcileResponse {
6333 #[serde(rename = "changedPlugins", default)]
6338 pub changed_plugins: Vec<PluginReconcileChangedPlugin>,
6339 #[serde(rename = "failedMaterializationRemotePluginIds", default)]
6342 pub failed_materialization_remote_plugin_ids: Vec<String>,
6343 #[serde(rename = "failedRemotePluginIds", default)]
6345 pub failed_remote_plugin_ids: Vec<String>,
6346}
6347
6348#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6349#[serde(rename_all = "camelCase")]
6350pub struct PluginShareCheckoutParams {
6351 #[serde(rename = "remotePluginId", default)]
6352 pub remote_plugin_id: String,
6353}
6354
6355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6356#[serde(rename_all = "camelCase")]
6357pub struct PluginShareCheckoutResponse {
6358 #[serde(rename = "marketplaceName", default)]
6359 pub marketplace_name: String,
6360 #[serde(rename = "marketplacePath")]
6361 pub marketplace_path: AbsolutePathBuf,
6362 #[serde(rename = "pluginId", default)]
6363 pub plugin_id: String,
6364 #[serde(rename = "pluginName", default)]
6365 pub plugin_name: String,
6366 #[serde(rename = "pluginPath")]
6367 pub plugin_path: AbsolutePathBuf,
6368 #[serde(rename = "remotePluginId", default)]
6369 pub remote_plugin_id: String,
6370 #[serde(
6371 rename = "remoteVersion",
6372 default,
6373 skip_serializing_if = "Option::is_none"
6374 )]
6375 pub remote_version: Option<String>,
6376}
6377
6378#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6379#[serde(rename_all = "camelCase")]
6380pub struct PluginShareContext {
6381 #[serde(
6382 rename = "canPublishToWorkspace",
6383 default,
6384 skip_serializing_if = "Option::is_none"
6385 )]
6386 pub can_publish_to_workspace: Option<bool>,
6387 #[serde(
6388 rename = "creatorAccountUserId",
6389 default,
6390 skip_serializing_if = "Option::is_none"
6391 )]
6392 pub creator_account_user_id: Option<String>,
6393 #[serde(
6394 rename = "creatorName",
6395 default,
6396 skip_serializing_if = "Option::is_none"
6397 )]
6398 pub creator_name: Option<String>,
6399 #[serde(default, skip_serializing_if = "Option::is_none")]
6400 pub discoverability: Option<PluginShareDiscoverability>,
6401 #[serde(rename = "remotePluginId", default)]
6402 pub remote_plugin_id: String,
6403 #[serde(
6404 rename = "remoteVersion",
6405 default,
6406 skip_serializing_if = "Option::is_none"
6407 )]
6408 pub remote_version: Option<String>,
6409 #[serde(
6410 rename = "sharePrincipals",
6411 default,
6412 skip_serializing_if = "Option::is_none"
6413 )]
6414 pub share_principals: Option<Vec<PluginSharePrincipal>>,
6415 #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
6416 pub share_url: Option<String>,
6417}
6418
6419#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6420#[serde(rename_all = "camelCase")]
6421pub struct PluginShareDeleteParams {
6422 #[serde(rename = "remotePluginId", default)]
6423 pub remote_plugin_id: String,
6424}
6425
6426#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6427#[serde(rename_all = "camelCase")]
6428pub struct PluginShareDeleteResponse {
6429 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6430 pub extra: serde_json::Map<String, Value>,
6431}
6432
6433#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6434pub enum PluginShareDiscoverability {
6435 #[serde(rename = "LISTED")]
6436 LISTED,
6437 #[serde(rename = "UNLISTED")]
6438 UNLISTED,
6439 #[serde(rename = "PRIVATE")]
6440 PRIVATE,
6441}
6442
6443#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6444#[serde(rename_all = "camelCase")]
6445pub struct PluginShareListItem {
6446 #[serde(
6447 rename = "localPluginPath",
6448 default,
6449 skip_serializing_if = "Option::is_none"
6450 )]
6451 pub local_plugin_path: Option<AbsolutePathBuf>,
6452 #[serde()]
6453 pub plugin: PluginSummary,
6454}
6455
6456#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6457#[serde(rename_all = "camelCase")]
6458pub struct PluginShareListParams {
6459 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6460 pub extra: serde_json::Map<String, Value>,
6461}
6462
6463#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6464#[serde(rename_all = "camelCase")]
6465pub struct PluginShareListResponse {
6466 #[serde(default)]
6467 pub data: Vec<PluginShareListItem>,
6468}
6469
6470#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6471#[serde(rename_all = "camelCase")]
6472pub struct PluginSharePrincipal {
6473 #[serde(default)]
6474 pub name: String,
6475 #[serde(rename = "principalId", default)]
6476 pub principal_id: String,
6477 #[serde(rename = "principalType")]
6478 pub principal_type: PluginSharePrincipalType,
6479 #[serde()]
6480 pub role: PluginSharePrincipalRole,
6481}
6482
6483#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6484pub enum PluginSharePrincipalRole {
6485 #[serde(rename = "reader")]
6486 Reader,
6487 #[serde(rename = "editor")]
6488 Editor,
6489 #[serde(rename = "owner")]
6490 Owner,
6491}
6492
6493#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6494pub enum PluginSharePrincipalType {
6495 #[serde(rename = "user")]
6496 User,
6497 #[serde(rename = "group")]
6498 Group,
6499 #[serde(rename = "workspace")]
6500 Workspace,
6501}
6502
6503#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6504#[serde(rename_all = "camelCase")]
6505pub struct PluginShareSaveParams {
6506 #[serde(default, skip_serializing_if = "Option::is_none")]
6507 pub discoverability: Option<PluginShareDiscoverability>,
6508 #[serde(rename = "pluginPath")]
6509 pub plugin_path: AbsolutePathBuf,
6510 #[serde(
6511 rename = "remotePluginId",
6512 default,
6513 skip_serializing_if = "Option::is_none"
6514 )]
6515 pub remote_plugin_id: Option<String>,
6516 #[serde(
6517 rename = "shareTargets",
6518 default,
6519 skip_serializing_if = "Option::is_none"
6520 )]
6521 pub share_targets: Option<Vec<PluginShareTarget>>,
6522}
6523
6524#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6525#[serde(rename_all = "camelCase")]
6526pub struct PluginShareSaveResponse {
6527 #[serde(
6528 rename = "canPublishToWorkspace",
6529 default,
6530 skip_serializing_if = "Option::is_none"
6531 )]
6532 pub can_publish_to_workspace: Option<bool>,
6533 #[serde(rename = "remotePluginId", default)]
6534 pub remote_plugin_id: String,
6535 #[serde(rename = "shareUrl", default)]
6536 pub share_url: String,
6537}
6538
6539#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6540#[serde(rename_all = "camelCase")]
6541pub struct PluginShareTarget {
6542 #[serde(rename = "principalId", default)]
6543 pub principal_id: String,
6544 #[serde(rename = "principalType")]
6545 pub principal_type: PluginSharePrincipalType,
6546 #[serde()]
6547 pub role: PluginShareTargetRole,
6548}
6549
6550#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6551pub enum PluginShareTargetRole {
6552 #[serde(rename = "reader")]
6553 Reader,
6554 #[serde(rename = "editor")]
6555 Editor,
6556}
6557
6558#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6559pub enum PluginShareUpdateDiscoverability {
6560 #[serde(rename = "UNLISTED")]
6561 UNLISTED,
6562 #[serde(rename = "PRIVATE")]
6563 PRIVATE,
6564 #[serde(rename = "LISTED")]
6565 LISTED,
6566}
6567
6568#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6569#[serde(rename_all = "camelCase")]
6570pub struct PluginShareUpdateTargetsParams {
6571 #[serde()]
6572 pub discoverability: PluginShareUpdateDiscoverability,
6573 #[serde(rename = "remotePluginId", default)]
6574 pub remote_plugin_id: String,
6575 #[serde(rename = "shareTargets", default)]
6576 pub share_targets: Vec<PluginShareTarget>,
6577}
6578
6579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6580#[serde(rename_all = "camelCase")]
6581pub struct PluginShareUpdateTargetsResponse {
6582 #[serde()]
6583 pub discoverability: PluginShareDiscoverability,
6584 #[serde(default)]
6585 pub principals: Vec<PluginSharePrincipal>,
6586}
6587
6588#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6589#[serde(rename_all = "camelCase")]
6590pub struct PluginSkillReadParams {
6591 #[serde(rename = "remoteMarketplaceName", default)]
6592 pub remote_marketplace_name: String,
6593 #[serde(rename = "remotePluginId", default)]
6594 pub remote_plugin_id: String,
6595 #[serde(rename = "skillName", default)]
6596 pub skill_name: String,
6597}
6598
6599#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6600#[serde(rename_all = "camelCase")]
6601pub struct PluginSkillReadResponse {
6602 #[serde(default, skip_serializing_if = "Option::is_none")]
6603 pub contents: Option<String>,
6604}
6605
6606#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6607#[serde(tag = "type", rename_all = "camelCase")]
6608pub enum PluginSource {
6609 Local {
6610 path: AbsolutePathBuf,
6611 },
6612 Git {
6613 #[serde(default, skip_serializing_if = "Option::is_none")]
6614 path: Option<String>,
6615 #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
6616 ref_name: Option<String>,
6617 #[serde(default, skip_serializing_if = "Option::is_none")]
6618 sha: Option<String>,
6619 url: String,
6620 },
6621 Npm {
6622 package: String,
6623 #[serde(default, skip_serializing_if = "Option::is_none")]
6624 registry: Option<String>,
6625 #[serde(default, skip_serializing_if = "Option::is_none")]
6626 version: Option<String>,
6627 },
6628 Remote,
6629}
6630
6631#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6632#[serde(rename_all = "camelCase")]
6633pub struct PluginSummary {
6634 #[serde(rename = "authPolicy")]
6635 pub auth_policy: PluginAuthPolicy,
6636 #[serde(default, skip_serializing_if = "Option::is_none")]
6637 pub availability: Option<Value>,
6638 #[serde(
6639 rename = "disabledReason",
6640 default,
6641 skip_serializing_if = "Option::is_none"
6642 )]
6643 pub disabled_reason: Option<PluginDisabledReason>,
6644 #[serde(
6645 rename = "eligiblePlanTypes",
6646 default,
6647 skip_serializing_if = "Option::is_none"
6648 )]
6649 pub eligible_plan_types: Option<Vec<String>>,
6650 #[serde(default)]
6651 pub enabled: bool,
6652 #[serde(default)]
6653 pub id: String,
6654 #[serde(rename = "installPolicy")]
6655 pub install_policy: PluginInstallPolicy,
6656 #[serde(
6657 rename = "installPolicySource",
6658 default,
6659 skip_serializing_if = "Option::is_none"
6660 )]
6661 pub install_policy_source: Option<PluginInstallPolicySource>,
6662 #[serde(default)]
6663 pub installed: bool,
6664 #[serde(
6665 rename = "installedAt",
6666 default,
6667 skip_serializing_if = "Option::is_none"
6668 )]
6669 pub installed_at: Option<i64>,
6670 #[serde(default, skip_serializing_if = "Option::is_none")]
6671 pub interface: Option<PluginInterface>,
6672 #[serde(default, skip_serializing_if = "Option::is_none")]
6673 pub keywords: Option<Vec<String>>,
6674 #[serde(
6675 rename = "localVersion",
6676 default,
6677 skip_serializing_if = "Option::is_none"
6678 )]
6679 pub local_version: Option<String>,
6680 #[serde(
6681 rename = "mustShowInstallationInterstitial",
6682 default,
6683 skip_serializing_if = "Option::is_none"
6684 )]
6685 pub must_show_installation_interstitial: Option<bool>,
6686 #[serde(default)]
6687 pub name: String,
6688 #[serde(
6689 rename = "remotePluginId",
6690 default,
6691 skip_serializing_if = "Option::is_none"
6692 )]
6693 pub remote_plugin_id: Option<String>,
6694 #[serde(
6695 rename = "shareContext",
6696 default,
6697 skip_serializing_if = "Option::is_none"
6698 )]
6699 pub share_context: Option<PluginShareContext>,
6700 #[serde()]
6701 pub source: PluginSource,
6702 #[serde(default, skip_serializing_if = "Option::is_none")]
6703 pub version: Option<String>,
6704}
6705
6706#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6707#[serde(rename_all = "camelCase")]
6708pub struct PluginUninstallParams {
6709 #[serde(rename = "pluginId", default)]
6710 pub plugin_id: String,
6711}
6712
6713#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6714#[serde(rename_all = "camelCase")]
6715pub struct PluginUninstallResponse {
6716 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6717 pub extra: serde_json::Map<String, Value>,
6718}
6719
6720#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6721#[serde(rename_all = "camelCase")]
6722pub struct PluginsMigration {
6723 #[serde(rename = "marketplaceName", default)]
6724 pub marketplace_name: String,
6725 #[serde(rename = "pluginNames", default)]
6726 pub plugin_names: Vec<String>,
6727}
6728
6729#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6730#[serde(rename_all = "camelCase")]
6731pub struct ProcessExitedNotification {
6732 #[serde(rename = "exitCode", default)]
6733 pub exit_code: i64,
6734 #[serde(
6738 rename = "outputDrainTimedOut",
6739 default,
6740 skip_serializing_if = "Option::is_none"
6741 )]
6742 pub output_drain_timed_out: Option<bool>,
6743 #[serde(rename = "processHandle", default)]
6744 pub process_handle: String,
6745 #[serde(default)]
6746 pub stderr: String,
6747 #[serde(rename = "stderrCapReached", default)]
6748 pub stderr_cap_reached: bool,
6749 #[serde(default)]
6750 pub stdout: String,
6751 #[serde(rename = "stdoutCapReached", default)]
6752 pub stdout_cap_reached: bool,
6753}
6754
6755#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6756#[serde(rename_all = "camelCase")]
6757pub struct ProcessOutputDeltaNotification {
6758 #[serde(rename = "capReached", default)]
6759 pub cap_reached: bool,
6760 #[serde(rename = "deltaBase64", default)]
6761 pub delta_base64: String,
6762 #[serde(rename = "processHandle", default)]
6763 pub process_handle: String,
6764 #[serde(default)]
6765 pub stream: Value,
6766}
6767
6768#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6769pub enum ProcessOutputStream {
6770 #[serde(rename = "stdout")]
6771 Stdout,
6772 #[serde(rename = "stderr")]
6773 Stderr,
6774}
6775
6776#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6777pub enum RateLimitReachedType {
6778 #[serde(rename = "rate_limit_reached")]
6779 Rate_limit_reached,
6780 #[serde(rename = "workspace_owner_credits_depleted")]
6781 Workspace_owner_credits_depleted,
6782 #[serde(rename = "workspace_member_credits_depleted")]
6783 Workspace_member_credits_depleted,
6784 #[serde(rename = "workspace_owner_usage_limit_reached")]
6785 Workspace_owner_usage_limit_reached,
6786 #[serde(rename = "workspace_member_usage_limit_reached")]
6787 Workspace_member_usage_limit_reached,
6788}
6789
6790#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6791#[serde(rename_all = "camelCase")]
6792pub struct RateLimitResetCredit {
6793 #[serde(default, skip_serializing_if = "Option::is_none")]
6794 pub description: Option<String>,
6795 #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
6796 pub expires_at: Option<i64>,
6797 #[serde(rename = "grantedAt", default)]
6798 pub granted_at: i64,
6799 #[serde(default)]
6800 pub id: String,
6801 #[serde(rename = "resetType")]
6802 pub reset_type: RateLimitResetType,
6803 #[serde()]
6804 pub status: RateLimitResetCreditStatus,
6805 #[serde(default, skip_serializing_if = "Option::is_none")]
6806 pub title: Option<String>,
6807}
6808
6809#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6810pub enum RateLimitResetCreditStatus {
6811 #[serde(rename = "available")]
6812 Available,
6813 #[serde(rename = "redeeming")]
6814 Redeeming,
6815 #[serde(rename = "redeemed")]
6816 Redeemed,
6817 #[serde(rename = "unknown")]
6818 Unknown,
6819}
6820
6821#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6822#[serde(rename_all = "camelCase")]
6823pub struct RateLimitResetCreditsSummary {
6824 #[serde(rename = "availableCount", default)]
6825 pub available_count: i64,
6826 #[serde(default, skip_serializing_if = "Option::is_none")]
6827 pub credits: Option<Vec<RateLimitResetCredit>>,
6828}
6829
6830#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6831pub enum RateLimitResetType {
6832 #[serde(rename = "codexRateLimits")]
6833 CodexRateLimits,
6834 #[serde(rename = "unknown")]
6835 Unknown,
6836}
6837
6838#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6839#[serde(rename_all = "camelCase")]
6840pub struct RateLimitSnapshot {
6841 #[serde(default, skip_serializing_if = "Option::is_none")]
6842 pub credits: Option<CreditsSnapshot>,
6843 #[serde(
6844 rename = "individualLimit",
6845 default,
6846 skip_serializing_if = "Option::is_none"
6847 )]
6848 pub individual_limit: Option<SpendControlLimitSnapshot>,
6849 #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
6850 pub limit_id: Option<String>,
6851 #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
6852 pub limit_name: Option<String>,
6853 #[serde(
6856 rename = "normalModelSlug",
6857 default,
6858 skip_serializing_if = "Option::is_none"
6859 )]
6860 pub normal_model_slug: Option<String>,
6861 #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
6862 pub plan_type: Option<PlanType>,
6863 #[serde(default, skip_serializing_if = "Option::is_none")]
6864 pub primary: Option<RateLimitWindow>,
6865 #[serde(
6866 rename = "rateLimitReachedType",
6867 default,
6868 skip_serializing_if = "Option::is_none"
6869 )]
6870 pub rate_limit_reached_type: Option<RateLimitReachedType>,
6871 #[serde(default, skip_serializing_if = "Option::is_none")]
6872 pub secondary: Option<RateLimitWindow>,
6873 #[serde(
6874 rename = "spendControlReached",
6875 default,
6876 skip_serializing_if = "Option::is_none"
6877 )]
6878 pub spend_control_reached: Option<bool>,
6879}
6880
6881#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6882#[serde(rename_all = "camelCase")]
6883pub struct RateLimitWindow {
6884 #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
6885 pub resets_at: Option<i64>,
6886 #[serde(rename = "usedPercent", default)]
6887 pub used_percent: i64,
6888 #[serde(
6889 rename = "windowDurationMins",
6890 default,
6891 skip_serializing_if = "Option::is_none"
6892 )]
6893 pub window_duration_mins: Option<i64>,
6894}
6895
6896#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6897pub enum RealtimeConversationVersion {
6898 #[serde(rename = "v1")]
6899 V1,
6900 #[serde(rename = "v2")]
6901 V2,
6902 #[serde(rename = "v3")]
6903 V3,
6904}
6905
6906#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
6908#[serde(transparent)]
6909pub struct ReasoningEffort(pub String);
6910
6911#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6912#[serde(rename_all = "camelCase")]
6913pub struct ReasoningEffortOption {
6914 #[serde(default)]
6915 pub description: String,
6916 #[serde(rename = "reasoningEffort")]
6917 pub reasoning_effort: ReasoningEffort,
6918}
6919
6920#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6921pub enum ReasoningSummary {
6922 #[serde(rename = "auto")]
6923 Auto,
6924 #[serde(rename = "concise")]
6925 Concise,
6926 #[serde(rename = "detailed")]
6927 Detailed,
6928 #[serde(rename = "none")]
6929 None,
6930}
6931
6932#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6933#[serde(rename_all = "camelCase")]
6934pub struct ReasoningSummaryPartAddedNotification {
6935 #[serde(rename = "itemId", default)]
6936 pub item_id: String,
6937 #[serde(rename = "summaryIndex", default)]
6938 pub summary_index: i64,
6939 #[serde(rename = "threadId", default)]
6940 pub thread_id: String,
6941 #[serde(rename = "turnId", default)]
6942 pub turn_id: String,
6943}
6944
6945#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6946#[serde(rename_all = "camelCase")]
6947pub struct ReasoningSummaryTextDeltaNotification {
6948 #[serde(default)]
6949 pub delta: String,
6950 #[serde(rename = "itemId", default)]
6951 pub item_id: String,
6952 #[serde(rename = "summaryIndex", default)]
6953 pub summary_index: i64,
6954 #[serde(rename = "threadId", default)]
6955 pub thread_id: String,
6956 #[serde(rename = "turnId", default)]
6957 pub turn_id: String,
6958}
6959
6960#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6961#[serde(rename_all = "camelCase")]
6962pub struct ReasoningTextDeltaNotification {
6963 #[serde(rename = "contentIndex", default)]
6964 pub content_index: i64,
6965 #[serde(default)]
6966 pub delta: String,
6967 #[serde(rename = "itemId", default)]
6968 pub item_id: String,
6969 #[serde(rename = "threadId", default)]
6970 pub thread_id: String,
6971 #[serde(rename = "turnId", default)]
6972 pub turn_id: String,
6973}
6974
6975#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6976pub enum RemoteControlConnectionStatus {
6977 #[serde(rename = "disabled")]
6978 Disabled,
6979 #[serde(rename = "connecting")]
6980 Connecting,
6981 #[serde(rename = "connected")]
6982 Connected,
6983 #[serde(rename = "errored")]
6984 Errored,
6985}
6986
6987#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6988#[serde(rename_all = "camelCase")]
6989pub struct RemoteControlStatusChangedNotification {
6990 #[serde(
6991 rename = "environmentId",
6992 default,
6993 skip_serializing_if = "Option::is_none"
6994 )]
6995 pub environment_id: Option<String>,
6996 #[serde(rename = "installationId", default)]
6997 pub installation_id: String,
6998 #[serde(rename = "serverName", default)]
6999 pub server_name: String,
7000 #[serde()]
7001 pub status: RemoteControlConnectionStatus,
7002}
7003
7004#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7005#[serde(untagged)]
7006pub enum RequestId {
7007 Variant0(String),
7008 Variant1(i64),
7009}
7010
7011#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7012#[serde(rename_all = "camelCase")]
7013pub struct RequestPermissionProfile {
7014 #[serde(
7015 rename = "fileSystem",
7016 default,
7017 skip_serializing_if = "Option::is_none"
7018 )]
7019 pub file_system: Option<AdditionalFileSystemPermissions>,
7020 #[serde(default, skip_serializing_if = "Option::is_none")]
7021 pub network: Option<AdditionalNetworkPermissions>,
7022}
7023
7024#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7025pub enum ResidencyRequirement {
7026 #[serde(rename = "us")]
7027 Us,
7028}
7029
7030#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7031#[serde(rename_all = "camelCase")]
7032pub struct Resource {
7033 #[serde(default, skip_serializing_if = "Option::is_none")]
7034 pub _meta: Option<Value>,
7035 #[serde(default, skip_serializing_if = "Option::is_none")]
7036 pub annotations: Option<Value>,
7037 #[serde(default, skip_serializing_if = "Option::is_none")]
7038 pub description: Option<String>,
7039 #[serde(default, skip_serializing_if = "Option::is_none")]
7040 pub icons: Option<Vec<Value>>,
7041 #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
7042 pub mime_type: Option<String>,
7043 #[serde(default)]
7044 pub name: String,
7045 #[serde(default, skip_serializing_if = "Option::is_none")]
7046 pub size: Option<i64>,
7047 #[serde(default, skip_serializing_if = "Option::is_none")]
7048 pub title: Option<String>,
7049 #[serde(default)]
7050 pub uri: String,
7051}
7052
7053#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7054#[serde(untagged)]
7055pub enum ResourceContent {
7056 Variant0(Value),
7057 Variant1(Value),
7058}
7059
7060#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7061#[serde(rename_all = "camelCase")]
7062pub struct ResourceTemplate {
7063 #[serde(default, skip_serializing_if = "Option::is_none")]
7064 pub annotations: Option<Value>,
7065 #[serde(default, skip_serializing_if = "Option::is_none")]
7066 pub description: Option<String>,
7067 #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
7068 pub mime_type: Option<String>,
7069 #[serde(default)]
7070 pub name: String,
7071 #[serde(default, skip_serializing_if = "Option::is_none")]
7072 pub title: Option<String>,
7073 #[serde(rename = "uriTemplate", default)]
7074 pub uri_template: String,
7075}
7076
7077#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7079#[serde(rename_all = "camelCase")]
7080pub struct ResponseUsageMetadata {
7081 #[serde(default, skip_serializing_if = "Option::is_none")]
7082 pub amount: Option<String>,
7083 #[serde(default, skip_serializing_if = "Option::is_none")]
7084 pub metadata: Option<Value>,
7085}
7086
7087#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7088pub enum ReviewDecision {
7089 #[serde(rename = "approved")]
7090 Approved,
7091 #[serde(rename = "approved_execpolicy_amendment")]
7092 ApprovedExecpolicyAmendment {
7093 proposed_execpolicy_amendment: Vec<String>,
7094 },
7095 #[serde(rename = "approved_for_session")]
7096 ApprovedForSession,
7097 #[serde(rename = "approved_mcp_policy_amendment")]
7098 ApprovedMcpPolicyAmendment,
7099 #[serde(rename = "network_policy_amendment")]
7100 NetworkPolicyAmendment {
7101 network_policy_amendment: NetworkPolicyAmendment,
7102 },
7103 #[serde(rename = "denied")]
7104 Denied { rejection: String },
7105 #[serde(rename = "timed_out")]
7106 TimedOut,
7107 #[serde(rename = "abort")]
7108 Abort,
7109}
7110
7111#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7112pub enum ReviewDelivery {
7113 #[serde(rename = "inline")]
7114 Inline,
7115}
7116
7117#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7118#[serde(rename_all = "camelCase")]
7119pub struct ReviewStartParams {
7120 #[serde(default, skip_serializing_if = "Option::is_none")]
7124 pub delivery: Option<ReviewDelivery>,
7125 #[serde()]
7126 pub target: ReviewTarget,
7127 #[serde(rename = "threadId", default)]
7128 pub thread_id: String,
7129}
7130
7131#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7132#[serde(rename_all = "camelCase")]
7133pub struct ReviewStartResponse {
7134 #[serde(rename = "reviewThreadId", default)]
7136 pub review_thread_id: String,
7137 #[serde()]
7138 pub turn: Turn,
7139}
7140
7141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7142#[serde(tag = "type", rename_all = "camelCase")]
7143pub enum ReviewTarget {
7144 #[serde(rename = "uncommittedChanges")]
7145 UncommittedChanges,
7146 #[serde(rename = "baseBranch")]
7147 BaseBranch {
7148 branch: String,
7149 },
7150 Commit {
7151 sha: String,
7152 #[serde(default, skip_serializing_if = "Option::is_none")]
7153 title: Option<String>,
7154 },
7155 Custom {
7156 instructions: String,
7157 },
7158}
7159
7160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7162pub enum AgentMessageDelivery {
7163 #[serde(rename = "async")]
7164 Async,
7165}
7166
7167#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7169pub struct AgentMessageModeration {
7170 pub moderated: bool,
7171 #[serde(default, skip_serializing_if = "Option::is_none")]
7172 pub display: Option<AgentMessageDisplay>,
7173}
7174
7175#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
7177#[serde(try_from = "u8", into = "u8")]
7178pub struct AgentMessageDisplayVersion;
7179
7180impl TryFrom<u8> for AgentMessageDisplayVersion {
7181 type Error = &'static str;
7182
7183 fn try_from(version: u8) -> Result<Self, Self::Error> {
7184 match version {
7185 1 => Ok(Self),
7186 _ => Err("unsupported answer display version"),
7187 }
7188 }
7189}
7190
7191impl From<AgentMessageDisplayVersion> for u8 {
7192 fn from(_: AgentMessageDisplayVersion) -> Self {
7193 1
7194 }
7195}
7196
7197#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7199#[serde(tag = "mode", rename_all = "camelCase")]
7200pub enum AgentMessageDisplay {
7201 Show {
7202 version: AgentMessageDisplayVersion,
7203 #[serde(default, skip_serializing_if = "Option::is_none")]
7204 annotation: Option<AnswerAnnotation>,
7205 #[serde(rename = "trustedContacts")]
7206 trusted_contacts: TrustedContacts,
7207 },
7208 Hide {
7209 version: AgentMessageDisplayVersion,
7210 replacement: AnswerReplacement,
7211 },
7212 Block {
7213 version: AgentMessageDisplayVersion,
7214 reason: BlockReason,
7215 },
7216}
7217
7218#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7220#[serde(tag = "kind", rename_all = "camelCase")]
7221pub enum AnswerAnnotation {
7222 WellbeingHelpline { subject: HelplineSubject },
7223}
7224
7225#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7227#[serde(rename_all = "camelCase")]
7228pub enum HelplineSubject {
7229 Answer,
7230 Prompt,
7231}
7232
7233#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7235#[serde(rename_all = "camelCase")]
7236pub enum TrustedContacts {
7237 Check,
7238 Skip,
7239}
7240
7241#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7243#[serde(tag = "kind", rename_all = "camelCase")]
7244pub enum AnswerReplacement {
7245 WellbeingPromptHelpline {},
7246}
7247
7248#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7250#[serde(tag = "kind", rename_all = "camelCase")]
7251pub enum BlockReason {
7252 Protection {
7253 #[serde(rename = "protectionType")]
7255 protection_type: String,
7256 },
7257 Cyber {
7258 #[serde(
7259 default,
7260 rename = "trustedAccess",
7261 skip_serializing_if = "Option::is_none"
7262 )]
7263 trusted_access: Option<bool>,
7264 },
7265}
7266
7267#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7269pub enum CliAuthCredentialsStoreMode {
7270 #[serde(rename = "file")]
7271 File,
7272 #[serde(rename = "keyring")]
7273 Keyring,
7274 #[serde(rename = "auto")]
7275 Auto,
7276 #[serde(rename = "ephemeral")]
7277 Ephemeral,
7278}
7279
7280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7282pub struct Project {
7283 #[serde(rename = "createdAt", default)]
7284 pub created_at: i64,
7285 #[serde(default)]
7286 pub id: String,
7287 #[serde(default)]
7288 pub metadata: std::collections::HashMap<String, String>,
7289 #[serde(default)]
7290 pub name: String,
7291 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7294 pub recency_at: Option<i64>,
7295 #[serde(default)]
7296 pub roots: Vec<ProjectRoot>,
7297 #[serde(rename = "updatedAt", default)]
7298 pub updated_at: i64,
7299}
7300
7301#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7303pub enum ProjectSortKey {
7304 #[serde(rename = "position")]
7305 Position,
7306 #[serde(rename = "recencyAt")]
7307 RecencyAt,
7308}
7309
7310#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7311pub enum ProjectChangeType {
7312 #[serde(rename = "created")]
7313 Created,
7314 #[serde(rename = "updated")]
7315 Updated,
7316 #[serde(rename = "deleted")]
7317 Deleted,
7318}
7319
7320#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7322pub struct ProjectChangedNotification {
7323 #[serde(rename = "changeType")]
7324 pub change_type: ProjectChangeType,
7325 #[serde(rename = "projectId", default)]
7326 pub project_id: String,
7327}
7328
7329#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7330pub struct ProjectRoot {
7331 pub path: AbsolutePathBuf,
7332}
7333
7334#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7336pub struct QueuedSubmission {
7337 #[serde(rename = "clientUserMessageId", default)]
7338 pub client_user_message_id: String,
7339 #[serde(default)]
7340 pub id: String,
7341 #[serde(default)]
7342 pub input: Vec<UserInput>,
7343 #[serde(
7345 rename = "responsesapiClientMetadata",
7346 default,
7347 skip_serializing_if = "Option::is_none"
7348 )]
7349 pub responsesapi_client_metadata: Option<std::collections::HashMap<String, String>>,
7350}
7351
7352#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7354pub struct StrictReviewRequiredNotification {
7355 #[serde(rename = "startedAtMs", default)]
7357 pub started_at_ms: i64,
7358 #[serde(rename = "threadId", default)]
7359 pub thread_id: String,
7360 #[serde(rename = "turnId", default)]
7361 pub turn_id: String,
7362}
7363
7364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7366pub struct ThreadProjectUpdatedNotification {
7367 #[serde(rename = "projectId", default)]
7368 pub project_id: Option<String>,
7369 #[serde(rename = "threadId", default)]
7370 pub thread_id: String,
7371}
7372
7373#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7375pub struct ThreadQueueChangedNotification {
7376 #[serde(rename = "threadId", default)]
7377 pub thread_id: String,
7378}
7379
7380#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7382pub struct ThreadRevertedNotification {
7383 #[serde(rename = "threadId", default)]
7384 pub thread_id: String,
7385}
7386
7387#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7390#[serde(rename_all = "camelCase")]
7391pub struct ThreadPredictionUpdatedNotification {
7392 pub result: ThreadPredictionResult,
7393 #[serde(rename = "sourceTurnId", default)]
7394 pub source_turn_id: String,
7395 #[serde(rename = "threadId", default)]
7396 pub thread_id: String,
7397}
7398
7399#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7401#[serde(tag = "type", rename_all = "camelCase")]
7402pub enum ThreadPredictionResult {
7403 Completed {
7404 #[serde(default, skip_serializing_if = "Option::is_none")]
7405 text: Option<String>,
7406 },
7407 Failed,
7408}
7409
7410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7412#[serde(rename_all = "camelCase")]
7413pub struct InAppBrowserRequirements {
7414 #[serde(
7415 rename = "allowExternalBrowserSettingsImport",
7416 default,
7417 skip_serializing_if = "Option::is_none"
7418 )]
7419 pub allow_external_browser_settings_import: Option<bool>,
7420}
7421
7422#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7424pub struct McpServerEventNotification {
7425 #[serde(default)]
7426 pub method: String,
7427 #[serde(default)]
7428 pub params: Value,
7429}
7430
7431#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7434pub struct McpServerEventStreamNotification {
7435 pub notification: McpServerEventNotification,
7436 #[serde(rename = "subscriptionId", default)]
7437 pub subscription_id: String,
7438}
7439
7440#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7443pub enum AllowDenyRequirement {
7444 #[serde(rename = "allow")]
7445 Allow,
7446 #[serde(rename = "deny")]
7447 Deny,
7448}
7449
7450#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7452pub enum BrowserUseAccessApprovalLifetime {
7453 #[serde(rename = "turn")]
7454 Turn,
7455 #[serde(rename = "thread")]
7456 Thread,
7457}
7458
7459#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7461pub enum McpServerConnectionStatus {
7462 #[serde(rename = "notStarted")]
7463 NotStarted,
7464 #[serde(rename = "starting")]
7465 Starting,
7466 #[serde(rename = "connected")]
7467 Connected,
7468 #[serde(rename = "authenticationRequired")]
7469 AuthenticationRequired,
7470 #[serde(rename = "failed")]
7471 Failed,
7472 #[serde(rename = "cancelled")]
7473 Cancelled,
7474 #[serde(rename = "disabled")]
7475 Disabled,
7476}
7477
7478#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7480#[serde(rename_all = "camelCase")]
7481pub struct BrowserUseOriginPolicy {
7482 #[serde(default, skip_serializing_if = "Option::is_none")]
7483 pub access: Option<AllowDenyRequirement>,
7484 #[serde(
7485 rename = "accessApprovalLifetime",
7486 default,
7487 skip_serializing_if = "Option::is_none"
7488 )]
7489 pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
7490 #[serde(
7491 rename = "autoReview",
7492 default,
7493 skip_serializing_if = "Option::is_none"
7494 )]
7495 pub auto_review: Option<AllowDenyRequirement>,
7496 #[serde(default, skip_serializing_if = "Option::is_none")]
7497 pub downloads: Option<AllowDenyRequirement>,
7498 #[serde(
7499 rename = "fullCdpAccess",
7500 default,
7501 skip_serializing_if = "Option::is_none"
7502 )]
7503 pub full_cdp_access: Option<AllowDenyRequirement>,
7504 #[serde(
7505 rename = "persistentApproval",
7506 default,
7507 skip_serializing_if = "Option::is_none"
7508 )]
7509 pub persistent_approval: Option<bool>,
7510 #[serde(default, skip_serializing_if = "Option::is_none")]
7511 pub uploads: Option<AllowDenyRequirement>,
7512}
7513
7514#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7516pub struct BrowserUseOriginPolicyConfig {
7517 #[serde(default, skip_serializing_if = "Option::is_none")]
7518 pub access: Option<AllowDenyRequirement>,
7519 #[serde(default, skip_serializing_if = "Option::is_none")]
7520 pub downloads: Option<AllowDenyRequirement>,
7521 #[serde(default, skip_serializing_if = "Option::is_none")]
7522 pub full_cdp_access: Option<AllowDenyRequirement>,
7523 #[serde(default, skip_serializing_if = "Option::is_none")]
7524 pub uploads: Option<AllowDenyRequirement>,
7525}
7526
7527#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7529pub struct BrowserUseConfig {
7530 #[serde(default, skip_serializing_if = "Option::is_none")]
7531 pub allow_history_access: Option<bool>,
7532 #[serde(default, skip_serializing_if = "Option::is_none")]
7533 pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
7534 #[serde(default, skip_serializing_if = "Option::is_none")]
7535 pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
7536}
7537
7538#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7540pub struct ComputerUseConfig {
7541 #[serde(default, skip_serializing_if = "Option::is_none")]
7542 pub default_app_access: Option<AllowDenyRequirement>,
7543 #[serde(default, skip_serializing_if = "Option::is_none")]
7544 pub macos: Option<ComputerUseMacosConfig>,
7545 #[serde(default, skip_serializing_if = "Option::is_none")]
7546 pub windows: Option<ComputerUseWindowsConfig>,
7547}
7548
7549#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7550pub struct ComputerUseMacosConfig {
7551 #[serde(default, skip_serializing_if = "Option::is_none")]
7552 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7553}
7554
7555#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7556pub struct ComputerUseWindowsConfig {
7557 #[serde(default, skip_serializing_if = "Option::is_none")]
7558 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7559 #[serde(default, skip_serializing_if = "Option::is_none")]
7560 pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
7561}
7562
7563#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7564pub struct ComputerUseWindowsExeConfig {
7565 pub access: AllowDenyRequirement,
7566 #[serde(default, skip_serializing_if = "Option::is_none")]
7567 pub binary_name: Option<String>,
7568 #[serde(default)]
7569 pub product_name: String,
7570 #[serde(default)]
7571 pub publisher_name: String,
7572}
7573
7574#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7576#[serde(rename_all = "camelCase")]
7577pub struct ComputerUseMacosRequirements {
7578 #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
7579 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7580}
7581
7582#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7583#[serde(rename_all = "camelCase")]
7584pub struct ComputerUseWindowsRequirements {
7585 #[serde(default, skip_serializing_if = "Option::is_none")]
7586 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7587 #[serde(default, skip_serializing_if = "Option::is_none")]
7588 pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
7589}
7590
7591#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7592#[serde(rename_all = "camelCase")]
7593pub struct ComputerUseWindowsExeRequirement {
7594 pub access: AllowDenyRequirement,
7595 #[serde(
7596 rename = "binaryName",
7597 default,
7598 skip_serializing_if = "Option::is_none"
7599 )]
7600 pub binary_name: Option<String>,
7601 #[serde(rename = "productName", default)]
7602 pub product_name: String,
7603 #[serde(rename = "publisherName", default)]
7604 pub publisher_name: String,
7605}
7606
7607#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7608pub enum SandboxMode {
7609 #[serde(rename = "read-only")]
7610 Read_only,
7611 #[serde(rename = "workspace-write")]
7612 Workspace_write,
7613 #[serde(rename = "danger-full-access")]
7614 Danger_full_access,
7615}
7616
7617#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7618#[serde(tag = "type", rename_all = "camelCase")]
7619pub enum SandboxPolicy {
7620 #[serde(rename = "dangerFullAccess")]
7621 DangerFullAccess,
7622 #[serde(rename = "readOnly")]
7623 ReadOnly {
7624 #[serde(
7625 rename = "networkAccess",
7626 default,
7627 skip_serializing_if = "Option::is_none"
7628 )]
7629 network_access: Option<bool>,
7630 },
7631 #[serde(rename = "externalSandbox")]
7632 ExternalSandbox {
7633 #[serde(
7634 rename = "networkAccess",
7635 default,
7636 skip_serializing_if = "Option::is_none"
7637 )]
7638 network_access: Option<Value>,
7639 },
7640 #[serde(rename = "workspaceWrite")]
7641 WorkspaceWrite {
7642 #[serde(
7643 rename = "excludeSlashTmp",
7644 default,
7645 skip_serializing_if = "Option::is_none"
7646 )]
7647 exclude_slash_tmp: Option<bool>,
7648 #[serde(
7649 rename = "excludeTmpdirEnvVar",
7650 default,
7651 skip_serializing_if = "Option::is_none"
7652 )]
7653 exclude_tmpdir_env_var: Option<bool>,
7654 #[serde(
7655 rename = "networkAccess",
7656 default,
7657 skip_serializing_if = "Option::is_none"
7658 )]
7659 network_access: Option<bool>,
7660 #[serde(
7661 rename = "writableRoots",
7662 default,
7663 skip_serializing_if = "Option::is_none"
7664 )]
7665 writable_roots: Option<Vec<AbsolutePathBuf>>,
7666 },
7667}
7668
7669#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7670#[serde(rename_all = "snake_case")]
7671pub struct SandboxWorkspaceWrite {
7672 #[serde(default, skip_serializing_if = "Option::is_none")]
7673 pub exclude_slash_tmp: Option<bool>,
7674 #[serde(default, skip_serializing_if = "Option::is_none")]
7675 pub exclude_tmpdir_env_var: Option<bool>,
7676 #[serde(default, skip_serializing_if = "Option::is_none")]
7677 pub network_access: Option<bool>,
7678 #[serde(default, skip_serializing_if = "Option::is_none")]
7679 pub writable_roots: Option<Vec<String>>,
7680}
7681
7682#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7683#[serde(tag = "type", rename_all = "camelCase")]
7684pub enum ScheduledTaskSchedule {
7685 Hourly {
7686 #[serde(default, skip_serializing_if = "Option::is_none")]
7687 days: Option<Vec<ScheduledTaskWeekday>>,
7688 #[serde(rename = "intervalHours")]
7689 interval_hours: i64,
7690 },
7691 Daily {
7692 time: String,
7693 },
7694 Weekdays {
7695 time: String,
7696 },
7697 Weekly {
7698 days: Vec<ScheduledTaskWeekday>,
7699 time: String,
7700 },
7701}
7702
7703#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7704#[serde(rename_all = "camelCase")]
7705pub struct ScheduledTaskSummary {
7706 #[serde(default)]
7707 pub key: String,
7708 #[serde(default)]
7709 pub name: String,
7710 #[serde(default)]
7711 pub prompt: String,
7712 #[serde()]
7713 pub schedule: ScheduledTaskSchedule,
7714}
7715
7716#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7717pub enum ScheduledTaskWeekday {
7718 #[serde(rename = "MO")]
7719 MO,
7720 #[serde(rename = "TU")]
7721 TU,
7722 #[serde(rename = "WE")]
7723 WE,
7724 #[serde(rename = "TH")]
7725 TH,
7726 #[serde(rename = "FR")]
7727 FR,
7728 #[serde(rename = "SA")]
7729 SA,
7730 #[serde(rename = "SU")]
7731 SU,
7732}
7733
7734#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7735#[serde(rename_all = "camelCase")]
7736pub struct SendAddCreditsNudgeEmailParams {
7737 #[serde(rename = "creditType")]
7738 pub credit_type: AddCreditsNudgeCreditType,
7739}
7740
7741#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7742#[serde(rename_all = "camelCase")]
7743pub struct SendAddCreditsNudgeEmailResponse {
7744 #[serde()]
7745 pub status: AddCreditsNudgeEmailStatus,
7746}
7747
7748#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7749#[serde(rename_all = "camelCase")]
7750pub struct ServerRequestResolvedNotification {
7751 #[serde(rename = "requestId")]
7752 pub request_id: RequestId,
7753 #[serde(rename = "threadId", default)]
7754 pub thread_id: String,
7755}
7756
7757#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7758#[serde(rename_all = "camelCase")]
7759pub struct SessionMigration {
7760 #[serde(default)]
7761 pub cwd: String,
7762 #[serde(default)]
7763 pub path: String,
7764 #[serde(default, skip_serializing_if = "Option::is_none")]
7765 pub title: Option<String>,
7766}
7767
7768#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7769pub enum SessionSource {
7770 #[serde(rename = "cli")]
7771 Cli,
7772 #[serde(rename = "vscode")]
7773 Vscode,
7774 #[serde(rename = "exec")]
7775 Exec,
7776 #[serde(rename = "appServer")]
7777 AppServer,
7778 #[serde(rename = "unknown")]
7779 Unknown,
7780 #[serde(rename = "custom")]
7781 Custom(String),
7782 #[serde(rename = "subAgent")]
7783 SubAgent(SubAgentSource),
7784}
7785
7786#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7787#[serde(rename_all = "camelCase")]
7788pub struct Settings {
7789 #[serde(default, skip_serializing_if = "Option::is_none")]
7790 pub developer_instructions: Option<String>,
7791 #[serde(default)]
7792 pub model: String,
7793 #[serde(default, skip_serializing_if = "Option::is_none")]
7794 pub reasoning_effort: Option<ReasoningEffort>,
7795}
7796
7797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7798#[serde(rename_all = "camelCase")]
7799pub struct SkillDependencies {
7800 #[serde(default)]
7801 pub tools: Vec<SkillToolDependency>,
7802}
7803
7804#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7805#[serde(rename_all = "camelCase")]
7806pub struct SkillErrorInfo {
7807 #[serde(default)]
7808 pub message: String,
7809 #[serde(default)]
7810 pub path: String,
7811}
7812
7813#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7814#[serde(rename_all = "camelCase")]
7815pub struct SkillInterface {
7816 #[serde(
7817 rename = "brandColor",
7818 default,
7819 skip_serializing_if = "Option::is_none"
7820 )]
7821 pub brand_color: Option<String>,
7822 #[serde(
7823 rename = "defaultPrompt",
7824 default,
7825 skip_serializing_if = "Option::is_none"
7826 )]
7827 pub default_prompt: Option<String>,
7828 #[serde(
7829 rename = "displayName",
7830 default,
7831 skip_serializing_if = "Option::is_none"
7832 )]
7833 pub display_name: Option<String>,
7834 #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
7835 pub icon_large: Option<AbsolutePathBuf>,
7836 #[serde(
7837 rename = "iconLargeUrl",
7838 default,
7839 skip_serializing_if = "Option::is_none"
7840 )]
7841 pub icon_large_url: Option<String>,
7842 #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
7843 pub icon_small: Option<AbsolutePathBuf>,
7844 #[serde(
7845 rename = "iconSmallUrl",
7846 default,
7847 skip_serializing_if = "Option::is_none"
7848 )]
7849 pub icon_small_url: Option<String>,
7850 #[serde(
7851 rename = "shortDescription",
7852 default,
7853 skip_serializing_if = "Option::is_none"
7854 )]
7855 pub short_description: Option<String>,
7856}
7857
7858#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7859#[serde(rename_all = "camelCase")]
7860pub struct SkillMetadata {
7861 #[serde(default, skip_serializing_if = "Option::is_none")]
7862 pub dependencies: Option<SkillDependencies>,
7863 #[serde(default)]
7864 pub description: String,
7865 #[serde(default)]
7866 pub enabled: bool,
7867 #[serde(default, skip_serializing_if = "Option::is_none")]
7868 pub interface: Option<SkillInterface>,
7869 #[serde(default)]
7870 pub name: String,
7871 #[serde()]
7872 pub path: LegacyAppPathString,
7873 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7874 pub plugin_id: Option<String>,
7875 #[serde()]
7876 pub scope: SkillScope,
7877 #[serde(
7878 rename = "shortDescription",
7879 default,
7880 skip_serializing_if = "Option::is_none"
7881 )]
7882 pub short_description: Option<String>,
7883}
7884
7885#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7886#[serde(rename_all = "camelCase")]
7887pub struct SkillMigration {
7888 #[serde(default)]
7889 pub name: String,
7890}
7891
7892#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7893pub enum SkillScope {
7894 #[serde(rename = "user")]
7895 User,
7896 #[serde(rename = "repo")]
7897 Repo,
7898 #[serde(rename = "system")]
7899 System,
7900 #[serde(rename = "admin")]
7901 Admin,
7902}
7903
7904#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7905#[serde(rename_all = "camelCase")]
7906pub struct SkillSummary {
7907 #[serde(default)]
7908 pub description: String,
7909 #[serde(default)]
7910 pub enabled: bool,
7911 #[serde(default, skip_serializing_if = "Option::is_none")]
7912 pub interface: Option<SkillInterface>,
7913 #[serde(default)]
7914 pub name: String,
7915 #[serde(default, skip_serializing_if = "Option::is_none")]
7916 pub path: Option<LegacyAppPathString>,
7917 #[serde(
7918 rename = "shortDescription",
7919 default,
7920 skip_serializing_if = "Option::is_none"
7921 )]
7922 pub short_description: Option<String>,
7923}
7924
7925#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7926#[serde(rename_all = "camelCase")]
7927pub struct SkillToolDependency {
7928 #[serde(default, skip_serializing_if = "Option::is_none")]
7929 pub command: Option<String>,
7930 #[serde(default, skip_serializing_if = "Option::is_none")]
7931 pub description: Option<String>,
7932 #[serde(default, skip_serializing_if = "Option::is_none")]
7933 pub transport: Option<String>,
7934 #[serde(rename = "type", default)]
7935 pub type_: String,
7936 #[serde(default, skip_serializing_if = "Option::is_none")]
7937 pub url: Option<String>,
7938 #[serde(default)]
7939 pub value: String,
7940}
7941
7942#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7943#[serde(rename_all = "camelCase")]
7944pub struct SkillsChangedNotification {
7945 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7946 pub extra: serde_json::Map<String, Value>,
7947}
7948
7949#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7950#[serde(rename_all = "camelCase")]
7951pub struct SkillsConfigWriteParams {
7952 #[serde(default)]
7953 pub enabled: bool,
7954 #[serde(default, skip_serializing_if = "Option::is_none")]
7955 pub name: Option<String>,
7956 #[serde(default, skip_serializing_if = "Option::is_none")]
7957 pub path: Option<AbsolutePathBuf>,
7958}
7959
7960#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7961#[serde(rename_all = "camelCase")]
7962pub struct SkillsConfigWriteResponse {
7963 #[serde(rename = "effectiveEnabled", default)]
7964 pub effective_enabled: bool,
7965}
7966
7967#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7968#[serde(rename_all = "camelCase")]
7969pub struct SkillsExtraRootsSetParams {
7970 #[serde(rename = "extraRoots", default)]
7971 pub extra_roots: Vec<AbsolutePathBuf>,
7972}
7973
7974#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7975#[serde(rename_all = "camelCase")]
7976pub struct SkillsExtraRootsSetResponse {
7977 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7978 pub extra: serde_json::Map<String, Value>,
7979}
7980
7981#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7982#[serde(rename_all = "camelCase")]
7983pub struct SkillsListEntry {
7984 #[serde(default)]
7985 pub cwd: String,
7986 #[serde(default)]
7987 pub errors: Vec<SkillErrorInfo>,
7988 #[serde(default)]
7989 pub skills: Vec<SkillMetadata>,
7990}
7991
7992#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7993#[serde(rename_all = "camelCase")]
7994pub struct SkillsListParams {
7995 #[serde(default, skip_serializing_if = "Option::is_none")]
7996 pub cwds: Option<Vec<String>>,
7997 #[serde(
7998 rename = "forceReload",
7999 default,
8000 skip_serializing_if = "Option::is_none"
8001 )]
8002 pub force_reload: Option<bool>,
8003}
8004
8005#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8006#[serde(rename_all = "camelCase")]
8007pub struct SkillsListResponse {
8008 #[serde(default)]
8009 pub data: Vec<SkillsListEntry>,
8010}
8011
8012#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8013pub enum SortDirection {
8014 #[serde(rename = "asc")]
8015 Asc,
8016 #[serde(rename = "desc")]
8017 Desc,
8018}
8019
8020#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8021#[serde(rename_all = "camelCase")]
8022pub struct SpendControlLimitSnapshot {
8023 #[serde(default)]
8024 pub limit: String,
8025 #[serde(rename = "remainingPercent", default)]
8026 pub remaining_percent: i64,
8027 #[serde(rename = "resetsAt", default)]
8028 pub resets_at: i64,
8029 #[serde(default)]
8030 pub used: String,
8031}
8032
8033#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8034pub enum SubAgentActivityKind {
8035 #[serde(rename = "started")]
8036 Started,
8037 #[serde(rename = "interacted")]
8038 Interacted,
8039 #[serde(rename = "interrupted")]
8040 Interrupted,
8041 #[serde(rename = "completed")]
8042 Completed,
8043}
8044
8045#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
8046pub enum SubAgentSource {
8047 #[serde(rename = "review")]
8048 Review,
8049 #[serde(rename = "compact")]
8050 Compact,
8051 #[serde(rename = "memory_consolidation")]
8052 MemoryConsolidation,
8053 #[serde(rename = "thread_spawn")]
8054 ThreadSpawn {
8055 #[serde(default, skip_serializing_if = "Option::is_none")]
8056 agent_nickname: Option<String>,
8057 #[serde(default, skip_serializing_if = "Option::is_none")]
8058 agent_path: Option<AgentPath>,
8059 #[serde(default, skip_serializing_if = "Option::is_none")]
8060 agent_role: Option<String>,
8061 depth: i64,
8062 parent_thread_id: ThreadId,
8063 },
8064 #[serde(rename = "other")]
8065 Other(String),
8066}
8067
8068#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8069#[serde(rename_all = "camelCase")]
8070pub struct SubagentMigration {
8071 #[serde(default)]
8072 pub name: String,
8073}
8074
8075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8076#[serde(rename_all = "camelCase")]
8077pub struct TerminalInteractionNotification {
8078 #[serde(rename = "itemId", default)]
8079 pub item_id: String,
8080 #[serde(rename = "processId", default)]
8081 pub process_id: String,
8082 #[serde(default)]
8083 pub stdin: String,
8084 #[serde(rename = "threadId", default)]
8085 pub thread_id: String,
8086 #[serde(rename = "turnId", default)]
8087 pub turn_id: String,
8088}
8089
8090#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8091#[serde(rename_all = "camelCase")]
8092pub struct TextElement {
8093 #[serde(rename = "byteRange", default)]
8094 pub byte_range: Value,
8095 #[serde(default, skip_serializing_if = "Option::is_none")]
8096 pub placeholder: Option<String>,
8097}
8098
8099#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8100#[serde(rename_all = "camelCase")]
8101pub struct TextPosition {
8102 #[serde(default)]
8103 pub column: i64,
8104 #[serde(default)]
8105 pub line: i64,
8106}
8107
8108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8109#[serde(rename_all = "camelCase")]
8110pub struct TextRange {
8111 #[serde()]
8112 pub end: TextPosition,
8113 #[serde()]
8114 pub start: TextPosition,
8115}
8116
8117#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8118#[serde(rename_all = "camelCase")]
8119pub struct Thread {
8120 #[serde(
8121 rename = "agentNickname",
8122 default,
8123 skip_serializing_if = "Option::is_none"
8124 )]
8125 pub agent_nickname: Option<String>,
8126 #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
8127 pub agent_role: Option<String>,
8128 #[serde(rename = "cliVersion", default)]
8129 pub cli_version: String,
8130 #[serde(rename = "createdAt", default)]
8131 pub created_at: i64,
8132 #[serde(default)]
8133 pub cwd: Value,
8134 #[serde(default)]
8135 pub ephemeral: bool,
8136 #[serde(
8137 rename = "forkedFromId",
8138 default,
8139 skip_serializing_if = "Option::is_none"
8140 )]
8141 pub forked_from_id: Option<String>,
8142 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
8143 pub git_info: Option<GitInfo>,
8144 #[serde(
8147 rename = "historyMode",
8148 default,
8149 skip_serializing_if = "Option::is_none"
8150 )]
8151 pub history_mode: Option<ThreadHistoryMode>,
8152 #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
8155 pub project_id: Option<String>,
8156 #[serde(default)]
8157 pub id: String,
8158 #[serde(default, skip_serializing_if = "Option::is_none")]
8161 pub model: Option<String>,
8162 #[serde(rename = "modelProvider", default)]
8163 pub model_provider: String,
8164 #[serde(default, skip_serializing_if = "Option::is_none")]
8165 pub name: Option<String>,
8166 #[serde(default, skip_serializing_if = "Option::is_none")]
8170 pub originator: Option<String>,
8171 #[serde(
8172 rename = "parentThreadId",
8173 default,
8174 skip_serializing_if = "Option::is_none"
8175 )]
8176 pub parent_thread_id: Option<String>,
8177 #[serde(default, skip_serializing_if = "Option::is_none")]
8178 pub path: Option<String>,
8179 #[serde(default)]
8180 pub preview: String,
8181 #[serde(
8185 rename = "reasoningEffort",
8186 default,
8187 skip_serializing_if = "Option::is_none"
8188 )]
8189 pub reasoning_effort: Option<ReasoningEffort>,
8190 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
8191 pub recency_at: Option<i64>,
8192 #[serde(default, skip_serializing_if = "Option::is_none")]
8193 pub section: Option<ThreadSection>,
8194 #[serde(
8195 rename = "sectionEnteredAt",
8196 default,
8197 skip_serializing_if = "Option::is_none"
8198 )]
8199 pub section_entered_at: Option<i64>,
8200 #[serde(rename = "sessionId", default)]
8201 pub session_id: String,
8202 #[serde(default)]
8203 pub source: Value,
8204 #[serde(default)]
8205 pub status: Value,
8206 #[serde(
8207 rename = "threadSource",
8208 default,
8209 skip_serializing_if = "Option::is_none"
8210 )]
8211 pub thread_source: Option<ThreadSource>,
8212 #[serde(default)]
8213 pub turns: Vec<Turn>,
8214 #[serde(rename = "updatedAt", default)]
8215 pub updated_at: i64,
8216}
8217
8218#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8219pub enum ThreadActiveFlag {
8220 #[serde(rename = "waitingOnApproval")]
8221 WaitingOnApproval,
8222 #[serde(rename = "waitingOnUserInput")]
8223 WaitingOnUserInput,
8224}
8225
8226#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8227#[serde(rename_all = "camelCase")]
8228pub struct ThreadApproveGuardianDeniedActionParams {
8229 #[serde(default)]
8230 pub event: Value,
8231 #[serde(rename = "threadId", default)]
8232 pub thread_id: String,
8233}
8234
8235#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8236#[serde(rename_all = "camelCase")]
8237pub struct ThreadApproveGuardianDeniedActionResponse {
8238 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8239 pub extra: serde_json::Map<String, Value>,
8240}
8241
8242#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8243#[serde(rename_all = "camelCase")]
8244pub struct ThreadArchiveParams {
8245 #[serde(rename = "threadId", default)]
8246 pub thread_id: String,
8247}
8248
8249#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8250#[serde(rename_all = "camelCase")]
8251pub struct ThreadArchiveResponse {
8252 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8253 pub extra: serde_json::Map<String, Value>,
8254}
8255
8256#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8257#[serde(rename_all = "camelCase")]
8258pub struct ThreadArchivedNotification {
8259 #[serde(rename = "threadId", default)]
8260 pub thread_id: String,
8261}
8262
8263#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8265#[serde(rename_all = "camelCase")]
8266pub struct ThreadAttachment {
8267 #[serde(rename = "attachmentType", default)]
8268 pub attachment_type: String,
8269 #[serde(rename = "createdAt", default)]
8270 pub created_at: i64,
8271 #[serde(default)]
8272 pub id: String,
8273 #[serde(rename = "identityKey", default)]
8274 pub identity_key: String,
8275 #[serde(default)]
8276 pub payload: Value,
8277}
8278
8279#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8281pub enum ThreadAttachmentAddOutcome {
8282 #[serde(rename = "created")]
8283 Created,
8284 #[serde(rename = "existing")]
8285 Existing,
8286}
8287
8288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8290#[serde(rename_all = "camelCase")]
8291pub struct ThreadAttachmentAddParams {
8292 #[serde(rename = "attachmentType", default)]
8293 pub attachment_type: String,
8294 #[serde(rename = "identityKey", default)]
8295 pub identity_key: String,
8296 #[serde(default)]
8297 pub payload: Value,
8298 #[serde(rename = "threadId", default)]
8299 pub thread_id: String,
8300}
8301
8302#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8304#[serde(rename_all = "camelCase")]
8305pub struct ThreadAttachmentAddResponse {
8306 pub attachment: ThreadAttachment,
8307 pub outcome: ThreadAttachmentAddOutcome,
8308}
8309
8310#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8312#[serde(rename_all = "camelCase")]
8313pub struct ThreadAttachmentListParams {
8314 #[serde(default, skip_serializing_if = "Option::is_none")]
8315 pub cursor: Option<String>,
8316 #[serde(default, skip_serializing_if = "Option::is_none")]
8317 pub limit: Option<i64>,
8318 #[serde(rename = "threadId", default)]
8319 pub thread_id: String,
8320}
8321
8322#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8324#[serde(rename_all = "camelCase")]
8325pub struct ThreadAttachmentListResponse {
8326 #[serde(default)]
8327 pub data: Vec<ThreadAttachment>,
8328 #[serde(
8329 rename = "nextCursor",
8330 default,
8331 skip_serializing_if = "Option::is_none"
8332 )]
8333 pub next_cursor: Option<String>,
8334}
8335
8336#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8338pub enum ThreadAttachmentOperation {
8339 #[serde(rename = "created")]
8340 Created,
8341 #[serde(rename = "deleted")]
8342 Deleted,
8343}
8344
8345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8347#[serde(rename_all = "camelCase")]
8348pub struct ThreadAttachmentOwner {
8349 #[serde(default)]
8351 pub archived: bool,
8352 #[serde(rename = "threadId", default)]
8353 pub thread_id: String,
8354}
8355
8356#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8358#[serde(rename_all = "camelCase")]
8359pub struct ThreadAttachmentOwnerListParams {
8360 #[serde(default, skip_serializing_if = "Option::is_none")]
8362 pub archived: Option<bool>,
8363 #[serde(rename = "attachmentType", default)]
8364 pub attachment_type: String,
8365 #[serde(default, skip_serializing_if = "Option::is_none")]
8366 pub cursor: Option<String>,
8367 #[serde(rename = "identityKey", default)]
8368 pub identity_key: String,
8369 #[serde(default, skip_serializing_if = "Option::is_none")]
8370 pub limit: Option<i64>,
8371}
8372
8373#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8375#[serde(rename_all = "camelCase")]
8376pub struct ThreadAttachmentOwnerListResponse {
8377 #[serde(default)]
8378 pub data: Vec<ThreadAttachmentOwner>,
8379 #[serde(
8380 rename = "nextCursor",
8381 default,
8382 skip_serializing_if = "Option::is_none"
8383 )]
8384 pub next_cursor: Option<String>,
8385}
8386
8387#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8389#[serde(rename_all = "camelCase")]
8390pub struct ThreadAttachmentRemoveParams {
8391 #[serde(rename = "attachmentType", default)]
8392 pub attachment_type: String,
8393 #[serde(rename = "identityKey", default)]
8394 pub identity_key: String,
8395 #[serde(rename = "threadId", default)]
8396 pub thread_id: String,
8397}
8398
8399#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8401#[serde(rename_all = "camelCase")]
8402pub struct ThreadAttachmentRemoveResponse {
8403 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8404 pub extra: serde_json::Map<String, Value>,
8405}
8406
8407#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8409#[serde(rename_all = "camelCase")]
8410pub struct ThreadAttachmentUpdatedNotification {
8411 #[serde(rename = "attachmentId", default)]
8412 pub attachment_id: String,
8413 #[serde(rename = "attachmentType", default)]
8414 pub attachment_type: String,
8415 #[serde(rename = "identityKey", default)]
8416 pub identity_key: String,
8417 pub operation: ThreadAttachmentOperation,
8418 #[serde(rename = "threadId", default)]
8419 pub thread_id: String,
8420}
8421
8422#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8423#[serde(rename_all = "camelCase")]
8424pub struct ThreadClosedNotification {
8425 #[serde(rename = "threadId", default)]
8426 pub thread_id: String,
8427}
8428
8429#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8430#[serde(rename_all = "camelCase")]
8431pub struct ThreadCompactStartParams {
8432 #[serde(rename = "threadId", default)]
8433 pub thread_id: String,
8434}
8435
8436#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8437#[serde(rename_all = "camelCase")]
8438pub struct ThreadCompactStartResponse {
8439 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8440 pub extra: serde_json::Map<String, Value>,
8441}
8442
8443#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8444#[serde(rename_all = "camelCase")]
8445pub struct ThreadDeleteParams {
8446 #[serde(rename = "threadId", default)]
8447 pub thread_id: String,
8448}
8449
8450#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8451#[serde(rename_all = "camelCase")]
8452pub struct ThreadDeleteResponse {
8453 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8454 pub extra: serde_json::Map<String, Value>,
8455}
8456
8457#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8458#[serde(rename_all = "camelCase")]
8459pub struct ThreadDeletedNotification {
8460 #[serde(rename = "threadId", default)]
8461 pub thread_id: String,
8462}
8463
8464#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8465#[serde(rename_all = "camelCase")]
8466pub struct ThreadForkParams {
8467 #[serde(
8468 rename = "approvalPolicy",
8469 default,
8470 skip_serializing_if = "Option::is_none"
8471 )]
8472 pub approval_policy: Option<AskForApproval>,
8473 #[serde(
8474 rename = "approvalsReviewer",
8475 default,
8476 skip_serializing_if = "Option::is_none"
8477 )]
8478 pub approvals_reviewer: Option<ApprovalsReviewer>,
8479 #[serde(
8480 rename = "baseInstructions",
8481 default,
8482 skip_serializing_if = "Option::is_none"
8483 )]
8484 pub base_instructions: Option<String>,
8485 #[serde(default, skip_serializing_if = "Option::is_none")]
8486 pub config: Option<Value>,
8487 #[serde(default, skip_serializing_if = "Option::is_none")]
8488 pub cwd: Option<String>,
8489 #[serde(
8490 rename = "developerInstructions",
8491 default,
8492 skip_serializing_if = "Option::is_none"
8493 )]
8494 pub developer_instructions: Option<String>,
8495 #[serde(default, skip_serializing_if = "Option::is_none")]
8496 pub ephemeral: Option<bool>,
8497 #[serde(
8498 rename = "excludeTurns",
8499 default,
8500 skip_serializing_if = "Option::is_none"
8501 )]
8502 pub exclude_turns: Option<bool>,
8503 #[serde(
8504 rename = "lastTurnId",
8505 default,
8506 skip_serializing_if = "Option::is_none"
8507 )]
8508 pub last_turn_id: Option<String>,
8509 #[serde(default, skip_serializing_if = "Option::is_none")]
8510 pub model: Option<String>,
8511 #[serde(
8512 rename = "modelProvider",
8513 default,
8514 skip_serializing_if = "Option::is_none"
8515 )]
8516 pub model_provider: Option<String>,
8517 #[serde(default, skip_serializing_if = "Option::is_none")]
8518 pub sandbox: Option<SandboxMode>,
8519 #[serde(
8520 rename = "serviceTier",
8521 default,
8522 skip_serializing_if = "Option::is_none"
8523 )]
8524 pub service_tier: Option<String>,
8525 #[serde(rename = "threadId", default)]
8526 pub thread_id: String,
8527 #[serde(
8528 rename = "threadSource",
8529 default,
8530 skip_serializing_if = "Option::is_none"
8531 )]
8532 pub thread_source: Option<ThreadSource>,
8533}
8534
8535#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8536#[serde(rename_all = "camelCase")]
8537pub struct ThreadForkResponse {
8538 #[serde(rename = "approvalPolicy")]
8539 pub approval_policy: AskForApproval,
8540 #[serde(rename = "approvalsReviewer", default)]
8541 pub approvals_reviewer: Value,
8542 #[serde()]
8543 pub cwd: AbsolutePathBuf,
8544 #[serde(rename = "disabledPluginIds", default)]
8547 pub disabled_plugin_ids: Vec<String>,
8548 #[serde(
8549 rename = "instructionSources",
8550 default,
8551 skip_serializing_if = "Option::is_none"
8552 )]
8553 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8554 #[serde(default)]
8555 pub model: String,
8556 #[serde(rename = "modelProvider", default)]
8557 pub model_provider: String,
8558 #[serde(
8559 rename = "reasoningEffort",
8560 default,
8561 skip_serializing_if = "Option::is_none"
8562 )]
8563 pub reasoning_effort: Option<ReasoningEffort>,
8564 #[serde(default)]
8565 pub sandbox: Value,
8566 #[serde(
8567 rename = "serviceTier",
8568 default,
8569 skip_serializing_if = "Option::is_none"
8570 )]
8571 pub service_tier: Option<String>,
8572 #[serde()]
8573 pub thread: Thread,
8574}
8575
8576#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8577#[serde(rename_all = "camelCase")]
8578pub struct ThreadGoal {
8579 #[serde(rename = "createdAt", default)]
8580 pub created_at: i64,
8581 #[serde(default)]
8582 pub objective: String,
8583 #[serde()]
8584 pub status: ThreadGoalStatus,
8585 #[serde(rename = "threadId", default)]
8586 pub thread_id: String,
8587 #[serde(rename = "timeUsedSeconds", default)]
8588 pub time_used_seconds: i64,
8589 #[serde(
8590 rename = "tokenBudget",
8591 default,
8592 skip_serializing_if = "Option::is_none"
8593 )]
8594 pub token_budget: Option<i64>,
8595 #[serde(rename = "tokensUsed", default)]
8596 pub tokens_used: i64,
8597 #[serde(rename = "updatedAt", default)]
8598 pub updated_at: i64,
8599}
8600
8601#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8602#[serde(rename_all = "camelCase")]
8603pub struct ThreadGoalClearParams {
8604 #[serde(default, skip_serializing_if = "Option::is_none")]
8606 pub origin: Option<ThreadGoalMutationOrigin>,
8607 #[serde(rename = "threadId", default)]
8608 pub thread_id: String,
8609}
8610
8611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8612#[serde(rename_all = "camelCase")]
8613pub struct ThreadGoalClearResponse {
8614 #[serde(default)]
8615 pub cleared: bool,
8616}
8617
8618#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8619#[serde(rename_all = "camelCase")]
8620pub struct ThreadGoalClearedNotification {
8621 #[serde(rename = "threadId", default)]
8622 pub thread_id: String,
8623}
8624
8625#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8626#[serde(rename_all = "camelCase")]
8627pub struct ThreadGoalGetParams {
8628 #[serde(rename = "threadId", default)]
8629 pub thread_id: String,
8630}
8631
8632#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8633#[serde(rename_all = "camelCase")]
8634pub struct ThreadGoalGetResponse {
8635 #[serde(default, skip_serializing_if = "Option::is_none")]
8636 pub goal: Option<ThreadGoal>,
8637}
8638
8639#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8641pub enum ThreadGoalMutationOrigin {
8642 #[serde(rename = "user")]
8643 User,
8644 #[serde(rename = "automatic")]
8645 Automatic,
8646}
8647
8648#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8649#[serde(rename_all = "camelCase")]
8650pub struct ThreadGoalSetParams {
8651 #[serde(default, skip_serializing_if = "Option::is_none")]
8652 pub objective: Option<String>,
8653 #[serde(default, skip_serializing_if = "Option::is_none")]
8655 pub origin: Option<ThreadGoalMutationOrigin>,
8656 #[serde(default, skip_serializing_if = "Option::is_none")]
8657 pub status: Option<ThreadGoalStatus>,
8658 #[serde(rename = "threadId", default)]
8659 pub thread_id: String,
8660 #[serde(
8661 rename = "tokenBudget",
8662 default,
8663 skip_serializing_if = "Option::is_none"
8664 )]
8665 pub token_budget: Option<i64>,
8666}
8667
8668#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8669#[serde(rename_all = "camelCase")]
8670pub struct ThreadGoalSetResponse {
8671 #[serde()]
8672 pub goal: ThreadGoal,
8673}
8674
8675#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8676pub enum ThreadGoalStatus {
8677 #[serde(rename = "active")]
8678 Active,
8679 #[serde(rename = "paused")]
8680 Paused,
8681 #[serde(rename = "blocked")]
8682 Blocked,
8683 #[serde(rename = "usageLimited")]
8684 UsageLimited,
8685 #[serde(rename = "budgetLimited")]
8686 BudgetLimited,
8687 #[serde(rename = "complete")]
8688 Complete,
8689}
8690
8691#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8692#[serde(rename_all = "camelCase")]
8693pub struct ThreadGoalUpdatedNotification {
8694 #[serde()]
8695 pub goal: ThreadGoal,
8696 #[serde(rename = "threadId", default)]
8697 pub thread_id: String,
8698 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8699 pub turn_id: Option<String>,
8700}
8701
8702#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
8703#[serde(transparent)]
8704pub struct ThreadId(pub String);
8705
8706#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8707#[serde(rename_all = "camelCase")]
8708pub struct ThreadInjectItemsParams {
8709 #[serde(default)]
8710 pub items: Vec<Value>,
8711 #[serde(rename = "threadId", default)]
8712 pub thread_id: String,
8713}
8714
8715#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8716#[serde(rename_all = "camelCase")]
8717pub struct ThreadInjectItemsResponse {
8718 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8719 pub extra: serde_json::Map<String, Value>,
8720}
8721
8722#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8724#[serde(rename_all = "camelCase")]
8725pub struct ThreadItem {
8726 #[serde(flatten)]
8727 pub payload: ThreadItemPayload,
8728 #[serde(
8730 rename = "startedAtMs",
8731 default,
8732 skip_serializing_if = "Option::is_none"
8733 )]
8734 pub started_at_ms: Option<i64>,
8735 #[serde(
8737 rename = "completedAtMs",
8738 default,
8739 skip_serializing_if = "Option::is_none"
8740 )]
8741 pub completed_at_ms: Option<i64>,
8742}
8743
8744impl ThreadItem {
8745 pub fn untimed(payload: ThreadItemPayload) -> Self {
8747 Self {
8748 payload,
8749 started_at_ms: None,
8750 completed_at_ms: None,
8751 }
8752 }
8753}
8754
8755impl From<ThreadItemPayload> for ThreadItem {
8756 fn from(payload: ThreadItemPayload) -> Self {
8757 Self::untimed(payload)
8758 }
8759}
8760
8761#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8763#[serde(tag = "type", rename_all = "camelCase")]
8764pub enum ThreadItemPayload {
8765 #[serde(rename = "userMessage")]
8766 UserMessage {
8767 #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
8768 client_id: Option<String>,
8769 content: Vec<UserInput>,
8770 id: String,
8771 },
8772 #[serde(rename = "hookPrompt")]
8773 HookPrompt {
8774 fragments: Vec<HookPromptFragment>,
8775 id: String,
8776 },
8777 #[serde(rename = "agentMessage")]
8778 AgentMessage {
8779 #[serde(default, skip_serializing_if = "Option::is_none")]
8780 delivery: Option<AgentMessageDelivery>,
8781 id: String,
8782 #[serde(
8783 rename = "memoryCitation",
8784 default,
8785 skip_serializing_if = "Option::is_none"
8786 )]
8787 memory_citation: Option<MemoryCitation>,
8788 #[serde(default, skip_serializing_if = "Option::is_none")]
8789 moderation: Option<AgentMessageModeration>,
8790 #[serde(default, skip_serializing_if = "Option::is_none")]
8791 phase: Option<MessagePhase>,
8792 #[serde(default, skip_serializing_if = "Option::is_none")]
8793 questions: Option<Vec<AsyncUserInputQuestion>>,
8794 text: String,
8795 },
8796 Plan {
8797 id: String,
8798 text: String,
8799 },
8800 Reasoning {
8801 #[serde(default, skip_serializing_if = "Option::is_none")]
8802 content: Option<Vec<String>>,
8803 id: String,
8804 #[serde(default, skip_serializing_if = "Option::is_none")]
8805 summary: Option<Vec<String>>,
8806 },
8807 #[serde(rename = "commandExecution")]
8808 CommandExecution {
8809 #[serde(
8810 rename = "aggregatedOutput",
8811 default,
8812 skip_serializing_if = "Option::is_none"
8813 )]
8814 aggregated_output: Option<String>,
8815 command: String,
8816 #[serde(rename = "commandActions")]
8817 command_actions: Vec<CommandAction>,
8818 cwd: Value,
8819 #[serde(
8820 rename = "durationMs",
8821 default,
8822 skip_serializing_if = "Option::is_none"
8823 )]
8824 duration_ms: Option<i64>,
8825 #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
8826 exit_code: Option<i64>,
8827 id: String,
8828 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8829 plugin_id: Option<String>,
8830 #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
8831 process_id: Option<String>,
8832 #[serde(
8833 rename = "scriptPath",
8834 default,
8835 skip_serializing_if = "Option::is_none"
8836 )]
8837 script_path: Option<String>,
8838 #[serde(default, skip_serializing_if = "Option::is_none")]
8839 source: Option<Value>,
8840 status: CommandExecutionStatus,
8841 },
8842 #[serde(rename = "fileChange")]
8843 FileChange {
8844 changes: Vec<FileUpdateChange>,
8845 id: String,
8846 status: PatchApplyStatus,
8847 },
8848 #[serde(rename = "mcpToolCall")]
8849 McpToolCall {
8850 #[serde(
8851 rename = "appContext",
8852 default,
8853 skip_serializing_if = "Option::is_none"
8854 )]
8855 app_context: Option<McpToolCallAppContext>,
8856 arguments: Value,
8857 #[serde(
8858 rename = "durationMs",
8859 default,
8860 skip_serializing_if = "Option::is_none"
8861 )]
8862 duration_ms: Option<i64>,
8863 #[serde(
8866 rename = "environmentId",
8867 default,
8868 skip_serializing_if = "Option::is_none"
8869 )]
8870 environment_id: Option<String>,
8871 #[serde(default, skip_serializing_if = "Option::is_none")]
8872 error: Option<McpToolCallError>,
8873 id: String,
8874 #[serde(
8877 rename = "mcpAppResourceUri",
8878 default,
8879 skip_serializing_if = "Option::is_none"
8880 )]
8881 mcp_app_resource_uri: Option<String>,
8882 #[serde(rename = "mcpAppUi", default, skip_serializing_if = "Option::is_none")]
8885 mcp_app_ui: Option<McpAppUi>,
8886 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8887 plugin_id: Option<String>,
8888 #[serde(
8889 rename = "readOnlyHint",
8890 default,
8891 skip_serializing_if = "Option::is_none"
8892 )]
8893 read_only_hint: Option<bool>,
8894 #[serde(default, skip_serializing_if = "Option::is_none")]
8895 result: Option<McpToolCallResult>,
8896 server: String,
8897 status: McpToolCallStatus,
8898 tool: String,
8899 },
8900 #[serde(rename = "dynamicToolCall")]
8901 DynamicToolCall {
8902 arguments: Value,
8903 #[serde(
8904 rename = "contentItems",
8905 default,
8906 skip_serializing_if = "Option::is_none"
8907 )]
8908 content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
8909 #[serde(
8910 rename = "durationMs",
8911 default,
8912 skip_serializing_if = "Option::is_none"
8913 )]
8914 duration_ms: Option<i64>,
8915 id: String,
8916 #[serde(default, skip_serializing_if = "Option::is_none")]
8917 namespace: Option<String>,
8918 status: DynamicToolCallStatus,
8919 #[serde(default, skip_serializing_if = "Option::is_none")]
8920 success: Option<bool>,
8921 tool: String,
8922 },
8923 #[serde(rename = "collabAgentToolCall")]
8924 CollabAgentToolCall {
8925 #[serde(rename = "agentsStates")]
8926 agents_states: std::collections::BTreeMap<String, CollabAgentState>,
8927 id: String,
8928 #[serde(default, skip_serializing_if = "Option::is_none")]
8929 model: Option<String>,
8930 #[serde(default, skip_serializing_if = "Option::is_none")]
8931 prompt: Option<String>,
8932 #[serde(
8933 rename = "reasoningEffort",
8934 default,
8935 skip_serializing_if = "Option::is_none"
8936 )]
8937 reasoning_effort: Option<ReasoningEffort>,
8938 #[serde(rename = "receiverThreadIds")]
8939 receiver_thread_ids: Vec<String>,
8940 #[serde(rename = "senderThreadId")]
8941 sender_thread_id: String,
8942 status: Value,
8943 tool: Value,
8944 },
8945 #[serde(rename = "subAgentActivity")]
8946 SubAgentActivity {
8947 #[serde(rename = "agentPath")]
8948 agent_path: String,
8949 #[serde(rename = "agentThreadId")]
8950 agent_thread_id: String,
8951 id: String,
8952 kind: SubAgentActivityKind,
8953 #[serde(default, skip_serializing_if = "Option::is_none")]
8956 model: Option<String>,
8957 #[serde(
8959 rename = "reasoningEffort",
8960 default,
8961 skip_serializing_if = "Option::is_none"
8962 )]
8963 reasoning_effort: Option<ReasoningEffort>,
8964 },
8965 #[serde(rename = "webSearch")]
8966 WebSearch {
8967 #[serde(default, skip_serializing_if = "Option::is_none")]
8968 action: Option<WebSearchAction>,
8969 id: String,
8970 query: String,
8971 #[serde(default, skip_serializing_if = "Option::is_none")]
8972 results: Option<Vec<Value>>,
8973 },
8974 #[serde(rename = "imageView")]
8975 ImageView {
8976 id: String,
8977 path: LegacyAppPathString,
8978 },
8979 Sleep {
8980 #[serde(rename = "durationMs")]
8981 duration_ms: i64,
8982 id: String,
8983 },
8984 #[serde(rename = "imageGeneration")]
8985 ImageGeneration {
8986 #[serde(default, skip_serializing_if = "Option::is_none")]
8987 failure: Option<ImageGenerationFailure>,
8988 #[serde(
8990 rename = "generationId",
8991 default,
8992 skip_serializing_if = "Option::is_none"
8993 )]
8994 generation_id: Option<String>,
8995 id: String,
8996 #[serde(flatten)]
8997 image: GeneratedImageRef,
8998 #[serde(
9000 rename = "inputImages",
9001 default,
9002 skip_serializing_if = "Option::is_none"
9003 )]
9004 input_images: Option<Vec<ImageGenerationInputImage>>,
9005 #[serde(
9006 rename = "revisedPrompt",
9007 default,
9008 skip_serializing_if = "Option::is_none"
9009 )]
9010 revised_prompt: Option<String>,
9011 #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
9012 saved_path: Option<AbsolutePathBuf>,
9013 status: String,
9014 #[serde(
9015 rename = "transparentBackground",
9016 default,
9017 skip_serializing_if = "Option::is_none"
9018 )]
9019 transparent_background: Option<bool>,
9020 },
9021 #[serde(rename = "enteredReviewMode")]
9022 EnteredReviewMode {
9023 id: String,
9024 review: String,
9025 },
9026 #[serde(rename = "exitedReviewMode")]
9027 ExitedReviewMode {
9028 id: String,
9029 review: String,
9030 },
9031 #[serde(rename = "contextCompaction")]
9032 ContextCompaction {
9033 id: String,
9034 },
9035 #[serde(rename = "functionCallOutput")]
9036 FunctionCallOutput {
9037 id: String,
9038 name: String,
9039 #[serde(default, skip_serializing_if = "Option::is_none")]
9040 namespace: Option<String>,
9041 output: FunctionCallOutputBody,
9042 },
9043}
9044
9045#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9046#[serde(untagged)]
9047pub enum ThreadListCwdFilter {
9048 Variant0(String),
9049 Variant1(Vec<String>),
9050}
9051
9052#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9053#[serde(rename_all = "camelCase")]
9054pub struct ThreadListParams {
9055 #[serde(default, skip_serializing_if = "Option::is_none")]
9056 pub archived: Option<bool>,
9057 #[serde(
9060 rename = "currentAccountOnly",
9061 default,
9062 skip_serializing_if = "Option::is_none"
9063 )]
9064 pub current_account_only: Option<bool>,
9065 #[serde(default, skip_serializing_if = "Option::is_none")]
9066 pub cursor: Option<String>,
9067 #[serde(default, skip_serializing_if = "Option::is_none")]
9068 pub cwd: Option<ThreadListCwdFilter>,
9069 #[serde(
9074 rename = "excludedThreadIds",
9075 default,
9076 skip_serializing_if = "Option::is_none"
9077 )]
9078 pub excluded_thread_ids: Option<Vec<String>>,
9079 #[serde(
9084 rename = "includedThreadIds",
9085 default,
9086 skip_serializing_if = "Option::is_none"
9087 )]
9088 pub included_thread_ids: Option<Vec<String>>,
9089 #[serde(default, skip_serializing_if = "Option::is_none")]
9090 pub limit: Option<i64>,
9091 #[serde(
9092 rename = "modelProviders",
9093 default,
9094 skip_serializing_if = "Option::is_none"
9095 )]
9096 pub model_providers: Option<Vec<String>>,
9097 #[serde(default, skip_serializing_if = "Option::is_none")]
9101 pub originators: Option<Vec<String>>,
9102 #[serde(
9103 rename = "searchTerm",
9104 default,
9105 skip_serializing_if = "Option::is_none"
9106 )]
9107 pub search_term: Option<String>,
9108 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
9109 pub section_id: Option<String>,
9110 #[serde(
9111 rename = "sortDirection",
9112 default,
9113 skip_serializing_if = "Option::is_none"
9114 )]
9115 pub sort_direction: Option<SortDirection>,
9116 #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
9117 pub sort_key: Option<ThreadSortKey>,
9118 #[serde(
9119 rename = "sourceKinds",
9120 default,
9121 skip_serializing_if = "Option::is_none"
9122 )]
9123 pub source_kinds: Option<Vec<ThreadSourceKind>>,
9124 #[serde(
9128 rename = "useStateDbOnly",
9129 default,
9130 skip_serializing_if = "Option::is_none"
9131 )]
9132 pub use_state_db_only: Option<bool>,
9133}
9134
9135#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9136#[serde(rename_all = "camelCase")]
9137pub struct ThreadListResponse {
9138 #[serde(
9139 rename = "backwardsCursor",
9140 default,
9141 skip_serializing_if = "Option::is_none"
9142 )]
9143 pub backwards_cursor: Option<String>,
9144 #[serde(default)]
9145 pub data: Vec<Thread>,
9146 #[serde(
9147 rename = "nextCursor",
9148 default,
9149 skip_serializing_if = "Option::is_none"
9150 )]
9151 pub next_cursor: Option<String>,
9152}
9153
9154#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9155#[serde(rename_all = "camelCase")]
9156pub struct ThreadLoadedListParams {
9157 #[serde(default, skip_serializing_if = "Option::is_none")]
9158 pub cursor: Option<String>,
9159 #[serde(default, skip_serializing_if = "Option::is_none")]
9160 pub limit: Option<i64>,
9161}
9162
9163#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9164#[serde(rename_all = "camelCase")]
9165pub struct ThreadLoadedListResponse {
9166 #[serde(default)]
9167 pub data: Vec<String>,
9168 #[serde(
9169 rename = "nextCursor",
9170 default,
9171 skip_serializing_if = "Option::is_none"
9172 )]
9173 pub next_cursor: Option<String>,
9174}
9175
9176#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9177#[serde(rename_all = "camelCase")]
9178pub struct ThreadMetadataGitInfoUpdateParams {
9179 #[serde(default, skip_serializing_if = "Option::is_none")]
9180 pub branch: Option<String>,
9181 #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
9182 pub origin_url: Option<String>,
9183 #[serde(default, skip_serializing_if = "Option::is_none")]
9184 pub sha: Option<String>,
9185}
9186
9187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9188#[serde(rename_all = "camelCase")]
9189pub struct ThreadMetadataUpdateParams {
9190 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
9191 pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
9192 #[serde(rename = "threadId", default)]
9193 pub thread_id: String,
9194}
9195
9196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9197#[serde(rename_all = "camelCase")]
9198pub struct ThreadMetadataUpdateResponse {
9199 #[serde()]
9200 pub thread: Thread,
9201}
9202
9203#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9204#[serde(rename_all = "camelCase")]
9205pub struct ThreadNameUpdatedNotification {
9206 #[serde(rename = "threadId", default)]
9207 pub thread_id: String,
9208 #[serde(
9209 rename = "threadName",
9210 default,
9211 skip_serializing_if = "Option::is_none"
9212 )]
9213 pub thread_name: Option<String>,
9214}
9215
9216#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9217#[serde(rename_all = "camelCase")]
9218pub struct ThreadReadParams {
9219 #[serde(
9220 rename = "includeTurns",
9221 default,
9222 skip_serializing_if = "Option::is_none"
9223 )]
9224 pub include_turns: Option<bool>,
9225 #[serde(rename = "threadId", default)]
9226 pub thread_id: String,
9227}
9228
9229#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9230#[serde(rename_all = "camelCase")]
9231pub struct ThreadReadResponse {
9232 #[serde()]
9233 pub thread: Thread,
9234}
9235
9236#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9239#[serde(rename_all = "camelCase")]
9240pub struct ThreadReadState {
9241 #[serde(
9242 rename = "firstUnread",
9243 default,
9244 skip_serializing_if = "Option::is_none"
9245 )]
9246 pub first_unread: Option<ThreadUnreadPosition>,
9247 #[serde(default)]
9248 pub revision: String,
9249}
9250
9251#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9252#[serde(rename_all = "camelCase")]
9253pub struct ThreadReadStateChangedNotification {
9254 #[serde(rename = "readState")]
9255 pub read_state: ThreadReadState,
9256 #[serde(rename = "threadId", default)]
9257 pub thread_id: String,
9258}
9259
9260#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
9262#[serde(rename_all = "camelCase")]
9263pub struct ThreadSectionChangedNotification {
9264 #[serde(rename = "threadId")]
9265 pub thread_id: String,
9266 #[serde(rename = "sectionId")]
9269 pub section_id: Option<String>,
9270}
9271
9272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9273#[serde(rename_all = "camelCase")]
9274pub struct ThreadRealtimeAudioChunk {
9275 #[serde(default)]
9276 pub data: String,
9277 #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
9278 pub item_id: Option<String>,
9279 #[serde(rename = "numChannels", default)]
9280 pub num_channels: i64,
9281 #[serde(rename = "sampleRate", default)]
9282 pub sample_rate: i64,
9283 #[serde(
9284 rename = "samplesPerChannel",
9285 default,
9286 skip_serializing_if = "Option::is_none"
9287 )]
9288 pub samples_per_channel: Option<i64>,
9289}
9290
9291#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9292#[serde(rename_all = "camelCase")]
9293pub struct ThreadRealtimeClosedNotification {
9294 #[serde(default, skip_serializing_if = "Option::is_none")]
9295 pub reason: Option<String>,
9296 #[serde(rename = "threadId", default)]
9297 pub thread_id: String,
9298}
9299
9300#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9301#[serde(rename_all = "camelCase")]
9302pub struct ThreadRealtimeErrorNotification {
9303 #[serde(default)]
9304 pub message: String,
9305 #[serde(rename = "threadId", default)]
9306 pub thread_id: String,
9307}
9308
9309#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9310#[serde(rename_all = "camelCase")]
9311pub struct ThreadRealtimeItemAddedNotification {
9312 #[serde(default)]
9313 pub item: Value,
9314 #[serde(rename = "threadId", default)]
9315 pub thread_id: String,
9316}
9317
9318#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9319#[serde(rename_all = "camelCase")]
9320pub struct ThreadRealtimeOutputAudioDeltaNotification {
9321 #[serde()]
9322 pub audio: ThreadRealtimeAudioChunk,
9323 #[serde(rename = "threadId", default)]
9324 pub thread_id: String,
9325}
9326
9327#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9328#[serde(rename_all = "camelCase")]
9329pub struct ThreadRealtimeSdpNotification {
9330 #[serde(default)]
9331 pub sdp: String,
9332 #[serde(rename = "threadId", default)]
9333 pub thread_id: String,
9334}
9335
9336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9337#[serde(rename_all = "camelCase")]
9338pub struct ThreadRealtimeStartedNotification {
9339 #[serde(
9340 rename = "realtimeSessionId",
9341 default,
9342 skip_serializing_if = "Option::is_none"
9343 )]
9344 pub realtime_session_id: Option<String>,
9345 #[serde(rename = "threadId", default)]
9346 pub thread_id: String,
9347 #[serde()]
9348 pub version: RealtimeConversationVersion,
9349}
9350
9351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9352#[serde(rename_all = "camelCase")]
9353pub struct ThreadRealtimeTranscriptDeltaNotification {
9354 #[serde(default)]
9355 pub delta: String,
9356 #[serde(default)]
9357 pub role: String,
9358 #[serde(rename = "threadId", default)]
9359 pub thread_id: String,
9360}
9361
9362#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9363#[serde(rename_all = "camelCase")]
9364pub struct ThreadRealtimeTranscriptDoneNotification {
9365 #[serde(default)]
9366 pub role: String,
9367 #[serde(default)]
9368 pub text: String,
9369 #[serde(rename = "threadId", default)]
9370 pub thread_id: String,
9371}
9372
9373#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9374#[serde(rename_all = "camelCase")]
9375pub struct ThreadResumeParams {
9376 #[serde(
9377 rename = "approvalPolicy",
9378 default,
9379 skip_serializing_if = "Option::is_none"
9380 )]
9381 pub approval_policy: Option<AskForApproval>,
9382 #[serde(
9383 rename = "approvalsReviewer",
9384 default,
9385 skip_serializing_if = "Option::is_none"
9386 )]
9387 pub approvals_reviewer: Option<ApprovalsReviewer>,
9388 #[serde(
9389 rename = "baseInstructions",
9390 default,
9391 skip_serializing_if = "Option::is_none"
9392 )]
9393 pub base_instructions: Option<String>,
9394 #[serde(default, skip_serializing_if = "Option::is_none")]
9395 pub config: Option<Value>,
9396 #[serde(default, skip_serializing_if = "Option::is_none")]
9397 pub cwd: Option<String>,
9398 #[serde(
9399 rename = "developerInstructions",
9400 default,
9401 skip_serializing_if = "Option::is_none"
9402 )]
9403 pub developer_instructions: Option<String>,
9404 #[serde(default, skip_serializing_if = "Option::is_none")]
9405 pub model: Option<String>,
9406 #[serde(
9407 rename = "modelProvider",
9408 default,
9409 skip_serializing_if = "Option::is_none"
9410 )]
9411 pub model_provider: Option<String>,
9412 #[serde(default, skip_serializing_if = "Option::is_none")]
9413 pub personality: Option<Personality>,
9414 #[serde(default, skip_serializing_if = "Option::is_none")]
9415 pub sandbox: Option<SandboxMode>,
9416 #[serde(
9417 rename = "serviceTier",
9418 default,
9419 skip_serializing_if = "Option::is_none"
9420 )]
9421 pub service_tier: Option<String>,
9422 #[serde(rename = "threadId", default)]
9423 pub thread_id: String,
9424 #[serde(
9425 rename = "excludeTurns",
9426 default,
9427 skip_serializing_if = "Option::is_none"
9428 )]
9429 pub exclude_turns: Option<bool>,
9430}
9431
9432#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9433#[serde(rename_all = "camelCase")]
9434pub struct ThreadResumeResponse {
9435 #[serde(rename = "approvalPolicy")]
9436 pub approval_policy: AskForApproval,
9437 #[serde(rename = "approvalsReviewer", default)]
9438 pub approvals_reviewer: Value,
9439 #[serde(
9442 rename = "collaborationMode",
9443 default,
9444 skip_serializing_if = "Option::is_none"
9445 )]
9446 pub collaboration_mode: Option<CollaborationMode>,
9447 #[serde()]
9448 pub cwd: AbsolutePathBuf,
9449 #[serde(rename = "disabledPluginIds", default)]
9452 pub disabled_plugin_ids: Vec<String>,
9453 #[serde(
9454 rename = "instructionSources",
9455 default,
9456 skip_serializing_if = "Option::is_none"
9457 )]
9458 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9459 #[serde(
9462 rename = "itemsBackwardsCursor",
9463 default,
9464 skip_serializing_if = "Option::is_none"
9465 )]
9466 pub items_backwards_cursor: Option<String>,
9467 #[serde(default)]
9468 pub model: String,
9469 #[serde(rename = "modelProvider", default)]
9470 pub model_provider: String,
9471 #[serde(
9472 rename = "reasoningEffort",
9473 default,
9474 skip_serializing_if = "Option::is_none"
9475 )]
9476 pub reasoning_effort: Option<ReasoningEffort>,
9477 #[serde(default)]
9478 pub sandbox: Value,
9479 #[serde(
9480 rename = "serviceTier",
9481 default,
9482 skip_serializing_if = "Option::is_none"
9483 )]
9484 pub service_tier: Option<String>,
9485 #[serde()]
9486 pub thread: Thread,
9487 #[serde(
9490 rename = "turnsBackwardsCursor",
9491 default,
9492 skip_serializing_if = "Option::is_none"
9493 )]
9494 pub turns_backwards_cursor: Option<String>,
9495}
9496
9497#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9499pub enum ThreadHistoryMode {
9500 #[serde(rename = "legacy")]
9501 Legacy,
9502 #[serde(rename = "paginated")]
9503 Paginated,
9504}
9505
9506#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9509#[serde(rename_all = "camelCase")]
9510pub struct ThreadItemEntry {
9511 #[serde(
9514 rename = "completedAtMs",
9515 default,
9516 skip_serializing_if = "Option::is_none"
9517 )]
9518 pub completed_at_ms: Option<i64>,
9519 #[serde()]
9520 pub item: ThreadItem,
9521 #[serde(
9526 rename = "outputDeferred",
9527 default,
9528 skip_serializing_if = "std::ops::Not::not"
9529 )]
9530 pub output_deferred: bool,
9531 #[serde(
9534 rename = "startedAtMs",
9535 default,
9536 skip_serializing_if = "Option::is_none"
9537 )]
9538 pub started_at_ms: Option<i64>,
9539 #[serde(rename = "turnId", default)]
9540 pub turn_id: String,
9541}
9542
9543#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9545#[serde(rename_all = "camelCase")]
9546pub struct ThreadItemsListParams {
9547 #[serde(default, skip_serializing_if = "Option::is_none")]
9553 pub cursor: Option<ThreadItemsListCursor>,
9554 #[serde(
9557 rename = "deferOutput",
9558 default,
9559 skip_serializing_if = "Option::is_none"
9560 )]
9561 pub defer_output: Option<ThreadItemOutputDeferral>,
9562 #[serde(default, skip_serializing_if = "Option::is_none")]
9563 pub limit: Option<u32>,
9564 #[serde(
9565 rename = "sortDirection",
9566 default,
9567 skip_serializing_if = "Option::is_none"
9568 )]
9569 pub sort_direction: Option<SortDirection>,
9570 #[serde(rename = "threadId", default)]
9571 pub thread_id: String,
9572 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
9574 pub turn_id: Option<String>,
9575}
9576
9577#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
9582#[serde(rename_all = "camelCase")]
9583pub struct ThreadItemOutputDeferral {
9584 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9587 pub command_execution: bool,
9588}
9589
9590#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9595#[serde(untagged)]
9596pub enum ThreadItemsListCursor {
9597 Opaque(String),
9598 Anchor(ThreadItemsListAnchor),
9599}
9600
9601#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9604#[serde(tag = "type", rename_all = "camelCase")]
9605pub enum ThreadItemsListAnchor {
9606 Item {
9607 #[serde(rename = "itemId")]
9608 item_id: String,
9609 },
9610}
9611
9612#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9614#[serde(rename_all = "camelCase")]
9615pub struct ThreadItemsListResponse {
9616 #[serde(
9617 rename = "backwardsCursor",
9618 default,
9619 skip_serializing_if = "Option::is_none"
9620 )]
9621 pub backwards_cursor: Option<String>,
9622 #[serde(default)]
9623 pub data: Vec<ThreadItemEntry>,
9624 #[serde(
9625 rename = "nextCursor",
9626 default,
9627 skip_serializing_if = "Option::is_none"
9628 )]
9629 pub next_cursor: Option<String>,
9630}
9631
9632#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9636pub struct ThreadRealtimeItem {
9637 #[serde(default)]
9638 pub id: String,
9639 #[serde(rename = "realtimeSessionId", default)]
9640 pub realtime_session_id: String,
9641 #[serde(
9644 rename = "observedAtMs",
9645 default,
9646 skip_serializing_if = "Option::is_none"
9647 )]
9648 pub observed_at_ms: Option<i64>,
9649 #[serde(flatten)]
9650 pub detail: ThreadRealtimeItemDetail,
9651}
9652
9653#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9655#[serde(tag = "type", rename_all = "camelCase")]
9656pub enum ThreadRealtimeItemDetail {
9657 #[serde(rename = "realtimeSessionStarted")]
9658 RealtimeSessionStarted,
9659 #[serde(rename = "frame")]
9663 Frame {
9664 channels: ThreadRealtimeFrameChannels,
9665 },
9666 #[serde(rename = "transcriptSegment")]
9667 TranscriptSegment {
9668 role: ThreadRealtimeTranscriptRole,
9669 text: String,
9670 },
9671 #[serde(rename = "bemItemPromoted")]
9672 BemItemPromoted {
9673 item_id: String,
9674 presentation: ThreadRealtimeBemItemPresentation,
9675 turn_id: String,
9676 },
9677 #[serde(rename = "realtimeSessionClosed")]
9678 RealtimeSessionClosed {
9679 outcome: ThreadRealtimeSessionOutcome,
9680 },
9681 #[serde(rename = "turnInputAccepted")]
9683 TurnInputAccepted {
9684 handoff_id: String,
9685 input: String,
9686 input_item_id: String,
9687 mode: ThreadRealtimeHandoffMode,
9688 source_event_ids: Vec<String>,
9689 turn_id: String,
9690 },
9691 #[serde(rename = "sessionInputSaved")]
9695 SessionInputSaved {
9696 input: String,
9697 input_item_id: String,
9698 reason: ThreadRealtimeSessionInputReason,
9699 source_event_ids: Vec<String>,
9700 },
9701}
9702
9703#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9706#[serde(rename_all = "camelCase")]
9707pub enum ThreadRealtimeSessionInputReason {
9708 Chunk,
9709 SessionEnd,
9710}
9711
9712#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
9716pub struct ThreadRealtimeFrameChannels {
9717 pub voice_transcript: ThreadRealtimeVoiceTranscript,
9718}
9719
9720#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
9722pub struct ThreadRealtimeVoiceTranscript {
9723 pub role: ThreadRealtimeTranscriptRole,
9724 pub text: String,
9725}
9726
9727#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9730#[serde(rename_all = "camelCase")]
9731pub enum ThreadRealtimeHandoffMode {
9732 Start,
9733 Steer,
9734}
9735
9736#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9739pub struct ThreadRealtimeEntry {
9740 pub item: ThreadRealtimeItem,
9741 pub position: u64,
9742}
9743
9744#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
9746#[serde(rename_all = "camelCase")]
9747pub enum ThreadRealtimeOrder {
9748 #[default]
9750 ObservedAt,
9751 Position,
9754}
9755
9756#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9759#[serde(rename_all = "camelCase")]
9760pub enum ThreadRealtimeCoverage {
9761 Unsupported,
9762 Pending,
9763 Ready,
9764}
9765
9766#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9769#[serde(tag = "type", rename_all = "camelCase")]
9770pub enum ThreadRealtimeBemItemPresentation {
9771 #[serde(rename = "wholeItem")]
9772 WholeItem,
9773 #[serde(rename = "inlineMarkdown")]
9774 InlineMarkdown,
9775 #[serde(rename = "inlineVisualization")]
9776 InlineVisualization { index: u32 },
9777}
9778
9779#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9781#[serde(rename_all = "camelCase")]
9782pub struct ThreadRealtimeItemStartedNotification {
9783 #[serde()]
9784 pub item: ThreadRealtimeItem,
9785 #[serde(rename = "threadId", default)]
9786 pub thread_id: String,
9787}
9788
9789#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9791#[serde(rename_all = "camelCase")]
9792pub struct ThreadRealtimeItemCompletedNotification {
9793 #[serde()]
9794 pub item: ThreadRealtimeItem,
9795 #[serde(rename = "threadId", default)]
9796 pub thread_id: String,
9797}
9798
9799#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9802#[serde(rename_all = "camelCase")]
9803pub struct ThreadRealtimeItemTranscriptDeltaNotification {
9804 #[serde(default)]
9805 pub delta: String,
9806 #[serde(rename = "itemId", default)]
9807 pub item_id: String,
9808 #[serde(rename = "threadId", default)]
9809 pub thread_id: String,
9810}
9811
9812#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9814pub enum ThreadRealtimeSessionOutcome {
9815 #[serde(rename = "ended")]
9816 Ended,
9817 #[serde(rename = "failed")]
9818 Failed,
9819}
9820
9821#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9823pub enum ThreadRealtimeTranscriptRole {
9824 #[serde(rename = "user")]
9825 User,
9826 #[serde(rename = "assistant")]
9827 Assistant,
9828}
9829
9830#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9834#[serde(rename_all = "camelCase")]
9835pub struct ThreadRevertParams {
9836 #[serde(rename = "beforeTurnId", default)]
9838 pub before_turn_id: String,
9839 #[serde(rename = "threadId", default)]
9840 pub thread_id: String,
9841}
9842
9843#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9846#[serde(rename_all = "camelCase")]
9847pub struct ThreadRevertResponse {
9848 #[serde(
9849 rename = "itemsBackwardsCursor",
9850 default,
9851 skip_serializing_if = "Option::is_none"
9852 )]
9853 pub items_backwards_cursor: Option<String>,
9854 #[serde()]
9855 pub thread: Thread,
9856 #[serde(
9857 rename = "turnsBackwardsCursor",
9858 default,
9859 skip_serializing_if = "Option::is_none"
9860 )]
9861 pub turns_backwards_cursor: Option<String>,
9862}
9863
9864#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9866#[serde(rename_all = "camelCase")]
9867pub struct ThreadSearchResult {
9868 pub thread: Thread,
9869 #[serde(default)]
9870 pub snippet: String,
9871}
9872
9873#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9880#[serde(rename_all = "camelCase")]
9881pub struct ThreadSearchPartialNotification {
9882 #[serde(rename = "requestId")]
9883 pub request_id: RequestId,
9884 #[serde(default)]
9885 pub data: Vec<ThreadSearchResult>,
9886}
9887
9888#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9889#[serde(rename_all = "camelCase")]
9890pub struct ThreadSection {
9891 #[serde(default, skip_serializing_if = "Option::is_none")]
9892 pub appearance: Option<ThreadSectionAppearance>,
9893 #[serde(default)]
9894 pub id: String,
9895 #[serde(default)]
9896 pub name: String,
9897}
9898
9899#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9900#[serde(rename_all = "camelCase")]
9901pub struct ThreadSectionAppearance {
9902 #[serde(default, skip_serializing_if = "Option::is_none")]
9903 pub color: Option<String>,
9904 #[serde(default, skip_serializing_if = "Option::is_none")]
9905 pub icon: Option<String>,
9906}
9907
9908#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9909#[serde(rename_all = "camelCase")]
9910pub struct ThreadSectionCreateParams {
9911 #[serde(default, skip_serializing_if = "Option::is_none")]
9912 pub appearance: Option<ThreadSectionAppearance>,
9913 #[serde(default)]
9914 pub name: String,
9915}
9916
9917#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9918#[serde(rename_all = "camelCase")]
9919pub struct ThreadSectionCreateResponse {
9920 #[serde()]
9921 pub section: ThreadSection,
9922}
9923
9924#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9925#[serde(rename_all = "camelCase")]
9926pub struct ThreadSectionDeleteParams {
9927 #[serde(rename = "sectionId", default)]
9928 pub section_id: String,
9929}
9930
9931#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9932#[serde(rename_all = "camelCase")]
9933pub struct ThreadSectionDeleteResponse {
9934 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9935 pub extra: serde_json::Map<String, Value>,
9936}
9937
9938#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9939#[serde(rename_all = "camelCase")]
9940pub struct ThreadSectionListParams {
9941 #[serde(default, skip_serializing_if = "Option::is_none")]
9942 pub cursor: Option<String>,
9943 #[serde(default, skip_serializing_if = "Option::is_none")]
9944 pub limit: Option<i64>,
9945}
9946
9947#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9948#[serde(rename_all = "camelCase")]
9949pub struct ThreadSectionListResponse {
9950 #[serde(default)]
9951 pub data: Vec<ThreadSection>,
9952 #[serde(
9953 rename = "nextCursor",
9954 default,
9955 skip_serializing_if = "Option::is_none"
9956 )]
9957 pub next_cursor: Option<String>,
9958}
9959
9960#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9961#[serde(rename_all = "camelCase")]
9962pub struct ThreadSectionMoveParams {
9963 #[serde(
9964 rename = "beforeThreadId",
9965 default,
9966 skip_serializing_if = "Option::is_none"
9967 )]
9968 pub before_thread_id: Option<String>,
9969 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
9970 pub section_id: Option<String>,
9971 #[serde(rename = "threadId", default)]
9972 pub thread_id: String,
9973}
9974
9975#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9976#[serde(rename_all = "camelCase")]
9977pub struct ThreadSectionMoveResponse {
9978 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9979 pub extra: serde_json::Map<String, Value>,
9980}
9981
9982#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9983#[serde(rename_all = "camelCase")]
9984pub struct ThreadSectionUpdateParams {
9985 #[serde(default, skip_serializing_if = "Option::is_none")]
9986 pub appearance: Option<ThreadSectionAppearance>,
9987 #[serde(default)]
9988 pub name: String,
9989 #[serde(rename = "sectionId", default)]
9990 pub section_id: String,
9991}
9992
9993#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9994#[serde(rename_all = "camelCase")]
9995pub struct ThreadSectionUpdateResponse {
9996 #[serde()]
9997 pub section: ThreadSection,
9998}
9999
10000#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10001#[serde(rename_all = "camelCase")]
10002pub struct ThreadSetNameParams {
10003 #[serde(default)]
10004 pub name: String,
10005 #[serde(rename = "threadId", default)]
10006 pub thread_id: String,
10007}
10008
10009#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10010#[serde(rename_all = "camelCase")]
10011pub struct ThreadSetNameResponse {
10012 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
10013 pub extra: serde_json::Map<String, Value>,
10014}
10015
10016#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10017#[serde(rename_all = "camelCase")]
10018pub struct ThreadSettings {
10019 #[serde(
10020 rename = "activePermissionProfile",
10021 default,
10022 skip_serializing_if = "Option::is_none"
10023 )]
10024 pub active_permission_profile: Option<ActivePermissionProfile>,
10025 #[serde(rename = "approvalPolicy")]
10026 pub approval_policy: AskForApproval,
10027 #[serde(rename = "approvalsReviewer")]
10028 pub approvals_reviewer: ApprovalsReviewer,
10029 #[serde(rename = "collaborationMode")]
10030 pub collaboration_mode: CollaborationMode,
10031 #[serde()]
10032 pub cwd: AbsolutePathBuf,
10033 #[serde(rename = "disabledPluginIds", default)]
10036 pub disabled_plugin_ids: Vec<String>,
10037 #[serde(default, skip_serializing_if = "Option::is_none")]
10038 pub effort: Option<ReasoningEffort>,
10039 #[serde(default)]
10040 pub model: String,
10041 #[serde(rename = "modelProvider", default)]
10042 pub model_provider: String,
10043 #[serde(default, skip_serializing_if = "Option::is_none")]
10044 pub personality: Option<Personality>,
10045 #[serde(rename = "sandboxPolicy")]
10046 pub sandbox_policy: SandboxPolicy,
10047 #[serde(
10048 rename = "serviceTier",
10049 default,
10050 skip_serializing_if = "Option::is_none"
10051 )]
10052 pub service_tier: Option<String>,
10053 #[serde(default, skip_serializing_if = "Option::is_none")]
10054 pub summary: Option<ReasoningSummary>,
10055}
10056
10057#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10058#[serde(rename_all = "camelCase")]
10059pub struct ThreadSettingsUpdatedNotification {
10060 #[serde(rename = "threadId", default)]
10061 pub thread_id: String,
10062 #[serde(rename = "threadSettings")]
10063 pub thread_settings: ThreadSettings,
10064}
10065
10066#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10067#[serde(rename_all = "camelCase")]
10068pub struct ThreadShellCommandParams {
10069 #[serde(default)]
10070 pub command: String,
10071 #[serde(rename = "threadId", default)]
10072 pub thread_id: String,
10073 #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
10076 pub timeout_ms: Option<i64>,
10077}
10078
10079#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10080#[serde(rename_all = "camelCase")]
10081pub struct ThreadShellCommandResponse {
10082 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
10083 pub extra: serde_json::Map<String, Value>,
10084}
10085
10086#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10087pub enum ThreadSortKey {
10088 #[serde(rename = "created_at")]
10089 Created_at,
10090 #[serde(rename = "updated_at")]
10091 Updated_at,
10092 #[serde(rename = "recency_at")]
10093 Recency_at,
10094 #[serde(rename = "section_position")]
10095 Section_position,
10096}
10097
10098#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
10099#[serde(transparent)]
10100pub struct ThreadSource(pub String);
10101
10102#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10103pub enum ThreadSourceKind {
10104 #[serde(rename = "cli")]
10105 Cli,
10106 #[serde(rename = "vscode")]
10107 Vscode,
10108 #[serde(rename = "exec")]
10109 Exec,
10110 #[serde(rename = "appServer")]
10111 AppServer,
10112 #[serde(rename = "subAgent")]
10113 SubAgent,
10114 #[serde(rename = "subAgentReview")]
10115 SubAgentReview,
10116 #[serde(rename = "subAgentCompact")]
10117 SubAgentCompact,
10118 #[serde(rename = "subAgentThreadSpawn")]
10119 SubAgentThreadSpawn,
10120 #[serde(rename = "subAgentOther")]
10121 SubAgentOther,
10122 #[serde(rename = "unknown")]
10123 Unknown,
10124}
10125
10126#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10127#[serde(rename_all = "camelCase")]
10128pub struct ThreadStartParams {
10129 #[serde(
10130 rename = "approvalPolicy",
10131 default,
10132 skip_serializing_if = "Option::is_none"
10133 )]
10134 pub approval_policy: Option<AskForApproval>,
10135 #[serde(
10136 rename = "approvalsReviewer",
10137 default,
10138 skip_serializing_if = "Option::is_none"
10139 )]
10140 pub approvals_reviewer: Option<ApprovalsReviewer>,
10141 #[serde(
10142 rename = "baseInstructions",
10143 default,
10144 skip_serializing_if = "Option::is_none"
10145 )]
10146 pub base_instructions: Option<String>,
10147 #[serde(default, skip_serializing_if = "Option::is_none")]
10148 pub config: Option<Value>,
10149 #[serde(default, skip_serializing_if = "Option::is_none")]
10150 pub cwd: Option<String>,
10151 #[serde(
10152 rename = "developerInstructions",
10153 default,
10154 skip_serializing_if = "Option::is_none"
10155 )]
10156 pub developer_instructions: Option<String>,
10157 #[serde(default, skip_serializing_if = "Option::is_none")]
10158 pub ephemeral: Option<bool>,
10159 #[serde(default, skip_serializing_if = "Option::is_none")]
10160 pub model: Option<String>,
10161 #[serde(
10162 rename = "modelProvider",
10163 default,
10164 skip_serializing_if = "Option::is_none"
10165 )]
10166 pub model_provider: Option<String>,
10167 #[serde(default, skip_serializing_if = "Option::is_none")]
10168 pub personality: Option<Personality>,
10169 #[serde(default, skip_serializing_if = "Option::is_none")]
10170 pub sandbox: Option<SandboxMode>,
10171 #[serde(
10172 rename = "serviceName",
10173 default,
10174 skip_serializing_if = "Option::is_none"
10175 )]
10176 pub service_name: Option<String>,
10177 #[serde(
10178 rename = "serviceTier",
10179 default,
10180 skip_serializing_if = "Option::is_none"
10181 )]
10182 pub service_tier: Option<String>,
10183 #[serde(
10184 rename = "sessionStartSource",
10185 default,
10186 skip_serializing_if = "Option::is_none"
10187 )]
10188 pub session_start_source: Option<ThreadStartSource>,
10189 #[serde(
10190 rename = "threadSource",
10191 default,
10192 skip_serializing_if = "Option::is_none"
10193 )]
10194 pub thread_source: Option<ThreadSource>,
10195}
10196
10197#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10198#[serde(rename_all = "camelCase")]
10199pub struct ThreadStartResponse {
10200 #[serde(rename = "approvalPolicy")]
10201 pub approval_policy: AskForApproval,
10202 #[serde(rename = "approvalsReviewer", default)]
10203 pub approvals_reviewer: Value,
10204 #[serde()]
10205 pub cwd: AbsolutePathBuf,
10206 #[serde(rename = "disabledPluginIds", default)]
10209 pub disabled_plugin_ids: Vec<String>,
10210 #[serde(
10211 rename = "instructionSources",
10212 default,
10213 skip_serializing_if = "Option::is_none"
10214 )]
10215 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
10216 #[serde(default)]
10217 pub model: String,
10218 #[serde(rename = "modelProvider", default)]
10219 pub model_provider: String,
10220 #[serde(
10221 rename = "reasoningEffort",
10222 default,
10223 skip_serializing_if = "Option::is_none"
10224 )]
10225 pub reasoning_effort: Option<ReasoningEffort>,
10226 #[serde(default)]
10227 pub sandbox: Value,
10228 #[serde(
10229 rename = "serviceTier",
10230 default,
10231 skip_serializing_if = "Option::is_none"
10232 )]
10233 pub service_tier: Option<String>,
10234 #[serde()]
10235 pub thread: Thread,
10236}
10237
10238#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10239pub enum ThreadStartSource {
10240 #[serde(rename = "startup")]
10241 Startup,
10242 #[serde(rename = "clear")]
10243 Clear,
10244}
10245
10246#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10247#[serde(rename_all = "camelCase")]
10248pub struct ThreadStartedNotification {
10249 #[serde()]
10250 pub thread: Thread,
10251}
10252
10253#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10254#[serde(tag = "type", rename_all = "camelCase")]
10255pub enum ThreadStatus {
10256 #[serde(rename = "notLoaded")]
10257 NotLoaded,
10258 Idle,
10259 #[serde(rename = "systemError")]
10260 SystemError,
10261 Active {
10262 #[serde(rename = "activeFlags")]
10263 active_flags: Vec<ThreadActiveFlag>,
10264 },
10265}
10266
10267#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10268#[serde(rename_all = "camelCase")]
10269pub struct ThreadStatusChangedNotification {
10270 #[serde()]
10271 pub status: ThreadStatus,
10272 #[serde(rename = "threadId", default)]
10273 pub thread_id: String,
10274}
10275
10276#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10277#[serde(rename_all = "camelCase")]
10278pub struct ThreadTokenUsage {
10279 #[serde()]
10280 pub last: TokenUsageBreakdown,
10281 #[serde(
10282 rename = "modelContextWindow",
10283 default,
10284 skip_serializing_if = "Option::is_none"
10285 )]
10286 pub model_context_window: Option<i64>,
10287 #[serde()]
10288 pub total: TokenUsageBreakdown,
10289}
10290
10291#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10292#[serde(rename_all = "camelCase")]
10293pub struct ThreadTokenUsageUpdatedNotification {
10294 #[serde(rename = "threadId", default)]
10295 pub thread_id: String,
10296 #[serde(rename = "tokenUsage")]
10297 pub token_usage: ThreadTokenUsage,
10298 #[serde(rename = "turnId", default)]
10299 pub turn_id: String,
10300}
10301
10302#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10303#[serde(rename_all = "camelCase")]
10304pub struct ThreadUnarchiveParams {
10305 #[serde(rename = "threadId", default)]
10306 pub thread_id: String,
10307}
10308
10309#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10310#[serde(rename_all = "camelCase")]
10311pub struct ThreadUnarchiveResponse {
10312 #[serde()]
10313 pub thread: Thread,
10314}
10315
10316#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10317#[serde(rename_all = "camelCase")]
10318pub struct ThreadUnarchivedNotification {
10319 #[serde(rename = "threadId", default)]
10320 pub thread_id: String,
10321}
10322
10323#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10324#[serde(tag = "type", rename_all = "camelCase")]
10325pub enum ThreadUnreadPosition {
10326 #[serde(rename = "threadStart")]
10328 ThreadStart,
10329 Turn {
10331 #[serde(rename = "turnId")]
10332 turn_id: String,
10333 },
10334}
10335
10336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10341#[serde(tag = "type", rename_all = "camelCase")]
10342#[allow(clippy::large_enum_variant)] pub enum ThreadTimelineEntry {
10344 Item {
10345 item: ThreadItem,
10346 position: u64,
10347 #[serde(rename = "turnId")]
10348 turn_id: String,
10349 },
10350 Realtime {
10351 item: ThreadRealtimeItem,
10352 position: u64,
10353 },
10354 TurnStarted {
10355 position: u64,
10356 #[serde(default, skip_serializing_if = "Option::is_none")]
10357 started_at: Option<i64>,
10358 turn_id: String,
10359 },
10360 TurnCompleted {
10361 #[serde(default, skip_serializing_if = "Option::is_none")]
10362 completed_at: Option<i64>,
10363 #[serde(default, skip_serializing_if = "Option::is_none")]
10364 duration_ms: Option<i64>,
10365 #[serde(default, skip_serializing_if = "Option::is_none")]
10366 error: Option<TurnError>,
10367 position: u64,
10368 #[serde(default, skip_serializing_if = "Option::is_none")]
10369 started_at: Option<i64>,
10370 status: TurnStatus,
10371 turn_id: String,
10372 },
10373}
10374
10375#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10377#[serde(rename_all = "camelCase")]
10378pub struct ThreadTurnsListParams {
10379 #[serde(default, skip_serializing_if = "Option::is_none")]
10380 pub cursor: Option<String>,
10381 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
10383 pub items_view: Option<TurnItemsView>,
10384 #[serde(default, skip_serializing_if = "Option::is_none")]
10385 pub limit: Option<u32>,
10386 #[serde(
10387 rename = "sortDirection",
10388 default,
10389 skip_serializing_if = "Option::is_none"
10390 )]
10391 pub sort_direction: Option<SortDirection>,
10392 #[serde(rename = "threadId", default)]
10393 pub thread_id: String,
10394}
10395
10396#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10398#[serde(rename_all = "camelCase")]
10399pub struct ThreadTurnsListResponse {
10400 #[serde(
10401 rename = "backwardsCursor",
10402 default,
10403 skip_serializing_if = "Option::is_none"
10404 )]
10405 pub backwards_cursor: Option<String>,
10406 #[serde(default)]
10407 pub data: Vec<Turn>,
10408 #[serde(
10409 rename = "nextCursor",
10410 default,
10411 skip_serializing_if = "Option::is_none"
10412 )]
10413 pub next_cursor: Option<String>,
10414}
10415
10416#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10417#[serde(rename_all = "camelCase")]
10418pub struct ThreadUnsubscribeParams {
10419 #[serde(rename = "threadId", default)]
10420 pub thread_id: String,
10421}
10422
10423#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10424#[serde(rename_all = "camelCase")]
10425pub struct ThreadUnsubscribeResponse {
10426 #[serde()]
10427 pub status: ThreadUnsubscribeStatus,
10428}
10429
10430#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10431pub enum ThreadUnsubscribeStatus {
10432 #[serde(rename = "notLoaded")]
10433 NotLoaded,
10434 #[serde(rename = "notSubscribed")]
10435 NotSubscribed,
10436 #[serde(rename = "unsubscribed")]
10437 Unsubscribed,
10438}
10439
10440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10441#[serde(rename_all = "camelCase")]
10442pub struct TokenUsageBreakdown {
10443 #[serde(
10444 rename = "cacheWriteInputTokens",
10445 default,
10446 skip_serializing_if = "Option::is_none"
10447 )]
10448 pub cache_write_input_tokens: Option<i64>,
10449 #[serde(rename = "cachedInputTokens", default)]
10450 pub cached_input_tokens: i64,
10451 #[serde(rename = "inputTokens", default)]
10452 pub input_tokens: i64,
10453 #[serde(rename = "outputTokens", default)]
10454 pub output_tokens: i64,
10455 #[serde(rename = "reasoningOutputTokens", default)]
10456 pub reasoning_output_tokens: i64,
10457 #[serde(rename = "totalTokens", default)]
10458 pub total_tokens: i64,
10459}
10460
10461#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10462#[serde(rename_all = "camelCase")]
10463pub struct Tool {
10464 #[serde(default, skip_serializing_if = "Option::is_none")]
10465 pub _meta: Option<Value>,
10466 #[serde(default, skip_serializing_if = "Option::is_none")]
10467 pub annotations: Option<Value>,
10468 #[serde(default, skip_serializing_if = "Option::is_none")]
10469 pub description: Option<String>,
10470 #[serde(default, skip_serializing_if = "Option::is_none")]
10471 pub icons: Option<Vec<Value>>,
10472 #[serde(rename = "inputSchema", default)]
10473 pub input_schema: Value,
10474 #[serde(default)]
10475 pub name: String,
10476 #[serde(
10477 rename = "outputSchema",
10478 default,
10479 skip_serializing_if = "Option::is_none"
10480 )]
10481 pub output_schema: Option<Value>,
10482 #[serde(default, skip_serializing_if = "Option::is_none")]
10483 pub title: Option<String>,
10484}
10485
10486#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10487#[serde(rename_all = "camelCase")]
10488pub struct ToolRequestUserInputAnswer {
10489 #[serde(default)]
10490 pub answers: Vec<String>,
10491}
10492
10493#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10494#[serde(rename_all = "camelCase")]
10495pub struct ToolRequestUserInputOption {
10496 #[serde(default)]
10497 pub description: String,
10498 #[serde(default)]
10499 pub label: String,
10500}
10501
10502#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10503#[serde(rename_all = "camelCase")]
10504pub struct ToolRequestUserInputParams {
10505 #[serde(
10506 rename = "autoResolutionMs",
10507 default,
10508 skip_serializing_if = "Option::is_none"
10509 )]
10510 pub auto_resolution_ms: Option<i64>,
10511 #[serde(rename = "isBlocking", default)]
10512 pub is_blocking: bool,
10513 #[serde(rename = "itemId", default)]
10514 pub item_id: String,
10515 #[serde(default)]
10516 pub questions: Vec<ToolRequestUserInputQuestion>,
10517 #[serde(rename = "threadId", default)]
10518 pub thread_id: String,
10519 #[serde(rename = "turnId", default)]
10520 pub turn_id: String,
10521}
10522
10523#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10524#[serde(rename_all = "camelCase")]
10525pub struct ToolRequestUserInputQuestion {
10526 #[serde(default)]
10527 pub header: String,
10528 #[serde(default)]
10529 pub id: String,
10530 #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
10531 pub is_other: Option<bool>,
10532 #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
10533 pub is_secret: Option<bool>,
10534 #[serde(default, skip_serializing_if = "Option::is_none")]
10535 pub options: Option<Vec<ToolRequestUserInputOption>>,
10536 #[serde(default)]
10537 pub question: String,
10538}
10539
10540#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10541#[serde(rename_all = "camelCase")]
10542pub struct ToolRequestUserInputResponse {
10543 #[serde(default)]
10544 pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
10545}
10546
10547#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10548#[serde(rename_all = "camelCase")]
10549pub struct ToolsV2 {
10550 #[serde(default, skip_serializing_if = "Option::is_none")]
10551 pub web_search: Option<WebSearchToolConfig>,
10552}
10553
10554#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10555#[serde(rename_all = "camelCase")]
10556pub struct Turn {
10557 #[serde(
10558 rename = "completedAt",
10559 default,
10560 skip_serializing_if = "Option::is_none"
10561 )]
10562 pub completed_at: Option<i64>,
10563 #[serde(
10564 rename = "durationMs",
10565 default,
10566 skip_serializing_if = "Option::is_none"
10567 )]
10568 pub duration_ms: Option<i64>,
10569 #[serde(default, skip_serializing_if = "Option::is_none")]
10570 pub error: Option<TurnError>,
10571 #[serde(default)]
10572 pub id: String,
10573 #[serde(default)]
10574 pub items: Vec<ThreadItem>,
10575 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
10576 pub items_view: Option<Value>,
10577 #[serde(
10581 rename = "rootTurnId",
10582 default,
10583 skip_serializing_if = "Option::is_none"
10584 )]
10585 pub root_turn_id: Option<String>,
10586 #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
10587 pub started_at: Option<i64>,
10588 #[serde()]
10589 pub status: TurnStatus,
10590}
10591
10592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10593#[serde(rename_all = "camelCase")]
10594pub struct TurnCompletedNotification {
10595 #[serde(rename = "threadId", default)]
10596 pub thread_id: String,
10597 #[serde()]
10598 pub turn: Turn,
10599}
10600
10601#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10602#[serde(rename_all = "camelCase")]
10603pub struct TurnDiffUpdatedNotification {
10604 #[serde(default)]
10605 pub diff: String,
10606 #[serde(rename = "threadId", default)]
10607 pub thread_id: String,
10608 #[serde(rename = "turnId", default)]
10609 pub turn_id: String,
10610}
10611
10612#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10613#[serde(rename_all = "camelCase")]
10614pub struct TurnError {
10615 #[serde(
10616 rename = "additionalDetails",
10617 default,
10618 skip_serializing_if = "Option::is_none"
10619 )]
10620 pub additional_details: Option<String>,
10621 #[serde(
10622 rename = "codexErrorInfo",
10623 default,
10624 skip_serializing_if = "Option::is_none"
10625 )]
10626 pub codex_error_info: Option<CodexErrorInfo>,
10627 #[serde(default)]
10628 pub message: String,
10629 #[serde(default, skip_serializing_if = "Option::is_none")]
10632 pub misalignment: Option<MisalignmentErrorDetails>,
10633}
10634
10635#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10636#[serde(rename_all = "camelCase")]
10637pub struct TurnInterruptParams {
10638 #[serde(rename = "threadId", default)]
10639 pub thread_id: String,
10640 #[serde(rename = "turnId", default)]
10641 pub turn_id: String,
10642}
10643
10644#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10645#[serde(rename_all = "camelCase")]
10646pub struct TurnInterruptResponse {
10647 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
10648 pub extra: serde_json::Map<String, Value>,
10649}
10650
10651#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
10652pub enum TurnItemsView {
10653 #[serde(rename = "notLoaded")]
10654 NotLoaded,
10655 #[serde(rename = "summary")]
10656 Summary,
10657 #[serde(rename = "full")]
10658 Full,
10659}
10660
10661#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10662#[serde(rename_all = "camelCase")]
10663pub struct TurnModerationMetadataNotification {
10664 #[serde(default)]
10665 pub metadata: Value,
10666 #[serde(rename = "threadId", default)]
10667 pub thread_id: String,
10668 #[serde(rename = "turnId", default)]
10669 pub turn_id: String,
10670}
10671
10672#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10673#[serde(rename_all = "camelCase")]
10674pub struct TurnPlanStep {
10675 #[serde()]
10676 pub status: TurnPlanStepStatus,
10677 #[serde(default)]
10678 pub step: String,
10679}
10680
10681#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10682pub enum TurnPlanStepStatus {
10683 #[serde(rename = "pending")]
10684 Pending,
10685 #[serde(rename = "inProgress")]
10686 InProgress,
10687 #[serde(rename = "completed")]
10688 Completed,
10689}
10690
10691#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10692#[serde(rename_all = "camelCase")]
10693pub struct TurnPlanUpdatedNotification {
10694 #[serde(default, skip_serializing_if = "Option::is_none")]
10695 pub explanation: Option<String>,
10696 #[serde(default)]
10697 pub plan: Vec<TurnPlanStep>,
10698 #[serde(rename = "threadId", default)]
10699 pub thread_id: String,
10700 #[serde(rename = "turnId", default)]
10701 pub turn_id: String,
10702}
10703
10704#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10705#[serde(rename_all = "camelCase")]
10706pub struct TurnStartParams {
10707 #[serde(
10708 rename = "approvalPolicy",
10709 default,
10710 skip_serializing_if = "Option::is_none"
10711 )]
10712 pub approval_policy: Option<AskForApproval>,
10713 #[serde(
10714 rename = "approvalsReviewer",
10715 default,
10716 skip_serializing_if = "Option::is_none"
10717 )]
10718 pub approvals_reviewer: Option<ApprovalsReviewer>,
10719 #[serde(
10720 rename = "clientUserMessageId",
10721 default,
10722 skip_serializing_if = "Option::is_none"
10723 )]
10724 pub client_user_message_id: Option<String>,
10725 #[serde(default, skip_serializing_if = "Option::is_none")]
10726 pub cwd: Option<String>,
10727 #[serde(
10730 rename = "disabledPluginIds",
10731 default,
10732 skip_serializing_if = "Option::is_none"
10733 )]
10734 pub disabled_plugin_ids: Option<Vec<String>>,
10735 #[serde(default, skip_serializing_if = "Option::is_none")]
10736 pub effort: Option<ReasoningEffort>,
10737 #[serde(default)]
10738 pub input: Vec<UserInput>,
10739 #[serde(default, skip_serializing_if = "Option::is_none")]
10740 pub model: Option<String>,
10741 #[serde(
10742 rename = "outputSchema",
10743 default,
10744 skip_serializing_if = "Option::is_none"
10745 )]
10746 pub output_schema: Option<Value>,
10747 #[serde(
10751 rename = "parentTurnId",
10752 default,
10753 skip_serializing_if = "Option::is_none"
10754 )]
10755 pub parent_turn_id: Option<String>,
10756 #[serde(default, skip_serializing_if = "Option::is_none")]
10757 pub personality: Option<Personality>,
10758 #[serde(
10763 rename = "rootTurnId",
10764 default,
10765 skip_serializing_if = "Option::is_none"
10766 )]
10767 pub root_turn_id: Option<String>,
10768 #[serde(
10769 rename = "sandboxPolicy",
10770 default,
10771 skip_serializing_if = "Option::is_none"
10772 )]
10773 pub sandbox_policy: Option<SandboxPolicy>,
10774 #[serde(
10775 rename = "serviceTier",
10776 default,
10777 skip_serializing_if = "Option::is_none"
10778 )]
10779 pub service_tier: Option<String>,
10780 #[serde(
10783 rename = "serviceTierForTurn",
10784 default,
10785 skip_serializing_if = "Option::is_none"
10786 )]
10787 pub service_tier_for_turn: Option<String>,
10788 #[serde(default, skip_serializing_if = "Option::is_none")]
10789 pub summary: Option<ReasoningSummary>,
10790 #[serde(rename = "threadId", default)]
10791 pub thread_id: String,
10792 #[serde(
10795 rename = "toolOutput",
10796 default,
10797 skip_serializing_if = "Option::is_none"
10798 )]
10799 pub tool_output: Option<TurnToolOutput>,
10800 #[serde(
10803 rename = "turnTrigger",
10804 default,
10805 skip_serializing_if = "Option::is_none"
10806 )]
10807 pub turn_trigger: Option<String>,
10808}
10809
10810#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10811#[serde(rename_all = "camelCase")]
10812pub struct TurnStartResponse {
10813 #[serde()]
10814 pub turn: Turn,
10815}
10816
10817#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10818#[serde(rename_all = "camelCase")]
10819pub struct TurnStartedNotification {
10820 #[serde(rename = "threadId", default)]
10821 pub thread_id: String,
10822 #[serde()]
10823 pub turn: Turn,
10824}
10825
10826#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10827pub enum TurnStatus {
10828 #[serde(rename = "completed")]
10829 Completed,
10830 #[serde(rename = "interrupted")]
10831 Interrupted,
10832 #[serde(rename = "failed")]
10833 Failed,
10834 #[serde(rename = "inProgress")]
10835 InProgress,
10836}
10837
10838#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10841#[serde(rename_all = "camelCase")]
10842pub struct TurnToolOutput {
10843 #[serde(default)]
10844 pub name: String,
10845 #[serde(default, skip_serializing_if = "Option::is_none")]
10846 pub namespace: Option<String>,
10847 #[serde()]
10848 pub output: FunctionCallOutputBody,
10849 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
10852 pub retain: bool,
10853}
10854
10855#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10856#[serde(rename_all = "camelCase")]
10857pub struct TurnSteerParams {
10858 #[serde(
10859 rename = "clientUserMessageId",
10860 default,
10861 skip_serializing_if = "Option::is_none"
10862 )]
10863 pub client_user_message_id: Option<String>,
10864 #[serde(rename = "expectedTurnId", default)]
10865 pub expected_turn_id: String,
10866 #[serde(default)]
10867 pub input: Vec<UserInput>,
10868 #[serde(rename = "threadId", default)]
10869 pub thread_id: String,
10870}
10871
10872#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10873#[serde(rename_all = "camelCase")]
10874pub struct TurnSteerResponse {
10875 #[serde(rename = "turnId", default)]
10876 pub turn_id: String,
10877}
10878
10879#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10880#[serde(tag = "type", rename_all = "camelCase")]
10881pub enum UserInput {
10882 Text {
10883 text: String,
10884 #[serde(default, skip_serializing_if = "Option::is_none")]
10885 text_elements: Option<Vec<TextElement>>,
10886 },
10887 Image {
10888 #[serde(default, skip_serializing_if = "Option::is_none")]
10889 detail: Option<ImageDetail>,
10890 #[serde(flatten)]
10891 image: UserInputImageReference,
10892 },
10893 #[serde(rename = "localImage")]
10894 LocalImage {
10895 #[serde(default, skip_serializing_if = "Option::is_none")]
10896 detail: Option<ImageDetail>,
10897 path: String,
10898 },
10899 Audio {
10900 #[serde(flatten)]
10901 audio: UserInputAudioReference,
10902 },
10903 #[serde(rename = "localAudio")]
10904 LocalAudio {
10905 path: String,
10906 },
10907 Skill {
10908 name: String,
10909 path: String,
10910 },
10911 Mention {
10912 name: String,
10913 path: String,
10914 },
10915}
10916
10917#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10923#[serde(untagged)]
10924pub enum UserInputImageReference {
10925 Inline {
10926 url: String,
10927 },
10928 File {
10929 #[serde(rename = "fileId")]
10930 file_id: String,
10931 },
10932}
10933
10934#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10940#[serde(untagged)]
10941pub enum UserInputAudioReference {
10942 Inline {
10943 url: String,
10944 },
10945 File {
10946 #[serde(rename = "fileId")]
10947 file_id: String,
10948 },
10949}
10950
10951#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10952pub enum Verbosity {
10953 #[serde(rename = "low")]
10954 Low,
10955 #[serde(rename = "medium")]
10956 Medium,
10957 #[serde(rename = "high")]
10958 High,
10959}
10960
10961#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10962#[serde(rename_all = "camelCase")]
10963pub struct WarningNotification {
10964 #[serde(default)]
10965 pub message: String,
10966 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
10967 pub thread_id: Option<String>,
10968}
10969
10970#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10971#[serde(tag = "type", rename_all = "camelCase")]
10972pub enum WebSearchAction {
10973 Search {
10974 #[serde(default, skip_serializing_if = "Option::is_none")]
10975 queries: Option<Vec<String>>,
10976 #[serde(default, skip_serializing_if = "Option::is_none")]
10977 query: Option<String>,
10978 },
10979 #[serde(rename = "openPage")]
10980 OpenPage {
10981 #[serde(default, skip_serializing_if = "Option::is_none")]
10982 url: Option<String>,
10983 },
10984 #[serde(rename = "findInPage")]
10985 FindInPage {
10986 #[serde(default, skip_serializing_if = "Option::is_none")]
10987 pattern: Option<String>,
10988 #[serde(default, skip_serializing_if = "Option::is_none")]
10989 url: Option<String>,
10990 },
10991 Other,
10992}
10993
10994#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10995pub enum WebSearchContextSize {
10996 #[serde(rename = "low")]
10997 Low,
10998 #[serde(rename = "medium")]
10999 Medium,
11000 #[serde(rename = "high")]
11001 High,
11002}
11003
11004#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
11005#[serde(rename_all = "camelCase")]
11006pub struct WebSearchLocation {
11007 #[serde(default, skip_serializing_if = "Option::is_none")]
11008 pub city: Option<String>,
11009 #[serde(default, skip_serializing_if = "Option::is_none")]
11010 pub country: Option<String>,
11011 #[serde(default, skip_serializing_if = "Option::is_none")]
11012 pub region: Option<String>,
11013 #[serde(default, skip_serializing_if = "Option::is_none")]
11014 pub timezone: Option<String>,
11015}
11016
11017#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11018pub enum WebSearchMode {
11019 #[serde(rename = "disabled")]
11020 Disabled,
11021 #[serde(rename = "cached")]
11022 Cached,
11023 #[serde(rename = "indexed")]
11024 Indexed,
11025 #[serde(rename = "live")]
11026 Live,
11027}
11028
11029#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11032pub enum WebSearchProvider {
11033 #[serde(rename = "standalone")]
11034 Standalone,
11035 #[serde(rename = "search_mcp")]
11036 SearchMcp,
11037}
11038
11039#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
11040#[serde(rename_all = "camelCase")]
11041pub struct WebSearchToolConfig {
11042 #[serde(default, skip_serializing_if = "Option::is_none")]
11043 pub allowed_domains: Option<Vec<String>>,
11044 #[serde(default, skip_serializing_if = "Option::is_none")]
11045 pub context_size: Option<WebSearchContextSize>,
11046 #[serde(default, skip_serializing_if = "Option::is_none")]
11047 pub location: Option<WebSearchLocation>,
11048}
11049
11050#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11051pub enum WindowsSandboxReadiness {
11052 #[serde(rename = "ready")]
11053 Ready,
11054 #[serde(rename = "notConfigured")]
11055 NotConfigured,
11056 #[serde(rename = "updateRequired")]
11057 UpdateRequired,
11058}
11059
11060#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11061#[serde(rename_all = "camelCase")]
11062pub struct WindowsSandboxReadinessResponse {
11063 #[serde()]
11064 pub status: WindowsSandboxReadiness,
11065}
11066
11067#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11068#[serde(rename_all = "camelCase")]
11069pub struct WindowsSandboxSetupCompletedNotification {
11070 #[serde(default, skip_serializing_if = "Option::is_none")]
11071 pub error: Option<String>,
11072 #[serde()]
11073 pub mode: WindowsSandboxSetupMode,
11074 #[serde(default)]
11075 pub success: bool,
11076}
11077
11078#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11079pub enum WindowsSandboxSetupMode {
11080 #[serde(rename = "elevated")]
11081 Elevated,
11082 #[serde(rename = "unelevated")]
11083 Unelevated,
11084}
11085
11086#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11090pub enum WindowsSandboxImplementation {
11091 #[serde(rename = "elevated")]
11092 Elevated,
11093 #[serde(rename = "unelevated")]
11094 Unelevated,
11095 #[serde(rename = "mxc")]
11096 Mxc,
11097}
11098
11099#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11100#[serde(rename_all = "camelCase")]
11101pub struct WindowsSandboxSetupStartParams {
11102 #[serde(default, skip_serializing_if = "Option::is_none")]
11103 pub cwd: Option<AbsolutePathBuf>,
11104 #[serde()]
11105 pub mode: WindowsSandboxSetupMode,
11106}
11107
11108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
11109#[serde(rename_all = "camelCase")]
11110pub struct WindowsSandboxSetupStartResponse {
11111 #[serde(default)]
11112 pub started: bool,
11113}
11114
11115#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
11116#[serde(rename_all = "camelCase")]
11117pub struct WindowsWorldWritableWarningNotification {
11118 #[serde(rename = "extraCount", default)]
11119 pub extra_count: i64,
11120 #[serde(rename = "failedScan", default)]
11121 pub failed_scan: bool,
11122 #[serde(rename = "samplePaths", default)]
11123 pub sample_paths: Vec<String>,
11124}
11125
11126#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11127#[serde(rename_all = "camelCase")]
11128pub struct WorkspaceMessage {
11129 #[serde(
11130 rename = "archivedAt",
11131 default,
11132 skip_serializing_if = "Option::is_none"
11133 )]
11134 pub archived_at: Option<i64>,
11135 #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
11136 pub created_at: Option<i64>,
11137 #[serde(rename = "messageBody", default)]
11138 pub message_body: String,
11139 #[serde(rename = "messageId", default)]
11140 pub message_id: String,
11141 #[serde(rename = "messageType")]
11142 pub message_type: WorkspaceMessageType,
11143}
11144
11145#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11146pub enum WorkspaceMessageType {
11147 #[serde(rename = "headline")]
11148 Headline,
11149 #[serde(rename = "announcement")]
11150 Announcement,
11151 #[serde(rename = "unknown")]
11152 Unknown,
11153}
11154
11155#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11156pub enum WriteStatus {
11157 #[serde(rename = "ok")]
11158 Ok,
11159 #[serde(rename = "okOverridden")]
11160 OkOverridden,
11161}