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