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 = "preModelRequest")]
3251    PreModelRequest,
3252    #[serde(rename = "postModelRequest")]
3253    PostModelRequest,
3254    #[serde(rename = "preToolUse")]
3255    PreToolUse,
3256    #[serde(rename = "permissionRequest")]
3257    PermissionRequest,
3258    #[serde(rename = "postToolUse")]
3259    PostToolUse,
3260    #[serde(rename = "preCompact")]
3261    PreCompact,
3262    #[serde(rename = "postCompact")]
3263    PostCompact,
3264    #[serde(rename = "sessionStart")]
3265    SessionStart,
3266    #[serde(rename = "sessionEnd")]
3267    SessionEnd,
3268    #[serde(rename = "userPromptSubmit")]
3269    UserPromptSubmit,
3270    #[serde(rename = "subagentStart")]
3271    SubagentStart,
3272    #[serde(rename = "subagentStop")]
3273    SubagentStop,
3274    #[serde(rename = "stop")]
3275    Stop,
3276    #[serde(rename = "interrupt")]
3277    Interrupt,
3278}
3279
3280#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3281pub enum HookExecutionMode {
3282    #[serde(rename = "sync")]
3283    Sync,
3284    #[serde(rename = "async")]
3285    Async,
3286}
3287
3288#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3289pub enum HookHandlerType {
3290    #[serde(rename = "command")]
3291    Command,
3292    #[serde(rename = "mcpTool")]
3293    McpTool,
3294    #[serde(rename = "prompt")]
3295    Prompt,
3296    #[serde(rename = "agent")]
3297    Agent,
3298}
3299
3300#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3301#[serde(rename_all = "camelCase")]
3302pub struct HookMetadata {
3303    #[serde(
3304        rename = "additionalContextLimit",
3305        default,
3306        skip_serializing_if = "Option::is_none"
3307    )]
3308    pub additional_context_limit: Option<i64>,
3309    #[serde(rename = "async", default, skip_serializing_if = "Option::is_none")]
3310    pub is_async: Option<bool>,
3311    #[serde(default, skip_serializing_if = "Option::is_none")]
3312    pub command: Option<String>,
3313    #[serde(rename = "currentHash", default)]
3314    pub current_hash: String,
3315    /// MCP server name (`handlerType: "mcpTool"` hooks).
3316    #[serde(default, skip_serializing_if = "Option::is_none")]
3317    pub server: Option<String>,
3318    /// MCP tool name (`handlerType: "mcpTool"` hooks).
3319    #[serde(default, skip_serializing_if = "Option::is_none")]
3320    pub tool: Option<String>,
3321    #[serde(rename = "displayOrder", default)]
3322    pub display_order: i64,
3323    #[serde(default)]
3324    pub enabled: bool,
3325    #[serde(rename = "eventName")]
3326    pub event_name: HookEventName,
3327    #[serde(
3328        rename = "executionMode",
3329        default,
3330        skip_serializing_if = "Option::is_none"
3331    )]
3332    pub execution_mode: Option<Value>,
3333    #[serde(rename = "handlerType")]
3334    pub handler_type: HookHandlerType,
3335    #[serde(rename = "isManaged", default)]
3336    pub is_managed: bool,
3337    #[serde(default)]
3338    pub key: String,
3339    #[serde(default, skip_serializing_if = "Option::is_none")]
3340    pub matcher: Option<String>,
3341    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
3342    pub plugin_id: Option<String>,
3343    #[serde()]
3344    pub source: HookSource,
3345    #[serde(rename = "sourcePath")]
3346    pub source_path: AbsolutePathBuf,
3347    #[serde(
3348        rename = "statusMessage",
3349        default,
3350        skip_serializing_if = "Option::is_none"
3351    )]
3352    pub status_message: Option<String>,
3353    #[serde(rename = "timeoutSec", default)]
3354    pub timeout_sec: i64,
3355    #[serde(rename = "trustStatus")]
3356    pub trust_status: HookTrustStatus,
3357}
3358
3359#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3360#[serde(rename_all = "camelCase")]
3361pub struct HookMigration {
3362    #[serde(default)]
3363    pub name: String,
3364}
3365
3366#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3367#[serde(rename_all = "camelCase")]
3368pub struct HookOutputEntry {
3369    #[serde()]
3370    pub kind: HookOutputEntryKind,
3371    #[serde(default)]
3372    pub text: String,
3373}
3374
3375#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3376pub enum HookOutputEntryKind {
3377    #[serde(rename = "warning")]
3378    Warning,
3379    #[serde(rename = "stop")]
3380    Stop,
3381    #[serde(rename = "feedback")]
3382    Feedback,
3383    #[serde(rename = "context")]
3384    Context,
3385    #[serde(rename = "error")]
3386    Error,
3387}
3388
3389#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3390#[serde(rename_all = "camelCase")]
3391pub struct HookPromptFragment {
3392    #[serde(rename = "hookRunId", default)]
3393    pub hook_run_id: String,
3394    #[serde(default)]
3395    pub text: String,
3396}
3397
3398#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3399pub enum HookRunStatus {
3400    #[serde(rename = "running")]
3401    Running,
3402    #[serde(rename = "completed")]
3403    Completed,
3404    #[serde(rename = "failed")]
3405    Failed,
3406    #[serde(rename = "blocked")]
3407    Blocked,
3408    #[serde(rename = "stopped")]
3409    Stopped,
3410}
3411
3412#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3413#[serde(rename_all = "camelCase")]
3414pub struct HookRunSummary {
3415    #[serde(
3416        rename = "completedAt",
3417        default,
3418        skip_serializing_if = "Option::is_none"
3419    )]
3420    pub completed_at: Option<i64>,
3421    #[serde(rename = "displayOrder", default)]
3422    pub display_order: i64,
3423    #[serde(
3424        rename = "durationMs",
3425        default,
3426        skip_serializing_if = "Option::is_none"
3427    )]
3428    pub duration_ms: Option<i64>,
3429    #[serde(default)]
3430    pub entries: Vec<HookOutputEntry>,
3431    #[serde(rename = "eventName")]
3432    pub event_name: HookEventName,
3433    #[serde(rename = "executionMode")]
3434    pub execution_mode: HookExecutionMode,
3435    #[serde(rename = "handlerType")]
3436    pub handler_type: HookHandlerType,
3437    #[serde(default)]
3438    pub id: String,
3439    #[serde()]
3440    pub scope: HookScope,
3441    #[serde(default, skip_serializing_if = "Option::is_none")]
3442    pub source: Option<Value>,
3443    #[serde(rename = "sourcePath")]
3444    pub source_path: AbsolutePathBuf,
3445    #[serde(rename = "startedAt", default)]
3446    pub started_at: i64,
3447    #[serde()]
3448    pub status: HookRunStatus,
3449    #[serde(
3450        rename = "statusMessage",
3451        default,
3452        skip_serializing_if = "Option::is_none"
3453    )]
3454    pub status_message: Option<String>,
3455}
3456
3457#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3458pub enum HookScope {
3459    #[serde(rename = "thread")]
3460    Thread,
3461    #[serde(rename = "turn")]
3462    Turn,
3463}
3464
3465#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3466pub enum HookSource {
3467    #[serde(rename = "system")]
3468    System,
3469    #[serde(rename = "user")]
3470    User,
3471    #[serde(rename = "project")]
3472    Project,
3473    #[serde(rename = "mdm")]
3474    Mdm,
3475    #[serde(rename = "sessionFlags")]
3476    SessionFlags,
3477    #[serde(rename = "plugin")]
3478    Plugin,
3479    #[serde(rename = "cloudRequirements")]
3480    CloudRequirements,
3481    #[serde(rename = "cloudManagedConfig")]
3482    CloudManagedConfig,
3483    #[serde(rename = "legacyManagedConfigFile")]
3484    LegacyManagedConfigFile,
3485    #[serde(rename = "legacyManagedConfigMdm")]
3486    LegacyManagedConfigMdm,
3487    #[serde(rename = "unknown")]
3488    Unknown,
3489}
3490
3491#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3492#[serde(rename_all = "camelCase")]
3493pub struct HookStartedNotification {
3494    #[serde()]
3495    pub run: HookRunSummary,
3496    #[serde(rename = "threadId", default)]
3497    pub thread_id: String,
3498    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
3499    pub turn_id: Option<String>,
3500}
3501
3502#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3503pub enum HookTrustStatus {
3504    #[serde(rename = "managed")]
3505    Managed,
3506    #[serde(rename = "untrusted")]
3507    Untrusted,
3508    #[serde(rename = "trusted")]
3509    Trusted,
3510    #[serde(rename = "modified")]
3511    Modified,
3512}
3513
3514#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3515#[serde(rename_all = "camelCase")]
3516pub struct HooksListEntry {
3517    #[serde(default)]
3518    pub cwd: String,
3519    #[serde(default)]
3520    pub errors: Vec<HookErrorInfo>,
3521    #[serde(default)]
3522    pub hooks: Vec<HookMetadata>,
3523    #[serde(default)]
3524    pub warnings: Vec<String>,
3525}
3526
3527#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3528#[serde(rename_all = "camelCase")]
3529pub struct HooksListParams {
3530    #[serde(default, skip_serializing_if = "Option::is_none")]
3531    pub cwds: Option<Vec<String>>,
3532}
3533
3534#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3535#[serde(rename_all = "camelCase")]
3536pub struct HooksListResponse {
3537    #[serde(default)]
3538    pub data: Vec<HooksListEntry>,
3539}
3540
3541#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3542pub enum ImageDetail {
3543    #[serde(rename = "auto")]
3544    Auto,
3545    #[serde(rename = "low")]
3546    Low,
3547    #[serde(rename = "high")]
3548    High,
3549    #[serde(rename = "original")]
3550    Original,
3551}
3552
3553#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3554#[serde(rename_all = "camelCase")]
3555pub struct InitializeCapabilities {
3556    #[serde(
3557        rename = "experimentalApi",
3558        default,
3559        skip_serializing_if = "Option::is_none"
3560    )]
3561    pub experimental_api: Option<bool>,
3562    /// Use explicit gateway OAuth login instead of automatic browser
3563    /// authorization. Applies to this app-server's gateway runtime; later
3564    /// connections cannot undo it.
3565    #[serde(
3566        rename = "explicitGatewayOauth",
3567        default,
3568        skip_serializing_if = "Option::is_none"
3569    )]
3570    pub explicit_gateway_oauth: Option<bool>,
3571    #[serde(default, skip_serializing_if = "Option::is_none")]
3572    pub extensions: Option<Value>,
3573    #[serde(
3574        rename = "mcpServerOpenaiFormElicitation",
3575        default,
3576        skip_serializing_if = "Option::is_none"
3577    )]
3578    pub mcp_server_openai_form_elicitation: Option<bool>,
3579    #[serde(
3580        rename = "optOutNotificationMethods",
3581        default,
3582        skip_serializing_if = "Option::is_none"
3583    )]
3584    pub opt_out_notification_methods: Option<Vec<String>>,
3585    #[serde(
3586        rename = "requestAttestation",
3587        default,
3588        skip_serializing_if = "Option::is_none"
3589    )]
3590    pub request_attestation: Option<bool>,
3591}
3592
3593#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3594#[serde(rename_all = "camelCase")]
3595pub struct InitializeParams {
3596    #[serde(default, skip_serializing_if = "Option::is_none")]
3597    pub capabilities: Option<InitializeCapabilities>,
3598    #[serde(rename = "clientInfo")]
3599    pub client_info: ClientInfo,
3600}
3601
3602#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3603#[serde(rename_all = "camelCase")]
3604pub struct InitializeResponse {
3605    #[serde(rename = "codexHome", default)]
3606    pub codex_home: Value,
3607    #[serde(rename = "platformFamily", default)]
3608    pub platform_family: String,
3609    #[serde(rename = "platformOs", default)]
3610    pub platform_os: String,
3611    #[serde(rename = "userAgent", default)]
3612    pub user_agent: String,
3613}
3614
3615#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
3616pub enum InputModality {
3617    #[serde(rename = "text")]
3618    Text,
3619    #[serde(rename = "image")]
3620    Image,
3621    #[serde(rename = "audio")]
3622    Audio,
3623}
3624
3625#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3626#[serde(rename_all = "camelCase")]
3627pub struct InstalledApp {
3628    #[serde(default)]
3629    pub callable: bool,
3630    #[serde(default)]
3631    pub enabled: bool,
3632    #[serde(default)]
3633    pub id: String,
3634    #[serde(
3635        rename = "runtimeName",
3636        default,
3637        skip_serializing_if = "Option::is_none"
3638    )]
3639    pub runtime_name: Option<String>,
3640}
3641
3642#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3643#[serde(rename_all = "camelCase")]
3644pub struct ItemCompletedNotification {
3645    #[serde(rename = "completedAtMs", default)]
3646    pub completed_at_ms: i64,
3647    #[serde()]
3648    pub item: ThreadItem,
3649    #[serde(rename = "threadId", default)]
3650    pub thread_id: String,
3651    #[serde(rename = "turnId", default)]
3652    pub turn_id: String,
3653}
3654
3655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3656#[serde(rename_all = "camelCase")]
3657pub struct ItemGuardianApprovalReviewCompletedNotification {
3658    #[serde()]
3659    pub action: GuardianApprovalReviewAction,
3660    #[serde(rename = "completedAtMs", default)]
3661    pub completed_at_ms: i64,
3662    #[serde(rename = "decisionSource")]
3663    pub decision_source: AutoReviewDecisionSource,
3664    #[serde()]
3665    pub review: GuardianApprovalReview,
3666    #[serde(rename = "reviewId", default)]
3667    pub review_id: String,
3668    #[serde(rename = "startedAtMs", default)]
3669    pub started_at_ms: i64,
3670    #[serde(
3671        rename = "targetItemId",
3672        default,
3673        skip_serializing_if = "Option::is_none"
3674    )]
3675    pub target_item_id: Option<String>,
3676    #[serde(rename = "threadId", default)]
3677    pub thread_id: String,
3678    #[serde(rename = "turnId", default)]
3679    pub turn_id: String,
3680}
3681
3682#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3683#[serde(rename_all = "camelCase")]
3684pub struct ItemGuardianApprovalReviewStartedNotification {
3685    #[serde()]
3686    pub action: GuardianApprovalReviewAction,
3687    #[serde()]
3688    pub review: GuardianApprovalReview,
3689    #[serde(rename = "reviewId", default)]
3690    pub review_id: String,
3691    #[serde(rename = "startedAtMs", default)]
3692    pub started_at_ms: i64,
3693    #[serde(
3694        rename = "targetItemId",
3695        default,
3696        skip_serializing_if = "Option::is_none"
3697    )]
3698    pub target_item_id: Option<String>,
3699    #[serde(rename = "threadId", default)]
3700    pub thread_id: String,
3701    #[serde(rename = "turnId", default)]
3702    pub turn_id: String,
3703}
3704
3705#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3706#[serde(rename_all = "camelCase")]
3707pub struct ItemStartedNotification {
3708    #[serde()]
3709    pub item: ThreadItem,
3710    #[serde(rename = "startedAtMs", default)]
3711    pub started_at_ms: i64,
3712    #[serde(rename = "threadId", default)]
3713    pub thread_id: String,
3714    #[serde(rename = "turnId", default)]
3715    pub turn_id: String,
3716}
3717
3718#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3719#[serde(rename_all = "camelCase")]
3720pub struct JSONRPCResponse {
3721    #[serde()]
3722    pub id: RequestId,
3723    #[serde(default)]
3724    pub result: Value,
3725}
3726
3727#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
3728#[serde(transparent)]
3729pub struct LegacyAppPathString(pub String);
3730
3731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3732#[serde(rename_all = "camelCase")]
3733pub struct ListMcpServerStatusParams {
3734    #[serde(default, skip_serializing_if = "Option::is_none")]
3735    pub cursor: Option<String>,
3736    #[serde(default, skip_serializing_if = "Option::is_none")]
3737    pub detail: Option<McpServerStatusDetail>,
3738    #[serde(default, skip_serializing_if = "Option::is_none")]
3739    pub limit: Option<i64>,
3740    /// Limit discovery to one server. With a thread ID, reuse that thread's
3741    /// MCP connection.
3742    #[serde(
3743        rename = "serverName",
3744        default,
3745        skip_serializing_if = "Option::is_none"
3746    )]
3747    pub server_name: Option<String>,
3748    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3749    pub thread_id: Option<String>,
3750}
3751
3752#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3753#[serde(rename_all = "camelCase")]
3754pub struct ListMcpServerStatusResponse {
3755    #[serde(default)]
3756    pub data: Vec<McpServerStatus>,
3757    #[serde(
3758        rename = "nextCursor",
3759        default,
3760        skip_serializing_if = "Option::is_none"
3761    )]
3762    pub next_cursor: Option<String>,
3763}
3764
3765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3766#[serde(tag = "type", rename_all = "camelCase")]
3767pub enum LoginAccountParams {
3768    #[serde(rename = "apiKey")]
3769    ApiKey {
3770        #[serde(rename = "apiKey")]
3771        api_key: String,
3772    },
3773    Chatgpt {
3774        #[serde(rename = "appBrand", default, skip_serializing_if = "Option::is_none")]
3775        app_brand: Option<LoginAppBrand>,
3776        #[serde(
3777            rename = "codexStreamlinedLogin",
3778            default,
3779            skip_serializing_if = "Option::is_none"
3780        )]
3781        codex_streamlined_login: Option<bool>,
3782        #[serde(
3783            rename = "useHostedLoginSuccessPage",
3784            default,
3785            skip_serializing_if = "Option::is_none"
3786        )]
3787        use_hosted_login_success_page: Option<bool>,
3788    },
3789    #[serde(rename = "chatgptDeviceCode")]
3790    ChatgptDeviceCode,
3791    #[serde(rename = "chatgptAuthTokens")]
3792    ChatgptAuthTokens {
3793        #[serde(rename = "accessToken")]
3794        access_token: String,
3795        #[serde(rename = "chatgptAccountId")]
3796        chatgpt_account_id: String,
3797        #[serde(
3798            rename = "chatgptPlanType",
3799            default,
3800            skip_serializing_if = "Option::is_none"
3801        )]
3802        chatgpt_plan_type: Option<String>,
3803    },
3804    #[serde(rename = "amazonBedrock")]
3805    AmazonBedrock {
3806        #[serde(rename = "apiKey")]
3807        api_key: String,
3808        region: String,
3809    },
3810    #[serde(rename = "amazonBedrockAccessKeys")]
3811    AmazonBedrockAccessKeys {
3812        #[serde(rename = "accessKeyId")]
3813        access_key_id: String,
3814        region: String,
3815        #[serde(rename = "secretAccessKey")]
3816        secret_access_key: String,
3817        #[serde(
3818            rename = "sessionToken",
3819            default,
3820            skip_serializing_if = "Option::is_none"
3821        )]
3822        session_token: Option<String>,
3823    },
3824}
3825
3826#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3827#[serde(tag = "type", rename_all = "camelCase")]
3828pub enum LoginAccountResponse {
3829    #[serde(rename = "apiKey")]
3830    ApiKey,
3831    Chatgpt {
3832        #[serde(rename = "authUrl")]
3833        auth_url: String,
3834        #[serde(rename = "loginId")]
3835        login_id: String,
3836    },
3837    #[serde(rename = "chatgptDeviceCode")]
3838    ChatgptDeviceCode {
3839        #[serde(rename = "loginId")]
3840        login_id: String,
3841        #[serde(rename = "userCode")]
3842        user_code: String,
3843        #[serde(rename = "verificationUrl")]
3844        verification_url: String,
3845    },
3846    #[serde(rename = "chatgptAuthTokens")]
3847    ChatgptAuthTokens,
3848    #[serde(rename = "amazonBedrock")]
3849    AmazonBedrock,
3850}
3851
3852#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3853pub enum LoginAppBrand {
3854    #[serde(rename = "codex")]
3855    Codex,
3856    #[serde(rename = "chatgpt")]
3857    Chatgpt,
3858}
3859
3860#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3861#[serde(rename_all = "camelCase")]
3862pub struct LogoutAccountResponse {
3863    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
3864    pub extra: serde_json::Map<String, Value>,
3865}
3866
3867#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3868#[serde(rename_all = "camelCase")]
3869pub struct MarketplaceAddParams {
3870    #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
3871    pub ref_name: Option<String>,
3872    #[serde(default)]
3873    pub source: String,
3874    #[serde(
3875        rename = "sparsePaths",
3876        default,
3877        skip_serializing_if = "Option::is_none"
3878    )]
3879    pub sparse_paths: Option<Vec<String>>,
3880}
3881
3882#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3883#[serde(rename_all = "camelCase")]
3884pub struct MarketplaceAddResponse {
3885    #[serde(rename = "alreadyAdded", default)]
3886    pub already_added: bool,
3887    #[serde(rename = "installedRoot")]
3888    pub installed_root: AbsolutePathBuf,
3889    #[serde(rename = "marketplaceName", default)]
3890    pub marketplace_name: String,
3891}
3892
3893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3894#[serde(rename_all = "camelCase")]
3895pub struct MarketplaceInterface {
3896    #[serde(
3897        rename = "displayName",
3898        default,
3899        skip_serializing_if = "Option::is_none"
3900    )]
3901    pub display_name: Option<String>,
3902}
3903
3904#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3905#[serde(rename_all = "camelCase")]
3906pub struct MarketplaceLoadErrorInfo {
3907    #[serde(rename = "marketplacePath")]
3908    pub marketplace_path: AbsolutePathBuf,
3909    #[serde(default)]
3910    pub message: String,
3911}
3912
3913#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3914#[serde(rename_all = "camelCase")]
3915pub struct MarketplaceRemoveParams {
3916    #[serde(rename = "marketplaceName", default)]
3917    pub marketplace_name: String,
3918}
3919
3920#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3921#[serde(rename_all = "camelCase")]
3922pub struct MarketplaceRemoveResponse {
3923    #[serde(
3924        rename = "installedRoot",
3925        default,
3926        skip_serializing_if = "Option::is_none"
3927    )]
3928    pub installed_root: Option<AbsolutePathBuf>,
3929    #[serde(rename = "marketplaceName", default)]
3930    pub marketplace_name: String,
3931}
3932
3933#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3934#[serde(rename_all = "camelCase")]
3935pub struct MarketplaceUpgradeErrorInfo {
3936    #[serde(rename = "marketplaceName", default)]
3937    pub marketplace_name: String,
3938    #[serde(default)]
3939    pub message: String,
3940}
3941
3942#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3943#[serde(rename_all = "camelCase")]
3944pub struct MarketplaceUpgradeParams {
3945    #[serde(
3946        rename = "marketplaceName",
3947        default,
3948        skip_serializing_if = "Option::is_none"
3949    )]
3950    pub marketplace_name: Option<String>,
3951}
3952
3953#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3954#[serde(rename_all = "camelCase")]
3955pub struct MarketplaceUpgradeResponse {
3956    #[serde(default)]
3957    pub errors: Vec<MarketplaceUpgradeErrorInfo>,
3958    #[serde(rename = "selectedMarketplaces", default)]
3959    pub selected_marketplaces: Vec<String>,
3960    #[serde(rename = "upgradedRoots", default)]
3961    pub upgraded_roots: Vec<AbsolutePathBuf>,
3962}
3963
3964#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3965pub enum McpAuthStatus {
3966    #[serde(rename = "unknown")]
3967    Unknown,
3968    #[serde(rename = "unsupported")]
3969    Unsupported,
3970    #[serde(rename = "notLoggedIn")]
3971    NotLoggedIn,
3972    #[serde(rename = "bearerToken")]
3973    BearerToken,
3974    #[serde(rename = "oAuth")]
3975    OAuth,
3976}
3977
3978#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3979pub enum McpElicitationArrayType {
3980    #[serde(rename = "array")]
3981    Array,
3982}
3983
3984#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3985#[serde(rename_all = "camelCase")]
3986pub struct McpElicitationBooleanSchema {
3987    #[serde(default, skip_serializing_if = "Option::is_none")]
3988    pub default: Option<bool>,
3989    #[serde(default, skip_serializing_if = "Option::is_none")]
3990    pub description: Option<String>,
3991    #[serde(default, skip_serializing_if = "Option::is_none")]
3992    pub title: Option<String>,
3993    #[serde(rename = "type")]
3994    pub type_: McpElicitationBooleanType,
3995}
3996
3997#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3998pub enum McpElicitationBooleanType {
3999    #[serde(rename = "boolean")]
4000    Boolean,
4001}
4002
4003#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4004#[serde(rename_all = "camelCase")]
4005pub struct McpElicitationConstOption {
4006    #[serde(rename = "const", default)]
4007    pub const_: String,
4008    #[serde(default)]
4009    pub title: String,
4010}
4011
4012#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4013#[serde(untagged)]
4014pub enum McpElicitationEnumSchema {
4015    McpElicitationSingleSelectEnumSchema(McpElicitationSingleSelectEnumSchema),
4016    McpElicitationMultiSelectEnumSchema(McpElicitationMultiSelectEnumSchema),
4017    McpElicitationLegacyTitledEnumSchema(McpElicitationLegacyTitledEnumSchema),
4018}
4019
4020#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4021#[serde(rename_all = "camelCase")]
4022pub struct McpElicitationLegacyTitledEnumSchema {
4023    #[serde(default, skip_serializing_if = "Option::is_none")]
4024    pub default: Option<String>,
4025    #[serde(default, skip_serializing_if = "Option::is_none")]
4026    pub description: Option<String>,
4027    #[serde(rename = "enum", default)]
4028    pub enum_: Vec<String>,
4029    #[serde(rename = "enumNames", default, skip_serializing_if = "Option::is_none")]
4030    pub enum_names: Option<Vec<String>>,
4031    #[serde(default, skip_serializing_if = "Option::is_none")]
4032    pub title: Option<String>,
4033    #[serde(rename = "type")]
4034    pub type_: McpElicitationStringType,
4035}
4036
4037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4038#[serde(untagged)]
4039pub enum McpElicitationMultiSelectEnumSchema {
4040    McpElicitationUntitledMultiSelectEnumSchema(McpElicitationUntitledMultiSelectEnumSchema),
4041    McpElicitationTitledMultiSelectEnumSchema(McpElicitationTitledMultiSelectEnumSchema),
4042}
4043
4044#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4045#[serde(rename_all = "camelCase")]
4046pub struct McpElicitationNumberSchema {
4047    #[serde(default, skip_serializing_if = "Option::is_none")]
4048    pub default: Option<f64>,
4049    #[serde(default, skip_serializing_if = "Option::is_none")]
4050    pub description: Option<String>,
4051    #[serde(default, skip_serializing_if = "Option::is_none")]
4052    pub maximum: Option<f64>,
4053    #[serde(default, skip_serializing_if = "Option::is_none")]
4054    pub minimum: Option<f64>,
4055    #[serde(default, skip_serializing_if = "Option::is_none")]
4056    pub title: Option<String>,
4057    #[serde(rename = "type")]
4058    pub type_: McpElicitationNumberType,
4059}
4060
4061#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4062pub enum McpElicitationNumberType {
4063    #[serde(rename = "number")]
4064    Number,
4065    #[serde(rename = "integer")]
4066    Integer,
4067}
4068
4069#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4070pub enum McpElicitationObjectType {
4071    #[serde(rename = "object")]
4072    Object,
4073}
4074
4075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4076#[serde(untagged)]
4077pub enum McpElicitationPrimitiveSchema {
4078    McpElicitationEnumSchema(McpElicitationEnumSchema),
4079    McpElicitationStringSchema(McpElicitationStringSchema),
4080    McpElicitationNumberSchema(McpElicitationNumberSchema),
4081    McpElicitationBooleanSchema(McpElicitationBooleanSchema),
4082}
4083
4084#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4085#[serde(rename_all = "camelCase")]
4086pub struct McpElicitationSchema {
4087    #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
4088    pub schema: Option<String>,
4089    #[serde(default)]
4090    pub properties: std::collections::BTreeMap<String, McpElicitationPrimitiveSchema>,
4091    #[serde(default, skip_serializing_if = "Option::is_none")]
4092    pub required: Option<Vec<String>>,
4093    #[serde(rename = "type")]
4094    pub type_: McpElicitationObjectType,
4095}
4096
4097#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4098#[serde(untagged)]
4099pub enum McpElicitationSingleSelectEnumSchema {
4100    McpElicitationUntitledSingleSelectEnumSchema(McpElicitationUntitledSingleSelectEnumSchema),
4101    McpElicitationTitledSingleSelectEnumSchema(McpElicitationTitledSingleSelectEnumSchema),
4102}
4103
4104#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4105pub enum McpElicitationStringFormat {
4106    #[serde(rename = "email")]
4107    Email,
4108    #[serde(rename = "uri")]
4109    Uri,
4110    #[serde(rename = "date")]
4111    Date,
4112    #[serde(rename = "date-time")]
4113    Date_time,
4114}
4115
4116#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4117#[serde(rename_all = "camelCase")]
4118pub struct McpElicitationStringSchema {
4119    #[serde(default, skip_serializing_if = "Option::is_none")]
4120    pub default: Option<String>,
4121    #[serde(default, skip_serializing_if = "Option::is_none")]
4122    pub description: Option<String>,
4123    #[serde(default, skip_serializing_if = "Option::is_none")]
4124    pub format: Option<McpElicitationStringFormat>,
4125    #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
4126    pub max_length: Option<i64>,
4127    #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
4128    pub min_length: Option<i64>,
4129    #[serde(default, skip_serializing_if = "Option::is_none")]
4130    pub title: Option<String>,
4131    #[serde(rename = "type")]
4132    pub type_: McpElicitationStringType,
4133}
4134
4135#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4136pub enum McpElicitationStringType {
4137    #[serde(rename = "string")]
4138    String,
4139}
4140
4141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4142#[serde(rename_all = "camelCase")]
4143pub struct McpElicitationTitledEnumItems {
4144    #[serde(rename = "anyOf", default)]
4145    pub any_of: Vec<McpElicitationConstOption>,
4146}
4147
4148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4149#[serde(rename_all = "camelCase")]
4150pub struct McpElicitationTitledMultiSelectEnumSchema {
4151    #[serde(default, skip_serializing_if = "Option::is_none")]
4152    pub default: Option<Vec<String>>,
4153    #[serde(default, skip_serializing_if = "Option::is_none")]
4154    pub description: Option<String>,
4155    #[serde()]
4156    pub items: McpElicitationTitledEnumItems,
4157    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4158    pub max_items: Option<i64>,
4159    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4160    pub min_items: Option<i64>,
4161    #[serde(default, skip_serializing_if = "Option::is_none")]
4162    pub title: Option<String>,
4163    #[serde(rename = "type")]
4164    pub type_: McpElicitationArrayType,
4165}
4166
4167#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4168#[serde(rename_all = "camelCase")]
4169pub struct McpElicitationTitledSingleSelectEnumSchema {
4170    #[serde(default, skip_serializing_if = "Option::is_none")]
4171    pub default: Option<String>,
4172    #[serde(default, skip_serializing_if = "Option::is_none")]
4173    pub description: Option<String>,
4174    #[serde(rename = "oneOf", default)]
4175    pub one_of: Vec<McpElicitationConstOption>,
4176    #[serde(default, skip_serializing_if = "Option::is_none")]
4177    pub title: Option<String>,
4178    #[serde(rename = "type")]
4179    pub type_: McpElicitationStringType,
4180}
4181
4182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4183#[serde(rename_all = "camelCase")]
4184pub struct McpElicitationUntitledEnumItems {
4185    #[serde(rename = "enum", default)]
4186    pub enum_: Vec<String>,
4187    #[serde(rename = "type")]
4188    pub type_: McpElicitationStringType,
4189}
4190
4191#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4192#[serde(rename_all = "camelCase")]
4193pub struct McpElicitationUntitledMultiSelectEnumSchema {
4194    #[serde(default, skip_serializing_if = "Option::is_none")]
4195    pub default: Option<Vec<String>>,
4196    #[serde(default, skip_serializing_if = "Option::is_none")]
4197    pub description: Option<String>,
4198    #[serde()]
4199    pub items: McpElicitationUntitledEnumItems,
4200    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4201    pub max_items: Option<i64>,
4202    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4203    pub min_items: Option<i64>,
4204    #[serde(default, skip_serializing_if = "Option::is_none")]
4205    pub title: Option<String>,
4206    #[serde(rename = "type")]
4207    pub type_: McpElicitationArrayType,
4208}
4209
4210#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4211#[serde(rename_all = "camelCase")]
4212pub struct McpElicitationUntitledSingleSelectEnumSchema {
4213    #[serde(default, skip_serializing_if = "Option::is_none")]
4214    pub default: Option<String>,
4215    #[serde(default, skip_serializing_if = "Option::is_none")]
4216    pub description: Option<String>,
4217    #[serde(rename = "enum", default)]
4218    pub enum_: Vec<String>,
4219    #[serde(default, skip_serializing_if = "Option::is_none")]
4220    pub title: Option<String>,
4221    #[serde(rename = "type")]
4222    pub type_: McpElicitationStringType,
4223}
4224
4225#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4226#[serde(rename_all = "camelCase")]
4227pub struct McpResourceReadParams {
4228    #[serde(
4229        rename = "connectorId",
4230        default,
4231        skip_serializing_if = "Option::is_none"
4232    )]
4233    pub connector_id: Option<String>,
4234    /// Originating MCP tool call used to select the resource's app.
4235    #[serde(
4236        rename = "originCallId",
4237        default,
4238        skip_serializing_if = "Option::is_none"
4239    )]
4240    pub origin_call_id: Option<String>,
4241    #[serde(default)]
4242    pub server: String,
4243    /// Explicit hosted app/account. Omit to retain legacy resource discovery.
4244    #[serde(default, skip_serializing_if = "Option::is_none")]
4245    pub target: Option<McpResourceReadTarget>,
4246    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4247    pub thread_id: Option<String>,
4248    #[serde(default)]
4249    pub uri: String,
4250}
4251
4252/// Explicit hosted app/account selector for `mcpServer/resource/read`.
4253#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4254#[serde(rename_all = "camelCase")]
4255pub struct McpResourceReadTarget {
4256    #[serde(rename = "connectorId", default)]
4257    pub connector_id: String,
4258    /// Null explicitly requests no-auth access, subject to the app's resource
4259    /// policy. Always serialized (the wire field is required but nullable).
4260    #[serde(rename = "linkId", default)]
4261    pub link_id: Option<String>,
4262}
4263
4264#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4265#[serde(rename_all = "camelCase")]
4266pub struct McpResourceReadResponse {
4267    #[serde(default)]
4268    pub contents: Vec<ResourceContent>,
4269    /// Originating call when the server applied app-specific resource
4270    /// scoping.
4271    #[serde(
4272        rename = "originCallId",
4273        default,
4274        skip_serializing_if = "Option::is_none"
4275    )]
4276    pub origin_call_id: Option<String>,
4277}
4278
4279#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4280pub enum McpServerElicitationAction {
4281    #[serde(rename = "accept")]
4282    Accept,
4283    #[serde(rename = "decline")]
4284    Decline,
4285    #[serde(rename = "cancel")]
4286    Cancel,
4287}
4288
4289#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4290#[serde(tag = "mode", rename_all = "camelCase")]
4291pub enum McpServerElicitationRequestParams {
4292    Form {
4293        #[serde(default, skip_serializing_if = "Option::is_none")]
4294        _meta: Option<Value>,
4295        message: String,
4296        #[serde(rename = "requestedSchema")]
4297        requested_schema: McpElicitationSchema,
4298    },
4299    #[serde(rename = "openai/form")]
4300    OpenaiForm {
4301        #[serde(default, skip_serializing_if = "Option::is_none")]
4302        _meta: Option<Value>,
4303        message: String,
4304        #[serde(rename = "requestedSchema")]
4305        requested_schema: Value,
4306    },
4307    #[serde(rename = "openaiForm")]
4308    OpenAiElicitationForm {
4309        #[serde(default, skip_serializing_if = "Option::is_none")]
4310        _meta: Option<Value>,
4311        message: String,
4312        #[serde(rename = "requestedSchema")]
4313        requested_schema: Value,
4314    },
4315    Url {
4316        #[serde(default, skip_serializing_if = "Option::is_none")]
4317        _meta: Option<Value>,
4318        #[serde(rename = "elicitationId")]
4319        elicitation_id: String,
4320        message: String,
4321        url: String,
4322    },
4323}
4324
4325#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4326#[serde(rename_all = "camelCase")]
4327pub struct McpServerElicitationRequestResponse {
4328    #[serde(default, skip_serializing_if = "Option::is_none")]
4329    pub _meta: Option<Value>,
4330    #[serde()]
4331    pub action: McpServerElicitationAction,
4332    #[serde(default, skip_serializing_if = "Option::is_none")]
4333    pub content: Option<Value>,
4334}
4335
4336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4337#[serde(rename_all = "camelCase")]
4338pub struct McpServerInfo {
4339    #[serde(default, skip_serializing_if = "Option::is_none")]
4340    pub description: Option<String>,
4341    #[serde(default, skip_serializing_if = "Option::is_none")]
4342    pub icons: Option<Vec<Value>>,
4343    #[serde(default)]
4344    pub name: String,
4345    #[serde(default, skip_serializing_if = "Option::is_none")]
4346    pub title: Option<String>,
4347    #[serde(default)]
4348    pub version: String,
4349    #[serde(
4350        rename = "websiteUrl",
4351        default,
4352        skip_serializing_if = "Option::is_none"
4353    )]
4354    pub website_url: Option<String>,
4355}
4356
4357#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4358#[serde(rename_all = "camelCase")]
4359pub struct McpServerMigration {
4360    #[serde(default)]
4361    pub name: String,
4362}
4363
4364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4365#[serde(rename_all = "camelCase")]
4366pub struct McpServerOauthLoginCompletedNotification {
4367    #[serde(default, skip_serializing_if = "Option::is_none")]
4368    pub error: Option<String>,
4369    /// Identifies the explicit login attempt. Older servers omit this field.
4370    #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4371    pub login_id: Option<String>,
4372    #[serde(default)]
4373    pub name: String,
4374    #[serde(default)]
4375    pub success: bool,
4376    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4377    pub thread_id: Option<String>,
4378}
4379
4380#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4381#[serde(rename_all = "camelCase")]
4382pub struct McpServerOauthLoginParams {
4383    #[serde(
4384        rename = "clientRegistration",
4385        default,
4386        skip_serializing_if = "Option::is_none"
4387    )]
4388    pub client_registration: Option<McpServerOauthClientRegistration>,
4389    #[serde(default)]
4390    pub name: String,
4391    #[serde(default, skip_serializing_if = "Option::is_none")]
4392    pub scopes: Option<Vec<String>>,
4393    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4394    pub thread_id: Option<String>,
4395    #[serde(
4396        rename = "timeoutSecs",
4397        default,
4398        skip_serializing_if = "Option::is_none"
4399    )]
4400    pub timeout_secs: Option<i64>,
4401}
4402
4403#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4404#[serde(rename_all = "camelCase")]
4405pub struct McpServerOauthLoginResponse {
4406    #[serde(rename = "authorizationUrl", default)]
4407    pub authorization_url: String,
4408    /// Identifies this login attempt across the response and completion
4409    /// notification. Older servers omit this field; current servers always
4410    /// return it.
4411    #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4412    pub login_id: Option<String>,
4413}
4414
4415#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4416#[serde(rename_all = "camelCase")]
4417pub struct McpServerRefreshResponse {
4418    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4419    pub extra: serde_json::Map<String, Value>,
4420}
4421
4422#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4423pub enum McpServerStartupFailureReason {
4424    #[serde(rename = "reauthenticationRequired")]
4425    ReauthenticationRequired,
4426}
4427
4428#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4429pub enum McpServerStartupState {
4430    #[serde(rename = "starting")]
4431    Starting,
4432    #[serde(rename = "ready")]
4433    Ready,
4434    #[serde(rename = "failed")]
4435    Failed,
4436    #[serde(rename = "cancelled")]
4437    Cancelled,
4438}
4439
4440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4441#[serde(rename_all = "camelCase")]
4442pub struct McpServerStatus {
4443    #[serde(rename = "authStatus")]
4444    pub auth_status: McpAuthStatus,
4445    /// HTTP origin of the effective configured endpoint, including plugin
4446    /// servers. Excludes credentials, path, query, and fragment; `None` for
4447    /// non-HTTP transports.
4448    #[serde(
4449        rename = "httpOrigin",
4450        default,
4451        skip_serializing_if = "Option::is_none"
4452    )]
4453    pub http_origin: Option<String>,
4454    /// Current thread-runtime connection state; absent when unavailable.
4455    #[serde(
4456        rename = "runtimeStatus",
4457        default,
4458        skip_serializing_if = "Option::is_none"
4459    )]
4460    pub runtime_status: Option<McpServerConnectionStatus>,
4461    #[serde(default)]
4462    pub name: String,
4463    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
4464    pub plugin_id: Option<String>,
4465    #[serde(rename = "resourceTemplates", default)]
4466    pub resource_templates: Vec<ResourceTemplate>,
4467    #[serde(default)]
4468    pub resources: Vec<Resource>,
4469    /// Capabilities advertised by the initialized MCP server; `None` when
4470    /// unavailable.
4471    #[serde(
4472        rename = "serverCapabilities",
4473        default,
4474        skip_serializing_if = "Option::is_none"
4475    )]
4476    pub server_capabilities: Option<Value>,
4477    #[serde(
4478        rename = "serverInfo",
4479        default,
4480        skip_serializing_if = "Option::is_none"
4481    )]
4482    pub server_info: Option<McpServerInfo>,
4483    /// Opaque `_meta` from the first page of the corresponding MCP tool
4484    /// catalog; `None` when unavailable.
4485    #[serde(
4486        rename = "toolListMeta",
4487        default,
4488        skip_serializing_if = "Option::is_none"
4489    )]
4490    pub tool_list_meta: Option<Value>,
4491    #[serde(default)]
4492    pub tools: std::collections::BTreeMap<String, Tool>,
4493    /// Tool discovery failed and no catalog was returned. `None` when a
4494    /// catalog is returned, including cached or empty catalogs.
4495    #[serde(
4496        rename = "toolsError",
4497        default,
4498        skip_serializing_if = "Option::is_none"
4499    )]
4500    pub tools_error: Option<String>,
4501}
4502
4503#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4504pub enum McpServerStatusDetail {
4505    #[serde(rename = "full")]
4506    Full,
4507    #[serde(rename = "toolsAndAuthOnly")]
4508    ToolsAndAuthOnly,
4509}
4510
4511#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4512#[serde(rename_all = "camelCase")]
4513pub struct McpServerStatusUpdatedNotification {
4514    #[serde(default, skip_serializing_if = "Option::is_none")]
4515    pub error: Option<String>,
4516    #[serde(
4517        rename = "failureReason",
4518        default,
4519        skip_serializing_if = "Option::is_none"
4520    )]
4521    pub failure_reason: Option<McpServerStartupFailureReason>,
4522    #[serde(default)]
4523    pub name: String,
4524    #[serde()]
4525    pub status: McpServerStartupState,
4526    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4527    pub thread_id: Option<String>,
4528}
4529
4530#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4531#[serde(rename_all = "camelCase")]
4532pub struct McpServerToolCallParams {
4533    #[serde(default, skip_serializing_if = "Option::is_none")]
4534    pub _meta: Option<Value>,
4535    #[serde(default, skip_serializing_if = "Option::is_none")]
4536    pub arguments: Option<Value>,
4537    #[serde(default)]
4538    pub server: String,
4539    #[serde(rename = "threadId", default)]
4540    pub thread_id: String,
4541    #[serde(default)]
4542    pub tool: String,
4543}
4544
4545#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4546#[serde(rename_all = "camelCase")]
4547pub struct McpServerToolCallResponse {
4548    #[serde(default, skip_serializing_if = "Option::is_none")]
4549    pub _meta: Option<Value>,
4550    #[serde(default)]
4551    pub content: Vec<Value>,
4552    #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
4553    pub is_error: Option<bool>,
4554    #[serde(
4555        rename = "structuredContent",
4556        default,
4557        skip_serializing_if = "Option::is_none"
4558    )]
4559    pub structured_content: Option<Value>,
4560}
4561
4562/// UI resource and display preference for model invocations, captured from
4563/// the tool descriptor (`ThreadItem::McpToolCall::mcp_app_ui`).
4564#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
4565#[serde(rename_all = "camelCase")]
4566pub struct McpAppUi {
4567    #[serde(rename = "resourceUri")]
4568    pub resource_uri: String,
4569    #[serde(rename = "preferredModelDisplayMode")]
4570    pub preferred_model_display_mode: McpAppDisplayMode,
4571}
4572
4573#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4574pub enum McpAppDisplayMode {
4575    #[serde(rename = "inline")]
4576    Inline,
4577    #[serde(rename = "fullscreen")]
4578    Fullscreen,
4579}
4580
4581#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4582#[serde(rename_all = "camelCase")]
4583pub struct McpToolCallAppContext {
4584    #[serde(
4585        rename = "actionName",
4586        default,
4587        skip_serializing_if = "Option::is_none"
4588    )]
4589    pub action_name: Option<String>,
4590    #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
4591    pub app_name: Option<String>,
4592    #[serde(rename = "connectorId", default)]
4593    pub connector_id: String,
4594    #[serde(rename = "linkId", default, skip_serializing_if = "Option::is_none")]
4595    pub link_id: Option<String>,
4596    #[serde(
4597        rename = "resourceUri",
4598        default,
4599        skip_serializing_if = "Option::is_none"
4600    )]
4601    pub resource_uri: Option<String>,
4602}
4603
4604#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4605#[serde(rename_all = "camelCase")]
4606pub struct McpToolCallError {
4607    #[serde(default)]
4608    pub message: String,
4609}
4610
4611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4612#[serde(rename_all = "camelCase")]
4613pub struct McpToolCallProgressNotification {
4614    #[serde(rename = "itemId", default)]
4615    pub item_id: String,
4616    #[serde(default)]
4617    pub message: String,
4618    #[serde(rename = "threadId", default)]
4619    pub thread_id: String,
4620    #[serde(rename = "turnId", default)]
4621    pub turn_id: String,
4622}
4623
4624#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4625#[serde(rename_all = "camelCase")]
4626pub struct McpToolCallResult {
4627    #[serde(default, skip_serializing_if = "Option::is_none")]
4628    pub _meta: Option<Value>,
4629    #[serde(default)]
4630    pub content: Vec<Value>,
4631    #[serde(
4632        rename = "structuredContent",
4633        default,
4634        skip_serializing_if = "Option::is_none"
4635    )]
4636    pub structured_content: Option<Value>,
4637}
4638
4639#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4640pub enum McpToolCallStatus {
4641    #[serde(rename = "inProgress")]
4642    InProgress,
4643    #[serde(rename = "completed")]
4644    Completed,
4645    #[serde(rename = "failed")]
4646    Failed,
4647}
4648
4649#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4650#[serde(rename_all = "camelCase")]
4651pub struct MemoryCitation {
4652    #[serde(default)]
4653    pub entries: Vec<MemoryCitationEntry>,
4654    #[serde(rename = "threadIds", default)]
4655    pub thread_ids: Vec<String>,
4656}
4657
4658#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4659#[serde(rename_all = "camelCase")]
4660pub struct MemoryCitationEntry {
4661    #[serde(rename = "lineEnd", default)]
4662    pub line_end: i64,
4663    #[serde(rename = "lineStart", default)]
4664    pub line_start: i64,
4665    #[serde(default)]
4666    pub note: String,
4667    #[serde(default)]
4668    pub path: String,
4669}
4670
4671#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4672pub enum MergeStrategy {
4673    #[serde(rename = "replace")]
4674    Replace,
4675    #[serde(rename = "upsert")]
4676    Upsert,
4677}
4678
4679#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4680pub enum MessagePhase {
4681    #[serde(rename = "commentary")]
4682    Commentary,
4683    /// Stable answer text that may be followed by more assistant output or
4684    /// tools (openai/codex#51241).
4685    #[serde(rename = "partial_answer")]
4686    PartialAnswer,
4687    #[serde(rename = "final_answer")]
4688    FinalAnswer,
4689}
4690
4691#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4692#[serde(rename_all = "camelCase")]
4693pub struct MigrationDetails {
4694    #[serde(default, skip_serializing_if = "Option::is_none")]
4695    pub commands: Option<Vec<CommandMigration>>,
4696    #[serde(default, skip_serializing_if = "Option::is_none")]
4697    pub hooks: Option<Vec<HookMigration>>,
4698    #[serde(
4699        rename = "mcpServers",
4700        default,
4701        skip_serializing_if = "Option::is_none"
4702    )]
4703    pub mcp_servers: Option<Vec<McpServerMigration>>,
4704    #[serde(default, skip_serializing_if = "Option::is_none")]
4705    pub memory: Option<Vec<String>>,
4706    #[serde(default, skip_serializing_if = "Option::is_none")]
4707    pub plugins: Option<Vec<PluginsMigration>>,
4708    #[serde(default, skip_serializing_if = "Option::is_none")]
4709    pub sessions: Option<Vec<SessionMigration>>,
4710    #[serde(default, skip_serializing_if = "Option::is_none")]
4711    pub skills: Option<Vec<SkillMigration>>,
4712    #[serde(default, skip_serializing_if = "Option::is_none")]
4713    pub subagents: Option<Vec<SubagentMigration>>,
4714}
4715
4716/// Public explanation and continuation instruction attached to a
4717/// misalignment-blocked turn error (0.148 upstream).
4718#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4719#[serde(rename_all = "camelCase")]
4720pub struct MisalignmentErrorDetails {
4721    #[serde(
4722        rename = "detailedExplanation",
4723        default,
4724        skip_serializing_if = "Option::is_none"
4725    )]
4726    pub detailed_explanation: Option<String>,
4727    /// Open-ended classification; accept categories added upstream.
4728    #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
4729    pub error_type: Option<String>,
4730    /// Opaque server-issued block target. Presence alone does not enable
4731    /// target-based continuation (openai/codex#51217).
4732    #[serde(
4733        rename = "reviewTarget",
4734        default,
4735        skip_serializing_if = "Option::is_none"
4736    )]
4737    pub review_target: Option<String>,
4738    /// Instruction to submit as the next turn's user input if continuation
4739    /// is confirmed.
4740    #[serde(default, skip_serializing_if = "Option::is_none")]
4741    pub steer: Option<MisalignmentSteer>,
4742}
4743
4744/// The steering instruction inside [`MisalignmentErrorDetails`].
4745#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4746#[serde(rename_all = "camelCase")]
4747pub struct MisalignmentSteer {
4748    #[serde(default)]
4749    pub message: String,
4750}
4751
4752#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4753pub enum ModeKind {
4754    #[serde(rename = "plan")]
4755    Plan,
4756    #[serde(rename = "default")]
4757    Default,
4758}
4759
4760#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4761#[serde(rename_all = "camelCase")]
4762pub struct Model {
4763    #[serde(
4764        rename = "additionalSpeedTiers",
4765        default,
4766        skip_serializing_if = "Option::is_none"
4767    )]
4768    pub additional_speed_tiers: Option<Vec<String>>,
4769    #[serde(
4770        rename = "availabilityNux",
4771        default,
4772        skip_serializing_if = "Option::is_none"
4773    )]
4774    pub availability_nux: Option<ModelAvailabilityNux>,
4775    /// `None` when the catalog does not provide access-program metadata.
4776    #[serde(
4777        rename = "availableAccessPrograms",
4778        default,
4779        skip_serializing_if = "Option::is_none"
4780    )]
4781    pub available_access_programs: Option<ModelAccessPrograms>,
4782    #[serde(rename = "defaultReasoningEffort")]
4783    pub default_reasoning_effort: ReasoningEffort,
4784    #[serde(
4785        rename = "defaultServiceTier",
4786        default,
4787        skip_serializing_if = "Option::is_none"
4788    )]
4789    pub default_service_tier: Option<String>,
4790    #[serde(default)]
4791    pub description: String,
4792    #[serde(rename = "displayName", default)]
4793    pub display_name: String,
4794    #[serde(default)]
4795    pub hidden: bool,
4796    #[serde(default)]
4797    pub id: String,
4798    #[serde(
4799        rename = "inputModalities",
4800        default,
4801        skip_serializing_if = "Option::is_none"
4802    )]
4803    pub input_modalities: Option<Vec<InputModality>>,
4804    #[serde(rename = "isDefault", default)]
4805    pub is_default: bool,
4806    #[serde(default)]
4807    pub model: String,
4808    #[serde(
4809        rename = "modelSpecialty",
4810        default,
4811        skip_serializing_if = "Option::is_none"
4812    )]
4813    pub model_specialty: Option<String>,
4814    #[serde(
4815        rename = "multiAgentVersion",
4816        default,
4817        skip_serializing_if = "Option::is_none"
4818    )]
4819    pub multi_agent_version: Option<MultiAgentVersion>,
4820    #[serde(
4821        rename = "serviceTiers",
4822        default,
4823        skip_serializing_if = "Option::is_none"
4824    )]
4825    pub service_tiers: Option<Vec<ModelServiceTier>>,
4826    #[serde(rename = "supportedReasoningEfforts", default)]
4827    pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
4828    /// Deprecated upstream: always `false`; models no longer support
4829    /// personality selection.
4830    #[serde(
4831        rename = "supportsPersonality",
4832        default,
4833        skip_serializing_if = "Option::is_none"
4834    )]
4835    pub supports_personality: Option<bool>,
4836    #[serde(default, skip_serializing_if = "Option::is_none")]
4837    pub upgrade: Option<String>,
4838    #[serde(
4839        rename = "upgradeInfo",
4840        default,
4841        skip_serializing_if = "Option::is_none"
4842    )]
4843    pub upgrade_info: Option<ModelUpgradeInfo>,
4844}
4845
4846/// Caller-specific explicit access programs advertised by model discovery.
4847#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4848#[serde(rename_all = "camelCase")]
4849pub struct ModelAccessPrograms {
4850    /// Accepted explicit selections.
4851    #[serde(default)]
4852    pub cyber: Vec<CyberAccessProgram>,
4853}
4854
4855#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4856#[serde(rename_all = "camelCase")]
4857pub struct ModelAvailabilityNux {
4858    #[serde(default)]
4859    pub message: String,
4860}
4861
4862#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4863#[serde(rename_all = "camelCase")]
4864pub struct ModelListParams {
4865    #[serde(default, skip_serializing_if = "Option::is_none")]
4866    pub cursor: Option<String>,
4867    #[serde(
4868        rename = "includeHidden",
4869        default,
4870        skip_serializing_if = "Option::is_none"
4871    )]
4872    pub include_hidden: Option<bool>,
4873    #[serde(default, skip_serializing_if = "Option::is_none")]
4874    pub limit: Option<i64>,
4875}
4876
4877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4878#[serde(rename_all = "camelCase")]
4879pub struct ModelListResponse {
4880    #[serde(default)]
4881    pub data: Vec<Model>,
4882    #[serde(
4883        rename = "nextCursor",
4884        default,
4885        skip_serializing_if = "Option::is_none"
4886    )]
4887    pub next_cursor: Option<String>,
4888}
4889
4890#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4891#[serde(rename_all = "camelCase")]
4892pub struct ModelProviderCapabilitiesReadParams {
4893    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4894    pub extra: serde_json::Map<String, Value>,
4895}
4896
4897#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4898#[serde(rename_all = "camelCase")]
4899pub struct ModelProviderCapabilitiesReadResponse {
4900    #[serde(rename = "imageGeneration", default)]
4901    pub image_generation: bool,
4902    #[serde(rename = "webSearch", default)]
4903    pub web_search: bool,
4904}
4905
4906#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4907pub enum ModelRerouteReason {
4908    #[serde(rename = "highRiskCyberActivity")]
4909    HighRiskCyberActivity,
4910}
4911
4912#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4913#[serde(rename_all = "camelCase")]
4914pub struct ModelReroutedNotification {
4915    #[serde(rename = "fromModel", default)]
4916    pub from_model: String,
4917    #[serde()]
4918    pub reason: ModelRerouteReason,
4919    #[serde(rename = "threadId", default)]
4920    pub thread_id: String,
4921    #[serde(rename = "toModel", default)]
4922    pub to_model: String,
4923    #[serde(rename = "turnId", default)]
4924    pub turn_id: String,
4925}
4926
4927#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4928#[serde(rename_all = "camelCase")]
4929pub struct ModelSafetyBufferingUpdatedNotification {
4930    #[serde(
4931        rename = "fasterModel",
4932        default,
4933        skip_serializing_if = "Option::is_none"
4934    )]
4935    pub faster_model: Option<String>,
4936    #[serde(default)]
4937    pub model: String,
4938    #[serde(default)]
4939    pub reasons: Vec<String>,
4940    #[serde(rename = "showBufferingUi", default)]
4941    pub show_buffering_ui: bool,
4942    #[serde(rename = "threadId", default)]
4943    pub thread_id: String,
4944    #[serde(rename = "turnId", default)]
4945    pub turn_id: String,
4946    #[serde(rename = "useCases", default)]
4947    pub use_cases: Vec<String>,
4948}
4949
4950#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4951#[serde(rename_all = "camelCase")]
4952pub struct ModelServiceTier {
4953    #[serde(default)]
4954    pub description: String,
4955    #[serde(default)]
4956    pub id: String,
4957    #[serde(default)]
4958    pub name: String,
4959}
4960
4961#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4962#[serde(rename_all = "camelCase")]
4963pub struct ModelUpgradeInfo {
4964    #[serde(
4965        rename = "migrationMarkdown",
4966        default,
4967        skip_serializing_if = "Option::is_none"
4968    )]
4969    pub migration_markdown: Option<String>,
4970    #[serde(default)]
4971    pub model: String,
4972    /// Informational Unix timestamp for this upgrade's scheduled
4973    /// retirement, if known.
4974    #[serde(
4975        rename = "retirementAt",
4976        default,
4977        skip_serializing_if = "Option::is_none"
4978    )]
4979    pub retirement_at: Option<i64>,
4980    #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
4981    pub model_link: Option<String>,
4982    #[serde(
4983        rename = "upgradeCopy",
4984        default,
4985        skip_serializing_if = "Option::is_none"
4986    )]
4987    pub upgrade_copy: Option<String>,
4988}
4989
4990#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4991pub enum ModelVerification {
4992    #[serde(rename = "trustedAccessForCyber")]
4993    TrustedAccessForCyber,
4994}
4995
4996#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4997#[serde(rename_all = "camelCase")]
4998pub struct ModelVerificationNotification {
4999    #[serde(rename = "threadId", default)]
5000    pub thread_id: String,
5001    #[serde(rename = "turnId", default)]
5002    pub turn_id: String,
5003    #[serde(default)]
5004    pub verifications: Vec<ModelVerification>,
5005}
5006
5007#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5008#[serde(rename_all = "camelCase")]
5009pub struct ModelsRequirements {
5010    #[serde(rename = "newThread", default, skip_serializing_if = "Option::is_none")]
5011    pub new_thread: Option<NewThreadModelDefaults>,
5012}
5013
5014#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5015pub enum MultiAgentVersion {
5016    #[serde(rename = "disabled")]
5017    Disabled,
5018    #[serde(rename = "v1")]
5019    V1,
5020    #[serde(rename = "v2")]
5021    V2,
5022}
5023
5024#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5025pub enum NetworkAccess {
5026    #[serde(rename = "restricted")]
5027    Restricted,
5028    #[serde(rename = "enabled")]
5029    Enabled,
5030}
5031
5032#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5033#[serde(rename_all = "camelCase")]
5034pub struct NetworkApprovalContext {
5035    #[serde(default)]
5036    pub host: String,
5037    #[serde()]
5038    pub protocol: NetworkApprovalProtocol,
5039}
5040
5041#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5042pub enum NetworkApprovalProtocol {
5043    #[serde(rename = "http")]
5044    Http,
5045    #[serde(rename = "https")]
5046    Https,
5047    #[serde(rename = "socks5Tcp")]
5048    Socks5Tcp,
5049    #[serde(rename = "socks5Udp")]
5050    Socks5Udp,
5051}
5052
5053#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5054#[serde(rename_all = "camelCase")]
5055pub struct NetworkPolicyAmendment {
5056    #[serde()]
5057    pub action: NetworkPolicyRuleAction,
5058    #[serde(default)]
5059    pub host: String,
5060}
5061
5062#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5063pub enum NetworkPolicyRuleAction {
5064    #[serde(rename = "allow")]
5065    Allow,
5066    #[serde(rename = "deny")]
5067    Deny,
5068}
5069
5070#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5071#[serde(rename_all = "camelCase")]
5072pub struct NewThreadModelDefaults {
5073    #[serde(default, skip_serializing_if = "Option::is_none")]
5074    pub model: Option<String>,
5075    #[serde(
5076        rename = "modelReasoningEffort",
5077        default,
5078        skip_serializing_if = "Option::is_none"
5079    )]
5080    pub model_reasoning_effort: Option<ReasoningEffort>,
5081    #[serde(
5082        rename = "serviceTier",
5083        default,
5084        skip_serializing_if = "Option::is_none"
5085    )]
5086    pub service_tier: Option<String>,
5087}
5088
5089#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5090pub enum NonSteerableTurnKind {
5091    #[serde(rename = "review")]
5092    Review,
5093    #[serde(rename = "compact")]
5094    Compact,
5095}
5096
5097#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5098#[serde(rename_all = "camelCase")]
5099pub struct OverriddenMetadata {
5100    #[serde(rename = "effectiveValue", default)]
5101    pub effective_value: Value,
5102    #[serde(default)]
5103    pub message: String,
5104    #[serde(rename = "overridingLayer")]
5105    pub overriding_layer: ConfigLayerMetadata,
5106}
5107
5108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5109#[serde(tag = "type", rename_all = "camelCase")]
5110pub enum ParsedCommand {
5111    Read {
5112        cmd: String,
5113        name: String,
5114        path: String,
5115    },
5116    List_files {
5117        cmd: String,
5118        #[serde(default, skip_serializing_if = "Option::is_none")]
5119        path: Option<String>,
5120    },
5121    Search {
5122        cmd: String,
5123        #[serde(default, skip_serializing_if = "Option::is_none")]
5124        path: Option<String>,
5125        #[serde(default, skip_serializing_if = "Option::is_none")]
5126        query: Option<String>,
5127    },
5128    Unknown {
5129        cmd: String,
5130    },
5131}
5132
5133#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5134pub enum PatchApplyStatus {
5135    #[serde(rename = "inProgress")]
5136    InProgress,
5137    #[serde(rename = "completed")]
5138    Completed,
5139    #[serde(rename = "failed")]
5140    Failed,
5141    #[serde(rename = "declined")]
5142    Declined,
5143}
5144
5145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5146#[serde(tag = "type", rename_all = "camelCase")]
5147pub enum PatchChangeKind {
5148    Add,
5149    Delete,
5150    Update {
5151        #[serde(default, skip_serializing_if = "Option::is_none")]
5152        move_path: Option<String>,
5153    },
5154}
5155
5156#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5157pub enum PermissionGrantScope {
5158    #[serde(rename = "turn")]
5159    Turn,
5160    #[serde(rename = "session")]
5161    Session,
5162}
5163
5164#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5165#[serde(rename_all = "camelCase")]
5166pub struct PermissionProfileListParams {
5167    #[serde(default, skip_serializing_if = "Option::is_none")]
5168    pub cursor: Option<String>,
5169    #[serde(default, skip_serializing_if = "Option::is_none")]
5170    pub cwd: Option<String>,
5171    #[serde(default, skip_serializing_if = "Option::is_none")]
5172    pub limit: Option<i64>,
5173}
5174
5175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5176#[serde(rename_all = "camelCase")]
5177pub struct PermissionProfileListResponse {
5178    #[serde(default)]
5179    pub data: Vec<PermissionProfileSummary>,
5180    #[serde(
5181        rename = "nextCursor",
5182        default,
5183        skip_serializing_if = "Option::is_none"
5184    )]
5185    pub next_cursor: Option<String>,
5186}
5187
5188#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5189#[serde(rename_all = "camelCase")]
5190pub struct PermissionProfileSummary {
5191    #[serde(default)]
5192    pub allowed: bool,
5193    #[serde(default, skip_serializing_if = "Option::is_none")]
5194    pub description: Option<String>,
5195    #[serde(default)]
5196    pub id: String,
5197}
5198
5199#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5200#[serde(rename_all = "camelCase")]
5201pub struct PermissionsRequestApprovalParams {
5202    #[serde()]
5203    pub cwd: LegacyAppPathString,
5204    #[serde(
5205        rename = "environmentId",
5206        default,
5207        skip_serializing_if = "Option::is_none"
5208    )]
5209    pub environment_id: Option<String>,
5210    #[serde(rename = "itemId", default)]
5211    pub item_id: String,
5212    #[serde()]
5213    pub permissions: RequestPermissionProfile,
5214    #[serde(default, skip_serializing_if = "Option::is_none")]
5215    pub reason: Option<String>,
5216    #[serde(rename = "startedAtMs", default)]
5217    pub started_at_ms: i64,
5218    #[serde(rename = "threadId", default)]
5219    pub thread_id: String,
5220    #[serde(rename = "turnId", default)]
5221    pub turn_id: String,
5222}
5223
5224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5225#[serde(rename_all = "camelCase")]
5226pub struct PermissionsRequestApprovalResponse {
5227    #[serde()]
5228    pub permissions: GrantedPermissionProfile,
5229    #[serde(default, skip_serializing_if = "Option::is_none")]
5230    pub scope: Option<Value>,
5231    #[serde(
5232        rename = "strictAutoReview",
5233        default,
5234        skip_serializing_if = "Option::is_none"
5235    )]
5236    pub strict_auto_review: Option<bool>,
5237}
5238
5239/// Deprecated upstream: `friendly` and `pragmatic` no longer select a style,
5240/// and `Model::supports_personality` is now always `false`. The setting is
5241/// still reported and accepted on the wire; changing it on a turn does not
5242/// rewrite the thread's existing instructions.
5243#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5244pub enum Personality {
5245    #[serde(rename = "none")]
5246    None,
5247    #[serde(rename = "friendly")]
5248    Friendly,
5249    #[serde(rename = "pragmatic")]
5250    Pragmatic,
5251}
5252
5253#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5254#[serde(rename_all = "camelCase")]
5255pub struct PlanDeltaNotification {
5256    #[serde(default)]
5257    pub delta: String,
5258    #[serde(rename = "itemId", default)]
5259    pub item_id: String,
5260    #[serde(rename = "threadId", default)]
5261    pub thread_id: String,
5262    #[serde(rename = "turnId", default)]
5263    pub turn_id: String,
5264}
5265
5266#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5267pub enum PlanType {
5268    #[serde(rename = "free")]
5269    Free,
5270    #[serde(rename = "go")]
5271    Go,
5272    #[serde(rename = "plus")]
5273    Plus,
5274    #[serde(rename = "pro")]
5275    Pro,
5276    #[serde(rename = "prolite")]
5277    Prolite,
5278    #[serde(rename = "promax")]
5279    Promax,
5280    #[serde(rename = "edu_plus")]
5281    Edu_plus,
5282    #[serde(rename = "edu_pro")]
5283    Edu_pro,
5284    #[serde(rename = "team")]
5285    Team,
5286    #[serde(rename = "self_serve_business_prolite")]
5287    Self_serve_business_prolite,
5288    #[serde(rename = "self_serve_business_usage_based")]
5289    Self_serve_business_usage_based,
5290    #[serde(rename = "business")]
5291    Business,
5292    #[serde(rename = "ent26")]
5293    Ent26,
5294    #[serde(rename = "enterprise_cbp_automation")]
5295    Enterprise_cbp_automation,
5296    #[serde(rename = "enterprise_cbp_usage_based")]
5297    Enterprise_cbp_usage_based,
5298    #[serde(rename = "enterprise")]
5299    Enterprise,
5300    #[serde(rename = "edu")]
5301    Edu,
5302    #[serde(rename = "sci")]
5303    Sci,
5304    #[serde(rename = "sci_plus")]
5305    Sci_plus,
5306    #[serde(rename = "unknown")]
5307    Unknown,
5308}
5309
5310#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5311pub enum PluginAuthPolicy {
5312    #[serde(rename = "ON_INSTALL")]
5313    ON_INSTALL,
5314    #[serde(rename = "ON_USE")]
5315    ON_USE,
5316}
5317
5318#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5319pub enum PluginAvailability {
5320    #[serde(rename = "DISABLED_BY_ADMIN")]
5321    DISABLEDBYADMIN,
5322    AVAILABLE,
5323}
5324
5325#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5326#[serde(rename_all = "camelCase")]
5327pub struct PluginDetail {
5328    #[serde(rename = "appTemplates", default)]
5329    pub app_templates: Vec<AppTemplateSummary>,
5330    #[serde(default)]
5331    pub apps: Vec<AppSummary>,
5332    #[serde(default, skip_serializing_if = "Option::is_none")]
5333    pub description: Option<String>,
5334    #[serde(default)]
5335    pub hooks: Vec<PluginHookSummary>,
5336    #[serde(rename = "marketplaceName", default)]
5337    pub marketplace_name: String,
5338    #[serde(
5339        rename = "marketplacePath",
5340        default,
5341        skip_serializing_if = "Option::is_none"
5342    )]
5343    pub marketplace_path: Option<AbsolutePathBuf>,
5344    #[serde(rename = "mcpServers", default)]
5345    pub mcp_servers: Vec<String>,
5346    /// The declared onboarding skill, when the plugin and visible skill are enabled.
5347    #[serde(
5348        rename = "onboardingSkill",
5349        default,
5350        skip_serializing_if = "Option::is_none"
5351    )]
5352    pub onboarding_skill: Option<SkillSummary>,
5353    #[serde(
5354        rename = "scheduledTasks",
5355        default,
5356        skip_serializing_if = "Option::is_none"
5357    )]
5358    pub scheduled_tasks: Option<Vec<ScheduledTaskSummary>>,
5359    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5360    pub share_url: Option<String>,
5361    #[serde(default)]
5362    pub skills: Vec<SkillSummary>,
5363    #[serde()]
5364    pub summary: PluginSummary,
5365}
5366
5367#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5368pub enum PluginDisabledReason {
5369    #[serde(rename = "disabled_by_admin")]
5370    Disabled_by_admin,
5371    #[serde(rename = "plan_not_eligible")]
5372    Plan_not_eligible,
5373    #[serde(rename = "required_app_unavailable")]
5374    Required_app_unavailable,
5375    #[serde(rename = "unknown")]
5376    Unknown,
5377}
5378
5379#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5380#[serde(rename_all = "camelCase")]
5381pub struct PluginHookSummary {
5382    #[serde(rename = "eventName")]
5383    pub event_name: HookEventName,
5384    #[serde(default)]
5385    pub key: String,
5386}
5387
5388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5389#[serde(rename_all = "camelCase")]
5390pub struct PluginInstallParams {
5391    #[serde(
5392        rename = "installAttemptId",
5393        default,
5394        skip_serializing_if = "Option::is_none"
5395    )]
5396    pub install_attempt_id: Option<String>,
5397    #[serde(
5398        rename = "marketplacePath",
5399        default,
5400        skip_serializing_if = "Option::is_none"
5401    )]
5402    pub marketplace_path: Option<AbsolutePathBuf>,
5403    #[serde(rename = "pluginName", default)]
5404    pub plugin_name: String,
5405    #[serde(
5406        rename = "remoteMarketplaceName",
5407        default,
5408        skip_serializing_if = "Option::is_none"
5409    )]
5410    pub remote_marketplace_name: Option<String>,
5411}
5412
5413#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5414pub enum PluginInstallPolicy {
5415    #[serde(rename = "NOT_AVAILABLE")]
5416    NOT_AVAILABLE,
5417    #[serde(rename = "AVAILABLE")]
5418    AVAILABLE,
5419    #[serde(rename = "INSTALLED_BY_DEFAULT")]
5420    INSTALLED_BY_DEFAULT,
5421}
5422
5423#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5424pub enum PluginInstallPolicySource {
5425    #[serde(rename = "WORKSPACE_SETTING")]
5426    WORKSPACE_SETTING,
5427    #[serde(rename = "IMPLICIT_CANONICAL_APP")]
5428    IMPLICIT_CANONICAL_APP,
5429}
5430
5431#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5432#[serde(rename_all = "camelCase")]
5433pub struct PluginInstallResponse {
5434    #[serde(rename = "appsNeedingAuth", default)]
5435    pub apps_needing_auth: Vec<AppSummary>,
5436    #[serde(rename = "authPolicy")]
5437    pub auth_policy: PluginAuthPolicy,
5438}
5439
5440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5441#[serde(rename_all = "camelCase")]
5442pub struct PluginInstalledParams {
5443    #[serde(default, skip_serializing_if = "Option::is_none")]
5444    pub cwds: Option<Vec<AbsolutePathBuf>>,
5445    #[serde(
5446        rename = "installSuggestionPluginNames",
5447        default,
5448        skip_serializing_if = "Option::is_none"
5449    )]
5450    pub install_suggestion_plugin_names: Option<Vec<String>>,
5451}
5452
5453#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5454#[serde(rename_all = "camelCase")]
5455pub struct PluginInstalledResponse {
5456    #[serde(
5457        rename = "marketplaceLoadErrors",
5458        default,
5459        skip_serializing_if = "Option::is_none"
5460    )]
5461    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5462    #[serde(default)]
5463    pub marketplaces: Vec<PluginMarketplaceEntry>,
5464}
5465
5466#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5467#[serde(rename_all = "camelCase")]
5468pub struct PluginInterface {
5469    #[serde(
5470        rename = "brandColor",
5471        default,
5472        skip_serializing_if = "Option::is_none"
5473    )]
5474    pub brand_color: Option<String>,
5475    #[serde(default)]
5476    pub capabilities: Vec<String>,
5477    #[serde(default, skip_serializing_if = "Option::is_none")]
5478    pub category: Option<String>,
5479    #[serde(
5480        rename = "composerIcon",
5481        default,
5482        skip_serializing_if = "Option::is_none"
5483    )]
5484    pub composer_icon: Option<AbsolutePathBuf>,
5485    #[serde(
5486        rename = "composerIconUrl",
5487        default,
5488        skip_serializing_if = "Option::is_none"
5489    )]
5490    pub composer_icon_url: Option<String>,
5491    #[serde(
5492        rename = "defaultPrompt",
5493        default,
5494        skip_serializing_if = "Option::is_none"
5495    )]
5496    pub default_prompt: Option<Vec<String>>,
5497    #[serde(
5498        rename = "developerName",
5499        default,
5500        skip_serializing_if = "Option::is_none"
5501    )]
5502    pub developer_name: Option<String>,
5503    #[serde(
5504        rename = "displayName",
5505        default,
5506        skip_serializing_if = "Option::is_none"
5507    )]
5508    pub display_name: Option<String>,
5509    #[serde(default, skip_serializing_if = "Option::is_none")]
5510    pub logo: Option<AbsolutePathBuf>,
5511    #[serde(rename = "logoDark", default, skip_serializing_if = "Option::is_none")]
5512    pub logo_dark: Option<AbsolutePathBuf>,
5513    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
5514    pub logo_url: Option<String>,
5515    #[serde(
5516        rename = "logoUrlDark",
5517        default,
5518        skip_serializing_if = "Option::is_none"
5519    )]
5520    pub logo_url_dark: Option<String>,
5521    #[serde(
5522        rename = "longDescription",
5523        default,
5524        skip_serializing_if = "Option::is_none"
5525    )]
5526    pub long_description: Option<String>,
5527    #[serde(
5528        rename = "privacyPolicyUrl",
5529        default,
5530        skip_serializing_if = "Option::is_none"
5531    )]
5532    pub privacy_policy_url: Option<String>,
5533    #[serde(rename = "screenshotUrls", default)]
5534    pub screenshot_urls: Vec<String>,
5535    #[serde(default)]
5536    pub screenshots: Vec<AbsolutePathBuf>,
5537    #[serde(
5538        rename = "shortDescription",
5539        default,
5540        skip_serializing_if = "Option::is_none"
5541    )]
5542    pub short_description: Option<String>,
5543    #[serde(
5544        rename = "termsOfServiceUrl",
5545        default,
5546        skip_serializing_if = "Option::is_none"
5547    )]
5548    pub terms_of_service_url: Option<String>,
5549    #[serde(
5550        rename = "websiteUrl",
5551        default,
5552        skip_serializing_if = "Option::is_none"
5553    )]
5554    pub website_url: Option<String>,
5555}
5556
5557#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5558pub enum PluginListMarketplaceKind {
5559    #[serde(rename = "local")]
5560    Local,
5561    #[serde(rename = "vertical")]
5562    Vertical,
5563    #[serde(rename = "workspace-directory")]
5564    Workspace_directory,
5565    #[serde(rename = "shared-with-me")]
5566    Shared_with_me,
5567    #[serde(rename = "created-by-me-remote")]
5568    Created_by_me_remote,
5569}
5570
5571#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5572#[serde(rename_all = "camelCase")]
5573pub struct PluginListParams {
5574    #[serde(default, skip_serializing_if = "Option::is_none")]
5575    pub cwds: Option<Vec<AbsolutePathBuf>>,
5576    #[serde(
5577        rename = "forceRefetch",
5578        default,
5579        skip_serializing_if = "Option::is_none"
5580    )]
5581    pub force_refetch: Option<bool>,
5582    #[serde(
5583        rename = "marketplaceKinds",
5584        default,
5585        skip_serializing_if = "Option::is_none"
5586    )]
5587    pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
5588}
5589
5590#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5591#[serde(rename_all = "camelCase")]
5592pub struct PluginListResponse {
5593    #[serde(
5594        rename = "featuredPluginIds",
5595        default,
5596        skip_serializing_if = "Option::is_none"
5597    )]
5598    pub featured_plugin_ids: Option<Vec<String>>,
5599    #[serde(
5600        rename = "marketplaceLoadErrors",
5601        default,
5602        skip_serializing_if = "Option::is_none"
5603    )]
5604    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5605    #[serde(default)]
5606    pub marketplaces: Vec<PluginMarketplaceEntry>,
5607}
5608
5609#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5610#[serde(rename_all = "camelCase")]
5611pub struct PluginMarketplaceEntry {
5612    #[serde(default, skip_serializing_if = "Option::is_none")]
5613    pub interface: Option<MarketplaceInterface>,
5614    #[serde(default)]
5615    pub name: String,
5616    #[serde(default, skip_serializing_if = "Option::is_none")]
5617    pub path: Option<AbsolutePathBuf>,
5618    #[serde(default)]
5619    pub plugins: Vec<PluginSummary>,
5620}
5621
5622#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5623#[serde(rename_all = "camelCase")]
5624pub struct PluginReadParams {
5625    #[serde(
5626        rename = "marketplacePath",
5627        default,
5628        skip_serializing_if = "Option::is_none"
5629    )]
5630    pub marketplace_path: Option<AbsolutePathBuf>,
5631    #[serde(rename = "pluginName", default)]
5632    pub plugin_name: String,
5633    #[serde(
5634        rename = "remoteMarketplaceName",
5635        default,
5636        skip_serializing_if = "Option::is_none"
5637    )]
5638    pub remote_marketplace_name: Option<String>,
5639}
5640
5641#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5642#[serde(rename_all = "camelCase")]
5643pub struct PluginReadResponse {
5644    #[serde()]
5645    pub plugin: PluginDetail,
5646}
5647
5648/// Runtime categories affected by this change, not just capabilities
5649/// currently present. Flags describe declarations before runtime policy
5650/// filtering. Updates OR the old and new bundle flags; enablement changes and
5651/// cached reinstalls use the cached bundle; removals retain the old bundle's
5652/// flags.
5653#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5654#[serde(rename_all = "camelCase")]
5655pub struct PluginReconcileChangedPlugin {
5656    #[serde(rename = "hasApps", default)]
5657    pub has_apps: bool,
5658    #[serde(rename = "hasHooks", default)]
5659    pub has_hooks: bool,
5660    #[serde(rename = "hasMcps", default)]
5661    pub has_mcps: bool,
5662    /// Whether either bundle declares skill roots; not a validated inventory
5663    /// of enabled skills.
5664    #[serde(rename = "hasSkills", default)]
5665    pub has_skills: bool,
5666    /// Local plugin ID (`name@marketplace`), matching `PluginSummary.id`.
5667    #[serde(default)]
5668    pub id: String,
5669}
5670
5671#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5672#[serde(rename_all = "camelCase")]
5673pub struct PluginReconcileParams {
5674    /// Optional client-provided reason recorded with the reconciliation
5675    /// attempt.
5676    #[serde(default, skip_serializing_if = "Option::is_none")]
5677    pub reason: Option<String>,
5678}
5679
5680/// Bundle and installed-state changes observed by this pass, not a
5681/// runtime-readiness acknowledgement or a cumulative diff since the client's
5682/// last request. Other metadata-only changes are not listed.
5683#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5684#[serde(rename_all = "camelCase")]
5685pub struct PluginReconcileResponse {
5686    /// Plugins affected by bundle changes, enablement changes, or removals.
5687    /// Installed-state changes compare against the previous cached snapshot,
5688    /// including cached reinstalls. Removal hints survive cache cleanup
5689    /// failures; unchanged plugins are omitted.
5690    #[serde(rename = "changedPlugins", default)]
5691    pub changed_plugins: Vec<PluginReconcileChangedPlugin>,
5692    /// Subset of failures for which the requested bundle could not be
5693    /// materialized. A previously cached version may still be available.
5694    #[serde(rename = "failedMaterializationRemotePluginIds", default)]
5695    pub failed_materialization_remote_plugin_ids: Vec<String>,
5696    /// Backend remote plugin IDs whose bundle or identity update failed.
5697    #[serde(rename = "failedRemotePluginIds", default)]
5698    pub failed_remote_plugin_ids: Vec<String>,
5699}
5700
5701#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5702#[serde(rename_all = "camelCase")]
5703pub struct PluginShareCheckoutParams {
5704    #[serde(rename = "remotePluginId", default)]
5705    pub remote_plugin_id: String,
5706}
5707
5708#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5709#[serde(rename_all = "camelCase")]
5710pub struct PluginShareCheckoutResponse {
5711    #[serde(rename = "marketplaceName", default)]
5712    pub marketplace_name: String,
5713    #[serde(rename = "marketplacePath")]
5714    pub marketplace_path: AbsolutePathBuf,
5715    #[serde(rename = "pluginId", default)]
5716    pub plugin_id: String,
5717    #[serde(rename = "pluginName", default)]
5718    pub plugin_name: String,
5719    #[serde(rename = "pluginPath")]
5720    pub plugin_path: AbsolutePathBuf,
5721    #[serde(rename = "remotePluginId", default)]
5722    pub remote_plugin_id: String,
5723    #[serde(
5724        rename = "remoteVersion",
5725        default,
5726        skip_serializing_if = "Option::is_none"
5727    )]
5728    pub remote_version: Option<String>,
5729}
5730
5731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5732#[serde(rename_all = "camelCase")]
5733pub struct PluginShareContext {
5734    #[serde(
5735        rename = "canPublishToWorkspace",
5736        default,
5737        skip_serializing_if = "Option::is_none"
5738    )]
5739    pub can_publish_to_workspace: Option<bool>,
5740    #[serde(
5741        rename = "creatorAccountUserId",
5742        default,
5743        skip_serializing_if = "Option::is_none"
5744    )]
5745    pub creator_account_user_id: Option<String>,
5746    #[serde(
5747        rename = "creatorName",
5748        default,
5749        skip_serializing_if = "Option::is_none"
5750    )]
5751    pub creator_name: Option<String>,
5752    #[serde(default, skip_serializing_if = "Option::is_none")]
5753    pub discoverability: Option<PluginShareDiscoverability>,
5754    #[serde(rename = "remotePluginId", default)]
5755    pub remote_plugin_id: String,
5756    #[serde(
5757        rename = "remoteVersion",
5758        default,
5759        skip_serializing_if = "Option::is_none"
5760    )]
5761    pub remote_version: Option<String>,
5762    #[serde(
5763        rename = "sharePrincipals",
5764        default,
5765        skip_serializing_if = "Option::is_none"
5766    )]
5767    pub share_principals: Option<Vec<PluginSharePrincipal>>,
5768    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5769    pub share_url: Option<String>,
5770}
5771
5772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5773#[serde(rename_all = "camelCase")]
5774pub struct PluginShareDeleteParams {
5775    #[serde(rename = "remotePluginId", default)]
5776    pub remote_plugin_id: String,
5777}
5778
5779#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5780#[serde(rename_all = "camelCase")]
5781pub struct PluginShareDeleteResponse {
5782    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5783    pub extra: serde_json::Map<String, Value>,
5784}
5785
5786#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5787pub enum PluginShareDiscoverability {
5788    #[serde(rename = "LISTED")]
5789    LISTED,
5790    #[serde(rename = "UNLISTED")]
5791    UNLISTED,
5792    #[serde(rename = "PRIVATE")]
5793    PRIVATE,
5794}
5795
5796#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5797#[serde(rename_all = "camelCase")]
5798pub struct PluginShareListItem {
5799    #[serde(
5800        rename = "localPluginPath",
5801        default,
5802        skip_serializing_if = "Option::is_none"
5803    )]
5804    pub local_plugin_path: Option<AbsolutePathBuf>,
5805    #[serde()]
5806    pub plugin: PluginSummary,
5807}
5808
5809#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5810#[serde(rename_all = "camelCase")]
5811pub struct PluginShareListParams {
5812    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5813    pub extra: serde_json::Map<String, Value>,
5814}
5815
5816#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5817#[serde(rename_all = "camelCase")]
5818pub struct PluginShareListResponse {
5819    #[serde(default)]
5820    pub data: Vec<PluginShareListItem>,
5821}
5822
5823#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5824#[serde(rename_all = "camelCase")]
5825pub struct PluginSharePrincipal {
5826    #[serde(default)]
5827    pub name: String,
5828    #[serde(rename = "principalId", default)]
5829    pub principal_id: String,
5830    #[serde(rename = "principalType")]
5831    pub principal_type: PluginSharePrincipalType,
5832    #[serde()]
5833    pub role: PluginSharePrincipalRole,
5834}
5835
5836#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5837pub enum PluginSharePrincipalRole {
5838    #[serde(rename = "reader")]
5839    Reader,
5840    #[serde(rename = "editor")]
5841    Editor,
5842    #[serde(rename = "owner")]
5843    Owner,
5844}
5845
5846#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5847pub enum PluginSharePrincipalType {
5848    #[serde(rename = "user")]
5849    User,
5850    #[serde(rename = "group")]
5851    Group,
5852    #[serde(rename = "workspace")]
5853    Workspace,
5854}
5855
5856#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5857#[serde(rename_all = "camelCase")]
5858pub struct PluginShareSaveParams {
5859    #[serde(default, skip_serializing_if = "Option::is_none")]
5860    pub discoverability: Option<PluginShareDiscoverability>,
5861    #[serde(rename = "pluginPath")]
5862    pub plugin_path: AbsolutePathBuf,
5863    #[serde(
5864        rename = "remotePluginId",
5865        default,
5866        skip_serializing_if = "Option::is_none"
5867    )]
5868    pub remote_plugin_id: Option<String>,
5869    #[serde(
5870        rename = "shareTargets",
5871        default,
5872        skip_serializing_if = "Option::is_none"
5873    )]
5874    pub share_targets: Option<Vec<PluginShareTarget>>,
5875}
5876
5877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5878#[serde(rename_all = "camelCase")]
5879pub struct PluginShareSaveResponse {
5880    #[serde(
5881        rename = "canPublishToWorkspace",
5882        default,
5883        skip_serializing_if = "Option::is_none"
5884    )]
5885    pub can_publish_to_workspace: Option<bool>,
5886    #[serde(rename = "remotePluginId", default)]
5887    pub remote_plugin_id: String,
5888    #[serde(rename = "shareUrl", default)]
5889    pub share_url: String,
5890}
5891
5892#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5893#[serde(rename_all = "camelCase")]
5894pub struct PluginShareTarget {
5895    #[serde(rename = "principalId", default)]
5896    pub principal_id: String,
5897    #[serde(rename = "principalType")]
5898    pub principal_type: PluginSharePrincipalType,
5899    #[serde()]
5900    pub role: PluginShareTargetRole,
5901}
5902
5903#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5904pub enum PluginShareTargetRole {
5905    #[serde(rename = "reader")]
5906    Reader,
5907    #[serde(rename = "editor")]
5908    Editor,
5909}
5910
5911#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5912pub enum PluginShareUpdateDiscoverability {
5913    #[serde(rename = "UNLISTED")]
5914    UNLISTED,
5915    #[serde(rename = "PRIVATE")]
5916    PRIVATE,
5917    #[serde(rename = "LISTED")]
5918    LISTED,
5919}
5920
5921#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5922#[serde(rename_all = "camelCase")]
5923pub struct PluginShareUpdateTargetsParams {
5924    #[serde()]
5925    pub discoverability: PluginShareUpdateDiscoverability,
5926    #[serde(rename = "remotePluginId", default)]
5927    pub remote_plugin_id: String,
5928    #[serde(rename = "shareTargets", default)]
5929    pub share_targets: Vec<PluginShareTarget>,
5930}
5931
5932#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5933#[serde(rename_all = "camelCase")]
5934pub struct PluginShareUpdateTargetsResponse {
5935    #[serde()]
5936    pub discoverability: PluginShareDiscoverability,
5937    #[serde(default)]
5938    pub principals: Vec<PluginSharePrincipal>,
5939}
5940
5941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5942#[serde(rename_all = "camelCase")]
5943pub struct PluginSkillReadParams {
5944    #[serde(rename = "remoteMarketplaceName", default)]
5945    pub remote_marketplace_name: String,
5946    #[serde(rename = "remotePluginId", default)]
5947    pub remote_plugin_id: String,
5948    #[serde(rename = "skillName", default)]
5949    pub skill_name: String,
5950}
5951
5952#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5953#[serde(rename_all = "camelCase")]
5954pub struct PluginSkillReadResponse {
5955    #[serde(default, skip_serializing_if = "Option::is_none")]
5956    pub contents: Option<String>,
5957}
5958
5959#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5960#[serde(tag = "type", rename_all = "camelCase")]
5961pub enum PluginSource {
5962    Local {
5963        path: AbsolutePathBuf,
5964    },
5965    Git {
5966        #[serde(default, skip_serializing_if = "Option::is_none")]
5967        path: Option<String>,
5968        #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
5969        ref_name: Option<String>,
5970        #[serde(default, skip_serializing_if = "Option::is_none")]
5971        sha: Option<String>,
5972        url: String,
5973    },
5974    Npm {
5975        package: String,
5976        #[serde(default, skip_serializing_if = "Option::is_none")]
5977        registry: Option<String>,
5978        #[serde(default, skip_serializing_if = "Option::is_none")]
5979        version: Option<String>,
5980    },
5981    Remote,
5982}
5983
5984#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5985#[serde(rename_all = "camelCase")]
5986pub struct PluginSummary {
5987    #[serde(rename = "authPolicy")]
5988    pub auth_policy: PluginAuthPolicy,
5989    #[serde(default, skip_serializing_if = "Option::is_none")]
5990    pub availability: Option<Value>,
5991    #[serde(
5992        rename = "disabledReason",
5993        default,
5994        skip_serializing_if = "Option::is_none"
5995    )]
5996    pub disabled_reason: Option<PluginDisabledReason>,
5997    #[serde(
5998        rename = "eligiblePlanTypes",
5999        default,
6000        skip_serializing_if = "Option::is_none"
6001    )]
6002    pub eligible_plan_types: Option<Vec<String>>,
6003    #[serde(default)]
6004    pub enabled: bool,
6005    #[serde(default)]
6006    pub id: String,
6007    #[serde(rename = "installPolicy")]
6008    pub install_policy: PluginInstallPolicy,
6009    #[serde(
6010        rename = "installPolicySource",
6011        default,
6012        skip_serializing_if = "Option::is_none"
6013    )]
6014    pub install_policy_source: Option<PluginInstallPolicySource>,
6015    #[serde(default)]
6016    pub installed: bool,
6017    #[serde(
6018        rename = "installedAt",
6019        default,
6020        skip_serializing_if = "Option::is_none"
6021    )]
6022    pub installed_at: Option<i64>,
6023    #[serde(default, skip_serializing_if = "Option::is_none")]
6024    pub interface: Option<PluginInterface>,
6025    #[serde(default, skip_serializing_if = "Option::is_none")]
6026    pub keywords: Option<Vec<String>>,
6027    #[serde(
6028        rename = "localVersion",
6029        default,
6030        skip_serializing_if = "Option::is_none"
6031    )]
6032    pub local_version: Option<String>,
6033    #[serde(
6034        rename = "mustShowInstallationInterstitial",
6035        default,
6036        skip_serializing_if = "Option::is_none"
6037    )]
6038    pub must_show_installation_interstitial: Option<bool>,
6039    #[serde(default)]
6040    pub name: String,
6041    #[serde(
6042        rename = "remotePluginId",
6043        default,
6044        skip_serializing_if = "Option::is_none"
6045    )]
6046    pub remote_plugin_id: Option<String>,
6047    #[serde(
6048        rename = "shareContext",
6049        default,
6050        skip_serializing_if = "Option::is_none"
6051    )]
6052    pub share_context: Option<PluginShareContext>,
6053    #[serde()]
6054    pub source: PluginSource,
6055    #[serde(default, skip_serializing_if = "Option::is_none")]
6056    pub version: Option<String>,
6057}
6058
6059#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6060#[serde(rename_all = "camelCase")]
6061pub struct PluginUninstallParams {
6062    #[serde(rename = "pluginId", default)]
6063    pub plugin_id: String,
6064}
6065
6066#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6067#[serde(rename_all = "camelCase")]
6068pub struct PluginUninstallResponse {
6069    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6070    pub extra: serde_json::Map<String, Value>,
6071}
6072
6073#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6074#[serde(rename_all = "camelCase")]
6075pub struct PluginsMigration {
6076    #[serde(rename = "marketplaceName", default)]
6077    pub marketplace_name: String,
6078    #[serde(rename = "pluginNames", default)]
6079    pub plugin_names: Vec<String>,
6080}
6081
6082#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6083#[serde(rename_all = "camelCase")]
6084pub struct ProcessExitedNotification {
6085    #[serde(rename = "exitCode", default)]
6086    pub exit_code: i64,
6087    #[serde(rename = "processHandle", default)]
6088    pub process_handle: String,
6089    #[serde(default)]
6090    pub stderr: String,
6091    #[serde(rename = "stderrCapReached", default)]
6092    pub stderr_cap_reached: bool,
6093    #[serde(default)]
6094    pub stdout: String,
6095    #[serde(rename = "stdoutCapReached", default)]
6096    pub stdout_cap_reached: bool,
6097}
6098
6099#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6100#[serde(rename_all = "camelCase")]
6101pub struct ProcessOutputDeltaNotification {
6102    #[serde(rename = "capReached", default)]
6103    pub cap_reached: bool,
6104    #[serde(rename = "deltaBase64", default)]
6105    pub delta_base64: String,
6106    #[serde(rename = "processHandle", default)]
6107    pub process_handle: String,
6108    #[serde(default)]
6109    pub stream: Value,
6110}
6111
6112#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6113pub enum ProcessOutputStream {
6114    #[serde(rename = "stdout")]
6115    Stdout,
6116    #[serde(rename = "stderr")]
6117    Stderr,
6118}
6119
6120#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6121pub enum RateLimitReachedType {
6122    #[serde(rename = "rate_limit_reached")]
6123    Rate_limit_reached,
6124    #[serde(rename = "workspace_owner_credits_depleted")]
6125    Workspace_owner_credits_depleted,
6126    #[serde(rename = "workspace_member_credits_depleted")]
6127    Workspace_member_credits_depleted,
6128    #[serde(rename = "workspace_owner_usage_limit_reached")]
6129    Workspace_owner_usage_limit_reached,
6130    #[serde(rename = "workspace_member_usage_limit_reached")]
6131    Workspace_member_usage_limit_reached,
6132}
6133
6134#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6135#[serde(rename_all = "camelCase")]
6136pub struct RateLimitResetCredit {
6137    #[serde(default, skip_serializing_if = "Option::is_none")]
6138    pub description: Option<String>,
6139    #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
6140    pub expires_at: Option<i64>,
6141    #[serde(rename = "grantedAt", default)]
6142    pub granted_at: i64,
6143    #[serde(default)]
6144    pub id: String,
6145    #[serde(rename = "resetType")]
6146    pub reset_type: RateLimitResetType,
6147    #[serde()]
6148    pub status: RateLimitResetCreditStatus,
6149    #[serde(default, skip_serializing_if = "Option::is_none")]
6150    pub title: Option<String>,
6151}
6152
6153#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6154pub enum RateLimitResetCreditStatus {
6155    #[serde(rename = "available")]
6156    Available,
6157    #[serde(rename = "redeeming")]
6158    Redeeming,
6159    #[serde(rename = "redeemed")]
6160    Redeemed,
6161    #[serde(rename = "unknown")]
6162    Unknown,
6163}
6164
6165#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6166#[serde(rename_all = "camelCase")]
6167pub struct RateLimitResetCreditsSummary {
6168    #[serde(rename = "availableCount", default)]
6169    pub available_count: i64,
6170    #[serde(default, skip_serializing_if = "Option::is_none")]
6171    pub credits: Option<Vec<RateLimitResetCredit>>,
6172}
6173
6174#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6175pub enum RateLimitResetType {
6176    #[serde(rename = "codexRateLimits")]
6177    CodexRateLimits,
6178    #[serde(rename = "unknown")]
6179    Unknown,
6180}
6181
6182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6183#[serde(rename_all = "camelCase")]
6184pub struct RateLimitSnapshot {
6185    #[serde(default, skip_serializing_if = "Option::is_none")]
6186    pub credits: Option<CreditsSnapshot>,
6187    #[serde(
6188        rename = "individualLimit",
6189        default,
6190        skip_serializing_if = "Option::is_none"
6191    )]
6192    pub individual_limit: Option<SpendControlLimitSnapshot>,
6193    #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
6194    pub limit_id: Option<String>,
6195    #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
6196    pub limit_name: Option<String>,
6197    /// Normal model whose display name and reasoning options describe this
6198    /// quota alias.
6199    #[serde(
6200        rename = "normalModelSlug",
6201        default,
6202        skip_serializing_if = "Option::is_none"
6203    )]
6204    pub normal_model_slug: Option<String>,
6205    #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
6206    pub plan_type: Option<PlanType>,
6207    #[serde(default, skip_serializing_if = "Option::is_none")]
6208    pub primary: Option<RateLimitWindow>,
6209    #[serde(
6210        rename = "rateLimitReachedType",
6211        default,
6212        skip_serializing_if = "Option::is_none"
6213    )]
6214    pub rate_limit_reached_type: Option<RateLimitReachedType>,
6215    #[serde(default, skip_serializing_if = "Option::is_none")]
6216    pub secondary: Option<RateLimitWindow>,
6217    #[serde(
6218        rename = "spendControlReached",
6219        default,
6220        skip_serializing_if = "Option::is_none"
6221    )]
6222    pub spend_control_reached: Option<bool>,
6223}
6224
6225#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6226#[serde(rename_all = "camelCase")]
6227pub struct RateLimitWindow {
6228    #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
6229    pub resets_at: Option<i64>,
6230    #[serde(rename = "usedPercent", default)]
6231    pub used_percent: i64,
6232    #[serde(
6233        rename = "windowDurationMins",
6234        default,
6235        skip_serializing_if = "Option::is_none"
6236    )]
6237    pub window_duration_mins: Option<i64>,
6238}
6239
6240#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6241pub enum RealtimeConversationVersion {
6242    #[serde(rename = "v1")]
6243    V1,
6244    #[serde(rename = "v2")]
6245    V2,
6246    #[serde(rename = "v3")]
6247    V3,
6248}
6249
6250/// A non-empty reasoning effort value advertised by the model.
6251#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
6252#[serde(transparent)]
6253pub struct ReasoningEffort(pub String);
6254
6255#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6256#[serde(rename_all = "camelCase")]
6257pub struct ReasoningEffortOption {
6258    #[serde(default)]
6259    pub description: String,
6260    #[serde(rename = "reasoningEffort")]
6261    pub reasoning_effort: ReasoningEffort,
6262}
6263
6264#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6265pub enum ReasoningSummary {
6266    #[serde(rename = "auto")]
6267    Auto,
6268    #[serde(rename = "concise")]
6269    Concise,
6270    #[serde(rename = "detailed")]
6271    Detailed,
6272    #[serde(rename = "none")]
6273    None,
6274}
6275
6276#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6277#[serde(rename_all = "camelCase")]
6278pub struct ReasoningSummaryPartAddedNotification {
6279    #[serde(rename = "itemId", default)]
6280    pub item_id: String,
6281    #[serde(rename = "summaryIndex", default)]
6282    pub summary_index: i64,
6283    #[serde(rename = "threadId", default)]
6284    pub thread_id: String,
6285    #[serde(rename = "turnId", default)]
6286    pub turn_id: String,
6287}
6288
6289#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6290#[serde(rename_all = "camelCase")]
6291pub struct ReasoningSummaryTextDeltaNotification {
6292    #[serde(default)]
6293    pub delta: String,
6294    #[serde(rename = "itemId", default)]
6295    pub item_id: String,
6296    #[serde(rename = "summaryIndex", default)]
6297    pub summary_index: i64,
6298    #[serde(rename = "threadId", default)]
6299    pub thread_id: String,
6300    #[serde(rename = "turnId", default)]
6301    pub turn_id: String,
6302}
6303
6304#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6305#[serde(rename_all = "camelCase")]
6306pub struct ReasoningTextDeltaNotification {
6307    #[serde(rename = "contentIndex", default)]
6308    pub content_index: i64,
6309    #[serde(default)]
6310    pub delta: String,
6311    #[serde(rename = "itemId", default)]
6312    pub item_id: String,
6313    #[serde(rename = "threadId", default)]
6314    pub thread_id: String,
6315    #[serde(rename = "turnId", default)]
6316    pub turn_id: String,
6317}
6318
6319#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6320pub enum RemoteControlConnectionStatus {
6321    #[serde(rename = "disabled")]
6322    Disabled,
6323    #[serde(rename = "connecting")]
6324    Connecting,
6325    #[serde(rename = "connected")]
6326    Connected,
6327    #[serde(rename = "errored")]
6328    Errored,
6329}
6330
6331#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6332#[serde(rename_all = "camelCase")]
6333pub struct RemoteControlStatusChangedNotification {
6334    #[serde(
6335        rename = "environmentId",
6336        default,
6337        skip_serializing_if = "Option::is_none"
6338    )]
6339    pub environment_id: Option<String>,
6340    #[serde(rename = "installationId", default)]
6341    pub installation_id: String,
6342    #[serde(rename = "serverName", default)]
6343    pub server_name: String,
6344    #[serde()]
6345    pub status: RemoteControlConnectionStatus,
6346}
6347
6348#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6349#[serde(untagged)]
6350pub enum RequestId {
6351    Variant0(String),
6352    Variant1(i64),
6353}
6354
6355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6356#[serde(rename_all = "camelCase")]
6357pub struct RequestPermissionProfile {
6358    #[serde(
6359        rename = "fileSystem",
6360        default,
6361        skip_serializing_if = "Option::is_none"
6362    )]
6363    pub file_system: Option<AdditionalFileSystemPermissions>,
6364    #[serde(default, skip_serializing_if = "Option::is_none")]
6365    pub network: Option<AdditionalNetworkPermissions>,
6366}
6367
6368#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6369pub enum ResidencyRequirement {
6370    #[serde(rename = "us")]
6371    Us,
6372}
6373
6374#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6375#[serde(rename_all = "camelCase")]
6376pub struct Resource {
6377    #[serde(default, skip_serializing_if = "Option::is_none")]
6378    pub _meta: Option<Value>,
6379    #[serde(default, skip_serializing_if = "Option::is_none")]
6380    pub annotations: Option<Value>,
6381    #[serde(default, skip_serializing_if = "Option::is_none")]
6382    pub description: Option<String>,
6383    #[serde(default, skip_serializing_if = "Option::is_none")]
6384    pub icons: Option<Vec<Value>>,
6385    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6386    pub mime_type: Option<String>,
6387    #[serde(default)]
6388    pub name: String,
6389    #[serde(default, skip_serializing_if = "Option::is_none")]
6390    pub size: Option<i64>,
6391    #[serde(default, skip_serializing_if = "Option::is_none")]
6392    pub title: Option<String>,
6393    #[serde(default)]
6394    pub uri: String,
6395}
6396
6397#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6398#[serde(untagged)]
6399pub enum ResourceContent {
6400    Variant0(Value),
6401    Variant1(Value),
6402}
6403
6404#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6405#[serde(rename_all = "camelCase")]
6406pub struct ResourceTemplate {
6407    #[serde(default, skip_serializing_if = "Option::is_none")]
6408    pub annotations: Option<Value>,
6409    #[serde(default, skip_serializing_if = "Option::is_none")]
6410    pub description: Option<String>,
6411    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6412    pub mime_type: Option<String>,
6413    #[serde(default)]
6414    pub name: String,
6415    #[serde(default, skip_serializing_if = "Option::is_none")]
6416    pub title: Option<String>,
6417    #[serde(rename = "uriTemplate", default)]
6418    pub uri_template: String,
6419}
6420
6421/// Usage metadata reported for one upstream response (0.148 upstream).
6422#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6423#[serde(rename_all = "camelCase")]
6424pub struct ResponseUsageMetadata {
6425    #[serde(default, skip_serializing_if = "Option::is_none")]
6426    pub amount: Option<String>,
6427    #[serde(default, skip_serializing_if = "Option::is_none")]
6428    pub metadata: Option<Value>,
6429}
6430
6431#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6432pub enum ReviewDecision {
6433    #[serde(rename = "approved")]
6434    Approved,
6435    #[serde(rename = "approved_execpolicy_amendment")]
6436    ApprovedExecpolicyAmendment {
6437        proposed_execpolicy_amendment: Vec<String>,
6438    },
6439    #[serde(rename = "approved_for_session")]
6440    ApprovedForSession,
6441    #[serde(rename = "approved_mcp_policy_amendment")]
6442    ApprovedMcpPolicyAmendment,
6443    #[serde(rename = "network_policy_amendment")]
6444    NetworkPolicyAmendment {
6445        network_policy_amendment: NetworkPolicyAmendment,
6446    },
6447    #[serde(rename = "denied")]
6448    Denied { rejection: String },
6449    #[serde(rename = "timed_out")]
6450    TimedOut,
6451    #[serde(rename = "abort")]
6452    Abort,
6453}
6454
6455#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6456pub enum ReviewDelivery {
6457    #[serde(rename = "inline")]
6458    Inline,
6459    #[serde(rename = "detached")]
6460    Detached,
6461}
6462
6463#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6464#[serde(rename_all = "camelCase")]
6465pub struct ReviewStartParams {
6466    #[serde(default, skip_serializing_if = "Option::is_none")]
6467    pub delivery: Option<ReviewDelivery>,
6468    #[serde()]
6469    pub target: ReviewTarget,
6470    #[serde(rename = "threadId", default)]
6471    pub thread_id: String,
6472}
6473
6474#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6475#[serde(rename_all = "camelCase")]
6476pub struct ReviewStartResponse {
6477    #[serde(rename = "reviewThreadId", default)]
6478    pub review_thread_id: String,
6479    #[serde()]
6480    pub turn: Turn,
6481}
6482
6483#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6484#[serde(tag = "type", rename_all = "camelCase")]
6485pub enum ReviewTarget {
6486    #[serde(rename = "uncommittedChanges")]
6487    UncommittedChanges,
6488    #[serde(rename = "baseBranch")]
6489    BaseBranch {
6490        branch: String,
6491    },
6492    Commit {
6493        sha: String,
6494        #[serde(default, skip_serializing_if = "Option::is_none")]
6495        title: Option<String>,
6496    },
6497    Custom {
6498        instructions: String,
6499    },
6500}
6501
6502/// Delivery mode for an agent message item (0.147: currently only `async`).
6503#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6504pub enum AgentMessageDelivery {
6505    #[serde(rename = "async")]
6506    Async,
6507}
6508
6509/// Where the CLI stores auth credentials.
6510#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6511pub enum CliAuthCredentialsStoreMode {
6512    #[serde(rename = "file")]
6513    File,
6514    #[serde(rename = "keyring")]
6515    Keyring,
6516    #[serde(rename = "auto")]
6517    Auto,
6518    #[serde(rename = "ephemeral")]
6519    Ephemeral,
6520}
6521
6522/// A project grouping threads, owned by app-server.
6523#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6524pub struct Project {
6525    #[serde(rename = "createdAt", default)]
6526    pub created_at: i64,
6527    #[serde(default)]
6528    pub id: String,
6529    #[serde(default)]
6530    pub metadata: std::collections::HashMap<String, String>,
6531    #[serde(default)]
6532    pub name: String,
6533    #[serde(default)]
6534    pub position: i64,
6535    /// Newest non-archived member thread's recency, in Unix seconds;
6536    /// absent/null when none exist (0.148 upstream).
6537    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
6538    pub recency_at: Option<i64>,
6539    #[serde(default)]
6540    pub roots: Vec<ProjectRoot>,
6541    #[serde(rename = "updatedAt", default)]
6542    pub updated_at: i64,
6543}
6544
6545/// Sort order for project listings (0.148 upstream).
6546#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6547pub enum ProjectSortKey {
6548    #[serde(rename = "position")]
6549    Position,
6550    #[serde(rename = "recencyAt")]
6551    RecencyAt,
6552}
6553
6554#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6555pub enum ProjectChangeType {
6556    #[serde(rename = "created")]
6557    Created,
6558    #[serde(rename = "updated")]
6559    Updated,
6560    #[serde(rename = "deleted")]
6561    Deleted,
6562}
6563
6564/// `project/changed` — a project was created, updated, or deleted.
6565#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6566pub struct ProjectChangedNotification {
6567    #[serde(rename = "changeType")]
6568    pub change_type: ProjectChangeType,
6569    #[serde(rename = "projectId", default)]
6570    pub project_id: String,
6571}
6572
6573#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6574pub struct ProjectRoot {
6575    pub path: AbsolutePathBuf,
6576}
6577
6578/// A user submission waiting in a thread's queue.
6579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6580pub struct QueuedSubmission {
6581    #[serde(rename = "clientUserMessageId", default)]
6582    pub client_user_message_id: String,
6583    #[serde(default)]
6584    pub id: String,
6585    #[serde(default)]
6586    pub input: Vec<UserInput>,
6587}
6588
6589/// `autoApprovalReview/strictReviewRequired` — a strict review gate opened.
6590#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6591pub struct StrictReviewRequiredNotification {
6592    /// Unix timestamp (ms) when this review started.
6593    #[serde(rename = "startedAtMs", default)]
6594    pub started_at_ms: i64,
6595    #[serde(rename = "threadId", default)]
6596    pub thread_id: String,
6597    #[serde(rename = "turnId", default)]
6598    pub turn_id: String,
6599}
6600
6601/// `thread/project/updated` — a thread's project assignment changed.
6602#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6603pub struct ThreadProjectUpdatedNotification {
6604    #[serde(rename = "projectId", default)]
6605    pub project_id: Option<String>,
6606    #[serde(rename = "threadId", default)]
6607    pub thread_id: String,
6608}
6609
6610/// `thread/queue/changed` — the thread's queued submissions changed.
6611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6612pub struct ThreadQueueChangedNotification {
6613    #[serde(rename = "threadId", default)]
6614    pub thread_id: String,
6615}
6616
6617/// `thread/reverted` — the thread was rolled back.
6618#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6619pub struct ThreadRevertedNotification {
6620    #[serde(rename = "threadId", default)]
6621    pub thread_id: String,
6622}
6623
6624/// `thread/prediction/updated` — a prediction requested for a turn finished
6625/// (`openai/codex@main` 90abcfac, experimental).
6626#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6627#[serde(rename_all = "camelCase")]
6628pub struct ThreadPredictionUpdatedNotification {
6629    pub result: ThreadPredictionResult,
6630    #[serde(rename = "sourceTurnId", default)]
6631    pub source_turn_id: String,
6632    #[serde(rename = "threadId", default)]
6633    pub thread_id: String,
6634}
6635
6636/// Outcome of a thread prediction (`openai/codex@main` 90abcfac).
6637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6638#[serde(tag = "type", rename_all = "camelCase")]
6639pub enum ThreadPredictionResult {
6640    Completed {
6641        #[serde(default, skip_serializing_if = "Option::is_none")]
6642        text: Option<String>,
6643    },
6644    Failed,
6645}
6646
6647/// In-app browser requirements (0.148 upstream).
6648#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6649#[serde(rename_all = "camelCase")]
6650pub struct InAppBrowserRequirements {
6651    #[serde(
6652        rename = "allowExternalBrowserSettingsImport",
6653        default,
6654        skip_serializing_if = "Option::is_none"
6655    )]
6656    pub allow_external_browser_settings_import: Option<bool>,
6657}
6658
6659/// One MCP-server-originated notification, relayed verbatim.
6660#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6661pub struct McpServerEventNotification {
6662    #[serde(default)]
6663    pub method: String,
6664    #[serde(default)]
6665    pub params: Value,
6666}
6667
6668/// `mcpServer/event/stream/notification` — an MCP server's own
6669/// notification stream, forwarded to subscribers.
6670#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6671pub struct McpServerEventStreamNotification {
6672    pub notification: McpServerEventNotification,
6673    #[serde(rename = "subscriptionId", default)]
6674    pub subscription_id: String,
6675}
6676
6677/// Allow/deny switch used across the browser-use / computer-use policy
6678/// surface (0.148 upstream).
6679#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6680pub enum AllowDenyRequirement {
6681    #[serde(rename = "allow")]
6682    Allow,
6683    #[serde(rename = "deny")]
6684    Deny,
6685}
6686
6687/// How long a granted browser-use access approval lasts.
6688#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6689pub enum BrowserUseAccessApprovalLifetime {
6690    #[serde(rename = "turn")]
6691    Turn,
6692    #[serde(rename = "thread")]
6693    Thread,
6694}
6695
6696/// Current thread-runtime MCP server connection state.
6697#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6698pub enum McpServerConnectionStatus {
6699    #[serde(rename = "notStarted")]
6700    NotStarted,
6701    #[serde(rename = "starting")]
6702    Starting,
6703    #[serde(rename = "connected")]
6704    Connected,
6705    #[serde(rename = "authenticationRequired")]
6706    AuthenticationRequired,
6707    #[serde(rename = "failed")]
6708    Failed,
6709    #[serde(rename = "cancelled")]
6710    Cancelled,
6711    #[serde(rename = "disabled")]
6712    Disabled,
6713}
6714
6715/// Per-origin browser-use policy (requirements side, camelCase wire).
6716#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6717#[serde(rename_all = "camelCase")]
6718pub struct BrowserUseOriginPolicy {
6719    #[serde(default, skip_serializing_if = "Option::is_none")]
6720    pub access: Option<AllowDenyRequirement>,
6721    #[serde(
6722        rename = "accessApprovalLifetime",
6723        default,
6724        skip_serializing_if = "Option::is_none"
6725    )]
6726    pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
6727    #[serde(
6728        rename = "autoReview",
6729        default,
6730        skip_serializing_if = "Option::is_none"
6731    )]
6732    pub auto_review: Option<AllowDenyRequirement>,
6733    #[serde(default, skip_serializing_if = "Option::is_none")]
6734    pub downloads: Option<AllowDenyRequirement>,
6735    #[serde(
6736        rename = "fullCdpAccess",
6737        default,
6738        skip_serializing_if = "Option::is_none"
6739    )]
6740    pub full_cdp_access: Option<AllowDenyRequirement>,
6741    #[serde(
6742        rename = "persistentApproval",
6743        default,
6744        skip_serializing_if = "Option::is_none"
6745    )]
6746    pub persistent_approval: Option<bool>,
6747    #[serde(default, skip_serializing_if = "Option::is_none")]
6748    pub uploads: Option<AllowDenyRequirement>,
6749}
6750
6751/// Per-origin browser-use policy (config side, snake_case wire).
6752#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6753pub struct BrowserUseOriginPolicyConfig {
6754    #[serde(default, skip_serializing_if = "Option::is_none")]
6755    pub access: Option<AllowDenyRequirement>,
6756    #[serde(default, skip_serializing_if = "Option::is_none")]
6757    pub downloads: Option<AllowDenyRequirement>,
6758    #[serde(default, skip_serializing_if = "Option::is_none")]
6759    pub full_cdp_access: Option<AllowDenyRequirement>,
6760    #[serde(default, skip_serializing_if = "Option::is_none")]
6761    pub uploads: Option<AllowDenyRequirement>,
6762}
6763
6764/// Browser-use configuration (config side, snake_case wire).
6765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6766pub struct BrowserUseConfig {
6767    #[serde(default, skip_serializing_if = "Option::is_none")]
6768    pub allow_history_access: Option<bool>,
6769    #[serde(default, skip_serializing_if = "Option::is_none")]
6770    pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
6771    #[serde(default, skip_serializing_if = "Option::is_none")]
6772    pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
6773}
6774
6775/// Computer-use configuration (config side, snake_case wire).
6776#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6777pub struct ComputerUseConfig {
6778    #[serde(default, skip_serializing_if = "Option::is_none")]
6779    pub default_app_access: Option<AllowDenyRequirement>,
6780    #[serde(default, skip_serializing_if = "Option::is_none")]
6781    pub macos: Option<ComputerUseMacosConfig>,
6782    #[serde(default, skip_serializing_if = "Option::is_none")]
6783    pub windows: Option<ComputerUseWindowsConfig>,
6784}
6785
6786#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6787pub struct ComputerUseMacosConfig {
6788    #[serde(default, skip_serializing_if = "Option::is_none")]
6789    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6790}
6791
6792#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6793pub struct ComputerUseWindowsConfig {
6794    #[serde(default, skip_serializing_if = "Option::is_none")]
6795    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6796    #[serde(default, skip_serializing_if = "Option::is_none")]
6797    pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
6798}
6799
6800#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6801pub struct ComputerUseWindowsExeConfig {
6802    pub access: AllowDenyRequirement,
6803    #[serde(default, skip_serializing_if = "Option::is_none")]
6804    pub binary_name: Option<String>,
6805    #[serde(default)]
6806    pub product_name: String,
6807    #[serde(default)]
6808    pub publisher_name: String,
6809}
6810
6811/// Per-platform computer-use requirements (camelCase wire).
6812#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6813#[serde(rename_all = "camelCase")]
6814pub struct ComputerUseMacosRequirements {
6815    #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
6816    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6817}
6818
6819#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6820#[serde(rename_all = "camelCase")]
6821pub struct ComputerUseWindowsRequirements {
6822    #[serde(default, skip_serializing_if = "Option::is_none")]
6823    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6824    #[serde(default, skip_serializing_if = "Option::is_none")]
6825    pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
6826}
6827
6828#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6829#[serde(rename_all = "camelCase")]
6830pub struct ComputerUseWindowsExeRequirement {
6831    pub access: AllowDenyRequirement,
6832    #[serde(
6833        rename = "binaryName",
6834        default,
6835        skip_serializing_if = "Option::is_none"
6836    )]
6837    pub binary_name: Option<String>,
6838    #[serde(rename = "productName", default)]
6839    pub product_name: String,
6840    #[serde(rename = "publisherName", default)]
6841    pub publisher_name: String,
6842}
6843
6844#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6845pub enum SandboxMode {
6846    #[serde(rename = "read-only")]
6847    Read_only,
6848    #[serde(rename = "workspace-write")]
6849    Workspace_write,
6850    #[serde(rename = "danger-full-access")]
6851    Danger_full_access,
6852}
6853
6854#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6855#[serde(tag = "type", rename_all = "camelCase")]
6856pub enum SandboxPolicy {
6857    #[serde(rename = "dangerFullAccess")]
6858    DangerFullAccess,
6859    #[serde(rename = "readOnly")]
6860    ReadOnly {
6861        #[serde(
6862            rename = "networkAccess",
6863            default,
6864            skip_serializing_if = "Option::is_none"
6865        )]
6866        network_access: Option<bool>,
6867    },
6868    #[serde(rename = "externalSandbox")]
6869    ExternalSandbox {
6870        #[serde(
6871            rename = "networkAccess",
6872            default,
6873            skip_serializing_if = "Option::is_none"
6874        )]
6875        network_access: Option<Value>,
6876    },
6877    #[serde(rename = "workspaceWrite")]
6878    WorkspaceWrite {
6879        #[serde(
6880            rename = "excludeSlashTmp",
6881            default,
6882            skip_serializing_if = "Option::is_none"
6883        )]
6884        exclude_slash_tmp: Option<bool>,
6885        #[serde(
6886            rename = "excludeTmpdirEnvVar",
6887            default,
6888            skip_serializing_if = "Option::is_none"
6889        )]
6890        exclude_tmpdir_env_var: Option<bool>,
6891        #[serde(
6892            rename = "networkAccess",
6893            default,
6894            skip_serializing_if = "Option::is_none"
6895        )]
6896        network_access: Option<bool>,
6897        #[serde(
6898            rename = "writableRoots",
6899            default,
6900            skip_serializing_if = "Option::is_none"
6901        )]
6902        writable_roots: Option<Vec<AbsolutePathBuf>>,
6903    },
6904}
6905
6906#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6907#[serde(rename_all = "snake_case")]
6908pub struct SandboxWorkspaceWrite {
6909    #[serde(default, skip_serializing_if = "Option::is_none")]
6910    pub exclude_slash_tmp: Option<bool>,
6911    #[serde(default, skip_serializing_if = "Option::is_none")]
6912    pub exclude_tmpdir_env_var: Option<bool>,
6913    #[serde(default, skip_serializing_if = "Option::is_none")]
6914    pub network_access: Option<bool>,
6915    #[serde(default, skip_serializing_if = "Option::is_none")]
6916    pub writable_roots: Option<Vec<String>>,
6917}
6918
6919#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6920#[serde(tag = "type", rename_all = "camelCase")]
6921pub enum ScheduledTaskSchedule {
6922    Hourly {
6923        #[serde(default, skip_serializing_if = "Option::is_none")]
6924        days: Option<Vec<ScheduledTaskWeekday>>,
6925        #[serde(rename = "intervalHours")]
6926        interval_hours: i64,
6927    },
6928    Daily {
6929        time: String,
6930    },
6931    Weekdays {
6932        time: String,
6933    },
6934    Weekly {
6935        days: Vec<ScheduledTaskWeekday>,
6936        time: String,
6937    },
6938}
6939
6940#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6941#[serde(rename_all = "camelCase")]
6942pub struct ScheduledTaskSummary {
6943    #[serde(default)]
6944    pub key: String,
6945    #[serde(default)]
6946    pub name: String,
6947    #[serde(default)]
6948    pub prompt: String,
6949    #[serde()]
6950    pub schedule: ScheduledTaskSchedule,
6951}
6952
6953#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6954pub enum ScheduledTaskWeekday {
6955    #[serde(rename = "MO")]
6956    MO,
6957    #[serde(rename = "TU")]
6958    TU,
6959    #[serde(rename = "WE")]
6960    WE,
6961    #[serde(rename = "TH")]
6962    TH,
6963    #[serde(rename = "FR")]
6964    FR,
6965    #[serde(rename = "SA")]
6966    SA,
6967    #[serde(rename = "SU")]
6968    SU,
6969}
6970
6971#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6972#[serde(rename_all = "camelCase")]
6973pub struct SendAddCreditsNudgeEmailParams {
6974    #[serde(rename = "creditType")]
6975    pub credit_type: AddCreditsNudgeCreditType,
6976}
6977
6978#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6979#[serde(rename_all = "camelCase")]
6980pub struct SendAddCreditsNudgeEmailResponse {
6981    #[serde()]
6982    pub status: AddCreditsNudgeEmailStatus,
6983}
6984
6985#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6986#[serde(rename_all = "camelCase")]
6987pub struct ServerRequestResolvedNotification {
6988    #[serde(rename = "requestId")]
6989    pub request_id: RequestId,
6990    #[serde(rename = "threadId", default)]
6991    pub thread_id: String,
6992}
6993
6994#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6995#[serde(rename_all = "camelCase")]
6996pub struct SessionMigration {
6997    #[serde(default)]
6998    pub cwd: String,
6999    #[serde(default)]
7000    pub path: String,
7001    #[serde(default, skip_serializing_if = "Option::is_none")]
7002    pub title: Option<String>,
7003}
7004
7005#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7006pub enum SessionSource {
7007    #[serde(rename = "cli")]
7008    Cli,
7009    #[serde(rename = "vscode")]
7010    Vscode,
7011    #[serde(rename = "exec")]
7012    Exec,
7013    #[serde(rename = "appServer")]
7014    AppServer,
7015    #[serde(rename = "unknown")]
7016    Unknown,
7017    #[serde(rename = "custom")]
7018    Custom(String),
7019    #[serde(rename = "subAgent")]
7020    SubAgent(SubAgentSource),
7021}
7022
7023#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7024#[serde(rename_all = "camelCase")]
7025pub struct Settings {
7026    #[serde(default, skip_serializing_if = "Option::is_none")]
7027    pub developer_instructions: Option<String>,
7028    #[serde(default)]
7029    pub model: String,
7030    #[serde(default, skip_serializing_if = "Option::is_none")]
7031    pub reasoning_effort: Option<ReasoningEffort>,
7032}
7033
7034#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7035#[serde(rename_all = "camelCase")]
7036pub struct SkillDependencies {
7037    #[serde(default)]
7038    pub tools: Vec<SkillToolDependency>,
7039}
7040
7041#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7042#[serde(rename_all = "camelCase")]
7043pub struct SkillErrorInfo {
7044    #[serde(default)]
7045    pub message: String,
7046    #[serde(default)]
7047    pub path: String,
7048}
7049
7050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7051#[serde(rename_all = "camelCase")]
7052pub struct SkillInterface {
7053    #[serde(
7054        rename = "brandColor",
7055        default,
7056        skip_serializing_if = "Option::is_none"
7057    )]
7058    pub brand_color: Option<String>,
7059    #[serde(
7060        rename = "defaultPrompt",
7061        default,
7062        skip_serializing_if = "Option::is_none"
7063    )]
7064    pub default_prompt: Option<String>,
7065    #[serde(
7066        rename = "displayName",
7067        default,
7068        skip_serializing_if = "Option::is_none"
7069    )]
7070    pub display_name: Option<String>,
7071    #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
7072    pub icon_large: Option<AbsolutePathBuf>,
7073    #[serde(
7074        rename = "iconLargeUrl",
7075        default,
7076        skip_serializing_if = "Option::is_none"
7077    )]
7078    pub icon_large_url: Option<String>,
7079    #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
7080    pub icon_small: Option<AbsolutePathBuf>,
7081    #[serde(
7082        rename = "iconSmallUrl",
7083        default,
7084        skip_serializing_if = "Option::is_none"
7085    )]
7086    pub icon_small_url: Option<String>,
7087    #[serde(
7088        rename = "shortDescription",
7089        default,
7090        skip_serializing_if = "Option::is_none"
7091    )]
7092    pub short_description: Option<String>,
7093}
7094
7095#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7096#[serde(rename_all = "camelCase")]
7097pub struct SkillMetadata {
7098    #[serde(default, skip_serializing_if = "Option::is_none")]
7099    pub dependencies: Option<SkillDependencies>,
7100    #[serde(default)]
7101    pub description: String,
7102    #[serde(default)]
7103    pub enabled: bool,
7104    #[serde(default, skip_serializing_if = "Option::is_none")]
7105    pub interface: Option<SkillInterface>,
7106    #[serde(default)]
7107    pub name: String,
7108    #[serde()]
7109    pub path: LegacyAppPathString,
7110    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7111    pub plugin_id: Option<String>,
7112    #[serde()]
7113    pub scope: SkillScope,
7114    #[serde(
7115        rename = "shortDescription",
7116        default,
7117        skip_serializing_if = "Option::is_none"
7118    )]
7119    pub short_description: Option<String>,
7120}
7121
7122#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7123#[serde(rename_all = "camelCase")]
7124pub struct SkillMigration {
7125    #[serde(default)]
7126    pub name: String,
7127}
7128
7129#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7130pub enum SkillScope {
7131    #[serde(rename = "user")]
7132    User,
7133    #[serde(rename = "repo")]
7134    Repo,
7135    #[serde(rename = "system")]
7136    System,
7137    #[serde(rename = "admin")]
7138    Admin,
7139}
7140
7141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7142#[serde(rename_all = "camelCase")]
7143pub struct SkillSummary {
7144    #[serde(default)]
7145    pub description: String,
7146    #[serde(default)]
7147    pub enabled: bool,
7148    #[serde(default, skip_serializing_if = "Option::is_none")]
7149    pub interface: Option<SkillInterface>,
7150    #[serde(default)]
7151    pub name: String,
7152    #[serde(default, skip_serializing_if = "Option::is_none")]
7153    pub path: Option<LegacyAppPathString>,
7154    #[serde(
7155        rename = "shortDescription",
7156        default,
7157        skip_serializing_if = "Option::is_none"
7158    )]
7159    pub short_description: Option<String>,
7160}
7161
7162#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7163#[serde(rename_all = "camelCase")]
7164pub struct SkillToolDependency {
7165    #[serde(default, skip_serializing_if = "Option::is_none")]
7166    pub command: Option<String>,
7167    #[serde(default, skip_serializing_if = "Option::is_none")]
7168    pub description: Option<String>,
7169    #[serde(default, skip_serializing_if = "Option::is_none")]
7170    pub transport: Option<String>,
7171    #[serde(rename = "type", default)]
7172    pub type_: String,
7173    #[serde(default, skip_serializing_if = "Option::is_none")]
7174    pub url: Option<String>,
7175    #[serde(default)]
7176    pub value: String,
7177}
7178
7179#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7180#[serde(rename_all = "camelCase")]
7181pub struct SkillsChangedNotification {
7182    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7183    pub extra: serde_json::Map<String, Value>,
7184}
7185
7186#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7187#[serde(rename_all = "camelCase")]
7188pub struct SkillsConfigWriteParams {
7189    #[serde(default)]
7190    pub enabled: bool,
7191    #[serde(default, skip_serializing_if = "Option::is_none")]
7192    pub name: Option<String>,
7193    #[serde(default, skip_serializing_if = "Option::is_none")]
7194    pub path: Option<AbsolutePathBuf>,
7195}
7196
7197#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7198#[serde(rename_all = "camelCase")]
7199pub struct SkillsConfigWriteResponse {
7200    #[serde(rename = "effectiveEnabled", default)]
7201    pub effective_enabled: bool,
7202}
7203
7204#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7205#[serde(rename_all = "camelCase")]
7206pub struct SkillsExtraRootsSetParams {
7207    #[serde(rename = "extraRoots", default)]
7208    pub extra_roots: Vec<AbsolutePathBuf>,
7209}
7210
7211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7212#[serde(rename_all = "camelCase")]
7213pub struct SkillsExtraRootsSetResponse {
7214    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7215    pub extra: serde_json::Map<String, Value>,
7216}
7217
7218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7219#[serde(rename_all = "camelCase")]
7220pub struct SkillsListEntry {
7221    #[serde(default)]
7222    pub cwd: String,
7223    #[serde(default)]
7224    pub errors: Vec<SkillErrorInfo>,
7225    #[serde(default)]
7226    pub skills: Vec<SkillMetadata>,
7227}
7228
7229#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7230#[serde(rename_all = "camelCase")]
7231pub struct SkillsListParams {
7232    #[serde(default, skip_serializing_if = "Option::is_none")]
7233    pub cwds: Option<Vec<String>>,
7234    #[serde(
7235        rename = "forceReload",
7236        default,
7237        skip_serializing_if = "Option::is_none"
7238    )]
7239    pub force_reload: Option<bool>,
7240}
7241
7242#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7243#[serde(rename_all = "camelCase")]
7244pub struct SkillsListResponse {
7245    #[serde(default)]
7246    pub data: Vec<SkillsListEntry>,
7247}
7248
7249#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7250pub enum SortDirection {
7251    #[serde(rename = "asc")]
7252    Asc,
7253    #[serde(rename = "desc")]
7254    Desc,
7255}
7256
7257#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7258#[serde(rename_all = "camelCase")]
7259pub struct SpendControlLimitSnapshot {
7260    #[serde(default)]
7261    pub limit: String,
7262    #[serde(rename = "remainingPercent", default)]
7263    pub remaining_percent: i64,
7264    #[serde(rename = "resetsAt", default)]
7265    pub resets_at: i64,
7266    #[serde(default)]
7267    pub used: String,
7268}
7269
7270#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7271pub enum SubAgentActivityKind {
7272    #[serde(rename = "started")]
7273    Started,
7274    #[serde(rename = "interacted")]
7275    Interacted,
7276    #[serde(rename = "interrupted")]
7277    Interrupted,
7278    #[serde(rename = "completed")]
7279    Completed,
7280}
7281
7282#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7283pub enum SubAgentSource {
7284    #[serde(rename = "review")]
7285    Review,
7286    #[serde(rename = "compact")]
7287    Compact,
7288    #[serde(rename = "memory_consolidation")]
7289    MemoryConsolidation,
7290    #[serde(rename = "thread_spawn")]
7291    ThreadSpawn {
7292        #[serde(default, skip_serializing_if = "Option::is_none")]
7293        agent_nickname: Option<String>,
7294        #[serde(default, skip_serializing_if = "Option::is_none")]
7295        agent_path: Option<AgentPath>,
7296        #[serde(default, skip_serializing_if = "Option::is_none")]
7297        agent_role: Option<String>,
7298        depth: i64,
7299        parent_thread_id: ThreadId,
7300    },
7301    #[serde(rename = "other")]
7302    Other(String),
7303}
7304
7305#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7306#[serde(rename_all = "camelCase")]
7307pub struct SubagentMigration {
7308    #[serde(default)]
7309    pub name: String,
7310}
7311
7312#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7313#[serde(rename_all = "camelCase")]
7314pub struct TerminalInteractionNotification {
7315    #[serde(rename = "itemId", default)]
7316    pub item_id: String,
7317    #[serde(rename = "processId", default)]
7318    pub process_id: String,
7319    #[serde(default)]
7320    pub stdin: String,
7321    #[serde(rename = "threadId", default)]
7322    pub thread_id: String,
7323    #[serde(rename = "turnId", default)]
7324    pub turn_id: String,
7325}
7326
7327#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7328#[serde(rename_all = "camelCase")]
7329pub struct TextElement {
7330    #[serde(rename = "byteRange", default)]
7331    pub byte_range: Value,
7332    #[serde(default, skip_serializing_if = "Option::is_none")]
7333    pub placeholder: Option<String>,
7334}
7335
7336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7337#[serde(rename_all = "camelCase")]
7338pub struct TextPosition {
7339    #[serde(default)]
7340    pub column: i64,
7341    #[serde(default)]
7342    pub line: i64,
7343}
7344
7345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7346#[serde(rename_all = "camelCase")]
7347pub struct TextRange {
7348    #[serde()]
7349    pub end: TextPosition,
7350    #[serde()]
7351    pub start: TextPosition,
7352}
7353
7354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7355#[serde(rename_all = "camelCase")]
7356pub struct Thread {
7357    #[serde(
7358        rename = "agentNickname",
7359        default,
7360        skip_serializing_if = "Option::is_none"
7361    )]
7362    pub agent_nickname: Option<String>,
7363    #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
7364    pub agent_role: Option<String>,
7365    #[serde(rename = "cliVersion", default)]
7366    pub cli_version: String,
7367    #[serde(rename = "createdAt", default)]
7368    pub created_at: i64,
7369    #[serde(default)]
7370    pub cwd: Value,
7371    #[serde(default)]
7372    pub ephemeral: bool,
7373    #[serde(
7374        rename = "forkedFromId",
7375        default,
7376        skip_serializing_if = "Option::is_none"
7377    )]
7378    pub forked_from_id: Option<String>,
7379    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
7380    pub git_info: Option<GitInfo>,
7381    /// Persisted history contract chosen at thread creation (0.148 upstream);
7382    /// absent on older servers, which are always `legacy`.
7383    #[serde(
7384        rename = "historyMode",
7385        default,
7386        skip_serializing_if = "Option::is_none"
7387    )]
7388    pub history_mode: Option<ThreadHistoryMode>,
7389    /// Canonical project assignment owned by app-server, if any. Required
7390    /// upstream from 0.147 but kept tolerant for pre-project servers.
7391    #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
7392    pub project_id: Option<String>,
7393    #[serde(default)]
7394    pub id: String,
7395    /// Current configured model when loaded, otherwise the latest persisted
7396    /// model. Null when unavailable. Not per-turn execution telemetry.
7397    #[serde(default, skip_serializing_if = "Option::is_none")]
7398    pub model: Option<String>,
7399    #[serde(rename = "modelProvider", default)]
7400    pub model_provider: String,
7401    #[serde(default, skip_serializing_if = "Option::is_none")]
7402    pub name: Option<String>,
7403    /// Originator recorded when the thread was created, independent of its
7404    /// current client or executor. `None` when the recorded originator is
7405    /// unavailable.
7406    #[serde(default, skip_serializing_if = "Option::is_none")]
7407    pub originator: Option<String>,
7408    #[serde(
7409        rename = "parentThreadId",
7410        default,
7411        skip_serializing_if = "Option::is_none"
7412    )]
7413    pub parent_thread_id: Option<String>,
7414    #[serde(default, skip_serializing_if = "Option::is_none")]
7415    pub path: Option<String>,
7416    #[serde(default)]
7417    pub preview: String,
7418    /// Current configured reasoning effort when loaded, otherwise the latest
7419    /// persisted effort. Null when unset or unavailable. Not per-turn
7420    /// execution telemetry.
7421    #[serde(
7422        rename = "reasoningEffort",
7423        default,
7424        skip_serializing_if = "Option::is_none"
7425    )]
7426    pub reasoning_effort: Option<ReasoningEffort>,
7427    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7428    pub recency_at: Option<i64>,
7429    #[serde(default, skip_serializing_if = "Option::is_none")]
7430    pub section: Option<ThreadSection>,
7431    #[serde(
7432        rename = "sectionEnteredAt",
7433        default,
7434        skip_serializing_if = "Option::is_none"
7435    )]
7436    pub section_entered_at: Option<i64>,
7437    #[serde(rename = "sessionId", default)]
7438    pub session_id: String,
7439    #[serde(default)]
7440    pub source: Value,
7441    #[serde(default)]
7442    pub status: Value,
7443    #[serde(
7444        rename = "threadSource",
7445        default,
7446        skip_serializing_if = "Option::is_none"
7447    )]
7448    pub thread_source: Option<ThreadSource>,
7449    #[serde(default)]
7450    pub turns: Vec<Turn>,
7451    #[serde(rename = "updatedAt", default)]
7452    pub updated_at: i64,
7453}
7454
7455#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7456pub enum ThreadActiveFlag {
7457    #[serde(rename = "waitingOnApproval")]
7458    WaitingOnApproval,
7459    #[serde(rename = "waitingOnUserInput")]
7460    WaitingOnUserInput,
7461}
7462
7463#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7464#[serde(rename_all = "camelCase")]
7465pub struct ThreadApproveGuardianDeniedActionParams {
7466    #[serde(default)]
7467    pub event: Value,
7468    #[serde(rename = "threadId", default)]
7469    pub thread_id: String,
7470}
7471
7472#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7473#[serde(rename_all = "camelCase")]
7474pub struct ThreadApproveGuardianDeniedActionResponse {
7475    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7476    pub extra: serde_json::Map<String, Value>,
7477}
7478
7479#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7480#[serde(rename_all = "camelCase")]
7481pub struct ThreadArchiveParams {
7482    #[serde(rename = "threadId", default)]
7483    pub thread_id: String,
7484}
7485
7486#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7487#[serde(rename_all = "camelCase")]
7488pub struct ThreadArchiveResponse {
7489    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7490    pub extra: serde_json::Map<String, Value>,
7491}
7492
7493#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7494#[serde(rename_all = "camelCase")]
7495pub struct ThreadArchivedNotification {
7496    #[serde(rename = "threadId", default)]
7497    pub thread_id: String,
7498}
7499
7500/// An independently persisted attachment associated with a thread.
7501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7502#[serde(rename_all = "camelCase")]
7503pub struct ThreadAttachment {
7504    #[serde(rename = "attachmentType", default)]
7505    pub attachment_type: String,
7506    #[serde(rename = "createdAt", default)]
7507    pub created_at: i64,
7508    #[serde(default)]
7509    pub id: String,
7510    #[serde(rename = "identityKey", default)]
7511    pub identity_key: String,
7512    #[serde(default)]
7513    pub payload: Value,
7514}
7515
7516/// Result of attempting to associate an attachment with a thread.
7517#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7518pub enum ThreadAttachmentAddOutcome {
7519    #[serde(rename = "created")]
7520    Created,
7521    #[serde(rename = "existing")]
7522    Existing,
7523}
7524
7525/// Parameters for creating or locating an attachment on its owning thread.
7526#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7527#[serde(rename_all = "camelCase")]
7528pub struct ThreadAttachmentAddParams {
7529    #[serde(rename = "attachmentType", default)]
7530    pub attachment_type: String,
7531    #[serde(rename = "identityKey", default)]
7532    pub identity_key: String,
7533    #[serde(default)]
7534    pub payload: Value,
7535    #[serde(rename = "threadId", default)]
7536    pub thread_id: String,
7537}
7538
7539/// The created or existing attachment.
7540#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7541#[serde(rename_all = "camelCase")]
7542pub struct ThreadAttachmentAddResponse {
7543    pub attachment: ThreadAttachment,
7544    pub outcome: ThreadAttachmentAddOutcome,
7545}
7546
7547/// Parameters for listing attachments from one thread.
7548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7549#[serde(rename_all = "camelCase")]
7550pub struct ThreadAttachmentListParams {
7551    #[serde(default, skip_serializing_if = "Option::is_none")]
7552    pub cursor: Option<String>,
7553    #[serde(default, skip_serializing_if = "Option::is_none")]
7554    pub limit: Option<i64>,
7555    #[serde(rename = "threadId", default)]
7556    pub thread_id: String,
7557}
7558
7559/// One page of attachments associated with the requested thread.
7560#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7561#[serde(rename_all = "camelCase")]
7562pub struct ThreadAttachmentListResponse {
7563    #[serde(default)]
7564    pub data: Vec<ThreadAttachment>,
7565    #[serde(
7566        rename = "nextCursor",
7567        default,
7568        skip_serializing_if = "Option::is_none"
7569    )]
7570    pub next_cursor: Option<String>,
7571}
7572
7573/// The persisted attachment change represented by a notification.
7574#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7575pub enum ThreadAttachmentOperation {
7576    #[serde(rename = "created")]
7577    Created,
7578    #[serde(rename = "deleted")]
7579    Deleted,
7580}
7581
7582/// A thread that currently owns an attachment with the requested identity.
7583#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7584#[serde(rename_all = "camelCase")]
7585pub struct ThreadAttachmentOwner {
7586    /// Whether the owning thread is archived, not whether it is currently executing a turn.
7587    #[serde(default)]
7588    pub archived: bool,
7589    #[serde(rename = "threadId", default)]
7590    pub thread_id: String,
7591}
7592
7593/// Parameters for reverse lookup by attachment identity within this server's store.
7594#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7595#[serde(rename_all = "camelCase")]
7596pub struct ThreadAttachmentOwnerListParams {
7597    /// Omitted or null returns all matches; false returns non-archived threads only.
7598    #[serde(default, skip_serializing_if = "Option::is_none")]
7599    pub archived: Option<bool>,
7600    #[serde(rename = "attachmentType", default)]
7601    pub attachment_type: String,
7602    #[serde(default, skip_serializing_if = "Option::is_none")]
7603    pub cursor: Option<String>,
7604    #[serde(rename = "identityKey", default)]
7605    pub identity_key: String,
7606    #[serde(default, skip_serializing_if = "Option::is_none")]
7607    pub limit: Option<i64>,
7608}
7609
7610/// One page of matching owners, including threads without their own user messages.
7611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7612#[serde(rename_all = "camelCase")]
7613pub struct ThreadAttachmentOwnerListResponse {
7614    #[serde(default)]
7615    pub data: Vec<ThreadAttachmentOwner>,
7616    #[serde(
7617        rename = "nextCursor",
7618        default,
7619        skip_serializing_if = "Option::is_none"
7620    )]
7621    pub next_cursor: Option<String>,
7622}
7623
7624/// Parameters for deleting an attachment by its stable thread-local identity.
7625#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7626#[serde(rename_all = "camelCase")]
7627pub struct ThreadAttachmentRemoveParams {
7628    #[serde(rename = "attachmentType", default)]
7629    pub attachment_type: String,
7630    #[serde(rename = "identityKey", default)]
7631    pub identity_key: String,
7632    #[serde(rename = "threadId", default)]
7633    pub thread_id: String,
7634}
7635
7636/// Successful deletion does not return additional attachment data.
7637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7638#[serde(rename_all = "camelCase")]
7639pub struct ThreadAttachmentRemoveResponse {
7640    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7641    pub extra: serde_json::Map<String, Value>,
7642}
7643
7644/// Notification published after a thread attachment is created or deleted.
7645#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7646#[serde(rename_all = "camelCase")]
7647pub struct ThreadAttachmentUpdatedNotification {
7648    #[serde(rename = "attachmentId", default)]
7649    pub attachment_id: String,
7650    #[serde(rename = "attachmentType", default)]
7651    pub attachment_type: String,
7652    #[serde(rename = "identityKey", default)]
7653    pub identity_key: String,
7654    pub operation: ThreadAttachmentOperation,
7655    #[serde(rename = "threadId", default)]
7656    pub thread_id: String,
7657}
7658
7659#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7660#[serde(rename_all = "camelCase")]
7661pub struct ThreadClosedNotification {
7662    #[serde(rename = "threadId", default)]
7663    pub thread_id: String,
7664}
7665
7666#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7667#[serde(rename_all = "camelCase")]
7668pub struct ThreadCompactStartParams {
7669    #[serde(rename = "threadId", default)]
7670    pub thread_id: String,
7671}
7672
7673#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7674#[serde(rename_all = "camelCase")]
7675pub struct ThreadCompactStartResponse {
7676    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7677    pub extra: serde_json::Map<String, Value>,
7678}
7679
7680#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7681#[serde(rename_all = "camelCase")]
7682pub struct ThreadDeleteParams {
7683    #[serde(rename = "threadId", default)]
7684    pub thread_id: String,
7685}
7686
7687#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7688#[serde(rename_all = "camelCase")]
7689pub struct ThreadDeleteResponse {
7690    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7691    pub extra: serde_json::Map<String, Value>,
7692}
7693
7694#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7695#[serde(rename_all = "camelCase")]
7696pub struct ThreadDeletedNotification {
7697    #[serde(rename = "threadId", default)]
7698    pub thread_id: String,
7699}
7700
7701#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7702#[serde(rename_all = "camelCase")]
7703pub struct ThreadForkParams {
7704    #[serde(
7705        rename = "approvalPolicy",
7706        default,
7707        skip_serializing_if = "Option::is_none"
7708    )]
7709    pub approval_policy: Option<AskForApproval>,
7710    #[serde(
7711        rename = "approvalsReviewer",
7712        default,
7713        skip_serializing_if = "Option::is_none"
7714    )]
7715    pub approvals_reviewer: Option<ApprovalsReviewer>,
7716    #[serde(
7717        rename = "baseInstructions",
7718        default,
7719        skip_serializing_if = "Option::is_none"
7720    )]
7721    pub base_instructions: Option<String>,
7722    #[serde(default, skip_serializing_if = "Option::is_none")]
7723    pub config: Option<Value>,
7724    #[serde(default, skip_serializing_if = "Option::is_none")]
7725    pub cwd: Option<String>,
7726    #[serde(
7727        rename = "developerInstructions",
7728        default,
7729        skip_serializing_if = "Option::is_none"
7730    )]
7731    pub developer_instructions: Option<String>,
7732    #[serde(default, skip_serializing_if = "Option::is_none")]
7733    pub ephemeral: Option<bool>,
7734    #[serde(
7735        rename = "excludeTurns",
7736        default,
7737        skip_serializing_if = "Option::is_none"
7738    )]
7739    pub exclude_turns: Option<bool>,
7740    #[serde(
7741        rename = "lastTurnId",
7742        default,
7743        skip_serializing_if = "Option::is_none"
7744    )]
7745    pub last_turn_id: Option<String>,
7746    #[serde(default, skip_serializing_if = "Option::is_none")]
7747    pub model: Option<String>,
7748    #[serde(
7749        rename = "modelProvider",
7750        default,
7751        skip_serializing_if = "Option::is_none"
7752    )]
7753    pub model_provider: Option<String>,
7754    #[serde(default, skip_serializing_if = "Option::is_none")]
7755    pub sandbox: Option<SandboxMode>,
7756    #[serde(
7757        rename = "serviceTier",
7758        default,
7759        skip_serializing_if = "Option::is_none"
7760    )]
7761    pub service_tier: Option<String>,
7762    #[serde(rename = "threadId", default)]
7763    pub thread_id: String,
7764    #[serde(
7765        rename = "threadSource",
7766        default,
7767        skip_serializing_if = "Option::is_none"
7768    )]
7769    pub thread_source: Option<ThreadSource>,
7770}
7771
7772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7773#[serde(rename_all = "camelCase")]
7774pub struct ThreadForkResponse {
7775    #[serde(rename = "approvalPolicy")]
7776    pub approval_policy: AskForApproval,
7777    #[serde(rename = "approvalsReviewer", default)]
7778    pub approvals_reviewer: Value,
7779    #[serde()]
7780    pub cwd: AbsolutePathBuf,
7781    /// Saved list of disabled plugin IDs. Does not yet filter plugin
7782    /// capabilities.
7783    #[serde(rename = "disabledPluginIds", default)]
7784    pub disabled_plugin_ids: Vec<String>,
7785    #[serde(
7786        rename = "instructionSources",
7787        default,
7788        skip_serializing_if = "Option::is_none"
7789    )]
7790    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
7791    #[serde(default)]
7792    pub model: String,
7793    #[serde(rename = "modelProvider", default)]
7794    pub model_provider: String,
7795    #[serde(
7796        rename = "reasoningEffort",
7797        default,
7798        skip_serializing_if = "Option::is_none"
7799    )]
7800    pub reasoning_effort: Option<ReasoningEffort>,
7801    #[serde(default)]
7802    pub sandbox: Value,
7803    #[serde(
7804        rename = "serviceTier",
7805        default,
7806        skip_serializing_if = "Option::is_none"
7807    )]
7808    pub service_tier: Option<String>,
7809    #[serde()]
7810    pub thread: Thread,
7811}
7812
7813#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7814#[serde(rename_all = "camelCase")]
7815pub struct ThreadGoal {
7816    #[serde(rename = "createdAt", default)]
7817    pub created_at: i64,
7818    #[serde(default)]
7819    pub objective: String,
7820    #[serde()]
7821    pub status: ThreadGoalStatus,
7822    #[serde(rename = "threadId", default)]
7823    pub thread_id: String,
7824    #[serde(rename = "timeUsedSeconds", default)]
7825    pub time_used_seconds: i64,
7826    #[serde(
7827        rename = "tokenBudget",
7828        default,
7829        skip_serializing_if = "Option::is_none"
7830    )]
7831    pub token_budget: Option<i64>,
7832    #[serde(rename = "tokensUsed", default)]
7833    pub tokens_used: i64,
7834    #[serde(rename = "updatedAt", default)]
7835    pub updated_at: i64,
7836}
7837
7838#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7839#[serde(rename_all = "camelCase")]
7840pub struct ThreadGoalClearParams {
7841    /// Missing provenance does not supply user authorization.
7842    #[serde(default, skip_serializing_if = "Option::is_none")]
7843    pub origin: Option<ThreadGoalMutationOrigin>,
7844    #[serde(rename = "threadId", default)]
7845    pub thread_id: String,
7846}
7847
7848#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7849#[serde(rename_all = "camelCase")]
7850pub struct ThreadGoalClearResponse {
7851    #[serde(default)]
7852    pub cleared: bool,
7853}
7854
7855#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7856#[serde(rename_all = "camelCase")]
7857pub struct ThreadGoalClearedNotification {
7858    #[serde(rename = "threadId", default)]
7859    pub thread_id: String,
7860}
7861
7862#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7863#[serde(rename_all = "camelCase")]
7864pub struct ThreadGoalGetParams {
7865    #[serde(rename = "threadId", default)]
7866    pub thread_id: String,
7867}
7868
7869#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7870#[serde(rename_all = "camelCase")]
7871pub struct ThreadGoalGetResponse {
7872    #[serde(default, skip_serializing_if = "Option::is_none")]
7873    pub goal: Option<ThreadGoal>,
7874}
7875
7876/// Distinguishes explicit user actions from automatic goal lifecycle mutations.
7877#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7878pub enum ThreadGoalMutationOrigin {
7879    #[serde(rename = "user")]
7880    User,
7881    #[serde(rename = "automatic")]
7882    Automatic,
7883}
7884
7885#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7886#[serde(rename_all = "camelCase")]
7887pub struct ThreadGoalSetParams {
7888    #[serde(default, skip_serializing_if = "Option::is_none")]
7889    pub objective: Option<String>,
7890    /// Missing provenance does not supply user authorization.
7891    #[serde(default, skip_serializing_if = "Option::is_none")]
7892    pub origin: Option<ThreadGoalMutationOrigin>,
7893    #[serde(default, skip_serializing_if = "Option::is_none")]
7894    pub status: Option<ThreadGoalStatus>,
7895    #[serde(rename = "threadId", default)]
7896    pub thread_id: String,
7897    #[serde(
7898        rename = "tokenBudget",
7899        default,
7900        skip_serializing_if = "Option::is_none"
7901    )]
7902    pub token_budget: Option<i64>,
7903}
7904
7905#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7906#[serde(rename_all = "camelCase")]
7907pub struct ThreadGoalSetResponse {
7908    #[serde()]
7909    pub goal: ThreadGoal,
7910}
7911
7912#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7913pub enum ThreadGoalStatus {
7914    #[serde(rename = "active")]
7915    Active,
7916    #[serde(rename = "paused")]
7917    Paused,
7918    #[serde(rename = "blocked")]
7919    Blocked,
7920    #[serde(rename = "usageLimited")]
7921    UsageLimited,
7922    #[serde(rename = "budgetLimited")]
7923    BudgetLimited,
7924    #[serde(rename = "complete")]
7925    Complete,
7926}
7927
7928#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7929#[serde(rename_all = "camelCase")]
7930pub struct ThreadGoalUpdatedNotification {
7931    #[serde()]
7932    pub goal: ThreadGoal,
7933    #[serde(rename = "threadId", default)]
7934    pub thread_id: String,
7935    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
7936    pub turn_id: Option<String>,
7937}
7938
7939#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
7940#[serde(transparent)]
7941pub struct ThreadId(pub String);
7942
7943#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7944#[serde(rename_all = "camelCase")]
7945pub struct ThreadInjectItemsParams {
7946    #[serde(default)]
7947    pub items: Vec<Value>,
7948    #[serde(rename = "threadId", default)]
7949    pub thread_id: String,
7950}
7951
7952#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7953#[serde(rename_all = "camelCase")]
7954pub struct ThreadInjectItemsResponse {
7955    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7956    pub extra: serde_json::Map<String, Value>,
7957}
7958
7959#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7960#[serde(tag = "type", rename_all = "camelCase")]
7961pub enum ThreadItem {
7962    #[serde(rename = "userMessage")]
7963    UserMessage {
7964        #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
7965        client_id: Option<String>,
7966        content: Vec<UserInput>,
7967        id: String,
7968    },
7969    #[serde(rename = "hookPrompt")]
7970    HookPrompt {
7971        fragments: Vec<HookPromptFragment>,
7972        id: String,
7973    },
7974    #[serde(rename = "agentMessage")]
7975    AgentMessage {
7976        #[serde(default, skip_serializing_if = "Option::is_none")]
7977        delivery: Option<AgentMessageDelivery>,
7978        id: String,
7979        #[serde(
7980            rename = "memoryCitation",
7981            default,
7982            skip_serializing_if = "Option::is_none"
7983        )]
7984        memory_citation: Option<MemoryCitation>,
7985        #[serde(default, skip_serializing_if = "Option::is_none")]
7986        phase: Option<MessagePhase>,
7987        #[serde(default, skip_serializing_if = "Option::is_none")]
7988        questions: Option<Vec<AsyncUserInputQuestion>>,
7989        text: String,
7990    },
7991    Plan {
7992        id: String,
7993        text: String,
7994    },
7995    Reasoning {
7996        #[serde(default, skip_serializing_if = "Option::is_none")]
7997        content: Option<Vec<String>>,
7998        id: String,
7999        #[serde(default, skip_serializing_if = "Option::is_none")]
8000        summary: Option<Vec<String>>,
8001    },
8002    #[serde(rename = "commandExecution")]
8003    CommandExecution {
8004        #[serde(
8005            rename = "aggregatedOutput",
8006            default,
8007            skip_serializing_if = "Option::is_none"
8008        )]
8009        aggregated_output: Option<String>,
8010        command: String,
8011        #[serde(rename = "commandActions")]
8012        command_actions: Vec<CommandAction>,
8013        cwd: Value,
8014        #[serde(
8015            rename = "durationMs",
8016            default,
8017            skip_serializing_if = "Option::is_none"
8018        )]
8019        duration_ms: Option<i64>,
8020        #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
8021        exit_code: Option<i64>,
8022        id: String,
8023        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8024        plugin_id: Option<String>,
8025        #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
8026        process_id: Option<String>,
8027        #[serde(
8028            rename = "scriptPath",
8029            default,
8030            skip_serializing_if = "Option::is_none"
8031        )]
8032        script_path: Option<String>,
8033        #[serde(default, skip_serializing_if = "Option::is_none")]
8034        source: Option<Value>,
8035        status: CommandExecutionStatus,
8036    },
8037    #[serde(rename = "fileChange")]
8038    FileChange {
8039        changes: Vec<FileUpdateChange>,
8040        id: String,
8041        status: PatchApplyStatus,
8042    },
8043    #[serde(rename = "mcpToolCall")]
8044    McpToolCall {
8045        #[serde(
8046            rename = "appContext",
8047            default,
8048            skip_serializing_if = "Option::is_none"
8049        )]
8050        app_context: Option<McpToolCallAppContext>,
8051        arguments: Value,
8052        #[serde(
8053            rename = "durationMs",
8054            default,
8055            skip_serializing_if = "Option::is_none"
8056        )]
8057        duration_ms: Option<i64>,
8058        #[serde(default, skip_serializing_if = "Option::is_none")]
8059        error: Option<McpToolCallError>,
8060        id: String,
8061        /// Legacy compatibility field; prefer `mcp_app_ui.resource_uri` when
8062        /// available.
8063        #[serde(
8064            rename = "mcpAppResourceUri",
8065            default,
8066            skip_serializing_if = "Option::is_none"
8067        )]
8068        mcp_app_resource_uri: Option<String>,
8069        /// Presentation captured from the invoked descriptor; absent in
8070        /// older history.
8071        #[serde(rename = "mcpAppUi", default, skip_serializing_if = "Option::is_none")]
8072        mcp_app_ui: Option<McpAppUi>,
8073        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8074        plugin_id: Option<String>,
8075        #[serde(
8076            rename = "readOnlyHint",
8077            default,
8078            skip_serializing_if = "Option::is_none"
8079        )]
8080        read_only_hint: Option<bool>,
8081        #[serde(default, skip_serializing_if = "Option::is_none")]
8082        result: Option<McpToolCallResult>,
8083        server: String,
8084        status: McpToolCallStatus,
8085        tool: String,
8086    },
8087    #[serde(rename = "dynamicToolCall")]
8088    DynamicToolCall {
8089        arguments: Value,
8090        #[serde(
8091            rename = "contentItems",
8092            default,
8093            skip_serializing_if = "Option::is_none"
8094        )]
8095        content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
8096        #[serde(
8097            rename = "durationMs",
8098            default,
8099            skip_serializing_if = "Option::is_none"
8100        )]
8101        duration_ms: Option<i64>,
8102        id: String,
8103        #[serde(default, skip_serializing_if = "Option::is_none")]
8104        namespace: Option<String>,
8105        status: DynamicToolCallStatus,
8106        #[serde(default, skip_serializing_if = "Option::is_none")]
8107        success: Option<bool>,
8108        tool: String,
8109    },
8110    #[serde(rename = "collabAgentToolCall")]
8111    CollabAgentToolCall {
8112        #[serde(rename = "agentsStates")]
8113        agents_states: std::collections::BTreeMap<String, CollabAgentState>,
8114        id: String,
8115        #[serde(default, skip_serializing_if = "Option::is_none")]
8116        model: Option<String>,
8117        #[serde(default, skip_serializing_if = "Option::is_none")]
8118        prompt: Option<String>,
8119        #[serde(
8120            rename = "reasoningEffort",
8121            default,
8122            skip_serializing_if = "Option::is_none"
8123        )]
8124        reasoning_effort: Option<ReasoningEffort>,
8125        #[serde(rename = "receiverThreadIds")]
8126        receiver_thread_ids: Vec<String>,
8127        #[serde(rename = "senderThreadId")]
8128        sender_thread_id: String,
8129        status: Value,
8130        tool: Value,
8131    },
8132    #[serde(rename = "subAgentActivity")]
8133    SubAgentActivity {
8134        #[serde(rename = "agentPath")]
8135        agent_path: String,
8136        #[serde(rename = "agentThreadId")]
8137        agent_thread_id: String,
8138        id: String,
8139        kind: SubAgentActivityKind,
8140        /// Resolved model at sub-agent creation; absent from older records
8141        /// and other activities.
8142        #[serde(default, skip_serializing_if = "Option::is_none")]
8143        model: Option<String>,
8144        /// Resolved reasoning effort at sub-agent creation, when known.
8145        #[serde(
8146            rename = "reasoningEffort",
8147            default,
8148            skip_serializing_if = "Option::is_none"
8149        )]
8150        reasoning_effort: Option<ReasoningEffort>,
8151    },
8152    #[serde(rename = "webSearch")]
8153    WebSearch {
8154        #[serde(default, skip_serializing_if = "Option::is_none")]
8155        action: Option<WebSearchAction>,
8156        id: String,
8157        query: String,
8158        #[serde(default, skip_serializing_if = "Option::is_none")]
8159        results: Option<Vec<Value>>,
8160    },
8161    #[serde(rename = "imageView")]
8162    ImageView {
8163        id: String,
8164        path: LegacyAppPathString,
8165    },
8166    Sleep {
8167        #[serde(rename = "durationMs")]
8168        duration_ms: i64,
8169        id: String,
8170    },
8171    #[serde(rename = "imageGeneration")]
8172    ImageGeneration {
8173        #[serde(default, skip_serializing_if = "Option::is_none")]
8174        failure: Option<ImageGenerationFailure>,
8175        id: String,
8176        #[serde(flatten)]
8177        image: GeneratedImageRef,
8178        /// Observed local inputs for a completed generation, absent on older items.
8179        #[serde(
8180            rename = "inputImages",
8181            default,
8182            skip_serializing_if = "Option::is_none"
8183        )]
8184        input_images: Option<Vec<ImageGenerationInputImage>>,
8185        #[serde(
8186            rename = "revisedPrompt",
8187            default,
8188            skip_serializing_if = "Option::is_none"
8189        )]
8190        revised_prompt: Option<String>,
8191        #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
8192        saved_path: Option<AbsolutePathBuf>,
8193        status: String,
8194        #[serde(
8195            rename = "transparentBackground",
8196            default,
8197            skip_serializing_if = "Option::is_none"
8198        )]
8199        transparent_background: Option<bool>,
8200    },
8201    #[serde(rename = "enteredReviewMode")]
8202    EnteredReviewMode {
8203        id: String,
8204        review: String,
8205    },
8206    #[serde(rename = "exitedReviewMode")]
8207    ExitedReviewMode {
8208        id: String,
8209        review: String,
8210    },
8211    #[serde(rename = "contextCompaction")]
8212    ContextCompaction {
8213        id: String,
8214    },
8215    #[serde(rename = "functionCallOutput")]
8216    FunctionCallOutput {
8217        id: String,
8218        name: String,
8219        #[serde(default, skip_serializing_if = "Option::is_none")]
8220        namespace: Option<String>,
8221        output: FunctionCallOutputBody,
8222    },
8223}
8224
8225#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8226#[serde(untagged)]
8227pub enum ThreadListCwdFilter {
8228    Variant0(String),
8229    Variant1(Vec<String>),
8230}
8231
8232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8233#[serde(rename_all = "camelCase")]
8234pub struct ThreadListParams {
8235    #[serde(default, skip_serializing_if = "Option::is_none")]
8236    pub archived: Option<bool>,
8237    #[serde(default, skip_serializing_if = "Option::is_none")]
8238    pub cursor: Option<String>,
8239    #[serde(default, skip_serializing_if = "Option::is_none")]
8240    pub cwd: Option<ThreadListCwdFilter>,
8241    /// Thread IDs to exclude before applying the result limit. Up to 100
8242    /// entries; invalid IDs or a larger list are rejected, never truncated.
8243    /// Send the same exclusions on each page. Omitted, null, or empty means
8244    /// no exclusions.
8245    #[serde(
8246        rename = "excludedThreadIds",
8247        default,
8248        skip_serializing_if = "Option::is_none"
8249    )]
8250    pub excluded_thread_ids: Option<Vec<String>>,
8251    #[serde(default, skip_serializing_if = "Option::is_none")]
8252    pub limit: Option<i64>,
8253    #[serde(
8254        rename = "modelProviders",
8255        default,
8256        skip_serializing_if = "Option::is_none"
8257    )]
8258    pub model_providers: Option<Vec<String>>,
8259    /// Optional originator allowlist, matching any supplied value exactly.
8260    /// Supported by hosted backends only; the local app-server rejects a
8261    /// nonempty list. Omitted or empty lists leave originators unrestricted.
8262    #[serde(default, skip_serializing_if = "Option::is_none")]
8263    pub originators: Option<Vec<String>>,
8264    #[serde(
8265        rename = "searchTerm",
8266        default,
8267        skip_serializing_if = "Option::is_none"
8268    )]
8269    pub search_term: Option<String>,
8270    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8271    pub section_id: Option<String>,
8272    #[serde(
8273        rename = "sortDirection",
8274        default,
8275        skip_serializing_if = "Option::is_none"
8276    )]
8277    pub sort_direction: Option<SortDirection>,
8278    #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
8279    pub sort_key: Option<ThreadSortKey>,
8280    #[serde(
8281        rename = "sourceKinds",
8282        default,
8283        skip_serializing_if = "Option::is_none"
8284    )]
8285    pub source_kinds: Option<Vec<ThreadSourceKind>>,
8286    #[serde(
8287        rename = "useStateDbOnly",
8288        default,
8289        skip_serializing_if = "Option::is_none"
8290    )]
8291    pub use_state_db_only: Option<bool>,
8292}
8293
8294#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8295#[serde(rename_all = "camelCase")]
8296pub struct ThreadListResponse {
8297    #[serde(
8298        rename = "backwardsCursor",
8299        default,
8300        skip_serializing_if = "Option::is_none"
8301    )]
8302    pub backwards_cursor: Option<String>,
8303    #[serde(default)]
8304    pub data: Vec<Thread>,
8305    #[serde(
8306        rename = "nextCursor",
8307        default,
8308        skip_serializing_if = "Option::is_none"
8309    )]
8310    pub next_cursor: Option<String>,
8311}
8312
8313#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8314#[serde(rename_all = "camelCase")]
8315pub struct ThreadLoadedListParams {
8316    #[serde(default, skip_serializing_if = "Option::is_none")]
8317    pub cursor: Option<String>,
8318    #[serde(default, skip_serializing_if = "Option::is_none")]
8319    pub limit: Option<i64>,
8320}
8321
8322#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8323#[serde(rename_all = "camelCase")]
8324pub struct ThreadLoadedListResponse {
8325    #[serde(default)]
8326    pub data: Vec<String>,
8327    #[serde(
8328        rename = "nextCursor",
8329        default,
8330        skip_serializing_if = "Option::is_none"
8331    )]
8332    pub next_cursor: Option<String>,
8333}
8334
8335#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8336#[serde(rename_all = "camelCase")]
8337pub struct ThreadMetadataGitInfoUpdateParams {
8338    #[serde(default, skip_serializing_if = "Option::is_none")]
8339    pub branch: Option<String>,
8340    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
8341    pub origin_url: Option<String>,
8342    #[serde(default, skip_serializing_if = "Option::is_none")]
8343    pub sha: Option<String>,
8344}
8345
8346#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8347#[serde(rename_all = "camelCase")]
8348pub struct ThreadMetadataUpdateParams {
8349    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
8350    pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
8351    #[serde(rename = "threadId", default)]
8352    pub thread_id: String,
8353}
8354
8355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8356#[serde(rename_all = "camelCase")]
8357pub struct ThreadMetadataUpdateResponse {
8358    #[serde()]
8359    pub thread: Thread,
8360}
8361
8362#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8363#[serde(rename_all = "camelCase")]
8364pub struct ThreadNameUpdatedNotification {
8365    #[serde(rename = "threadId", default)]
8366    pub thread_id: String,
8367    #[serde(
8368        rename = "threadName",
8369        default,
8370        skip_serializing_if = "Option::is_none"
8371    )]
8372    pub thread_name: Option<String>,
8373}
8374
8375#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8376#[serde(rename_all = "camelCase")]
8377pub struct ThreadReadParams {
8378    #[serde(
8379        rename = "includeTurns",
8380        default,
8381        skip_serializing_if = "Option::is_none"
8382    )]
8383    pub include_turns: Option<bool>,
8384    #[serde(rename = "threadId", default)]
8385    pub thread_id: String,
8386}
8387
8388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8389#[serde(rename_all = "camelCase")]
8390pub struct ThreadReadResponse {
8391    #[serde()]
8392    pub thread: Thread,
8393}
8394
8395/// The first unread position in a durable local thread. A null position means read.
8396/// The opaque revision guards edits against activity or marks the caller has not seen.
8397#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8398#[serde(rename_all = "camelCase")]
8399pub struct ThreadReadState {
8400    #[serde(
8401        rename = "firstUnread",
8402        default,
8403        skip_serializing_if = "Option::is_none"
8404    )]
8405    pub first_unread: Option<ThreadUnreadPosition>,
8406    #[serde(default)]
8407    pub revision: String,
8408}
8409
8410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8411#[serde(rename_all = "camelCase")]
8412pub struct ThreadReadStateChangedNotification {
8413    #[serde(rename = "readState")]
8414    pub read_state: ThreadReadState,
8415    #[serde(rename = "threadId", default)]
8416    pub thread_id: String,
8417}
8418
8419#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8420#[serde(rename_all = "camelCase")]
8421pub struct ThreadRealtimeAudioChunk {
8422    #[serde(default)]
8423    pub data: String,
8424    #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
8425    pub item_id: Option<String>,
8426    #[serde(rename = "numChannels", default)]
8427    pub num_channels: i64,
8428    #[serde(rename = "sampleRate", default)]
8429    pub sample_rate: i64,
8430    #[serde(
8431        rename = "samplesPerChannel",
8432        default,
8433        skip_serializing_if = "Option::is_none"
8434    )]
8435    pub samples_per_channel: Option<i64>,
8436}
8437
8438#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8439#[serde(rename_all = "camelCase")]
8440pub struct ThreadRealtimeClosedNotification {
8441    #[serde(default, skip_serializing_if = "Option::is_none")]
8442    pub reason: Option<String>,
8443    #[serde(rename = "threadId", default)]
8444    pub thread_id: String,
8445}
8446
8447#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8448#[serde(rename_all = "camelCase")]
8449pub struct ThreadRealtimeErrorNotification {
8450    #[serde(default)]
8451    pub message: String,
8452    #[serde(rename = "threadId", default)]
8453    pub thread_id: String,
8454}
8455
8456#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8457#[serde(rename_all = "camelCase")]
8458pub struct ThreadRealtimeItemAddedNotification {
8459    #[serde(default)]
8460    pub item: Value,
8461    #[serde(rename = "threadId", default)]
8462    pub thread_id: String,
8463}
8464
8465#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8466#[serde(rename_all = "camelCase")]
8467pub struct ThreadRealtimeOutputAudioDeltaNotification {
8468    #[serde()]
8469    pub audio: ThreadRealtimeAudioChunk,
8470    #[serde(rename = "threadId", default)]
8471    pub thread_id: String,
8472}
8473
8474#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8475#[serde(rename_all = "camelCase")]
8476pub struct ThreadRealtimeSdpNotification {
8477    #[serde(default)]
8478    pub sdp: String,
8479    #[serde(rename = "threadId", default)]
8480    pub thread_id: String,
8481}
8482
8483#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8484#[serde(rename_all = "camelCase")]
8485pub struct ThreadRealtimeStartedNotification {
8486    #[serde(
8487        rename = "realtimeSessionId",
8488        default,
8489        skip_serializing_if = "Option::is_none"
8490    )]
8491    pub realtime_session_id: Option<String>,
8492    #[serde(rename = "threadId", default)]
8493    pub thread_id: String,
8494    #[serde()]
8495    pub version: RealtimeConversationVersion,
8496}
8497
8498#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8499#[serde(rename_all = "camelCase")]
8500pub struct ThreadRealtimeTranscriptDeltaNotification {
8501    #[serde(default)]
8502    pub delta: String,
8503    #[serde(default)]
8504    pub role: String,
8505    #[serde(rename = "threadId", default)]
8506    pub thread_id: String,
8507}
8508
8509#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8510#[serde(rename_all = "camelCase")]
8511pub struct ThreadRealtimeTranscriptDoneNotification {
8512    #[serde(default)]
8513    pub role: String,
8514    #[serde(default)]
8515    pub text: String,
8516    #[serde(rename = "threadId", default)]
8517    pub thread_id: String,
8518}
8519
8520#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8521#[serde(rename_all = "camelCase")]
8522pub struct ThreadResumeParams {
8523    #[serde(
8524        rename = "approvalPolicy",
8525        default,
8526        skip_serializing_if = "Option::is_none"
8527    )]
8528    pub approval_policy: Option<AskForApproval>,
8529    #[serde(
8530        rename = "approvalsReviewer",
8531        default,
8532        skip_serializing_if = "Option::is_none"
8533    )]
8534    pub approvals_reviewer: Option<ApprovalsReviewer>,
8535    #[serde(
8536        rename = "baseInstructions",
8537        default,
8538        skip_serializing_if = "Option::is_none"
8539    )]
8540    pub base_instructions: Option<String>,
8541    #[serde(default, skip_serializing_if = "Option::is_none")]
8542    pub config: Option<Value>,
8543    #[serde(default, skip_serializing_if = "Option::is_none")]
8544    pub cwd: Option<String>,
8545    #[serde(
8546        rename = "developerInstructions",
8547        default,
8548        skip_serializing_if = "Option::is_none"
8549    )]
8550    pub developer_instructions: Option<String>,
8551    #[serde(default, skip_serializing_if = "Option::is_none")]
8552    pub model: Option<String>,
8553    #[serde(
8554        rename = "modelProvider",
8555        default,
8556        skip_serializing_if = "Option::is_none"
8557    )]
8558    pub model_provider: Option<String>,
8559    #[serde(default, skip_serializing_if = "Option::is_none")]
8560    pub personality: Option<Personality>,
8561    #[serde(default, skip_serializing_if = "Option::is_none")]
8562    pub sandbox: Option<SandboxMode>,
8563    #[serde(
8564        rename = "serviceTier",
8565        default,
8566        skip_serializing_if = "Option::is_none"
8567    )]
8568    pub service_tier: Option<String>,
8569    #[serde(rename = "threadId", default)]
8570    pub thread_id: String,
8571    #[serde(
8572        rename = "excludeTurns",
8573        default,
8574        skip_serializing_if = "Option::is_none"
8575    )]
8576    pub exclude_turns: Option<bool>,
8577}
8578
8579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8580#[serde(rename_all = "camelCase")]
8581pub struct ThreadResumeResponse {
8582    #[serde(rename = "approvalPolicy")]
8583    pub approval_policy: AskForApproval,
8584    #[serde(rename = "approvalsReviewer", default)]
8585    pub approvals_reviewer: Value,
8586    /// Effective collaboration mode. Absent when resuming from an older
8587    /// server.
8588    #[serde(
8589        rename = "collaborationMode",
8590        default,
8591        skip_serializing_if = "Option::is_none"
8592    )]
8593    pub collaboration_mode: Option<CollaborationMode>,
8594    #[serde()]
8595    pub cwd: AbsolutePathBuf,
8596    /// Saved list of disabled plugin IDs. Does not yet filter plugin
8597    /// capabilities.
8598    #[serde(rename = "disabledPluginIds", default)]
8599    pub disabled_plugin_ids: Vec<String>,
8600    #[serde(
8601        rename = "instructionSources",
8602        default,
8603        skip_serializing_if = "Option::is_none"
8604    )]
8605    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8606    /// Cursor for hydrating paginated items backwards via `thread/items/list`
8607    /// with `sortDirection: "desc"` (0.148 upstream).
8608    #[serde(
8609        rename = "itemsBackwardsCursor",
8610        default,
8611        skip_serializing_if = "Option::is_none"
8612    )]
8613    pub items_backwards_cursor: Option<String>,
8614    #[serde(default)]
8615    pub model: String,
8616    #[serde(rename = "modelProvider", default)]
8617    pub model_provider: String,
8618    #[serde(
8619        rename = "reasoningEffort",
8620        default,
8621        skip_serializing_if = "Option::is_none"
8622    )]
8623    pub reasoning_effort: Option<ReasoningEffort>,
8624    #[serde(default)]
8625    pub sandbox: Value,
8626    #[serde(
8627        rename = "serviceTier",
8628        default,
8629        skip_serializing_if = "Option::is_none"
8630    )]
8631    pub service_tier: Option<String>,
8632    #[serde()]
8633    pub thread: Thread,
8634    /// Cursor for hydrating paginated turns backwards via `thread/turns/list`
8635    /// with `sortDirection: "desc"` (0.148 upstream).
8636    #[serde(
8637        rename = "turnsBackwardsCursor",
8638        default,
8639        skip_serializing_if = "Option::is_none"
8640    )]
8641    pub turns_backwards_cursor: Option<String>,
8642}
8643
8644/// Persisted thread history contract (0.148 upstream).
8645#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8646pub enum ThreadHistoryMode {
8647    #[serde(rename = "legacy")]
8648    Legacy,
8649    #[serde(rename = "paginated")]
8650    Paginated,
8651}
8652
8653/// One item plus the turn that contains it, as returned by
8654/// `thread/items/list` (0.148 upstream).
8655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8656#[serde(rename_all = "camelCase")]
8657pub struct ThreadItemEntry {
8658    /// Unix timestamp (milliseconds) when the item completed, if recorded by
8659    /// the producer.
8660    #[serde(
8661        rename = "completedAtMs",
8662        default,
8663        skip_serializing_if = "Option::is_none"
8664    )]
8665    pub completed_at_ms: Option<i64>,
8666    #[serde()]
8667    pub item: ThreadItem,
8668    /// Unix timestamp (milliseconds) when the item started, if recorded by
8669    /// the producer.
8670    #[serde(
8671        rename = "startedAtMs",
8672        default,
8673        skip_serializing_if = "Option::is_none"
8674    )]
8675    pub started_at_ms: Option<i64>,
8676    #[serde(rename = "turnId", default)]
8677    pub turn_id: String,
8678}
8679
8680/// Params for `thread/items/list` — paginated item hydration (0.148 upstream).
8681#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8682#[serde(rename_all = "camelCase")]
8683pub struct ThreadItemsListParams {
8684    /// Opaque continuation cursor, or an exclusive item anchor in the
8685    /// requested visible turn (`openai/codex@main` de9e78e3). An item anchor
8686    /// requires a non-empty `turn_id`; ascending (the default) returns items
8687    /// after it, descending returns items before it. Continue with the
8688    /// returned string cursor.
8689    #[serde(default, skip_serializing_if = "Option::is_none")]
8690    pub cursor: Option<ThreadItemsListCursor>,
8691    #[serde(default, skip_serializing_if = "Option::is_none")]
8692    pub limit: Option<u32>,
8693    #[serde(
8694        rename = "sortDirection",
8695        default,
8696        skip_serializing_if = "Option::is_none"
8697    )]
8698    pub sort_direction: Option<SortDirection>,
8699    #[serde(rename = "threadId", default)]
8700    pub thread_id: String,
8701    /// Optional turn id filter; omitted returns items across the thread.
8702    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8703    pub turn_id: Option<String>,
8704}
8705
8706/// Starting position for a `thread/items/list` page: either the opaque
8707/// string cursor a previous page returned, or an item anchor
8708/// (`openai/codex@main` de9e78e3). Untagged, so a bare string stays a bare
8709/// string on the wire.
8710#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8711#[serde(untagged)]
8712pub enum ThreadItemsListCursor {
8713    Opaque(String),
8714    Anchor(ThreadItemsListAnchor),
8715}
8716
8717/// An exclusive item position within the requested visible turn
8718/// (`openai/codex@main` de9e78e3).
8719#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8720#[serde(tag = "type", rename_all = "camelCase")]
8721pub enum ThreadItemsListAnchor {
8722    Item {
8723        #[serde(rename = "itemId")]
8724        item_id: String,
8725    },
8726}
8727
8728/// Response to `thread/items/list` (0.148 upstream).
8729#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8730#[serde(rename_all = "camelCase")]
8731pub struct ThreadItemsListResponse {
8732    #[serde(
8733        rename = "backwardsCursor",
8734        default,
8735        skip_serializing_if = "Option::is_none"
8736    )]
8737    pub backwards_cursor: Option<String>,
8738    #[serde(default)]
8739    pub data: Vec<ThreadItemEntry>,
8740    #[serde(
8741        rename = "nextCursor",
8742        default,
8743        skip_serializing_if = "Option::is_none"
8744    )]
8745    pub next_cursor: Option<String>,
8746}
8747
8748/// EXPERIMENTAL upstream — a thread-scoped realtime item in the canonical
8749/// timeline (0.148). Top-level identity fields are camelCase on the wire
8750/// while variant payload fields are snake_case; mirrored exactly.
8751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8752pub struct ThreadRealtimeItem {
8753    #[serde(default)]
8754    pub id: String,
8755    #[serde(rename = "realtimeSessionId", default)]
8756    pub realtime_session_id: String,
8757    #[serde(flatten)]
8758    pub detail: ThreadRealtimeItemDetail,
8759}
8760
8761/// The `type`-tagged payload of a [`ThreadRealtimeItem`].
8762#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8763#[serde(tag = "type", rename_all = "camelCase")]
8764pub enum ThreadRealtimeItemDetail {
8765    #[serde(rename = "realtimeSessionStarted")]
8766    RealtimeSessionStarted,
8767    #[serde(rename = "transcriptSegment")]
8768    TranscriptSegment {
8769        role: ThreadRealtimeTranscriptRole,
8770        text: String,
8771    },
8772    #[serde(rename = "bemItemPromoted")]
8773    BemItemPromoted {
8774        item_id: String,
8775        presentation: ThreadRealtimeBemItemPresentation,
8776        turn_id: String,
8777    },
8778    #[serde(rename = "realtimeSessionClosed")]
8779    RealtimeSessionClosed {
8780        outcome: ThreadRealtimeSessionOutcome,
8781    },
8782}
8783
8784/// EXPERIMENTAL upstream — how an existing agent item appears in a realtime
8785/// conversation (0.148).
8786#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8787#[serde(tag = "type", rename_all = "camelCase")]
8788pub enum ThreadRealtimeBemItemPresentation {
8789    #[serde(rename = "wholeItem")]
8790    WholeItem,
8791    #[serde(rename = "inlineMarkdown")]
8792    InlineMarkdown,
8793    #[serde(rename = "inlineVisualization")]
8794    InlineVisualization { index: u32 },
8795}
8796
8797/// EXPERIMENTAL upstream — `thread/realtime/item/started` params (0.148).
8798#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8799#[serde(rename_all = "camelCase")]
8800pub struct ThreadRealtimeItemStartedNotification {
8801    #[serde()]
8802    pub item: ThreadRealtimeItem,
8803    #[serde(rename = "threadId", default)]
8804    pub thread_id: String,
8805}
8806
8807/// EXPERIMENTAL upstream — `thread/realtime/item/completed` params (0.148).
8808#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8809#[serde(rename_all = "camelCase")]
8810pub struct ThreadRealtimeItemCompletedNotification {
8811    #[serde()]
8812    pub item: ThreadRealtimeItem,
8813    #[serde(rename = "threadId", default)]
8814    pub thread_id: String,
8815}
8816
8817/// EXPERIMENTAL upstream — `thread/realtime/item/transcript/delta` params:
8818/// text appended to an active realtime transcript item (0.148).
8819#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8820#[serde(rename_all = "camelCase")]
8821pub struct ThreadRealtimeItemTranscriptDeltaNotification {
8822    #[serde(default)]
8823    pub delta: String,
8824    #[serde(rename = "itemId", default)]
8825    pub item_id: String,
8826    #[serde(rename = "threadId", default)]
8827    pub thread_id: String,
8828}
8829
8830/// EXPERIMENTAL upstream — outcome of a closed realtime session (0.148).
8831#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8832pub enum ThreadRealtimeSessionOutcome {
8833    #[serde(rename = "ended")]
8834    Ended,
8835    #[serde(rename = "failed")]
8836    Failed,
8837}
8838
8839/// EXPERIMENTAL upstream — speaker role in a realtime transcript (0.148).
8840#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8841pub enum ThreadRealtimeTranscriptRole {
8842    #[serde(rename = "user")]
8843    User,
8844    #[serde(rename = "assistant")]
8845    Assistant,
8846}
8847
8848/// Params for `thread/revert` — replace a paginated thread's durable history
8849/// with the prefix before one turn; local file changes are untouched
8850/// (0.148 upstream).
8851#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8852#[serde(rename_all = "camelCase")]
8853pub struct ThreadRevertParams {
8854    /// Turn excluded from the replacement history, with every later turn.
8855    #[serde(rename = "beforeTurnId", default)]
8856    pub before_turn_id: String,
8857    #[serde(rename = "threadId", default)]
8858    pub thread_id: String,
8859}
8860
8861/// Response to `thread/revert` (0.148 upstream). `thread.turns` is always
8862/// empty; retained history hydrates through `thread/turns/list`.
8863#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8864#[serde(rename_all = "camelCase")]
8865pub struct ThreadRevertResponse {
8866    #[serde(
8867        rename = "itemsBackwardsCursor",
8868        default,
8869        skip_serializing_if = "Option::is_none"
8870    )]
8871    pub items_backwards_cursor: Option<String>,
8872    #[serde()]
8873    pub thread: Thread,
8874    #[serde(
8875        rename = "turnsBackwardsCursor",
8876        default,
8877        skip_serializing_if = "Option::is_none"
8878    )]
8879    pub turns_backwards_cursor: Option<String>,
8880}
8881
8882#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8883#[serde(rename_all = "camelCase")]
8884pub struct ThreadSection {
8885    #[serde(default, skip_serializing_if = "Option::is_none")]
8886    pub appearance: Option<ThreadSectionAppearance>,
8887    #[serde(default)]
8888    pub id: String,
8889    #[serde(default)]
8890    pub name: String,
8891}
8892
8893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8894#[serde(rename_all = "camelCase")]
8895pub struct ThreadSectionAppearance {
8896    #[serde(default, skip_serializing_if = "Option::is_none")]
8897    pub color: Option<String>,
8898    #[serde(default, skip_serializing_if = "Option::is_none")]
8899    pub icon: Option<String>,
8900}
8901
8902#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8903#[serde(rename_all = "camelCase")]
8904pub struct ThreadSectionCreateParams {
8905    #[serde(default, skip_serializing_if = "Option::is_none")]
8906    pub appearance: Option<ThreadSectionAppearance>,
8907    #[serde(default)]
8908    pub name: String,
8909}
8910
8911#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8912#[serde(rename_all = "camelCase")]
8913pub struct ThreadSectionCreateResponse {
8914    #[serde()]
8915    pub section: ThreadSection,
8916}
8917
8918#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8919#[serde(rename_all = "camelCase")]
8920pub struct ThreadSectionDeleteParams {
8921    #[serde(rename = "sectionId", default)]
8922    pub section_id: String,
8923}
8924
8925#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8926#[serde(rename_all = "camelCase")]
8927pub struct ThreadSectionDeleteResponse {
8928    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8929    pub extra: serde_json::Map<String, Value>,
8930}
8931
8932#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8933#[serde(rename_all = "camelCase")]
8934pub struct ThreadSectionListParams {
8935    #[serde(default, skip_serializing_if = "Option::is_none")]
8936    pub cursor: Option<String>,
8937    #[serde(default, skip_serializing_if = "Option::is_none")]
8938    pub limit: Option<i64>,
8939}
8940
8941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8942#[serde(rename_all = "camelCase")]
8943pub struct ThreadSectionListResponse {
8944    #[serde(default)]
8945    pub data: Vec<ThreadSection>,
8946    #[serde(
8947        rename = "nextCursor",
8948        default,
8949        skip_serializing_if = "Option::is_none"
8950    )]
8951    pub next_cursor: Option<String>,
8952}
8953
8954#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8955#[serde(rename_all = "camelCase")]
8956pub struct ThreadSectionMoveParams {
8957    #[serde(
8958        rename = "beforeThreadId",
8959        default,
8960        skip_serializing_if = "Option::is_none"
8961    )]
8962    pub before_thread_id: Option<String>,
8963    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8964    pub section_id: Option<String>,
8965    #[serde(rename = "threadId", default)]
8966    pub thread_id: String,
8967}
8968
8969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8970#[serde(rename_all = "camelCase")]
8971pub struct ThreadSectionMoveResponse {
8972    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8973    pub extra: serde_json::Map<String, Value>,
8974}
8975
8976#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8977#[serde(rename_all = "camelCase")]
8978pub struct ThreadSectionUpdateParams {
8979    #[serde(default, skip_serializing_if = "Option::is_none")]
8980    pub appearance: Option<ThreadSectionAppearance>,
8981    #[serde(default)]
8982    pub name: String,
8983    #[serde(rename = "sectionId", default)]
8984    pub section_id: String,
8985}
8986
8987#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8988#[serde(rename_all = "camelCase")]
8989pub struct ThreadSectionUpdateResponse {
8990    #[serde()]
8991    pub section: ThreadSection,
8992}
8993
8994#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8995#[serde(rename_all = "camelCase")]
8996pub struct ThreadSetNameParams {
8997    #[serde(default)]
8998    pub name: String,
8999    #[serde(rename = "threadId", default)]
9000    pub thread_id: String,
9001}
9002
9003#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9004#[serde(rename_all = "camelCase")]
9005pub struct ThreadSetNameResponse {
9006    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9007    pub extra: serde_json::Map<String, Value>,
9008}
9009
9010#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9011#[serde(rename_all = "camelCase")]
9012pub struct ThreadSettings {
9013    #[serde(
9014        rename = "activePermissionProfile",
9015        default,
9016        skip_serializing_if = "Option::is_none"
9017    )]
9018    pub active_permission_profile: Option<ActivePermissionProfile>,
9019    #[serde(rename = "approvalPolicy")]
9020    pub approval_policy: AskForApproval,
9021    #[serde(rename = "approvalsReviewer")]
9022    pub approvals_reviewer: ApprovalsReviewer,
9023    #[serde(rename = "collaborationMode")]
9024    pub collaboration_mode: CollaborationMode,
9025    #[serde()]
9026    pub cwd: AbsolutePathBuf,
9027    /// Saved list of disabled plugin IDs. Does not yet filter plugin
9028    /// capabilities.
9029    #[serde(rename = "disabledPluginIds", default)]
9030    pub disabled_plugin_ids: Vec<String>,
9031    #[serde(default, skip_serializing_if = "Option::is_none")]
9032    pub effort: Option<ReasoningEffort>,
9033    #[serde(default)]
9034    pub model: String,
9035    #[serde(rename = "modelProvider", default)]
9036    pub model_provider: String,
9037    #[serde(default, skip_serializing_if = "Option::is_none")]
9038    pub personality: Option<Personality>,
9039    #[serde(rename = "sandboxPolicy")]
9040    pub sandbox_policy: SandboxPolicy,
9041    #[serde(
9042        rename = "serviceTier",
9043        default,
9044        skip_serializing_if = "Option::is_none"
9045    )]
9046    pub service_tier: Option<String>,
9047    #[serde(default, skip_serializing_if = "Option::is_none")]
9048    pub summary: Option<ReasoningSummary>,
9049}
9050
9051#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9052#[serde(rename_all = "camelCase")]
9053pub struct ThreadSettingsUpdatedNotification {
9054    #[serde(rename = "threadId", default)]
9055    pub thread_id: String,
9056    #[serde(rename = "threadSettings")]
9057    pub thread_settings: ThreadSettings,
9058}
9059
9060#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9061#[serde(rename_all = "camelCase")]
9062pub struct ThreadShellCommandParams {
9063    #[serde(default)]
9064    pub command: String,
9065    #[serde(rename = "threadId", default)]
9066    pub thread_id: String,
9067    /// Maximum execution time in ms; defaults to one hour when omitted.
9068    /// Zero requests an immediate timeout, not unlimited (0.148 upstream).
9069    #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
9070    pub timeout_ms: Option<i64>,
9071}
9072
9073#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9074#[serde(rename_all = "camelCase")]
9075pub struct ThreadShellCommandResponse {
9076    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9077    pub extra: serde_json::Map<String, Value>,
9078}
9079
9080#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9081pub enum ThreadSortKey {
9082    #[serde(rename = "created_at")]
9083    Created_at,
9084    #[serde(rename = "updated_at")]
9085    Updated_at,
9086    #[serde(rename = "recency_at")]
9087    Recency_at,
9088    #[serde(rename = "section_position")]
9089    Section_position,
9090}
9091
9092#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
9093#[serde(transparent)]
9094pub struct ThreadSource(pub String);
9095
9096#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9097pub enum ThreadSourceKind {
9098    #[serde(rename = "cli")]
9099    Cli,
9100    #[serde(rename = "vscode")]
9101    Vscode,
9102    #[serde(rename = "exec")]
9103    Exec,
9104    #[serde(rename = "appServer")]
9105    AppServer,
9106    #[serde(rename = "subAgent")]
9107    SubAgent,
9108    #[serde(rename = "subAgentReview")]
9109    SubAgentReview,
9110    #[serde(rename = "subAgentCompact")]
9111    SubAgentCompact,
9112    #[serde(rename = "subAgentThreadSpawn")]
9113    SubAgentThreadSpawn,
9114    #[serde(rename = "subAgentOther")]
9115    SubAgentOther,
9116    #[serde(rename = "unknown")]
9117    Unknown,
9118}
9119
9120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9121#[serde(rename_all = "camelCase")]
9122pub struct ThreadStartParams {
9123    #[serde(
9124        rename = "approvalPolicy",
9125        default,
9126        skip_serializing_if = "Option::is_none"
9127    )]
9128    pub approval_policy: Option<AskForApproval>,
9129    #[serde(
9130        rename = "approvalsReviewer",
9131        default,
9132        skip_serializing_if = "Option::is_none"
9133    )]
9134    pub approvals_reviewer: Option<ApprovalsReviewer>,
9135    #[serde(
9136        rename = "baseInstructions",
9137        default,
9138        skip_serializing_if = "Option::is_none"
9139    )]
9140    pub base_instructions: Option<String>,
9141    #[serde(default, skip_serializing_if = "Option::is_none")]
9142    pub config: Option<Value>,
9143    #[serde(default, skip_serializing_if = "Option::is_none")]
9144    pub cwd: Option<String>,
9145    #[serde(
9146        rename = "developerInstructions",
9147        default,
9148        skip_serializing_if = "Option::is_none"
9149    )]
9150    pub developer_instructions: Option<String>,
9151    #[serde(default, skip_serializing_if = "Option::is_none")]
9152    pub ephemeral: Option<bool>,
9153    #[serde(default, skip_serializing_if = "Option::is_none")]
9154    pub model: Option<String>,
9155    #[serde(
9156        rename = "modelProvider",
9157        default,
9158        skip_serializing_if = "Option::is_none"
9159    )]
9160    pub model_provider: Option<String>,
9161    #[serde(default, skip_serializing_if = "Option::is_none")]
9162    pub personality: Option<Personality>,
9163    #[serde(default, skip_serializing_if = "Option::is_none")]
9164    pub sandbox: Option<SandboxMode>,
9165    #[serde(
9166        rename = "serviceName",
9167        default,
9168        skip_serializing_if = "Option::is_none"
9169    )]
9170    pub service_name: Option<String>,
9171    #[serde(
9172        rename = "serviceTier",
9173        default,
9174        skip_serializing_if = "Option::is_none"
9175    )]
9176    pub service_tier: Option<String>,
9177    #[serde(
9178        rename = "sessionStartSource",
9179        default,
9180        skip_serializing_if = "Option::is_none"
9181    )]
9182    pub session_start_source: Option<ThreadStartSource>,
9183    #[serde(
9184        rename = "threadSource",
9185        default,
9186        skip_serializing_if = "Option::is_none"
9187    )]
9188    pub thread_source: Option<ThreadSource>,
9189}
9190
9191#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9192#[serde(rename_all = "camelCase")]
9193pub struct ThreadStartResponse {
9194    #[serde(rename = "approvalPolicy")]
9195    pub approval_policy: AskForApproval,
9196    #[serde(rename = "approvalsReviewer", default)]
9197    pub approvals_reviewer: Value,
9198    #[serde()]
9199    pub cwd: AbsolutePathBuf,
9200    /// Saved list of disabled plugin IDs. Does not yet filter plugin
9201    /// capabilities.
9202    #[serde(rename = "disabledPluginIds", default)]
9203    pub disabled_plugin_ids: Vec<String>,
9204    #[serde(
9205        rename = "instructionSources",
9206        default,
9207        skip_serializing_if = "Option::is_none"
9208    )]
9209    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9210    #[serde(default)]
9211    pub model: String,
9212    #[serde(rename = "modelProvider", default)]
9213    pub model_provider: String,
9214    #[serde(
9215        rename = "reasoningEffort",
9216        default,
9217        skip_serializing_if = "Option::is_none"
9218    )]
9219    pub reasoning_effort: Option<ReasoningEffort>,
9220    #[serde(default)]
9221    pub sandbox: Value,
9222    #[serde(
9223        rename = "serviceTier",
9224        default,
9225        skip_serializing_if = "Option::is_none"
9226    )]
9227    pub service_tier: Option<String>,
9228    #[serde()]
9229    pub thread: Thread,
9230}
9231
9232#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9233pub enum ThreadStartSource {
9234    #[serde(rename = "startup")]
9235    Startup,
9236    #[serde(rename = "clear")]
9237    Clear,
9238}
9239
9240#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9241#[serde(rename_all = "camelCase")]
9242pub struct ThreadStartedNotification {
9243    #[serde()]
9244    pub thread: Thread,
9245}
9246
9247#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9248#[serde(tag = "type", rename_all = "camelCase")]
9249pub enum ThreadStatus {
9250    #[serde(rename = "notLoaded")]
9251    NotLoaded,
9252    Idle,
9253    #[serde(rename = "systemError")]
9254    SystemError,
9255    Active {
9256        #[serde(rename = "activeFlags")]
9257        active_flags: Vec<ThreadActiveFlag>,
9258    },
9259}
9260
9261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9262#[serde(rename_all = "camelCase")]
9263pub struct ThreadStatusChangedNotification {
9264    #[serde()]
9265    pub status: ThreadStatus,
9266    #[serde(rename = "threadId", default)]
9267    pub thread_id: String,
9268}
9269
9270#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9271#[serde(rename_all = "camelCase")]
9272pub struct ThreadTokenUsage {
9273    #[serde()]
9274    pub last: TokenUsageBreakdown,
9275    #[serde(
9276        rename = "modelContextWindow",
9277        default,
9278        skip_serializing_if = "Option::is_none"
9279    )]
9280    pub model_context_window: Option<i64>,
9281    #[serde()]
9282    pub total: TokenUsageBreakdown,
9283}
9284
9285#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9286#[serde(rename_all = "camelCase")]
9287pub struct ThreadTokenUsageUpdatedNotification {
9288    #[serde(rename = "threadId", default)]
9289    pub thread_id: String,
9290    #[serde(rename = "tokenUsage")]
9291    pub token_usage: ThreadTokenUsage,
9292    #[serde(rename = "turnId", default)]
9293    pub turn_id: String,
9294}
9295
9296#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9297#[serde(rename_all = "camelCase")]
9298pub struct ThreadUnarchiveParams {
9299    #[serde(rename = "threadId", default)]
9300    pub thread_id: String,
9301}
9302
9303#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9304#[serde(rename_all = "camelCase")]
9305pub struct ThreadUnarchiveResponse {
9306    #[serde()]
9307    pub thread: Thread,
9308}
9309
9310#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9311#[serde(rename_all = "camelCase")]
9312pub struct ThreadUnarchivedNotification {
9313    #[serde(rename = "threadId", default)]
9314    pub thread_id: String,
9315}
9316
9317#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9318#[serde(tag = "type", rename_all = "camelCase")]
9319pub enum ThreadUnreadPosition {
9320    /// Explicitly marked unread, including when the thread has no turns.
9321    #[serde(rename = "threadStart")]
9322    ThreadStart,
9323    /// The earliest completed result needing attention.
9324    Turn {
9325        #[serde(rename = "turnId")]
9326        turn_id: String,
9327    },
9328}
9329
9330/// EXPERIMENTAL upstream — one item or turn boundary in canonical rollout
9331/// order (0.148). Wire quirk mirrored exactly: the `item` variant uses
9332/// camelCase `turnId` while the turn-boundary variants use snake_case
9333/// `turn_id`/`started_at`/`completed_at`/`duration_ms`.
9334#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9335#[serde(tag = "type", rename_all = "camelCase")]
9336#[allow(clippy::large_enum_variant)] // transient per-entry wire value, not stored in bulk
9337pub enum ThreadTimelineEntry {
9338    Item {
9339        item: ThreadItem,
9340        position: u64,
9341        #[serde(rename = "turnId")]
9342        turn_id: String,
9343    },
9344    Realtime {
9345        item: ThreadRealtimeItem,
9346        position: u64,
9347    },
9348    TurnStarted {
9349        position: u64,
9350        #[serde(default, skip_serializing_if = "Option::is_none")]
9351        started_at: Option<i64>,
9352        turn_id: String,
9353    },
9354    TurnCompleted {
9355        #[serde(default, skip_serializing_if = "Option::is_none")]
9356        completed_at: Option<i64>,
9357        #[serde(default, skip_serializing_if = "Option::is_none")]
9358        duration_ms: Option<i64>,
9359        #[serde(default, skip_serializing_if = "Option::is_none")]
9360        error: Option<TurnError>,
9361        position: u64,
9362        #[serde(default, skip_serializing_if = "Option::is_none")]
9363        started_at: Option<i64>,
9364        status: TurnStatus,
9365        turn_id: String,
9366    },
9367}
9368
9369/// Params for `thread/turns/list` — paginated turn hydration (0.148 upstream).
9370#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9371#[serde(rename_all = "camelCase")]
9372pub struct ThreadTurnsListParams {
9373    #[serde(default, skip_serializing_if = "Option::is_none")]
9374    pub cursor: Option<String>,
9375    /// How much item detail to include per turn; defaults to summary.
9376    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9377    pub items_view: Option<TurnItemsView>,
9378    #[serde(default, skip_serializing_if = "Option::is_none")]
9379    pub limit: Option<u32>,
9380    #[serde(
9381        rename = "sortDirection",
9382        default,
9383        skip_serializing_if = "Option::is_none"
9384    )]
9385    pub sort_direction: Option<SortDirection>,
9386    #[serde(rename = "threadId", default)]
9387    pub thread_id: String,
9388}
9389
9390/// Response to `thread/turns/list` (0.148 upstream).
9391#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9392#[serde(rename_all = "camelCase")]
9393pub struct ThreadTurnsListResponse {
9394    #[serde(
9395        rename = "backwardsCursor",
9396        default,
9397        skip_serializing_if = "Option::is_none"
9398    )]
9399    pub backwards_cursor: Option<String>,
9400    #[serde(default)]
9401    pub data: Vec<Turn>,
9402    #[serde(
9403        rename = "nextCursor",
9404        default,
9405        skip_serializing_if = "Option::is_none"
9406    )]
9407    pub next_cursor: Option<String>,
9408}
9409
9410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9411#[serde(rename_all = "camelCase")]
9412pub struct ThreadUnsubscribeParams {
9413    #[serde(rename = "threadId", default)]
9414    pub thread_id: String,
9415}
9416
9417#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9418#[serde(rename_all = "camelCase")]
9419pub struct ThreadUnsubscribeResponse {
9420    #[serde()]
9421    pub status: ThreadUnsubscribeStatus,
9422}
9423
9424#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9425pub enum ThreadUnsubscribeStatus {
9426    #[serde(rename = "notLoaded")]
9427    NotLoaded,
9428    #[serde(rename = "notSubscribed")]
9429    NotSubscribed,
9430    #[serde(rename = "unsubscribed")]
9431    Unsubscribed,
9432}
9433
9434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9435#[serde(rename_all = "camelCase")]
9436pub struct TokenUsageBreakdown {
9437    #[serde(
9438        rename = "cacheWriteInputTokens",
9439        default,
9440        skip_serializing_if = "Option::is_none"
9441    )]
9442    pub cache_write_input_tokens: Option<i64>,
9443    #[serde(rename = "cachedInputTokens", default)]
9444    pub cached_input_tokens: i64,
9445    #[serde(rename = "inputTokens", default)]
9446    pub input_tokens: i64,
9447    #[serde(rename = "outputTokens", default)]
9448    pub output_tokens: i64,
9449    #[serde(rename = "reasoningOutputTokens", default)]
9450    pub reasoning_output_tokens: i64,
9451    #[serde(rename = "totalTokens", default)]
9452    pub total_tokens: i64,
9453}
9454
9455#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9456#[serde(rename_all = "camelCase")]
9457pub struct Tool {
9458    #[serde(default, skip_serializing_if = "Option::is_none")]
9459    pub _meta: Option<Value>,
9460    #[serde(default, skip_serializing_if = "Option::is_none")]
9461    pub annotations: Option<Value>,
9462    #[serde(default, skip_serializing_if = "Option::is_none")]
9463    pub description: Option<String>,
9464    #[serde(default, skip_serializing_if = "Option::is_none")]
9465    pub icons: Option<Vec<Value>>,
9466    #[serde(rename = "inputSchema", default)]
9467    pub input_schema: Value,
9468    #[serde(default)]
9469    pub name: String,
9470    #[serde(
9471        rename = "outputSchema",
9472        default,
9473        skip_serializing_if = "Option::is_none"
9474    )]
9475    pub output_schema: Option<Value>,
9476    #[serde(default, skip_serializing_if = "Option::is_none")]
9477    pub title: Option<String>,
9478}
9479
9480#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9481#[serde(rename_all = "camelCase")]
9482pub struct ToolRequestUserInputAnswer {
9483    #[serde(default)]
9484    pub answers: Vec<String>,
9485}
9486
9487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9488#[serde(rename_all = "camelCase")]
9489pub struct ToolRequestUserInputOption {
9490    #[serde(default)]
9491    pub description: String,
9492    #[serde(default)]
9493    pub label: String,
9494}
9495
9496#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9497#[serde(rename_all = "camelCase")]
9498pub struct ToolRequestUserInputParams {
9499    #[serde(
9500        rename = "autoResolutionMs",
9501        default,
9502        skip_serializing_if = "Option::is_none"
9503    )]
9504    pub auto_resolution_ms: Option<i64>,
9505    #[serde(rename = "isBlocking", default)]
9506    pub is_blocking: bool,
9507    #[serde(rename = "itemId", default)]
9508    pub item_id: String,
9509    #[serde(default)]
9510    pub questions: Vec<ToolRequestUserInputQuestion>,
9511    #[serde(rename = "threadId", default)]
9512    pub thread_id: String,
9513    #[serde(rename = "turnId", default)]
9514    pub turn_id: String,
9515}
9516
9517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9518#[serde(rename_all = "camelCase")]
9519pub struct ToolRequestUserInputQuestion {
9520    #[serde(default)]
9521    pub header: String,
9522    #[serde(default)]
9523    pub id: String,
9524    #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
9525    pub is_other: Option<bool>,
9526    #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
9527    pub is_secret: Option<bool>,
9528    #[serde(default, skip_serializing_if = "Option::is_none")]
9529    pub options: Option<Vec<ToolRequestUserInputOption>>,
9530    #[serde(default)]
9531    pub question: String,
9532}
9533
9534#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9535#[serde(rename_all = "camelCase")]
9536pub struct ToolRequestUserInputResponse {
9537    #[serde(default)]
9538    pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
9539}
9540
9541#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9542#[serde(rename_all = "camelCase")]
9543pub struct ToolsV2 {
9544    #[serde(default, skip_serializing_if = "Option::is_none")]
9545    pub web_search: Option<WebSearchToolConfig>,
9546}
9547
9548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9549#[serde(rename_all = "camelCase")]
9550pub struct Turn {
9551    #[serde(
9552        rename = "completedAt",
9553        default,
9554        skip_serializing_if = "Option::is_none"
9555    )]
9556    pub completed_at: Option<i64>,
9557    #[serde(
9558        rename = "durationMs",
9559        default,
9560        skip_serializing_if = "Option::is_none"
9561    )]
9562    pub duration_ms: Option<i64>,
9563    #[serde(default, skip_serializing_if = "Option::is_none")]
9564    pub error: Option<TurnError>,
9565    #[serde(default)]
9566    pub id: String,
9567    #[serde(default)]
9568    pub items: Vec<ThreadItem>,
9569    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9570    pub items_view: Option<Value>,
9571    /// ID of the first turn in the chain of work that led to this turn. Pass
9572    /// this as `rootTurnId` when starting work on behalf of this turn. May be
9573    /// null in older history or a `review/start` response.
9574    #[serde(
9575        rename = "rootTurnId",
9576        default,
9577        skip_serializing_if = "Option::is_none"
9578    )]
9579    pub root_turn_id: Option<String>,
9580    #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
9581    pub started_at: Option<i64>,
9582    #[serde()]
9583    pub status: TurnStatus,
9584}
9585
9586#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9587#[serde(rename_all = "camelCase")]
9588pub struct TurnCompletedNotification {
9589    #[serde(rename = "threadId", default)]
9590    pub thread_id: String,
9591    #[serde()]
9592    pub turn: Turn,
9593}
9594
9595#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9596#[serde(rename_all = "camelCase")]
9597pub struct TurnDiffUpdatedNotification {
9598    #[serde(default)]
9599    pub diff: String,
9600    #[serde(rename = "threadId", default)]
9601    pub thread_id: String,
9602    #[serde(rename = "turnId", default)]
9603    pub turn_id: String,
9604}
9605
9606#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9607#[serde(rename_all = "camelCase")]
9608pub struct TurnError {
9609    #[serde(
9610        rename = "additionalDetails",
9611        default,
9612        skip_serializing_if = "Option::is_none"
9613    )]
9614    pub additional_details: Option<String>,
9615    #[serde(
9616        rename = "codexErrorInfo",
9617        default,
9618        skip_serializing_if = "Option::is_none"
9619    )]
9620    pub codex_error_info: Option<CodexErrorInfo>,
9621    #[serde(default)]
9622    pub message: String,
9623    /// Public explanation and continuation instruction for a misalignment
9624    /// block (0.148 upstream).
9625    #[serde(default, skip_serializing_if = "Option::is_none")]
9626    pub misalignment: Option<MisalignmentErrorDetails>,
9627}
9628
9629#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9630#[serde(rename_all = "camelCase")]
9631pub struct TurnInterruptParams {
9632    #[serde(rename = "threadId", default)]
9633    pub thread_id: String,
9634    #[serde(rename = "turnId", default)]
9635    pub turn_id: String,
9636}
9637
9638#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9639#[serde(rename_all = "camelCase")]
9640pub struct TurnInterruptResponse {
9641    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9642    pub extra: serde_json::Map<String, Value>,
9643}
9644
9645#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
9646pub enum TurnItemsView {
9647    #[serde(rename = "notLoaded")]
9648    NotLoaded,
9649    #[serde(rename = "summary")]
9650    Summary,
9651    #[serde(rename = "full")]
9652    Full,
9653}
9654
9655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9656#[serde(rename_all = "camelCase")]
9657pub struct TurnModerationMetadataNotification {
9658    #[serde(default)]
9659    pub metadata: Value,
9660    #[serde(rename = "threadId", default)]
9661    pub thread_id: String,
9662    #[serde(rename = "turnId", default)]
9663    pub turn_id: String,
9664}
9665
9666#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9667#[serde(rename_all = "camelCase")]
9668pub struct TurnPlanStep {
9669    #[serde()]
9670    pub status: TurnPlanStepStatus,
9671    #[serde(default)]
9672    pub step: String,
9673}
9674
9675#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9676pub enum TurnPlanStepStatus {
9677    #[serde(rename = "pending")]
9678    Pending,
9679    #[serde(rename = "inProgress")]
9680    InProgress,
9681    #[serde(rename = "completed")]
9682    Completed,
9683}
9684
9685#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9686#[serde(rename_all = "camelCase")]
9687pub struct TurnPlanUpdatedNotification {
9688    #[serde(default, skip_serializing_if = "Option::is_none")]
9689    pub explanation: Option<String>,
9690    #[serde(default)]
9691    pub plan: Vec<TurnPlanStep>,
9692    #[serde(rename = "threadId", default)]
9693    pub thread_id: String,
9694    #[serde(rename = "turnId", default)]
9695    pub turn_id: String,
9696}
9697
9698#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9699#[serde(rename_all = "camelCase")]
9700pub struct TurnStartParams {
9701    #[serde(
9702        rename = "approvalPolicy",
9703        default,
9704        skip_serializing_if = "Option::is_none"
9705    )]
9706    pub approval_policy: Option<AskForApproval>,
9707    #[serde(
9708        rename = "approvalsReviewer",
9709        default,
9710        skip_serializing_if = "Option::is_none"
9711    )]
9712    pub approvals_reviewer: Option<ApprovalsReviewer>,
9713    #[serde(
9714        rename = "clientUserMessageId",
9715        default,
9716        skip_serializing_if = "Option::is_none"
9717    )]
9718    pub client_user_message_id: Option<String>,
9719    #[serde(default, skip_serializing_if = "Option::is_none")]
9720    pub cwd: Option<String>,
9721    /// Replace this thread's disabled plugin IDs. Omitted/null preserves the
9722    /// list; `[]` clears it.
9723    #[serde(
9724        rename = "disabledPluginIds",
9725        default,
9726        skip_serializing_if = "Option::is_none"
9727    )]
9728    pub disabled_plugin_ids: Option<Vec<String>>,
9729    #[serde(default, skip_serializing_if = "Option::is_none")]
9730    pub effort: Option<ReasoningEffort>,
9731    #[serde(default)]
9732    pub input: Vec<UserInput>,
9733    #[serde(default, skip_serializing_if = "Option::is_none")]
9734    pub model: Option<String>,
9735    #[serde(
9736        rename = "outputSchema",
9737        default,
9738        skip_serializing_if = "Option::is_none"
9739    )]
9740    pub output_schema: Option<Value>,
9741    /// ID of the turn that caused this new turn to start. Set this when
9742    /// starting work on behalf of another turn; leave unset for work started
9743    /// directly by the user. Ignored when adding input to an active turn.
9744    #[serde(
9745        rename = "parentTurnId",
9746        default,
9747        skip_serializing_if = "Option::is_none"
9748    )]
9749    pub parent_turn_id: Option<String>,
9750    #[serde(default, skip_serializing_if = "Option::is_none")]
9751    pub personality: Option<Personality>,
9752    /// ID of the first turn in the chain of work that led to this new turn.
9753    /// When setting `parent_turn_id`, set this to the parent turn's
9754    /// `root_turn_id` when known; if omitted, the new turn becomes its own
9755    /// root. Ignored when adding input to an active turn.
9756    #[serde(
9757        rename = "rootTurnId",
9758        default,
9759        skip_serializing_if = "Option::is_none"
9760    )]
9761    pub root_turn_id: Option<String>,
9762    #[serde(
9763        rename = "sandboxPolicy",
9764        default,
9765        skip_serializing_if = "Option::is_none"
9766    )]
9767    pub sandbox_policy: Option<SandboxPolicy>,
9768    #[serde(
9769        rename = "serviceTier",
9770        default,
9771        skip_serializing_if = "Option::is_none"
9772    )]
9773    pub service_tier: Option<String>,
9774    /// One-turn service-tier override; `"default"` for standard speed.
9775    /// Omitted or null inherits the thread's tier (0.148 upstream).
9776    #[serde(
9777        rename = "serviceTierForTurn",
9778        default,
9779        skip_serializing_if = "Option::is_none"
9780    )]
9781    pub service_tier_for_turn: Option<String>,
9782    #[serde(default, skip_serializing_if = "Option::is_none")]
9783    pub summary: Option<ReasoningSummary>,
9784    #[serde(rename = "threadId", default)]
9785    pub thread_id: String,
9786    /// Pre-computed tool output to inject when starting the turn
9787    /// (0.148 upstream).
9788    #[serde(
9789        rename = "toolOutput",
9790        default,
9791        skip_serializing_if = "Option::is_none"
9792    )]
9793    pub tool_output: Option<TurnToolOutput>,
9794    /// Optional source classification for the caller starting this turn;
9795    /// ignored when steering an already-active turn (0.148 upstream).
9796    #[serde(
9797        rename = "turnTrigger",
9798        default,
9799        skip_serializing_if = "Option::is_none"
9800    )]
9801    pub turn_trigger: Option<String>,
9802}
9803
9804#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9805#[serde(rename_all = "camelCase")]
9806pub struct TurnStartResponse {
9807    #[serde()]
9808    pub turn: Turn,
9809}
9810
9811#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9812#[serde(rename_all = "camelCase")]
9813pub struct TurnStartedNotification {
9814    #[serde(rename = "threadId", default)]
9815    pub thread_id: String,
9816    #[serde()]
9817    pub turn: Turn,
9818}
9819
9820#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9821pub enum TurnStatus {
9822    #[serde(rename = "completed")]
9823    Completed,
9824    #[serde(rename = "interrupted")]
9825    Interrupted,
9826    #[serde(rename = "failed")]
9827    Failed,
9828    #[serde(rename = "inProgress")]
9829    InProgress,
9830}
9831
9832/// A pre-computed tool output supplied when starting a turn
9833/// (`TurnStartParams.toolOutput`, 0.148 upstream).
9834#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9835#[serde(rename_all = "camelCase")]
9836pub struct TurnToolOutput {
9837    #[serde(default)]
9838    pub name: String,
9839    #[serde(default, skip_serializing_if = "Option::is_none")]
9840    pub namespace: Option<String>,
9841    #[serde()]
9842    pub output: FunctionCallOutputBody,
9843    /// Requests retention of this output in the thread's model history
9844    /// (openai/codex#52686). Omitted from the wire when `false`.
9845    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9846    pub retain: bool,
9847}
9848
9849#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9850#[serde(rename_all = "camelCase")]
9851pub struct TurnSteerParams {
9852    #[serde(
9853        rename = "clientUserMessageId",
9854        default,
9855        skip_serializing_if = "Option::is_none"
9856    )]
9857    pub client_user_message_id: Option<String>,
9858    #[serde(rename = "expectedTurnId", default)]
9859    pub expected_turn_id: String,
9860    #[serde(default)]
9861    pub input: Vec<UserInput>,
9862    #[serde(rename = "threadId", default)]
9863    pub thread_id: String,
9864}
9865
9866#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9867#[serde(rename_all = "camelCase")]
9868pub struct TurnSteerResponse {
9869    #[serde(rename = "turnId", default)]
9870    pub turn_id: String,
9871}
9872
9873#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9874#[serde(tag = "type", rename_all = "camelCase")]
9875pub enum UserInput {
9876    Text {
9877        text: String,
9878        #[serde(default, skip_serializing_if = "Option::is_none")]
9879        text_elements: Option<Vec<TextElement>>,
9880    },
9881    Image {
9882        #[serde(default, skip_serializing_if = "Option::is_none")]
9883        detail: Option<ImageDetail>,
9884        #[serde(flatten)]
9885        image: UserInputImageReference,
9886    },
9887    #[serde(rename = "localImage")]
9888    LocalImage {
9889        #[serde(default, skip_serializing_if = "Option::is_none")]
9890        detail: Option<ImageDetail>,
9891        path: String,
9892    },
9893    Audio {
9894        url: String,
9895    },
9896    #[serde(rename = "localAudio")]
9897    LocalAudio {
9898        path: String,
9899    },
9900    Skill {
9901        name: String,
9902        path: String,
9903    },
9904    Mention {
9905        name: String,
9906        path: String,
9907    },
9908}
9909
9910/// How a [`UserInput::Image`] names its image: an inline `url` (data URL or
9911/// remote URL) or a previously uploaded `fileId`. Flattened into the variant;
9912/// untagged, so exactly one of the two keys is on the wire. Mirrors the v2
9913/// `ImageReference` upstream; the Responses-API twin used by tool outputs is
9914/// [`ImageReference`].
9915#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9916#[serde(untagged)]
9917pub enum UserInputImageReference {
9918    Inline {
9919        url: String,
9920    },
9921    File {
9922        #[serde(rename = "fileId")]
9923        file_id: String,
9924    },
9925}
9926
9927#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9928pub enum Verbosity {
9929    #[serde(rename = "low")]
9930    Low,
9931    #[serde(rename = "medium")]
9932    Medium,
9933    #[serde(rename = "high")]
9934    High,
9935}
9936
9937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9938#[serde(rename_all = "camelCase")]
9939pub struct WarningNotification {
9940    #[serde(default)]
9941    pub message: String,
9942    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
9943    pub thread_id: Option<String>,
9944}
9945
9946#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9947#[serde(tag = "type", rename_all = "camelCase")]
9948pub enum WebSearchAction {
9949    Search {
9950        #[serde(default, skip_serializing_if = "Option::is_none")]
9951        queries: Option<Vec<String>>,
9952        #[serde(default, skip_serializing_if = "Option::is_none")]
9953        query: Option<String>,
9954    },
9955    #[serde(rename = "openPage")]
9956    OpenPage {
9957        #[serde(default, skip_serializing_if = "Option::is_none")]
9958        url: Option<String>,
9959    },
9960    #[serde(rename = "findInPage")]
9961    FindInPage {
9962        #[serde(default, skip_serializing_if = "Option::is_none")]
9963        pattern: Option<String>,
9964        #[serde(default, skip_serializing_if = "Option::is_none")]
9965        url: Option<String>,
9966    },
9967    Other,
9968}
9969
9970#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9971pub enum WebSearchContextSize {
9972    #[serde(rename = "low")]
9973    Low,
9974    #[serde(rename = "medium")]
9975    Medium,
9976    #[serde(rename = "high")]
9977    High,
9978}
9979
9980#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9981#[serde(rename_all = "camelCase")]
9982pub struct WebSearchLocation {
9983    #[serde(default, skip_serializing_if = "Option::is_none")]
9984    pub city: Option<String>,
9985    #[serde(default, skip_serializing_if = "Option::is_none")]
9986    pub country: Option<String>,
9987    #[serde(default, skip_serializing_if = "Option::is_none")]
9988    pub region: Option<String>,
9989    #[serde(default, skip_serializing_if = "Option::is_none")]
9990    pub timezone: Option<String>,
9991}
9992
9993#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9994pub enum WebSearchMode {
9995    #[serde(rename = "disabled")]
9996    Disabled,
9997    #[serde(rename = "cached")]
9998    Cached,
9999    #[serde(rename = "indexed")]
10000    Indexed,
10001    #[serde(rename = "live")]
10002    Live,
10003}
10004
10005#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10006#[serde(rename_all = "camelCase")]
10007pub struct WebSearchToolConfig {
10008    #[serde(default, skip_serializing_if = "Option::is_none")]
10009    pub allowed_domains: Option<Vec<String>>,
10010    #[serde(default, skip_serializing_if = "Option::is_none")]
10011    pub context_size: Option<WebSearchContextSize>,
10012    #[serde(default, skip_serializing_if = "Option::is_none")]
10013    pub location: Option<WebSearchLocation>,
10014}
10015
10016#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10017pub enum WindowsSandboxReadiness {
10018    #[serde(rename = "ready")]
10019    Ready,
10020    #[serde(rename = "notConfigured")]
10021    NotConfigured,
10022    #[serde(rename = "updateRequired")]
10023    UpdateRequired,
10024}
10025
10026#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10027#[serde(rename_all = "camelCase")]
10028pub struct WindowsSandboxReadinessResponse {
10029    #[serde()]
10030    pub status: WindowsSandboxReadiness,
10031}
10032
10033#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10034#[serde(rename_all = "camelCase")]
10035pub struct WindowsSandboxSetupCompletedNotification {
10036    #[serde(default, skip_serializing_if = "Option::is_none")]
10037    pub error: Option<String>,
10038    #[serde()]
10039    pub mode: WindowsSandboxSetupMode,
10040    #[serde(default)]
10041    pub success: bool,
10042}
10043
10044#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10045pub enum WindowsSandboxSetupMode {
10046    #[serde(rename = "elevated")]
10047    Elevated,
10048    #[serde(rename = "unelevated")]
10049    Unelevated,
10050}
10051
10052/// A Windows sandbox implementation a managed policy may allow
10053/// ([`ConfigRequirements::allowed_windows_sandbox_implementations`]). Grows
10054/// `mxc` beyond the two [`WindowsSandboxSetupMode`] values.
10055#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10056pub enum WindowsSandboxImplementation {
10057    #[serde(rename = "elevated")]
10058    Elevated,
10059    #[serde(rename = "unelevated")]
10060    Unelevated,
10061    #[serde(rename = "mxc")]
10062    Mxc,
10063}
10064
10065#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10066#[serde(rename_all = "camelCase")]
10067pub struct WindowsSandboxSetupStartParams {
10068    #[serde(default, skip_serializing_if = "Option::is_none")]
10069    pub cwd: Option<AbsolutePathBuf>,
10070    #[serde()]
10071    pub mode: WindowsSandboxSetupMode,
10072}
10073
10074#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10075#[serde(rename_all = "camelCase")]
10076pub struct WindowsSandboxSetupStartResponse {
10077    #[serde(default)]
10078    pub started: bool,
10079}
10080
10081#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10082#[serde(rename_all = "camelCase")]
10083pub struct WindowsWorldWritableWarningNotification {
10084    #[serde(rename = "extraCount", default)]
10085    pub extra_count: i64,
10086    #[serde(rename = "failedScan", default)]
10087    pub failed_scan: bool,
10088    #[serde(rename = "samplePaths", default)]
10089    pub sample_paths: Vec<String>,
10090}
10091
10092#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10093#[serde(rename_all = "camelCase")]
10094pub struct WorkspaceMessage {
10095    #[serde(
10096        rename = "archivedAt",
10097        default,
10098        skip_serializing_if = "Option::is_none"
10099    )]
10100    pub archived_at: Option<i64>,
10101    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
10102    pub created_at: Option<i64>,
10103    #[serde(rename = "messageBody", default)]
10104    pub message_body: String,
10105    #[serde(rename = "messageId", default)]
10106    pub message_id: String,
10107    #[serde(rename = "messageType")]
10108    pub message_type: WorkspaceMessageType,
10109}
10110
10111#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10112pub enum WorkspaceMessageType {
10113    #[serde(rename = "headline")]
10114    Headline,
10115    #[serde(rename = "announcement")]
10116    Announcement,
10117    #[serde(rename = "unknown")]
10118    Unknown,
10119}
10120
10121#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10122pub enum WriteStatus {
10123    #[serde(rename = "ok")]
10124    Ok,
10125    #[serde(rename = "okOverridden")]
10126    OkOverridden,
10127}