codex_codes/protocol_generated/
types.rs

1// AUTO-GENERATED by scripts/codegen_protocol.py — DO NOT EDIT BY HAND.
2// Run `python3 scripts/codegen_protocol.py` to regenerate.
3//
4// Every wire type reachable from a method in the upstream codex
5// app-server schema bundle is emitted here as a Rust struct or enum.
6// Cross-references resolve to other types in this module.
7
8#![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/// A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).
20///
21/// IMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute.
22#[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    },
37    #[serde(rename = "amazonBedrock")]
38    AmazonBedrock {
39        #[serde(
40            rename = "usesCodexManagedCredentials",
41            default,
42            skip_serializing_if = "Option::is_none"
43        )]
44        uses_codex_managed_credentials: Option<bool>,
45    },
46}
47
48#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
49#[serde(rename_all = "camelCase")]
50pub struct AccountLoginCompletedNotification {
51    #[serde(default, skip_serializing_if = "Option::is_none")]
52    pub error: Option<String>,
53    #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
54    pub login_id: Option<String>,
55    #[serde(
56        rename = "onboardingEntrypoint",
57        default,
58        skip_serializing_if = "Option::is_none"
59    )]
60    pub onboarding_entrypoint: Option<DesktopOnboardingEntrypoint>,
61    #[serde(default)]
62    pub success: bool,
63}
64
65#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
66#[serde(rename_all = "camelCase")]
67pub struct AccountRateLimitsUpdatedNotification {
68    #[serde(rename = "rateLimits")]
69    pub rate_limits: RateLimitSnapshot,
70}
71
72#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
73#[serde(rename_all = "camelCase")]
74pub struct AccountTokenUsageDailyBucket {
75    #[serde(rename = "startDate", default)]
76    pub start_date: String,
77    #[serde(default)]
78    pub tokens: i64,
79}
80
81#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
82#[serde(rename_all = "camelCase")]
83pub struct AccountTokenUsageSummary {
84    #[serde(
85        rename = "currentStreakDays",
86        default,
87        skip_serializing_if = "Option::is_none"
88    )]
89    pub current_streak_days: Option<i64>,
90    #[serde(
91        rename = "lifetimeTokens",
92        default,
93        skip_serializing_if = "Option::is_none"
94    )]
95    pub lifetime_tokens: Option<i64>,
96    #[serde(
97        rename = "longestRunningTurnSec",
98        default,
99        skip_serializing_if = "Option::is_none"
100    )]
101    pub longest_running_turn_sec: Option<i64>,
102    #[serde(
103        rename = "longestStreakDays",
104        default,
105        skip_serializing_if = "Option::is_none"
106    )]
107    pub longest_streak_days: Option<i64>,
108    #[serde(
109        rename = "peakDailyTokens",
110        default,
111        skip_serializing_if = "Option::is_none"
112    )]
113    pub peak_daily_tokens: Option<i64>,
114}
115
116#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
117#[serde(rename_all = "camelCase")]
118pub struct AccountUpdatedNotification {
119    #[serde(rename = "authMode", default, skip_serializing_if = "Option::is_none")]
120    pub auth_mode: Option<AuthMode>,
121    #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
122    pub plan_type: Option<PlanType>,
123}
124
125#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
126#[serde(rename_all = "camelCase")]
127pub struct ActivePermissionProfile {
128    #[serde(default, skip_serializing_if = "Option::is_none")]
129    pub extends: Option<String>,
130    #[serde(default)]
131    pub id: String,
132}
133
134#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
135pub enum AddCreditsNudgeCreditType {
136    #[serde(rename = "credits")]
137    Credits,
138    #[serde(rename = "usage_limit")]
139    Usage_limit,
140}
141
142#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
143pub enum AddCreditsNudgeEmailStatus {
144    #[serde(rename = "sent")]
145    Sent,
146    #[serde(rename = "cooldown_active")]
147    Cooldown_active,
148}
149
150#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
151#[serde(rename_all = "camelCase")]
152pub struct AdditionalFileSystemPermissions {
153    #[serde(default, skip_serializing_if = "Option::is_none")]
154    pub entries: Option<Vec<FileSystemSandboxEntry>>,
155    #[serde(
156        rename = "globScanMaxDepth",
157        default,
158        skip_serializing_if = "Option::is_none"
159    )]
160    pub glob_scan_max_depth: Option<i64>,
161    #[serde(default, skip_serializing_if = "Option::is_none")]
162    pub read: Option<Vec<LegacyAppPathString>>,
163    #[serde(default, skip_serializing_if = "Option::is_none")]
164    pub write: Option<Vec<LegacyAppPathString>>,
165}
166
167#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
168#[serde(rename_all = "camelCase")]
169pub struct AdditionalNetworkPermissions {
170    #[serde(default, skip_serializing_if = "Option::is_none")]
171    pub enabled: Option<bool>,
172}
173
174#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
175#[serde(rename_all = "camelCase")]
176pub struct AgentMessageDeltaNotification {
177    #[serde(default)]
178    pub delta: String,
179    #[serde(rename = "itemId", default)]
180    pub item_id: String,
181    #[serde(rename = "threadId", default)]
182    pub thread_id: String,
183    #[serde(rename = "turnId", default)]
184    pub turn_id: String,
185}
186
187#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
188#[serde(transparent)]
189pub struct AgentPath(pub String);
190
191#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
192#[serde(rename_all = "snake_case")]
193pub struct AnalyticsConfig {
194    #[serde(default, skip_serializing_if = "Option::is_none")]
195    pub enabled: Option<bool>,
196    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
197    pub additional: serde_json::Map<String, Value>,
198}
199
200#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
201#[serde(rename_all = "camelCase")]
202pub struct AppBranding {
203    #[serde(default, skip_serializing_if = "Option::is_none")]
204    pub category: Option<String>,
205    #[serde(default, skip_serializing_if = "Option::is_none")]
206    pub developer: Option<String>,
207    #[serde(rename = "isDiscoverableApp", default)]
208    pub is_discoverable_app: bool,
209    #[serde(
210        rename = "privacyPolicy",
211        default,
212        skip_serializing_if = "Option::is_none"
213    )]
214    pub privacy_policy: Option<String>,
215    #[serde(
216        rename = "termsOfService",
217        default,
218        skip_serializing_if = "Option::is_none"
219    )]
220    pub terms_of_service: Option<String>,
221    #[serde(default, skip_serializing_if = "Option::is_none")]
222    pub website: Option<String>,
223}
224
225#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
226#[serde(rename_all = "camelCase")]
227pub struct AppInfo {
228    #[serde(
229        rename = "appMetadata",
230        default,
231        skip_serializing_if = "Option::is_none"
232    )]
233    pub app_metadata: Option<AppMetadata>,
234    #[serde(default, skip_serializing_if = "Option::is_none")]
235    pub branding: Option<AppBranding>,
236    #[serde(default, skip_serializing_if = "Option::is_none")]
237    pub description: Option<String>,
238    #[serde(
239        rename = "distributionChannel",
240        default,
241        skip_serializing_if = "Option::is_none"
242    )]
243    pub distribution_channel: Option<String>,
244    #[serde(
245        rename = "iconAssets",
246        default,
247        skip_serializing_if = "Option::is_none"
248    )]
249    pub icon_assets: Option<std::collections::BTreeMap<String, String>>,
250    #[serde(
251        rename = "iconDarkAssets",
252        default,
253        skip_serializing_if = "Option::is_none"
254    )]
255    pub icon_dark_assets: Option<std::collections::BTreeMap<String, String>>,
256    #[serde(default)]
257    pub id: String,
258    #[serde(
259        rename = "installUrl",
260        default,
261        skip_serializing_if = "Option::is_none"
262    )]
263    pub install_url: Option<String>,
264    #[serde(
265        rename = "isAccessible",
266        default,
267        skip_serializing_if = "Option::is_none"
268    )]
269    pub is_accessible: Option<bool>,
270    #[serde(rename = "isEnabled", default, skip_serializing_if = "Option::is_none")]
271    pub is_enabled: Option<bool>,
272    #[serde(default, skip_serializing_if = "Option::is_none")]
273    pub labels: Option<std::collections::BTreeMap<String, String>>,
274    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
275    pub logo_url: Option<String>,
276    #[serde(
277        rename = "logoUrlDark",
278        default,
279        skip_serializing_if = "Option::is_none"
280    )]
281    pub logo_url_dark: Option<String>,
282    #[serde(default)]
283    pub name: String,
284    #[serde(
285        rename = "pluginDisplayNames",
286        default,
287        skip_serializing_if = "Option::is_none"
288    )]
289    pub plugin_display_names: Option<Vec<String>>,
290}
291
292#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
293#[serde(rename_all = "camelCase")]
294pub struct AppListUpdatedNotification {
295    #[serde(default)]
296    pub data: Vec<AppInfo>,
297}
298
299#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
300#[serde(rename_all = "camelCase")]
301pub struct AppMetadata {
302    #[serde(default, skip_serializing_if = "Option::is_none")]
303    pub categories: Option<Vec<String>>,
304    #[serde(default, skip_serializing_if = "Option::is_none")]
305    pub developer: Option<String>,
306    #[serde(
307        rename = "firstPartyRequiresInstall",
308        default,
309        skip_serializing_if = "Option::is_none"
310    )]
311    pub first_party_requires_install: Option<bool>,
312    #[serde(default, skip_serializing_if = "Option::is_none")]
313    pub review: Option<AppReview>,
314    #[serde(default, skip_serializing_if = "Option::is_none")]
315    pub screenshots: Option<Vec<AppScreenshot>>,
316    #[serde(
317        rename = "seoDescription",
318        default,
319        skip_serializing_if = "Option::is_none"
320    )]
321    pub seo_description: Option<String>,
322    #[serde(
323        rename = "showInComposerWhenUnlinked",
324        default,
325        skip_serializing_if = "Option::is_none"
326    )]
327    pub show_in_composer_when_unlinked: Option<bool>,
328    #[serde(
329        rename = "subCategories",
330        default,
331        skip_serializing_if = "Option::is_none"
332    )]
333    pub sub_categories: Option<Vec<String>>,
334    #[serde(default, skip_serializing_if = "Option::is_none")]
335    pub version: Option<String>,
336    #[serde(rename = "versionId", default, skip_serializing_if = "Option::is_none")]
337    pub version_id: Option<String>,
338    #[serde(
339        rename = "versionNotes",
340        default,
341        skip_serializing_if = "Option::is_none"
342    )]
343    pub version_notes: Option<String>,
344}
345
346#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
347#[serde(rename_all = "camelCase")]
348pub struct AppReview {
349    #[serde(default)]
350    pub status: String,
351}
352
353#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
354#[serde(rename_all = "camelCase")]
355pub struct AppScreenshot {
356    #[serde(rename = "fileId", default, skip_serializing_if = "Option::is_none")]
357    pub file_id: Option<String>,
358    #[serde(default, skip_serializing_if = "Option::is_none")]
359    pub url: Option<String>,
360    #[serde(rename = "userPrompt", default)]
361    pub user_prompt: String,
362}
363
364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
365#[serde(rename_all = "camelCase")]
366pub struct AppSummary {
367    #[serde(default, skip_serializing_if = "Option::is_none")]
368    pub category: Option<String>,
369    #[serde(default, skip_serializing_if = "Option::is_none")]
370    pub description: Option<String>,
371    #[serde(default)]
372    pub id: String,
373    #[serde(
374        rename = "installUrl",
375        default,
376        skip_serializing_if = "Option::is_none"
377    )]
378    pub install_url: Option<String>,
379    #[serde(default)]
380    pub name: String,
381}
382
383#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
384#[serde(rename_all = "camelCase")]
385pub struct AppTemplateSummary {
386    #[serde(
387        rename = "canonicalConnectorId",
388        default,
389        skip_serializing_if = "Option::is_none"
390    )]
391    pub canonical_connector_id: Option<String>,
392    #[serde(default, skip_serializing_if = "Option::is_none")]
393    pub category: Option<String>,
394    #[serde(default, skip_serializing_if = "Option::is_none")]
395    pub description: Option<String>,
396    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
397    pub logo_url: Option<String>,
398    #[serde(
399        rename = "logoUrlDark",
400        default,
401        skip_serializing_if = "Option::is_none"
402    )]
403    pub logo_url_dark: Option<String>,
404    #[serde(rename = "materializedAppIds", default)]
405    pub materialized_app_ids: Vec<String>,
406    #[serde(default)]
407    pub name: String,
408    #[serde(default, skip_serializing_if = "Option::is_none")]
409    pub reason: Option<AppTemplateUnavailableReason>,
410    #[serde(rename = "templateId", default)]
411    pub template_id: String,
412}
413
414#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
415pub enum AppTemplateUnavailableReason {
416    #[serde(rename = "NOT_CONFIGURED_FOR_WORKSPACE")]
417    NOT_CONFIGURED_FOR_WORKSPACE,
418    #[serde(rename = "NO_ACTIVE_WORKSPACE")]
419    NO_ACTIVE_WORKSPACE,
420}
421
422#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
423#[serde(rename_all = "camelCase")]
424pub struct AppToolSummary {
425    #[serde(default)]
426    pub description: String,
427    #[serde(
428        rename = "disabledReason",
429        default,
430        skip_serializing_if = "Option::is_none"
431    )]
432    pub disabled_reason: Option<String>,
433    #[serde(rename = "isEnabled", default, skip_serializing_if = "Option::is_none")]
434    pub is_enabled: Option<bool>,
435    #[serde(
436        rename = "isReadOnly",
437        default,
438        skip_serializing_if = "Option::is_none"
439    )]
440    pub is_read_only: Option<bool>,
441    #[serde(default)]
442    pub name: String,
443    #[serde(default, skip_serializing_if = "Option::is_none")]
444    pub title: Option<String>,
445}
446
447#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
448#[serde(rename_all = "camelCase")]
449pub struct ApplyPatchApprovalParams {
450    #[serde(rename = "callId", default)]
451    pub call_id: String,
452    #[serde(rename = "conversationId")]
453    pub conversation_id: ThreadId,
454    #[serde(rename = "fileChanges", default)]
455    pub file_changes: std::collections::BTreeMap<String, FileChange>,
456    #[serde(rename = "grantRoot", default, skip_serializing_if = "Option::is_none")]
457    pub grant_root: Option<String>,
458    #[serde(default, skip_serializing_if = "Option::is_none")]
459    pub reason: Option<String>,
460}
461
462#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
463#[serde(rename_all = "camelCase")]
464pub struct ApplyPatchApprovalResponse {
465    #[serde()]
466    pub decision: ReviewDecision,
467}
468
469#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
470pub enum ApprovalsReviewer {
471    #[serde(rename = "user")]
472    User,
473    #[serde(rename = "auto_review")]
474    Auto_review,
475    #[serde(rename = "guardian_subagent")]
476    Guardian_subagent,
477}
478
479#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
480#[serde(rename_all = "camelCase")]
481pub struct AppsInstalledParams {
482    #[serde(
483        rename = "forceRefresh",
484        default,
485        skip_serializing_if = "Option::is_none"
486    )]
487    pub force_refresh: Option<bool>,
488    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
489    pub thread_id: Option<String>,
490}
491
492#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
493#[serde(rename_all = "camelCase")]
494pub struct AppsInstalledResponse {
495    #[serde(default)]
496    pub apps: Vec<InstalledApp>,
497}
498
499#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
500#[serde(rename_all = "camelCase")]
501pub struct AppsListParams {
502    #[serde(default, skip_serializing_if = "Option::is_none")]
503    pub cursor: Option<String>,
504    #[serde(
505        rename = "forceRefetch",
506        default,
507        skip_serializing_if = "Option::is_none"
508    )]
509    pub force_refetch: Option<bool>,
510    #[serde(default, skip_serializing_if = "Option::is_none")]
511    pub limit: Option<i64>,
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 AppsListResponse {
519    #[serde(default)]
520    pub data: Vec<AppInfo>,
521    #[serde(
522        rename = "nextCursor",
523        default,
524        skip_serializing_if = "Option::is_none"
525    )]
526    pub next_cursor: Option<String>,
527}
528
529#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
530#[serde(rename_all = "camelCase")]
531pub struct AppsReadParams {
532    #[serde(rename = "appIds", default)]
533    pub app_ids: Vec<String>,
534    #[serde(
535        rename = "includeTools",
536        default,
537        skip_serializing_if = "Option::is_none"
538    )]
539    pub include_tools: Option<bool>,
540    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
541    pub thread_id: Option<String>,
542}
543
544#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
545#[serde(rename_all = "camelCase")]
546pub struct AppsReadResponse {
547    #[serde(default)]
548    pub apps: Vec<ConnectorMetadata>,
549    #[serde(rename = "missingAppIds", default)]
550    pub missing_app_ids: Vec<String>,
551}
552
553#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
554pub enum AskForApproval {
555    #[serde(rename = "untrusted")]
556    Untrusted,
557    #[serde(rename = "on-request")]
558    OnRequest,
559    #[serde(rename = "never")]
560    Never,
561    #[serde(rename = "granular")]
562    Granular {
563        mcp_elicitations: bool,
564        #[serde(default, skip_serializing_if = "Option::is_none")]
565        request_permissions: Option<bool>,
566        rules: bool,
567        sandbox_approval: bool,
568        #[serde(default, skip_serializing_if = "Option::is_none")]
569        skill_approval: Option<bool>,
570    },
571}
572
573#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
574#[serde(rename_all = "camelCase")]
575pub struct AttestationGenerateParams {
576    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
577    pub extra: serde_json::Map<String, Value>,
578}
579
580#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
581#[serde(rename_all = "camelCase")]
582pub struct AttestationGenerateResponse {
583    #[serde(default)]
584    pub token: String,
585}
586
587/// `modelProvider/authRecoveryStarted` / `modelProvider/authRecoveryCompleted`
588/// params — the server is re-establishing a model provider's credentials
589/// mid-turn (0.148 upstream).
590#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
591#[serde(rename_all = "camelCase")]
592pub struct AuthRecoveryNotification {
593    #[serde(default)]
594    pub message: String,
595    #[serde(default)]
596    pub provider: String,
597    #[serde(rename = "threadId", default)]
598    pub thread_id: String,
599    #[serde(rename = "turnId", default)]
600    pub turn_id: String,
601}
602
603#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
604pub enum AuthMode {
605    #[serde(rename = "apikey")]
606    Apikey,
607    #[serde(rename = "chatgpt")]
608    Chatgpt,
609    #[serde(rename = "chatgptAuthTokens")]
610    ChatgptAuthTokens,
611    #[serde(rename = "headers")]
612    Headers,
613    #[serde(rename = "agentIdentity")]
614    AgentIdentity,
615    #[serde(rename = "personalAccessToken")]
616    PersonalAccessToken,
617    #[serde(rename = "bedrockApiKey")]
618    BedrockApiKey,
619    #[serde(rename = "bedrockAccessKeys")]
620    BedrockAccessKeys,
621}
622
623#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
624pub enum AutoCompactTokenLimitScope {
625    #[serde(rename = "total")]
626    Total,
627    #[serde(rename = "body_after_prefix")]
628    BodyAfterPrefix,
629}
630
631#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
632pub enum AutoReviewDecisionSource {
633    #[serde(rename = "agent")]
634    Agent,
635}
636
637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
638#[serde(rename_all = "camelCase")]
639pub struct AutoReviewRequirements {
640    #[serde(
641        rename = "ignoreRules",
642        default,
643        skip_serializing_if = "Option::is_none"
644    )]
645    pub ignore_rules: Option<Vec<String>>,
646    #[serde(
647        rename = "requiredOnModels",
648        default,
649        skip_serializing_if = "Option::is_none"
650    )]
651    pub required_on_models: Option<Vec<String>>,
652}
653
654#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
655#[serde(rename_all = "camelCase")]
656pub struct BrowserUseRequirements {
657    #[serde(
658        rename = "allowGlobalPersistentApproval",
659        default,
660        skip_serializing_if = "Option::is_none"
661    )]
662    pub allow_global_persistent_approval: Option<bool>,
663    #[serde(
664        rename = "allowHistoryAccess",
665        default,
666        skip_serializing_if = "Option::is_none"
667    )]
668    pub allow_history_access: Option<bool>,
669    #[serde(
670        rename = "defaultOriginPolicy",
671        default,
672        skip_serializing_if = "Option::is_none"
673    )]
674    pub default_origin_policy: Option<BrowserUseOriginPolicy>,
675    #[serde(default, skip_serializing_if = "Option::is_none")]
676    pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicy>>,
677    #[serde(
678        rename = "disableAutoReview",
679        default,
680        skip_serializing_if = "Option::is_none"
681    )]
682    pub disable_auto_review: Option<bool>,
683}
684
685#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
686#[serde(rename_all = "camelCase")]
687pub struct ByteRange {
688    #[serde(default)]
689    pub end: i64,
690    #[serde(default)]
691    pub start: i64,
692}
693
694#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
695#[serde(rename_all = "camelCase")]
696pub struct CancelLoginAccountParams {
697    #[serde(rename = "loginId", default)]
698    pub login_id: String,
699}
700
701#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
702#[serde(rename_all = "camelCase")]
703pub struct CancelLoginAccountResponse {
704    #[serde()]
705    pub status: CancelLoginAccountStatus,
706}
707
708#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
709pub enum CancelLoginAccountStatus {
710    #[serde(rename = "canceled")]
711    Canceled,
712    #[serde(rename = "notFound")]
713    NotFound,
714}
715
716#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
717#[serde(rename_all = "camelCase")]
718pub struct ChatgptAuthTokensRefreshParams {
719    #[serde(
720        rename = "previousAccountId",
721        default,
722        skip_serializing_if = "Option::is_none"
723    )]
724    pub previous_account_id: Option<String>,
725    #[serde()]
726    pub reason: ChatgptAuthTokensRefreshReason,
727}
728
729#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
730pub enum ChatgptAuthTokensRefreshReason {
731    #[serde(rename = "unauthorized")]
732    Unauthorized,
733}
734
735#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
736#[serde(rename_all = "camelCase")]
737pub struct ChatgptAuthTokensRefreshResponse {
738    #[serde(rename = "accessToken", default)]
739    pub access_token: String,
740    #[serde(rename = "chatgptAccountId", default)]
741    pub chatgpt_account_id: String,
742    #[serde(
743        rename = "chatgptPlanType",
744        default,
745        skip_serializing_if = "Option::is_none"
746    )]
747    pub chatgpt_plan_type: Option<String>,
748}
749
750#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
751#[serde(rename_all = "camelCase")]
752pub struct ClientInfo {
753    #[serde(default)]
754    pub name: String,
755    #[serde(default, skip_serializing_if = "Option::is_none")]
756    pub title: Option<String>,
757    #[serde(default)]
758    pub version: String,
759}
760
761#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
762pub enum CodexErrorInfo {
763    #[serde(rename = "contextWindowExceeded")]
764    ContextWindowExceeded,
765    #[serde(rename = "sessionBudgetExceeded")]
766    SessionBudgetExceeded,
767    #[serde(rename = "usageLimitExceeded")]
768    UsageLimitExceeded,
769    #[serde(rename = "rateLimitExceeded")]
770    RateLimitExceeded,
771    #[serde(rename = "serverOverloaded")]
772    ServerOverloaded,
773    #[serde(rename = "cyberPolicy")]
774    CyberPolicy,
775    #[serde(rename = "misalignmentPolicyViolation")]
776    MisalignmentPolicyViolation,
777    #[serde(rename = "internalServerError")]
778    InternalServerError,
779    #[serde(rename = "unauthorized")]
780    Unauthorized,
781    #[serde(rename = "badRequest")]
782    BadRequest,
783    #[serde(rename = "threadRollbackFailed")]
784    ThreadRollbackFailed,
785    #[serde(rename = "sandboxError")]
786    SandboxError,
787    #[serde(rename = "other")]
788    Other,
789    #[serde(rename = "httpConnectionFailed")]
790    HttpConnectionFailed {
791        #[serde(
792            rename = "httpStatusCode",
793            default,
794            skip_serializing_if = "Option::is_none"
795        )]
796        http_status_code: Option<i64>,
797    },
798    #[serde(rename = "responseStreamConnectionFailed")]
799    ResponseStreamConnectionFailed {
800        #[serde(
801            rename = "httpStatusCode",
802            default,
803            skip_serializing_if = "Option::is_none"
804        )]
805        http_status_code: Option<i64>,
806    },
807    #[serde(rename = "responseStreamDisconnected")]
808    ResponseStreamDisconnected {
809        #[serde(
810            rename = "httpStatusCode",
811            default,
812            skip_serializing_if = "Option::is_none"
813        )]
814        http_status_code: Option<i64>,
815    },
816    #[serde(rename = "responseTooManyFailedAttempts")]
817    ResponseTooManyFailedAttempts {
818        #[serde(
819            rename = "httpStatusCode",
820            default,
821            skip_serializing_if = "Option::is_none"
822        )]
823        http_status_code: Option<i64>,
824    },
825    #[serde(rename = "activeTurnNotSteerable")]
826    ActiveTurnNotSteerable {
827        #[serde(rename = "turnKind")]
828        turn_kind: NonSteerableTurnKind,
829    },
830}
831
832#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
833#[serde(rename_all = "camelCase")]
834pub struct CollabAgentState {
835    #[serde(default, skip_serializing_if = "Option::is_none")]
836    pub message: Option<String>,
837    #[serde()]
838    pub status: CollabAgentStatus,
839}
840
841#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
842pub enum CollabAgentStatus {
843    #[serde(rename = "pendingInit")]
844    PendingInit,
845    #[serde(rename = "running")]
846    Running,
847    #[serde(rename = "interrupted")]
848    Interrupted,
849    #[serde(rename = "completed")]
850    Completed,
851    #[serde(rename = "errored")]
852    Errored,
853    #[serde(rename = "shutdown")]
854    Shutdown,
855    #[serde(rename = "notFound")]
856    NotFound,
857}
858
859#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
860pub enum CollabAgentTool {
861    #[serde(rename = "spawnAgent")]
862    SpawnAgent,
863    #[serde(rename = "sendInput")]
864    SendInput,
865    #[serde(rename = "resumeAgent")]
866    ResumeAgent,
867    #[serde(rename = "wait")]
868    Wait,
869    #[serde(rename = "closeAgent")]
870    CloseAgent,
871    #[serde(rename = "sendMessage")]
872    SendMessage,
873    #[serde(rename = "followupTask")]
874    FollowupTask,
875    #[serde(rename = "interruptAgent")]
876    InterruptAgent,
877    #[serde(rename = "listAgents")]
878    ListAgents,
879}
880
881#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
882pub enum CollabAgentToolCallStatus {
883    #[serde(rename = "inProgress")]
884    InProgress,
885    #[serde(rename = "completed")]
886    Completed,
887    #[serde(rename = "failed")]
888    Failed,
889    #[serde(rename = "interrupted")]
890    Interrupted,
891}
892
893/// Requested cyber treatment for a ChatGPT-authenticated turn; authorization
894/// and model-tier restrictions stay server-owned (0.148 upstream).
895#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
896pub enum CyberAccessProgram {
897    #[serde(rename = "standard")]
898    Standard,
899    #[serde(rename = "daybreakBlue")]
900    DaybreakBlue,
901    #[serde(rename = "daybreakRed")]
902    DaybreakRed,
903}
904
905#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
906#[serde(rename_all = "camelCase")]
907pub struct CollaborationMode {
908    #[serde()]
909    pub mode: ModeKind,
910    #[serde()]
911    pub settings: Settings,
912}
913
914#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
915#[serde(tag = "type", rename_all = "camelCase")]
916pub enum CommandAction {
917    Read {
918        command: String,
919        name: String,
920        path: LegacyAppPathString,
921    },
922    #[serde(rename = "listFiles")]
923    ListFiles {
924        command: String,
925        #[serde(default, skip_serializing_if = "Option::is_none")]
926        path: Option<String>,
927    },
928    Search {
929        command: String,
930        #[serde(default, skip_serializing_if = "Option::is_none")]
931        path: Option<String>,
932        #[serde(default, skip_serializing_if = "Option::is_none")]
933        query: Option<String>,
934    },
935    Unknown {
936        command: String,
937    },
938}
939
940#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
941#[serde(rename_all = "camelCase")]
942pub struct CommandExecOutputDeltaNotification {
943    #[serde(rename = "capReached", default)]
944    pub cap_reached: bool,
945    #[serde(rename = "deltaBase64", default)]
946    pub delta_base64: String,
947    #[serde(rename = "processId", default)]
948    pub process_id: String,
949    #[serde(default)]
950    pub stream: Value,
951}
952
953#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
954pub enum CommandExecOutputStream {
955    #[serde(rename = "stdout")]
956    Stdout,
957    #[serde(rename = "stderr")]
958    Stderr,
959}
960
961#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
962#[serde(rename_all = "camelCase")]
963pub struct CommandExecParams {
964    #[serde(default)]
965    pub command: Vec<String>,
966    #[serde(default, skip_serializing_if = "Option::is_none")]
967    pub cwd: Option<String>,
968    #[serde(
969        rename = "disableOutputCap",
970        default,
971        skip_serializing_if = "Option::is_none"
972    )]
973    pub disable_output_cap: Option<bool>,
974    #[serde(
975        rename = "disableTimeout",
976        default,
977        skip_serializing_if = "Option::is_none"
978    )]
979    pub disable_timeout: Option<bool>,
980    #[serde(default, skip_serializing_if = "Option::is_none")]
981    pub env: Option<std::collections::BTreeMap<String, Option<String>>>,
982    #[serde(
983        rename = "outputBytesCap",
984        default,
985        skip_serializing_if = "Option::is_none"
986    )]
987    pub output_bytes_cap: Option<i64>,
988    #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
989    pub process_id: Option<String>,
990    #[serde(
991        rename = "sandboxPolicy",
992        default,
993        skip_serializing_if = "Option::is_none"
994    )]
995    pub sandbox_policy: Option<SandboxPolicy>,
996    #[serde(default, skip_serializing_if = "Option::is_none")]
997    pub size: Option<CommandExecTerminalSize>,
998    #[serde(
999        rename = "streamStdin",
1000        default,
1001        skip_serializing_if = "Option::is_none"
1002    )]
1003    pub stream_stdin: Option<bool>,
1004    #[serde(
1005        rename = "streamStdoutStderr",
1006        default,
1007        skip_serializing_if = "Option::is_none"
1008    )]
1009    pub stream_stdout_stderr: Option<bool>,
1010    #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
1011    pub timeout_ms: Option<i64>,
1012    #[serde(default, skip_serializing_if = "Option::is_none")]
1013    pub tty: Option<bool>,
1014}
1015
1016#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1017#[serde(rename_all = "camelCase")]
1018pub struct CommandExecResizeParams {
1019    #[serde(rename = "processId", default)]
1020    pub process_id: String,
1021    #[serde(default)]
1022    pub size: Value,
1023}
1024
1025#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1026#[serde(rename_all = "camelCase")]
1027pub struct CommandExecResizeResponse {
1028    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1029    pub extra: serde_json::Map<String, Value>,
1030}
1031
1032#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1033#[serde(rename_all = "camelCase")]
1034pub struct CommandExecResponse {
1035    #[serde(rename = "exitCode", default)]
1036    pub exit_code: i64,
1037    #[serde(default)]
1038    pub stderr: String,
1039    #[serde(default)]
1040    pub stdout: String,
1041}
1042
1043#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1044#[serde(rename_all = "camelCase")]
1045pub struct CommandExecTerminalSize {
1046    #[serde(default)]
1047    pub cols: i64,
1048    #[serde(default)]
1049    pub rows: i64,
1050}
1051
1052#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1053#[serde(rename_all = "camelCase")]
1054pub struct CommandExecTerminateParams {
1055    #[serde(rename = "processId", default)]
1056    pub process_id: String,
1057}
1058
1059#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1060#[serde(rename_all = "camelCase")]
1061pub struct CommandExecTerminateResponse {
1062    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1063    pub extra: serde_json::Map<String, Value>,
1064}
1065
1066#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1067#[serde(rename_all = "camelCase")]
1068pub struct CommandExecWriteParams {
1069    #[serde(
1070        rename = "closeStdin",
1071        default,
1072        skip_serializing_if = "Option::is_none"
1073    )]
1074    pub close_stdin: Option<bool>,
1075    #[serde(
1076        rename = "deltaBase64",
1077        default,
1078        skip_serializing_if = "Option::is_none"
1079    )]
1080    pub delta_base64: Option<String>,
1081    #[serde(rename = "processId", default)]
1082    pub process_id: String,
1083}
1084
1085#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1086#[serde(rename_all = "camelCase")]
1087pub struct CommandExecWriteResponse {
1088    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1089    pub extra: serde_json::Map<String, Value>,
1090}
1091
1092#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1093pub enum CommandExecutionApprovalDecision {
1094    #[serde(rename = "accept")]
1095    Accept,
1096    #[serde(rename = "acceptForSession")]
1097    AcceptForSession,
1098    #[serde(rename = "acceptWithExecpolicyAmendment")]
1099    AcceptWithExecpolicyAmendment { execpolicy_amendment: Vec<String> },
1100    #[serde(rename = "applyNetworkPolicyAmendment")]
1101    ApplyNetworkPolicyAmendment {
1102        network_policy_amendment: NetworkPolicyAmendment,
1103    },
1104    #[serde(rename = "decline")]
1105    Decline,
1106    #[serde(rename = "cancel")]
1107    Cancel,
1108}
1109
1110/// Distinguishes a command approval from input sent to an existing terminal
1111/// (v1 `commandExecution/requestApproval`, 0.148 upstream).
1112#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1113pub enum CommandExecutionApprovalKind {
1114    #[serde(rename = "command")]
1115    Command,
1116    #[serde(rename = "writeStdin")]
1117    WriteStdin,
1118}
1119
1120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1121#[serde(rename_all = "camelCase")]
1122pub struct CommandExecutionOutputDeltaNotification {
1123    #[serde(default)]
1124    pub delta: String,
1125    #[serde(rename = "itemId", default)]
1126    pub item_id: String,
1127    #[serde(rename = "threadId", default)]
1128    pub thread_id: String,
1129    #[serde(rename = "turnId", default)]
1130    pub turn_id: String,
1131}
1132
1133#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1134#[serde(rename_all = "camelCase")]
1135pub struct CommandExecutionRequestApprovalParams {
1136    #[serde(
1137        rename = "approvalId",
1138        default,
1139        skip_serializing_if = "Option::is_none"
1140    )]
1141    pub approval_id: Option<String>,
1142    #[serde(default, skip_serializing_if = "Option::is_none")]
1143    pub command: Option<String>,
1144    #[serde(
1145        rename = "commandActions",
1146        default,
1147        skip_serializing_if = "Option::is_none"
1148    )]
1149    pub command_actions: Option<Vec<CommandAction>>,
1150    #[serde(default, skip_serializing_if = "Option::is_none")]
1151    pub cwd: Option<LegacyAppPathString>,
1152    #[serde(
1153        rename = "environmentId",
1154        default,
1155        skip_serializing_if = "Option::is_none"
1156    )]
1157    pub environment_id: Option<String>,
1158    #[serde(rename = "itemId", default)]
1159    pub item_id: String,
1160    /// Kind of action under review; defaults to `command` on older servers.
1161    /// `writeStdin` marks input to an existing terminal (0.148 upstream).
1162    #[serde(default, skip_serializing_if = "Option::is_none")]
1163    pub kind: Option<CommandExecutionApprovalKind>,
1164    #[serde(
1165        rename = "networkApprovalContext",
1166        default,
1167        skip_serializing_if = "Option::is_none"
1168    )]
1169    pub network_approval_context: Option<NetworkApprovalContext>,
1170    #[serde(
1171        rename = "proposedExecpolicyAmendment",
1172        default,
1173        skip_serializing_if = "Option::is_none"
1174    )]
1175    pub proposed_execpolicy_amendment: Option<Vec<String>>,
1176    #[serde(
1177        rename = "proposedNetworkPolicyAmendments",
1178        default,
1179        skip_serializing_if = "Option::is_none"
1180    )]
1181    pub proposed_network_policy_amendments: Option<Vec<NetworkPolicyAmendment>>,
1182    #[serde(default, skip_serializing_if = "Option::is_none")]
1183    pub reason: Option<String>,
1184    #[serde(rename = "startedAtMs", default)]
1185    pub started_at_ms: i64,
1186    #[serde(rename = "threadId", default)]
1187    pub thread_id: String,
1188    #[serde(rename = "turnId", default)]
1189    pub turn_id: String,
1190}
1191
1192#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1193#[serde(rename_all = "camelCase")]
1194pub struct CommandExecutionRequestApprovalResponse {
1195    #[serde()]
1196    pub decision: CommandExecutionApprovalDecision,
1197}
1198
1199#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1200pub enum CommandExecutionSource {
1201    #[serde(rename = "agent")]
1202    Agent,
1203    #[serde(rename = "userShell")]
1204    UserShell,
1205    #[serde(rename = "unifiedExecStartup")]
1206    UnifiedExecStartup,
1207    #[serde(rename = "unifiedExecInteraction")]
1208    UnifiedExecInteraction,
1209}
1210
1211#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1212pub enum CommandExecutionStatus {
1213    #[serde(rename = "inProgress")]
1214    InProgress,
1215    #[serde(rename = "completed")]
1216    Completed,
1217    #[serde(rename = "failed")]
1218    Failed,
1219    #[serde(rename = "declined")]
1220    Declined,
1221}
1222
1223#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1224#[serde(rename_all = "camelCase")]
1225pub struct CommandMigration {
1226    #[serde(default)]
1227    pub name: String,
1228}
1229
1230#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1231#[serde(rename_all = "camelCase")]
1232pub struct ComputerUseRequirements {
1233    #[serde(
1234        rename = "allowPersistentApproval",
1235        default,
1236        skip_serializing_if = "Option::is_none"
1237    )]
1238    pub allow_persistent_approval: Option<bool>,
1239    #[serde(
1240        rename = "defaultAppAccess",
1241        default,
1242        skip_serializing_if = "Option::is_none"
1243    )]
1244    pub default_app_access: Option<AllowDenyRequirement>,
1245    #[serde(default, skip_serializing_if = "Option::is_none")]
1246    pub macos: Option<ComputerUseMacosRequirements>,
1247    #[serde(default, skip_serializing_if = "Option::is_none")]
1248    pub windows: Option<ComputerUseWindowsRequirements>,
1249    #[serde(
1250        rename = "allowLockedComputerUse",
1251        default,
1252        skip_serializing_if = "Option::is_none"
1253    )]
1254    pub allow_locked_computer_use: Option<bool>,
1255}
1256
1257#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1258#[serde(rename_all = "snake_case")]
1259pub struct Config {
1260    #[serde(default, skip_serializing_if = "Option::is_none")]
1261    pub analytics: Option<AnalyticsConfig>,
1262    #[serde(default, skip_serializing_if = "Option::is_none")]
1263    pub browser_use: Option<BrowserUseConfig>,
1264    #[serde(default, skip_serializing_if = "Option::is_none")]
1265    pub computer_use: Option<ComputerUseConfig>,
1266    #[serde(default, skip_serializing_if = "Option::is_none")]
1267    pub approval_policy: Option<AskForApproval>,
1268    #[serde(default, skip_serializing_if = "Option::is_none")]
1269    pub approvals_reviewer: Option<ApprovalsReviewer>,
1270    #[serde(default, skip_serializing_if = "Option::is_none")]
1271    pub compact_prompt: Option<String>,
1272    #[serde(default, skip_serializing_if = "Option::is_none")]
1273    pub desktop: Option<Value>,
1274    #[serde(default, skip_serializing_if = "Option::is_none")]
1275    pub developer_instructions: Option<String>,
1276    #[serde(default, skip_serializing_if = "Option::is_none")]
1277    pub forced_chatgpt_workspace_id: Option<ForcedChatgptWorkspaceIds>,
1278    #[serde(default, skip_serializing_if = "Option::is_none")]
1279    pub forced_login_method: Option<ForcedLoginMethod>,
1280    #[serde(default, skip_serializing_if = "Option::is_none")]
1281    pub instructions: Option<String>,
1282    #[serde(default, skip_serializing_if = "Option::is_none")]
1283    pub model: Option<String>,
1284    #[serde(default, skip_serializing_if = "Option::is_none")]
1285    pub model_auto_compact_token_limit: Option<i64>,
1286    #[serde(default, skip_serializing_if = "Option::is_none")]
1287    pub model_auto_compact_token_limit_scope: Option<AutoCompactTokenLimitScope>,
1288    #[serde(default, skip_serializing_if = "Option::is_none")]
1289    pub model_context_window: Option<i64>,
1290    #[serde(default, skip_serializing_if = "Option::is_none")]
1291    pub model_provider: Option<String>,
1292    #[serde(default, skip_serializing_if = "Option::is_none")]
1293    pub model_reasoning_effort: Option<ReasoningEffort>,
1294    #[serde(default, skip_serializing_if = "Option::is_none")]
1295    pub model_reasoning_summary: Option<ReasoningSummary>,
1296    #[serde(default, skip_serializing_if = "Option::is_none")]
1297    pub model_verbosity: Option<Verbosity>,
1298    #[serde(default, skip_serializing_if = "Option::is_none")]
1299    pub review_model: Option<String>,
1300    #[serde(default, skip_serializing_if = "Option::is_none")]
1301    pub sandbox_mode: Option<SandboxMode>,
1302    #[serde(default, skip_serializing_if = "Option::is_none")]
1303    pub sandbox_workspace_write: Option<SandboxWorkspaceWrite>,
1304    #[serde(default, skip_serializing_if = "Option::is_none")]
1305    pub service_tier: Option<String>,
1306    #[serde(default, skip_serializing_if = "Option::is_none")]
1307    pub tools: Option<ToolsV2>,
1308    #[serde(default, skip_serializing_if = "Option::is_none")]
1309    pub web_search: Option<WebSearchMode>,
1310    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1311    pub additional: serde_json::Map<String, Value>,
1312}
1313
1314#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1315#[serde(rename_all = "camelCase")]
1316pub struct ConfigBatchWriteParams {
1317    #[serde(default)]
1318    pub edits: Vec<ConfigEdit>,
1319    #[serde(
1320        rename = "expectedVersion",
1321        default,
1322        skip_serializing_if = "Option::is_none"
1323    )]
1324    pub expected_version: Option<String>,
1325    #[serde(rename = "filePath", default, skip_serializing_if = "Option::is_none")]
1326    pub file_path: Option<String>,
1327    #[serde(
1328        rename = "reloadUserConfig",
1329        default,
1330        skip_serializing_if = "Option::is_none"
1331    )]
1332    pub reload_user_config: Option<bool>,
1333}
1334
1335#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1336#[serde(rename_all = "camelCase")]
1337pub struct ConfigEdit {
1338    #[serde(rename = "keyPath", default)]
1339    pub key_path: String,
1340    #[serde(rename = "mergeStrategy")]
1341    pub merge_strategy: MergeStrategy,
1342    #[serde(default)]
1343    pub value: Value,
1344}
1345
1346#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1347#[serde(rename_all = "camelCase")]
1348pub struct ConfigLayer {
1349    #[serde(default)]
1350    pub config: Value,
1351    #[serde(
1352        rename = "disabledReason",
1353        default,
1354        skip_serializing_if = "Option::is_none"
1355    )]
1356    pub disabled_reason: Option<String>,
1357    #[serde()]
1358    pub name: ConfigLayerSource,
1359    #[serde(default)]
1360    pub version: String,
1361}
1362
1363#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1364#[serde(rename_all = "camelCase")]
1365pub struct ConfigLayerMetadata {
1366    #[serde()]
1367    pub name: ConfigLayerSource,
1368    #[serde(default)]
1369    pub version: String,
1370}
1371
1372#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1373#[serde(tag = "type", rename_all = "camelCase")]
1374pub enum ConfigLayerSource {
1375    #[serde(rename = "packagedDefaults")]
1376    PackagedDefaults {
1377        file: Value,
1378    },
1379    Mdm {
1380        domain: String,
1381        key: String,
1382    },
1383    System {
1384        file: Value,
1385    },
1386    #[serde(rename = "enterpriseManaged")]
1387    EnterpriseManaged {
1388        id: String,
1389        name: String,
1390    },
1391    User {
1392        file: Value,
1393        #[serde(default, skip_serializing_if = "Option::is_none")]
1394        profile: Option<String>,
1395    },
1396    Project {
1397        #[serde(rename = "dotCodexFolder")]
1398        dot_codex_folder: AbsolutePathBuf,
1399    },
1400    #[serde(rename = "sessionFlags")]
1401    SessionFlags,
1402    #[serde(rename = "legacyManagedConfigTomlFromFile")]
1403    LegacyManagedConfigTomlFromFile {
1404        file: AbsolutePathBuf,
1405    },
1406    #[serde(rename = "legacyManagedConfigTomlFromMdm")]
1407    LegacyManagedConfigTomlFromMdm,
1408}
1409
1410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1411#[serde(rename_all = "camelCase")]
1412pub struct ConfigReadParams {
1413    #[serde(default, skip_serializing_if = "Option::is_none")]
1414    pub cwd: Option<String>,
1415    #[serde(
1416        rename = "includeLayers",
1417        default,
1418        skip_serializing_if = "Option::is_none"
1419    )]
1420    pub include_layers: Option<bool>,
1421}
1422
1423#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1424#[serde(rename_all = "camelCase")]
1425pub struct ConfigReadResponse {
1426    #[serde()]
1427    pub config: Config,
1428    #[serde(default, skip_serializing_if = "Option::is_none")]
1429    pub layers: Option<Vec<ConfigLayer>>,
1430    #[serde(default)]
1431    pub origins: std::collections::BTreeMap<String, ConfigLayerMetadata>,
1432}
1433
1434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1435#[serde(rename_all = "camelCase")]
1436pub struct ConfigRequirements {
1437    #[serde(
1438        rename = "allowBrowserAndComputerUse",
1439        default,
1440        skip_serializing_if = "Option::is_none"
1441    )]
1442    pub allow_browser_and_computer_use: Option<bool>,
1443    #[serde(
1444        rename = "additionalDeveloperInstructions",
1445        default,
1446        skip_serializing_if = "Option::is_none"
1447    )]
1448    pub additional_developer_instructions: Option<String>,
1449    #[serde(
1450        rename = "inAppBrowser",
1451        default,
1452        skip_serializing_if = "Option::is_none"
1453    )]
1454    pub in_app_browser: Option<InAppBrowserRequirements>,
1455    #[serde(
1456        rename = "chatgptBaseUrl",
1457        default,
1458        skip_serializing_if = "Option::is_none"
1459    )]
1460    pub chatgpt_base_url: Option<String>,
1461    #[serde(
1462        rename = "cliAuthCredentialsStore",
1463        default,
1464        skip_serializing_if = "Option::is_none"
1465    )]
1466    pub cli_auth_credentials_store: Option<CliAuthCredentialsStoreMode>,
1467    #[serde(
1468        rename = "allowAppshots",
1469        default,
1470        skip_serializing_if = "Option::is_none"
1471    )]
1472    pub allow_appshots: Option<bool>,
1473    #[serde(
1474        rename = "allowLoginShell",
1475        default,
1476        skip_serializing_if = "Option::is_none"
1477    )]
1478    pub allow_login_shell: Option<bool>,
1479    #[serde(
1480        rename = "allowManagedHooksOnly",
1481        default,
1482        skip_serializing_if = "Option::is_none"
1483    )]
1484    pub allow_managed_hooks_only: Option<bool>,
1485    #[serde(
1486        rename = "allowRemoteControl",
1487        default,
1488        skip_serializing_if = "Option::is_none"
1489    )]
1490    pub allow_remote_control: Option<bool>,
1491    #[serde(
1492        rename = "allowedApprovalPolicies",
1493        default,
1494        skip_serializing_if = "Option::is_none"
1495    )]
1496    pub allowed_approval_policies: Option<Vec<AskForApproval>>,
1497    #[serde(
1498        rename = "allowedPermissionProfiles",
1499        default,
1500        skip_serializing_if = "Option::is_none"
1501    )]
1502    pub allowed_permission_profiles: Option<std::collections::BTreeMap<String, bool>>,
1503    #[serde(
1504        rename = "allowedSandboxModes",
1505        default,
1506        skip_serializing_if = "Option::is_none"
1507    )]
1508    pub allowed_sandbox_modes: Option<Vec<SandboxMode>>,
1509    #[serde(
1510        rename = "allowedWebSearchModes",
1511        default,
1512        skip_serializing_if = "Option::is_none"
1513    )]
1514    pub allowed_web_search_modes: Option<Vec<WebSearchMode>>,
1515    #[serde(
1516        rename = "allowedWindowsSandboxImplementations",
1517        default,
1518        skip_serializing_if = "Option::is_none"
1519    )]
1520    pub allowed_windows_sandbox_implementations: Option<Vec<WindowsSandboxSetupMode>>,
1521    #[serde(
1522        rename = "autoReview",
1523        default,
1524        skip_serializing_if = "Option::is_none"
1525    )]
1526    pub auto_review: Option<AutoReviewRequirements>,
1527    #[serde(
1528        rename = "browserUse",
1529        default,
1530        skip_serializing_if = "Option::is_none"
1531    )]
1532    pub browser_use: Option<BrowserUseRequirements>,
1533    #[serde(
1534        rename = "checkForUpdateOnStartup",
1535        default,
1536        skip_serializing_if = "Option::is_none"
1537    )]
1538    pub check_for_update_on_startup: Option<bool>,
1539    #[serde(
1540        rename = "computerUse",
1541        default,
1542        skip_serializing_if = "Option::is_none"
1543    )]
1544    pub computer_use: Option<ComputerUseRequirements>,
1545    #[serde(
1546        rename = "defaultPermissions",
1547        default,
1548        skip_serializing_if = "Option::is_none"
1549    )]
1550    pub default_permissions: Option<String>,
1551    #[serde(
1552        rename = "enforceResidency",
1553        default,
1554        skip_serializing_if = "Option::is_none"
1555    )]
1556    pub enforce_residency: Option<ResidencyRequirement>,
1557    #[serde(
1558        rename = "featureRequirements",
1559        default,
1560        skip_serializing_if = "Option::is_none"
1561    )]
1562    pub feature_requirements: Option<std::collections::BTreeMap<String, bool>>,
1563    #[serde(default, skip_serializing_if = "Option::is_none")]
1564    pub feedback: Option<FeedbackRequirements>,
1565    #[serde(rename = "logDir", default, skip_serializing_if = "Option::is_none")]
1566    pub log_dir: Option<String>,
1567    #[serde(
1568        rename = "modelCatalogJson",
1569        default,
1570        skip_serializing_if = "Option::is_none"
1571    )]
1572    pub model_catalog_json: Option<String>,
1573    #[serde(default, skip_serializing_if = "Option::is_none")]
1574    pub models: Option<ModelsRequirements>,
1575    #[serde(
1576        rename = "sqliteHome",
1577        default,
1578        skip_serializing_if = "Option::is_none"
1579    )]
1580    pub sqlite_home: Option<String>,
1581    #[serde(
1582        rename = "windowsSandboxPrivateDesktop",
1583        default,
1584        skip_serializing_if = "Option::is_none"
1585    )]
1586    pub windows_sandbox_private_desktop: Option<bool>,
1587}
1588
1589#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1590#[serde(rename_all = "camelCase")]
1591pub struct ConfigRequirementsReadResponse {
1592    #[serde(default, skip_serializing_if = "Option::is_none")]
1593    pub requirements: Option<ConfigRequirements>,
1594}
1595
1596#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1597#[serde(rename_all = "camelCase")]
1598pub struct ConfigValueWriteParams {
1599    #[serde(
1600        rename = "expectedVersion",
1601        default,
1602        skip_serializing_if = "Option::is_none"
1603    )]
1604    pub expected_version: Option<String>,
1605    #[serde(rename = "filePath", default, skip_serializing_if = "Option::is_none")]
1606    pub file_path: Option<String>,
1607    #[serde(rename = "keyPath", default)]
1608    pub key_path: String,
1609    #[serde(rename = "mergeStrategy")]
1610    pub merge_strategy: MergeStrategy,
1611    #[serde(default)]
1612    pub value: Value,
1613}
1614
1615#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1616#[serde(rename_all = "camelCase")]
1617pub struct ConfigWarningNotification {
1618    #[serde(default, skip_serializing_if = "Option::is_none")]
1619    pub details: Option<String>,
1620    #[serde(default, skip_serializing_if = "Option::is_none")]
1621    pub path: Option<String>,
1622    #[serde(default, skip_serializing_if = "Option::is_none")]
1623    pub range: Option<TextRange>,
1624    #[serde(default)]
1625    pub summary: String,
1626}
1627
1628#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1629#[serde(rename_all = "camelCase")]
1630pub struct ConfigWriteResponse {
1631    #[serde(rename = "filePath", default)]
1632    pub file_path: Value,
1633    #[serde(
1634        rename = "overriddenMetadata",
1635        default,
1636        skip_serializing_if = "Option::is_none"
1637    )]
1638    pub overridden_metadata: Option<OverriddenMetadata>,
1639    #[serde()]
1640    pub status: WriteStatus,
1641    #[serde(default)]
1642    pub version: String,
1643}
1644
1645#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1646#[serde(rename_all = "camelCase")]
1647pub struct ConnectorMetadata {
1648    #[serde(default, skip_serializing_if = "Option::is_none")]
1649    pub description: Option<String>,
1650    #[serde(
1651        rename = "distributionChannel",
1652        default,
1653        skip_serializing_if = "Option::is_none"
1654    )]
1655    pub distribution_channel: Option<String>,
1656    #[serde(rename = "iconUrl", default, skip_serializing_if = "Option::is_none")]
1657    pub icon_url: Option<String>,
1658    #[serde(
1659        rename = "iconUrlDark",
1660        default,
1661        skip_serializing_if = "Option::is_none"
1662    )]
1663    pub icon_url_dark: Option<String>,
1664    #[serde(default)]
1665    pub id: String,
1666    #[serde(
1667        rename = "installUrl",
1668        default,
1669        skip_serializing_if = "Option::is_none"
1670    )]
1671    pub install_url: Option<String>,
1672    #[serde(default)]
1673    pub name: String,
1674    #[serde(
1675        rename = "pluginDisplayNames",
1676        default,
1677        skip_serializing_if = "Option::is_none"
1678    )]
1679    pub plugin_display_names: Option<Vec<String>>,
1680    #[serde(
1681        rename = "toolSummaries",
1682        default,
1683        skip_serializing_if = "Option::is_none"
1684    )]
1685    pub tool_summaries: Option<Vec<AppToolSummary>>,
1686}
1687
1688#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
1689pub enum ConsumeAccountRateLimitResetCreditOutcome {
1690    #[serde(rename = "reset")]
1691    Reset,
1692    #[serde(rename = "nothingToReset")]
1693    NothingToReset,
1694    #[serde(rename = "noCredit")]
1695    NoCredit,
1696    #[serde(rename = "alreadyRedeemed")]
1697    AlreadyRedeemed,
1698}
1699
1700#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1701#[serde(rename_all = "camelCase")]
1702pub struct ConsumeAccountRateLimitResetCreditParams {
1703    #[serde(rename = "creditId", default, skip_serializing_if = "Option::is_none")]
1704    pub credit_id: Option<String>,
1705    #[serde(rename = "idempotencyKey", default)]
1706    pub idempotency_key: String,
1707}
1708
1709#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1710#[serde(rename_all = "camelCase")]
1711pub struct ConsumeAccountRateLimitResetCreditResponse {
1712    #[serde()]
1713    pub outcome: ConsumeAccountRateLimitResetCreditOutcome,
1714}
1715
1716#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1717#[serde(rename_all = "camelCase")]
1718pub struct ContextCompactedNotification {
1719    #[serde(rename = "threadId", default)]
1720    pub thread_id: String,
1721    #[serde(rename = "turnId", default)]
1722    pub turn_id: String,
1723}
1724
1725#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1726#[serde(rename_all = "camelCase")]
1727pub struct CreditsSnapshot {
1728    #[serde(default, skip_serializing_if = "Option::is_none")]
1729    pub balance: Option<String>,
1730    #[serde(rename = "hasCredits", default)]
1731    pub has_credits: bool,
1732    #[serde(default)]
1733    pub unlimited: bool,
1734}
1735
1736#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1737#[serde(rename_all = "camelCase")]
1738pub struct DeprecationNoticeNotification {
1739    #[serde(default, skip_serializing_if = "Option::is_none")]
1740    pub details: Option<String>,
1741    #[serde(default)]
1742    pub summary: String,
1743}
1744
1745#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1746pub enum DesktopOnboardingEntrypoint {
1747    #[serde(rename = "life_sciences")]
1748    Life_sciences,
1749}
1750
1751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1752#[serde(tag = "type", rename_all = "camelCase")]
1753pub enum DynamicToolCallOutputContentItem {
1754    #[serde(rename = "inputText")]
1755    InputText { text: String },
1756    #[serde(rename = "inputImage")]
1757    InputImage {
1758        #[serde(rename = "imageUrl")]
1759        image_url: String,
1760    },
1761    #[serde(rename = "inputAudio")]
1762    InputAudio {
1763        #[serde(rename = "audioUrl")]
1764        audio_url: String,
1765    },
1766}
1767
1768#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1769#[serde(rename_all = "camelCase")]
1770pub struct DynamicToolCallParams {
1771    #[serde(default)]
1772    pub arguments: Value,
1773    #[serde(rename = "callId", default)]
1774    pub call_id: String,
1775    #[serde(default, skip_serializing_if = "Option::is_none")]
1776    pub namespace: Option<String>,
1777    #[serde(rename = "threadId", default)]
1778    pub thread_id: String,
1779    #[serde(default)]
1780    pub tool: String,
1781    #[serde(rename = "turnId", default)]
1782    pub turn_id: String,
1783}
1784
1785#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1786#[serde(rename_all = "camelCase")]
1787pub struct DynamicToolCallResponse {
1788    #[serde(rename = "contentItems", default)]
1789    pub content_items: Vec<DynamicToolCallOutputContentItem>,
1790    #[serde(default)]
1791    pub success: bool,
1792}
1793
1794#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1795pub enum DynamicToolCallStatus {
1796    #[serde(rename = "inProgress")]
1797    InProgress,
1798    #[serde(rename = "completed")]
1799    Completed,
1800    #[serde(rename = "failed")]
1801    Failed,
1802}
1803
1804#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1805#[serde(rename_all = "camelCase")]
1806pub struct EnvironmentConnectionNotification {
1807    #[serde(rename = "environmentId", default)]
1808    pub environment_id: String,
1809    #[serde(rename = "threadId", default)]
1810    pub thread_id: String,
1811}
1812
1813#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1814#[serde(rename_all = "camelCase")]
1815pub struct ErrorNotification {
1816    #[serde()]
1817    pub error: TurnError,
1818    #[serde(rename = "threadId", default)]
1819    pub thread_id: String,
1820    #[serde(rename = "turnId", default)]
1821    pub turn_id: String,
1822    #[serde(rename = "willRetry", default)]
1823    pub will_retry: bool,
1824}
1825
1826#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1827#[serde(rename_all = "camelCase")]
1828pub struct ExecCommandApprovalParams {
1829    #[serde(
1830        rename = "approvalId",
1831        default,
1832        skip_serializing_if = "Option::is_none"
1833    )]
1834    pub approval_id: Option<String>,
1835    #[serde(rename = "callId", default)]
1836    pub call_id: String,
1837    #[serde(default)]
1838    pub command: Vec<String>,
1839    #[serde(rename = "conversationId")]
1840    pub conversation_id: ThreadId,
1841    #[serde(default)]
1842    pub cwd: String,
1843    #[serde(rename = "parsedCmd", default)]
1844    pub parsed_cmd: Vec<ParsedCommand>,
1845    #[serde(default, skip_serializing_if = "Option::is_none")]
1846    pub reason: Option<String>,
1847}
1848
1849#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1850#[serde(rename_all = "camelCase")]
1851pub struct ExecCommandApprovalResponse {
1852    #[serde()]
1853    pub decision: ReviewDecision,
1854}
1855
1856#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1857#[serde(rename_all = "camelCase")]
1858pub struct ExperimentalFeature {
1859    #[serde(default, skip_serializing_if = "Option::is_none")]
1860    pub announcement: Option<String>,
1861    #[serde(rename = "defaultEnabled", default)]
1862    pub default_enabled: bool,
1863    #[serde(default, skip_serializing_if = "Option::is_none")]
1864    pub description: Option<String>,
1865    #[serde(
1866        rename = "displayName",
1867        default,
1868        skip_serializing_if = "Option::is_none"
1869    )]
1870    pub display_name: Option<String>,
1871    #[serde(default)]
1872    pub enabled: bool,
1873    #[serde(default)]
1874    pub name: String,
1875    #[serde(default)]
1876    pub stage: Value,
1877}
1878
1879#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1880#[serde(rename_all = "camelCase")]
1881pub struct ExperimentalFeatureEnablementSetParams {
1882    #[serde(default)]
1883    pub enablement: std::collections::BTreeMap<String, bool>,
1884}
1885
1886#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1887#[serde(rename_all = "camelCase")]
1888pub struct ExperimentalFeatureEnablementSetResponse {
1889    #[serde(default)]
1890    pub enablement: std::collections::BTreeMap<String, bool>,
1891}
1892
1893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1894#[serde(rename_all = "camelCase")]
1895pub struct ExperimentalFeatureListParams {
1896    #[serde(default, skip_serializing_if = "Option::is_none")]
1897    pub cursor: Option<String>,
1898    #[serde(default, skip_serializing_if = "Option::is_none")]
1899    pub limit: Option<i64>,
1900    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
1901    pub thread_id: Option<String>,
1902}
1903
1904#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1905#[serde(rename_all = "camelCase")]
1906pub struct ExperimentalFeatureListResponse {
1907    #[serde(default)]
1908    pub data: Vec<ExperimentalFeature>,
1909    #[serde(
1910        rename = "nextCursor",
1911        default,
1912        skip_serializing_if = "Option::is_none"
1913    )]
1914    pub next_cursor: Option<String>,
1915}
1916
1917#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
1918pub enum ExperimentalFeatureStage {
1919    #[serde(rename = "beta")]
1920    Beta,
1921    #[serde(rename = "underDevelopment")]
1922    UnderDevelopment,
1923    #[serde(rename = "stable")]
1924    Stable,
1925    #[serde(rename = "deprecated")]
1926    Deprecated,
1927    #[serde(rename = "removed")]
1928    Removed,
1929}
1930
1931#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1932#[serde(rename_all = "camelCase")]
1933pub struct ExternalAgentConfigDetectParams {
1934    #[serde(default, skip_serializing_if = "Option::is_none")]
1935    pub cwds: Option<Vec<String>>,
1936    #[serde(
1937        rename = "includeHome",
1938        default,
1939        skip_serializing_if = "Option::is_none"
1940    )]
1941    pub include_home: Option<bool>,
1942    #[serde(
1943        rename = "maxSessionAgeDays",
1944        default,
1945        skip_serializing_if = "Option::is_none"
1946    )]
1947    pub max_session_age_days: Option<i64>,
1948    #[serde(
1949        rename = "maxSessions",
1950        default,
1951        skip_serializing_if = "Option::is_none"
1952    )]
1953    pub max_sessions: Option<i64>,
1954    #[serde(
1955        rename = "migrationSource",
1956        default,
1957        skip_serializing_if = "Option::is_none"
1958    )]
1959    pub migration_source: Option<String>,
1960    #[serde(default, skip_serializing_if = "Option::is_none")]
1961    pub source: Option<String>,
1962}
1963
1964#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1965#[serde(rename_all = "camelCase")]
1966pub struct ExternalAgentConfigDetectResponse {
1967    #[serde(default, skip_serializing_if = "Option::is_none")]
1968    pub connectors: Option<Vec<ExternalAgentDetectedConnectorCandidate>>,
1969    #[serde(default)]
1970    pub items: Vec<ExternalAgentConfigMigrationItem>,
1971}
1972
1973#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1974#[serde(rename_all = "camelCase")]
1975pub struct ExternalAgentConfigImportCompletedNotification {
1976    #[serde(rename = "importId", default)]
1977    pub import_id: String,
1978    #[serde(rename = "itemTypeResults", default)]
1979    pub item_type_results: Vec<ExternalAgentConfigImportTypeResult>,
1980}
1981
1982#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1983#[serde(rename_all = "camelCase")]
1984pub struct ExternalAgentConfigImportHistoriesReadResponse {
1985    #[serde(default)]
1986    pub connectors: Vec<ExternalAgentImportedConnectorCandidate>,
1987    #[serde(default)]
1988    pub data: Vec<ExternalAgentConfigImportHistory>,
1989}
1990
1991#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1992#[serde(rename_all = "camelCase")]
1993pub struct ExternalAgentConfigImportHistory {
1994    #[serde(rename = "completedAtMs", default)]
1995    pub completed_at_ms: i64,
1996    #[serde(default)]
1997    pub failures: Vec<ExternalAgentConfigImportItemTypeFailure>,
1998    #[serde(rename = "importId", default)]
1999    pub import_id: String,
2000    #[serde(
2001        rename = "providerId",
2002        default,
2003        skip_serializing_if = "Option::is_none"
2004    )]
2005    pub provider_id: Option<String>,
2006    #[serde(default)]
2007    pub successes: Vec<ExternalAgentConfigImportItemTypeSuccess>,
2008}
2009
2010#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2011#[serde(rename_all = "camelCase")]
2012pub struct ExternalAgentConfigImportHistoryRecordParams {
2013    #[serde(rename = "itemTypeResults", default)]
2014    pub item_type_results: Vec<ExternalAgentConfigImportHistoryRecordTypeResultParams>,
2015    #[serde(rename = "providerId", default)]
2016    pub provider_id: String,
2017}
2018
2019#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2020#[serde(rename_all = "camelCase")]
2021pub struct ExternalAgentConfigImportHistoryRecordResponse {
2022    #[serde(rename = "importId", default)]
2023    pub import_id: String,
2024}
2025
2026#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2027#[serde(rename_all = "camelCase")]
2028pub struct ExternalAgentConfigImportHistoryRecordSuccessParams {
2029    #[serde(default, skip_serializing_if = "Option::is_none")]
2030    pub cwd: Option<String>,
2031    #[serde(rename = "itemType")]
2032    pub item_type: ExternalAgentConfigMigrationItemType,
2033    #[serde(default, skip_serializing_if = "Option::is_none")]
2034    pub source: Option<String>,
2035    #[serde(default, skip_serializing_if = "Option::is_none")]
2036    pub target: Option<String>,
2037    #[serde(default, skip_serializing_if = "Option::is_none")]
2038    pub title: Option<String>,
2039}
2040
2041#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2042#[serde(rename_all = "camelCase")]
2043pub struct ExternalAgentConfigImportHistoryRecordTypeResultParams {
2044    #[serde(default)]
2045    pub failures: Vec<ExternalAgentConfigImportItemTypeFailure>,
2046    #[serde(rename = "itemType")]
2047    pub item_type: ExternalAgentConfigMigrationItemType,
2048    #[serde(default)]
2049    pub successes: Vec<ExternalAgentConfigImportHistoryRecordSuccessParams>,
2050}
2051
2052#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2053#[serde(rename_all = "camelCase")]
2054pub struct ExternalAgentConfigImportItemTypeFailure {
2055    #[serde(default, skip_serializing_if = "Option::is_none")]
2056    pub cwd: Option<String>,
2057    #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
2058    pub error_type: Option<String>,
2059    #[serde(rename = "failureStage", default)]
2060    pub failure_stage: String,
2061    #[serde(rename = "itemType")]
2062    pub item_type: ExternalAgentConfigMigrationItemType,
2063    #[serde(default)]
2064    pub message: String,
2065    #[serde(default, skip_serializing_if = "Option::is_none")]
2066    pub source: Option<String>,
2067    #[serde(
2068        rename = "subErrorType",
2069        default,
2070        skip_serializing_if = "Option::is_none"
2071    )]
2072    pub sub_error_type: Option<String>,
2073}
2074
2075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2076#[serde(rename_all = "camelCase")]
2077pub struct ExternalAgentConfigImportItemTypeSuccess {
2078    #[serde(default, skip_serializing_if = "Option::is_none")]
2079    pub cwd: Option<String>,
2080    #[serde(rename = "itemType")]
2081    pub item_type: ExternalAgentConfigMigrationItemType,
2082    #[serde(default, skip_serializing_if = "Option::is_none")]
2083    pub source: Option<String>,
2084    #[serde(default, skip_serializing_if = "Option::is_none")]
2085    pub target: Option<String>,
2086    #[serde(default, skip_serializing_if = "Option::is_none")]
2087    pub title: Option<String>,
2088}
2089
2090#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2091#[serde(rename_all = "camelCase")]
2092pub struct ExternalAgentConfigImportParams {
2093    #[serde(rename = "migrationItems", default)]
2094    pub migration_items: Vec<ExternalAgentConfigMigrationItem>,
2095    #[serde(
2096        rename = "migrationSource",
2097        default,
2098        skip_serializing_if = "Option::is_none"
2099    )]
2100    pub migration_source: Option<String>,
2101    #[serde(
2102        rename = "providerId",
2103        default,
2104        skip_serializing_if = "Option::is_none"
2105    )]
2106    pub provider_id: Option<String>,
2107    #[serde(default, skip_serializing_if = "Option::is_none")]
2108    pub source: Option<String>,
2109}
2110
2111#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2112#[serde(rename_all = "camelCase")]
2113pub struct ExternalAgentConfigImportProgressNotification {
2114    #[serde(rename = "importId", default)]
2115    pub import_id: String,
2116    #[serde(rename = "itemTypeResults", default)]
2117    pub item_type_results: Vec<ExternalAgentConfigImportTypeResult>,
2118}
2119
2120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2121#[serde(rename_all = "camelCase")]
2122pub struct ExternalAgentConfigImportResponse {
2123    #[serde(rename = "importId", default)]
2124    pub import_id: String,
2125}
2126
2127#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2128#[serde(rename_all = "camelCase")]
2129pub struct ExternalAgentConfigImportTypeResult {
2130    #[serde(default)]
2131    pub failures: Vec<ExternalAgentConfigImportItemTypeFailure>,
2132    #[serde(rename = "itemType")]
2133    pub item_type: ExternalAgentConfigMigrationItemType,
2134    #[serde(default)]
2135    pub successes: Vec<ExternalAgentConfigImportItemTypeSuccess>,
2136}
2137
2138#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2139#[serde(rename_all = "camelCase")]
2140pub struct ExternalAgentConfigMigrationItem {
2141    #[serde(default, skip_serializing_if = "Option::is_none")]
2142    pub cwd: Option<String>,
2143    #[serde(default)]
2144    pub description: String,
2145    #[serde(default, skip_serializing_if = "Option::is_none")]
2146    pub details: Option<MigrationDetails>,
2147    #[serde(rename = "itemType")]
2148    pub item_type: ExternalAgentConfigMigrationItemType,
2149}
2150
2151#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2152pub enum ExternalAgentConfigMigrationItemType {
2153    #[serde(rename = "AGENTS_MD")]
2154    AGENTS_MD,
2155    #[serde(rename = "CONFIG")]
2156    CONFIG,
2157    #[serde(rename = "SKILLS")]
2158    SKILLS,
2159    #[serde(rename = "PLUGINS")]
2160    PLUGINS,
2161    #[serde(rename = "MCP_SERVER_CONFIG")]
2162    MCP_SERVER_CONFIG,
2163    #[serde(rename = "SUBAGENTS")]
2164    SUBAGENTS,
2165    #[serde(rename = "HOOKS")]
2166    HOOKS,
2167    #[serde(rename = "COMMANDS")]
2168    COMMANDS,
2169    #[serde(rename = "MEMORY")]
2170    MEMORY,
2171    #[serde(rename = "SESSIONS")]
2172    SESSIONS,
2173}
2174
2175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2176#[serde(rename_all = "camelCase")]
2177pub struct ExternalAgentDetectedConnectorCandidate {
2178    #[serde(default)]
2179    pub name: String,
2180    #[serde(rename = "sessionCount", default)]
2181    pub session_count: i64,
2182    #[serde()]
2183    pub source: ExternalAgentDetectedConnectorSource,
2184}
2185
2186#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2187pub enum ExternalAgentDetectedConnectorSource {
2188    #[serde(rename = "remoteMcpServersConfig")]
2189    RemoteMcpServersConfig,
2190    #[serde(rename = "sessionToolUse")]
2191    SessionToolUse,
2192}
2193
2194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2195#[serde(rename_all = "camelCase")]
2196pub struct ExternalAgentImportedConnectorCandidate {
2197    #[serde(default)]
2198    pub name: String,
2199    #[serde(rename = "sessionCount", default)]
2200    pub session_count: i64,
2201    #[serde()]
2202    pub source: ExternalAgentImportedConnectorSource,
2203}
2204
2205#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2206pub enum ExternalAgentImportedConnectorSource {
2207    #[serde(rename = "remoteMcpServersConfig")]
2208    RemoteMcpServersConfig,
2209}
2210
2211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2212#[serde(rename_all = "camelCase")]
2213pub struct FeedbackRequirements {
2214    #[serde(default, skip_serializing_if = "Option::is_none")]
2215    pub enabled: Option<bool>,
2216}
2217
2218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2219#[serde(rename_all = "camelCase")]
2220pub struct FeedbackUploadParams {
2221    #[serde(default)]
2222    pub classification: String,
2223    #[serde(
2224        rename = "extraLogFiles",
2225        default,
2226        skip_serializing_if = "Option::is_none"
2227    )]
2228    pub extra_log_files: Option<Vec<String>>,
2229    #[serde(
2230        rename = "includeLogs",
2231        default,
2232        skip_serializing_if = "Option::is_none"
2233    )]
2234    pub include_logs: Option<bool>,
2235    #[serde(default, skip_serializing_if = "Option::is_none")]
2236    pub reason: Option<String>,
2237    #[serde(default, skip_serializing_if = "Option::is_none")]
2238    pub tags: Option<std::collections::BTreeMap<String, String>>,
2239    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
2240    pub thread_id: Option<String>,
2241}
2242
2243#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2244#[serde(rename_all = "camelCase")]
2245pub struct FeedbackUploadResponse {
2246    #[serde(rename = "threadId", default)]
2247    pub thread_id: String,
2248}
2249
2250#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2251#[serde(tag = "type", rename_all = "camelCase")]
2252pub enum FileChange {
2253    Add {
2254        content: String,
2255    },
2256    Delete {
2257        content: String,
2258    },
2259    Update {
2260        #[serde(default, skip_serializing_if = "Option::is_none")]
2261        move_path: Option<String>,
2262        unified_diff: String,
2263    },
2264}
2265
2266#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
2267pub enum FileChangeApprovalDecision {
2268    #[serde(rename = "accept")]
2269    Accept,
2270    #[serde(rename = "acceptForSession")]
2271    AcceptForSession,
2272    #[serde(rename = "decline")]
2273    Decline,
2274    #[serde(rename = "cancel")]
2275    Cancel,
2276}
2277
2278#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2279#[serde(rename_all = "camelCase")]
2280pub struct FileChangeOutputDeltaNotification {
2281    #[serde(default)]
2282    pub delta: String,
2283    #[serde(rename = "itemId", default)]
2284    pub item_id: String,
2285    #[serde(rename = "threadId", default)]
2286    pub thread_id: String,
2287    #[serde(rename = "turnId", default)]
2288    pub turn_id: String,
2289}
2290
2291#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2292#[serde(rename_all = "camelCase")]
2293pub struct FileChangePatchUpdatedNotification {
2294    #[serde(default)]
2295    pub changes: Vec<FileUpdateChange>,
2296    #[serde(rename = "itemId", default)]
2297    pub item_id: String,
2298    #[serde(rename = "threadId", default)]
2299    pub thread_id: String,
2300    #[serde(rename = "turnId", default)]
2301    pub turn_id: String,
2302}
2303
2304#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2305#[serde(rename_all = "camelCase")]
2306pub struct FileChangeRequestApprovalParams {
2307    #[serde(rename = "grantRoot", default, skip_serializing_if = "Option::is_none")]
2308    pub grant_root: Option<String>,
2309    #[serde(rename = "itemId", default)]
2310    pub item_id: String,
2311    #[serde(default, skip_serializing_if = "Option::is_none")]
2312    pub reason: Option<String>,
2313    #[serde(rename = "startedAtMs", default)]
2314    pub started_at_ms: i64,
2315    #[serde(rename = "threadId", default)]
2316    pub thread_id: String,
2317    #[serde(rename = "turnId", default)]
2318    pub turn_id: String,
2319}
2320
2321#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2322#[serde(rename_all = "camelCase")]
2323pub struct FileChangeRequestApprovalResponse {
2324    #[serde()]
2325    pub decision: FileChangeApprovalDecision,
2326}
2327
2328#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2329pub enum FileSystemAccessMode {
2330    #[serde(rename = "read")]
2331    Read,
2332    #[serde(rename = "write")]
2333    Write,
2334    #[serde(rename = "deny")]
2335    Deny,
2336}
2337
2338#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2339#[serde(tag = "type", rename_all = "camelCase")]
2340pub enum FileSystemPath {
2341    Path { path: LegacyAppPathString },
2342    Glob_pattern { pattern: String },
2343    Special { value: FileSystemSpecialPath },
2344}
2345
2346#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2347#[serde(rename_all = "camelCase")]
2348pub struct FileSystemSandboxEntry {
2349    #[serde()]
2350    pub access: FileSystemAccessMode,
2351    #[serde()]
2352    pub path: FileSystemPath,
2353}
2354
2355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2356#[serde(tag = "kind", rename_all = "camelCase")]
2357pub enum FileSystemSpecialPath {
2358    Root,
2359    Minimal,
2360    ProjectRoots {
2361        #[serde(default, skip_serializing_if = "Option::is_none")]
2362        subpath: Option<LegacyAppPathString>,
2363    },
2364    Tmpdir,
2365    SlashTmp,
2366    Unknown {
2367        path: String,
2368        #[serde(default, skip_serializing_if = "Option::is_none")]
2369        subpath: Option<LegacyAppPathString>,
2370    },
2371}
2372
2373#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2374#[serde(rename_all = "camelCase")]
2375pub struct FileUpdateChange {
2376    #[serde(default)]
2377    pub diff: String,
2378    #[serde()]
2379    pub kind: PatchChangeKind,
2380    #[serde(default)]
2381    pub path: String,
2382}
2383
2384#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2385#[serde(untagged)]
2386pub enum ForcedChatgptWorkspaceIds {
2387    Variant0(String),
2388    Variant1(Vec<String>),
2389}
2390
2391#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2392pub enum ForcedLoginMethod {
2393    #[serde(rename = "chatgpt")]
2394    Chatgpt,
2395    #[serde(rename = "api")]
2396    Api,
2397}
2398
2399#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2400#[serde(rename_all = "camelCase")]
2401pub struct FsChangedNotification {
2402    #[serde(rename = "changedPaths", default)]
2403    pub changed_paths: Vec<AbsolutePathBuf>,
2404    #[serde(rename = "watchId", default)]
2405    pub watch_id: String,
2406}
2407
2408#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2409#[serde(rename_all = "camelCase")]
2410pub struct FsCopyParams {
2411    #[serde(rename = "destinationPath", default)]
2412    pub destination_path: Value,
2413    #[serde(default, skip_serializing_if = "Option::is_none")]
2414    pub recursive: Option<bool>,
2415    #[serde(rename = "sourcePath", default)]
2416    pub source_path: Value,
2417}
2418
2419#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2420#[serde(rename_all = "camelCase")]
2421pub struct FsCopyResponse {
2422    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2423    pub extra: serde_json::Map<String, Value>,
2424}
2425
2426#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2427#[serde(rename_all = "camelCase")]
2428pub struct FsCreateDirectoryParams {
2429    #[serde(default)]
2430    pub path: Value,
2431    #[serde(default, skip_serializing_if = "Option::is_none")]
2432    pub recursive: Option<bool>,
2433}
2434
2435#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2436#[serde(rename_all = "camelCase")]
2437pub struct FsCreateDirectoryResponse {
2438    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2439    pub extra: serde_json::Map<String, Value>,
2440}
2441
2442#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2443#[serde(rename_all = "camelCase")]
2444pub struct FsGetMetadataParams {
2445    #[serde(default)]
2446    pub path: Value,
2447}
2448
2449#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2450#[serde(rename_all = "camelCase")]
2451pub struct FsGetMetadataResponse {
2452    #[serde(rename = "createdAtMs", default)]
2453    pub created_at_ms: i64,
2454    #[serde(rename = "isDirectory", default)]
2455    pub is_directory: bool,
2456    #[serde(rename = "isFile", default)]
2457    pub is_file: bool,
2458    #[serde(rename = "isSymlink", default)]
2459    pub is_symlink: bool,
2460    #[serde(rename = "modifiedAtMs", default)]
2461    pub modified_at_ms: i64,
2462}
2463
2464#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2465#[serde(rename_all = "camelCase")]
2466pub struct FsReadDirectoryEntry {
2467    #[serde(rename = "fileName", default)]
2468    pub file_name: String,
2469    #[serde(rename = "isDirectory", default)]
2470    pub is_directory: bool,
2471    #[serde(rename = "isFile", default)]
2472    pub is_file: bool,
2473}
2474
2475#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2476#[serde(rename_all = "camelCase")]
2477pub struct FsReadDirectoryParams {
2478    #[serde(default)]
2479    pub path: Value,
2480}
2481
2482#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2483#[serde(rename_all = "camelCase")]
2484pub struct FsReadDirectoryResponse {
2485    #[serde(default)]
2486    pub entries: Vec<FsReadDirectoryEntry>,
2487}
2488
2489#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2490#[serde(rename_all = "camelCase")]
2491pub struct FsReadFileParams {
2492    #[serde(default)]
2493    pub path: Value,
2494}
2495
2496#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2497#[serde(rename_all = "camelCase")]
2498pub struct FsReadFileResponse {
2499    #[serde(rename = "dataBase64", default)]
2500    pub data_base64: String,
2501}
2502
2503#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2504#[serde(rename_all = "camelCase")]
2505pub struct FsRemoveParams {
2506    #[serde(default, skip_serializing_if = "Option::is_none")]
2507    pub force: Option<bool>,
2508    #[serde(default)]
2509    pub path: Value,
2510    #[serde(default, skip_serializing_if = "Option::is_none")]
2511    pub recursive: Option<bool>,
2512}
2513
2514#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2515#[serde(rename_all = "camelCase")]
2516pub struct FsRemoveResponse {
2517    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2518    pub extra: serde_json::Map<String, Value>,
2519}
2520
2521#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2522#[serde(rename_all = "camelCase")]
2523pub struct FsUnwatchParams {
2524    #[serde(rename = "watchId", default)]
2525    pub watch_id: String,
2526}
2527
2528#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2529#[serde(rename_all = "camelCase")]
2530pub struct FsUnwatchResponse {
2531    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2532    pub extra: serde_json::Map<String, Value>,
2533}
2534
2535#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2536#[serde(rename_all = "camelCase")]
2537pub struct FsWatchParams {
2538    #[serde(default)]
2539    pub path: Value,
2540    #[serde(rename = "watchId", default)]
2541    pub watch_id: String,
2542}
2543
2544#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2545#[serde(rename_all = "camelCase")]
2546pub struct FsWatchResponse {
2547    #[serde(default)]
2548    pub path: Value,
2549}
2550
2551#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2552#[serde(rename_all = "camelCase")]
2553pub struct FsWriteFileParams {
2554    #[serde(rename = "dataBase64", default)]
2555    pub data_base64: String,
2556    #[serde(default)]
2557    pub path: Value,
2558}
2559
2560#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2561#[serde(rename_all = "camelCase")]
2562pub struct FsWriteFileResponse {
2563    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2564    pub extra: serde_json::Map<String, Value>,
2565}
2566
2567#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2568pub enum FuzzyFileSearchMatchType {
2569    #[serde(rename = "file")]
2570    File,
2571    #[serde(rename = "directory")]
2572    Directory,
2573}
2574
2575#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2576#[serde(rename_all = "camelCase")]
2577pub struct FuzzyFileSearchParams {
2578    #[serde(
2579        rename = "cancellationToken",
2580        default,
2581        skip_serializing_if = "Option::is_none"
2582    )]
2583    pub cancellation_token: Option<String>,
2584    #[serde(default)]
2585    pub query: String,
2586    #[serde(default)]
2587    pub roots: Vec<String>,
2588}
2589
2590#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2591#[serde(rename_all = "camelCase")]
2592pub struct FuzzyFileSearchResponse {
2593    #[serde(default)]
2594    pub files: Vec<FuzzyFileSearchResult>,
2595}
2596
2597/// A tool call's output body: either a plain string or Responses-API
2598/// compatible content items (0.148 upstream).
2599#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2600#[serde(untagged)]
2601pub enum FunctionCallOutputBody {
2602    Text(String),
2603    Items(Vec<FunctionCallOutputContentItem>),
2604}
2605
2606/// Responses-API compatible content items a tool call can return — the
2607/// subset of ContentItem supported as function call outputs (0.148 upstream).
2608/// Wire tags and fields are snake_case, unlike most v2 types.
2609#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2610#[serde(tag = "type")]
2611pub enum FunctionCallOutputContentItem {
2612    #[serde(rename = "input_text")]
2613    InputText { text: String },
2614    #[serde(rename = "input_image")]
2615    InputImage {
2616        #[serde(default, skip_serializing_if = "Option::is_none")]
2617        detail: Option<ImageDetail>,
2618        image_url: String,
2619    },
2620    #[serde(rename = "input_audio")]
2621    InputAudio { audio_url: String },
2622    #[serde(rename = "encrypted_content")]
2623    EncryptedContent { encrypted_content: String },
2624}
2625
2626#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2627#[serde(rename_all = "camelCase")]
2628pub struct FuzzyFileSearchResult {
2629    #[serde(default)]
2630    pub file_name: String,
2631    #[serde(default, skip_serializing_if = "Option::is_none")]
2632    pub indices: Option<Vec<i64>>,
2633    #[serde()]
2634    pub match_type: FuzzyFileSearchMatchType,
2635    #[serde(default)]
2636    pub path: String,
2637    #[serde(default)]
2638    pub root: String,
2639    #[serde(default)]
2640    pub score: i64,
2641}
2642
2643#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2644#[serde(rename_all = "camelCase")]
2645pub struct FuzzyFileSearchSessionCompletedNotification {
2646    #[serde(rename = "sessionId", default)]
2647    pub session_id: String,
2648}
2649
2650#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2651#[serde(rename_all = "camelCase")]
2652pub struct FuzzyFileSearchSessionUpdatedNotification {
2653    #[serde(default)]
2654    pub files: Vec<FuzzyFileSearchResult>,
2655    #[serde(default)]
2656    pub query: String,
2657    #[serde(rename = "sessionId", default)]
2658    pub session_id: String,
2659}
2660
2661#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2662#[serde(rename_all = "camelCase")]
2663pub struct GetAccountParams {
2664    #[serde(
2665        rename = "refreshToken",
2666        default,
2667        skip_serializing_if = "Option::is_none"
2668    )]
2669    pub refresh_token: Option<bool>,
2670}
2671
2672#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2673#[serde(rename_all = "camelCase")]
2674pub struct GetAccountRateLimitsResponse {
2675    #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
2676    pub account_id: Option<String>,
2677    #[serde(
2678        rename = "rateLimitResetCredits",
2679        default,
2680        skip_serializing_if = "Option::is_none"
2681    )]
2682    pub rate_limit_reset_credits: Option<RateLimitResetCreditsSummary>,
2683    #[serde(
2684        rename = "rateLimitUpsell",
2685        default,
2686        skip_serializing_if = "Option::is_none"
2687    )]
2688    pub rate_limit_upsell: Option<Value>,
2689    #[serde(rename = "rateLimits", default)]
2690    pub rate_limits: Value,
2691    #[serde(
2692        rename = "rateLimitsByLimitId",
2693        default,
2694        skip_serializing_if = "Option::is_none"
2695    )]
2696    pub rate_limits_by_limit_id: Option<std::collections::BTreeMap<String, RateLimitSnapshot>>,
2697}
2698
2699#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2700#[serde(rename_all = "camelCase")]
2701pub struct GetAccountResponse {
2702    #[serde(default, skip_serializing_if = "Option::is_none")]
2703    pub account: Option<Account>,
2704    #[serde(rename = "requiresOpenaiAuth", default)]
2705    pub requires_openai_auth: bool,
2706}
2707
2708#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2709#[serde(rename_all = "camelCase")]
2710pub struct GetAccountTokenUsageResponse {
2711    #[serde(
2712        rename = "dailyUsageBuckets",
2713        default,
2714        skip_serializing_if = "Option::is_none"
2715    )]
2716    pub daily_usage_buckets: Option<Vec<AccountTokenUsageDailyBucket>>,
2717    #[serde()]
2718    pub summary: AccountTokenUsageSummary,
2719    #[serde(
2720        rename = "threadUsage",
2721        default,
2722        skip_serializing_if = "Option::is_none"
2723    )]
2724    pub thread_usage: Option<ThreadUsage>,
2725}
2726
2727#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2728#[serde(rename_all = "camelCase")]
2729pub struct GetAccountTokenUsageParams {
2730    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
2731    pub thread_id: Option<String>,
2732}
2733
2734#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2735#[serde(rename_all = "camelCase")]
2736pub struct ThreadUsage {
2737    #[serde(rename = "estimatedUsageCreditsMicros", default)]
2738    pub estimated_usage_credits_micros: i64,
2739    #[serde(
2740        rename = "estimatedUsageUsdMicros",
2741        default,
2742        skip_serializing_if = "Option::is_none"
2743    )]
2744    pub estimated_usage_usd_micros: Option<i64>,
2745    #[serde(default)]
2746    pub groups: Vec<ThreadUsageBreakdownGroup>,
2747    #[serde(rename = "threadId", default)]
2748    pub thread_id: String,
2749}
2750
2751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2752#[serde(rename_all = "camelCase")]
2753pub struct ThreadUsageBreakdownGroup {
2754    #[serde(
2755        rename = "cachedInputTokens",
2756        default,
2757        skip_serializing_if = "Option::is_none"
2758    )]
2759    pub cached_input_tokens: Option<i64>,
2760    #[serde(rename = "estimatedUsageCreditsMicros", default)]
2761    pub estimated_usage_credits_micros: i64,
2762    #[serde(
2763        rename = "inputTokens",
2764        default,
2765        skip_serializing_if = "Option::is_none"
2766    )]
2767    pub input_tokens: Option<i64>,
2768    #[serde(default, skip_serializing_if = "Option::is_none")]
2769    pub model: Option<String>,
2770    #[serde(
2771        rename = "netNewInputTokens",
2772        default,
2773        skip_serializing_if = "Option::is_none"
2774    )]
2775    pub net_new_input_tokens: Option<i64>,
2776    #[serde(
2777        rename = "outputTokens",
2778        default,
2779        skip_serializing_if = "Option::is_none"
2780    )]
2781    pub output_tokens: Option<i64>,
2782    #[serde(
2783        rename = "reasoningEffort",
2784        default,
2785        skip_serializing_if = "Option::is_none"
2786    )]
2787    pub reasoning_effort: Option<String>,
2788    #[serde(default, skip_serializing_if = "Option::is_none")]
2789    pub speed: Option<String>,
2790    #[serde(
2791        rename = "totalTokens",
2792        default,
2793        skip_serializing_if = "Option::is_none"
2794    )]
2795    pub total_tokens: Option<i64>,
2796}
2797
2798#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2799#[serde(tag = "type", rename_all = "camelCase")]
2800pub enum ImageGenerationFailure {
2801    #[serde(rename = "usageLimitExceeded")]
2802    UsageLimitExceeded {
2803        #[serde(rename = "limitId")]
2804        limit_id: String,
2805        #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
2806        resets_at: Option<i64>,
2807    },
2808}
2809
2810#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2811#[serde(rename_all = "lowercase")]
2812pub enum McpServerOauthClientRegistration {
2813    Auto,
2814    Cimd,
2815    Dcr,
2816}
2817
2818#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2819#[serde(rename_all = "camelCase")]
2820pub struct GetWorkspaceMessagesResponse {
2821    #[serde(rename = "featureEnabled", default)]
2822    pub feature_enabled: bool,
2823    #[serde(default)]
2824    pub messages: Vec<WorkspaceMessage>,
2825}
2826
2827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2828#[serde(rename_all = "camelCase")]
2829pub struct GitInfo {
2830    #[serde(default, skip_serializing_if = "Option::is_none")]
2831    pub branch: Option<String>,
2832    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
2833    pub origin_url: Option<String>,
2834    #[serde(default, skip_serializing_if = "Option::is_none")]
2835    pub sha: Option<String>,
2836}
2837
2838#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2839#[serde(rename_all = "camelCase")]
2840pub struct GrantedPermissionProfile {
2841    #[serde(
2842        rename = "fileSystem",
2843        default,
2844        skip_serializing_if = "Option::is_none"
2845    )]
2846    pub file_system: Option<AdditionalFileSystemPermissions>,
2847    #[serde(default, skip_serializing_if = "Option::is_none")]
2848    pub network: Option<AdditionalNetworkPermissions>,
2849}
2850
2851#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2852#[serde(rename_all = "camelCase")]
2853pub struct GuardianApprovalReview {
2854    #[serde(default, skip_serializing_if = "Option::is_none")]
2855    pub rationale: Option<String>,
2856    #[serde(rename = "riskLevel", default, skip_serializing_if = "Option::is_none")]
2857    pub risk_level: Option<GuardianRiskLevel>,
2858    #[serde()]
2859    pub status: GuardianApprovalReviewStatus,
2860    #[serde(
2861        rename = "userAuthorization",
2862        default,
2863        skip_serializing_if = "Option::is_none"
2864    )]
2865    pub user_authorization: Option<GuardianUserAuthorization>,
2866}
2867
2868#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2869#[serde(tag = "type", rename_all = "camelCase")]
2870pub enum GuardianApprovalReviewAction {
2871    Command {
2872        command: String,
2873        cwd: AbsolutePathBuf,
2874        source: GuardianCommandSource,
2875    },
2876    Execve {
2877        argv: Vec<String>,
2878        cwd: AbsolutePathBuf,
2879        program: String,
2880        source: GuardianCommandSource,
2881    },
2882    #[serde(rename = "writeStdin")]
2883    WriteStdin {
2884        #[serde(rename = "approvalId")]
2885        approval_id: String,
2886        cwd: LegacyAppPathString,
2887        #[serde(rename = "processId")]
2888        process_id: String,
2889        stdin: String,
2890    },
2891    #[serde(rename = "applyPatch")]
2892    ApplyPatch {
2893        cwd: AbsolutePathBuf,
2894        files: Vec<AbsolutePathBuf>,
2895    },
2896    #[serde(rename = "networkAccess")]
2897    NetworkAccess {
2898        host: String,
2899        port: i64,
2900        protocol: NetworkApprovalProtocol,
2901        target: String,
2902    },
2903    #[serde(rename = "mcpToolCall")]
2904    McpToolCall {
2905        #[serde(
2906            rename = "connectorId",
2907            default,
2908            skip_serializing_if = "Option::is_none"
2909        )]
2910        connector_id: Option<String>,
2911        #[serde(
2912            rename = "connectorName",
2913            default,
2914            skip_serializing_if = "Option::is_none"
2915        )]
2916        connector_name: Option<String>,
2917        server: String,
2918        #[serde(rename = "toolName")]
2919        tool_name: String,
2920        #[serde(rename = "toolTitle", default, skip_serializing_if = "Option::is_none")]
2921        tool_title: Option<String>,
2922    },
2923    #[serde(rename = "requestPermissions")]
2924    RequestPermissions {
2925        permissions: RequestPermissionProfile,
2926        #[serde(default, skip_serializing_if = "Option::is_none")]
2927        reason: Option<String>,
2928    },
2929}
2930
2931#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2932pub enum GuardianApprovalReviewStatus {
2933    #[serde(rename = "inProgress")]
2934    InProgress,
2935    #[serde(rename = "approved")]
2936    Approved,
2937    #[serde(rename = "denied")]
2938    Denied,
2939    #[serde(rename = "timedOut")]
2940    TimedOut,
2941    #[serde(rename = "aborted")]
2942    Aborted,
2943}
2944
2945#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2946pub enum GuardianCommandSource {
2947    #[serde(rename = "shell")]
2948    Shell,
2949    #[serde(rename = "unifiedExec")]
2950    UnifiedExec,
2951}
2952
2953#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2954pub enum GuardianRiskLevel {
2955    #[serde(rename = "low")]
2956    Low,
2957    #[serde(rename = "medium")]
2958    Medium,
2959    #[serde(rename = "high")]
2960    High,
2961    #[serde(rename = "critical")]
2962    Critical,
2963}
2964
2965#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2966pub enum GuardianUserAuthorization {
2967    #[serde(rename = "unknown")]
2968    Unknown,
2969    #[serde(rename = "low")]
2970    Low,
2971    #[serde(rename = "medium")]
2972    Medium,
2973    #[serde(rename = "high")]
2974    High,
2975}
2976
2977#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2978#[serde(rename_all = "camelCase")]
2979pub struct GuardianWarningNotification {
2980    #[serde(default)]
2981    pub message: String,
2982    #[serde(rename = "threadId", default)]
2983    pub thread_id: String,
2984}
2985
2986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2987#[serde(rename_all = "camelCase")]
2988pub struct HookCompletedNotification {
2989    #[serde()]
2990    pub run: HookRunSummary,
2991    #[serde(rename = "threadId", default)]
2992    pub thread_id: String,
2993    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
2994    pub turn_id: Option<String>,
2995}
2996
2997#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2998#[serde(rename_all = "camelCase")]
2999pub struct HookErrorInfo {
3000    #[serde(default)]
3001    pub message: String,
3002    #[serde(default)]
3003    pub path: String,
3004}
3005
3006#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3007pub enum HookEventName {
3008    #[serde(rename = "preToolUse")]
3009    PreToolUse,
3010    #[serde(rename = "permissionRequest")]
3011    PermissionRequest,
3012    #[serde(rename = "postToolUse")]
3013    PostToolUse,
3014    #[serde(rename = "preCompact")]
3015    PreCompact,
3016    #[serde(rename = "postCompact")]
3017    PostCompact,
3018    #[serde(rename = "sessionStart")]
3019    SessionStart,
3020    #[serde(rename = "sessionEnd")]
3021    SessionEnd,
3022    #[serde(rename = "userPromptSubmit")]
3023    UserPromptSubmit,
3024    #[serde(rename = "subagentStart")]
3025    SubagentStart,
3026    #[serde(rename = "subagentStop")]
3027    SubagentStop,
3028    #[serde(rename = "stop")]
3029    Stop,
3030    #[serde(rename = "interrupt")]
3031    Interrupt,
3032}
3033
3034#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3035pub enum HookExecutionMode {
3036    #[serde(rename = "sync")]
3037    Sync,
3038    #[serde(rename = "async")]
3039    Async,
3040}
3041
3042#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3043pub enum HookHandlerType {
3044    #[serde(rename = "command")]
3045    Command,
3046    #[serde(rename = "mcpTool")]
3047    McpTool,
3048    #[serde(rename = "prompt")]
3049    Prompt,
3050    #[serde(rename = "agent")]
3051    Agent,
3052}
3053
3054#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3055#[serde(rename_all = "camelCase")]
3056pub struct HookMetadata {
3057    #[serde(
3058        rename = "additionalContextLimit",
3059        default,
3060        skip_serializing_if = "Option::is_none"
3061    )]
3062    pub additional_context_limit: Option<i64>,
3063    #[serde(rename = "async", default, skip_serializing_if = "Option::is_none")]
3064    pub is_async: Option<bool>,
3065    #[serde(default, skip_serializing_if = "Option::is_none")]
3066    pub command: Option<String>,
3067    #[serde(rename = "currentHash", default)]
3068    pub current_hash: String,
3069    /// MCP server name (`handlerType: "mcpTool"` hooks).
3070    #[serde(default, skip_serializing_if = "Option::is_none")]
3071    pub server: Option<String>,
3072    /// MCP tool name (`handlerType: "mcpTool"` hooks).
3073    #[serde(default, skip_serializing_if = "Option::is_none")]
3074    pub tool: Option<String>,
3075    #[serde(rename = "displayOrder", default)]
3076    pub display_order: i64,
3077    #[serde(default)]
3078    pub enabled: bool,
3079    #[serde(rename = "eventName")]
3080    pub event_name: HookEventName,
3081    #[serde(
3082        rename = "executionMode",
3083        default,
3084        skip_serializing_if = "Option::is_none"
3085    )]
3086    pub execution_mode: Option<Value>,
3087    #[serde(rename = "handlerType")]
3088    pub handler_type: HookHandlerType,
3089    #[serde(rename = "isManaged", default)]
3090    pub is_managed: bool,
3091    #[serde(default)]
3092    pub key: String,
3093    #[serde(default, skip_serializing_if = "Option::is_none")]
3094    pub matcher: Option<String>,
3095    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
3096    pub plugin_id: Option<String>,
3097    #[serde()]
3098    pub source: HookSource,
3099    #[serde(rename = "sourcePath")]
3100    pub source_path: AbsolutePathBuf,
3101    #[serde(
3102        rename = "statusMessage",
3103        default,
3104        skip_serializing_if = "Option::is_none"
3105    )]
3106    pub status_message: Option<String>,
3107    #[serde(rename = "timeoutSec", default)]
3108    pub timeout_sec: i64,
3109    #[serde(rename = "trustStatus")]
3110    pub trust_status: HookTrustStatus,
3111}
3112
3113#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3114#[serde(rename_all = "camelCase")]
3115pub struct HookMigration {
3116    #[serde(default)]
3117    pub name: String,
3118}
3119
3120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3121#[serde(rename_all = "camelCase")]
3122pub struct HookOutputEntry {
3123    #[serde()]
3124    pub kind: HookOutputEntryKind,
3125    #[serde(default)]
3126    pub text: String,
3127}
3128
3129#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3130pub enum HookOutputEntryKind {
3131    #[serde(rename = "warning")]
3132    Warning,
3133    #[serde(rename = "stop")]
3134    Stop,
3135    #[serde(rename = "feedback")]
3136    Feedback,
3137    #[serde(rename = "context")]
3138    Context,
3139    #[serde(rename = "error")]
3140    Error,
3141}
3142
3143#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3144#[serde(rename_all = "camelCase")]
3145pub struct HookPromptFragment {
3146    #[serde(rename = "hookRunId", default)]
3147    pub hook_run_id: String,
3148    #[serde(default)]
3149    pub text: String,
3150}
3151
3152#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3153pub enum HookRunStatus {
3154    #[serde(rename = "running")]
3155    Running,
3156    #[serde(rename = "completed")]
3157    Completed,
3158    #[serde(rename = "failed")]
3159    Failed,
3160    #[serde(rename = "blocked")]
3161    Blocked,
3162    #[serde(rename = "stopped")]
3163    Stopped,
3164}
3165
3166#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3167#[serde(rename_all = "camelCase")]
3168pub struct HookRunSummary {
3169    #[serde(
3170        rename = "completedAt",
3171        default,
3172        skip_serializing_if = "Option::is_none"
3173    )]
3174    pub completed_at: Option<i64>,
3175    #[serde(rename = "displayOrder", default)]
3176    pub display_order: i64,
3177    #[serde(
3178        rename = "durationMs",
3179        default,
3180        skip_serializing_if = "Option::is_none"
3181    )]
3182    pub duration_ms: Option<i64>,
3183    #[serde(default)]
3184    pub entries: Vec<HookOutputEntry>,
3185    #[serde(rename = "eventName")]
3186    pub event_name: HookEventName,
3187    #[serde(rename = "executionMode")]
3188    pub execution_mode: HookExecutionMode,
3189    #[serde(rename = "handlerType")]
3190    pub handler_type: HookHandlerType,
3191    #[serde(default)]
3192    pub id: String,
3193    #[serde()]
3194    pub scope: HookScope,
3195    #[serde(default, skip_serializing_if = "Option::is_none")]
3196    pub source: Option<Value>,
3197    #[serde(rename = "sourcePath")]
3198    pub source_path: AbsolutePathBuf,
3199    #[serde(rename = "startedAt", default)]
3200    pub started_at: i64,
3201    #[serde()]
3202    pub status: HookRunStatus,
3203    #[serde(
3204        rename = "statusMessage",
3205        default,
3206        skip_serializing_if = "Option::is_none"
3207    )]
3208    pub status_message: Option<String>,
3209}
3210
3211#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3212pub enum HookScope {
3213    #[serde(rename = "thread")]
3214    Thread,
3215    #[serde(rename = "turn")]
3216    Turn,
3217}
3218
3219#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3220pub enum HookSource {
3221    #[serde(rename = "system")]
3222    System,
3223    #[serde(rename = "user")]
3224    User,
3225    #[serde(rename = "project")]
3226    Project,
3227    #[serde(rename = "mdm")]
3228    Mdm,
3229    #[serde(rename = "sessionFlags")]
3230    SessionFlags,
3231    #[serde(rename = "plugin")]
3232    Plugin,
3233    #[serde(rename = "cloudRequirements")]
3234    CloudRequirements,
3235    #[serde(rename = "cloudManagedConfig")]
3236    CloudManagedConfig,
3237    #[serde(rename = "legacyManagedConfigFile")]
3238    LegacyManagedConfigFile,
3239    #[serde(rename = "legacyManagedConfigMdm")]
3240    LegacyManagedConfigMdm,
3241    #[serde(rename = "unknown")]
3242    Unknown,
3243}
3244
3245#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3246#[serde(rename_all = "camelCase")]
3247pub struct HookStartedNotification {
3248    #[serde()]
3249    pub run: HookRunSummary,
3250    #[serde(rename = "threadId", default)]
3251    pub thread_id: String,
3252    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
3253    pub turn_id: Option<String>,
3254}
3255
3256#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3257pub enum HookTrustStatus {
3258    #[serde(rename = "managed")]
3259    Managed,
3260    #[serde(rename = "untrusted")]
3261    Untrusted,
3262    #[serde(rename = "trusted")]
3263    Trusted,
3264    #[serde(rename = "modified")]
3265    Modified,
3266}
3267
3268#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3269#[serde(rename_all = "camelCase")]
3270pub struct HooksListEntry {
3271    #[serde(default)]
3272    pub cwd: String,
3273    #[serde(default)]
3274    pub errors: Vec<HookErrorInfo>,
3275    #[serde(default)]
3276    pub hooks: Vec<HookMetadata>,
3277    #[serde(default)]
3278    pub warnings: Vec<String>,
3279}
3280
3281#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3282#[serde(rename_all = "camelCase")]
3283pub struct HooksListParams {
3284    #[serde(default, skip_serializing_if = "Option::is_none")]
3285    pub cwds: Option<Vec<String>>,
3286}
3287
3288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3289#[serde(rename_all = "camelCase")]
3290pub struct HooksListResponse {
3291    #[serde(default)]
3292    pub data: Vec<HooksListEntry>,
3293}
3294
3295#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3296pub enum ImageDetail {
3297    #[serde(rename = "auto")]
3298    Auto,
3299    #[serde(rename = "low")]
3300    Low,
3301    #[serde(rename = "high")]
3302    High,
3303    #[serde(rename = "original")]
3304    Original,
3305}
3306
3307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3308#[serde(rename_all = "camelCase")]
3309pub struct InitializeCapabilities {
3310    #[serde(
3311        rename = "experimentalApi",
3312        default,
3313        skip_serializing_if = "Option::is_none"
3314    )]
3315    pub experimental_api: Option<bool>,
3316    #[serde(default, skip_serializing_if = "Option::is_none")]
3317    pub extensions: Option<Value>,
3318    #[serde(
3319        rename = "mcpServerOpenaiFormElicitation",
3320        default,
3321        skip_serializing_if = "Option::is_none"
3322    )]
3323    pub mcp_server_openai_form_elicitation: Option<bool>,
3324    #[serde(
3325        rename = "optOutNotificationMethods",
3326        default,
3327        skip_serializing_if = "Option::is_none"
3328    )]
3329    pub opt_out_notification_methods: Option<Vec<String>>,
3330    #[serde(
3331        rename = "requestAttestation",
3332        default,
3333        skip_serializing_if = "Option::is_none"
3334    )]
3335    pub request_attestation: Option<bool>,
3336}
3337
3338#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3339#[serde(rename_all = "camelCase")]
3340pub struct InitializeParams {
3341    #[serde(default, skip_serializing_if = "Option::is_none")]
3342    pub capabilities: Option<InitializeCapabilities>,
3343    #[serde(rename = "clientInfo")]
3344    pub client_info: ClientInfo,
3345}
3346
3347#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3348#[serde(rename_all = "camelCase")]
3349pub struct InitializeResponse {
3350    #[serde(rename = "codexHome", default)]
3351    pub codex_home: Value,
3352    #[serde(rename = "platformFamily", default)]
3353    pub platform_family: String,
3354    #[serde(rename = "platformOs", default)]
3355    pub platform_os: String,
3356    #[serde(rename = "userAgent", default)]
3357    pub user_agent: String,
3358}
3359
3360#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
3361pub enum InputModality {
3362    #[serde(rename = "text")]
3363    Text,
3364    #[serde(rename = "image")]
3365    Image,
3366    #[serde(rename = "audio")]
3367    Audio,
3368}
3369
3370#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3371#[serde(rename_all = "camelCase")]
3372pub struct InstalledApp {
3373    #[serde(default)]
3374    pub callable: bool,
3375    #[serde(default)]
3376    pub enabled: bool,
3377    #[serde(default)]
3378    pub id: String,
3379    #[serde(
3380        rename = "runtimeName",
3381        default,
3382        skip_serializing_if = "Option::is_none"
3383    )]
3384    pub runtime_name: Option<String>,
3385}
3386
3387#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3388#[serde(rename_all = "camelCase")]
3389pub struct ItemCompletedNotification {
3390    #[serde(rename = "completedAtMs", default)]
3391    pub completed_at_ms: i64,
3392    #[serde()]
3393    pub item: ThreadItem,
3394    #[serde(rename = "threadId", default)]
3395    pub thread_id: String,
3396    #[serde(rename = "turnId", default)]
3397    pub turn_id: String,
3398}
3399
3400#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3401#[serde(rename_all = "camelCase")]
3402pub struct ItemGuardianApprovalReviewCompletedNotification {
3403    #[serde()]
3404    pub action: GuardianApprovalReviewAction,
3405    #[serde(rename = "completedAtMs", default)]
3406    pub completed_at_ms: i64,
3407    #[serde(rename = "decisionSource")]
3408    pub decision_source: AutoReviewDecisionSource,
3409    #[serde()]
3410    pub review: GuardianApprovalReview,
3411    #[serde(rename = "reviewId", default)]
3412    pub review_id: String,
3413    #[serde(rename = "startedAtMs", default)]
3414    pub started_at_ms: i64,
3415    #[serde(
3416        rename = "targetItemId",
3417        default,
3418        skip_serializing_if = "Option::is_none"
3419    )]
3420    pub target_item_id: Option<String>,
3421    #[serde(rename = "threadId", default)]
3422    pub thread_id: String,
3423    #[serde(rename = "turnId", default)]
3424    pub turn_id: String,
3425}
3426
3427#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3428#[serde(rename_all = "camelCase")]
3429pub struct ItemGuardianApprovalReviewStartedNotification {
3430    #[serde()]
3431    pub action: GuardianApprovalReviewAction,
3432    #[serde()]
3433    pub review: GuardianApprovalReview,
3434    #[serde(rename = "reviewId", default)]
3435    pub review_id: String,
3436    #[serde(rename = "startedAtMs", default)]
3437    pub started_at_ms: i64,
3438    #[serde(
3439        rename = "targetItemId",
3440        default,
3441        skip_serializing_if = "Option::is_none"
3442    )]
3443    pub target_item_id: Option<String>,
3444    #[serde(rename = "threadId", default)]
3445    pub thread_id: String,
3446    #[serde(rename = "turnId", default)]
3447    pub turn_id: String,
3448}
3449
3450#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3451#[serde(rename_all = "camelCase")]
3452pub struct ItemStartedNotification {
3453    #[serde()]
3454    pub item: ThreadItem,
3455    #[serde(rename = "startedAtMs", default)]
3456    pub started_at_ms: i64,
3457    #[serde(rename = "threadId", default)]
3458    pub thread_id: String,
3459    #[serde(rename = "turnId", default)]
3460    pub turn_id: String,
3461}
3462
3463#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3464#[serde(rename_all = "camelCase")]
3465pub struct JSONRPCResponse {
3466    #[serde()]
3467    pub id: RequestId,
3468    #[serde(default)]
3469    pub result: Value,
3470}
3471
3472#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
3473#[serde(transparent)]
3474pub struct LegacyAppPathString(pub String);
3475
3476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3477#[serde(rename_all = "camelCase")]
3478pub struct ListMcpServerStatusParams {
3479    #[serde(default, skip_serializing_if = "Option::is_none")]
3480    pub cursor: Option<String>,
3481    #[serde(default, skip_serializing_if = "Option::is_none")]
3482    pub detail: Option<McpServerStatusDetail>,
3483    #[serde(default, skip_serializing_if = "Option::is_none")]
3484    pub limit: Option<i64>,
3485    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3486    pub thread_id: Option<String>,
3487}
3488
3489#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3490#[serde(rename_all = "camelCase")]
3491pub struct ListMcpServerStatusResponse {
3492    #[serde(default)]
3493    pub data: Vec<McpServerStatus>,
3494    #[serde(
3495        rename = "nextCursor",
3496        default,
3497        skip_serializing_if = "Option::is_none"
3498    )]
3499    pub next_cursor: Option<String>,
3500}
3501
3502#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3503#[serde(tag = "type", rename_all = "camelCase")]
3504pub enum LoginAccountParams {
3505    #[serde(rename = "apiKey")]
3506    ApiKey {
3507        #[serde(rename = "apiKey")]
3508        api_key: String,
3509    },
3510    Chatgpt {
3511        #[serde(rename = "appBrand", default, skip_serializing_if = "Option::is_none")]
3512        app_brand: Option<LoginAppBrand>,
3513        #[serde(
3514            rename = "codexStreamlinedLogin",
3515            default,
3516            skip_serializing_if = "Option::is_none"
3517        )]
3518        codex_streamlined_login: Option<bool>,
3519        #[serde(
3520            rename = "useHostedLoginSuccessPage",
3521            default,
3522            skip_serializing_if = "Option::is_none"
3523        )]
3524        use_hosted_login_success_page: Option<bool>,
3525    },
3526    #[serde(rename = "chatgptDeviceCode")]
3527    ChatgptDeviceCode,
3528    #[serde(rename = "chatgptAuthTokens")]
3529    ChatgptAuthTokens {
3530        #[serde(rename = "accessToken")]
3531        access_token: String,
3532        #[serde(rename = "chatgptAccountId")]
3533        chatgpt_account_id: String,
3534        #[serde(
3535            rename = "chatgptPlanType",
3536            default,
3537            skip_serializing_if = "Option::is_none"
3538        )]
3539        chatgpt_plan_type: Option<String>,
3540    },
3541    #[serde(rename = "amazonBedrock")]
3542    AmazonBedrock {
3543        #[serde(rename = "apiKey")]
3544        api_key: String,
3545        region: String,
3546    },
3547    #[serde(rename = "amazonBedrockAccessKeys")]
3548    AmazonBedrockAccessKeys {
3549        #[serde(rename = "accessKeyId")]
3550        access_key_id: String,
3551        region: String,
3552        #[serde(rename = "secretAccessKey")]
3553        secret_access_key: String,
3554        #[serde(
3555            rename = "sessionToken",
3556            default,
3557            skip_serializing_if = "Option::is_none"
3558        )]
3559        session_token: Option<String>,
3560    },
3561}
3562
3563#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3564#[serde(tag = "type", rename_all = "camelCase")]
3565pub enum LoginAccountResponse {
3566    #[serde(rename = "apiKey")]
3567    ApiKey,
3568    Chatgpt {
3569        #[serde(rename = "authUrl")]
3570        auth_url: String,
3571        #[serde(rename = "loginId")]
3572        login_id: String,
3573    },
3574    #[serde(rename = "chatgptDeviceCode")]
3575    ChatgptDeviceCode {
3576        #[serde(rename = "loginId")]
3577        login_id: String,
3578        #[serde(rename = "userCode")]
3579        user_code: String,
3580        #[serde(rename = "verificationUrl")]
3581        verification_url: String,
3582    },
3583    #[serde(rename = "chatgptAuthTokens")]
3584    ChatgptAuthTokens,
3585    #[serde(rename = "amazonBedrock")]
3586    AmazonBedrock,
3587}
3588
3589#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3590pub enum LoginAppBrand {
3591    #[serde(rename = "codex")]
3592    Codex,
3593    #[serde(rename = "chatgpt")]
3594    Chatgpt,
3595}
3596
3597#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3598#[serde(rename_all = "camelCase")]
3599pub struct LogoutAccountResponse {
3600    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
3601    pub extra: serde_json::Map<String, Value>,
3602}
3603
3604#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3605#[serde(rename_all = "camelCase")]
3606pub struct MarketplaceAddParams {
3607    #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
3608    pub ref_name: Option<String>,
3609    #[serde(default)]
3610    pub source: String,
3611    #[serde(
3612        rename = "sparsePaths",
3613        default,
3614        skip_serializing_if = "Option::is_none"
3615    )]
3616    pub sparse_paths: Option<Vec<String>>,
3617}
3618
3619#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3620#[serde(rename_all = "camelCase")]
3621pub struct MarketplaceAddResponse {
3622    #[serde(rename = "alreadyAdded", default)]
3623    pub already_added: bool,
3624    #[serde(rename = "installedRoot")]
3625    pub installed_root: AbsolutePathBuf,
3626    #[serde(rename = "marketplaceName", default)]
3627    pub marketplace_name: String,
3628}
3629
3630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3631#[serde(rename_all = "camelCase")]
3632pub struct MarketplaceInterface {
3633    #[serde(
3634        rename = "displayName",
3635        default,
3636        skip_serializing_if = "Option::is_none"
3637    )]
3638    pub display_name: Option<String>,
3639}
3640
3641#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3642#[serde(rename_all = "camelCase")]
3643pub struct MarketplaceLoadErrorInfo {
3644    #[serde(rename = "marketplacePath")]
3645    pub marketplace_path: AbsolutePathBuf,
3646    #[serde(default)]
3647    pub message: String,
3648}
3649
3650#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3651#[serde(rename_all = "camelCase")]
3652pub struct MarketplaceRemoveParams {
3653    #[serde(rename = "marketplaceName", default)]
3654    pub marketplace_name: String,
3655}
3656
3657#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3658#[serde(rename_all = "camelCase")]
3659pub struct MarketplaceRemoveResponse {
3660    #[serde(
3661        rename = "installedRoot",
3662        default,
3663        skip_serializing_if = "Option::is_none"
3664    )]
3665    pub installed_root: Option<AbsolutePathBuf>,
3666    #[serde(rename = "marketplaceName", default)]
3667    pub marketplace_name: String,
3668}
3669
3670#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3671#[serde(rename_all = "camelCase")]
3672pub struct MarketplaceUpgradeErrorInfo {
3673    #[serde(rename = "marketplaceName", default)]
3674    pub marketplace_name: String,
3675    #[serde(default)]
3676    pub message: String,
3677}
3678
3679#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3680#[serde(rename_all = "camelCase")]
3681pub struct MarketplaceUpgradeParams {
3682    #[serde(
3683        rename = "marketplaceName",
3684        default,
3685        skip_serializing_if = "Option::is_none"
3686    )]
3687    pub marketplace_name: Option<String>,
3688}
3689
3690#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3691#[serde(rename_all = "camelCase")]
3692pub struct MarketplaceUpgradeResponse {
3693    #[serde(default)]
3694    pub errors: Vec<MarketplaceUpgradeErrorInfo>,
3695    #[serde(rename = "selectedMarketplaces", default)]
3696    pub selected_marketplaces: Vec<String>,
3697    #[serde(rename = "upgradedRoots", default)]
3698    pub upgraded_roots: Vec<AbsolutePathBuf>,
3699}
3700
3701#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3702pub enum McpAuthStatus {
3703    #[serde(rename = "unknown")]
3704    Unknown,
3705    #[serde(rename = "unsupported")]
3706    Unsupported,
3707    #[serde(rename = "notLoggedIn")]
3708    NotLoggedIn,
3709    #[serde(rename = "bearerToken")]
3710    BearerToken,
3711    #[serde(rename = "oAuth")]
3712    OAuth,
3713}
3714
3715#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3716pub enum McpElicitationArrayType {
3717    #[serde(rename = "array")]
3718    Array,
3719}
3720
3721#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3722#[serde(rename_all = "camelCase")]
3723pub struct McpElicitationBooleanSchema {
3724    #[serde(default, skip_serializing_if = "Option::is_none")]
3725    pub default: Option<bool>,
3726    #[serde(default, skip_serializing_if = "Option::is_none")]
3727    pub description: Option<String>,
3728    #[serde(default, skip_serializing_if = "Option::is_none")]
3729    pub title: Option<String>,
3730    #[serde(rename = "type")]
3731    pub type_: McpElicitationBooleanType,
3732}
3733
3734#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3735pub enum McpElicitationBooleanType {
3736    #[serde(rename = "boolean")]
3737    Boolean,
3738}
3739
3740#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3741#[serde(rename_all = "camelCase")]
3742pub struct McpElicitationConstOption {
3743    #[serde(rename = "const", default)]
3744    pub const_: String,
3745    #[serde(default)]
3746    pub title: String,
3747}
3748
3749#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3750#[serde(untagged)]
3751pub enum McpElicitationEnumSchema {
3752    McpElicitationSingleSelectEnumSchema(McpElicitationSingleSelectEnumSchema),
3753    McpElicitationMultiSelectEnumSchema(McpElicitationMultiSelectEnumSchema),
3754    McpElicitationLegacyTitledEnumSchema(McpElicitationLegacyTitledEnumSchema),
3755}
3756
3757#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3758#[serde(rename_all = "camelCase")]
3759pub struct McpElicitationLegacyTitledEnumSchema {
3760    #[serde(default, skip_serializing_if = "Option::is_none")]
3761    pub default: Option<String>,
3762    #[serde(default, skip_serializing_if = "Option::is_none")]
3763    pub description: Option<String>,
3764    #[serde(rename = "enum", default)]
3765    pub enum_: Vec<String>,
3766    #[serde(rename = "enumNames", default, skip_serializing_if = "Option::is_none")]
3767    pub enum_names: Option<Vec<String>>,
3768    #[serde(default, skip_serializing_if = "Option::is_none")]
3769    pub title: Option<String>,
3770    #[serde(rename = "type")]
3771    pub type_: McpElicitationStringType,
3772}
3773
3774#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3775#[serde(untagged)]
3776pub enum McpElicitationMultiSelectEnumSchema {
3777    McpElicitationUntitledMultiSelectEnumSchema(McpElicitationUntitledMultiSelectEnumSchema),
3778    McpElicitationTitledMultiSelectEnumSchema(McpElicitationTitledMultiSelectEnumSchema),
3779}
3780
3781#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3782#[serde(rename_all = "camelCase")]
3783pub struct McpElicitationNumberSchema {
3784    #[serde(default, skip_serializing_if = "Option::is_none")]
3785    pub default: Option<f64>,
3786    #[serde(default, skip_serializing_if = "Option::is_none")]
3787    pub description: Option<String>,
3788    #[serde(default, skip_serializing_if = "Option::is_none")]
3789    pub maximum: Option<f64>,
3790    #[serde(default, skip_serializing_if = "Option::is_none")]
3791    pub minimum: Option<f64>,
3792    #[serde(default, skip_serializing_if = "Option::is_none")]
3793    pub title: Option<String>,
3794    #[serde(rename = "type")]
3795    pub type_: McpElicitationNumberType,
3796}
3797
3798#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3799pub enum McpElicitationNumberType {
3800    #[serde(rename = "number")]
3801    Number,
3802    #[serde(rename = "integer")]
3803    Integer,
3804}
3805
3806#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3807pub enum McpElicitationObjectType {
3808    #[serde(rename = "object")]
3809    Object,
3810}
3811
3812#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3813#[serde(untagged)]
3814pub enum McpElicitationPrimitiveSchema {
3815    McpElicitationEnumSchema(McpElicitationEnumSchema),
3816    McpElicitationStringSchema(McpElicitationStringSchema),
3817    McpElicitationNumberSchema(McpElicitationNumberSchema),
3818    McpElicitationBooleanSchema(McpElicitationBooleanSchema),
3819}
3820
3821#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3822#[serde(rename_all = "camelCase")]
3823pub struct McpElicitationSchema {
3824    #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
3825    pub schema: Option<String>,
3826    #[serde(default)]
3827    pub properties: std::collections::BTreeMap<String, McpElicitationPrimitiveSchema>,
3828    #[serde(default, skip_serializing_if = "Option::is_none")]
3829    pub required: Option<Vec<String>>,
3830    #[serde(rename = "type")]
3831    pub type_: McpElicitationObjectType,
3832}
3833
3834#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3835#[serde(untagged)]
3836pub enum McpElicitationSingleSelectEnumSchema {
3837    McpElicitationUntitledSingleSelectEnumSchema(McpElicitationUntitledSingleSelectEnumSchema),
3838    McpElicitationTitledSingleSelectEnumSchema(McpElicitationTitledSingleSelectEnumSchema),
3839}
3840
3841#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3842pub enum McpElicitationStringFormat {
3843    #[serde(rename = "email")]
3844    Email,
3845    #[serde(rename = "uri")]
3846    Uri,
3847    #[serde(rename = "date")]
3848    Date,
3849    #[serde(rename = "date-time")]
3850    Date_time,
3851}
3852
3853#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3854#[serde(rename_all = "camelCase")]
3855pub struct McpElicitationStringSchema {
3856    #[serde(default, skip_serializing_if = "Option::is_none")]
3857    pub default: Option<String>,
3858    #[serde(default, skip_serializing_if = "Option::is_none")]
3859    pub description: Option<String>,
3860    #[serde(default, skip_serializing_if = "Option::is_none")]
3861    pub format: Option<McpElicitationStringFormat>,
3862    #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
3863    pub max_length: Option<i64>,
3864    #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
3865    pub min_length: Option<i64>,
3866    #[serde(default, skip_serializing_if = "Option::is_none")]
3867    pub title: Option<String>,
3868    #[serde(rename = "type")]
3869    pub type_: McpElicitationStringType,
3870}
3871
3872#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3873pub enum McpElicitationStringType {
3874    #[serde(rename = "string")]
3875    String,
3876}
3877
3878#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3879#[serde(rename_all = "camelCase")]
3880pub struct McpElicitationTitledEnumItems {
3881    #[serde(rename = "anyOf", default)]
3882    pub any_of: Vec<McpElicitationConstOption>,
3883}
3884
3885#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3886#[serde(rename_all = "camelCase")]
3887pub struct McpElicitationTitledMultiSelectEnumSchema {
3888    #[serde(default, skip_serializing_if = "Option::is_none")]
3889    pub default: Option<Vec<String>>,
3890    #[serde(default, skip_serializing_if = "Option::is_none")]
3891    pub description: Option<String>,
3892    #[serde()]
3893    pub items: McpElicitationTitledEnumItems,
3894    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
3895    pub max_items: Option<i64>,
3896    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
3897    pub min_items: Option<i64>,
3898    #[serde(default, skip_serializing_if = "Option::is_none")]
3899    pub title: Option<String>,
3900    #[serde(rename = "type")]
3901    pub type_: McpElicitationArrayType,
3902}
3903
3904#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3905#[serde(rename_all = "camelCase")]
3906pub struct McpElicitationTitledSingleSelectEnumSchema {
3907    #[serde(default, skip_serializing_if = "Option::is_none")]
3908    pub default: Option<String>,
3909    #[serde(default, skip_serializing_if = "Option::is_none")]
3910    pub description: Option<String>,
3911    #[serde(rename = "oneOf", default)]
3912    pub one_of: Vec<McpElicitationConstOption>,
3913    #[serde(default, skip_serializing_if = "Option::is_none")]
3914    pub title: Option<String>,
3915    #[serde(rename = "type")]
3916    pub type_: McpElicitationStringType,
3917}
3918
3919#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3920#[serde(rename_all = "camelCase")]
3921pub struct McpElicitationUntitledEnumItems {
3922    #[serde(rename = "enum", default)]
3923    pub enum_: Vec<String>,
3924    #[serde(rename = "type")]
3925    pub type_: McpElicitationStringType,
3926}
3927
3928#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3929#[serde(rename_all = "camelCase")]
3930pub struct McpElicitationUntitledMultiSelectEnumSchema {
3931    #[serde(default, skip_serializing_if = "Option::is_none")]
3932    pub default: Option<Vec<String>>,
3933    #[serde(default, skip_serializing_if = "Option::is_none")]
3934    pub description: Option<String>,
3935    #[serde()]
3936    pub items: McpElicitationUntitledEnumItems,
3937    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
3938    pub max_items: Option<i64>,
3939    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
3940    pub min_items: Option<i64>,
3941    #[serde(default, skip_serializing_if = "Option::is_none")]
3942    pub title: Option<String>,
3943    #[serde(rename = "type")]
3944    pub type_: McpElicitationArrayType,
3945}
3946
3947#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3948#[serde(rename_all = "camelCase")]
3949pub struct McpElicitationUntitledSingleSelectEnumSchema {
3950    #[serde(default, skip_serializing_if = "Option::is_none")]
3951    pub default: Option<String>,
3952    #[serde(default, skip_serializing_if = "Option::is_none")]
3953    pub description: Option<String>,
3954    #[serde(rename = "enum", default)]
3955    pub enum_: Vec<String>,
3956    #[serde(default, skip_serializing_if = "Option::is_none")]
3957    pub title: Option<String>,
3958    #[serde(rename = "type")]
3959    pub type_: McpElicitationStringType,
3960}
3961
3962#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3963#[serde(rename_all = "camelCase")]
3964pub struct McpResourceReadParams {
3965    #[serde(
3966        rename = "connectorId",
3967        default,
3968        skip_serializing_if = "Option::is_none"
3969    )]
3970    pub connector_id: Option<String>,
3971    /// Originating MCP tool call used to select the resource's app.
3972    #[serde(
3973        rename = "originCallId",
3974        default,
3975        skip_serializing_if = "Option::is_none"
3976    )]
3977    pub origin_call_id: Option<String>,
3978    #[serde(default)]
3979    pub server: String,
3980    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3981    pub thread_id: Option<String>,
3982    #[serde(default)]
3983    pub uri: String,
3984}
3985
3986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3987#[serde(rename_all = "camelCase")]
3988pub struct McpResourceReadResponse {
3989    #[serde(default)]
3990    pub contents: Vec<ResourceContent>,
3991    /// Originating call when the server applied app-specific resource
3992    /// scoping.
3993    #[serde(
3994        rename = "originCallId",
3995        default,
3996        skip_serializing_if = "Option::is_none"
3997    )]
3998    pub origin_call_id: Option<String>,
3999}
4000
4001#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4002pub enum McpServerElicitationAction {
4003    #[serde(rename = "accept")]
4004    Accept,
4005    #[serde(rename = "decline")]
4006    Decline,
4007    #[serde(rename = "cancel")]
4008    Cancel,
4009}
4010
4011#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4012#[serde(tag = "mode", rename_all = "camelCase")]
4013pub enum McpServerElicitationRequestParams {
4014    Form {
4015        #[serde(default, skip_serializing_if = "Option::is_none")]
4016        _meta: Option<Value>,
4017        message: String,
4018        #[serde(rename = "requestedSchema")]
4019        requested_schema: McpElicitationSchema,
4020    },
4021    #[serde(rename = "openai/form")]
4022    OpenaiForm {
4023        #[serde(default, skip_serializing_if = "Option::is_none")]
4024        _meta: Option<Value>,
4025        message: String,
4026        #[serde(rename = "requestedSchema")]
4027        requested_schema: Value,
4028    },
4029    #[serde(rename = "openaiForm")]
4030    OpenAiElicitationForm {
4031        #[serde(default, skip_serializing_if = "Option::is_none")]
4032        _meta: Option<Value>,
4033        message: String,
4034        #[serde(rename = "requestedSchema")]
4035        requested_schema: Value,
4036    },
4037    Url {
4038        #[serde(default, skip_serializing_if = "Option::is_none")]
4039        _meta: Option<Value>,
4040        #[serde(rename = "elicitationId")]
4041        elicitation_id: String,
4042        message: String,
4043        url: String,
4044    },
4045}
4046
4047#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4048#[serde(rename_all = "camelCase")]
4049pub struct McpServerElicitationRequestResponse {
4050    #[serde(default, skip_serializing_if = "Option::is_none")]
4051    pub _meta: Option<Value>,
4052    #[serde()]
4053    pub action: McpServerElicitationAction,
4054    #[serde(default, skip_serializing_if = "Option::is_none")]
4055    pub content: Option<Value>,
4056}
4057
4058#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4059#[serde(rename_all = "camelCase")]
4060pub struct McpServerInfo {
4061    #[serde(default, skip_serializing_if = "Option::is_none")]
4062    pub description: Option<String>,
4063    #[serde(default, skip_serializing_if = "Option::is_none")]
4064    pub icons: Option<Vec<Value>>,
4065    #[serde(default)]
4066    pub name: String,
4067    #[serde(default, skip_serializing_if = "Option::is_none")]
4068    pub title: Option<String>,
4069    #[serde(default)]
4070    pub version: String,
4071    #[serde(
4072        rename = "websiteUrl",
4073        default,
4074        skip_serializing_if = "Option::is_none"
4075    )]
4076    pub website_url: Option<String>,
4077}
4078
4079#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4080#[serde(rename_all = "camelCase")]
4081pub struct McpServerMigration {
4082    #[serde(default)]
4083    pub name: String,
4084}
4085
4086#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4087#[serde(rename_all = "camelCase")]
4088pub struct McpServerOauthLoginCompletedNotification {
4089    #[serde(default, skip_serializing_if = "Option::is_none")]
4090    pub error: Option<String>,
4091    #[serde(default)]
4092    pub name: String,
4093    #[serde(default)]
4094    pub success: bool,
4095    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4096    pub thread_id: Option<String>,
4097}
4098
4099#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4100#[serde(rename_all = "camelCase")]
4101pub struct McpServerOauthLoginParams {
4102    #[serde(
4103        rename = "clientRegistration",
4104        default,
4105        skip_serializing_if = "Option::is_none"
4106    )]
4107    pub client_registration: Option<McpServerOauthClientRegistration>,
4108    #[serde(default)]
4109    pub name: String,
4110    #[serde(default, skip_serializing_if = "Option::is_none")]
4111    pub scopes: Option<Vec<String>>,
4112    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4113    pub thread_id: Option<String>,
4114    #[serde(
4115        rename = "timeoutSecs",
4116        default,
4117        skip_serializing_if = "Option::is_none"
4118    )]
4119    pub timeout_secs: Option<i64>,
4120}
4121
4122#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4123#[serde(rename_all = "camelCase")]
4124pub struct McpServerOauthLoginResponse {
4125    #[serde(rename = "authorizationUrl", default)]
4126    pub authorization_url: String,
4127}
4128
4129#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4130#[serde(rename_all = "camelCase")]
4131pub struct McpServerRefreshResponse {
4132    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4133    pub extra: serde_json::Map<String, Value>,
4134}
4135
4136#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4137pub enum McpServerStartupFailureReason {
4138    #[serde(rename = "reauthenticationRequired")]
4139    ReauthenticationRequired,
4140}
4141
4142#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4143pub enum McpServerStartupState {
4144    #[serde(rename = "starting")]
4145    Starting,
4146    #[serde(rename = "ready")]
4147    Ready,
4148    #[serde(rename = "failed")]
4149    Failed,
4150    #[serde(rename = "cancelled")]
4151    Cancelled,
4152}
4153
4154#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4155#[serde(rename_all = "camelCase")]
4156pub struct McpServerStatus {
4157    #[serde(rename = "authStatus")]
4158    pub auth_status: McpAuthStatus,
4159    /// Current thread-runtime connection state; absent when unavailable.
4160    #[serde(
4161        rename = "runtimeStatus",
4162        default,
4163        skip_serializing_if = "Option::is_none"
4164    )]
4165    pub runtime_status: Option<McpServerConnectionStatus>,
4166    #[serde(default)]
4167    pub name: String,
4168    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
4169    pub plugin_id: Option<String>,
4170    #[serde(rename = "resourceTemplates", default)]
4171    pub resource_templates: Vec<ResourceTemplate>,
4172    #[serde(default)]
4173    pub resources: Vec<Resource>,
4174    #[serde(
4175        rename = "serverInfo",
4176        default,
4177        skip_serializing_if = "Option::is_none"
4178    )]
4179    pub server_info: Option<McpServerInfo>,
4180    #[serde(default)]
4181    pub tools: std::collections::BTreeMap<String, Tool>,
4182}
4183
4184#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4185pub enum McpServerStatusDetail {
4186    #[serde(rename = "full")]
4187    Full,
4188    #[serde(rename = "toolsAndAuthOnly")]
4189    ToolsAndAuthOnly,
4190}
4191
4192#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4193#[serde(rename_all = "camelCase")]
4194pub struct McpServerStatusUpdatedNotification {
4195    #[serde(default, skip_serializing_if = "Option::is_none")]
4196    pub error: Option<String>,
4197    #[serde(
4198        rename = "failureReason",
4199        default,
4200        skip_serializing_if = "Option::is_none"
4201    )]
4202    pub failure_reason: Option<McpServerStartupFailureReason>,
4203    #[serde(default)]
4204    pub name: String,
4205    #[serde()]
4206    pub status: McpServerStartupState,
4207    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4208    pub thread_id: Option<String>,
4209}
4210
4211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4212#[serde(rename_all = "camelCase")]
4213pub struct McpServerToolCallParams {
4214    #[serde(default, skip_serializing_if = "Option::is_none")]
4215    pub _meta: Option<Value>,
4216    #[serde(default, skip_serializing_if = "Option::is_none")]
4217    pub arguments: Option<Value>,
4218    #[serde(default)]
4219    pub server: String,
4220    #[serde(rename = "threadId", default)]
4221    pub thread_id: String,
4222    #[serde(default)]
4223    pub tool: String,
4224}
4225
4226#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4227#[serde(rename_all = "camelCase")]
4228pub struct McpServerToolCallResponse {
4229    #[serde(default, skip_serializing_if = "Option::is_none")]
4230    pub _meta: Option<Value>,
4231    #[serde(default)]
4232    pub content: Vec<Value>,
4233    #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
4234    pub is_error: Option<bool>,
4235    #[serde(
4236        rename = "structuredContent",
4237        default,
4238        skip_serializing_if = "Option::is_none"
4239    )]
4240    pub structured_content: Option<Value>,
4241}
4242
4243#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4244#[serde(rename_all = "camelCase")]
4245pub struct McpToolCallAppContext {
4246    #[serde(
4247        rename = "actionName",
4248        default,
4249        skip_serializing_if = "Option::is_none"
4250    )]
4251    pub action_name: Option<String>,
4252    #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
4253    pub app_name: Option<String>,
4254    #[serde(rename = "connectorId", default)]
4255    pub connector_id: String,
4256    #[serde(rename = "linkId", default, skip_serializing_if = "Option::is_none")]
4257    pub link_id: Option<String>,
4258    #[serde(
4259        rename = "resourceUri",
4260        default,
4261        skip_serializing_if = "Option::is_none"
4262    )]
4263    pub resource_uri: Option<String>,
4264}
4265
4266#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4267#[serde(rename_all = "camelCase")]
4268pub struct McpToolCallError {
4269    #[serde(default)]
4270    pub message: String,
4271}
4272
4273#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4274#[serde(rename_all = "camelCase")]
4275pub struct McpToolCallProgressNotification {
4276    #[serde(rename = "itemId", default)]
4277    pub item_id: String,
4278    #[serde(default)]
4279    pub message: String,
4280    #[serde(rename = "threadId", default)]
4281    pub thread_id: String,
4282    #[serde(rename = "turnId", default)]
4283    pub turn_id: String,
4284}
4285
4286#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4287#[serde(rename_all = "camelCase")]
4288pub struct McpToolCallResult {
4289    #[serde(default, skip_serializing_if = "Option::is_none")]
4290    pub _meta: Option<Value>,
4291    #[serde(default)]
4292    pub content: Vec<Value>,
4293    #[serde(
4294        rename = "structuredContent",
4295        default,
4296        skip_serializing_if = "Option::is_none"
4297    )]
4298    pub structured_content: Option<Value>,
4299}
4300
4301#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4302pub enum McpToolCallStatus {
4303    #[serde(rename = "inProgress")]
4304    InProgress,
4305    #[serde(rename = "completed")]
4306    Completed,
4307    #[serde(rename = "failed")]
4308    Failed,
4309}
4310
4311#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4312#[serde(rename_all = "camelCase")]
4313pub struct MemoryCitation {
4314    #[serde(default)]
4315    pub entries: Vec<MemoryCitationEntry>,
4316    #[serde(rename = "threadIds", default)]
4317    pub thread_ids: Vec<String>,
4318}
4319
4320#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4321#[serde(rename_all = "camelCase")]
4322pub struct MemoryCitationEntry {
4323    #[serde(rename = "lineEnd", default)]
4324    pub line_end: i64,
4325    #[serde(rename = "lineStart", default)]
4326    pub line_start: i64,
4327    #[serde(default)]
4328    pub note: String,
4329    #[serde(default)]
4330    pub path: String,
4331}
4332
4333#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4334pub enum MergeStrategy {
4335    #[serde(rename = "replace")]
4336    Replace,
4337    #[serde(rename = "upsert")]
4338    Upsert,
4339}
4340
4341#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4342pub enum MessagePhase {
4343    #[serde(rename = "commentary")]
4344    Commentary,
4345    #[serde(rename = "final_answer")]
4346    FinalAnswer,
4347}
4348
4349#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4350#[serde(rename_all = "camelCase")]
4351pub struct MigrationDetails {
4352    #[serde(default, skip_serializing_if = "Option::is_none")]
4353    pub commands: Option<Vec<CommandMigration>>,
4354    #[serde(default, skip_serializing_if = "Option::is_none")]
4355    pub hooks: Option<Vec<HookMigration>>,
4356    #[serde(
4357        rename = "mcpServers",
4358        default,
4359        skip_serializing_if = "Option::is_none"
4360    )]
4361    pub mcp_servers: Option<Vec<McpServerMigration>>,
4362    #[serde(default, skip_serializing_if = "Option::is_none")]
4363    pub memory: Option<Vec<String>>,
4364    #[serde(default, skip_serializing_if = "Option::is_none")]
4365    pub plugins: Option<Vec<PluginsMigration>>,
4366    #[serde(default, skip_serializing_if = "Option::is_none")]
4367    pub sessions: Option<Vec<SessionMigration>>,
4368    #[serde(default, skip_serializing_if = "Option::is_none")]
4369    pub skills: Option<Vec<SkillMigration>>,
4370    #[serde(default, skip_serializing_if = "Option::is_none")]
4371    pub subagents: Option<Vec<SubagentMigration>>,
4372}
4373
4374/// Public explanation and continuation instruction attached to a
4375/// misalignment-blocked turn error (0.148 upstream).
4376#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4377#[serde(rename_all = "camelCase")]
4378pub struct MisalignmentErrorDetails {
4379    #[serde(
4380        rename = "detailedExplanation",
4381        default,
4382        skip_serializing_if = "Option::is_none"
4383    )]
4384    pub detailed_explanation: Option<String>,
4385    /// Open-ended classification; accept categories added upstream.
4386    #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
4387    pub error_type: Option<String>,
4388    /// Instruction to submit as the next turn's user input if continuation
4389    /// is confirmed.
4390    #[serde(default, skip_serializing_if = "Option::is_none")]
4391    pub steer: Option<MisalignmentSteer>,
4392}
4393
4394/// The steering instruction inside [`MisalignmentErrorDetails`].
4395#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4396#[serde(rename_all = "camelCase")]
4397pub struct MisalignmentSteer {
4398    #[serde(default)]
4399    pub message: String,
4400}
4401
4402#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4403pub enum ModeKind {
4404    #[serde(rename = "plan")]
4405    Plan,
4406    #[serde(rename = "default")]
4407    Default,
4408}
4409
4410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4411#[serde(rename_all = "camelCase")]
4412pub struct Model {
4413    #[serde(
4414        rename = "additionalSpeedTiers",
4415        default,
4416        skip_serializing_if = "Option::is_none"
4417    )]
4418    pub additional_speed_tiers: Option<Vec<String>>,
4419    #[serde(
4420        rename = "availabilityNux",
4421        default,
4422        skip_serializing_if = "Option::is_none"
4423    )]
4424    pub availability_nux: Option<ModelAvailabilityNux>,
4425    #[serde(rename = "defaultReasoningEffort")]
4426    pub default_reasoning_effort: ReasoningEffort,
4427    #[serde(
4428        rename = "defaultServiceTier",
4429        default,
4430        skip_serializing_if = "Option::is_none"
4431    )]
4432    pub default_service_tier: Option<String>,
4433    #[serde(default)]
4434    pub description: String,
4435    #[serde(rename = "displayName", default)]
4436    pub display_name: String,
4437    #[serde(default)]
4438    pub hidden: bool,
4439    #[serde(default)]
4440    pub id: String,
4441    #[serde(
4442        rename = "inputModalities",
4443        default,
4444        skip_serializing_if = "Option::is_none"
4445    )]
4446    pub input_modalities: Option<Vec<InputModality>>,
4447    #[serde(rename = "isDefault", default)]
4448    pub is_default: bool,
4449    #[serde(default)]
4450    pub model: String,
4451    #[serde(
4452        rename = "modelSpecialty",
4453        default,
4454        skip_serializing_if = "Option::is_none"
4455    )]
4456    pub model_specialty: Option<String>,
4457    #[serde(
4458        rename = "multiAgentVersion",
4459        default,
4460        skip_serializing_if = "Option::is_none"
4461    )]
4462    pub multi_agent_version: Option<MultiAgentVersion>,
4463    #[serde(
4464        rename = "serviceTiers",
4465        default,
4466        skip_serializing_if = "Option::is_none"
4467    )]
4468    pub service_tiers: Option<Vec<ModelServiceTier>>,
4469    #[serde(rename = "supportedReasoningEfforts", default)]
4470    pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
4471    #[serde(
4472        rename = "supportsPersonality",
4473        default,
4474        skip_serializing_if = "Option::is_none"
4475    )]
4476    pub supports_personality: Option<bool>,
4477    #[serde(default, skip_serializing_if = "Option::is_none")]
4478    pub upgrade: Option<String>,
4479    #[serde(
4480        rename = "upgradeInfo",
4481        default,
4482        skip_serializing_if = "Option::is_none"
4483    )]
4484    pub upgrade_info: Option<ModelUpgradeInfo>,
4485}
4486
4487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4488#[serde(rename_all = "camelCase")]
4489pub struct ModelAvailabilityNux {
4490    #[serde(default)]
4491    pub message: String,
4492}
4493
4494#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4495#[serde(rename_all = "camelCase")]
4496pub struct ModelListParams {
4497    #[serde(default, skip_serializing_if = "Option::is_none")]
4498    pub cursor: Option<String>,
4499    #[serde(
4500        rename = "includeHidden",
4501        default,
4502        skip_serializing_if = "Option::is_none"
4503    )]
4504    pub include_hidden: Option<bool>,
4505    #[serde(default, skip_serializing_if = "Option::is_none")]
4506    pub limit: Option<i64>,
4507}
4508
4509#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4510#[serde(rename_all = "camelCase")]
4511pub struct ModelListResponse {
4512    #[serde(default)]
4513    pub data: Vec<Model>,
4514    #[serde(
4515        rename = "nextCursor",
4516        default,
4517        skip_serializing_if = "Option::is_none"
4518    )]
4519    pub next_cursor: Option<String>,
4520}
4521
4522#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4523#[serde(rename_all = "camelCase")]
4524pub struct ModelProviderCapabilitiesReadParams {
4525    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4526    pub extra: serde_json::Map<String, Value>,
4527}
4528
4529#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4530#[serde(rename_all = "camelCase")]
4531pub struct ModelProviderCapabilitiesReadResponse {
4532    #[serde(rename = "imageGeneration", default)]
4533    pub image_generation: bool,
4534    #[serde(rename = "namespaceTools", default)]
4535    pub namespace_tools: bool,
4536    #[serde(rename = "webSearch", default)]
4537    pub web_search: bool,
4538}
4539
4540#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4541pub enum ModelRerouteReason {
4542    #[serde(rename = "highRiskCyberActivity")]
4543    HighRiskCyberActivity,
4544}
4545
4546#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4547#[serde(rename_all = "camelCase")]
4548pub struct ModelReroutedNotification {
4549    #[serde(rename = "fromModel", default)]
4550    pub from_model: String,
4551    #[serde()]
4552    pub reason: ModelRerouteReason,
4553    #[serde(rename = "threadId", default)]
4554    pub thread_id: String,
4555    #[serde(rename = "toModel", default)]
4556    pub to_model: String,
4557    #[serde(rename = "turnId", default)]
4558    pub turn_id: String,
4559}
4560
4561#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4562#[serde(rename_all = "camelCase")]
4563pub struct ModelSafetyBufferingUpdatedNotification {
4564    #[serde(
4565        rename = "fasterModel",
4566        default,
4567        skip_serializing_if = "Option::is_none"
4568    )]
4569    pub faster_model: Option<String>,
4570    #[serde(default)]
4571    pub model: String,
4572    #[serde(default)]
4573    pub reasons: Vec<String>,
4574    #[serde(rename = "showBufferingUi", default)]
4575    pub show_buffering_ui: bool,
4576    #[serde(rename = "threadId", default)]
4577    pub thread_id: String,
4578    #[serde(rename = "turnId", default)]
4579    pub turn_id: String,
4580    #[serde(rename = "useCases", default)]
4581    pub use_cases: Vec<String>,
4582}
4583
4584#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4585#[serde(rename_all = "camelCase")]
4586pub struct ModelServiceTier {
4587    #[serde(default)]
4588    pub description: String,
4589    #[serde(default)]
4590    pub id: String,
4591    #[serde(default)]
4592    pub name: String,
4593}
4594
4595#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4596#[serde(rename_all = "camelCase")]
4597pub struct ModelUpgradeInfo {
4598    #[serde(
4599        rename = "migrationMarkdown",
4600        default,
4601        skip_serializing_if = "Option::is_none"
4602    )]
4603    pub migration_markdown: Option<String>,
4604    #[serde(default)]
4605    pub model: String,
4606    /// Informational Unix timestamp for this upgrade's scheduled
4607    /// retirement, if known.
4608    #[serde(
4609        rename = "retirementAt",
4610        default,
4611        skip_serializing_if = "Option::is_none"
4612    )]
4613    pub retirement_at: Option<i64>,
4614    #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
4615    pub model_link: Option<String>,
4616    #[serde(
4617        rename = "upgradeCopy",
4618        default,
4619        skip_serializing_if = "Option::is_none"
4620    )]
4621    pub upgrade_copy: Option<String>,
4622}
4623
4624#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4625pub enum ModelVerification {
4626    #[serde(rename = "trustedAccessForCyber")]
4627    TrustedAccessForCyber,
4628}
4629
4630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4631#[serde(rename_all = "camelCase")]
4632pub struct ModelVerificationNotification {
4633    #[serde(rename = "threadId", default)]
4634    pub thread_id: String,
4635    #[serde(rename = "turnId", default)]
4636    pub turn_id: String,
4637    #[serde(default)]
4638    pub verifications: Vec<ModelVerification>,
4639}
4640
4641#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4642#[serde(rename_all = "camelCase")]
4643pub struct ModelsRequirements {
4644    #[serde(rename = "newThread", default, skip_serializing_if = "Option::is_none")]
4645    pub new_thread: Option<NewThreadModelDefaults>,
4646}
4647
4648#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4649pub enum MultiAgentVersion {
4650    #[serde(rename = "disabled")]
4651    Disabled,
4652    #[serde(rename = "v1")]
4653    V1,
4654    #[serde(rename = "v2")]
4655    V2,
4656}
4657
4658#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4659pub enum NetworkAccess {
4660    #[serde(rename = "restricted")]
4661    Restricted,
4662    #[serde(rename = "enabled")]
4663    Enabled,
4664}
4665
4666#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4667#[serde(rename_all = "camelCase")]
4668pub struct NetworkApprovalContext {
4669    #[serde(default)]
4670    pub host: String,
4671    #[serde()]
4672    pub protocol: NetworkApprovalProtocol,
4673}
4674
4675#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4676pub enum NetworkApprovalProtocol {
4677    #[serde(rename = "http")]
4678    Http,
4679    #[serde(rename = "https")]
4680    Https,
4681    #[serde(rename = "socks5Tcp")]
4682    Socks5Tcp,
4683    #[serde(rename = "socks5Udp")]
4684    Socks5Udp,
4685}
4686
4687#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4688#[serde(rename_all = "camelCase")]
4689pub struct NetworkPolicyAmendment {
4690    #[serde()]
4691    pub action: NetworkPolicyRuleAction,
4692    #[serde(default)]
4693    pub host: String,
4694}
4695
4696#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4697pub enum NetworkPolicyRuleAction {
4698    #[serde(rename = "allow")]
4699    Allow,
4700    #[serde(rename = "deny")]
4701    Deny,
4702}
4703
4704#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4705#[serde(rename_all = "camelCase")]
4706pub struct NewThreadModelDefaults {
4707    #[serde(default, skip_serializing_if = "Option::is_none")]
4708    pub model: Option<String>,
4709    #[serde(
4710        rename = "modelReasoningEffort",
4711        default,
4712        skip_serializing_if = "Option::is_none"
4713    )]
4714    pub model_reasoning_effort: Option<ReasoningEffort>,
4715    #[serde(
4716        rename = "serviceTier",
4717        default,
4718        skip_serializing_if = "Option::is_none"
4719    )]
4720    pub service_tier: Option<String>,
4721}
4722
4723#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4724pub enum NonSteerableTurnKind {
4725    #[serde(rename = "review")]
4726    Review,
4727    #[serde(rename = "compact")]
4728    Compact,
4729}
4730
4731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4732#[serde(rename_all = "camelCase")]
4733pub struct OverriddenMetadata {
4734    #[serde(rename = "effectiveValue", default)]
4735    pub effective_value: Value,
4736    #[serde(default)]
4737    pub message: String,
4738    #[serde(rename = "overridingLayer")]
4739    pub overriding_layer: ConfigLayerMetadata,
4740}
4741
4742#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4743#[serde(tag = "type", rename_all = "camelCase")]
4744pub enum ParsedCommand {
4745    Read {
4746        cmd: String,
4747        name: String,
4748        path: String,
4749    },
4750    List_files {
4751        cmd: String,
4752        #[serde(default, skip_serializing_if = "Option::is_none")]
4753        path: Option<String>,
4754    },
4755    Search {
4756        cmd: String,
4757        #[serde(default, skip_serializing_if = "Option::is_none")]
4758        path: Option<String>,
4759        #[serde(default, skip_serializing_if = "Option::is_none")]
4760        query: Option<String>,
4761    },
4762    Unknown {
4763        cmd: String,
4764    },
4765}
4766
4767#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4768pub enum PatchApplyStatus {
4769    #[serde(rename = "inProgress")]
4770    InProgress,
4771    #[serde(rename = "completed")]
4772    Completed,
4773    #[serde(rename = "failed")]
4774    Failed,
4775    #[serde(rename = "declined")]
4776    Declined,
4777}
4778
4779#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4780#[serde(tag = "type", rename_all = "camelCase")]
4781pub enum PatchChangeKind {
4782    Add,
4783    Delete,
4784    Update {
4785        #[serde(default, skip_serializing_if = "Option::is_none")]
4786        move_path: Option<String>,
4787    },
4788}
4789
4790#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4791pub enum PermissionGrantScope {
4792    #[serde(rename = "turn")]
4793    Turn,
4794    #[serde(rename = "session")]
4795    Session,
4796}
4797
4798#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4799#[serde(rename_all = "camelCase")]
4800pub struct PermissionProfileListParams {
4801    #[serde(default, skip_serializing_if = "Option::is_none")]
4802    pub cursor: Option<String>,
4803    #[serde(default, skip_serializing_if = "Option::is_none")]
4804    pub cwd: Option<String>,
4805    #[serde(default, skip_serializing_if = "Option::is_none")]
4806    pub limit: Option<i64>,
4807}
4808
4809#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4810#[serde(rename_all = "camelCase")]
4811pub struct PermissionProfileListResponse {
4812    #[serde(default)]
4813    pub data: Vec<PermissionProfileSummary>,
4814    #[serde(
4815        rename = "nextCursor",
4816        default,
4817        skip_serializing_if = "Option::is_none"
4818    )]
4819    pub next_cursor: Option<String>,
4820}
4821
4822#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4823#[serde(rename_all = "camelCase")]
4824pub struct PermissionProfileSummary {
4825    #[serde(default)]
4826    pub allowed: bool,
4827    #[serde(default, skip_serializing_if = "Option::is_none")]
4828    pub description: Option<String>,
4829    #[serde(default)]
4830    pub id: String,
4831}
4832
4833#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4834#[serde(rename_all = "camelCase")]
4835pub struct PermissionsRequestApprovalParams {
4836    #[serde()]
4837    pub cwd: AbsolutePathBuf,
4838    #[serde(
4839        rename = "environmentId",
4840        default,
4841        skip_serializing_if = "Option::is_none"
4842    )]
4843    pub environment_id: Option<String>,
4844    #[serde(rename = "itemId", default)]
4845    pub item_id: String,
4846    #[serde()]
4847    pub permissions: RequestPermissionProfile,
4848    #[serde(default, skip_serializing_if = "Option::is_none")]
4849    pub reason: Option<String>,
4850    #[serde(rename = "startedAtMs", default)]
4851    pub started_at_ms: i64,
4852    #[serde(rename = "threadId", default)]
4853    pub thread_id: String,
4854    #[serde(rename = "turnId", default)]
4855    pub turn_id: String,
4856}
4857
4858#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4859#[serde(rename_all = "camelCase")]
4860pub struct PermissionsRequestApprovalResponse {
4861    #[serde()]
4862    pub permissions: GrantedPermissionProfile,
4863    #[serde(default, skip_serializing_if = "Option::is_none")]
4864    pub scope: Option<Value>,
4865    #[serde(
4866        rename = "strictAutoReview",
4867        default,
4868        skip_serializing_if = "Option::is_none"
4869    )]
4870    pub strict_auto_review: Option<bool>,
4871}
4872
4873#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4874pub enum Personality {
4875    #[serde(rename = "none")]
4876    None,
4877    #[serde(rename = "friendly")]
4878    Friendly,
4879    #[serde(rename = "pragmatic")]
4880    Pragmatic,
4881}
4882
4883#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4884#[serde(rename_all = "camelCase")]
4885pub struct PlanDeltaNotification {
4886    #[serde(default)]
4887    pub delta: String,
4888    #[serde(rename = "itemId", default)]
4889    pub item_id: String,
4890    #[serde(rename = "threadId", default)]
4891    pub thread_id: String,
4892    #[serde(rename = "turnId", default)]
4893    pub turn_id: String,
4894}
4895
4896#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4897pub enum PlanType {
4898    #[serde(rename = "free")]
4899    Free,
4900    #[serde(rename = "go")]
4901    Go,
4902    #[serde(rename = "plus")]
4903    Plus,
4904    #[serde(rename = "pro")]
4905    Pro,
4906    #[serde(rename = "prolite")]
4907    Prolite,
4908    #[serde(rename = "edu_plus")]
4909    Edu_plus,
4910    #[serde(rename = "edu_pro")]
4911    Edu_pro,
4912    #[serde(rename = "team")]
4913    Team,
4914    #[serde(rename = "self_serve_business_prolite")]
4915    Self_serve_business_prolite,
4916    #[serde(rename = "self_serve_business_usage_based")]
4917    Self_serve_business_usage_based,
4918    #[serde(rename = "business")]
4919    Business,
4920    #[serde(rename = "ent26")]
4921    Ent26,
4922    #[serde(rename = "enterprise_cbp_automation")]
4923    Enterprise_cbp_automation,
4924    #[serde(rename = "enterprise_cbp_usage_based")]
4925    Enterprise_cbp_usage_based,
4926    #[serde(rename = "enterprise")]
4927    Enterprise,
4928    #[serde(rename = "edu")]
4929    Edu,
4930    #[serde(rename = "unknown")]
4931    Unknown,
4932}
4933
4934#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4935pub enum PluginAuthPolicy {
4936    #[serde(rename = "ON_INSTALL")]
4937    ON_INSTALL,
4938    #[serde(rename = "ON_USE")]
4939    ON_USE,
4940}
4941
4942#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4943pub enum PluginAvailability {
4944    #[serde(rename = "DISABLED_BY_ADMIN")]
4945    DISABLEDBYADMIN,
4946    AVAILABLE,
4947}
4948
4949#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4950#[serde(rename_all = "camelCase")]
4951pub struct PluginDetail {
4952    #[serde(rename = "appTemplates", default)]
4953    pub app_templates: Vec<AppTemplateSummary>,
4954    #[serde(default)]
4955    pub apps: Vec<AppSummary>,
4956    #[serde(default, skip_serializing_if = "Option::is_none")]
4957    pub description: Option<String>,
4958    #[serde(default)]
4959    pub hooks: Vec<PluginHookSummary>,
4960    #[serde(rename = "marketplaceName", default)]
4961    pub marketplace_name: String,
4962    #[serde(
4963        rename = "marketplacePath",
4964        default,
4965        skip_serializing_if = "Option::is_none"
4966    )]
4967    pub marketplace_path: Option<AbsolutePathBuf>,
4968    #[serde(rename = "mcpServers", default)]
4969    pub mcp_servers: Vec<String>,
4970    #[serde(
4971        rename = "scheduledTasks",
4972        default,
4973        skip_serializing_if = "Option::is_none"
4974    )]
4975    pub scheduled_tasks: Option<Vec<ScheduledTaskSummary>>,
4976    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
4977    pub share_url: Option<String>,
4978    #[serde(default)]
4979    pub skills: Vec<SkillSummary>,
4980    #[serde()]
4981    pub summary: PluginSummary,
4982}
4983
4984#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4985pub enum PluginDisabledReason {
4986    #[serde(rename = "disabled_by_admin")]
4987    Disabled_by_admin,
4988    #[serde(rename = "plan_not_eligible")]
4989    Plan_not_eligible,
4990    #[serde(rename = "required_app_unavailable")]
4991    Required_app_unavailable,
4992    #[serde(rename = "unknown")]
4993    Unknown,
4994}
4995
4996#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4997#[serde(rename_all = "camelCase")]
4998pub struct PluginHookSummary {
4999    #[serde(rename = "eventName")]
5000    pub event_name: HookEventName,
5001    #[serde(default)]
5002    pub key: String,
5003}
5004
5005#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5006#[serde(rename_all = "camelCase")]
5007pub struct PluginInstallParams {
5008    #[serde(
5009        rename = "installAttemptId",
5010        default,
5011        skip_serializing_if = "Option::is_none"
5012    )]
5013    pub install_attempt_id: Option<String>,
5014    #[serde(
5015        rename = "marketplacePath",
5016        default,
5017        skip_serializing_if = "Option::is_none"
5018    )]
5019    pub marketplace_path: Option<AbsolutePathBuf>,
5020    #[serde(rename = "pluginName", default)]
5021    pub plugin_name: String,
5022    #[serde(
5023        rename = "remoteMarketplaceName",
5024        default,
5025        skip_serializing_if = "Option::is_none"
5026    )]
5027    pub remote_marketplace_name: Option<String>,
5028}
5029
5030#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5031pub enum PluginInstallPolicy {
5032    #[serde(rename = "NOT_AVAILABLE")]
5033    NOT_AVAILABLE,
5034    #[serde(rename = "AVAILABLE")]
5035    AVAILABLE,
5036    #[serde(rename = "INSTALLED_BY_DEFAULT")]
5037    INSTALLED_BY_DEFAULT,
5038}
5039
5040#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5041pub enum PluginInstallPolicySource {
5042    #[serde(rename = "WORKSPACE_SETTING")]
5043    WORKSPACE_SETTING,
5044    #[serde(rename = "IMPLICIT_CANONICAL_APP")]
5045    IMPLICIT_CANONICAL_APP,
5046}
5047
5048#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5049#[serde(rename_all = "camelCase")]
5050pub struct PluginInstallResponse {
5051    #[serde(rename = "appsNeedingAuth", default)]
5052    pub apps_needing_auth: Vec<AppSummary>,
5053    #[serde(rename = "authPolicy")]
5054    pub auth_policy: PluginAuthPolicy,
5055}
5056
5057#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5058#[serde(rename_all = "camelCase")]
5059pub struct PluginInstalledParams {
5060    #[serde(default, skip_serializing_if = "Option::is_none")]
5061    pub cwds: Option<Vec<AbsolutePathBuf>>,
5062    #[serde(
5063        rename = "installSuggestionPluginNames",
5064        default,
5065        skip_serializing_if = "Option::is_none"
5066    )]
5067    pub install_suggestion_plugin_names: Option<Vec<String>>,
5068}
5069
5070#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5071#[serde(rename_all = "camelCase")]
5072pub struct PluginInstalledResponse {
5073    #[serde(
5074        rename = "marketplaceLoadErrors",
5075        default,
5076        skip_serializing_if = "Option::is_none"
5077    )]
5078    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5079    #[serde(default)]
5080    pub marketplaces: Vec<PluginMarketplaceEntry>,
5081}
5082
5083#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5084#[serde(rename_all = "camelCase")]
5085pub struct PluginInterface {
5086    #[serde(
5087        rename = "brandColor",
5088        default,
5089        skip_serializing_if = "Option::is_none"
5090    )]
5091    pub brand_color: Option<String>,
5092    #[serde(default)]
5093    pub capabilities: Vec<String>,
5094    #[serde(default, skip_serializing_if = "Option::is_none")]
5095    pub category: Option<String>,
5096    #[serde(
5097        rename = "composerIcon",
5098        default,
5099        skip_serializing_if = "Option::is_none"
5100    )]
5101    pub composer_icon: Option<AbsolutePathBuf>,
5102    #[serde(
5103        rename = "composerIconUrl",
5104        default,
5105        skip_serializing_if = "Option::is_none"
5106    )]
5107    pub composer_icon_url: Option<String>,
5108    #[serde(
5109        rename = "defaultPrompt",
5110        default,
5111        skip_serializing_if = "Option::is_none"
5112    )]
5113    pub default_prompt: Option<Vec<String>>,
5114    #[serde(
5115        rename = "developerName",
5116        default,
5117        skip_serializing_if = "Option::is_none"
5118    )]
5119    pub developer_name: Option<String>,
5120    #[serde(
5121        rename = "displayName",
5122        default,
5123        skip_serializing_if = "Option::is_none"
5124    )]
5125    pub display_name: Option<String>,
5126    #[serde(default, skip_serializing_if = "Option::is_none")]
5127    pub logo: Option<AbsolutePathBuf>,
5128    #[serde(rename = "logoDark", default, skip_serializing_if = "Option::is_none")]
5129    pub logo_dark: Option<AbsolutePathBuf>,
5130    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
5131    pub logo_url: Option<String>,
5132    #[serde(
5133        rename = "logoUrlDark",
5134        default,
5135        skip_serializing_if = "Option::is_none"
5136    )]
5137    pub logo_url_dark: Option<String>,
5138    #[serde(
5139        rename = "longDescription",
5140        default,
5141        skip_serializing_if = "Option::is_none"
5142    )]
5143    pub long_description: Option<String>,
5144    #[serde(
5145        rename = "privacyPolicyUrl",
5146        default,
5147        skip_serializing_if = "Option::is_none"
5148    )]
5149    pub privacy_policy_url: Option<String>,
5150    #[serde(rename = "screenshotUrls", default)]
5151    pub screenshot_urls: Vec<String>,
5152    #[serde(default)]
5153    pub screenshots: Vec<AbsolutePathBuf>,
5154    #[serde(
5155        rename = "shortDescription",
5156        default,
5157        skip_serializing_if = "Option::is_none"
5158    )]
5159    pub short_description: Option<String>,
5160    #[serde(
5161        rename = "termsOfServiceUrl",
5162        default,
5163        skip_serializing_if = "Option::is_none"
5164    )]
5165    pub terms_of_service_url: Option<String>,
5166    #[serde(
5167        rename = "websiteUrl",
5168        default,
5169        skip_serializing_if = "Option::is_none"
5170    )]
5171    pub website_url: Option<String>,
5172}
5173
5174#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5175pub enum PluginListMarketplaceKind {
5176    #[serde(rename = "local")]
5177    Local,
5178    #[serde(rename = "vertical")]
5179    Vertical,
5180    #[serde(rename = "workspace-directory")]
5181    Workspace_directory,
5182    #[serde(rename = "shared-with-me")]
5183    Shared_with_me,
5184    #[serde(rename = "created-by-me-remote")]
5185    Created_by_me_remote,
5186}
5187
5188#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5189#[serde(rename_all = "camelCase")]
5190pub struct PluginListParams {
5191    #[serde(default, skip_serializing_if = "Option::is_none")]
5192    pub cwds: Option<Vec<AbsolutePathBuf>>,
5193    #[serde(
5194        rename = "forceRefetch",
5195        default,
5196        skip_serializing_if = "Option::is_none"
5197    )]
5198    pub force_refetch: Option<bool>,
5199    #[serde(
5200        rename = "marketplaceKinds",
5201        default,
5202        skip_serializing_if = "Option::is_none"
5203    )]
5204    pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
5205}
5206
5207#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5208#[serde(rename_all = "camelCase")]
5209pub struct PluginListResponse {
5210    #[serde(
5211        rename = "featuredPluginIds",
5212        default,
5213        skip_serializing_if = "Option::is_none"
5214    )]
5215    pub featured_plugin_ids: Option<Vec<String>>,
5216    #[serde(
5217        rename = "marketplaceLoadErrors",
5218        default,
5219        skip_serializing_if = "Option::is_none"
5220    )]
5221    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5222    #[serde(default)]
5223    pub marketplaces: Vec<PluginMarketplaceEntry>,
5224}
5225
5226#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5227#[serde(rename_all = "camelCase")]
5228pub struct PluginMarketplaceEntry {
5229    #[serde(default, skip_serializing_if = "Option::is_none")]
5230    pub interface: Option<MarketplaceInterface>,
5231    #[serde(default)]
5232    pub name: String,
5233    #[serde(default, skip_serializing_if = "Option::is_none")]
5234    pub path: Option<AbsolutePathBuf>,
5235    #[serde(default)]
5236    pub plugins: Vec<PluginSummary>,
5237}
5238
5239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5240#[serde(rename_all = "camelCase")]
5241pub struct PluginReadParams {
5242    #[serde(
5243        rename = "marketplacePath",
5244        default,
5245        skip_serializing_if = "Option::is_none"
5246    )]
5247    pub marketplace_path: Option<AbsolutePathBuf>,
5248    #[serde(rename = "pluginName", default)]
5249    pub plugin_name: String,
5250    #[serde(
5251        rename = "remoteMarketplaceName",
5252        default,
5253        skip_serializing_if = "Option::is_none"
5254    )]
5255    pub remote_marketplace_name: Option<String>,
5256}
5257
5258#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5259#[serde(rename_all = "camelCase")]
5260pub struct PluginReadResponse {
5261    #[serde()]
5262    pub plugin: PluginDetail,
5263}
5264
5265/// Runtime categories affected by this change, not just capabilities
5266/// currently present. Flags describe declarations before runtime policy
5267/// filtering. Updates OR the old and new bundle flags; enablement changes and
5268/// cached reinstalls use the cached bundle; removals retain the old bundle's
5269/// flags.
5270#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5271#[serde(rename_all = "camelCase")]
5272pub struct PluginReconcileChangedPlugin {
5273    #[serde(rename = "hasApps", default)]
5274    pub has_apps: bool,
5275    #[serde(rename = "hasHooks", default)]
5276    pub has_hooks: bool,
5277    #[serde(rename = "hasMcps", default)]
5278    pub has_mcps: bool,
5279    /// Whether either bundle declares skill roots; not a validated inventory
5280    /// of enabled skills.
5281    #[serde(rename = "hasSkills", default)]
5282    pub has_skills: bool,
5283    /// Local plugin ID (`name@marketplace`), matching `PluginSummary.id`.
5284    #[serde(default)]
5285    pub id: String,
5286}
5287
5288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5289#[serde(rename_all = "camelCase")]
5290pub struct PluginReconcileParams {
5291    /// Optional client-provided reason recorded with the reconciliation
5292    /// attempt.
5293    #[serde(default, skip_serializing_if = "Option::is_none")]
5294    pub reason: Option<String>,
5295}
5296
5297/// Bundle and installed-state changes observed by this pass, not a
5298/// runtime-readiness acknowledgement or a cumulative diff since the client's
5299/// last request. Other metadata-only changes are not listed.
5300#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5301#[serde(rename_all = "camelCase")]
5302pub struct PluginReconcileResponse {
5303    /// Plugins affected by bundle changes, enablement changes, or removals.
5304    /// Installed-state changes compare against the previous cached snapshot,
5305    /// including cached reinstalls. Removal hints survive cache cleanup
5306    /// failures; unchanged plugins are omitted.
5307    #[serde(rename = "changedPlugins", default)]
5308    pub changed_plugins: Vec<PluginReconcileChangedPlugin>,
5309    /// Subset of failures for which the requested bundle could not be
5310    /// materialized. A previously cached version may still be available.
5311    #[serde(rename = "failedMaterializationRemotePluginIds", default)]
5312    pub failed_materialization_remote_plugin_ids: Vec<String>,
5313    /// Backend remote plugin IDs whose bundle or identity update failed.
5314    #[serde(rename = "failedRemotePluginIds", default)]
5315    pub failed_remote_plugin_ids: Vec<String>,
5316}
5317
5318#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5319#[serde(rename_all = "camelCase")]
5320pub struct PluginShareCheckoutParams {
5321    #[serde(rename = "remotePluginId", default)]
5322    pub remote_plugin_id: String,
5323}
5324
5325#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5326#[serde(rename_all = "camelCase")]
5327pub struct PluginShareCheckoutResponse {
5328    #[serde(rename = "marketplaceName", default)]
5329    pub marketplace_name: String,
5330    #[serde(rename = "marketplacePath")]
5331    pub marketplace_path: AbsolutePathBuf,
5332    #[serde(rename = "pluginId", default)]
5333    pub plugin_id: String,
5334    #[serde(rename = "pluginName", default)]
5335    pub plugin_name: String,
5336    #[serde(rename = "pluginPath")]
5337    pub plugin_path: AbsolutePathBuf,
5338    #[serde(rename = "remotePluginId", default)]
5339    pub remote_plugin_id: String,
5340    #[serde(
5341        rename = "remoteVersion",
5342        default,
5343        skip_serializing_if = "Option::is_none"
5344    )]
5345    pub remote_version: Option<String>,
5346}
5347
5348#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5349#[serde(rename_all = "camelCase")]
5350pub struct PluginShareContext {
5351    #[serde(
5352        rename = "canPublishToWorkspace",
5353        default,
5354        skip_serializing_if = "Option::is_none"
5355    )]
5356    pub can_publish_to_workspace: Option<bool>,
5357    #[serde(
5358        rename = "creatorAccountUserId",
5359        default,
5360        skip_serializing_if = "Option::is_none"
5361    )]
5362    pub creator_account_user_id: Option<String>,
5363    #[serde(
5364        rename = "creatorName",
5365        default,
5366        skip_serializing_if = "Option::is_none"
5367    )]
5368    pub creator_name: Option<String>,
5369    #[serde(default, skip_serializing_if = "Option::is_none")]
5370    pub discoverability: Option<PluginShareDiscoverability>,
5371    #[serde(rename = "remotePluginId", default)]
5372    pub remote_plugin_id: String,
5373    #[serde(
5374        rename = "remoteVersion",
5375        default,
5376        skip_serializing_if = "Option::is_none"
5377    )]
5378    pub remote_version: Option<String>,
5379    #[serde(
5380        rename = "sharePrincipals",
5381        default,
5382        skip_serializing_if = "Option::is_none"
5383    )]
5384    pub share_principals: Option<Vec<PluginSharePrincipal>>,
5385    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5386    pub share_url: Option<String>,
5387}
5388
5389#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5390#[serde(rename_all = "camelCase")]
5391pub struct PluginShareDeleteParams {
5392    #[serde(rename = "remotePluginId", default)]
5393    pub remote_plugin_id: String,
5394}
5395
5396#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5397#[serde(rename_all = "camelCase")]
5398pub struct PluginShareDeleteResponse {
5399    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5400    pub extra: serde_json::Map<String, Value>,
5401}
5402
5403#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5404pub enum PluginShareDiscoverability {
5405    #[serde(rename = "LISTED")]
5406    LISTED,
5407    #[serde(rename = "UNLISTED")]
5408    UNLISTED,
5409    #[serde(rename = "PRIVATE")]
5410    PRIVATE,
5411}
5412
5413#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5414#[serde(rename_all = "camelCase")]
5415pub struct PluginShareListItem {
5416    #[serde(
5417        rename = "localPluginPath",
5418        default,
5419        skip_serializing_if = "Option::is_none"
5420    )]
5421    pub local_plugin_path: Option<AbsolutePathBuf>,
5422    #[serde()]
5423    pub plugin: PluginSummary,
5424}
5425
5426#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5427#[serde(rename_all = "camelCase")]
5428pub struct PluginShareListParams {
5429    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5430    pub extra: serde_json::Map<String, Value>,
5431}
5432
5433#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5434#[serde(rename_all = "camelCase")]
5435pub struct PluginShareListResponse {
5436    #[serde(default)]
5437    pub data: Vec<PluginShareListItem>,
5438}
5439
5440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5441#[serde(rename_all = "camelCase")]
5442pub struct PluginSharePrincipal {
5443    #[serde(default)]
5444    pub name: String,
5445    #[serde(rename = "principalId", default)]
5446    pub principal_id: String,
5447    #[serde(rename = "principalType")]
5448    pub principal_type: PluginSharePrincipalType,
5449    #[serde()]
5450    pub role: PluginSharePrincipalRole,
5451}
5452
5453#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5454pub enum PluginSharePrincipalRole {
5455    #[serde(rename = "reader")]
5456    Reader,
5457    #[serde(rename = "editor")]
5458    Editor,
5459    #[serde(rename = "owner")]
5460    Owner,
5461}
5462
5463#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5464pub enum PluginSharePrincipalType {
5465    #[serde(rename = "user")]
5466    User,
5467    #[serde(rename = "group")]
5468    Group,
5469    #[serde(rename = "workspace")]
5470    Workspace,
5471}
5472
5473#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5474#[serde(rename_all = "camelCase")]
5475pub struct PluginShareSaveParams {
5476    #[serde(default, skip_serializing_if = "Option::is_none")]
5477    pub discoverability: Option<PluginShareDiscoverability>,
5478    #[serde(rename = "pluginPath")]
5479    pub plugin_path: AbsolutePathBuf,
5480    #[serde(
5481        rename = "remotePluginId",
5482        default,
5483        skip_serializing_if = "Option::is_none"
5484    )]
5485    pub remote_plugin_id: Option<String>,
5486    #[serde(
5487        rename = "shareTargets",
5488        default,
5489        skip_serializing_if = "Option::is_none"
5490    )]
5491    pub share_targets: Option<Vec<PluginShareTarget>>,
5492}
5493
5494#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5495#[serde(rename_all = "camelCase")]
5496pub struct PluginShareSaveResponse {
5497    #[serde(
5498        rename = "canPublishToWorkspace",
5499        default,
5500        skip_serializing_if = "Option::is_none"
5501    )]
5502    pub can_publish_to_workspace: Option<bool>,
5503    #[serde(rename = "remotePluginId", default)]
5504    pub remote_plugin_id: String,
5505    #[serde(rename = "shareUrl", default)]
5506    pub share_url: String,
5507}
5508
5509#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5510#[serde(rename_all = "camelCase")]
5511pub struct PluginShareTarget {
5512    #[serde(rename = "principalId", default)]
5513    pub principal_id: String,
5514    #[serde(rename = "principalType")]
5515    pub principal_type: PluginSharePrincipalType,
5516    #[serde()]
5517    pub role: PluginShareTargetRole,
5518}
5519
5520#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5521pub enum PluginShareTargetRole {
5522    #[serde(rename = "reader")]
5523    Reader,
5524    #[serde(rename = "editor")]
5525    Editor,
5526}
5527
5528#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5529pub enum PluginShareUpdateDiscoverability {
5530    #[serde(rename = "UNLISTED")]
5531    UNLISTED,
5532    #[serde(rename = "PRIVATE")]
5533    PRIVATE,
5534    #[serde(rename = "LISTED")]
5535    LISTED,
5536}
5537
5538#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5539#[serde(rename_all = "camelCase")]
5540pub struct PluginShareUpdateTargetsParams {
5541    #[serde()]
5542    pub discoverability: PluginShareUpdateDiscoverability,
5543    #[serde(rename = "remotePluginId", default)]
5544    pub remote_plugin_id: String,
5545    #[serde(rename = "shareTargets", default)]
5546    pub share_targets: Vec<PluginShareTarget>,
5547}
5548
5549#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5550#[serde(rename_all = "camelCase")]
5551pub struct PluginShareUpdateTargetsResponse {
5552    #[serde()]
5553    pub discoverability: PluginShareDiscoverability,
5554    #[serde(default)]
5555    pub principals: Vec<PluginSharePrincipal>,
5556}
5557
5558#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5559#[serde(rename_all = "camelCase")]
5560pub struct PluginSkillReadParams {
5561    #[serde(rename = "remoteMarketplaceName", default)]
5562    pub remote_marketplace_name: String,
5563    #[serde(rename = "remotePluginId", default)]
5564    pub remote_plugin_id: String,
5565    #[serde(rename = "skillName", default)]
5566    pub skill_name: String,
5567}
5568
5569#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5570#[serde(rename_all = "camelCase")]
5571pub struct PluginSkillReadResponse {
5572    #[serde(default, skip_serializing_if = "Option::is_none")]
5573    pub contents: Option<String>,
5574}
5575
5576#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5577#[serde(tag = "type", rename_all = "camelCase")]
5578pub enum PluginSource {
5579    Local {
5580        path: AbsolutePathBuf,
5581    },
5582    Git {
5583        #[serde(default, skip_serializing_if = "Option::is_none")]
5584        path: Option<String>,
5585        #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
5586        ref_name: Option<String>,
5587        #[serde(default, skip_serializing_if = "Option::is_none")]
5588        sha: Option<String>,
5589        url: String,
5590    },
5591    Npm {
5592        package: String,
5593        #[serde(default, skip_serializing_if = "Option::is_none")]
5594        registry: Option<String>,
5595        #[serde(default, skip_serializing_if = "Option::is_none")]
5596        version: Option<String>,
5597    },
5598    Remote,
5599}
5600
5601#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5602#[serde(rename_all = "camelCase")]
5603pub struct PluginSummary {
5604    #[serde(rename = "authPolicy")]
5605    pub auth_policy: PluginAuthPolicy,
5606    #[serde(default, skip_serializing_if = "Option::is_none")]
5607    pub availability: Option<Value>,
5608    #[serde(
5609        rename = "disabledReason",
5610        default,
5611        skip_serializing_if = "Option::is_none"
5612    )]
5613    pub disabled_reason: Option<PluginDisabledReason>,
5614    #[serde(
5615        rename = "eligiblePlanTypes",
5616        default,
5617        skip_serializing_if = "Option::is_none"
5618    )]
5619    pub eligible_plan_types: Option<Vec<String>>,
5620    #[serde(default)]
5621    pub enabled: bool,
5622    #[serde(default)]
5623    pub id: String,
5624    #[serde(rename = "installPolicy")]
5625    pub install_policy: PluginInstallPolicy,
5626    #[serde(
5627        rename = "installPolicySource",
5628        default,
5629        skip_serializing_if = "Option::is_none"
5630    )]
5631    pub install_policy_source: Option<PluginInstallPolicySource>,
5632    #[serde(default)]
5633    pub installed: bool,
5634    #[serde(
5635        rename = "installedAt",
5636        default,
5637        skip_serializing_if = "Option::is_none"
5638    )]
5639    pub installed_at: Option<i64>,
5640    #[serde(default, skip_serializing_if = "Option::is_none")]
5641    pub interface: Option<PluginInterface>,
5642    #[serde(default, skip_serializing_if = "Option::is_none")]
5643    pub keywords: Option<Vec<String>>,
5644    #[serde(
5645        rename = "localVersion",
5646        default,
5647        skip_serializing_if = "Option::is_none"
5648    )]
5649    pub local_version: Option<String>,
5650    #[serde(
5651        rename = "mustShowInstallationInterstitial",
5652        default,
5653        skip_serializing_if = "Option::is_none"
5654    )]
5655    pub must_show_installation_interstitial: Option<bool>,
5656    #[serde(default)]
5657    pub name: String,
5658    #[serde(
5659        rename = "remotePluginId",
5660        default,
5661        skip_serializing_if = "Option::is_none"
5662    )]
5663    pub remote_plugin_id: Option<String>,
5664    #[serde(
5665        rename = "shareContext",
5666        default,
5667        skip_serializing_if = "Option::is_none"
5668    )]
5669    pub share_context: Option<PluginShareContext>,
5670    #[serde()]
5671    pub source: PluginSource,
5672    #[serde(default, skip_serializing_if = "Option::is_none")]
5673    pub version: Option<String>,
5674}
5675
5676#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5677#[serde(rename_all = "camelCase")]
5678pub struct PluginUninstallParams {
5679    #[serde(rename = "pluginId", default)]
5680    pub plugin_id: String,
5681}
5682
5683#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5684#[serde(rename_all = "camelCase")]
5685pub struct PluginUninstallResponse {
5686    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5687    pub extra: serde_json::Map<String, Value>,
5688}
5689
5690#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5691#[serde(rename_all = "camelCase")]
5692pub struct PluginsMigration {
5693    #[serde(rename = "marketplaceName", default)]
5694    pub marketplace_name: String,
5695    #[serde(rename = "pluginNames", default)]
5696    pub plugin_names: Vec<String>,
5697}
5698
5699#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5700#[serde(rename_all = "camelCase")]
5701pub struct ProcessExitedNotification {
5702    #[serde(rename = "exitCode", default)]
5703    pub exit_code: i64,
5704    #[serde(rename = "processHandle", default)]
5705    pub process_handle: String,
5706    #[serde(default)]
5707    pub stderr: String,
5708    #[serde(rename = "stderrCapReached", default)]
5709    pub stderr_cap_reached: bool,
5710    #[serde(default)]
5711    pub stdout: String,
5712    #[serde(rename = "stdoutCapReached", default)]
5713    pub stdout_cap_reached: bool,
5714}
5715
5716#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5717#[serde(rename_all = "camelCase")]
5718pub struct ProcessOutputDeltaNotification {
5719    #[serde(rename = "capReached", default)]
5720    pub cap_reached: bool,
5721    #[serde(rename = "deltaBase64", default)]
5722    pub delta_base64: String,
5723    #[serde(rename = "processHandle", default)]
5724    pub process_handle: String,
5725    #[serde(default)]
5726    pub stream: Value,
5727}
5728
5729#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5730pub enum ProcessOutputStream {
5731    #[serde(rename = "stdout")]
5732    Stdout,
5733    #[serde(rename = "stderr")]
5734    Stderr,
5735}
5736
5737#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5738pub enum RateLimitReachedType {
5739    #[serde(rename = "rate_limit_reached")]
5740    Rate_limit_reached,
5741    #[serde(rename = "workspace_owner_credits_depleted")]
5742    Workspace_owner_credits_depleted,
5743    #[serde(rename = "workspace_member_credits_depleted")]
5744    Workspace_member_credits_depleted,
5745    #[serde(rename = "workspace_owner_usage_limit_reached")]
5746    Workspace_owner_usage_limit_reached,
5747    #[serde(rename = "workspace_member_usage_limit_reached")]
5748    Workspace_member_usage_limit_reached,
5749}
5750
5751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5752#[serde(rename_all = "camelCase")]
5753pub struct RateLimitResetCredit {
5754    #[serde(default, skip_serializing_if = "Option::is_none")]
5755    pub description: Option<String>,
5756    #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
5757    pub expires_at: Option<i64>,
5758    #[serde(rename = "grantedAt", default)]
5759    pub granted_at: i64,
5760    #[serde(default)]
5761    pub id: String,
5762    #[serde(rename = "resetType")]
5763    pub reset_type: RateLimitResetType,
5764    #[serde()]
5765    pub status: RateLimitResetCreditStatus,
5766    #[serde(default, skip_serializing_if = "Option::is_none")]
5767    pub title: Option<String>,
5768}
5769
5770#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5771pub enum RateLimitResetCreditStatus {
5772    #[serde(rename = "available")]
5773    Available,
5774    #[serde(rename = "redeeming")]
5775    Redeeming,
5776    #[serde(rename = "redeemed")]
5777    Redeemed,
5778    #[serde(rename = "unknown")]
5779    Unknown,
5780}
5781
5782#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5783#[serde(rename_all = "camelCase")]
5784pub struct RateLimitResetCreditsSummary {
5785    #[serde(rename = "availableCount", default)]
5786    pub available_count: i64,
5787    #[serde(default, skip_serializing_if = "Option::is_none")]
5788    pub credits: Option<Vec<RateLimitResetCredit>>,
5789}
5790
5791#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5792pub enum RateLimitResetType {
5793    #[serde(rename = "codexRateLimits")]
5794    CodexRateLimits,
5795    #[serde(rename = "unknown")]
5796    Unknown,
5797}
5798
5799#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5800#[serde(rename_all = "camelCase")]
5801pub struct RateLimitSnapshot {
5802    #[serde(default, skip_serializing_if = "Option::is_none")]
5803    pub credits: Option<CreditsSnapshot>,
5804    #[serde(
5805        rename = "individualLimit",
5806        default,
5807        skip_serializing_if = "Option::is_none"
5808    )]
5809    pub individual_limit: Option<SpendControlLimitSnapshot>,
5810    #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
5811    pub limit_id: Option<String>,
5812    #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
5813    pub limit_name: Option<String>,
5814    #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
5815    pub plan_type: Option<PlanType>,
5816    #[serde(default, skip_serializing_if = "Option::is_none")]
5817    pub primary: Option<RateLimitWindow>,
5818    #[serde(
5819        rename = "rateLimitReachedType",
5820        default,
5821        skip_serializing_if = "Option::is_none"
5822    )]
5823    pub rate_limit_reached_type: Option<RateLimitReachedType>,
5824    #[serde(default, skip_serializing_if = "Option::is_none")]
5825    pub secondary: Option<RateLimitWindow>,
5826    #[serde(
5827        rename = "spendControlReached",
5828        default,
5829        skip_serializing_if = "Option::is_none"
5830    )]
5831    pub spend_control_reached: Option<bool>,
5832}
5833
5834#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5835#[serde(rename_all = "camelCase")]
5836pub struct RateLimitWindow {
5837    #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
5838    pub resets_at: Option<i64>,
5839    #[serde(rename = "usedPercent", default)]
5840    pub used_percent: i64,
5841    #[serde(
5842        rename = "windowDurationMins",
5843        default,
5844        skip_serializing_if = "Option::is_none"
5845    )]
5846    pub window_duration_mins: Option<i64>,
5847}
5848
5849#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5850pub enum RealtimeConversationVersion {
5851    #[serde(rename = "v1")]
5852    V1,
5853    #[serde(rename = "v2")]
5854    V2,
5855    #[serde(rename = "v3")]
5856    V3,
5857}
5858
5859/// A non-empty reasoning effort value advertised by the model.
5860#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
5861#[serde(transparent)]
5862pub struct ReasoningEffort(pub String);
5863
5864#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5865#[serde(rename_all = "camelCase")]
5866pub struct ReasoningEffortOption {
5867    #[serde(default)]
5868    pub description: String,
5869    #[serde(rename = "reasoningEffort")]
5870    pub reasoning_effort: ReasoningEffort,
5871}
5872
5873#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5874pub enum ReasoningSummary {
5875    #[serde(rename = "auto")]
5876    Auto,
5877    #[serde(rename = "concise")]
5878    Concise,
5879    #[serde(rename = "detailed")]
5880    Detailed,
5881    #[serde(rename = "none")]
5882    None,
5883}
5884
5885#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5886#[serde(rename_all = "camelCase")]
5887pub struct ReasoningSummaryPartAddedNotification {
5888    #[serde(rename = "itemId", default)]
5889    pub item_id: String,
5890    #[serde(rename = "summaryIndex", default)]
5891    pub summary_index: i64,
5892    #[serde(rename = "threadId", default)]
5893    pub thread_id: String,
5894    #[serde(rename = "turnId", default)]
5895    pub turn_id: String,
5896}
5897
5898#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5899#[serde(rename_all = "camelCase")]
5900pub struct ReasoningSummaryTextDeltaNotification {
5901    #[serde(default)]
5902    pub delta: String,
5903    #[serde(rename = "itemId", default)]
5904    pub item_id: String,
5905    #[serde(rename = "summaryIndex", default)]
5906    pub summary_index: i64,
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, PartialEq, Serialize, Deserialize, Default)]
5914#[serde(rename_all = "camelCase")]
5915pub struct ReasoningTextDeltaNotification {
5916    #[serde(rename = "contentIndex", default)]
5917    pub content_index: i64,
5918    #[serde(default)]
5919    pub delta: String,
5920    #[serde(rename = "itemId", default)]
5921    pub item_id: String,
5922    #[serde(rename = "threadId", default)]
5923    pub thread_id: String,
5924    #[serde(rename = "turnId", default)]
5925    pub turn_id: String,
5926}
5927
5928#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5929pub enum RemoteControlConnectionStatus {
5930    #[serde(rename = "disabled")]
5931    Disabled,
5932    #[serde(rename = "connecting")]
5933    Connecting,
5934    #[serde(rename = "connected")]
5935    Connected,
5936    #[serde(rename = "errored")]
5937    Errored,
5938}
5939
5940#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5941#[serde(rename_all = "camelCase")]
5942pub struct RemoteControlStatusChangedNotification {
5943    #[serde(
5944        rename = "environmentId",
5945        default,
5946        skip_serializing_if = "Option::is_none"
5947    )]
5948    pub environment_id: Option<String>,
5949    #[serde(rename = "installationId", default)]
5950    pub installation_id: String,
5951    #[serde(rename = "serverName", default)]
5952    pub server_name: String,
5953    #[serde()]
5954    pub status: RemoteControlConnectionStatus,
5955}
5956
5957#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5958#[serde(untagged)]
5959pub enum RequestId {
5960    Variant0(String),
5961    Variant1(i64),
5962}
5963
5964#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5965#[serde(rename_all = "camelCase")]
5966pub struct RequestPermissionProfile {
5967    #[serde(
5968        rename = "fileSystem",
5969        default,
5970        skip_serializing_if = "Option::is_none"
5971    )]
5972    pub file_system: Option<AdditionalFileSystemPermissions>,
5973    #[serde(default, skip_serializing_if = "Option::is_none")]
5974    pub network: Option<AdditionalNetworkPermissions>,
5975}
5976
5977#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5978pub enum ResidencyRequirement {
5979    #[serde(rename = "us")]
5980    Us,
5981}
5982
5983#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5984#[serde(rename_all = "camelCase")]
5985pub struct Resource {
5986    #[serde(default, skip_serializing_if = "Option::is_none")]
5987    pub _meta: Option<Value>,
5988    #[serde(default, skip_serializing_if = "Option::is_none")]
5989    pub annotations: Option<Value>,
5990    #[serde(default, skip_serializing_if = "Option::is_none")]
5991    pub description: Option<String>,
5992    #[serde(default, skip_serializing_if = "Option::is_none")]
5993    pub icons: Option<Vec<Value>>,
5994    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
5995    pub mime_type: Option<String>,
5996    #[serde(default)]
5997    pub name: String,
5998    #[serde(default, skip_serializing_if = "Option::is_none")]
5999    pub size: Option<i64>,
6000    #[serde(default, skip_serializing_if = "Option::is_none")]
6001    pub title: Option<String>,
6002    #[serde(default)]
6003    pub uri: String,
6004}
6005
6006#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6007#[serde(untagged)]
6008pub enum ResourceContent {
6009    Variant0(Value),
6010    Variant1(Value),
6011}
6012
6013#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6014#[serde(rename_all = "camelCase")]
6015pub struct ResourceTemplate {
6016    #[serde(default, skip_serializing_if = "Option::is_none")]
6017    pub annotations: Option<Value>,
6018    #[serde(default, skip_serializing_if = "Option::is_none")]
6019    pub description: Option<String>,
6020    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6021    pub mime_type: Option<String>,
6022    #[serde(default)]
6023    pub name: String,
6024    #[serde(default, skip_serializing_if = "Option::is_none")]
6025    pub title: Option<String>,
6026    #[serde(rename = "uriTemplate", default)]
6027    pub uri_template: String,
6028}
6029
6030/// Usage metadata reported for one upstream response (0.148 upstream).
6031#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6032#[serde(rename_all = "camelCase")]
6033pub struct ResponseUsageMetadata {
6034    #[serde(default, skip_serializing_if = "Option::is_none")]
6035    pub amount: Option<String>,
6036    #[serde(default, skip_serializing_if = "Option::is_none")]
6037    pub metadata: Option<Value>,
6038}
6039
6040#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6041pub enum ReviewDecision {
6042    #[serde(rename = "approved")]
6043    Approved,
6044    #[serde(rename = "approved_execpolicy_amendment")]
6045    ApprovedExecpolicyAmendment {
6046        proposed_execpolicy_amendment: Vec<String>,
6047    },
6048    #[serde(rename = "approved_for_session")]
6049    ApprovedForSession,
6050    #[serde(rename = "approved_mcp_policy_amendment")]
6051    ApprovedMcpPolicyAmendment,
6052    #[serde(rename = "network_policy_amendment")]
6053    NetworkPolicyAmendment {
6054        network_policy_amendment: NetworkPolicyAmendment,
6055    },
6056    #[serde(rename = "denied")]
6057    Denied { rejection: String },
6058    #[serde(rename = "timed_out")]
6059    TimedOut,
6060    #[serde(rename = "abort")]
6061    Abort,
6062}
6063
6064#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6065pub enum ReviewDelivery {
6066    #[serde(rename = "inline")]
6067    Inline,
6068    #[serde(rename = "detached")]
6069    Detached,
6070}
6071
6072#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6073#[serde(rename_all = "camelCase")]
6074pub struct ReviewStartParams {
6075    #[serde(default, skip_serializing_if = "Option::is_none")]
6076    pub delivery: Option<ReviewDelivery>,
6077    #[serde()]
6078    pub target: ReviewTarget,
6079    #[serde(rename = "threadId", default)]
6080    pub thread_id: String,
6081}
6082
6083#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6084#[serde(rename_all = "camelCase")]
6085pub struct ReviewStartResponse {
6086    #[serde(rename = "reviewThreadId", default)]
6087    pub review_thread_id: String,
6088    #[serde()]
6089    pub turn: Turn,
6090}
6091
6092#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6093#[serde(tag = "type", rename_all = "camelCase")]
6094pub enum ReviewTarget {
6095    #[serde(rename = "uncommittedChanges")]
6096    UncommittedChanges,
6097    #[serde(rename = "baseBranch")]
6098    BaseBranch {
6099        branch: String,
6100    },
6101    Commit {
6102        sha: String,
6103        #[serde(default, skip_serializing_if = "Option::is_none")]
6104        title: Option<String>,
6105    },
6106    Custom {
6107        instructions: String,
6108    },
6109}
6110
6111/// Delivery mode for an agent message item (0.147: currently only `async`).
6112#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6113pub enum AgentMessageDelivery {
6114    #[serde(rename = "async")]
6115    Async,
6116}
6117
6118/// Where the CLI stores auth credentials.
6119#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6120pub enum CliAuthCredentialsStoreMode {
6121    #[serde(rename = "file")]
6122    File,
6123    #[serde(rename = "keyring")]
6124    Keyring,
6125    #[serde(rename = "auto")]
6126    Auto,
6127    #[serde(rename = "ephemeral")]
6128    Ephemeral,
6129}
6130
6131/// A project grouping threads, owned by app-server.
6132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6133pub struct Project {
6134    #[serde(rename = "createdAt", default)]
6135    pub created_at: i64,
6136    #[serde(default)]
6137    pub id: String,
6138    #[serde(default)]
6139    pub metadata: std::collections::HashMap<String, String>,
6140    #[serde(default)]
6141    pub name: String,
6142    #[serde(default)]
6143    pub position: i64,
6144    /// Newest non-archived member thread's recency, in Unix seconds;
6145    /// absent/null when none exist (0.148 upstream).
6146    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
6147    pub recency_at: Option<i64>,
6148    #[serde(default)]
6149    pub roots: Vec<ProjectRoot>,
6150    #[serde(rename = "updatedAt", default)]
6151    pub updated_at: i64,
6152}
6153
6154/// Sort order for project listings (0.148 upstream).
6155#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6156pub enum ProjectSortKey {
6157    #[serde(rename = "position")]
6158    Position,
6159    #[serde(rename = "recencyAt")]
6160    RecencyAt,
6161}
6162
6163#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6164pub enum ProjectChangeType {
6165    #[serde(rename = "created")]
6166    Created,
6167    #[serde(rename = "updated")]
6168    Updated,
6169    #[serde(rename = "deleted")]
6170    Deleted,
6171}
6172
6173/// `project/changed` — a project was created, updated, or deleted.
6174#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6175pub struct ProjectChangedNotification {
6176    #[serde(rename = "changeType")]
6177    pub change_type: ProjectChangeType,
6178    #[serde(rename = "projectId", default)]
6179    pub project_id: String,
6180}
6181
6182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6183pub struct ProjectRoot {
6184    pub path: AbsolutePathBuf,
6185}
6186
6187/// A user submission waiting in a thread's queue.
6188#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6189pub struct QueuedSubmission {
6190    #[serde(rename = "clientUserMessageId", default)]
6191    pub client_user_message_id: String,
6192    #[serde(default)]
6193    pub id: String,
6194    #[serde(default)]
6195    pub input: Vec<UserInput>,
6196}
6197
6198/// `autoApprovalReview/strictReviewRequired` — a strict review gate opened.
6199#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6200pub struct StrictReviewRequiredNotification {
6201    /// Unix timestamp (ms) when this review started.
6202    #[serde(rename = "startedAtMs", default)]
6203    pub started_at_ms: i64,
6204    #[serde(rename = "threadId", default)]
6205    pub thread_id: String,
6206    #[serde(rename = "turnId", default)]
6207    pub turn_id: String,
6208}
6209
6210/// `thread/project/updated` — a thread's project assignment changed.
6211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6212pub struct ThreadProjectUpdatedNotification {
6213    #[serde(rename = "projectId", default)]
6214    pub project_id: Option<String>,
6215    #[serde(rename = "threadId", default)]
6216    pub thread_id: String,
6217}
6218
6219/// `thread/queue/changed` — the thread's queued submissions changed.
6220#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6221pub struct ThreadQueueChangedNotification {
6222    #[serde(rename = "threadId", default)]
6223    pub thread_id: String,
6224}
6225
6226/// `thread/reverted` — the thread was rolled back.
6227#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6228pub struct ThreadRevertedNotification {
6229    #[serde(rename = "threadId", default)]
6230    pub thread_id: String,
6231}
6232
6233/// In-app browser requirements (0.148 upstream).
6234#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6235#[serde(rename_all = "camelCase")]
6236pub struct InAppBrowserRequirements {
6237    #[serde(
6238        rename = "allowExternalBrowserSettingsImport",
6239        default,
6240        skip_serializing_if = "Option::is_none"
6241    )]
6242    pub allow_external_browser_settings_import: Option<bool>,
6243}
6244
6245/// One MCP-server-originated notification, relayed verbatim.
6246#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6247pub struct McpServerEventNotification {
6248    #[serde(default)]
6249    pub method: String,
6250    #[serde(default)]
6251    pub params: Value,
6252}
6253
6254/// `mcpServer/event/stream/notification` — an MCP server's own
6255/// notification stream, forwarded to subscribers.
6256#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6257pub struct McpServerEventStreamNotification {
6258    pub notification: McpServerEventNotification,
6259    #[serde(rename = "subscriptionId", default)]
6260    pub subscription_id: String,
6261}
6262
6263/// Allow/deny switch used across the browser-use / computer-use policy
6264/// surface (0.148 upstream).
6265#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6266pub enum AllowDenyRequirement {
6267    #[serde(rename = "allow")]
6268    Allow,
6269    #[serde(rename = "deny")]
6270    Deny,
6271}
6272
6273/// How long a granted browser-use access approval lasts.
6274#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6275pub enum BrowserUseAccessApprovalLifetime {
6276    #[serde(rename = "turn")]
6277    Turn,
6278    #[serde(rename = "thread")]
6279    Thread,
6280}
6281
6282/// Current thread-runtime MCP server connection state.
6283#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6284pub enum McpServerConnectionStatus {
6285    #[serde(rename = "notStarted")]
6286    NotStarted,
6287    #[serde(rename = "starting")]
6288    Starting,
6289    #[serde(rename = "connected")]
6290    Connected,
6291    #[serde(rename = "authenticationRequired")]
6292    AuthenticationRequired,
6293    #[serde(rename = "failed")]
6294    Failed,
6295    #[serde(rename = "cancelled")]
6296    Cancelled,
6297    #[serde(rename = "disabled")]
6298    Disabled,
6299}
6300
6301/// Per-origin browser-use policy (requirements side, camelCase wire).
6302#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6303#[serde(rename_all = "camelCase")]
6304pub struct BrowserUseOriginPolicy {
6305    #[serde(default, skip_serializing_if = "Option::is_none")]
6306    pub access: Option<AllowDenyRequirement>,
6307    #[serde(
6308        rename = "accessApprovalLifetime",
6309        default,
6310        skip_serializing_if = "Option::is_none"
6311    )]
6312    pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
6313    #[serde(
6314        rename = "autoReview",
6315        default,
6316        skip_serializing_if = "Option::is_none"
6317    )]
6318    pub auto_review: Option<AllowDenyRequirement>,
6319    #[serde(default, skip_serializing_if = "Option::is_none")]
6320    pub downloads: Option<AllowDenyRequirement>,
6321    #[serde(
6322        rename = "fullCdpAccess",
6323        default,
6324        skip_serializing_if = "Option::is_none"
6325    )]
6326    pub full_cdp_access: Option<AllowDenyRequirement>,
6327    #[serde(
6328        rename = "persistentApproval",
6329        default,
6330        skip_serializing_if = "Option::is_none"
6331    )]
6332    pub persistent_approval: Option<bool>,
6333    #[serde(default, skip_serializing_if = "Option::is_none")]
6334    pub uploads: Option<AllowDenyRequirement>,
6335}
6336
6337/// Per-origin browser-use policy (config side, snake_case wire).
6338#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6339pub struct BrowserUseOriginPolicyConfig {
6340    #[serde(default, skip_serializing_if = "Option::is_none")]
6341    pub access: Option<AllowDenyRequirement>,
6342    #[serde(default, skip_serializing_if = "Option::is_none")]
6343    pub downloads: Option<AllowDenyRequirement>,
6344    #[serde(default, skip_serializing_if = "Option::is_none")]
6345    pub full_cdp_access: Option<AllowDenyRequirement>,
6346    #[serde(default, skip_serializing_if = "Option::is_none")]
6347    pub uploads: Option<AllowDenyRequirement>,
6348}
6349
6350/// Browser-use configuration (config side, snake_case wire).
6351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6352pub struct BrowserUseConfig {
6353    #[serde(default, skip_serializing_if = "Option::is_none")]
6354    pub allow_history_access: Option<bool>,
6355    #[serde(default, skip_serializing_if = "Option::is_none")]
6356    pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
6357    #[serde(default, skip_serializing_if = "Option::is_none")]
6358    pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
6359}
6360
6361/// Computer-use configuration (config side, snake_case wire).
6362#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6363pub struct ComputerUseConfig {
6364    #[serde(default, skip_serializing_if = "Option::is_none")]
6365    pub default_app_access: Option<AllowDenyRequirement>,
6366    #[serde(default, skip_serializing_if = "Option::is_none")]
6367    pub macos: Option<ComputerUseMacosConfig>,
6368    #[serde(default, skip_serializing_if = "Option::is_none")]
6369    pub windows: Option<ComputerUseWindowsConfig>,
6370}
6371
6372#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6373pub struct ComputerUseMacosConfig {
6374    #[serde(default, skip_serializing_if = "Option::is_none")]
6375    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6376}
6377
6378#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6379pub struct ComputerUseWindowsConfig {
6380    #[serde(default, skip_serializing_if = "Option::is_none")]
6381    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6382    #[serde(default, skip_serializing_if = "Option::is_none")]
6383    pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
6384}
6385
6386#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6387pub struct ComputerUseWindowsExeConfig {
6388    pub access: AllowDenyRequirement,
6389    #[serde(default, skip_serializing_if = "Option::is_none")]
6390    pub binary_name: Option<String>,
6391    #[serde(default)]
6392    pub product_name: String,
6393    #[serde(default)]
6394    pub publisher_name: String,
6395}
6396
6397/// Per-platform computer-use requirements (camelCase wire).
6398#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6399#[serde(rename_all = "camelCase")]
6400pub struct ComputerUseMacosRequirements {
6401    #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
6402    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6403}
6404
6405#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6406#[serde(rename_all = "camelCase")]
6407pub struct ComputerUseWindowsRequirements {
6408    #[serde(default, skip_serializing_if = "Option::is_none")]
6409    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6410    #[serde(default, skip_serializing_if = "Option::is_none")]
6411    pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
6412}
6413
6414#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6415#[serde(rename_all = "camelCase")]
6416pub struct ComputerUseWindowsExeRequirement {
6417    pub access: AllowDenyRequirement,
6418    #[serde(
6419        rename = "binaryName",
6420        default,
6421        skip_serializing_if = "Option::is_none"
6422    )]
6423    pub binary_name: Option<String>,
6424    #[serde(rename = "productName", default)]
6425    pub product_name: String,
6426    #[serde(rename = "publisherName", default)]
6427    pub publisher_name: String,
6428}
6429
6430#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6431pub enum SandboxMode {
6432    #[serde(rename = "read-only")]
6433    Read_only,
6434    #[serde(rename = "workspace-write")]
6435    Workspace_write,
6436    #[serde(rename = "danger-full-access")]
6437    Danger_full_access,
6438}
6439
6440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6441#[serde(tag = "type", rename_all = "camelCase")]
6442pub enum SandboxPolicy {
6443    #[serde(rename = "dangerFullAccess")]
6444    DangerFullAccess,
6445    #[serde(rename = "readOnly")]
6446    ReadOnly {
6447        #[serde(
6448            rename = "networkAccess",
6449            default,
6450            skip_serializing_if = "Option::is_none"
6451        )]
6452        network_access: Option<bool>,
6453    },
6454    #[serde(rename = "externalSandbox")]
6455    ExternalSandbox {
6456        #[serde(
6457            rename = "networkAccess",
6458            default,
6459            skip_serializing_if = "Option::is_none"
6460        )]
6461        network_access: Option<Value>,
6462    },
6463    #[serde(rename = "workspaceWrite")]
6464    WorkspaceWrite {
6465        #[serde(
6466            rename = "excludeSlashTmp",
6467            default,
6468            skip_serializing_if = "Option::is_none"
6469        )]
6470        exclude_slash_tmp: Option<bool>,
6471        #[serde(
6472            rename = "excludeTmpdirEnvVar",
6473            default,
6474            skip_serializing_if = "Option::is_none"
6475        )]
6476        exclude_tmpdir_env_var: Option<bool>,
6477        #[serde(
6478            rename = "networkAccess",
6479            default,
6480            skip_serializing_if = "Option::is_none"
6481        )]
6482        network_access: Option<bool>,
6483        #[serde(
6484            rename = "writableRoots",
6485            default,
6486            skip_serializing_if = "Option::is_none"
6487        )]
6488        writable_roots: Option<Vec<AbsolutePathBuf>>,
6489    },
6490}
6491
6492#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6493#[serde(rename_all = "snake_case")]
6494pub struct SandboxWorkspaceWrite {
6495    #[serde(default, skip_serializing_if = "Option::is_none")]
6496    pub exclude_slash_tmp: Option<bool>,
6497    #[serde(default, skip_serializing_if = "Option::is_none")]
6498    pub exclude_tmpdir_env_var: Option<bool>,
6499    #[serde(default, skip_serializing_if = "Option::is_none")]
6500    pub network_access: Option<bool>,
6501    #[serde(default, skip_serializing_if = "Option::is_none")]
6502    pub writable_roots: Option<Vec<String>>,
6503}
6504
6505#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6506#[serde(tag = "type", rename_all = "camelCase")]
6507pub enum ScheduledTaskSchedule {
6508    Hourly {
6509        #[serde(default, skip_serializing_if = "Option::is_none")]
6510        days: Option<Vec<ScheduledTaskWeekday>>,
6511        #[serde(rename = "intervalHours")]
6512        interval_hours: i64,
6513    },
6514    Daily {
6515        time: String,
6516    },
6517    Weekdays {
6518        time: String,
6519    },
6520    Weekly {
6521        days: Vec<ScheduledTaskWeekday>,
6522        time: String,
6523    },
6524}
6525
6526#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6527#[serde(rename_all = "camelCase")]
6528pub struct ScheduledTaskSummary {
6529    #[serde(default)]
6530    pub key: String,
6531    #[serde(default)]
6532    pub name: String,
6533    #[serde(default)]
6534    pub prompt: String,
6535    #[serde()]
6536    pub schedule: ScheduledTaskSchedule,
6537}
6538
6539#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6540pub enum ScheduledTaskWeekday {
6541    #[serde(rename = "MO")]
6542    MO,
6543    #[serde(rename = "TU")]
6544    TU,
6545    #[serde(rename = "WE")]
6546    WE,
6547    #[serde(rename = "TH")]
6548    TH,
6549    #[serde(rename = "FR")]
6550    FR,
6551    #[serde(rename = "SA")]
6552    SA,
6553    #[serde(rename = "SU")]
6554    SU,
6555}
6556
6557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6558#[serde(rename_all = "camelCase")]
6559pub struct SendAddCreditsNudgeEmailParams {
6560    #[serde(rename = "creditType")]
6561    pub credit_type: AddCreditsNudgeCreditType,
6562}
6563
6564#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6565#[serde(rename_all = "camelCase")]
6566pub struct SendAddCreditsNudgeEmailResponse {
6567    #[serde()]
6568    pub status: AddCreditsNudgeEmailStatus,
6569}
6570
6571#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6572#[serde(rename_all = "camelCase")]
6573pub struct ServerRequestResolvedNotification {
6574    #[serde(rename = "requestId")]
6575    pub request_id: RequestId,
6576    #[serde(rename = "threadId", default)]
6577    pub thread_id: String,
6578}
6579
6580#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6581#[serde(rename_all = "camelCase")]
6582pub struct SessionMigration {
6583    #[serde(default)]
6584    pub cwd: String,
6585    #[serde(default)]
6586    pub path: String,
6587    #[serde(default, skip_serializing_if = "Option::is_none")]
6588    pub title: Option<String>,
6589}
6590
6591#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6592pub enum SessionSource {
6593    #[serde(rename = "cli")]
6594    Cli,
6595    #[serde(rename = "vscode")]
6596    Vscode,
6597    #[serde(rename = "exec")]
6598    Exec,
6599    #[serde(rename = "appServer")]
6600    AppServer,
6601    #[serde(rename = "unknown")]
6602    Unknown,
6603    #[serde(rename = "custom")]
6604    Custom(String),
6605    #[serde(rename = "subAgent")]
6606    SubAgent(SubAgentSource),
6607}
6608
6609#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6610#[serde(rename_all = "camelCase")]
6611pub struct Settings {
6612    #[serde(default, skip_serializing_if = "Option::is_none")]
6613    pub developer_instructions: Option<String>,
6614    #[serde(default)]
6615    pub model: String,
6616    #[serde(default, skip_serializing_if = "Option::is_none")]
6617    pub reasoning_effort: Option<ReasoningEffort>,
6618}
6619
6620#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6621#[serde(rename_all = "camelCase")]
6622pub struct SkillDependencies {
6623    #[serde(default)]
6624    pub tools: Vec<SkillToolDependency>,
6625}
6626
6627#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6628#[serde(rename_all = "camelCase")]
6629pub struct SkillErrorInfo {
6630    #[serde(default)]
6631    pub message: String,
6632    #[serde(default)]
6633    pub path: String,
6634}
6635
6636#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6637#[serde(rename_all = "camelCase")]
6638pub struct SkillInterface {
6639    #[serde(
6640        rename = "brandColor",
6641        default,
6642        skip_serializing_if = "Option::is_none"
6643    )]
6644    pub brand_color: Option<String>,
6645    #[serde(
6646        rename = "defaultPrompt",
6647        default,
6648        skip_serializing_if = "Option::is_none"
6649    )]
6650    pub default_prompt: Option<String>,
6651    #[serde(
6652        rename = "displayName",
6653        default,
6654        skip_serializing_if = "Option::is_none"
6655    )]
6656    pub display_name: Option<String>,
6657    #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
6658    pub icon_large: Option<AbsolutePathBuf>,
6659    #[serde(
6660        rename = "iconLargeUrl",
6661        default,
6662        skip_serializing_if = "Option::is_none"
6663    )]
6664    pub icon_large_url: Option<String>,
6665    #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
6666    pub icon_small: Option<AbsolutePathBuf>,
6667    #[serde(
6668        rename = "iconSmallUrl",
6669        default,
6670        skip_serializing_if = "Option::is_none"
6671    )]
6672    pub icon_small_url: Option<String>,
6673    #[serde(
6674        rename = "shortDescription",
6675        default,
6676        skip_serializing_if = "Option::is_none"
6677    )]
6678    pub short_description: Option<String>,
6679}
6680
6681#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6682#[serde(rename_all = "camelCase")]
6683pub struct SkillMetadata {
6684    #[serde(default, skip_serializing_if = "Option::is_none")]
6685    pub dependencies: Option<SkillDependencies>,
6686    #[serde(default)]
6687    pub description: String,
6688    #[serde(default)]
6689    pub enabled: bool,
6690    #[serde(default, skip_serializing_if = "Option::is_none")]
6691    pub interface: Option<SkillInterface>,
6692    #[serde(default)]
6693    pub name: String,
6694    #[serde()]
6695    pub path: AbsolutePathBuf,
6696    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
6697    pub plugin_id: Option<String>,
6698    #[serde()]
6699    pub scope: SkillScope,
6700    #[serde(
6701        rename = "shortDescription",
6702        default,
6703        skip_serializing_if = "Option::is_none"
6704    )]
6705    pub short_description: Option<String>,
6706}
6707
6708#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6709#[serde(rename_all = "camelCase")]
6710pub struct SkillMigration {
6711    #[serde(default)]
6712    pub name: String,
6713}
6714
6715#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6716pub enum SkillScope {
6717    #[serde(rename = "user")]
6718    User,
6719    #[serde(rename = "repo")]
6720    Repo,
6721    #[serde(rename = "system")]
6722    System,
6723    #[serde(rename = "admin")]
6724    Admin,
6725}
6726
6727#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6728#[serde(rename_all = "camelCase")]
6729pub struct SkillSummary {
6730    #[serde(default)]
6731    pub description: String,
6732    #[serde(default)]
6733    pub enabled: bool,
6734    #[serde(default, skip_serializing_if = "Option::is_none")]
6735    pub interface: Option<SkillInterface>,
6736    #[serde(default)]
6737    pub name: String,
6738    #[serde(default, skip_serializing_if = "Option::is_none")]
6739    pub path: Option<AbsolutePathBuf>,
6740    #[serde(
6741        rename = "shortDescription",
6742        default,
6743        skip_serializing_if = "Option::is_none"
6744    )]
6745    pub short_description: Option<String>,
6746}
6747
6748#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6749#[serde(rename_all = "camelCase")]
6750pub struct SkillToolDependency {
6751    #[serde(default, skip_serializing_if = "Option::is_none")]
6752    pub command: Option<String>,
6753    #[serde(default, skip_serializing_if = "Option::is_none")]
6754    pub description: Option<String>,
6755    #[serde(default, skip_serializing_if = "Option::is_none")]
6756    pub transport: Option<String>,
6757    #[serde(rename = "type", default)]
6758    pub type_: String,
6759    #[serde(default, skip_serializing_if = "Option::is_none")]
6760    pub url: Option<String>,
6761    #[serde(default)]
6762    pub value: String,
6763}
6764
6765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6766#[serde(rename_all = "camelCase")]
6767pub struct SkillsChangedNotification {
6768    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6769    pub extra: serde_json::Map<String, Value>,
6770}
6771
6772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6773#[serde(rename_all = "camelCase")]
6774pub struct SkillsConfigWriteParams {
6775    #[serde(default)]
6776    pub enabled: bool,
6777    #[serde(default, skip_serializing_if = "Option::is_none")]
6778    pub name: Option<String>,
6779    #[serde(default, skip_serializing_if = "Option::is_none")]
6780    pub path: Option<AbsolutePathBuf>,
6781}
6782
6783#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6784#[serde(rename_all = "camelCase")]
6785pub struct SkillsConfigWriteResponse {
6786    #[serde(rename = "effectiveEnabled", default)]
6787    pub effective_enabled: bool,
6788}
6789
6790#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6791#[serde(rename_all = "camelCase")]
6792pub struct SkillsExtraRootsSetParams {
6793    #[serde(rename = "extraRoots", default)]
6794    pub extra_roots: Vec<AbsolutePathBuf>,
6795}
6796
6797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6798#[serde(rename_all = "camelCase")]
6799pub struct SkillsExtraRootsSetResponse {
6800    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6801    pub extra: serde_json::Map<String, Value>,
6802}
6803
6804#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6805#[serde(rename_all = "camelCase")]
6806pub struct SkillsListEntry {
6807    #[serde(default)]
6808    pub cwd: String,
6809    #[serde(default)]
6810    pub errors: Vec<SkillErrorInfo>,
6811    #[serde(default)]
6812    pub skills: Vec<SkillMetadata>,
6813}
6814
6815#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6816#[serde(rename_all = "camelCase")]
6817pub struct SkillsListParams {
6818    #[serde(default, skip_serializing_if = "Option::is_none")]
6819    pub cwds: Option<Vec<String>>,
6820    #[serde(
6821        rename = "forceReload",
6822        default,
6823        skip_serializing_if = "Option::is_none"
6824    )]
6825    pub force_reload: Option<bool>,
6826}
6827
6828#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6829#[serde(rename_all = "camelCase")]
6830pub struct SkillsListResponse {
6831    #[serde(default)]
6832    pub data: Vec<SkillsListEntry>,
6833}
6834
6835#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6836pub enum SortDirection {
6837    #[serde(rename = "asc")]
6838    Asc,
6839    #[serde(rename = "desc")]
6840    Desc,
6841}
6842
6843#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6844#[serde(rename_all = "camelCase")]
6845pub struct SpendControlLimitSnapshot {
6846    #[serde(default)]
6847    pub limit: String,
6848    #[serde(rename = "remainingPercent", default)]
6849    pub remaining_percent: i64,
6850    #[serde(rename = "resetsAt", default)]
6851    pub resets_at: i64,
6852    #[serde(default)]
6853    pub used: String,
6854}
6855
6856#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6857pub enum SubAgentActivityKind {
6858    #[serde(rename = "started")]
6859    Started,
6860    #[serde(rename = "interacted")]
6861    Interacted,
6862    #[serde(rename = "interrupted")]
6863    Interrupted,
6864    #[serde(rename = "completed")]
6865    Completed,
6866}
6867
6868#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6869pub enum SubAgentSource {
6870    #[serde(rename = "review")]
6871    Review,
6872    #[serde(rename = "compact")]
6873    Compact,
6874    #[serde(rename = "memory_consolidation")]
6875    MemoryConsolidation,
6876    #[serde(rename = "thread_spawn")]
6877    ThreadSpawn {
6878        #[serde(default, skip_serializing_if = "Option::is_none")]
6879        agent_nickname: Option<String>,
6880        #[serde(default, skip_serializing_if = "Option::is_none")]
6881        agent_path: Option<AgentPath>,
6882        #[serde(default, skip_serializing_if = "Option::is_none")]
6883        agent_role: Option<String>,
6884        depth: i64,
6885        parent_thread_id: ThreadId,
6886    },
6887    #[serde(rename = "other")]
6888    Other(String),
6889}
6890
6891#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6892#[serde(rename_all = "camelCase")]
6893pub struct SubagentMigration {
6894    #[serde(default)]
6895    pub name: String,
6896}
6897
6898#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6899#[serde(rename_all = "camelCase")]
6900pub struct TerminalInteractionNotification {
6901    #[serde(rename = "itemId", default)]
6902    pub item_id: String,
6903    #[serde(rename = "processId", default)]
6904    pub process_id: String,
6905    #[serde(default)]
6906    pub stdin: String,
6907    #[serde(rename = "threadId", default)]
6908    pub thread_id: String,
6909    #[serde(rename = "turnId", default)]
6910    pub turn_id: String,
6911}
6912
6913#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6914#[serde(rename_all = "camelCase")]
6915pub struct TextElement {
6916    #[serde(rename = "byteRange", default)]
6917    pub byte_range: Value,
6918    #[serde(default, skip_serializing_if = "Option::is_none")]
6919    pub placeholder: Option<String>,
6920}
6921
6922#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6923#[serde(rename_all = "camelCase")]
6924pub struct TextPosition {
6925    #[serde(default)]
6926    pub column: i64,
6927    #[serde(default)]
6928    pub line: i64,
6929}
6930
6931#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6932#[serde(rename_all = "camelCase")]
6933pub struct TextRange {
6934    #[serde()]
6935    pub end: TextPosition,
6936    #[serde()]
6937    pub start: TextPosition,
6938}
6939
6940#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6941#[serde(rename_all = "camelCase")]
6942pub struct Thread {
6943    #[serde(
6944        rename = "agentNickname",
6945        default,
6946        skip_serializing_if = "Option::is_none"
6947    )]
6948    pub agent_nickname: Option<String>,
6949    #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
6950    pub agent_role: Option<String>,
6951    #[serde(rename = "cliVersion", default)]
6952    pub cli_version: String,
6953    #[serde(rename = "createdAt", default)]
6954    pub created_at: i64,
6955    #[serde(default)]
6956    pub cwd: Value,
6957    #[serde(default)]
6958    pub ephemeral: bool,
6959    #[serde(
6960        rename = "forkedFromId",
6961        default,
6962        skip_serializing_if = "Option::is_none"
6963    )]
6964    pub forked_from_id: Option<String>,
6965    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
6966    pub git_info: Option<GitInfo>,
6967    /// Persisted history contract chosen at thread creation (0.148 upstream);
6968    /// absent on older servers, which are always `legacy`.
6969    #[serde(
6970        rename = "historyMode",
6971        default,
6972        skip_serializing_if = "Option::is_none"
6973    )]
6974    pub history_mode: Option<ThreadHistoryMode>,
6975    /// Canonical project assignment owned by app-server, if any. Required
6976    /// upstream from 0.147 but kept tolerant for pre-project servers.
6977    #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
6978    pub project_id: Option<String>,
6979    #[serde(default)]
6980    pub id: String,
6981    #[serde(rename = "modelProvider", default)]
6982    pub model_provider: String,
6983    #[serde(default, skip_serializing_if = "Option::is_none")]
6984    pub name: Option<String>,
6985    #[serde(
6986        rename = "parentThreadId",
6987        default,
6988        skip_serializing_if = "Option::is_none"
6989    )]
6990    pub parent_thread_id: Option<String>,
6991    #[serde(default, skip_serializing_if = "Option::is_none")]
6992    pub path: Option<String>,
6993    #[serde(default)]
6994    pub preview: String,
6995    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
6996    pub recency_at: Option<i64>,
6997    #[serde(default, skip_serializing_if = "Option::is_none")]
6998    pub section: Option<ThreadSection>,
6999    #[serde(
7000        rename = "sectionEnteredAt",
7001        default,
7002        skip_serializing_if = "Option::is_none"
7003    )]
7004    pub section_entered_at: Option<i64>,
7005    #[serde(rename = "sessionId", default)]
7006    pub session_id: String,
7007    #[serde(default)]
7008    pub source: Value,
7009    #[serde(default)]
7010    pub status: Value,
7011    #[serde(
7012        rename = "threadSource",
7013        default,
7014        skip_serializing_if = "Option::is_none"
7015    )]
7016    pub thread_source: Option<ThreadSource>,
7017    #[serde(default)]
7018    pub turns: Vec<Turn>,
7019    #[serde(rename = "updatedAt", default)]
7020    pub updated_at: i64,
7021}
7022
7023#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7024pub enum ThreadActiveFlag {
7025    #[serde(rename = "waitingOnApproval")]
7026    WaitingOnApproval,
7027    #[serde(rename = "waitingOnUserInput")]
7028    WaitingOnUserInput,
7029}
7030
7031#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7032#[serde(rename_all = "camelCase")]
7033pub struct ThreadApproveGuardianDeniedActionParams {
7034    #[serde(default)]
7035    pub event: Value,
7036    #[serde(rename = "threadId", default)]
7037    pub thread_id: String,
7038}
7039
7040#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7041#[serde(rename_all = "camelCase")]
7042pub struct ThreadApproveGuardianDeniedActionResponse {
7043    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7044    pub extra: serde_json::Map<String, Value>,
7045}
7046
7047#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7048#[serde(rename_all = "camelCase")]
7049pub struct ThreadArchiveParams {
7050    #[serde(rename = "threadId", default)]
7051    pub thread_id: String,
7052}
7053
7054#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7055#[serde(rename_all = "camelCase")]
7056pub struct ThreadArchiveResponse {
7057    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7058    pub extra: serde_json::Map<String, Value>,
7059}
7060
7061#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7062#[serde(rename_all = "camelCase")]
7063pub struct ThreadArchivedNotification {
7064    #[serde(rename = "threadId", default)]
7065    pub thread_id: String,
7066}
7067
7068#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7069#[serde(rename_all = "camelCase")]
7070pub struct ThreadClosedNotification {
7071    #[serde(rename = "threadId", default)]
7072    pub thread_id: String,
7073}
7074
7075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7076#[serde(rename_all = "camelCase")]
7077pub struct ThreadCompactStartParams {
7078    #[serde(rename = "threadId", default)]
7079    pub thread_id: String,
7080}
7081
7082#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7083#[serde(rename_all = "camelCase")]
7084pub struct ThreadCompactStartResponse {
7085    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7086    pub extra: serde_json::Map<String, Value>,
7087}
7088
7089#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7090#[serde(rename_all = "camelCase")]
7091pub struct ThreadDeleteParams {
7092    #[serde(rename = "threadId", default)]
7093    pub thread_id: String,
7094}
7095
7096#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7097#[serde(rename_all = "camelCase")]
7098pub struct ThreadDeleteResponse {
7099    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7100    pub extra: serde_json::Map<String, Value>,
7101}
7102
7103#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7104#[serde(rename_all = "camelCase")]
7105pub struct ThreadDeletedNotification {
7106    #[serde(rename = "threadId", default)]
7107    pub thread_id: String,
7108}
7109
7110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7111#[serde(rename_all = "camelCase")]
7112pub struct ThreadForkParams {
7113    #[serde(
7114        rename = "approvalPolicy",
7115        default,
7116        skip_serializing_if = "Option::is_none"
7117    )]
7118    pub approval_policy: Option<AskForApproval>,
7119    #[serde(
7120        rename = "approvalsReviewer",
7121        default,
7122        skip_serializing_if = "Option::is_none"
7123    )]
7124    pub approvals_reviewer: Option<ApprovalsReviewer>,
7125    #[serde(
7126        rename = "baseInstructions",
7127        default,
7128        skip_serializing_if = "Option::is_none"
7129    )]
7130    pub base_instructions: Option<String>,
7131    #[serde(default, skip_serializing_if = "Option::is_none")]
7132    pub config: Option<Value>,
7133    #[serde(default, skip_serializing_if = "Option::is_none")]
7134    pub cwd: Option<String>,
7135    #[serde(
7136        rename = "developerInstructions",
7137        default,
7138        skip_serializing_if = "Option::is_none"
7139    )]
7140    pub developer_instructions: Option<String>,
7141    #[serde(default, skip_serializing_if = "Option::is_none")]
7142    pub ephemeral: Option<bool>,
7143    #[serde(
7144        rename = "excludeTurns",
7145        default,
7146        skip_serializing_if = "Option::is_none"
7147    )]
7148    pub exclude_turns: Option<bool>,
7149    #[serde(
7150        rename = "lastTurnId",
7151        default,
7152        skip_serializing_if = "Option::is_none"
7153    )]
7154    pub last_turn_id: Option<String>,
7155    #[serde(default, skip_serializing_if = "Option::is_none")]
7156    pub model: Option<String>,
7157    #[serde(
7158        rename = "modelProvider",
7159        default,
7160        skip_serializing_if = "Option::is_none"
7161    )]
7162    pub model_provider: Option<String>,
7163    #[serde(default, skip_serializing_if = "Option::is_none")]
7164    pub sandbox: Option<SandboxMode>,
7165    #[serde(
7166        rename = "serviceTier",
7167        default,
7168        skip_serializing_if = "Option::is_none"
7169    )]
7170    pub service_tier: Option<String>,
7171    #[serde(rename = "threadId", default)]
7172    pub thread_id: String,
7173    #[serde(
7174        rename = "threadSource",
7175        default,
7176        skip_serializing_if = "Option::is_none"
7177    )]
7178    pub thread_source: Option<ThreadSource>,
7179}
7180
7181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7182#[serde(rename_all = "camelCase")]
7183pub struct ThreadForkResponse {
7184    #[serde(rename = "approvalPolicy")]
7185    pub approval_policy: AskForApproval,
7186    #[serde(rename = "approvalsReviewer", default)]
7187    pub approvals_reviewer: Value,
7188    #[serde()]
7189    pub cwd: AbsolutePathBuf,
7190    #[serde(
7191        rename = "instructionSources",
7192        default,
7193        skip_serializing_if = "Option::is_none"
7194    )]
7195    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
7196    #[serde(default)]
7197    pub model: String,
7198    #[serde(rename = "modelProvider", default)]
7199    pub model_provider: String,
7200    #[serde(
7201        rename = "reasoningEffort",
7202        default,
7203        skip_serializing_if = "Option::is_none"
7204    )]
7205    pub reasoning_effort: Option<ReasoningEffort>,
7206    #[serde(default)]
7207    pub sandbox: Value,
7208    #[serde(
7209        rename = "serviceTier",
7210        default,
7211        skip_serializing_if = "Option::is_none"
7212    )]
7213    pub service_tier: Option<String>,
7214    #[serde()]
7215    pub thread: Thread,
7216}
7217
7218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7219#[serde(rename_all = "camelCase")]
7220pub struct ThreadGoal {
7221    #[serde(rename = "createdAt", default)]
7222    pub created_at: i64,
7223    #[serde(default)]
7224    pub objective: String,
7225    #[serde()]
7226    pub status: ThreadGoalStatus,
7227    #[serde(rename = "threadId", default)]
7228    pub thread_id: String,
7229    #[serde(rename = "timeUsedSeconds", default)]
7230    pub time_used_seconds: i64,
7231    #[serde(
7232        rename = "tokenBudget",
7233        default,
7234        skip_serializing_if = "Option::is_none"
7235    )]
7236    pub token_budget: Option<i64>,
7237    #[serde(rename = "tokensUsed", default)]
7238    pub tokens_used: i64,
7239    #[serde(rename = "updatedAt", default)]
7240    pub updated_at: i64,
7241}
7242
7243#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7244#[serde(rename_all = "camelCase")]
7245pub struct ThreadGoalClearParams {
7246    #[serde(rename = "threadId", default)]
7247    pub thread_id: String,
7248}
7249
7250#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7251#[serde(rename_all = "camelCase")]
7252pub struct ThreadGoalClearResponse {
7253    #[serde(default)]
7254    pub cleared: bool,
7255}
7256
7257#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7258#[serde(rename_all = "camelCase")]
7259pub struct ThreadGoalClearedNotification {
7260    #[serde(rename = "threadId", default)]
7261    pub thread_id: String,
7262}
7263
7264#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7265#[serde(rename_all = "camelCase")]
7266pub struct ThreadGoalGetParams {
7267    #[serde(rename = "threadId", default)]
7268    pub thread_id: String,
7269}
7270
7271#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7272#[serde(rename_all = "camelCase")]
7273pub struct ThreadGoalGetResponse {
7274    #[serde(default, skip_serializing_if = "Option::is_none")]
7275    pub goal: Option<ThreadGoal>,
7276}
7277
7278#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7279#[serde(rename_all = "camelCase")]
7280pub struct ThreadGoalSetParams {
7281    #[serde(default, skip_serializing_if = "Option::is_none")]
7282    pub objective: Option<String>,
7283    #[serde(default, skip_serializing_if = "Option::is_none")]
7284    pub status: Option<ThreadGoalStatus>,
7285    #[serde(rename = "threadId", default)]
7286    pub thread_id: String,
7287    #[serde(
7288        rename = "tokenBudget",
7289        default,
7290        skip_serializing_if = "Option::is_none"
7291    )]
7292    pub token_budget: Option<i64>,
7293}
7294
7295#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7296#[serde(rename_all = "camelCase")]
7297pub struct ThreadGoalSetResponse {
7298    #[serde()]
7299    pub goal: ThreadGoal,
7300}
7301
7302#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7303pub enum ThreadGoalStatus {
7304    #[serde(rename = "active")]
7305    Active,
7306    #[serde(rename = "paused")]
7307    Paused,
7308    #[serde(rename = "blocked")]
7309    Blocked,
7310    #[serde(rename = "usageLimited")]
7311    UsageLimited,
7312    #[serde(rename = "budgetLimited")]
7313    BudgetLimited,
7314    #[serde(rename = "complete")]
7315    Complete,
7316}
7317
7318#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7319#[serde(rename_all = "camelCase")]
7320pub struct ThreadGoalUpdatedNotification {
7321    #[serde()]
7322    pub goal: ThreadGoal,
7323    #[serde(rename = "threadId", default)]
7324    pub thread_id: String,
7325    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
7326    pub turn_id: Option<String>,
7327}
7328
7329#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
7330#[serde(transparent)]
7331pub struct ThreadId(pub String);
7332
7333#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7334#[serde(rename_all = "camelCase")]
7335pub struct ThreadInjectItemsParams {
7336    #[serde(default)]
7337    pub items: Vec<Value>,
7338    #[serde(rename = "threadId", default)]
7339    pub thread_id: String,
7340}
7341
7342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7343#[serde(rename_all = "camelCase")]
7344pub struct ThreadInjectItemsResponse {
7345    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7346    pub extra: serde_json::Map<String, Value>,
7347}
7348
7349#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7350#[serde(tag = "type", rename_all = "camelCase")]
7351pub enum ThreadItem {
7352    #[serde(rename = "userMessage")]
7353    UserMessage {
7354        #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
7355        client_id: Option<String>,
7356        content: Vec<UserInput>,
7357        id: String,
7358    },
7359    #[serde(rename = "hookPrompt")]
7360    HookPrompt {
7361        fragments: Vec<HookPromptFragment>,
7362        id: String,
7363    },
7364    #[serde(rename = "agentMessage")]
7365    AgentMessage {
7366        #[serde(default, skip_serializing_if = "Option::is_none")]
7367        delivery: Option<AgentMessageDelivery>,
7368        id: String,
7369        #[serde(
7370            rename = "memoryCitation",
7371            default,
7372            skip_serializing_if = "Option::is_none"
7373        )]
7374        memory_citation: Option<MemoryCitation>,
7375        #[serde(default, skip_serializing_if = "Option::is_none")]
7376        phase: Option<MessagePhase>,
7377        text: String,
7378    },
7379    Plan {
7380        id: String,
7381        text: String,
7382    },
7383    Reasoning {
7384        #[serde(default, skip_serializing_if = "Option::is_none")]
7385        content: Option<Vec<String>>,
7386        id: String,
7387        #[serde(default, skip_serializing_if = "Option::is_none")]
7388        summary: Option<Vec<String>>,
7389    },
7390    #[serde(rename = "commandExecution")]
7391    CommandExecution {
7392        #[serde(
7393            rename = "aggregatedOutput",
7394            default,
7395            skip_serializing_if = "Option::is_none"
7396        )]
7397        aggregated_output: Option<String>,
7398        command: String,
7399        #[serde(rename = "commandActions")]
7400        command_actions: Vec<CommandAction>,
7401        cwd: Value,
7402        #[serde(
7403            rename = "durationMs",
7404            default,
7405            skip_serializing_if = "Option::is_none"
7406        )]
7407        duration_ms: Option<i64>,
7408        #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
7409        exit_code: Option<i64>,
7410        id: String,
7411        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7412        plugin_id: Option<String>,
7413        #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
7414        process_id: Option<String>,
7415        #[serde(
7416            rename = "scriptPath",
7417            default,
7418            skip_serializing_if = "Option::is_none"
7419        )]
7420        script_path: Option<String>,
7421        #[serde(default, skip_serializing_if = "Option::is_none")]
7422        source: Option<Value>,
7423        status: CommandExecutionStatus,
7424    },
7425    #[serde(rename = "fileChange")]
7426    FileChange {
7427        changes: Vec<FileUpdateChange>,
7428        id: String,
7429        status: PatchApplyStatus,
7430    },
7431    #[serde(rename = "mcpToolCall")]
7432    McpToolCall {
7433        #[serde(
7434            rename = "appContext",
7435            default,
7436            skip_serializing_if = "Option::is_none"
7437        )]
7438        app_context: Option<McpToolCallAppContext>,
7439        arguments: Value,
7440        #[serde(
7441            rename = "durationMs",
7442            default,
7443            skip_serializing_if = "Option::is_none"
7444        )]
7445        duration_ms: Option<i64>,
7446        #[serde(default, skip_serializing_if = "Option::is_none")]
7447        error: Option<McpToolCallError>,
7448        id: String,
7449        #[serde(
7450            rename = "mcpAppResourceUri",
7451            default,
7452            skip_serializing_if = "Option::is_none"
7453        )]
7454        mcp_app_resource_uri: Option<String>,
7455        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7456        plugin_id: Option<String>,
7457        #[serde(
7458            rename = "readOnlyHint",
7459            default,
7460            skip_serializing_if = "Option::is_none"
7461        )]
7462        read_only_hint: Option<bool>,
7463        #[serde(default, skip_serializing_if = "Option::is_none")]
7464        result: Option<McpToolCallResult>,
7465        server: String,
7466        status: McpToolCallStatus,
7467        tool: String,
7468    },
7469    #[serde(rename = "dynamicToolCall")]
7470    DynamicToolCall {
7471        arguments: Value,
7472        #[serde(
7473            rename = "contentItems",
7474            default,
7475            skip_serializing_if = "Option::is_none"
7476        )]
7477        content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
7478        #[serde(
7479            rename = "durationMs",
7480            default,
7481            skip_serializing_if = "Option::is_none"
7482        )]
7483        duration_ms: Option<i64>,
7484        id: String,
7485        #[serde(default, skip_serializing_if = "Option::is_none")]
7486        namespace: Option<String>,
7487        status: DynamicToolCallStatus,
7488        #[serde(default, skip_serializing_if = "Option::is_none")]
7489        success: Option<bool>,
7490        tool: String,
7491    },
7492    #[serde(rename = "collabAgentToolCall")]
7493    CollabAgentToolCall {
7494        #[serde(rename = "agentsStates")]
7495        agents_states: std::collections::BTreeMap<String, CollabAgentState>,
7496        id: String,
7497        #[serde(default, skip_serializing_if = "Option::is_none")]
7498        model: Option<String>,
7499        #[serde(default, skip_serializing_if = "Option::is_none")]
7500        prompt: Option<String>,
7501        #[serde(
7502            rename = "reasoningEffort",
7503            default,
7504            skip_serializing_if = "Option::is_none"
7505        )]
7506        reasoning_effort: Option<ReasoningEffort>,
7507        #[serde(rename = "receiverThreadIds")]
7508        receiver_thread_ids: Vec<String>,
7509        #[serde(rename = "senderThreadId")]
7510        sender_thread_id: String,
7511        status: Value,
7512        tool: Value,
7513    },
7514    #[serde(rename = "subAgentActivity")]
7515    SubAgentActivity {
7516        #[serde(rename = "agentPath")]
7517        agent_path: String,
7518        #[serde(rename = "agentThreadId")]
7519        agent_thread_id: String,
7520        id: String,
7521        kind: SubAgentActivityKind,
7522    },
7523    #[serde(rename = "webSearch")]
7524    WebSearch {
7525        #[serde(default, skip_serializing_if = "Option::is_none")]
7526        action: Option<WebSearchAction>,
7527        id: String,
7528        query: String,
7529        #[serde(default, skip_serializing_if = "Option::is_none")]
7530        results: Option<Vec<Value>>,
7531    },
7532    #[serde(rename = "imageView")]
7533    ImageView {
7534        id: String,
7535        path: LegacyAppPathString,
7536    },
7537    Sleep {
7538        #[serde(rename = "durationMs")]
7539        duration_ms: i64,
7540        id: String,
7541    },
7542    #[serde(rename = "imageGeneration")]
7543    ImageGeneration {
7544        #[serde(default, skip_serializing_if = "Option::is_none")]
7545        failure: Option<ImageGenerationFailure>,
7546        id: String,
7547        result: String,
7548        #[serde(
7549            rename = "revisedPrompt",
7550            default,
7551            skip_serializing_if = "Option::is_none"
7552        )]
7553        revised_prompt: Option<String>,
7554        #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
7555        saved_path: Option<AbsolutePathBuf>,
7556        status: String,
7557        #[serde(
7558            rename = "transparentBackground",
7559            default,
7560            skip_serializing_if = "Option::is_none"
7561        )]
7562        transparent_background: Option<bool>,
7563    },
7564    #[serde(rename = "enteredReviewMode")]
7565    EnteredReviewMode {
7566        id: String,
7567        review: String,
7568    },
7569    #[serde(rename = "exitedReviewMode")]
7570    ExitedReviewMode {
7571        id: String,
7572        review: String,
7573    },
7574    #[serde(rename = "contextCompaction")]
7575    ContextCompaction {
7576        id: String,
7577    },
7578    #[serde(rename = "functionCallOutput")]
7579    FunctionCallOutput {
7580        id: String,
7581        name: String,
7582        #[serde(default, skip_serializing_if = "Option::is_none")]
7583        namespace: Option<String>,
7584        output: FunctionCallOutputBody,
7585    },
7586}
7587
7588#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7589#[serde(untagged)]
7590pub enum ThreadListCwdFilter {
7591    Variant0(String),
7592    Variant1(Vec<String>),
7593}
7594
7595#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7596#[serde(rename_all = "camelCase")]
7597pub struct ThreadListParams {
7598    #[serde(default, skip_serializing_if = "Option::is_none")]
7599    pub archived: Option<bool>,
7600    #[serde(default, skip_serializing_if = "Option::is_none")]
7601    pub cursor: Option<String>,
7602    #[serde(default, skip_serializing_if = "Option::is_none")]
7603    pub cwd: Option<ThreadListCwdFilter>,
7604    #[serde(default, skip_serializing_if = "Option::is_none")]
7605    pub limit: Option<i64>,
7606    #[serde(
7607        rename = "modelProviders",
7608        default,
7609        skip_serializing_if = "Option::is_none"
7610    )]
7611    pub model_providers: Option<Vec<String>>,
7612    #[serde(
7613        rename = "searchTerm",
7614        default,
7615        skip_serializing_if = "Option::is_none"
7616    )]
7617    pub search_term: Option<String>,
7618    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
7619    pub section_id: Option<String>,
7620    #[serde(
7621        rename = "sortDirection",
7622        default,
7623        skip_serializing_if = "Option::is_none"
7624    )]
7625    pub sort_direction: Option<SortDirection>,
7626    #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
7627    pub sort_key: Option<ThreadSortKey>,
7628    #[serde(
7629        rename = "sourceKinds",
7630        default,
7631        skip_serializing_if = "Option::is_none"
7632    )]
7633    pub source_kinds: Option<Vec<ThreadSourceKind>>,
7634    #[serde(
7635        rename = "useStateDbOnly",
7636        default,
7637        skip_serializing_if = "Option::is_none"
7638    )]
7639    pub use_state_db_only: Option<bool>,
7640}
7641
7642#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7643#[serde(rename_all = "camelCase")]
7644pub struct ThreadListResponse {
7645    #[serde(
7646        rename = "backwardsCursor",
7647        default,
7648        skip_serializing_if = "Option::is_none"
7649    )]
7650    pub backwards_cursor: Option<String>,
7651    #[serde(default)]
7652    pub data: Vec<Thread>,
7653    #[serde(
7654        rename = "nextCursor",
7655        default,
7656        skip_serializing_if = "Option::is_none"
7657    )]
7658    pub next_cursor: Option<String>,
7659}
7660
7661#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7662#[serde(rename_all = "camelCase")]
7663pub struct ThreadLoadedListParams {
7664    #[serde(default, skip_serializing_if = "Option::is_none")]
7665    pub cursor: Option<String>,
7666    #[serde(default, skip_serializing_if = "Option::is_none")]
7667    pub limit: Option<i64>,
7668}
7669
7670#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7671#[serde(rename_all = "camelCase")]
7672pub struct ThreadLoadedListResponse {
7673    #[serde(default)]
7674    pub data: Vec<String>,
7675    #[serde(
7676        rename = "nextCursor",
7677        default,
7678        skip_serializing_if = "Option::is_none"
7679    )]
7680    pub next_cursor: Option<String>,
7681}
7682
7683#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7684#[serde(rename_all = "camelCase")]
7685pub struct ThreadMetadataGitInfoUpdateParams {
7686    #[serde(default, skip_serializing_if = "Option::is_none")]
7687    pub branch: Option<String>,
7688    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
7689    pub origin_url: Option<String>,
7690    #[serde(default, skip_serializing_if = "Option::is_none")]
7691    pub sha: Option<String>,
7692}
7693
7694#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7695#[serde(rename_all = "camelCase")]
7696pub struct ThreadMetadataUpdateParams {
7697    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
7698    pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
7699    #[serde(rename = "threadId", default)]
7700    pub thread_id: String,
7701}
7702
7703#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7704#[serde(rename_all = "camelCase")]
7705pub struct ThreadMetadataUpdateResponse {
7706    #[serde()]
7707    pub thread: Thread,
7708}
7709
7710#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7711#[serde(rename_all = "camelCase")]
7712pub struct ThreadNameUpdatedNotification {
7713    #[serde(rename = "threadId", default)]
7714    pub thread_id: String,
7715    #[serde(
7716        rename = "threadName",
7717        default,
7718        skip_serializing_if = "Option::is_none"
7719    )]
7720    pub thread_name: Option<String>,
7721}
7722
7723#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7724#[serde(rename_all = "camelCase")]
7725pub struct ThreadReadParams {
7726    #[serde(
7727        rename = "includeTurns",
7728        default,
7729        skip_serializing_if = "Option::is_none"
7730    )]
7731    pub include_turns: Option<bool>,
7732    #[serde(rename = "threadId", default)]
7733    pub thread_id: String,
7734}
7735
7736#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7737#[serde(rename_all = "camelCase")]
7738pub struct ThreadReadResponse {
7739    #[serde()]
7740    pub thread: Thread,
7741}
7742
7743#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7744#[serde(rename_all = "camelCase")]
7745pub struct ThreadRealtimeAudioChunk {
7746    #[serde(default)]
7747    pub data: String,
7748    #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
7749    pub item_id: Option<String>,
7750    #[serde(rename = "numChannels", default)]
7751    pub num_channels: i64,
7752    #[serde(rename = "sampleRate", default)]
7753    pub sample_rate: i64,
7754    #[serde(
7755        rename = "samplesPerChannel",
7756        default,
7757        skip_serializing_if = "Option::is_none"
7758    )]
7759    pub samples_per_channel: Option<i64>,
7760}
7761
7762#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7763#[serde(rename_all = "camelCase")]
7764pub struct ThreadRealtimeClosedNotification {
7765    #[serde(default, skip_serializing_if = "Option::is_none")]
7766    pub reason: Option<String>,
7767    #[serde(rename = "threadId", default)]
7768    pub thread_id: String,
7769}
7770
7771#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7772#[serde(rename_all = "camelCase")]
7773pub struct ThreadRealtimeErrorNotification {
7774    #[serde(default)]
7775    pub message: String,
7776    #[serde(rename = "threadId", default)]
7777    pub thread_id: String,
7778}
7779
7780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7781#[serde(rename_all = "camelCase")]
7782pub struct ThreadRealtimeItemAddedNotification {
7783    #[serde(default)]
7784    pub item: Value,
7785    #[serde(rename = "threadId", default)]
7786    pub thread_id: String,
7787}
7788
7789#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7790#[serde(rename_all = "camelCase")]
7791pub struct ThreadRealtimeOutputAudioDeltaNotification {
7792    #[serde()]
7793    pub audio: ThreadRealtimeAudioChunk,
7794    #[serde(rename = "threadId", default)]
7795    pub thread_id: String,
7796}
7797
7798#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7799#[serde(rename_all = "camelCase")]
7800pub struct ThreadRealtimeSdpNotification {
7801    #[serde(default)]
7802    pub sdp: String,
7803    #[serde(rename = "threadId", default)]
7804    pub thread_id: String,
7805}
7806
7807#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7808#[serde(rename_all = "camelCase")]
7809pub struct ThreadRealtimeStartedNotification {
7810    #[serde(
7811        rename = "realtimeSessionId",
7812        default,
7813        skip_serializing_if = "Option::is_none"
7814    )]
7815    pub realtime_session_id: Option<String>,
7816    #[serde(rename = "threadId", default)]
7817    pub thread_id: String,
7818    #[serde()]
7819    pub version: RealtimeConversationVersion,
7820}
7821
7822#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7823#[serde(rename_all = "camelCase")]
7824pub struct ThreadRealtimeTranscriptDeltaNotification {
7825    #[serde(default)]
7826    pub delta: String,
7827    #[serde(default)]
7828    pub role: String,
7829    #[serde(rename = "threadId", default)]
7830    pub thread_id: String,
7831}
7832
7833#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7834#[serde(rename_all = "camelCase")]
7835pub struct ThreadRealtimeTranscriptDoneNotification {
7836    #[serde(default)]
7837    pub role: String,
7838    #[serde(default)]
7839    pub text: String,
7840    #[serde(rename = "threadId", default)]
7841    pub thread_id: String,
7842}
7843
7844#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7845#[serde(rename_all = "camelCase")]
7846pub struct ThreadResumeParams {
7847    #[serde(
7848        rename = "approvalPolicy",
7849        default,
7850        skip_serializing_if = "Option::is_none"
7851    )]
7852    pub approval_policy: Option<AskForApproval>,
7853    #[serde(
7854        rename = "approvalsReviewer",
7855        default,
7856        skip_serializing_if = "Option::is_none"
7857    )]
7858    pub approvals_reviewer: Option<ApprovalsReviewer>,
7859    #[serde(
7860        rename = "baseInstructions",
7861        default,
7862        skip_serializing_if = "Option::is_none"
7863    )]
7864    pub base_instructions: Option<String>,
7865    #[serde(default, skip_serializing_if = "Option::is_none")]
7866    pub config: Option<Value>,
7867    #[serde(default, skip_serializing_if = "Option::is_none")]
7868    pub cwd: Option<String>,
7869    #[serde(
7870        rename = "developerInstructions",
7871        default,
7872        skip_serializing_if = "Option::is_none"
7873    )]
7874    pub developer_instructions: Option<String>,
7875    #[serde(default, skip_serializing_if = "Option::is_none")]
7876    pub model: Option<String>,
7877    #[serde(
7878        rename = "modelProvider",
7879        default,
7880        skip_serializing_if = "Option::is_none"
7881    )]
7882    pub model_provider: Option<String>,
7883    #[serde(default, skip_serializing_if = "Option::is_none")]
7884    pub personality: Option<Personality>,
7885    #[serde(default, skip_serializing_if = "Option::is_none")]
7886    pub sandbox: Option<SandboxMode>,
7887    #[serde(
7888        rename = "serviceTier",
7889        default,
7890        skip_serializing_if = "Option::is_none"
7891    )]
7892    pub service_tier: Option<String>,
7893    #[serde(rename = "threadId", default)]
7894    pub thread_id: String,
7895    #[serde(
7896        rename = "excludeTurns",
7897        default,
7898        skip_serializing_if = "Option::is_none"
7899    )]
7900    pub exclude_turns: Option<bool>,
7901}
7902
7903#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7904#[serde(rename_all = "camelCase")]
7905pub struct ThreadResumeResponse {
7906    #[serde(rename = "approvalPolicy")]
7907    pub approval_policy: AskForApproval,
7908    #[serde(rename = "approvalsReviewer", default)]
7909    pub approvals_reviewer: Value,
7910    #[serde()]
7911    pub cwd: AbsolutePathBuf,
7912    #[serde(
7913        rename = "instructionSources",
7914        default,
7915        skip_serializing_if = "Option::is_none"
7916    )]
7917    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
7918    /// Cursor for hydrating paginated items backwards via `thread/items/list`
7919    /// with `sortDirection: "desc"` (0.148 upstream).
7920    #[serde(
7921        rename = "itemsBackwardsCursor",
7922        default,
7923        skip_serializing_if = "Option::is_none"
7924    )]
7925    pub items_backwards_cursor: Option<String>,
7926    #[serde(default)]
7927    pub model: String,
7928    #[serde(rename = "modelProvider", default)]
7929    pub model_provider: String,
7930    #[serde(
7931        rename = "reasoningEffort",
7932        default,
7933        skip_serializing_if = "Option::is_none"
7934    )]
7935    pub reasoning_effort: Option<ReasoningEffort>,
7936    #[serde(default)]
7937    pub sandbox: Value,
7938    #[serde(
7939        rename = "serviceTier",
7940        default,
7941        skip_serializing_if = "Option::is_none"
7942    )]
7943    pub service_tier: Option<String>,
7944    #[serde()]
7945    pub thread: Thread,
7946    /// Cursor for hydrating paginated turns backwards via `thread/turns/list`
7947    /// with `sortDirection: "desc"` (0.148 upstream).
7948    #[serde(
7949        rename = "turnsBackwardsCursor",
7950        default,
7951        skip_serializing_if = "Option::is_none"
7952    )]
7953    pub turns_backwards_cursor: Option<String>,
7954}
7955
7956/// Persisted thread history contract (0.148 upstream).
7957#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7958pub enum ThreadHistoryMode {
7959    #[serde(rename = "legacy")]
7960    Legacy,
7961    #[serde(rename = "paginated")]
7962    Paginated,
7963}
7964
7965/// One item plus the turn that contains it, as returned by
7966/// `thread/items/list` (0.148 upstream).
7967#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7968#[serde(rename_all = "camelCase")]
7969pub struct ThreadItemEntry {
7970    #[serde()]
7971    pub item: ThreadItem,
7972    #[serde(rename = "turnId", default)]
7973    pub turn_id: String,
7974}
7975
7976/// Params for `thread/items/list` — paginated item hydration (0.148 upstream).
7977#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7978#[serde(rename_all = "camelCase")]
7979pub struct ThreadItemsListParams {
7980    #[serde(default, skip_serializing_if = "Option::is_none")]
7981    pub cursor: Option<String>,
7982    #[serde(default, skip_serializing_if = "Option::is_none")]
7983    pub limit: Option<u32>,
7984    #[serde(
7985        rename = "sortDirection",
7986        default,
7987        skip_serializing_if = "Option::is_none"
7988    )]
7989    pub sort_direction: Option<SortDirection>,
7990    #[serde(rename = "threadId", default)]
7991    pub thread_id: String,
7992    /// Optional turn id filter; omitted returns items across the thread.
7993    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
7994    pub turn_id: Option<String>,
7995}
7996
7997/// Response to `thread/items/list` (0.148 upstream).
7998#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7999#[serde(rename_all = "camelCase")]
8000pub struct ThreadItemsListResponse {
8001    #[serde(
8002        rename = "backwardsCursor",
8003        default,
8004        skip_serializing_if = "Option::is_none"
8005    )]
8006    pub backwards_cursor: Option<String>,
8007    #[serde(default)]
8008    pub data: Vec<ThreadItemEntry>,
8009    #[serde(
8010        rename = "nextCursor",
8011        default,
8012        skip_serializing_if = "Option::is_none"
8013    )]
8014    pub next_cursor: Option<String>,
8015}
8016
8017/// EXPERIMENTAL upstream — a thread-scoped realtime item in the canonical
8018/// timeline (0.148). Top-level identity fields are camelCase on the wire
8019/// while variant payload fields are snake_case; mirrored exactly.
8020#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8021pub struct ThreadRealtimeItem {
8022    #[serde(default)]
8023    pub id: String,
8024    #[serde(rename = "realtimeSessionId", default)]
8025    pub realtime_session_id: String,
8026    #[serde(flatten)]
8027    pub detail: ThreadRealtimeItemDetail,
8028}
8029
8030/// The `type`-tagged payload of a [`ThreadRealtimeItem`].
8031#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8032#[serde(tag = "type", rename_all = "camelCase")]
8033pub enum ThreadRealtimeItemDetail {
8034    #[serde(rename = "realtimeSessionStarted")]
8035    RealtimeSessionStarted,
8036    #[serde(rename = "transcriptSegment")]
8037    TranscriptSegment {
8038        role: ThreadRealtimeTranscriptRole,
8039        text: String,
8040    },
8041    #[serde(rename = "bemItemPromoted")]
8042    BemItemPromoted {
8043        item_id: String,
8044        presentation: ThreadRealtimeBemItemPresentation,
8045        turn_id: String,
8046    },
8047    #[serde(rename = "realtimeSessionClosed")]
8048    RealtimeSessionClosed {
8049        outcome: ThreadRealtimeSessionOutcome,
8050    },
8051}
8052
8053/// EXPERIMENTAL upstream — how an existing agent item appears in a realtime
8054/// conversation (0.148).
8055#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8056#[serde(tag = "type", rename_all = "camelCase")]
8057pub enum ThreadRealtimeBemItemPresentation {
8058    #[serde(rename = "wholeItem")]
8059    WholeItem,
8060    #[serde(rename = "inlineMarkdown")]
8061    InlineMarkdown,
8062    #[serde(rename = "inlineVisualization")]
8063    InlineVisualization { index: u32 },
8064}
8065
8066/// EXPERIMENTAL upstream — `thread/realtime/item/started` params (0.148).
8067#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8068#[serde(rename_all = "camelCase")]
8069pub struct ThreadRealtimeItemStartedNotification {
8070    #[serde()]
8071    pub item: ThreadRealtimeItem,
8072    #[serde(rename = "threadId", default)]
8073    pub thread_id: String,
8074}
8075
8076/// EXPERIMENTAL upstream — `thread/realtime/item/completed` params (0.148).
8077#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8078#[serde(rename_all = "camelCase")]
8079pub struct ThreadRealtimeItemCompletedNotification {
8080    #[serde()]
8081    pub item: ThreadRealtimeItem,
8082    #[serde(rename = "threadId", default)]
8083    pub thread_id: String,
8084}
8085
8086/// EXPERIMENTAL upstream — `thread/realtime/item/transcript/delta` params:
8087/// text appended to an active realtime transcript item (0.148).
8088#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8089#[serde(rename_all = "camelCase")]
8090pub struct ThreadRealtimeItemTranscriptDeltaNotification {
8091    #[serde(default)]
8092    pub delta: String,
8093    #[serde(rename = "itemId", default)]
8094    pub item_id: String,
8095    #[serde(rename = "threadId", default)]
8096    pub thread_id: String,
8097}
8098
8099/// EXPERIMENTAL upstream — outcome of a closed realtime session (0.148).
8100#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8101pub enum ThreadRealtimeSessionOutcome {
8102    #[serde(rename = "ended")]
8103    Ended,
8104    #[serde(rename = "failed")]
8105    Failed,
8106}
8107
8108/// EXPERIMENTAL upstream — speaker role in a realtime transcript (0.148).
8109#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8110pub enum ThreadRealtimeTranscriptRole {
8111    #[serde(rename = "user")]
8112    User,
8113    #[serde(rename = "assistant")]
8114    Assistant,
8115}
8116
8117/// Params for `thread/revert` — replace a paginated thread's durable history
8118/// with the prefix before one turn; local file changes are untouched
8119/// (0.148 upstream).
8120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8121#[serde(rename_all = "camelCase")]
8122pub struct ThreadRevertParams {
8123    /// Turn excluded from the replacement history, with every later turn.
8124    #[serde(rename = "beforeTurnId", default)]
8125    pub before_turn_id: String,
8126    #[serde(rename = "threadId", default)]
8127    pub thread_id: String,
8128}
8129
8130/// Response to `thread/revert` (0.148 upstream). `thread.turns` is always
8131/// empty; retained history hydrates through `thread/turns/list`.
8132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8133#[serde(rename_all = "camelCase")]
8134pub struct ThreadRevertResponse {
8135    #[serde(
8136        rename = "itemsBackwardsCursor",
8137        default,
8138        skip_serializing_if = "Option::is_none"
8139    )]
8140    pub items_backwards_cursor: Option<String>,
8141    #[serde()]
8142    pub thread: Thread,
8143    #[serde(
8144        rename = "turnsBackwardsCursor",
8145        default,
8146        skip_serializing_if = "Option::is_none"
8147    )]
8148    pub turns_backwards_cursor: Option<String>,
8149}
8150
8151#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8152#[serde(rename_all = "camelCase")]
8153pub struct ThreadRollbackParams {
8154    #[serde(rename = "numTurns", default)]
8155    pub num_turns: i64,
8156    #[serde(rename = "threadId", default)]
8157    pub thread_id: String,
8158}
8159
8160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8161#[serde(rename_all = "camelCase")]
8162pub struct ThreadRollbackResponse {
8163    #[serde(default)]
8164    pub thread: Value,
8165}
8166
8167#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8168#[serde(rename_all = "camelCase")]
8169pub struct ThreadSection {
8170    #[serde(default, skip_serializing_if = "Option::is_none")]
8171    pub appearance: Option<ThreadSectionAppearance>,
8172    #[serde(default)]
8173    pub id: String,
8174    #[serde(default)]
8175    pub name: String,
8176}
8177
8178#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8179#[serde(rename_all = "camelCase")]
8180pub struct ThreadSectionAppearance {
8181    #[serde(default, skip_serializing_if = "Option::is_none")]
8182    pub color: Option<String>,
8183    #[serde(default, skip_serializing_if = "Option::is_none")]
8184    pub icon: Option<String>,
8185}
8186
8187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8188#[serde(rename_all = "camelCase")]
8189pub struct ThreadSectionCreateParams {
8190    #[serde(default, skip_serializing_if = "Option::is_none")]
8191    pub appearance: Option<ThreadSectionAppearance>,
8192    #[serde(default)]
8193    pub name: String,
8194}
8195
8196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8197#[serde(rename_all = "camelCase")]
8198pub struct ThreadSectionCreateResponse {
8199    #[serde()]
8200    pub section: ThreadSection,
8201}
8202
8203#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8204#[serde(rename_all = "camelCase")]
8205pub struct ThreadSectionDeleteParams {
8206    #[serde(rename = "sectionId", default)]
8207    pub section_id: String,
8208}
8209
8210#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8211#[serde(rename_all = "camelCase")]
8212pub struct ThreadSectionDeleteResponse {
8213    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8214    pub extra: serde_json::Map<String, Value>,
8215}
8216
8217#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8218#[serde(rename_all = "camelCase")]
8219pub struct ThreadSectionListParams {
8220    #[serde(default, skip_serializing_if = "Option::is_none")]
8221    pub cursor: Option<String>,
8222    #[serde(default, skip_serializing_if = "Option::is_none")]
8223    pub limit: Option<i64>,
8224}
8225
8226#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8227#[serde(rename_all = "camelCase")]
8228pub struct ThreadSectionListResponse {
8229    #[serde(default)]
8230    pub data: Vec<ThreadSection>,
8231    #[serde(
8232        rename = "nextCursor",
8233        default,
8234        skip_serializing_if = "Option::is_none"
8235    )]
8236    pub next_cursor: Option<String>,
8237}
8238
8239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8240#[serde(rename_all = "camelCase")]
8241pub struct ThreadSectionMoveParams {
8242    #[serde(
8243        rename = "beforeThreadId",
8244        default,
8245        skip_serializing_if = "Option::is_none"
8246    )]
8247    pub before_thread_id: Option<String>,
8248    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8249    pub section_id: Option<String>,
8250    #[serde(rename = "threadId", default)]
8251    pub thread_id: String,
8252}
8253
8254#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8255#[serde(rename_all = "camelCase")]
8256pub struct ThreadSectionMoveResponse {
8257    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8258    pub extra: serde_json::Map<String, Value>,
8259}
8260
8261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8262#[serde(rename_all = "camelCase")]
8263pub struct ThreadSectionUpdateParams {
8264    #[serde(default, skip_serializing_if = "Option::is_none")]
8265    pub appearance: Option<ThreadSectionAppearance>,
8266    #[serde(default)]
8267    pub name: String,
8268    #[serde(rename = "sectionId", default)]
8269    pub section_id: String,
8270}
8271
8272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8273#[serde(rename_all = "camelCase")]
8274pub struct ThreadSectionUpdateResponse {
8275    #[serde()]
8276    pub section: ThreadSection,
8277}
8278
8279#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8280#[serde(rename_all = "camelCase")]
8281pub struct ThreadSetNameParams {
8282    #[serde(default)]
8283    pub name: String,
8284    #[serde(rename = "threadId", default)]
8285    pub thread_id: String,
8286}
8287
8288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8289#[serde(rename_all = "camelCase")]
8290pub struct ThreadSetNameResponse {
8291    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8292    pub extra: serde_json::Map<String, Value>,
8293}
8294
8295#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8296#[serde(rename_all = "camelCase")]
8297pub struct ThreadSettings {
8298    #[serde(
8299        rename = "activePermissionProfile",
8300        default,
8301        skip_serializing_if = "Option::is_none"
8302    )]
8303    pub active_permission_profile: Option<ActivePermissionProfile>,
8304    #[serde(rename = "approvalPolicy")]
8305    pub approval_policy: AskForApproval,
8306    #[serde(rename = "approvalsReviewer")]
8307    pub approvals_reviewer: ApprovalsReviewer,
8308    #[serde(rename = "collaborationMode")]
8309    pub collaboration_mode: CollaborationMode,
8310    #[serde()]
8311    pub cwd: AbsolutePathBuf,
8312    #[serde(default, skip_serializing_if = "Option::is_none")]
8313    pub effort: Option<ReasoningEffort>,
8314    #[serde(default)]
8315    pub model: String,
8316    #[serde(rename = "modelProvider", default)]
8317    pub model_provider: String,
8318    #[serde(default, skip_serializing_if = "Option::is_none")]
8319    pub personality: Option<Personality>,
8320    #[serde(rename = "sandboxPolicy")]
8321    pub sandbox_policy: SandboxPolicy,
8322    #[serde(
8323        rename = "serviceTier",
8324        default,
8325        skip_serializing_if = "Option::is_none"
8326    )]
8327    pub service_tier: Option<String>,
8328    #[serde(default, skip_serializing_if = "Option::is_none")]
8329    pub summary: Option<ReasoningSummary>,
8330}
8331
8332#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8333#[serde(rename_all = "camelCase")]
8334pub struct ThreadSettingsUpdatedNotification {
8335    #[serde(rename = "threadId", default)]
8336    pub thread_id: String,
8337    #[serde(rename = "threadSettings")]
8338    pub thread_settings: ThreadSettings,
8339}
8340
8341#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8342#[serde(rename_all = "camelCase")]
8343pub struct ThreadShellCommandParams {
8344    #[serde(default)]
8345    pub command: String,
8346    #[serde(rename = "threadId", default)]
8347    pub thread_id: String,
8348    /// Maximum execution time in ms; defaults to one hour when omitted.
8349    /// Zero requests an immediate timeout, not unlimited (0.148 upstream).
8350    #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
8351    pub timeout_ms: Option<i64>,
8352}
8353
8354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8355#[serde(rename_all = "camelCase")]
8356pub struct ThreadShellCommandResponse {
8357    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8358    pub extra: serde_json::Map<String, Value>,
8359}
8360
8361#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8362pub enum ThreadSortKey {
8363    #[serde(rename = "created_at")]
8364    Created_at,
8365    #[serde(rename = "updated_at")]
8366    Updated_at,
8367    #[serde(rename = "recency_at")]
8368    Recency_at,
8369    #[serde(rename = "section_position")]
8370    Section_position,
8371}
8372
8373#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
8374#[serde(transparent)]
8375pub struct ThreadSource(pub String);
8376
8377#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8378pub enum ThreadSourceKind {
8379    #[serde(rename = "cli")]
8380    Cli,
8381    #[serde(rename = "vscode")]
8382    Vscode,
8383    #[serde(rename = "exec")]
8384    Exec,
8385    #[serde(rename = "appServer")]
8386    AppServer,
8387    #[serde(rename = "subAgent")]
8388    SubAgent,
8389    #[serde(rename = "subAgentReview")]
8390    SubAgentReview,
8391    #[serde(rename = "subAgentCompact")]
8392    SubAgentCompact,
8393    #[serde(rename = "subAgentThreadSpawn")]
8394    SubAgentThreadSpawn,
8395    #[serde(rename = "subAgentOther")]
8396    SubAgentOther,
8397    #[serde(rename = "unknown")]
8398    Unknown,
8399}
8400
8401#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8402#[serde(rename_all = "camelCase")]
8403pub struct ThreadStartParams {
8404    #[serde(
8405        rename = "approvalPolicy",
8406        default,
8407        skip_serializing_if = "Option::is_none"
8408    )]
8409    pub approval_policy: Option<AskForApproval>,
8410    #[serde(
8411        rename = "approvalsReviewer",
8412        default,
8413        skip_serializing_if = "Option::is_none"
8414    )]
8415    pub approvals_reviewer: Option<ApprovalsReviewer>,
8416    #[serde(
8417        rename = "baseInstructions",
8418        default,
8419        skip_serializing_if = "Option::is_none"
8420    )]
8421    pub base_instructions: Option<String>,
8422    #[serde(default, skip_serializing_if = "Option::is_none")]
8423    pub config: Option<Value>,
8424    #[serde(default, skip_serializing_if = "Option::is_none")]
8425    pub cwd: Option<String>,
8426    #[serde(
8427        rename = "developerInstructions",
8428        default,
8429        skip_serializing_if = "Option::is_none"
8430    )]
8431    pub developer_instructions: Option<String>,
8432    #[serde(default, skip_serializing_if = "Option::is_none")]
8433    pub ephemeral: Option<bool>,
8434    #[serde(default, skip_serializing_if = "Option::is_none")]
8435    pub model: Option<String>,
8436    #[serde(
8437        rename = "modelProvider",
8438        default,
8439        skip_serializing_if = "Option::is_none"
8440    )]
8441    pub model_provider: Option<String>,
8442    #[serde(default, skip_serializing_if = "Option::is_none")]
8443    pub personality: Option<Personality>,
8444    #[serde(default, skip_serializing_if = "Option::is_none")]
8445    pub sandbox: Option<SandboxMode>,
8446    #[serde(
8447        rename = "serviceName",
8448        default,
8449        skip_serializing_if = "Option::is_none"
8450    )]
8451    pub service_name: Option<String>,
8452    #[serde(
8453        rename = "serviceTier",
8454        default,
8455        skip_serializing_if = "Option::is_none"
8456    )]
8457    pub service_tier: Option<String>,
8458    #[serde(
8459        rename = "sessionStartSource",
8460        default,
8461        skip_serializing_if = "Option::is_none"
8462    )]
8463    pub session_start_source: Option<ThreadStartSource>,
8464    #[serde(
8465        rename = "threadSource",
8466        default,
8467        skip_serializing_if = "Option::is_none"
8468    )]
8469    pub thread_source: Option<ThreadSource>,
8470}
8471
8472#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8473#[serde(rename_all = "camelCase")]
8474pub struct ThreadStartResponse {
8475    #[serde(rename = "approvalPolicy")]
8476    pub approval_policy: AskForApproval,
8477    #[serde(rename = "approvalsReviewer", default)]
8478    pub approvals_reviewer: Value,
8479    #[serde()]
8480    pub cwd: AbsolutePathBuf,
8481    #[serde(
8482        rename = "instructionSources",
8483        default,
8484        skip_serializing_if = "Option::is_none"
8485    )]
8486    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8487    #[serde(default)]
8488    pub model: String,
8489    #[serde(rename = "modelProvider", default)]
8490    pub model_provider: String,
8491    #[serde(
8492        rename = "reasoningEffort",
8493        default,
8494        skip_serializing_if = "Option::is_none"
8495    )]
8496    pub reasoning_effort: Option<ReasoningEffort>,
8497    #[serde(default)]
8498    pub sandbox: Value,
8499    #[serde(
8500        rename = "serviceTier",
8501        default,
8502        skip_serializing_if = "Option::is_none"
8503    )]
8504    pub service_tier: Option<String>,
8505    #[serde()]
8506    pub thread: Thread,
8507}
8508
8509#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8510pub enum ThreadStartSource {
8511    #[serde(rename = "startup")]
8512    Startup,
8513    #[serde(rename = "clear")]
8514    Clear,
8515}
8516
8517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8518#[serde(rename_all = "camelCase")]
8519pub struct ThreadStartedNotification {
8520    #[serde()]
8521    pub thread: Thread,
8522}
8523
8524#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8525#[serde(tag = "type", rename_all = "camelCase")]
8526pub enum ThreadStatus {
8527    #[serde(rename = "notLoaded")]
8528    NotLoaded,
8529    Idle,
8530    #[serde(rename = "systemError")]
8531    SystemError,
8532    Active {
8533        #[serde(rename = "activeFlags")]
8534        active_flags: Vec<ThreadActiveFlag>,
8535    },
8536}
8537
8538#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8539#[serde(rename_all = "camelCase")]
8540pub struct ThreadStatusChangedNotification {
8541    #[serde()]
8542    pub status: ThreadStatus,
8543    #[serde(rename = "threadId", default)]
8544    pub thread_id: String,
8545}
8546
8547#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8548#[serde(rename_all = "camelCase")]
8549pub struct ThreadTokenUsage {
8550    #[serde()]
8551    pub last: TokenUsageBreakdown,
8552    #[serde(
8553        rename = "modelContextWindow",
8554        default,
8555        skip_serializing_if = "Option::is_none"
8556    )]
8557    pub model_context_window: Option<i64>,
8558    #[serde()]
8559    pub total: TokenUsageBreakdown,
8560}
8561
8562#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8563#[serde(rename_all = "camelCase")]
8564pub struct ThreadTokenUsageUpdatedNotification {
8565    #[serde(rename = "threadId", default)]
8566    pub thread_id: String,
8567    #[serde(rename = "tokenUsage")]
8568    pub token_usage: ThreadTokenUsage,
8569    #[serde(rename = "turnId", default)]
8570    pub turn_id: String,
8571}
8572
8573#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8574#[serde(rename_all = "camelCase")]
8575pub struct ThreadUnarchiveParams {
8576    #[serde(rename = "threadId", default)]
8577    pub thread_id: String,
8578}
8579
8580#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8581#[serde(rename_all = "camelCase")]
8582pub struct ThreadUnarchiveResponse {
8583    #[serde()]
8584    pub thread: Thread,
8585}
8586
8587#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8588#[serde(rename_all = "camelCase")]
8589pub struct ThreadUnarchivedNotification {
8590    #[serde(rename = "threadId", default)]
8591    pub thread_id: String,
8592}
8593
8594/// EXPERIMENTAL upstream — one item or turn boundary in canonical rollout
8595/// order (0.148). Wire quirk mirrored exactly: the `item` variant uses
8596/// camelCase `turnId` while the turn-boundary variants use snake_case
8597/// `turn_id`/`started_at`/`completed_at`/`duration_ms`.
8598#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8599#[serde(tag = "type", rename_all = "camelCase")]
8600#[allow(clippy::large_enum_variant)] // transient per-entry wire value, not stored in bulk
8601pub enum ThreadTimelineEntry {
8602    Item {
8603        item: ThreadItem,
8604        position: u64,
8605        #[serde(rename = "turnId")]
8606        turn_id: String,
8607    },
8608    Realtime {
8609        item: ThreadRealtimeItem,
8610        position: u64,
8611    },
8612    TurnStarted {
8613        position: u64,
8614        #[serde(default, skip_serializing_if = "Option::is_none")]
8615        started_at: Option<i64>,
8616        turn_id: String,
8617    },
8618    TurnCompleted {
8619        #[serde(default, skip_serializing_if = "Option::is_none")]
8620        completed_at: Option<i64>,
8621        #[serde(default, skip_serializing_if = "Option::is_none")]
8622        duration_ms: Option<i64>,
8623        #[serde(default, skip_serializing_if = "Option::is_none")]
8624        error: Option<TurnError>,
8625        position: u64,
8626        #[serde(default, skip_serializing_if = "Option::is_none")]
8627        started_at: Option<i64>,
8628        status: TurnStatus,
8629        turn_id: String,
8630    },
8631}
8632
8633/// Params for `thread/turns/list` — paginated turn hydration (0.148 upstream).
8634#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8635#[serde(rename_all = "camelCase")]
8636pub struct ThreadTurnsListParams {
8637    #[serde(default, skip_serializing_if = "Option::is_none")]
8638    pub cursor: Option<String>,
8639    /// How much item detail to include per turn; defaults to summary.
8640    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
8641    pub items_view: Option<TurnItemsView>,
8642    #[serde(default, skip_serializing_if = "Option::is_none")]
8643    pub limit: Option<u32>,
8644    #[serde(
8645        rename = "sortDirection",
8646        default,
8647        skip_serializing_if = "Option::is_none"
8648    )]
8649    pub sort_direction: Option<SortDirection>,
8650    #[serde(rename = "threadId", default)]
8651    pub thread_id: String,
8652}
8653
8654/// Response to `thread/turns/list` (0.148 upstream).
8655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8656#[serde(rename_all = "camelCase")]
8657pub struct ThreadTurnsListResponse {
8658    #[serde(
8659        rename = "backwardsCursor",
8660        default,
8661        skip_serializing_if = "Option::is_none"
8662    )]
8663    pub backwards_cursor: Option<String>,
8664    #[serde(default)]
8665    pub data: Vec<Turn>,
8666    #[serde(
8667        rename = "nextCursor",
8668        default,
8669        skip_serializing_if = "Option::is_none"
8670    )]
8671    pub next_cursor: Option<String>,
8672}
8673
8674#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8675#[serde(rename_all = "camelCase")]
8676pub struct ThreadUnsubscribeParams {
8677    #[serde(rename = "threadId", default)]
8678    pub thread_id: String,
8679}
8680
8681#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8682#[serde(rename_all = "camelCase")]
8683pub struct ThreadUnsubscribeResponse {
8684    #[serde()]
8685    pub status: ThreadUnsubscribeStatus,
8686}
8687
8688#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8689pub enum ThreadUnsubscribeStatus {
8690    #[serde(rename = "notLoaded")]
8691    NotLoaded,
8692    #[serde(rename = "notSubscribed")]
8693    NotSubscribed,
8694    #[serde(rename = "unsubscribed")]
8695    Unsubscribed,
8696}
8697
8698#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8699#[serde(rename_all = "camelCase")]
8700pub struct TokenUsageBreakdown {
8701    #[serde(
8702        rename = "cacheWriteInputTokens",
8703        default,
8704        skip_serializing_if = "Option::is_none"
8705    )]
8706    pub cache_write_input_tokens: Option<i64>,
8707    #[serde(rename = "cachedInputTokens", default)]
8708    pub cached_input_tokens: i64,
8709    #[serde(rename = "inputTokens", default)]
8710    pub input_tokens: i64,
8711    #[serde(rename = "outputTokens", default)]
8712    pub output_tokens: i64,
8713    #[serde(rename = "reasoningOutputTokens", default)]
8714    pub reasoning_output_tokens: i64,
8715    #[serde(rename = "totalTokens", default)]
8716    pub total_tokens: i64,
8717}
8718
8719#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8720#[serde(rename_all = "camelCase")]
8721pub struct Tool {
8722    #[serde(default, skip_serializing_if = "Option::is_none")]
8723    pub _meta: Option<Value>,
8724    #[serde(default, skip_serializing_if = "Option::is_none")]
8725    pub annotations: Option<Value>,
8726    #[serde(default, skip_serializing_if = "Option::is_none")]
8727    pub description: Option<String>,
8728    #[serde(default, skip_serializing_if = "Option::is_none")]
8729    pub icons: Option<Vec<Value>>,
8730    #[serde(rename = "inputSchema", default)]
8731    pub input_schema: Value,
8732    #[serde(default)]
8733    pub name: String,
8734    #[serde(
8735        rename = "outputSchema",
8736        default,
8737        skip_serializing_if = "Option::is_none"
8738    )]
8739    pub output_schema: Option<Value>,
8740    #[serde(default, skip_serializing_if = "Option::is_none")]
8741    pub title: Option<String>,
8742}
8743
8744#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8745#[serde(rename_all = "camelCase")]
8746pub struct ToolRequestUserInputAnswer {
8747    #[serde(default)]
8748    pub answers: Vec<String>,
8749}
8750
8751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8752#[serde(rename_all = "camelCase")]
8753pub struct ToolRequestUserInputOption {
8754    #[serde(default)]
8755    pub description: String,
8756    #[serde(default)]
8757    pub label: String,
8758}
8759
8760#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8761#[serde(rename_all = "camelCase")]
8762pub struct ToolRequestUserInputParams {
8763    #[serde(
8764        rename = "autoResolutionMs",
8765        default,
8766        skip_serializing_if = "Option::is_none"
8767    )]
8768    pub auto_resolution_ms: Option<i64>,
8769    #[serde(rename = "isBlocking", default)]
8770    pub is_blocking: bool,
8771    #[serde(rename = "itemId", default)]
8772    pub item_id: String,
8773    #[serde(default)]
8774    pub questions: Vec<ToolRequestUserInputQuestion>,
8775    #[serde(rename = "threadId", default)]
8776    pub thread_id: String,
8777    #[serde(rename = "turnId", default)]
8778    pub turn_id: String,
8779}
8780
8781#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8782#[serde(rename_all = "camelCase")]
8783pub struct ToolRequestUserInputQuestion {
8784    #[serde(default)]
8785    pub header: String,
8786    #[serde(default)]
8787    pub id: String,
8788    #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
8789    pub is_other: Option<bool>,
8790    #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
8791    pub is_secret: Option<bool>,
8792    #[serde(default, skip_serializing_if = "Option::is_none")]
8793    pub options: Option<Vec<ToolRequestUserInputOption>>,
8794    #[serde(default)]
8795    pub question: String,
8796}
8797
8798#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8799#[serde(rename_all = "camelCase")]
8800pub struct ToolRequestUserInputResponse {
8801    #[serde(default)]
8802    pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
8803}
8804
8805#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8806#[serde(rename_all = "camelCase")]
8807pub struct ToolsV2 {
8808    #[serde(default, skip_serializing_if = "Option::is_none")]
8809    pub web_search: Option<WebSearchToolConfig>,
8810}
8811
8812#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8813#[serde(rename_all = "camelCase")]
8814pub struct Turn {
8815    #[serde(
8816        rename = "completedAt",
8817        default,
8818        skip_serializing_if = "Option::is_none"
8819    )]
8820    pub completed_at: Option<i64>,
8821    #[serde(
8822        rename = "durationMs",
8823        default,
8824        skip_serializing_if = "Option::is_none"
8825    )]
8826    pub duration_ms: Option<i64>,
8827    #[serde(default, skip_serializing_if = "Option::is_none")]
8828    pub error: Option<TurnError>,
8829    #[serde(default)]
8830    pub id: String,
8831    #[serde(default)]
8832    pub items: Vec<ThreadItem>,
8833    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
8834    pub items_view: Option<Value>,
8835    #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
8836    pub started_at: Option<i64>,
8837    #[serde()]
8838    pub status: TurnStatus,
8839}
8840
8841#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8842#[serde(rename_all = "camelCase")]
8843pub struct TurnCompletedNotification {
8844    #[serde(rename = "threadId", default)]
8845    pub thread_id: String,
8846    #[serde()]
8847    pub turn: Turn,
8848}
8849
8850#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8851#[serde(rename_all = "camelCase")]
8852pub struct TurnDiffUpdatedNotification {
8853    #[serde(default)]
8854    pub diff: String,
8855    #[serde(rename = "threadId", default)]
8856    pub thread_id: String,
8857    #[serde(rename = "turnId", default)]
8858    pub turn_id: String,
8859}
8860
8861#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8862#[serde(rename_all = "camelCase")]
8863pub struct TurnError {
8864    #[serde(
8865        rename = "additionalDetails",
8866        default,
8867        skip_serializing_if = "Option::is_none"
8868    )]
8869    pub additional_details: Option<String>,
8870    #[serde(
8871        rename = "codexErrorInfo",
8872        default,
8873        skip_serializing_if = "Option::is_none"
8874    )]
8875    pub codex_error_info: Option<CodexErrorInfo>,
8876    #[serde(default)]
8877    pub message: String,
8878    /// Public explanation and continuation instruction for a misalignment
8879    /// block (0.148 upstream).
8880    #[serde(default, skip_serializing_if = "Option::is_none")]
8881    pub misalignment: Option<MisalignmentErrorDetails>,
8882}
8883
8884#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8885#[serde(rename_all = "camelCase")]
8886pub struct TurnInterruptParams {
8887    #[serde(rename = "threadId", default)]
8888    pub thread_id: String,
8889    #[serde(rename = "turnId", default)]
8890    pub turn_id: String,
8891}
8892
8893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8894#[serde(rename_all = "camelCase")]
8895pub struct TurnInterruptResponse {
8896    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8897    pub extra: serde_json::Map<String, Value>,
8898}
8899
8900#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
8901pub enum TurnItemsView {
8902    #[serde(rename = "notLoaded")]
8903    NotLoaded,
8904    #[serde(rename = "summary")]
8905    Summary,
8906    #[serde(rename = "full")]
8907    Full,
8908}
8909
8910#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8911#[serde(rename_all = "camelCase")]
8912pub struct TurnModerationMetadataNotification {
8913    #[serde(default)]
8914    pub metadata: Value,
8915    #[serde(rename = "threadId", default)]
8916    pub thread_id: String,
8917    #[serde(rename = "turnId", default)]
8918    pub turn_id: String,
8919}
8920
8921#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8922#[serde(rename_all = "camelCase")]
8923pub struct TurnPlanStep {
8924    #[serde()]
8925    pub status: TurnPlanStepStatus,
8926    #[serde(default)]
8927    pub step: String,
8928}
8929
8930#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8931pub enum TurnPlanStepStatus {
8932    #[serde(rename = "pending")]
8933    Pending,
8934    #[serde(rename = "inProgress")]
8935    InProgress,
8936    #[serde(rename = "completed")]
8937    Completed,
8938}
8939
8940#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8941#[serde(rename_all = "camelCase")]
8942pub struct TurnPlanUpdatedNotification {
8943    #[serde(default, skip_serializing_if = "Option::is_none")]
8944    pub explanation: Option<String>,
8945    #[serde(default)]
8946    pub plan: Vec<TurnPlanStep>,
8947    #[serde(rename = "threadId", default)]
8948    pub thread_id: String,
8949    #[serde(rename = "turnId", default)]
8950    pub turn_id: String,
8951}
8952
8953#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8954#[serde(rename_all = "camelCase")]
8955pub struct TurnStartParams {
8956    #[serde(
8957        rename = "approvalPolicy",
8958        default,
8959        skip_serializing_if = "Option::is_none"
8960    )]
8961    pub approval_policy: Option<AskForApproval>,
8962    #[serde(
8963        rename = "approvalsReviewer",
8964        default,
8965        skip_serializing_if = "Option::is_none"
8966    )]
8967    pub approvals_reviewer: Option<ApprovalsReviewer>,
8968    #[serde(
8969        rename = "clientUserMessageId",
8970        default,
8971        skip_serializing_if = "Option::is_none"
8972    )]
8973    pub client_user_message_id: Option<String>,
8974    #[serde(default, skip_serializing_if = "Option::is_none")]
8975    pub cwd: Option<String>,
8976    #[serde(default, skip_serializing_if = "Option::is_none")]
8977    pub effort: Option<ReasoningEffort>,
8978    #[serde(default)]
8979    pub input: Vec<UserInput>,
8980    #[serde(default, skip_serializing_if = "Option::is_none")]
8981    pub model: Option<String>,
8982    #[serde(
8983        rename = "outputSchema",
8984        default,
8985        skip_serializing_if = "Option::is_none"
8986    )]
8987    pub output_schema: Option<Value>,
8988    #[serde(default, skip_serializing_if = "Option::is_none")]
8989    pub personality: Option<Personality>,
8990    #[serde(
8991        rename = "sandboxPolicy",
8992        default,
8993        skip_serializing_if = "Option::is_none"
8994    )]
8995    pub sandbox_policy: Option<SandboxPolicy>,
8996    #[serde(
8997        rename = "serviceTier",
8998        default,
8999        skip_serializing_if = "Option::is_none"
9000    )]
9001    pub service_tier: Option<String>,
9002    /// One-turn service-tier override; `"default"` for standard speed.
9003    /// Omitted or null inherits the thread's tier (0.148 upstream).
9004    #[serde(
9005        rename = "serviceTierForTurn",
9006        default,
9007        skip_serializing_if = "Option::is_none"
9008    )]
9009    pub service_tier_for_turn: Option<String>,
9010    #[serde(default, skip_serializing_if = "Option::is_none")]
9011    pub summary: Option<ReasoningSummary>,
9012    #[serde(rename = "threadId", default)]
9013    pub thread_id: String,
9014    /// Pre-computed tool output to inject when starting the turn
9015    /// (0.148 upstream).
9016    #[serde(
9017        rename = "toolOutput",
9018        default,
9019        skip_serializing_if = "Option::is_none"
9020    )]
9021    pub tool_output: Option<TurnToolOutput>,
9022    /// Optional source classification for the caller starting this turn;
9023    /// ignored when steering an already-active turn (0.148 upstream).
9024    #[serde(
9025        rename = "turnTrigger",
9026        default,
9027        skip_serializing_if = "Option::is_none"
9028    )]
9029    pub turn_trigger: Option<String>,
9030}
9031
9032#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9033#[serde(rename_all = "camelCase")]
9034pub struct TurnStartResponse {
9035    #[serde()]
9036    pub turn: Turn,
9037}
9038
9039#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9040#[serde(rename_all = "camelCase")]
9041pub struct TurnStartedNotification {
9042    #[serde(rename = "threadId", default)]
9043    pub thread_id: String,
9044    #[serde()]
9045    pub turn: Turn,
9046}
9047
9048#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9049pub enum TurnStatus {
9050    #[serde(rename = "completed")]
9051    Completed,
9052    #[serde(rename = "interrupted")]
9053    Interrupted,
9054    #[serde(rename = "failed")]
9055    Failed,
9056    #[serde(rename = "inProgress")]
9057    InProgress,
9058}
9059
9060/// A pre-computed tool output supplied when starting a turn
9061/// (`TurnStartParams.toolOutput`, 0.148 upstream).
9062#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9063#[serde(rename_all = "camelCase")]
9064pub struct TurnToolOutput {
9065    #[serde(default)]
9066    pub name: String,
9067    #[serde(default, skip_serializing_if = "Option::is_none")]
9068    pub namespace: Option<String>,
9069    #[serde()]
9070    pub output: FunctionCallOutputBody,
9071}
9072
9073#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9074#[serde(rename_all = "camelCase")]
9075pub struct TurnSteerParams {
9076    #[serde(
9077        rename = "clientUserMessageId",
9078        default,
9079        skip_serializing_if = "Option::is_none"
9080    )]
9081    pub client_user_message_id: Option<String>,
9082    #[serde(rename = "expectedTurnId", default)]
9083    pub expected_turn_id: String,
9084    #[serde(default)]
9085    pub input: Vec<UserInput>,
9086    #[serde(rename = "threadId", default)]
9087    pub thread_id: String,
9088}
9089
9090#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9091#[serde(rename_all = "camelCase")]
9092pub struct TurnSteerResponse {
9093    #[serde(rename = "turnId", default)]
9094    pub turn_id: String,
9095}
9096
9097#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9098#[serde(tag = "type", rename_all = "camelCase")]
9099pub enum UserInput {
9100    Text {
9101        text: String,
9102        #[serde(default, skip_serializing_if = "Option::is_none")]
9103        text_elements: Option<Vec<TextElement>>,
9104    },
9105    Image {
9106        #[serde(default, skip_serializing_if = "Option::is_none")]
9107        detail: Option<ImageDetail>,
9108        url: String,
9109    },
9110    #[serde(rename = "localImage")]
9111    LocalImage {
9112        #[serde(default, skip_serializing_if = "Option::is_none")]
9113        detail: Option<ImageDetail>,
9114        path: String,
9115    },
9116    Audio {
9117        url: String,
9118    },
9119    #[serde(rename = "localAudio")]
9120    LocalAudio {
9121        path: String,
9122    },
9123    Skill {
9124        name: String,
9125        path: String,
9126    },
9127    Mention {
9128        name: String,
9129        path: String,
9130    },
9131}
9132
9133#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9134pub enum Verbosity {
9135    #[serde(rename = "low")]
9136    Low,
9137    #[serde(rename = "medium")]
9138    Medium,
9139    #[serde(rename = "high")]
9140    High,
9141}
9142
9143#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9144#[serde(rename_all = "camelCase")]
9145pub struct WarningNotification {
9146    #[serde(default)]
9147    pub message: String,
9148    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
9149    pub thread_id: Option<String>,
9150}
9151
9152#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9153#[serde(tag = "type", rename_all = "camelCase")]
9154pub enum WebSearchAction {
9155    Search {
9156        #[serde(default, skip_serializing_if = "Option::is_none")]
9157        queries: Option<Vec<String>>,
9158        #[serde(default, skip_serializing_if = "Option::is_none")]
9159        query: Option<String>,
9160    },
9161    #[serde(rename = "openPage")]
9162    OpenPage {
9163        #[serde(default, skip_serializing_if = "Option::is_none")]
9164        url: Option<String>,
9165    },
9166    #[serde(rename = "findInPage")]
9167    FindInPage {
9168        #[serde(default, skip_serializing_if = "Option::is_none")]
9169        pattern: Option<String>,
9170        #[serde(default, skip_serializing_if = "Option::is_none")]
9171        url: Option<String>,
9172    },
9173    Other,
9174}
9175
9176#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9177pub enum WebSearchContextSize {
9178    #[serde(rename = "low")]
9179    Low,
9180    #[serde(rename = "medium")]
9181    Medium,
9182    #[serde(rename = "high")]
9183    High,
9184}
9185
9186#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9187#[serde(rename_all = "camelCase")]
9188pub struct WebSearchLocation {
9189    #[serde(default, skip_serializing_if = "Option::is_none")]
9190    pub city: Option<String>,
9191    #[serde(default, skip_serializing_if = "Option::is_none")]
9192    pub country: Option<String>,
9193    #[serde(default, skip_serializing_if = "Option::is_none")]
9194    pub region: Option<String>,
9195    #[serde(default, skip_serializing_if = "Option::is_none")]
9196    pub timezone: Option<String>,
9197}
9198
9199#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9200pub enum WebSearchMode {
9201    #[serde(rename = "disabled")]
9202    Disabled,
9203    #[serde(rename = "cached")]
9204    Cached,
9205    #[serde(rename = "indexed")]
9206    Indexed,
9207    #[serde(rename = "live")]
9208    Live,
9209}
9210
9211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9212#[serde(rename_all = "camelCase")]
9213pub struct WebSearchToolConfig {
9214    #[serde(default, skip_serializing_if = "Option::is_none")]
9215    pub allowed_domains: Option<Vec<String>>,
9216    #[serde(default, skip_serializing_if = "Option::is_none")]
9217    pub context_size: Option<WebSearchContextSize>,
9218    #[serde(default, skip_serializing_if = "Option::is_none")]
9219    pub location: Option<WebSearchLocation>,
9220}
9221
9222#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9223pub enum WindowsSandboxReadiness {
9224    #[serde(rename = "ready")]
9225    Ready,
9226    #[serde(rename = "notConfigured")]
9227    NotConfigured,
9228    #[serde(rename = "updateRequired")]
9229    UpdateRequired,
9230}
9231
9232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9233#[serde(rename_all = "camelCase")]
9234pub struct WindowsSandboxReadinessResponse {
9235    #[serde()]
9236    pub status: WindowsSandboxReadiness,
9237}
9238
9239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9240#[serde(rename_all = "camelCase")]
9241pub struct WindowsSandboxSetupCompletedNotification {
9242    #[serde(default, skip_serializing_if = "Option::is_none")]
9243    pub error: Option<String>,
9244    #[serde()]
9245    pub mode: WindowsSandboxSetupMode,
9246    #[serde(default)]
9247    pub success: bool,
9248}
9249
9250#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9251pub enum WindowsSandboxSetupMode {
9252    #[serde(rename = "elevated")]
9253    Elevated,
9254    #[serde(rename = "unelevated")]
9255    Unelevated,
9256}
9257
9258#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9259#[serde(rename_all = "camelCase")]
9260pub struct WindowsSandboxSetupStartParams {
9261    #[serde(default, skip_serializing_if = "Option::is_none")]
9262    pub cwd: Option<AbsolutePathBuf>,
9263    #[serde()]
9264    pub mode: WindowsSandboxSetupMode,
9265}
9266
9267#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9268#[serde(rename_all = "camelCase")]
9269pub struct WindowsSandboxSetupStartResponse {
9270    #[serde(default)]
9271    pub started: bool,
9272}
9273
9274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9275#[serde(rename_all = "camelCase")]
9276pub struct WindowsWorldWritableWarningNotification {
9277    #[serde(rename = "extraCount", default)]
9278    pub extra_count: i64,
9279    #[serde(rename = "failedScan", default)]
9280    pub failed_scan: bool,
9281    #[serde(rename = "samplePaths", default)]
9282    pub sample_paths: Vec<String>,
9283}
9284
9285#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9286#[serde(rename_all = "camelCase")]
9287pub struct WorkspaceMessage {
9288    #[serde(
9289        rename = "archivedAt",
9290        default,
9291        skip_serializing_if = "Option::is_none"
9292    )]
9293    pub archived_at: Option<i64>,
9294    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
9295    pub created_at: Option<i64>,
9296    #[serde(rename = "messageBody", default)]
9297    pub message_body: String,
9298    #[serde(rename = "messageId", default)]
9299    pub message_id: String,
9300    #[serde(rename = "messageType")]
9301    pub message_type: WorkspaceMessageType,
9302}
9303
9304#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9305pub enum WorkspaceMessageType {
9306    #[serde(rename = "headline")]
9307    Headline,
9308    #[serde(rename = "announcement")]
9309    Announcement,
9310    #[serde(rename = "unknown")]
9311    Unknown,
9312}
9313
9314#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9315pub enum WriteStatus {
9316    #[serde(rename = "ok")]
9317    Ok,
9318    #[serde(rename = "okOverridden")]
9319    OkOverridden,
9320}
codex_codes/protocol_generated/types.rs

codex_codes/protocol_generated/
types.rs
