Skip to main content

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