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