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    /// Select this environment's registration. Requires `server_name` and
3957    /// `thread_id`. When omitted, a named request uses the same server as
3958    /// older clients.
3959    #[serde(
3960        rename = "environmentId",
3961        default,
3962        skip_serializing_if = "Option::is_none"
3963    )]
3964    pub environment_id: Option<String>,
3965    #[serde(default, skip_serializing_if = "Option::is_none")]
3966    pub limit: Option<i64>,
3967    /// Limit discovery to one server. With a thread ID, reuse that thread's
3968    /// MCP connection.
3969    #[serde(
3970        rename = "serverName",
3971        default,
3972        skip_serializing_if = "Option::is_none"
3973    )]
3974    pub server_name: Option<String>,
3975    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3976    pub thread_id: Option<String>,
3977}
3978
3979#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3980#[serde(rename_all = "camelCase")]
3981pub struct ListMcpServerStatusResponse {
3982    #[serde(default)]
3983    pub data: Vec<McpServerStatus>,
3984    #[serde(
3985        rename = "nextCursor",
3986        default,
3987        skip_serializing_if = "Option::is_none"
3988    )]
3989    pub next_cursor: Option<String>,
3990}
3991
3992#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3993#[serde(tag = "type", rename_all = "camelCase")]
3994pub enum LoginAccountParams {
3995    #[serde(rename = "apiKey")]
3996    ApiKey {
3997        #[serde(rename = "apiKey")]
3998        api_key: String,
3999    },
4000    Chatgpt {
4001        #[serde(rename = "appBrand", default, skip_serializing_if = "Option::is_none")]
4002        app_brand: Option<LoginAppBrand>,
4003        #[serde(
4004            rename = "codexStreamlinedLogin",
4005            default,
4006            skip_serializing_if = "Option::is_none"
4007        )]
4008        codex_streamlined_login: Option<bool>,
4009        #[serde(
4010            rename = "useHostedLoginSuccessPage",
4011            default,
4012            skip_serializing_if = "Option::is_none"
4013        )]
4014        use_hosted_login_success_page: Option<bool>,
4015    },
4016    #[serde(rename = "chatgptDeviceCode")]
4017    ChatgptDeviceCode,
4018    #[serde(rename = "chatgptAuthTokens")]
4019    ChatgptAuthTokens {
4020        #[serde(rename = "accessToken")]
4021        access_token: String,
4022        #[serde(rename = "chatgptAccountId")]
4023        chatgpt_account_id: String,
4024        #[serde(
4025            rename = "chatgptPlanType",
4026            default,
4027            skip_serializing_if = "Option::is_none"
4028        )]
4029        chatgpt_plan_type: Option<String>,
4030    },
4031    #[serde(rename = "amazonBedrock")]
4032    AmazonBedrock {
4033        #[serde(rename = "apiKey")]
4034        api_key: String,
4035        region: String,
4036    },
4037    #[serde(rename = "amazonBedrockAccessKeys")]
4038    AmazonBedrockAccessKeys {
4039        #[serde(rename = "accessKeyId")]
4040        access_key_id: String,
4041        region: String,
4042        #[serde(rename = "secretAccessKey")]
4043        secret_access_key: String,
4044        #[serde(
4045            rename = "sessionToken",
4046            default,
4047            skip_serializing_if = "Option::is_none"
4048        )]
4049        session_token: Option<String>,
4050    },
4051}
4052
4053#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4054#[serde(tag = "type", rename_all = "camelCase")]
4055pub enum LoginAccountResponse {
4056    #[serde(rename = "apiKey")]
4057    ApiKey,
4058    Chatgpt {
4059        #[serde(rename = "authUrl")]
4060        auth_url: String,
4061        #[serde(rename = "loginId")]
4062        login_id: String,
4063    },
4064    #[serde(rename = "chatgptDeviceCode")]
4065    ChatgptDeviceCode {
4066        #[serde(rename = "loginId")]
4067        login_id: String,
4068        #[serde(rename = "userCode")]
4069        user_code: String,
4070        #[serde(rename = "verificationUrl")]
4071        verification_url: String,
4072    },
4073    #[serde(rename = "chatgptAuthTokens")]
4074    ChatgptAuthTokens,
4075    #[serde(rename = "amazonBedrock")]
4076    AmazonBedrock,
4077}
4078
4079#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4080pub enum LoginAppBrand {
4081    #[serde(rename = "codex")]
4082    Codex,
4083    #[serde(rename = "chatgpt")]
4084    Chatgpt,
4085}
4086
4087#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4088#[serde(rename_all = "camelCase")]
4089pub struct LogoutAccountResponse {
4090    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4091    pub extra: serde_json::Map<String, Value>,
4092}
4093
4094#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4095#[serde(rename_all = "camelCase")]
4096pub struct MarketplaceAddParams {
4097    #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
4098    pub ref_name: Option<String>,
4099    #[serde(default)]
4100    pub source: String,
4101    #[serde(
4102        rename = "sparsePaths",
4103        default,
4104        skip_serializing_if = "Option::is_none"
4105    )]
4106    pub sparse_paths: Option<Vec<String>>,
4107}
4108
4109#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4110#[serde(rename_all = "camelCase")]
4111pub struct MarketplaceAddResponse {
4112    #[serde(rename = "alreadyAdded", default)]
4113    pub already_added: bool,
4114    #[serde(rename = "installedRoot")]
4115    pub installed_root: AbsolutePathBuf,
4116    #[serde(rename = "marketplaceName", default)]
4117    pub marketplace_name: String,
4118}
4119
4120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4121#[serde(rename_all = "camelCase")]
4122pub struct MarketplaceInterface {
4123    #[serde(
4124        rename = "displayName",
4125        default,
4126        skip_serializing_if = "Option::is_none"
4127    )]
4128    pub display_name: Option<String>,
4129}
4130
4131#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4132#[serde(rename_all = "camelCase")]
4133pub struct MarketplaceLoadErrorInfo {
4134    #[serde(rename = "marketplacePath")]
4135    pub marketplace_path: AbsolutePathBuf,
4136    #[serde(default)]
4137    pub message: String,
4138}
4139
4140#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4141#[serde(rename_all = "camelCase")]
4142pub struct MarketplaceRemoveParams {
4143    #[serde(rename = "marketplaceName", default)]
4144    pub marketplace_name: String,
4145}
4146
4147#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4148#[serde(rename_all = "camelCase")]
4149pub struct MarketplaceRemoveResponse {
4150    #[serde(
4151        rename = "installedRoot",
4152        default,
4153        skip_serializing_if = "Option::is_none"
4154    )]
4155    pub installed_root: Option<AbsolutePathBuf>,
4156    #[serde(rename = "marketplaceName", default)]
4157    pub marketplace_name: String,
4158}
4159
4160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4161#[serde(rename_all = "camelCase")]
4162pub struct MarketplaceUpgradeErrorInfo {
4163    #[serde(rename = "marketplaceName", default)]
4164    pub marketplace_name: String,
4165    #[serde(default)]
4166    pub message: String,
4167}
4168
4169#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4170#[serde(rename_all = "camelCase")]
4171pub struct MarketplaceUpgradeParams {
4172    #[serde(
4173        rename = "marketplaceName",
4174        default,
4175        skip_serializing_if = "Option::is_none"
4176    )]
4177    pub marketplace_name: Option<String>,
4178}
4179
4180#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4181#[serde(rename_all = "camelCase")]
4182pub struct MarketplaceUpgradeResponse {
4183    #[serde(default)]
4184    pub errors: Vec<MarketplaceUpgradeErrorInfo>,
4185    #[serde(rename = "selectedMarketplaces", default)]
4186    pub selected_marketplaces: Vec<String>,
4187    #[serde(rename = "upgradedRoots", default)]
4188    pub upgraded_roots: Vec<AbsolutePathBuf>,
4189}
4190
4191#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4192pub enum McpAuthStatus {
4193    #[serde(rename = "unknown")]
4194    Unknown,
4195    #[serde(rename = "unsupported")]
4196    Unsupported,
4197    #[serde(rename = "notLoggedIn")]
4198    NotLoggedIn,
4199    #[serde(rename = "bearerToken")]
4200    BearerToken,
4201    #[serde(rename = "oAuth")]
4202    OAuth,
4203}
4204
4205#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4206pub enum McpElicitationArrayType {
4207    #[serde(rename = "array")]
4208    Array,
4209}
4210
4211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4212#[serde(rename_all = "camelCase")]
4213pub struct McpElicitationBooleanSchema {
4214    #[serde(default, skip_serializing_if = "Option::is_none")]
4215    pub default: Option<bool>,
4216    #[serde(default, skip_serializing_if = "Option::is_none")]
4217    pub description: Option<String>,
4218    #[serde(default, skip_serializing_if = "Option::is_none")]
4219    pub title: Option<String>,
4220    #[serde(rename = "type")]
4221    pub type_: McpElicitationBooleanType,
4222}
4223
4224#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4225pub enum McpElicitationBooleanType {
4226    #[serde(rename = "boolean")]
4227    Boolean,
4228}
4229
4230#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4231#[serde(rename_all = "camelCase")]
4232pub struct McpElicitationConstOption {
4233    #[serde(rename = "const", default)]
4234    pub const_: String,
4235    #[serde(default)]
4236    pub title: String,
4237}
4238
4239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4240#[serde(untagged)]
4241pub enum McpElicitationEnumSchema {
4242    McpElicitationSingleSelectEnumSchema(McpElicitationSingleSelectEnumSchema),
4243    McpElicitationMultiSelectEnumSchema(McpElicitationMultiSelectEnumSchema),
4244    McpElicitationLegacyTitledEnumSchema(McpElicitationLegacyTitledEnumSchema),
4245}
4246
4247#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4248#[serde(rename_all = "camelCase")]
4249pub struct McpElicitationLegacyTitledEnumSchema {
4250    #[serde(default, skip_serializing_if = "Option::is_none")]
4251    pub default: Option<String>,
4252    #[serde(default, skip_serializing_if = "Option::is_none")]
4253    pub description: Option<String>,
4254    #[serde(rename = "enum", default)]
4255    pub enum_: Vec<String>,
4256    #[serde(rename = "enumNames", default, skip_serializing_if = "Option::is_none")]
4257    pub enum_names: Option<Vec<String>>,
4258    #[serde(default, skip_serializing_if = "Option::is_none")]
4259    pub title: Option<String>,
4260    #[serde(rename = "type")]
4261    pub type_: McpElicitationStringType,
4262}
4263
4264#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4265#[serde(untagged)]
4266pub enum McpElicitationMultiSelectEnumSchema {
4267    McpElicitationUntitledMultiSelectEnumSchema(McpElicitationUntitledMultiSelectEnumSchema),
4268    McpElicitationTitledMultiSelectEnumSchema(McpElicitationTitledMultiSelectEnumSchema),
4269}
4270
4271#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4272#[serde(rename_all = "camelCase")]
4273pub struct McpElicitationNumberSchema {
4274    #[serde(default, skip_serializing_if = "Option::is_none")]
4275    pub default: Option<f64>,
4276    #[serde(default, skip_serializing_if = "Option::is_none")]
4277    pub description: Option<String>,
4278    #[serde(default, skip_serializing_if = "Option::is_none")]
4279    pub maximum: Option<f64>,
4280    #[serde(default, skip_serializing_if = "Option::is_none")]
4281    pub minimum: Option<f64>,
4282    #[serde(default, skip_serializing_if = "Option::is_none")]
4283    pub title: Option<String>,
4284    #[serde(rename = "type")]
4285    pub type_: McpElicitationNumberType,
4286}
4287
4288#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4289pub enum McpElicitationNumberType {
4290    #[serde(rename = "number")]
4291    Number,
4292    #[serde(rename = "integer")]
4293    Integer,
4294}
4295
4296#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4297pub enum McpElicitationObjectType {
4298    #[serde(rename = "object")]
4299    Object,
4300}
4301
4302#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4303#[serde(untagged)]
4304pub enum McpElicitationPrimitiveSchema {
4305    McpElicitationEnumSchema(McpElicitationEnumSchema),
4306    McpElicitationStringSchema(McpElicitationStringSchema),
4307    McpElicitationNumberSchema(McpElicitationNumberSchema),
4308    McpElicitationBooleanSchema(McpElicitationBooleanSchema),
4309}
4310
4311#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4312#[serde(rename_all = "camelCase")]
4313pub struct McpElicitationSchema {
4314    #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
4315    pub schema: Option<String>,
4316    #[serde(default)]
4317    pub properties: std::collections::BTreeMap<String, McpElicitationPrimitiveSchema>,
4318    #[serde(default, skip_serializing_if = "Option::is_none")]
4319    pub required: Option<Vec<String>>,
4320    #[serde(rename = "type")]
4321    pub type_: McpElicitationObjectType,
4322}
4323
4324#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4325#[serde(untagged)]
4326pub enum McpElicitationSingleSelectEnumSchema {
4327    McpElicitationUntitledSingleSelectEnumSchema(McpElicitationUntitledSingleSelectEnumSchema),
4328    McpElicitationTitledSingleSelectEnumSchema(McpElicitationTitledSingleSelectEnumSchema),
4329}
4330
4331#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4332pub enum McpElicitationStringFormat {
4333    #[serde(rename = "email")]
4334    Email,
4335    #[serde(rename = "uri")]
4336    Uri,
4337    #[serde(rename = "date")]
4338    Date,
4339    #[serde(rename = "date-time")]
4340    Date_time,
4341}
4342
4343#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4344#[serde(rename_all = "camelCase")]
4345pub struct McpElicitationStringSchema {
4346    #[serde(default, skip_serializing_if = "Option::is_none")]
4347    pub default: Option<String>,
4348    #[serde(default, skip_serializing_if = "Option::is_none")]
4349    pub description: Option<String>,
4350    #[serde(default, skip_serializing_if = "Option::is_none")]
4351    pub format: Option<McpElicitationStringFormat>,
4352    #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
4353    pub max_length: Option<i64>,
4354    #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
4355    pub min_length: Option<i64>,
4356    #[serde(default, skip_serializing_if = "Option::is_none")]
4357    pub title: Option<String>,
4358    #[serde(rename = "type")]
4359    pub type_: McpElicitationStringType,
4360}
4361
4362#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4363pub enum McpElicitationStringType {
4364    #[serde(rename = "string")]
4365    String,
4366}
4367
4368#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4369#[serde(rename_all = "camelCase")]
4370pub struct McpElicitationTitledEnumItems {
4371    #[serde(rename = "anyOf", default)]
4372    pub any_of: Vec<McpElicitationConstOption>,
4373}
4374
4375#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4376#[serde(rename_all = "camelCase")]
4377pub struct McpElicitationTitledMultiSelectEnumSchema {
4378    #[serde(default, skip_serializing_if = "Option::is_none")]
4379    pub default: Option<Vec<String>>,
4380    #[serde(default, skip_serializing_if = "Option::is_none")]
4381    pub description: Option<String>,
4382    #[serde()]
4383    pub items: McpElicitationTitledEnumItems,
4384    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4385    pub max_items: Option<i64>,
4386    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4387    pub min_items: Option<i64>,
4388    #[serde(default, skip_serializing_if = "Option::is_none")]
4389    pub title: Option<String>,
4390    #[serde(rename = "type")]
4391    pub type_: McpElicitationArrayType,
4392}
4393
4394#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4395#[serde(rename_all = "camelCase")]
4396pub struct McpElicitationTitledSingleSelectEnumSchema {
4397    #[serde(default, skip_serializing_if = "Option::is_none")]
4398    pub default: Option<String>,
4399    #[serde(default, skip_serializing_if = "Option::is_none")]
4400    pub description: Option<String>,
4401    #[serde(rename = "oneOf", default)]
4402    pub one_of: Vec<McpElicitationConstOption>,
4403    #[serde(default, skip_serializing_if = "Option::is_none")]
4404    pub title: Option<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 McpElicitationUntitledEnumItems {
4412    #[serde(rename = "enum", default)]
4413    pub enum_: Vec<String>,
4414    #[serde(rename = "type")]
4415    pub type_: McpElicitationStringType,
4416}
4417
4418#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4419#[serde(rename_all = "camelCase")]
4420pub struct McpElicitationUntitledMultiSelectEnumSchema {
4421    #[serde(default, skip_serializing_if = "Option::is_none")]
4422    pub default: Option<Vec<String>>,
4423    #[serde(default, skip_serializing_if = "Option::is_none")]
4424    pub description: Option<String>,
4425    #[serde()]
4426    pub items: McpElicitationUntitledEnumItems,
4427    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4428    pub max_items: Option<i64>,
4429    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4430    pub min_items: Option<i64>,
4431    #[serde(default, skip_serializing_if = "Option::is_none")]
4432    pub title: Option<String>,
4433    #[serde(rename = "type")]
4434    pub type_: McpElicitationArrayType,
4435}
4436
4437#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4438#[serde(rename_all = "camelCase")]
4439pub struct McpElicitationUntitledSingleSelectEnumSchema {
4440    #[serde(default, skip_serializing_if = "Option::is_none")]
4441    pub default: Option<String>,
4442    #[serde(default, skip_serializing_if = "Option::is_none")]
4443    pub description: Option<String>,
4444    #[serde(rename = "enum", default)]
4445    pub enum_: Vec<String>,
4446    #[serde(default, skip_serializing_if = "Option::is_none")]
4447    pub title: Option<String>,
4448    #[serde(rename = "type")]
4449    pub type_: McpElicitationStringType,
4450}
4451
4452#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4453#[serde(rename_all = "camelCase")]
4454pub struct McpResourceReadParams {
4455    /// Additional MCP request metadata. Account and turn routing keys are reserved.
4456    #[serde(rename = "_meta", default, skip_serializing_if = "Option::is_none")]
4457    pub meta: Option<serde_json::Map<String, Value>>,
4458    #[serde(
4459        rename = "connectorId",
4460        default,
4461        skip_serializing_if = "Option::is_none"
4462    )]
4463    pub connector_id: Option<String>,
4464    /// Exact registration scope; omission preserves legacy name-only selection.
4465    #[serde(
4466        rename = "environmentId",
4467        default,
4468        skip_serializing_if = "Option::is_none"
4469    )]
4470    pub environment_id: Option<String>,
4471    /// Originating MCP tool call used to select the resource's app.
4472    #[serde(
4473        rename = "originCallId",
4474        default,
4475        skip_serializing_if = "Option::is_none"
4476    )]
4477    pub origin_call_id: Option<String>,
4478    #[serde(default)]
4479    pub server: String,
4480    /// Explicit hosted app/account. Omit to retain legacy resource discovery.
4481    #[serde(default, skip_serializing_if = "Option::is_none")]
4482    pub target: Option<McpResourceReadTarget>,
4483    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4484    pub thread_id: Option<String>,
4485    #[serde(default)]
4486    pub uri: String,
4487}
4488
4489/// Explicit hosted app/account selector for `mcpServer/resource/read`.
4490#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4491#[serde(rename_all = "camelCase")]
4492pub struct McpResourceReadTarget {
4493    #[serde(rename = "connectorId", default)]
4494    pub connector_id: String,
4495    /// Null explicitly requests no-auth access, subject to the app's resource
4496    /// policy. Always serialized (the wire field is required but nullable).
4497    #[serde(rename = "linkId", default)]
4498    pub link_id: Option<String>,
4499}
4500
4501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4502#[serde(rename_all = "camelCase")]
4503pub struct McpResourceReadResponse {
4504    #[serde(default)]
4505    pub contents: Vec<ResourceContent>,
4506    /// Originating call when the server applied app-specific resource
4507    /// scoping.
4508    #[serde(
4509        rename = "originCallId",
4510        default,
4511        skip_serializing_if = "Option::is_none"
4512    )]
4513    pub origin_call_id: Option<String>,
4514}
4515
4516#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4517pub enum McpServerElicitationAction {
4518    #[serde(rename = "accept")]
4519    Accept,
4520    #[serde(rename = "decline")]
4521    Decline,
4522    #[serde(rename = "cancel")]
4523    Cancel,
4524}
4525
4526#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4527#[serde(tag = "mode", rename_all = "camelCase")]
4528pub enum McpServerElicitationRequestParams {
4529    Form {
4530        #[serde(default, skip_serializing_if = "Option::is_none")]
4531        _meta: Option<Value>,
4532        message: String,
4533        #[serde(rename = "requestedSchema")]
4534        requested_schema: McpElicitationSchema,
4535    },
4536    #[serde(rename = "openai/form")]
4537    OpenaiForm {
4538        #[serde(default, skip_serializing_if = "Option::is_none")]
4539        _meta: Option<Value>,
4540        message: String,
4541        #[serde(rename = "requestedSchema")]
4542        requested_schema: Value,
4543    },
4544    #[serde(rename = "openaiForm")]
4545    OpenAiElicitationForm {
4546        #[serde(default, skip_serializing_if = "Option::is_none")]
4547        _meta: Option<Value>,
4548        message: String,
4549        #[serde(rename = "requestedSchema")]
4550        requested_schema: Value,
4551    },
4552    Url {
4553        #[serde(default, skip_serializing_if = "Option::is_none")]
4554        _meta: Option<Value>,
4555        #[serde(rename = "elicitationId")]
4556        elicitation_id: String,
4557        message: String,
4558        url: String,
4559    },
4560}
4561
4562#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4563#[serde(rename_all = "camelCase")]
4564pub struct McpServerElicitationRequestResponse {
4565    #[serde(default, skip_serializing_if = "Option::is_none")]
4566    pub _meta: Option<Value>,
4567    #[serde()]
4568    pub action: McpServerElicitationAction,
4569    #[serde(default, skip_serializing_if = "Option::is_none")]
4570    pub content: Option<Value>,
4571}
4572
4573#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4574#[serde(rename_all = "camelCase")]
4575pub struct McpServerInfo {
4576    #[serde(default, skip_serializing_if = "Option::is_none")]
4577    pub description: Option<String>,
4578    #[serde(default, skip_serializing_if = "Option::is_none")]
4579    pub icons: Option<Vec<Value>>,
4580    #[serde(default)]
4581    pub name: String,
4582    #[serde(default, skip_serializing_if = "Option::is_none")]
4583    pub title: Option<String>,
4584    #[serde(default)]
4585    pub version: String,
4586    #[serde(
4587        rename = "websiteUrl",
4588        default,
4589        skip_serializing_if = "Option::is_none"
4590    )]
4591    pub website_url: Option<String>,
4592}
4593
4594#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4595#[serde(rename_all = "camelCase")]
4596pub struct McpServerMigration {
4597    #[serde(default)]
4598    pub name: String,
4599}
4600
4601#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4602#[serde(rename_all = "camelCase")]
4603pub struct McpServerOauthLoginCompletedNotification {
4604    #[serde(default, skip_serializing_if = "Option::is_none")]
4605    pub error: Option<String>,
4606    /// Identifies the explicit login attempt. Older servers omit this field.
4607    #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4608    pub login_id: Option<String>,
4609    #[serde(default)]
4610    pub name: String,
4611    #[serde(default)]
4612    pub success: bool,
4613    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4614    pub thread_id: Option<String>,
4615}
4616
4617#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4618#[serde(rename_all = "camelCase")]
4619pub struct McpServerOauthLoginParams {
4620    #[serde(
4621        rename = "clientRegistration",
4622        default,
4623        skip_serializing_if = "Option::is_none"
4624    )]
4625    pub client_registration: Option<McpServerOauthClientRegistration>,
4626    /// Exact registration scope; omission preserves legacy name-only selection.
4627    #[serde(
4628        rename = "environmentId",
4629        default,
4630        skip_serializing_if = "Option::is_none"
4631    )]
4632    pub environment_id: Option<String>,
4633    #[serde(default)]
4634    pub name: String,
4635    #[serde(default, skip_serializing_if = "Option::is_none")]
4636    pub scopes: Option<Vec<String>>,
4637    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4638    pub thread_id: Option<String>,
4639    #[serde(
4640        rename = "timeoutSecs",
4641        default,
4642        skip_serializing_if = "Option::is_none"
4643    )]
4644    pub timeout_secs: Option<i64>,
4645}
4646
4647#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4648#[serde(rename_all = "camelCase")]
4649pub struct McpServerOauthLoginResponse {
4650    #[serde(rename = "authorizationUrl", default)]
4651    pub authorization_url: String,
4652    /// Identifies this login attempt across the response and completion
4653    /// notification. Older servers omit this field; current servers always
4654    /// return it.
4655    #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4656    pub login_id: Option<String>,
4657}
4658
4659#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4660#[serde(rename_all = "camelCase")]
4661pub struct McpServerRefreshResponse {
4662    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4663    pub extra: serde_json::Map<String, Value>,
4664}
4665
4666#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4667pub enum McpServerStartupFailureReason {
4668    #[serde(rename = "reauthenticationRequired")]
4669    ReauthenticationRequired,
4670}
4671
4672#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4673pub enum McpServerStartupState {
4674    #[serde(rename = "starting")]
4675    Starting,
4676    #[serde(rename = "ready")]
4677    Ready,
4678    #[serde(rename = "failed")]
4679    Failed,
4680    #[serde(rename = "cancelled")]
4681    Cancelled,
4682}
4683
4684#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4685#[serde(rename_all = "camelCase")]
4686pub struct McpServerStatus {
4687    #[serde(rename = "authStatus")]
4688    pub auth_status: McpAuthStatus,
4689    /// Environment that contributed this registration; `None` for a
4690    /// thread-wide server. Older servers omit this field.
4691    #[serde(
4692        rename = "environmentId",
4693        default,
4694        skip_serializing_if = "Option::is_none"
4695    )]
4696    pub environment_id: Option<String>,
4697    /// HTTP origin of the effective configured endpoint, including plugin
4698    /// servers. Excludes credentials, path, query, and fragment; `None` for
4699    /// non-HTTP transports.
4700    #[serde(
4701        rename = "httpOrigin",
4702        default,
4703        skip_serializing_if = "Option::is_none"
4704    )]
4705    pub http_origin: Option<String>,
4706    /// Current thread-runtime connection state; absent when unavailable.
4707    #[serde(
4708        rename = "runtimeStatus",
4709        default,
4710        skip_serializing_if = "Option::is_none"
4711    )]
4712    pub runtime_status: Option<McpServerConnectionStatus>,
4713    #[serde(default)]
4714    pub name: String,
4715    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
4716    pub plugin_id: Option<String>,
4717    #[serde(rename = "resourceTemplates", default)]
4718    pub resource_templates: Vec<ResourceTemplate>,
4719    #[serde(default)]
4720    pub resources: Vec<Resource>,
4721    /// Capabilities advertised by the initialized MCP server; `None` when
4722    /// unavailable.
4723    #[serde(
4724        rename = "serverCapabilities",
4725        default,
4726        skip_serializing_if = "Option::is_none"
4727    )]
4728    pub server_capabilities: Option<Value>,
4729    #[serde(
4730        rename = "serverInfo",
4731        default,
4732        skip_serializing_if = "Option::is_none"
4733    )]
4734    pub server_info: Option<McpServerInfo>,
4735    /// Opaque `_meta` from the first page of the corresponding MCP tool
4736    /// catalog; `None` when unavailable.
4737    #[serde(
4738        rename = "toolListMeta",
4739        default,
4740        skip_serializing_if = "Option::is_none"
4741    )]
4742    pub tool_list_meta: Option<Value>,
4743    #[serde(default)]
4744    pub tools: std::collections::BTreeMap<String, Tool>,
4745    /// Tool discovery failed and no catalog was returned. `None` when a
4746    /// catalog is returned, including cached or empty catalogs.
4747    #[serde(
4748        rename = "toolsError",
4749        default,
4750        skip_serializing_if = "Option::is_none"
4751    )]
4752    pub tools_error: Option<String>,
4753}
4754
4755#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4756pub enum McpServerStatusDetail {
4757    #[serde(rename = "full")]
4758    Full,
4759    #[serde(rename = "toolsAndAuthOnly")]
4760    ToolsAndAuthOnly,
4761}
4762
4763#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4764#[serde(rename_all = "camelCase")]
4765pub struct McpServerStatusUpdatedNotification {
4766    /// Registration scope, not necessarily the server's execution environment.
4767    #[serde(
4768        rename = "environmentId",
4769        default,
4770        skip_serializing_if = "Option::is_none"
4771    )]
4772    pub environment_id: Option<String>,
4773    #[serde(default, skip_serializing_if = "Option::is_none")]
4774    pub error: Option<String>,
4775    #[serde(
4776        rename = "failureReason",
4777        default,
4778        skip_serializing_if = "Option::is_none"
4779    )]
4780    pub failure_reason: Option<McpServerStartupFailureReason>,
4781    #[serde(default)]
4782    pub name: String,
4783    #[serde()]
4784    pub status: McpServerStartupState,
4785    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4786    pub thread_id: Option<String>,
4787}
4788
4789#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4790#[serde(rename_all = "camelCase")]
4791pub struct McpServerToolCallParams {
4792    #[serde(default, skip_serializing_if = "Option::is_none")]
4793    pub _meta: Option<Value>,
4794    #[serde(default, skip_serializing_if = "Option::is_none")]
4795    pub arguments: Option<Value>,
4796    /// Exact registration scope; omission preserves legacy name-only selection.
4797    #[serde(
4798        rename = "environmentId",
4799        default,
4800        skip_serializing_if = "Option::is_none"
4801    )]
4802    pub environment_id: Option<String>,
4803    #[serde(default)]
4804    pub server: String,
4805    #[serde(rename = "threadId", default)]
4806    pub thread_id: String,
4807    #[serde(default)]
4808    pub tool: String,
4809}
4810
4811#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4812#[serde(rename_all = "camelCase")]
4813pub struct McpServerToolCallResponse {
4814    #[serde(default, skip_serializing_if = "Option::is_none")]
4815    pub _meta: Option<Value>,
4816    #[serde(default)]
4817    pub content: Vec<Value>,
4818    #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
4819    pub is_error: Option<bool>,
4820    #[serde(
4821        rename = "structuredContent",
4822        default,
4823        skip_serializing_if = "Option::is_none"
4824    )]
4825    pub structured_content: Option<Value>,
4826}
4827
4828/// UI resource and display preference for model invocations, captured from
4829/// the tool descriptor (`ThreadItemPayload::McpToolCall::mcp_app_ui`).
4830#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
4831#[serde(rename_all = "camelCase")]
4832pub struct McpAppUi {
4833    #[serde(rename = "resourceUri")]
4834    pub resource_uri: String,
4835    #[serde(rename = "preferredModelDisplayMode")]
4836    pub preferred_model_display_mode: McpAppDisplayMode,
4837}
4838
4839#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4840pub enum McpAppDisplayMode {
4841    #[serde(rename = "inline")]
4842    Inline,
4843    #[serde(rename = "fullscreen")]
4844    Fullscreen,
4845}
4846
4847#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4848#[serde(rename_all = "camelCase")]
4849pub struct McpToolCallAppContext {
4850    #[serde(
4851        rename = "actionName",
4852        default,
4853        skip_serializing_if = "Option::is_none"
4854    )]
4855    pub action_name: Option<String>,
4856    #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
4857    pub app_name: Option<String>,
4858    #[serde(rename = "connectorId", default)]
4859    pub connector_id: String,
4860    #[serde(rename = "linkId", default, skip_serializing_if = "Option::is_none")]
4861    pub link_id: Option<String>,
4862    #[serde(
4863        rename = "resourceUri",
4864        default,
4865        skip_serializing_if = "Option::is_none"
4866    )]
4867    pub resource_uri: Option<String>,
4868}
4869
4870#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4871#[serde(rename_all = "camelCase")]
4872pub struct McpToolCallError {
4873    #[serde(default)]
4874    pub message: String,
4875}
4876
4877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4878#[serde(rename_all = "camelCase")]
4879pub struct McpToolCallProgressNotification {
4880    #[serde(rename = "itemId", default)]
4881    pub item_id: String,
4882    #[serde(default)]
4883    pub message: String,
4884    #[serde(rename = "threadId", default)]
4885    pub thread_id: String,
4886    #[serde(rename = "turnId", default)]
4887    pub turn_id: String,
4888}
4889
4890#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4891#[serde(rename_all = "camelCase")]
4892pub struct McpToolCallResult {
4893    #[serde(default, skip_serializing_if = "Option::is_none")]
4894    pub _meta: Option<Value>,
4895    #[serde(default)]
4896    pub content: Vec<Value>,
4897    #[serde(
4898        rename = "structuredContent",
4899        default,
4900        skip_serializing_if = "Option::is_none"
4901    )]
4902    pub structured_content: Option<Value>,
4903}
4904
4905#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4906pub enum McpToolCallStatus {
4907    #[serde(rename = "inProgress")]
4908    InProgress,
4909    #[serde(rename = "completed")]
4910    Completed,
4911    #[serde(rename = "failed")]
4912    Failed,
4913}
4914
4915#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4916#[serde(rename_all = "camelCase")]
4917pub struct MemoryCitation {
4918    #[serde(default)]
4919    pub entries: Vec<MemoryCitationEntry>,
4920    #[serde(rename = "threadIds", default)]
4921    pub thread_ids: Vec<String>,
4922}
4923
4924#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4925#[serde(rename_all = "camelCase")]
4926pub struct MemoryCitationEntry {
4927    #[serde(rename = "lineEnd", default)]
4928    pub line_end: i64,
4929    #[serde(rename = "lineStart", default)]
4930    pub line_start: i64,
4931    #[serde(default)]
4932    pub note: String,
4933    #[serde(default)]
4934    pub path: String,
4935}
4936
4937#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4938pub enum MergeStrategy {
4939    #[serde(rename = "replace")]
4940    Replace,
4941    #[serde(rename = "upsert")]
4942    Upsert,
4943}
4944
4945#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4946pub enum MessagePhase {
4947    #[serde(rename = "commentary")]
4948    Commentary,
4949    /// Stable answer text that may be followed by more assistant output or
4950    /// tools (openai/codex#51241).
4951    #[serde(rename = "partial_answer")]
4952    PartialAnswer,
4953    #[serde(rename = "final_answer")]
4954    FinalAnswer,
4955}
4956
4957#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4958#[serde(rename_all = "camelCase")]
4959pub struct MigrationDetails {
4960    #[serde(default, skip_serializing_if = "Option::is_none")]
4961    pub commands: Option<Vec<CommandMigration>>,
4962    #[serde(default, skip_serializing_if = "Option::is_none")]
4963    pub hooks: Option<Vec<HookMigration>>,
4964    #[serde(
4965        rename = "mcpServers",
4966        default,
4967        skip_serializing_if = "Option::is_none"
4968    )]
4969    pub mcp_servers: Option<Vec<McpServerMigration>>,
4970    #[serde(default, skip_serializing_if = "Option::is_none")]
4971    pub memory: Option<Vec<String>>,
4972    #[serde(default, skip_serializing_if = "Option::is_none")]
4973    pub plugins: Option<Vec<PluginsMigration>>,
4974    #[serde(default, skip_serializing_if = "Option::is_none")]
4975    pub sessions: Option<Vec<SessionMigration>>,
4976    #[serde(default, skip_serializing_if = "Option::is_none")]
4977    pub skills: Option<Vec<SkillMigration>>,
4978    #[serde(default, skip_serializing_if = "Option::is_none")]
4979    pub subagents: Option<Vec<SubagentMigration>>,
4980}
4981
4982/// Public explanation and continuation instruction attached to a
4983/// misalignment-blocked turn error (0.148 upstream).
4984#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4985#[serde(rename_all = "camelCase")]
4986pub struct MisalignmentErrorDetails {
4987    #[serde(
4988        rename = "detailedExplanation",
4989        default,
4990        skip_serializing_if = "Option::is_none"
4991    )]
4992    pub detailed_explanation: Option<String>,
4993    /// Open-ended classification; accept categories added upstream.
4994    #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
4995    pub error_type: Option<String>,
4996    /// Opaque server-issued block target. Presence alone does not enable
4997    /// target-based continuation (openai/codex#51217).
4998    #[serde(
4999        rename = "reviewTarget",
5000        default,
5001        skip_serializing_if = "Option::is_none"
5002    )]
5003    pub review_target: Option<String>,
5004    /// Instruction to submit as the next turn's user input if continuation
5005    /// is confirmed.
5006    #[serde(default, skip_serializing_if = "Option::is_none")]
5007    pub steer: Option<MisalignmentSteer>,
5008}
5009
5010/// The steering instruction inside [`MisalignmentErrorDetails`].
5011#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5012#[serde(rename_all = "camelCase")]
5013pub struct MisalignmentSteer {
5014    #[serde(default)]
5015    pub message: String,
5016}
5017
5018#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5019pub enum ModeKind {
5020    #[serde(rename = "plan")]
5021    Plan,
5022    #[serde(rename = "default")]
5023    Default,
5024}
5025
5026#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5027#[serde(rename_all = "camelCase")]
5028pub struct Model {
5029    #[serde(
5030        rename = "additionalSpeedTiers",
5031        default,
5032        skip_serializing_if = "Option::is_none"
5033    )]
5034    pub additional_speed_tiers: Option<Vec<String>>,
5035    #[serde(
5036        rename = "availabilityNux",
5037        default,
5038        skip_serializing_if = "Option::is_none"
5039    )]
5040    pub availability_nux: Option<ModelAvailabilityNux>,
5041    /// `None` when the catalog does not provide access-program metadata.
5042    #[serde(
5043        rename = "availableAccessPrograms",
5044        default,
5045        skip_serializing_if = "Option::is_none"
5046    )]
5047    pub available_access_programs: Option<ModelAccessPrograms>,
5048    #[serde(rename = "defaultReasoningEffort")]
5049    pub default_reasoning_effort: ReasoningEffort,
5050    #[serde(
5051        rename = "defaultServiceTier",
5052        default,
5053        skip_serializing_if = "Option::is_none"
5054    )]
5055    pub default_service_tier: Option<String>,
5056    #[serde(default)]
5057    pub description: String,
5058    #[serde(rename = "displayName", default)]
5059    pub display_name: String,
5060    #[serde(default)]
5061    pub hidden: bool,
5062    #[serde(default)]
5063    pub id: String,
5064    #[serde(
5065        rename = "inputModalities",
5066        default,
5067        skip_serializing_if = "Option::is_none"
5068    )]
5069    pub input_modalities: Option<Vec<InputModality>>,
5070    #[serde(rename = "isDefault", default)]
5071    pub is_default: bool,
5072    #[serde(default)]
5073    pub model: String,
5074    #[serde(
5075        rename = "modelSpecialty",
5076        default,
5077        skip_serializing_if = "Option::is_none"
5078    )]
5079    pub model_specialty: Option<String>,
5080    #[serde(
5081        rename = "multiAgentVersion",
5082        default,
5083        skip_serializing_if = "Option::is_none"
5084    )]
5085    pub multi_agent_version: Option<MultiAgentVersion>,
5086    #[serde(
5087        rename = "serviceTiers",
5088        default,
5089        skip_serializing_if = "Option::is_none"
5090    )]
5091    pub service_tiers: Option<Vec<ModelServiceTier>>,
5092    #[serde(rename = "supportedReasoningEfforts", default)]
5093    pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
5094    /// Deprecated upstream: always `false`; models no longer support
5095    /// personality selection.
5096    #[serde(
5097        rename = "supportsPersonality",
5098        default,
5099        skip_serializing_if = "Option::is_none"
5100    )]
5101    pub supports_personality: Option<bool>,
5102    #[serde(default, skip_serializing_if = "Option::is_none")]
5103    pub upgrade: Option<String>,
5104    #[serde(
5105        rename = "upgradeInfo",
5106        default,
5107        skip_serializing_if = "Option::is_none"
5108    )]
5109    pub upgrade_info: Option<ModelUpgradeInfo>,
5110}
5111
5112/// Caller-specific explicit access programs advertised by model discovery.
5113#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5114#[serde(rename_all = "camelCase")]
5115pub struct ModelAccessPrograms {
5116    /// Accepted explicit selections.
5117    #[serde(default)]
5118    pub cyber: Vec<CyberAccessProgram>,
5119}
5120
5121#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5122#[serde(rename_all = "camelCase")]
5123pub struct ModelAvailabilityNux {
5124    #[serde(default)]
5125    pub message: String,
5126}
5127
5128#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5129#[serde(rename_all = "camelCase")]
5130pub struct ModelListParams {
5131    #[serde(default, skip_serializing_if = "Option::is_none")]
5132    pub cursor: Option<String>,
5133    #[serde(
5134        rename = "includeHidden",
5135        default,
5136        skip_serializing_if = "Option::is_none"
5137    )]
5138    pub include_hidden: Option<bool>,
5139    #[serde(default, skip_serializing_if = "Option::is_none")]
5140    pub limit: Option<i64>,
5141    /// List models for this configured provider instead of the app-server
5142    /// default.
5143    #[serde(
5144        rename = "modelProvider",
5145        default,
5146        skip_serializing_if = "Option::is_none"
5147    )]
5148    pub model_provider: Option<String>,
5149}
5150
5151#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5152#[serde(rename_all = "camelCase")]
5153pub struct ModelListResponse {
5154    #[serde(default)]
5155    pub data: Vec<Model>,
5156    #[serde(
5157        rename = "nextCursor",
5158        default,
5159        skip_serializing_if = "Option::is_none"
5160    )]
5161    pub next_cursor: Option<String>,
5162}
5163
5164#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5165#[serde(rename_all = "camelCase")]
5166pub struct ModelProviderCapabilitiesReadParams {
5167    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5168    pub extra: serde_json::Map<String, Value>,
5169}
5170
5171#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5172#[serde(rename_all = "camelCase")]
5173pub struct ModelProviderCapabilitiesReadResponse {
5174    #[serde(rename = "imageGeneration", default)]
5175    pub image_generation: bool,
5176    #[serde(rename = "webSearch", default)]
5177    pub web_search: bool,
5178}
5179
5180/// Params for `modelProvider/list`. Takes no fields.
5181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5182#[serde(rename_all = "camelCase")]
5183pub struct ModelProviderListParams {
5184    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5185    pub extra: serde_json::Map<String, Value>,
5186}
5187
5188/// Response to `modelProvider/list`: every configured model provider.
5189#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5190#[serde(rename_all = "camelCase")]
5191pub struct ModelProviderListResponse {
5192    pub data: Vec<ModelProviderSummary>,
5193    #[serde(rename = "defaultProviderId")]
5194    pub default_provider_id: String,
5195    #[serde(rename = "canChangeDefault")]
5196    pub can_change_default: bool,
5197}
5198
5199/// One entry in [`ModelProviderListResponse::data`].
5200#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5201#[serde(rename_all = "camelCase")]
5202pub struct ModelProviderSummary {
5203    pub id: String,
5204    pub name: String,
5205    /// Whether a supported configuration field can be edited in the active user layer.
5206    #[serde(rename = "canEdit")]
5207    pub can_edit: bool,
5208    /// Null when the endpoint is absent or cannot be safely displayed.
5209    #[serde(rename = "baseUrl", default)]
5210    pub base_url: Option<String>,
5211    pub settings: ProviderSettings,
5212}
5213
5214/// Provider-specific configuration fields visible to clients.
5215#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5216#[serde(tag = "type", rename_all = "camelCase")]
5217pub enum ProviderSettings {
5218    #[serde(rename = "openai")]
5219    OpenAi,
5220    #[serde(rename = "customGateway")]
5221    CustomGateway { auth: GatewayAuth },
5222    #[serde(rename = "bedrock")]
5223    Bedrock {
5224        #[serde(default)]
5225        profile: Option<String>,
5226        #[serde(default)]
5227        region: Option<String>,
5228    },
5229    #[serde(rename = "gcp")]
5230    Gcp {
5231        #[serde(rename = "projectId", default)]
5232        project_id: Option<String>,
5233        #[serde(default)]
5234        location: Option<String>,
5235        /// Path on the app-server host, without credential-file contents.
5236        #[serde(rename = "credentialFile", default)]
5237        credential_file: Option<String>,
5238    },
5239}
5240
5241/// How a custom gateway provider authenticates.
5242#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5243#[serde(tag = "mode", rename_all = "camelCase")]
5244pub enum GatewayAuth {
5245    #[serde(rename = "none")]
5246    None,
5247    #[serde(rename = "environmentVariable")]
5248    EnvironmentVariable {
5249        #[serde(rename = "envKey")]
5250        env_key: String,
5251    },
5252    /// Authentication is configured outside the gateway form. Preserve it on edits.
5253    #[serde(rename = "externallyConfigured")]
5254    ExternallyConfigured {
5255        #[serde(rename = "envKey", default)]
5256        env_key: Option<String>,
5257    },
5258}
5259
5260/// Params for `modelProvider/config/write`.
5261#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5262#[serde(rename_all = "camelCase")]
5263pub struct ModelProviderConfigWriteParams {
5264    pub settings: ProviderSettingsPatch,
5265}
5266
5267/// Params for `modelProvider/default/set`; the response is a
5268/// [`ConfigWriteResponse`].
5269#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5270#[serde(rename_all = "camelCase")]
5271pub struct ModelProviderDefaultSetParams {
5272    /// Configured provider to use by default for new threads and unscoped
5273    /// model lists.
5274    pub provider_id: String,
5275}
5276
5277/// Response to `modelProvider/config/write`: the provider as written.
5278#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5279#[serde(rename_all = "camelCase")]
5280pub struct ModelProviderConfigWriteResponse {
5281    pub provider: ModelProviderSummary,
5282}
5283
5284/// Omitted patch fields preserve their values. Explicit null clears a nullable field.
5285///
5286/// Nullable patch fields are `Option<Option<String>>`: `None` omits the field
5287/// (preserve), `Some(None)` sends `null` (clear), `Some(Some(v))` sets it.
5288#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5289#[serde(tag = "type", rename_all = "camelCase")]
5290pub enum ProviderSettingsPatch {
5291    #[serde(rename = "customGateway")]
5292    CustomGateway {
5293        /// Omit or pass null to allocate a new custom provider ID.
5294        #[serde(
5295            rename = "providerId",
5296            default,
5297            skip_serializing_if = "Option::is_none"
5298        )]
5299        provider_id: Option<String>,
5300        /// Omit to preserve the name. Unlike the other fields it cannot be cleared.
5301        #[serde(
5302            default,
5303            deserialize_with = "deserialize_patch_name",
5304            skip_serializing_if = "Option::is_none"
5305        )]
5306        name: Option<String>,
5307        #[serde(
5308            rename = "baseUrl",
5309            default,
5310            deserialize_with = "deserialize_patch_field",
5311            skip_serializing_if = "Option::is_none"
5312        )]
5313        base_url: Option<Option<String>>,
5314        #[serde(
5315            rename = "envKey",
5316            default,
5317            deserialize_with = "deserialize_patch_field",
5318            skip_serializing_if = "Option::is_none"
5319        )]
5320        env_key: Option<Option<String>>,
5321    },
5322    /// AWS configuration fields for built-in Bedrock providers.
5323    #[serde(rename = "bedrock")]
5324    Bedrock {
5325        #[serde(rename = "providerId")]
5326        provider_id: BedrockProviderId,
5327        #[serde(
5328            default,
5329            deserialize_with = "deserialize_patch_field",
5330            skip_serializing_if = "Option::is_none"
5331        )]
5332        profile: Option<Option<String>>,
5333        #[serde(
5334            default,
5335            deserialize_with = "deserialize_patch_field",
5336            skip_serializing_if = "Option::is_none"
5337        )]
5338        region: Option<Option<String>>,
5339    },
5340    /// GCP configuration fields. Credential-file paths refer to the app-server host.
5341    #[serde(rename = "gcp")]
5342    Gcp {
5343        #[serde(rename = "providerId")]
5344        provider_id: GcpProviderId,
5345        #[serde(
5346            rename = "projectId",
5347            default,
5348            deserialize_with = "deserialize_patch_field",
5349            skip_serializing_if = "Option::is_none"
5350        )]
5351        project_id: Option<Option<String>>,
5352        #[serde(
5353            default,
5354            deserialize_with = "deserialize_patch_field",
5355            skip_serializing_if = "Option::is_none"
5356        )]
5357        location: Option<Option<String>>,
5358        #[serde(
5359            rename = "credentialFile",
5360            default,
5361            deserialize_with = "deserialize_patch_field",
5362            skip_serializing_if = "Option::is_none"
5363        )]
5364        credential_file: Option<Option<String>>,
5365    },
5366}
5367
5368/// A present field (even `null`) becomes `Some`; a missing one falls back to `None` via `default`.
5369fn deserialize_patch_field<'de, D>(deserializer: D) -> Result<Option<Option<String>>, D::Error>
5370where
5371    D: serde::Deserializer<'de>,
5372{
5373    Option::<String>::deserialize(deserializer).map(Some)
5374}
5375
5376/// A missing name preserves it, but an explicitly supplied name must be a string.
5377fn deserialize_patch_name<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
5378where
5379    D: serde::Deserializer<'de>,
5380{
5381    String::deserialize(deserializer).map(Some)
5382}
5383
5384/// Built-in Bedrock provider IDs accepted by [`ProviderSettingsPatch::Bedrock`].
5385#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
5386pub enum BedrockProviderId {
5387    #[serde(rename = "amazon-bedrock")]
5388    AmazonBedrock,
5389    #[serde(rename = "amazon-bedrock-runtime")]
5390    AmazonBedrockRuntime,
5391}
5392
5393/// Built-in GCP provider IDs accepted by [`ProviderSettingsPatch::Gcp`].
5394#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
5395pub enum GcpProviderId {
5396    #[serde(rename = "gcp")]
5397    Gcp,
5398}
5399
5400/// Structured JSON-RPC error data. Unknown errors must retain the client's normal fallback.
5401///
5402/// Carried in [`crate::JsonRpcErrorData::data`] when a thread's stored model
5403/// provider can't be used for resume or new input.
5404#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5405#[serde(tag = "type", rename_all = "camelCase")]
5406pub enum ModelProviderError {
5407    #[serde(rename = "modelProviderMismatch")]
5408    ModelProviderMismatch {
5409        #[serde(rename = "modelProvider")]
5410        model_provider: String,
5411        #[serde(rename = "currentModelProvider")]
5412        current_model_provider: String,
5413    },
5414    #[serde(rename = "modelProviderNotConfigured")]
5415    ModelProviderNotConfigured {
5416        #[serde(rename = "modelProvider")]
5417        model_provider: String,
5418    },
5419    #[serde(rename = "modelProviderPolicyConflict")]
5420    ModelProviderPolicyConflict {
5421        #[serde(rename = "modelProvider")]
5422        model_provider: String,
5423        #[serde(rename = "requiredModelProvider")]
5424        required_model_provider: String,
5425    },
5426}
5427
5428#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5429pub enum ModelRerouteReason {
5430    #[serde(rename = "highRiskCyberActivity")]
5431    HighRiskCyberActivity,
5432}
5433
5434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5435#[serde(rename_all = "camelCase")]
5436pub struct ModelReroutedNotification {
5437    #[serde(rename = "fromModel", default)]
5438    pub from_model: String,
5439    #[serde()]
5440    pub reason: ModelRerouteReason,
5441    #[serde(rename = "threadId", default)]
5442    pub thread_id: String,
5443    #[serde(rename = "toModel", default)]
5444    pub to_model: String,
5445    #[serde(rename = "turnId", default)]
5446    pub turn_id: String,
5447}
5448
5449#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5450#[serde(rename_all = "camelCase")]
5451pub struct ModelSafetyBufferingUpdatedNotification {
5452    #[serde(
5453        rename = "fasterModel",
5454        default,
5455        skip_serializing_if = "Option::is_none"
5456    )]
5457    pub faster_model: Option<String>,
5458    #[serde(default)]
5459    pub model: String,
5460    #[serde(default)]
5461    pub reasons: Vec<String>,
5462    #[serde(rename = "showBufferingUi", default)]
5463    pub show_buffering_ui: bool,
5464    #[serde(rename = "threadId", default)]
5465    pub thread_id: String,
5466    #[serde(rename = "turnId", default)]
5467    pub turn_id: String,
5468    #[serde(rename = "useCases", default)]
5469    pub use_cases: Vec<String>,
5470}
5471
5472#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5473#[serde(rename_all = "camelCase")]
5474pub struct ModelServiceTier {
5475    #[serde(default)]
5476    pub description: String,
5477    #[serde(default)]
5478    pub id: String,
5479    #[serde(default)]
5480    pub name: String,
5481}
5482
5483#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5484#[serde(rename_all = "camelCase")]
5485pub struct ModelUpgradeInfo {
5486    #[serde(
5487        rename = "migrationMarkdown",
5488        default,
5489        skip_serializing_if = "Option::is_none"
5490    )]
5491    pub migration_markdown: Option<String>,
5492    #[serde(default)]
5493    pub model: String,
5494    /// Informational Unix timestamp for this upgrade's scheduled
5495    /// retirement, if known.
5496    #[serde(
5497        rename = "retirementAt",
5498        default,
5499        skip_serializing_if = "Option::is_none"
5500    )]
5501    pub retirement_at: Option<i64>,
5502    #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
5503    pub model_link: Option<String>,
5504    #[serde(
5505        rename = "upgradeCopy",
5506        default,
5507        skip_serializing_if = "Option::is_none"
5508    )]
5509    pub upgrade_copy: Option<String>,
5510}
5511
5512#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5513pub enum ModelVerification {
5514    #[serde(rename = "trustedAccessForCyber")]
5515    TrustedAccessForCyber,
5516}
5517
5518#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5519#[serde(rename_all = "camelCase")]
5520pub struct ModelVerificationNotification {
5521    #[serde(rename = "threadId", default)]
5522    pub thread_id: String,
5523    #[serde(rename = "turnId", default)]
5524    pub turn_id: String,
5525    #[serde(default)]
5526    pub verifications: Vec<ModelVerification>,
5527}
5528
5529#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5530#[serde(rename_all = "camelCase")]
5531pub struct ModelsRequirements {
5532    #[serde(rename = "newThread", default, skip_serializing_if = "Option::is_none")]
5533    pub new_thread: Option<NewThreadModelDefaults>,
5534}
5535
5536#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5537pub enum MultiAgentVersion {
5538    #[serde(rename = "disabled")]
5539    Disabled,
5540    #[serde(rename = "v1")]
5541    V1,
5542    #[serde(rename = "v2")]
5543    V2,
5544}
5545
5546#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5547pub enum NetworkAccess {
5548    #[serde(rename = "restricted")]
5549    Restricted,
5550    #[serde(rename = "enabled")]
5551    Enabled,
5552}
5553
5554#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5555#[serde(rename_all = "camelCase")]
5556pub struct NetworkApprovalContext {
5557    #[serde(default)]
5558    pub host: String,
5559    #[serde()]
5560    pub protocol: NetworkApprovalProtocol,
5561}
5562
5563#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5564pub enum NetworkApprovalProtocol {
5565    #[serde(rename = "http")]
5566    Http,
5567    #[serde(rename = "https")]
5568    Https,
5569    #[serde(rename = "socks5Tcp")]
5570    Socks5Tcp,
5571    #[serde(rename = "socks5Udp")]
5572    Socks5Udp,
5573}
5574
5575#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5576#[serde(rename_all = "camelCase")]
5577pub struct NetworkPolicyAmendment {
5578    #[serde()]
5579    pub action: NetworkPolicyRuleAction,
5580    #[serde(default)]
5581    pub host: String,
5582}
5583
5584#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5585pub enum NetworkPolicyRuleAction {
5586    #[serde(rename = "allow")]
5587    Allow,
5588    #[serde(rename = "deny")]
5589    Deny,
5590}
5591
5592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5593#[serde(rename_all = "camelCase")]
5594pub struct NewThreadModelDefaults {
5595    #[serde(default, skip_serializing_if = "Option::is_none")]
5596    pub model: Option<String>,
5597    #[serde(
5598        rename = "modelReasoningEffort",
5599        default,
5600        skip_serializing_if = "Option::is_none"
5601    )]
5602    pub model_reasoning_effort: Option<ReasoningEffort>,
5603    #[serde(
5604        rename = "serviceTier",
5605        default,
5606        skip_serializing_if = "Option::is_none"
5607    )]
5608    pub service_tier: Option<String>,
5609}
5610
5611#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5612pub enum NonSteerableTurnKind {
5613    #[serde(rename = "review")]
5614    Review,
5615    #[serde(rename = "compact")]
5616    Compact,
5617}
5618
5619/// An OpenTelemetry exporter pinned by managed requirements.
5620#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5621#[serde(rename_all = "kebab-case")]
5622pub enum OtelExporter {
5623    None,
5624    Statsig,
5625    OtlpHttp {
5626        endpoint: String,
5627        /// Header names are retained; values are redacted by the server.
5628        headers: std::collections::BTreeMap<String, String>,
5629        protocol: OtelHttpProtocol,
5630        #[serde(default, skip_serializing_if = "Option::is_none")]
5631        tls: Option<OtelTlsConfig>,
5632    },
5633    OtlpGrpc {
5634        endpoint: String,
5635        /// Header names are retained; values are redacted by the server.
5636        headers: std::collections::BTreeMap<String, String>,
5637        #[serde(default, skip_serializing_if = "Option::is_none")]
5638        tls: Option<OtelTlsConfig>,
5639    },
5640}
5641
5642#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5643#[serde(rename_all = "kebab-case")]
5644pub enum OtelHttpProtocol {
5645    Binary,
5646    Json,
5647}
5648
5649/// OpenTelemetry settings enforced by managed requirements
5650/// (`ConfigRequirements::otel`). Keys are snake_case on the wire.
5651#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5652#[serde(rename_all = "snake_case")]
5653pub struct OtelRequirements {
5654    /// Absolute path of a managed executable whose output supplies OTLP HTTP
5655    /// export headers. Only honored from local system/MDM requirements, never
5656    /// from cloud requirements.
5657    #[serde(default, skip_serializing_if = "Option::is_none")]
5658    pub headers_helper: Option<String>,
5659    /// How often, in milliseconds, `headers_helper` is re-run to refresh the
5660    /// export headers.
5661    #[serde(default, skip_serializing_if = "Option::is_none")]
5662    pub headers_helper_refresh_interval_ms: Option<std::num::NonZeroU64>,
5663    #[serde(default, skip_serializing_if = "Option::is_none")]
5664    pub tool_result: Option<OtelToolResultLogConfig>,
5665    #[serde(default, skip_serializing_if = "Option::is_none")]
5666    pub log_sse_deltas: Option<bool>,
5667    #[serde(default, skip_serializing_if = "Option::is_none")]
5668    pub log_user_prompt: Option<bool>,
5669    #[serde(default, skip_serializing_if = "Option::is_none")]
5670    pub log_agent_responses: Option<bool>,
5671    #[serde(default, skip_serializing_if = "Option::is_none")]
5672    pub log_guardian_assessments: Option<bool>,
5673    #[serde(default, skip_serializing_if = "Option::is_none")]
5674    pub environment: Option<String>,
5675    #[serde(default, skip_serializing_if = "Option::is_none")]
5676    pub exporter: Option<OtelExporter>,
5677    #[serde(default, skip_serializing_if = "Option::is_none")]
5678    pub trace_exporter: Option<OtelExporter>,
5679    #[serde(default, skip_serializing_if = "Option::is_none")]
5680    pub metrics_exporter: Option<OtelExporter>,
5681    #[serde(default, skip_serializing_if = "Option::is_none")]
5682    pub span_attributes: Option<std::collections::BTreeMap<String, String>>,
5683    #[serde(default, skip_serializing_if = "Option::is_none")]
5684    pub tracestate:
5685        Option<std::collections::BTreeMap<String, std::collections::BTreeMap<String, String>>>,
5686}
5687
5688#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
5689#[serde(rename_all = "kebab-case")]
5690pub struct OtelTlsConfig {
5691    #[serde(default, skip_serializing_if = "Option::is_none")]
5692    pub ca_certificate: Option<String>,
5693    #[serde(default, skip_serializing_if = "Option::is_none")]
5694    pub client_certificate: Option<String>,
5695    #[serde(default, skip_serializing_if = "Option::is_none")]
5696    pub client_private_key: Option<String>,
5697}
5698
5699#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
5700#[serde(rename_all = "snake_case")]
5701pub struct OtelToolResultLogConfig {
5702    pub max_bytes: u64,
5703}
5704
5705#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5706#[serde(rename_all = "camelCase")]
5707pub struct OverriddenMetadata {
5708    #[serde(rename = "effectiveValue", default)]
5709    pub effective_value: Value,
5710    #[serde(default)]
5711    pub message: String,
5712    #[serde(rename = "overridingLayer")]
5713    pub overriding_layer: ConfigLayerMetadata,
5714}
5715
5716#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5717#[serde(tag = "type", rename_all = "camelCase")]
5718pub enum ParsedCommand {
5719    Read {
5720        cmd: String,
5721        name: String,
5722        path: String,
5723    },
5724    List_files {
5725        cmd: String,
5726        #[serde(default, skip_serializing_if = "Option::is_none")]
5727        path: Option<String>,
5728    },
5729    Search {
5730        cmd: String,
5731        #[serde(default, skip_serializing_if = "Option::is_none")]
5732        path: Option<String>,
5733        #[serde(default, skip_serializing_if = "Option::is_none")]
5734        query: Option<String>,
5735    },
5736    Unknown {
5737        cmd: String,
5738    },
5739}
5740
5741#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5742pub enum PatchApplyStatus {
5743    #[serde(rename = "inProgress")]
5744    InProgress,
5745    #[serde(rename = "completed")]
5746    Completed,
5747    #[serde(rename = "failed")]
5748    Failed,
5749    #[serde(rename = "declined")]
5750    Declined,
5751}
5752
5753#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5754#[serde(tag = "type", rename_all = "camelCase")]
5755pub enum PatchChangeKind {
5756    Add,
5757    Delete,
5758    Update {
5759        #[serde(default, skip_serializing_if = "Option::is_none")]
5760        move_path: Option<String>,
5761    },
5762}
5763
5764#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5765pub enum PermissionGrantScope {
5766    #[serde(rename = "turn")]
5767    Turn,
5768    #[serde(rename = "session")]
5769    Session,
5770}
5771
5772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5773#[serde(rename_all = "camelCase")]
5774pub struct PermissionProfileListParams {
5775    #[serde(default, skip_serializing_if = "Option::is_none")]
5776    pub cursor: Option<String>,
5777    #[serde(default, skip_serializing_if = "Option::is_none")]
5778    pub cwd: Option<String>,
5779    #[serde(default, skip_serializing_if = "Option::is_none")]
5780    pub limit: Option<i64>,
5781}
5782
5783#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5784#[serde(rename_all = "camelCase")]
5785pub struct PermissionProfileListResponse {
5786    #[serde(default)]
5787    pub data: Vec<PermissionProfileSummary>,
5788    #[serde(
5789        rename = "nextCursor",
5790        default,
5791        skip_serializing_if = "Option::is_none"
5792    )]
5793    pub next_cursor: Option<String>,
5794}
5795
5796#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5797#[serde(rename_all = "camelCase")]
5798pub struct PermissionProfileSummary {
5799    #[serde(default)]
5800    pub allowed: bool,
5801    #[serde(default, skip_serializing_if = "Option::is_none")]
5802    pub description: Option<String>,
5803    #[serde(default)]
5804    pub id: String,
5805}
5806
5807#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5808#[serde(rename_all = "camelCase")]
5809pub struct PermissionsRequestApprovalParams {
5810    #[serde()]
5811    pub cwd: LegacyAppPathString,
5812    #[serde(
5813        rename = "environmentId",
5814        default,
5815        skip_serializing_if = "Option::is_none"
5816    )]
5817    pub environment_id: Option<String>,
5818    #[serde(rename = "itemId", default)]
5819    pub item_id: String,
5820    #[serde()]
5821    pub permissions: RequestPermissionProfile,
5822    #[serde(default, skip_serializing_if = "Option::is_none")]
5823    pub reason: Option<String>,
5824    #[serde(rename = "startedAtMs", default)]
5825    pub started_at_ms: i64,
5826    #[serde(rename = "threadId", default)]
5827    pub thread_id: String,
5828    #[serde(rename = "turnId", default)]
5829    pub turn_id: String,
5830}
5831
5832#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5833#[serde(rename_all = "camelCase")]
5834pub struct PermissionsRequestApprovalResponse {
5835    #[serde()]
5836    pub permissions: GrantedPermissionProfile,
5837    #[serde(default, skip_serializing_if = "Option::is_none")]
5838    pub scope: Option<Value>,
5839    #[serde(
5840        rename = "strictAutoReview",
5841        default,
5842        skip_serializing_if = "Option::is_none"
5843    )]
5844    pub strict_auto_review: Option<bool>,
5845}
5846
5847/// Deprecated upstream: `friendly` and `pragmatic` no longer select a style,
5848/// and `Model::supports_personality` is now always `false`. The setting is
5849/// still reported and accepted on the wire; changing it on a turn does not
5850/// rewrite the thread's existing instructions.
5851#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5852pub enum Personality {
5853    #[serde(rename = "none")]
5854    None,
5855    #[serde(rename = "friendly")]
5856    Friendly,
5857    #[serde(rename = "pragmatic")]
5858    Pragmatic,
5859}
5860
5861#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5862#[serde(rename_all = "camelCase")]
5863pub struct PlanDeltaNotification {
5864    #[serde(default)]
5865    pub delta: String,
5866    #[serde(rename = "itemId", default)]
5867    pub item_id: String,
5868    #[serde(rename = "threadId", default)]
5869    pub thread_id: String,
5870    #[serde(rename = "turnId", default)]
5871    pub turn_id: String,
5872}
5873
5874#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5875pub enum PlanType {
5876    #[serde(rename = "free")]
5877    Free,
5878    #[serde(rename = "go")]
5879    Go,
5880    #[serde(rename = "plus")]
5881    Plus,
5882    #[serde(rename = "pro")]
5883    Pro,
5884    #[serde(rename = "prolite")]
5885    Prolite,
5886    #[serde(rename = "promax")]
5887    Promax,
5888    #[serde(rename = "edu_plus")]
5889    Edu_plus,
5890    #[serde(rename = "edu_pro")]
5891    Edu_pro,
5892    #[serde(rename = "team")]
5893    Team,
5894    #[serde(rename = "self_serve_business_prolite")]
5895    Self_serve_business_prolite,
5896    #[serde(rename = "self_serve_business_usage_based")]
5897    Self_serve_business_usage_based,
5898    #[serde(rename = "business")]
5899    Business,
5900    #[serde(rename = "ent26")]
5901    Ent26,
5902    #[serde(rename = "enterprise_cbp_automation")]
5903    Enterprise_cbp_automation,
5904    #[serde(rename = "enterprise_cbp_usage_based")]
5905    Enterprise_cbp_usage_based,
5906    #[serde(rename = "enterprise")]
5907    Enterprise,
5908    #[serde(rename = "edu")]
5909    Edu,
5910    #[serde(rename = "sci")]
5911    Sci,
5912    #[serde(rename = "sci_plus")]
5913    Sci_plus,
5914    #[serde(rename = "unknown")]
5915    Unknown,
5916}
5917
5918#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5919pub enum PluginAuthPolicy {
5920    #[serde(rename = "ON_INSTALL")]
5921    ON_INSTALL,
5922    #[serde(rename = "ON_USE")]
5923    ON_USE,
5924}
5925
5926#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5927pub enum PluginAvailability {
5928    #[serde(rename = "DISABLED_BY_ADMIN")]
5929    DISABLEDBYADMIN,
5930    AVAILABLE,
5931}
5932
5933#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5934#[serde(rename_all = "camelCase")]
5935pub struct PluginDetail {
5936    #[serde(rename = "appTemplates", default)]
5937    pub app_templates: Vec<AppTemplateSummary>,
5938    #[serde(default)]
5939    pub apps: Vec<AppSummary>,
5940    #[serde(default, skip_serializing_if = "Option::is_none")]
5941    pub description: Option<String>,
5942    #[serde(default)]
5943    pub hooks: Vec<PluginHookSummary>,
5944    #[serde(rename = "marketplaceName", default)]
5945    pub marketplace_name: String,
5946    #[serde(
5947        rename = "marketplacePath",
5948        default,
5949        skip_serializing_if = "Option::is_none"
5950    )]
5951    pub marketplace_path: Option<AbsolutePathBuf>,
5952    #[serde(rename = "mcpServers", default)]
5953    pub mcp_servers: Vec<String>,
5954    /// The declared onboarding skill, when the plugin and visible skill are enabled.
5955    #[serde(
5956        rename = "onboardingSkill",
5957        default,
5958        skip_serializing_if = "Option::is_none"
5959    )]
5960    pub onboarding_skill: Option<SkillSummary>,
5961    #[serde(
5962        rename = "scheduledTasks",
5963        default,
5964        skip_serializing_if = "Option::is_none"
5965    )]
5966    pub scheduled_tasks: Option<Vec<ScheduledTaskSummary>>,
5967    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5968    pub share_url: Option<String>,
5969    #[serde(default)]
5970    pub skills: Vec<SkillSummary>,
5971    #[serde()]
5972    pub summary: PluginSummary,
5973}
5974
5975#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5976pub enum PluginDisabledReason {
5977    #[serde(rename = "disabled_by_admin")]
5978    Disabled_by_admin,
5979    #[serde(rename = "plan_not_eligible")]
5980    Plan_not_eligible,
5981    #[serde(rename = "required_app_unavailable")]
5982    Required_app_unavailable,
5983    #[serde(rename = "unknown")]
5984    Unknown,
5985}
5986
5987#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5988#[serde(rename_all = "camelCase")]
5989pub struct PluginHookSummary {
5990    #[serde(rename = "eventName")]
5991    pub event_name: HookEventName,
5992    #[serde(default)]
5993    pub key: String,
5994}
5995
5996#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5997#[serde(rename_all = "camelCase")]
5998pub struct PluginInstallParams {
5999    #[serde(
6000        rename = "installAttemptId",
6001        default,
6002        skip_serializing_if = "Option::is_none"
6003    )]
6004    pub install_attempt_id: Option<String>,
6005    #[serde(
6006        rename = "marketplacePath",
6007        default,
6008        skip_serializing_if = "Option::is_none"
6009    )]
6010    pub marketplace_path: Option<AbsolutePathBuf>,
6011    #[serde(rename = "pluginName", default)]
6012    pub plugin_name: String,
6013    #[serde(
6014        rename = "remoteMarketplaceName",
6015        default,
6016        skip_serializing_if = "Option::is_none"
6017    )]
6018    pub remote_marketplace_name: Option<String>,
6019}
6020
6021#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6022pub enum PluginInstallPolicy {
6023    #[serde(rename = "NOT_AVAILABLE")]
6024    NOT_AVAILABLE,
6025    #[serde(rename = "AVAILABLE")]
6026    AVAILABLE,
6027    #[serde(rename = "INSTALLED_BY_DEFAULT")]
6028    INSTALLED_BY_DEFAULT,
6029}
6030
6031#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6032pub enum PluginInstallPolicySource {
6033    #[serde(rename = "WORKSPACE_SETTING")]
6034    WORKSPACE_SETTING,
6035    #[serde(rename = "IMPLICIT_CANONICAL_APP")]
6036    IMPLICIT_CANONICAL_APP,
6037}
6038
6039#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6040#[serde(rename_all = "camelCase")]
6041pub struct PluginInstallResponse {
6042    #[serde(rename = "appsNeedingAuth", default)]
6043    pub apps_needing_auth: Vec<AppSummary>,
6044    #[serde(rename = "authPolicy")]
6045    pub auth_policy: PluginAuthPolicy,
6046}
6047
6048#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6049#[serde(rename_all = "camelCase")]
6050pub struct PluginInstalledParams {
6051    #[serde(default, skip_serializing_if = "Option::is_none")]
6052    pub cwds: Option<Vec<AbsolutePathBuf>>,
6053    #[serde(
6054        rename = "installSuggestionPluginNames",
6055        default,
6056        skip_serializing_if = "Option::is_none"
6057    )]
6058    pub install_suggestion_plugin_names: Option<Vec<String>>,
6059}
6060
6061#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6062#[serde(rename_all = "camelCase")]
6063pub struct PluginInstalledResponse {
6064    #[serde(
6065        rename = "marketplaceLoadErrors",
6066        default,
6067        skip_serializing_if = "Option::is_none"
6068    )]
6069    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
6070    #[serde(default)]
6071    pub marketplaces: Vec<PluginMarketplaceEntry>,
6072}
6073
6074#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6075#[serde(rename_all = "camelCase")]
6076pub struct PluginInterface {
6077    #[serde(
6078        rename = "brandColor",
6079        default,
6080        skip_serializing_if = "Option::is_none"
6081    )]
6082    pub brand_color: Option<String>,
6083    #[serde(default)]
6084    pub capabilities: Vec<String>,
6085    #[serde(default, skip_serializing_if = "Option::is_none")]
6086    pub category: Option<String>,
6087    #[serde(
6088        rename = "composerIcon",
6089        default,
6090        skip_serializing_if = "Option::is_none"
6091    )]
6092    pub composer_icon: Option<AbsolutePathBuf>,
6093    #[serde(
6094        rename = "composerIconUrl",
6095        default,
6096        skip_serializing_if = "Option::is_none"
6097    )]
6098    pub composer_icon_url: Option<String>,
6099    #[serde(
6100        rename = "defaultPrompt",
6101        default,
6102        skip_serializing_if = "Option::is_none"
6103    )]
6104    pub default_prompt: Option<Vec<String>>,
6105    #[serde(
6106        rename = "developerName",
6107        default,
6108        skip_serializing_if = "Option::is_none"
6109    )]
6110    pub developer_name: Option<String>,
6111    #[serde(
6112        rename = "displayName",
6113        default,
6114        skip_serializing_if = "Option::is_none"
6115    )]
6116    pub display_name: Option<String>,
6117    #[serde(default, skip_serializing_if = "Option::is_none")]
6118    pub logo: Option<AbsolutePathBuf>,
6119    #[serde(rename = "logoDark", default, skip_serializing_if = "Option::is_none")]
6120    pub logo_dark: Option<AbsolutePathBuf>,
6121    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
6122    pub logo_url: Option<String>,
6123    #[serde(
6124        rename = "logoUrlDark",
6125        default,
6126        skip_serializing_if = "Option::is_none"
6127    )]
6128    pub logo_url_dark: Option<String>,
6129    #[serde(
6130        rename = "longDescription",
6131        default,
6132        skip_serializing_if = "Option::is_none"
6133    )]
6134    pub long_description: Option<String>,
6135    #[serde(
6136        rename = "privacyPolicyUrl",
6137        default,
6138        skip_serializing_if = "Option::is_none"
6139    )]
6140    pub privacy_policy_url: Option<String>,
6141    #[serde(rename = "screenshotUrls", default)]
6142    pub screenshot_urls: Vec<String>,
6143    #[serde(default)]
6144    pub screenshots: Vec<AbsolutePathBuf>,
6145    #[serde(
6146        rename = "shortDescription",
6147        default,
6148        skip_serializing_if = "Option::is_none"
6149    )]
6150    pub short_description: Option<String>,
6151    #[serde(
6152        rename = "termsOfServiceUrl",
6153        default,
6154        skip_serializing_if = "Option::is_none"
6155    )]
6156    pub terms_of_service_url: Option<String>,
6157    #[serde(
6158        rename = "websiteUrl",
6159        default,
6160        skip_serializing_if = "Option::is_none"
6161    )]
6162    pub website_url: Option<String>,
6163}
6164
6165#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6166pub enum PluginListMarketplaceKind {
6167    #[serde(rename = "local")]
6168    Local,
6169    #[serde(rename = "vertical")]
6170    Vertical,
6171    #[serde(rename = "workspace-directory")]
6172    Workspace_directory,
6173    #[serde(rename = "shared-with-me")]
6174    Shared_with_me,
6175    #[serde(rename = "created-by-me-remote")]
6176    Created_by_me_remote,
6177}
6178
6179#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6180#[serde(rename_all = "camelCase")]
6181pub struct PluginListParams {
6182    #[serde(default, skip_serializing_if = "Option::is_none")]
6183    pub cwds: Option<Vec<AbsolutePathBuf>>,
6184    #[serde(
6185        rename = "forceRefetch",
6186        default,
6187        skip_serializing_if = "Option::is_none"
6188    )]
6189    pub force_refetch: Option<bool>,
6190    #[serde(
6191        rename = "marketplaceKinds",
6192        default,
6193        skip_serializing_if = "Option::is_none"
6194    )]
6195    pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
6196}
6197
6198#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6199#[serde(rename_all = "camelCase")]
6200pub struct PluginListResponse {
6201    #[serde(
6202        rename = "featuredPluginIds",
6203        default,
6204        skip_serializing_if = "Option::is_none"
6205    )]
6206    pub featured_plugin_ids: Option<Vec<String>>,
6207    #[serde(
6208        rename = "marketplaceLoadErrors",
6209        default,
6210        skip_serializing_if = "Option::is_none"
6211    )]
6212    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
6213    #[serde(default)]
6214    pub marketplaces: Vec<PluginMarketplaceEntry>,
6215}
6216
6217#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6218#[serde(rename_all = "camelCase")]
6219pub struct PluginMarketplaceEntry {
6220    #[serde(default, skip_serializing_if = "Option::is_none")]
6221    pub interface: Option<MarketplaceInterface>,
6222    #[serde(default)]
6223    pub name: String,
6224    #[serde(default, skip_serializing_if = "Option::is_none")]
6225    pub path: Option<AbsolutePathBuf>,
6226    #[serde(default)]
6227    pub plugins: Vec<PluginSummary>,
6228}
6229
6230#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6231#[serde(rename_all = "camelCase")]
6232pub struct PluginReadParams {
6233    #[serde(
6234        rename = "marketplacePath",
6235        default,
6236        skip_serializing_if = "Option::is_none"
6237    )]
6238    pub marketplace_path: Option<AbsolutePathBuf>,
6239    #[serde(rename = "pluginName", default)]
6240    pub plugin_name: String,
6241    #[serde(
6242        rename = "remoteMarketplaceName",
6243        default,
6244        skip_serializing_if = "Option::is_none"
6245    )]
6246    pub remote_marketplace_name: Option<String>,
6247}
6248
6249#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6250#[serde(rename_all = "camelCase")]
6251pub struct PluginReadResponse {
6252    #[serde()]
6253    pub plugin: PluginDetail,
6254}
6255
6256/// Runtime categories affected by this change, not just capabilities
6257/// currently present. Flags describe declarations before runtime policy
6258/// filtering. Updates OR the old and new bundle flags; enablement changes and
6259/// cached reinstalls use the cached bundle; removals retain the old bundle's
6260/// flags.
6261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6262#[serde(rename_all = "camelCase")]
6263pub struct PluginReconcileChangedPlugin {
6264    #[serde(rename = "hasApps", default)]
6265    pub has_apps: bool,
6266    #[serde(rename = "hasHooks", default)]
6267    pub has_hooks: bool,
6268    #[serde(rename = "hasMcps", default)]
6269    pub has_mcps: bool,
6270    /// Whether either bundle declares skill roots; not a validated inventory
6271    /// of enabled skills.
6272    #[serde(rename = "hasSkills", default)]
6273    pub has_skills: bool,
6274    /// Local plugin ID (`name@marketplace`), matching `PluginSummary.id`.
6275    #[serde(default)]
6276    pub id: String,
6277}
6278
6279#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6280#[serde(rename_all = "camelCase")]
6281pub struct PluginReconcileParams {
6282    /// Optional client-provided reason recorded with the reconciliation
6283    /// attempt.
6284    #[serde(default, skip_serializing_if = "Option::is_none")]
6285    pub reason: Option<String>,
6286}
6287
6288/// Bundle and installed-state changes observed by this pass, not a
6289/// runtime-readiness acknowledgement or a cumulative diff since the client's
6290/// last request. Other metadata-only changes are not listed.
6291#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6292#[serde(rename_all = "camelCase")]
6293pub struct PluginReconcileResponse {
6294    /// Plugins affected by bundle changes, enablement changes, or removals.
6295    /// Installed-state changes compare against the previous cached snapshot,
6296    /// including cached reinstalls. Removal hints survive cache cleanup
6297    /// failures; unchanged plugins are omitted.
6298    #[serde(rename = "changedPlugins", default)]
6299    pub changed_plugins: Vec<PluginReconcileChangedPlugin>,
6300    /// Subset of failures for which the requested bundle could not be
6301    /// materialized. A previously cached version may still be available.
6302    #[serde(rename = "failedMaterializationRemotePluginIds", default)]
6303    pub failed_materialization_remote_plugin_ids: Vec<String>,
6304    /// Backend remote plugin IDs whose bundle or identity update failed.
6305    #[serde(rename = "failedRemotePluginIds", default)]
6306    pub failed_remote_plugin_ids: Vec<String>,
6307}
6308
6309#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6310#[serde(rename_all = "camelCase")]
6311pub struct PluginShareCheckoutParams {
6312    #[serde(rename = "remotePluginId", default)]
6313    pub remote_plugin_id: String,
6314}
6315
6316#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6317#[serde(rename_all = "camelCase")]
6318pub struct PluginShareCheckoutResponse {
6319    #[serde(rename = "marketplaceName", default)]
6320    pub marketplace_name: String,
6321    #[serde(rename = "marketplacePath")]
6322    pub marketplace_path: AbsolutePathBuf,
6323    #[serde(rename = "pluginId", default)]
6324    pub plugin_id: String,
6325    #[serde(rename = "pluginName", default)]
6326    pub plugin_name: String,
6327    #[serde(rename = "pluginPath")]
6328    pub plugin_path: AbsolutePathBuf,
6329    #[serde(rename = "remotePluginId", default)]
6330    pub remote_plugin_id: String,
6331    #[serde(
6332        rename = "remoteVersion",
6333        default,
6334        skip_serializing_if = "Option::is_none"
6335    )]
6336    pub remote_version: Option<String>,
6337}
6338
6339#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6340#[serde(rename_all = "camelCase")]
6341pub struct PluginShareContext {
6342    #[serde(
6343        rename = "canPublishToWorkspace",
6344        default,
6345        skip_serializing_if = "Option::is_none"
6346    )]
6347    pub can_publish_to_workspace: Option<bool>,
6348    #[serde(
6349        rename = "creatorAccountUserId",
6350        default,
6351        skip_serializing_if = "Option::is_none"
6352    )]
6353    pub creator_account_user_id: Option<String>,
6354    #[serde(
6355        rename = "creatorName",
6356        default,
6357        skip_serializing_if = "Option::is_none"
6358    )]
6359    pub creator_name: Option<String>,
6360    #[serde(default, skip_serializing_if = "Option::is_none")]
6361    pub discoverability: Option<PluginShareDiscoverability>,
6362    #[serde(rename = "remotePluginId", default)]
6363    pub remote_plugin_id: String,
6364    #[serde(
6365        rename = "remoteVersion",
6366        default,
6367        skip_serializing_if = "Option::is_none"
6368    )]
6369    pub remote_version: Option<String>,
6370    #[serde(
6371        rename = "sharePrincipals",
6372        default,
6373        skip_serializing_if = "Option::is_none"
6374    )]
6375    pub share_principals: Option<Vec<PluginSharePrincipal>>,
6376    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
6377    pub share_url: Option<String>,
6378}
6379
6380#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6381#[serde(rename_all = "camelCase")]
6382pub struct PluginShareDeleteParams {
6383    #[serde(rename = "remotePluginId", default)]
6384    pub remote_plugin_id: String,
6385}
6386
6387#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6388#[serde(rename_all = "camelCase")]
6389pub struct PluginShareDeleteResponse {
6390    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6391    pub extra: serde_json::Map<String, Value>,
6392}
6393
6394#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6395pub enum PluginShareDiscoverability {
6396    #[serde(rename = "LISTED")]
6397    LISTED,
6398    #[serde(rename = "UNLISTED")]
6399    UNLISTED,
6400    #[serde(rename = "PRIVATE")]
6401    PRIVATE,
6402}
6403
6404#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6405#[serde(rename_all = "camelCase")]
6406pub struct PluginShareListItem {
6407    #[serde(
6408        rename = "localPluginPath",
6409        default,
6410        skip_serializing_if = "Option::is_none"
6411    )]
6412    pub local_plugin_path: Option<AbsolutePathBuf>,
6413    #[serde()]
6414    pub plugin: PluginSummary,
6415}
6416
6417#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6418#[serde(rename_all = "camelCase")]
6419pub struct PluginShareListParams {
6420    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6421    pub extra: serde_json::Map<String, Value>,
6422}
6423
6424#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6425#[serde(rename_all = "camelCase")]
6426pub struct PluginShareListResponse {
6427    #[serde(default)]
6428    pub data: Vec<PluginShareListItem>,
6429}
6430
6431#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6432#[serde(rename_all = "camelCase")]
6433pub struct PluginSharePrincipal {
6434    #[serde(default)]
6435    pub name: String,
6436    #[serde(rename = "principalId", default)]
6437    pub principal_id: String,
6438    #[serde(rename = "principalType")]
6439    pub principal_type: PluginSharePrincipalType,
6440    #[serde()]
6441    pub role: PluginSharePrincipalRole,
6442}
6443
6444#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6445pub enum PluginSharePrincipalRole {
6446    #[serde(rename = "reader")]
6447    Reader,
6448    #[serde(rename = "editor")]
6449    Editor,
6450    #[serde(rename = "owner")]
6451    Owner,
6452}
6453
6454#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6455pub enum PluginSharePrincipalType {
6456    #[serde(rename = "user")]
6457    User,
6458    #[serde(rename = "group")]
6459    Group,
6460    #[serde(rename = "workspace")]
6461    Workspace,
6462}
6463
6464#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6465#[serde(rename_all = "camelCase")]
6466pub struct PluginShareSaveParams {
6467    #[serde(default, skip_serializing_if = "Option::is_none")]
6468    pub discoverability: Option<PluginShareDiscoverability>,
6469    #[serde(rename = "pluginPath")]
6470    pub plugin_path: AbsolutePathBuf,
6471    #[serde(
6472        rename = "remotePluginId",
6473        default,
6474        skip_serializing_if = "Option::is_none"
6475    )]
6476    pub remote_plugin_id: Option<String>,
6477    #[serde(
6478        rename = "shareTargets",
6479        default,
6480        skip_serializing_if = "Option::is_none"
6481    )]
6482    pub share_targets: Option<Vec<PluginShareTarget>>,
6483}
6484
6485#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6486#[serde(rename_all = "camelCase")]
6487pub struct PluginShareSaveResponse {
6488    #[serde(
6489        rename = "canPublishToWorkspace",
6490        default,
6491        skip_serializing_if = "Option::is_none"
6492    )]
6493    pub can_publish_to_workspace: Option<bool>,
6494    #[serde(rename = "remotePluginId", default)]
6495    pub remote_plugin_id: String,
6496    #[serde(rename = "shareUrl", default)]
6497    pub share_url: String,
6498}
6499
6500#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6501#[serde(rename_all = "camelCase")]
6502pub struct PluginShareTarget {
6503    #[serde(rename = "principalId", default)]
6504    pub principal_id: String,
6505    #[serde(rename = "principalType")]
6506    pub principal_type: PluginSharePrincipalType,
6507    #[serde()]
6508    pub role: PluginShareTargetRole,
6509}
6510
6511#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6512pub enum PluginShareTargetRole {
6513    #[serde(rename = "reader")]
6514    Reader,
6515    #[serde(rename = "editor")]
6516    Editor,
6517}
6518
6519#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6520pub enum PluginShareUpdateDiscoverability {
6521    #[serde(rename = "UNLISTED")]
6522    UNLISTED,
6523    #[serde(rename = "PRIVATE")]
6524    PRIVATE,
6525    #[serde(rename = "LISTED")]
6526    LISTED,
6527}
6528
6529#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6530#[serde(rename_all = "camelCase")]
6531pub struct PluginShareUpdateTargetsParams {
6532    #[serde()]
6533    pub discoverability: PluginShareUpdateDiscoverability,
6534    #[serde(rename = "remotePluginId", default)]
6535    pub remote_plugin_id: String,
6536    #[serde(rename = "shareTargets", default)]
6537    pub share_targets: Vec<PluginShareTarget>,
6538}
6539
6540#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6541#[serde(rename_all = "camelCase")]
6542pub struct PluginShareUpdateTargetsResponse {
6543    #[serde()]
6544    pub discoverability: PluginShareDiscoverability,
6545    #[serde(default)]
6546    pub principals: Vec<PluginSharePrincipal>,
6547}
6548
6549#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6550#[serde(rename_all = "camelCase")]
6551pub struct PluginSkillReadParams {
6552    #[serde(rename = "remoteMarketplaceName", default)]
6553    pub remote_marketplace_name: String,
6554    #[serde(rename = "remotePluginId", default)]
6555    pub remote_plugin_id: String,
6556    #[serde(rename = "skillName", default)]
6557    pub skill_name: String,
6558}
6559
6560#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6561#[serde(rename_all = "camelCase")]
6562pub struct PluginSkillReadResponse {
6563    #[serde(default, skip_serializing_if = "Option::is_none")]
6564    pub contents: Option<String>,
6565}
6566
6567#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6568#[serde(tag = "type", rename_all = "camelCase")]
6569pub enum PluginSource {
6570    Local {
6571        path: AbsolutePathBuf,
6572    },
6573    Git {
6574        #[serde(default, skip_serializing_if = "Option::is_none")]
6575        path: Option<String>,
6576        #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
6577        ref_name: Option<String>,
6578        #[serde(default, skip_serializing_if = "Option::is_none")]
6579        sha: Option<String>,
6580        url: String,
6581    },
6582    Npm {
6583        package: String,
6584        #[serde(default, skip_serializing_if = "Option::is_none")]
6585        registry: Option<String>,
6586        #[serde(default, skip_serializing_if = "Option::is_none")]
6587        version: Option<String>,
6588    },
6589    Remote,
6590}
6591
6592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6593#[serde(rename_all = "camelCase")]
6594pub struct PluginSummary {
6595    #[serde(rename = "authPolicy")]
6596    pub auth_policy: PluginAuthPolicy,
6597    #[serde(default, skip_serializing_if = "Option::is_none")]
6598    pub availability: Option<Value>,
6599    #[serde(
6600        rename = "disabledReason",
6601        default,
6602        skip_serializing_if = "Option::is_none"
6603    )]
6604    pub disabled_reason: Option<PluginDisabledReason>,
6605    #[serde(
6606        rename = "eligiblePlanTypes",
6607        default,
6608        skip_serializing_if = "Option::is_none"
6609    )]
6610    pub eligible_plan_types: Option<Vec<String>>,
6611    #[serde(default)]
6612    pub enabled: bool,
6613    #[serde(default)]
6614    pub id: String,
6615    #[serde(rename = "installPolicy")]
6616    pub install_policy: PluginInstallPolicy,
6617    #[serde(
6618        rename = "installPolicySource",
6619        default,
6620        skip_serializing_if = "Option::is_none"
6621    )]
6622    pub install_policy_source: Option<PluginInstallPolicySource>,
6623    #[serde(default)]
6624    pub installed: bool,
6625    #[serde(
6626        rename = "installedAt",
6627        default,
6628        skip_serializing_if = "Option::is_none"
6629    )]
6630    pub installed_at: Option<i64>,
6631    #[serde(default, skip_serializing_if = "Option::is_none")]
6632    pub interface: Option<PluginInterface>,
6633    #[serde(default, skip_serializing_if = "Option::is_none")]
6634    pub keywords: Option<Vec<String>>,
6635    #[serde(
6636        rename = "localVersion",
6637        default,
6638        skip_serializing_if = "Option::is_none"
6639    )]
6640    pub local_version: Option<String>,
6641    #[serde(
6642        rename = "mustShowInstallationInterstitial",
6643        default,
6644        skip_serializing_if = "Option::is_none"
6645    )]
6646    pub must_show_installation_interstitial: Option<bool>,
6647    #[serde(default)]
6648    pub name: String,
6649    #[serde(
6650        rename = "remotePluginId",
6651        default,
6652        skip_serializing_if = "Option::is_none"
6653    )]
6654    pub remote_plugin_id: Option<String>,
6655    #[serde(
6656        rename = "shareContext",
6657        default,
6658        skip_serializing_if = "Option::is_none"
6659    )]
6660    pub share_context: Option<PluginShareContext>,
6661    #[serde()]
6662    pub source: PluginSource,
6663    #[serde(default, skip_serializing_if = "Option::is_none")]
6664    pub version: Option<String>,
6665}
6666
6667#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6668#[serde(rename_all = "camelCase")]
6669pub struct PluginUninstallParams {
6670    #[serde(rename = "pluginId", default)]
6671    pub plugin_id: String,
6672}
6673
6674#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6675#[serde(rename_all = "camelCase")]
6676pub struct PluginUninstallResponse {
6677    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6678    pub extra: serde_json::Map<String, Value>,
6679}
6680
6681#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6682#[serde(rename_all = "camelCase")]
6683pub struct PluginsMigration {
6684    #[serde(rename = "marketplaceName", default)]
6685    pub marketplace_name: String,
6686    #[serde(rename = "pluginNames", default)]
6687    pub plugin_names: Vec<String>,
6688}
6689
6690#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6691#[serde(rename_all = "camelCase")]
6692pub struct ProcessExitedNotification {
6693    #[serde(rename = "exitCode", default)]
6694    pub exit_code: i64,
6695    /// Whether output collection hit its post-exit deadline before seeing EOF
6696    /// or reaching the requested byte cap on either stream. Older servers omit
6697    /// this field.
6698    #[serde(
6699        rename = "outputDrainTimedOut",
6700        default,
6701        skip_serializing_if = "Option::is_none"
6702    )]
6703    pub output_drain_timed_out: Option<bool>,
6704    #[serde(rename = "processHandle", default)]
6705    pub process_handle: String,
6706    #[serde(default)]
6707    pub stderr: String,
6708    #[serde(rename = "stderrCapReached", default)]
6709    pub stderr_cap_reached: bool,
6710    #[serde(default)]
6711    pub stdout: String,
6712    #[serde(rename = "stdoutCapReached", default)]
6713    pub stdout_cap_reached: bool,
6714}
6715
6716#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6717#[serde(rename_all = "camelCase")]
6718pub struct ProcessOutputDeltaNotification {
6719    #[serde(rename = "capReached", default)]
6720    pub cap_reached: bool,
6721    #[serde(rename = "deltaBase64", default)]
6722    pub delta_base64: String,
6723    #[serde(rename = "processHandle", default)]
6724    pub process_handle: String,
6725    #[serde(default)]
6726    pub stream: Value,
6727}
6728
6729#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6730pub enum ProcessOutputStream {
6731    #[serde(rename = "stdout")]
6732    Stdout,
6733    #[serde(rename = "stderr")]
6734    Stderr,
6735}
6736
6737#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6738pub enum RateLimitReachedType {
6739    #[serde(rename = "rate_limit_reached")]
6740    Rate_limit_reached,
6741    #[serde(rename = "workspace_owner_credits_depleted")]
6742    Workspace_owner_credits_depleted,
6743    #[serde(rename = "workspace_member_credits_depleted")]
6744    Workspace_member_credits_depleted,
6745    #[serde(rename = "workspace_owner_usage_limit_reached")]
6746    Workspace_owner_usage_limit_reached,
6747    #[serde(rename = "workspace_member_usage_limit_reached")]
6748    Workspace_member_usage_limit_reached,
6749}
6750
6751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6752#[serde(rename_all = "camelCase")]
6753pub struct RateLimitResetCredit {
6754    #[serde(default, skip_serializing_if = "Option::is_none")]
6755    pub description: Option<String>,
6756    #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
6757    pub expires_at: Option<i64>,
6758    #[serde(rename = "grantedAt", default)]
6759    pub granted_at: i64,
6760    #[serde(default)]
6761    pub id: String,
6762    #[serde(rename = "resetType")]
6763    pub reset_type: RateLimitResetType,
6764    #[serde()]
6765    pub status: RateLimitResetCreditStatus,
6766    #[serde(default, skip_serializing_if = "Option::is_none")]
6767    pub title: Option<String>,
6768}
6769
6770#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6771pub enum RateLimitResetCreditStatus {
6772    #[serde(rename = "available")]
6773    Available,
6774    #[serde(rename = "redeeming")]
6775    Redeeming,
6776    #[serde(rename = "redeemed")]
6777    Redeemed,
6778    #[serde(rename = "unknown")]
6779    Unknown,
6780}
6781
6782#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6783#[serde(rename_all = "camelCase")]
6784pub struct RateLimitResetCreditsSummary {
6785    #[serde(rename = "availableCount", default)]
6786    pub available_count: i64,
6787    #[serde(default, skip_serializing_if = "Option::is_none")]
6788    pub credits: Option<Vec<RateLimitResetCredit>>,
6789}
6790
6791#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6792pub enum RateLimitResetType {
6793    #[serde(rename = "codexRateLimits")]
6794    CodexRateLimits,
6795    #[serde(rename = "unknown")]
6796    Unknown,
6797}
6798
6799#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6800#[serde(rename_all = "camelCase")]
6801pub struct RateLimitSnapshot {
6802    #[serde(default, skip_serializing_if = "Option::is_none")]
6803    pub credits: Option<CreditsSnapshot>,
6804    #[serde(
6805        rename = "individualLimit",
6806        default,
6807        skip_serializing_if = "Option::is_none"
6808    )]
6809    pub individual_limit: Option<SpendControlLimitSnapshot>,
6810    #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
6811    pub limit_id: Option<String>,
6812    #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
6813    pub limit_name: Option<String>,
6814    /// Normal model whose display name and reasoning options describe this
6815    /// quota alias.
6816    #[serde(
6817        rename = "normalModelSlug",
6818        default,
6819        skip_serializing_if = "Option::is_none"
6820    )]
6821    pub normal_model_slug: Option<String>,
6822    #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
6823    pub plan_type: Option<PlanType>,
6824    #[serde(default, skip_serializing_if = "Option::is_none")]
6825    pub primary: Option<RateLimitWindow>,
6826    #[serde(
6827        rename = "rateLimitReachedType",
6828        default,
6829        skip_serializing_if = "Option::is_none"
6830    )]
6831    pub rate_limit_reached_type: Option<RateLimitReachedType>,
6832    #[serde(default, skip_serializing_if = "Option::is_none")]
6833    pub secondary: Option<RateLimitWindow>,
6834    #[serde(
6835        rename = "spendControlReached",
6836        default,
6837        skip_serializing_if = "Option::is_none"
6838    )]
6839    pub spend_control_reached: Option<bool>,
6840}
6841
6842#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6843#[serde(rename_all = "camelCase")]
6844pub struct RateLimitWindow {
6845    #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
6846    pub resets_at: Option<i64>,
6847    #[serde(rename = "usedPercent", default)]
6848    pub used_percent: i64,
6849    #[serde(
6850        rename = "windowDurationMins",
6851        default,
6852        skip_serializing_if = "Option::is_none"
6853    )]
6854    pub window_duration_mins: Option<i64>,
6855}
6856
6857#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6858pub enum RealtimeConversationVersion {
6859    #[serde(rename = "v1")]
6860    V1,
6861    #[serde(rename = "v2")]
6862    V2,
6863    #[serde(rename = "v3")]
6864    V3,
6865}
6866
6867/// A non-empty reasoning effort value advertised by the model.
6868#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
6869#[serde(transparent)]
6870pub struct ReasoningEffort(pub String);
6871
6872#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6873#[serde(rename_all = "camelCase")]
6874pub struct ReasoningEffortOption {
6875    #[serde(default)]
6876    pub description: String,
6877    #[serde(rename = "reasoningEffort")]
6878    pub reasoning_effort: ReasoningEffort,
6879}
6880
6881#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6882pub enum ReasoningSummary {
6883    #[serde(rename = "auto")]
6884    Auto,
6885    #[serde(rename = "concise")]
6886    Concise,
6887    #[serde(rename = "detailed")]
6888    Detailed,
6889    #[serde(rename = "none")]
6890    None,
6891}
6892
6893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6894#[serde(rename_all = "camelCase")]
6895pub struct ReasoningSummaryPartAddedNotification {
6896    #[serde(rename = "itemId", default)]
6897    pub item_id: String,
6898    #[serde(rename = "summaryIndex", default)]
6899    pub summary_index: i64,
6900    #[serde(rename = "threadId", default)]
6901    pub thread_id: String,
6902    #[serde(rename = "turnId", default)]
6903    pub turn_id: String,
6904}
6905
6906#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6907#[serde(rename_all = "camelCase")]
6908pub struct ReasoningSummaryTextDeltaNotification {
6909    #[serde(default)]
6910    pub delta: String,
6911    #[serde(rename = "itemId", default)]
6912    pub item_id: String,
6913    #[serde(rename = "summaryIndex", default)]
6914    pub summary_index: i64,
6915    #[serde(rename = "threadId", default)]
6916    pub thread_id: String,
6917    #[serde(rename = "turnId", default)]
6918    pub turn_id: String,
6919}
6920
6921#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6922#[serde(rename_all = "camelCase")]
6923pub struct ReasoningTextDeltaNotification {
6924    #[serde(rename = "contentIndex", default)]
6925    pub content_index: i64,
6926    #[serde(default)]
6927    pub delta: String,
6928    #[serde(rename = "itemId", default)]
6929    pub item_id: String,
6930    #[serde(rename = "threadId", default)]
6931    pub thread_id: String,
6932    #[serde(rename = "turnId", default)]
6933    pub turn_id: String,
6934}
6935
6936#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6937pub enum RemoteControlConnectionStatus {
6938    #[serde(rename = "disabled")]
6939    Disabled,
6940    #[serde(rename = "connecting")]
6941    Connecting,
6942    #[serde(rename = "connected")]
6943    Connected,
6944    #[serde(rename = "errored")]
6945    Errored,
6946}
6947
6948#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6949#[serde(rename_all = "camelCase")]
6950pub struct RemoteControlStatusChangedNotification {
6951    #[serde(
6952        rename = "environmentId",
6953        default,
6954        skip_serializing_if = "Option::is_none"
6955    )]
6956    pub environment_id: Option<String>,
6957    #[serde(rename = "installationId", default)]
6958    pub installation_id: String,
6959    #[serde(rename = "serverName", default)]
6960    pub server_name: String,
6961    #[serde()]
6962    pub status: RemoteControlConnectionStatus,
6963}
6964
6965#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6966#[serde(untagged)]
6967pub enum RequestId {
6968    Variant0(String),
6969    Variant1(i64),
6970}
6971
6972#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6973#[serde(rename_all = "camelCase")]
6974pub struct RequestPermissionProfile {
6975    #[serde(
6976        rename = "fileSystem",
6977        default,
6978        skip_serializing_if = "Option::is_none"
6979    )]
6980    pub file_system: Option<AdditionalFileSystemPermissions>,
6981    #[serde(default, skip_serializing_if = "Option::is_none")]
6982    pub network: Option<AdditionalNetworkPermissions>,
6983}
6984
6985#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6986pub enum ResidencyRequirement {
6987    #[serde(rename = "us")]
6988    Us,
6989}
6990
6991#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6992#[serde(rename_all = "camelCase")]
6993pub struct Resource {
6994    #[serde(default, skip_serializing_if = "Option::is_none")]
6995    pub _meta: Option<Value>,
6996    #[serde(default, skip_serializing_if = "Option::is_none")]
6997    pub annotations: Option<Value>,
6998    #[serde(default, skip_serializing_if = "Option::is_none")]
6999    pub description: Option<String>,
7000    #[serde(default, skip_serializing_if = "Option::is_none")]
7001    pub icons: Option<Vec<Value>>,
7002    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
7003    pub mime_type: Option<String>,
7004    #[serde(default)]
7005    pub name: String,
7006    #[serde(default, skip_serializing_if = "Option::is_none")]
7007    pub size: Option<i64>,
7008    #[serde(default, skip_serializing_if = "Option::is_none")]
7009    pub title: Option<String>,
7010    #[serde(default)]
7011    pub uri: String,
7012}
7013
7014#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7015#[serde(untagged)]
7016pub enum ResourceContent {
7017    Variant0(Value),
7018    Variant1(Value),
7019}
7020
7021#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7022#[serde(rename_all = "camelCase")]
7023pub struct ResourceTemplate {
7024    #[serde(default, skip_serializing_if = "Option::is_none")]
7025    pub annotations: Option<Value>,
7026    #[serde(default, skip_serializing_if = "Option::is_none")]
7027    pub description: Option<String>,
7028    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
7029    pub mime_type: Option<String>,
7030    #[serde(default)]
7031    pub name: String,
7032    #[serde(default, skip_serializing_if = "Option::is_none")]
7033    pub title: Option<String>,
7034    #[serde(rename = "uriTemplate", default)]
7035    pub uri_template: String,
7036}
7037
7038/// Usage metadata reported for one upstream response (0.148 upstream).
7039#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7040#[serde(rename_all = "camelCase")]
7041pub struct ResponseUsageMetadata {
7042    #[serde(default, skip_serializing_if = "Option::is_none")]
7043    pub amount: Option<String>,
7044    #[serde(default, skip_serializing_if = "Option::is_none")]
7045    pub metadata: Option<Value>,
7046}
7047
7048#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7049pub enum ReviewDecision {
7050    #[serde(rename = "approved")]
7051    Approved,
7052    #[serde(rename = "approved_execpolicy_amendment")]
7053    ApprovedExecpolicyAmendment {
7054        proposed_execpolicy_amendment: Vec<String>,
7055    },
7056    #[serde(rename = "approved_for_session")]
7057    ApprovedForSession,
7058    #[serde(rename = "approved_mcp_policy_amendment")]
7059    ApprovedMcpPolicyAmendment,
7060    #[serde(rename = "network_policy_amendment")]
7061    NetworkPolicyAmendment {
7062        network_policy_amendment: NetworkPolicyAmendment,
7063    },
7064    #[serde(rename = "denied")]
7065    Denied { rejection: String },
7066    #[serde(rename = "timed_out")]
7067    TimedOut,
7068    #[serde(rename = "abort")]
7069    Abort,
7070}
7071
7072#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7073pub enum ReviewDelivery {
7074    #[serde(rename = "inline")]
7075    Inline,
7076}
7077
7078#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7079#[serde(rename_all = "camelCase")]
7080pub struct ReviewStartParams {
7081    /// Reviews run inline on the supplied thread. Omit this field or pass
7082    /// `inline`. To review on a separate thread, start a thread first and use
7083    /// its id.
7084    #[serde(default, skip_serializing_if = "Option::is_none")]
7085    pub delivery: Option<ReviewDelivery>,
7086    #[serde()]
7087    pub target: ReviewTarget,
7088    #[serde(rename = "threadId", default)]
7089    pub thread_id: String,
7090}
7091
7092#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7093#[serde(rename_all = "camelCase")]
7094pub struct ReviewStartResponse {
7095    /// The thread id supplied to `review/start`.
7096    #[serde(rename = "reviewThreadId", default)]
7097    pub review_thread_id: String,
7098    #[serde()]
7099    pub turn: Turn,
7100}
7101
7102#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7103#[serde(tag = "type", rename_all = "camelCase")]
7104pub enum ReviewTarget {
7105    #[serde(rename = "uncommittedChanges")]
7106    UncommittedChanges,
7107    #[serde(rename = "baseBranch")]
7108    BaseBranch {
7109        branch: String,
7110    },
7111    Commit {
7112        sha: String,
7113        #[serde(default, skip_serializing_if = "Option::is_none")]
7114        title: Option<String>,
7115    },
7116    Custom {
7117        instructions: String,
7118    },
7119}
7120
7121/// Delivery mode for an agent message item (0.147: currently only `async`).
7122#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7123pub enum AgentMessageDelivery {
7124    #[serde(rename = "async")]
7125    Async,
7126}
7127
7128/// Moderation state attached to an agent message item.
7129#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7130pub struct AgentMessageModeration {
7131    pub moderated: bool,
7132    #[serde(default, skip_serializing_if = "Option::is_none")]
7133    pub display: Option<AgentMessageDisplay>,
7134}
7135
7136/// The only supported version of the answer display contract (wire value `1`).
7137#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
7138#[serde(try_from = "u8", into = "u8")]
7139pub struct AgentMessageDisplayVersion;
7140
7141impl TryFrom<u8> for AgentMessageDisplayVersion {
7142    type Error = &'static str;
7143
7144    fn try_from(version: u8) -> Result<Self, Self::Error> {
7145        match version {
7146            1 => Ok(Self),
7147            _ => Err("unsupported answer display version"),
7148        }
7149    }
7150}
7151
7152impl From<AgentMessageDisplayVersion> for u8 {
7153    fn from(_: AgentMessageDisplayVersion) -> Self {
7154        1
7155    }
7156}
7157
7158/// How Chat should present a recovered answer.
7159#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7160#[serde(tag = "mode", rename_all = "camelCase")]
7161pub enum AgentMessageDisplay {
7162    Show {
7163        version: AgentMessageDisplayVersion,
7164        #[serde(default, skip_serializing_if = "Option::is_none")]
7165        annotation: Option<AnswerAnnotation>,
7166        #[serde(rename = "trustedContacts")]
7167        trusted_contacts: TrustedContacts,
7168    },
7169    Hide {
7170        version: AgentMessageDisplayVersion,
7171        replacement: AnswerReplacement,
7172    },
7173    Block {
7174        version: AgentMessageDisplayVersion,
7175        reason: BlockReason,
7176    },
7177}
7178
7179/// An annotation Chat shows alongside a displayed answer.
7180#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7181#[serde(tag = "kind", rename_all = "camelCase")]
7182pub enum AnswerAnnotation {
7183    WellbeingHelpline { subject: HelplineSubject },
7184}
7185
7186/// Whether a wellbeing helpline annotation refers to the answer or the prompt.
7187#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7188#[serde(rename_all = "camelCase")]
7189pub enum HelplineSubject {
7190    Answer,
7191    Prompt,
7192}
7193
7194/// Whether Chat should check the user's trusted contacts before showing an answer.
7195#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7196#[serde(rename_all = "camelCase")]
7197pub enum TrustedContacts {
7198    Check,
7199    Skip,
7200}
7201
7202/// What Chat shows in place of a hidden answer.
7203#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7204#[serde(tag = "kind", rename_all = "camelCase")]
7205pub enum AnswerReplacement {
7206    WellbeingPromptHelpline {},
7207}
7208
7209/// Why an answer is blocked.
7210#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7211#[serde(tag = "kind", rename_all = "camelCase")]
7212pub enum BlockReason {
7213    Protection {
7214        /// Identifies the same moderation row that Chat writes on the live path.
7215        #[serde(rename = "protectionType")]
7216        protection_type: String,
7217    },
7218    Cyber {
7219        #[serde(
7220            default,
7221            rename = "trustedAccess",
7222            skip_serializing_if = "Option::is_none"
7223        )]
7224        trusted_access: Option<bool>,
7225    },
7226}
7227
7228/// Where the CLI stores auth credentials.
7229#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7230pub enum CliAuthCredentialsStoreMode {
7231    #[serde(rename = "file")]
7232    File,
7233    #[serde(rename = "keyring")]
7234    Keyring,
7235    #[serde(rename = "auto")]
7236    Auto,
7237    #[serde(rename = "ephemeral")]
7238    Ephemeral,
7239}
7240
7241/// A project grouping threads, owned by app-server.
7242#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7243pub struct Project {
7244    #[serde(rename = "createdAt", default)]
7245    pub created_at: i64,
7246    #[serde(default)]
7247    pub id: String,
7248    #[serde(default)]
7249    pub metadata: std::collections::HashMap<String, String>,
7250    #[serde(default)]
7251    pub name: String,
7252    /// Newest non-archived member thread's recency, in Unix seconds;
7253    /// absent/null when none exist (0.148 upstream).
7254    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7255    pub recency_at: Option<i64>,
7256    #[serde(default)]
7257    pub roots: Vec<ProjectRoot>,
7258    #[serde(rename = "updatedAt", default)]
7259    pub updated_at: i64,
7260}
7261
7262/// Sort order for project listings (0.148 upstream).
7263#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7264pub enum ProjectSortKey {
7265    #[serde(rename = "position")]
7266    Position,
7267    #[serde(rename = "recencyAt")]
7268    RecencyAt,
7269}
7270
7271#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7272pub enum ProjectChangeType {
7273    #[serde(rename = "created")]
7274    Created,
7275    #[serde(rename = "updated")]
7276    Updated,
7277    #[serde(rename = "deleted")]
7278    Deleted,
7279}
7280
7281/// `project/changed` — a project was created, updated, or deleted.
7282#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7283pub struct ProjectChangedNotification {
7284    #[serde(rename = "changeType")]
7285    pub change_type: ProjectChangeType,
7286    #[serde(rename = "projectId", default)]
7287    pub project_id: String,
7288}
7289
7290#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7291pub struct ProjectRoot {
7292    pub path: AbsolutePathBuf,
7293}
7294
7295/// A user submission waiting in a thread's queue.
7296#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7297pub struct QueuedSubmission {
7298    #[serde(rename = "clientUserMessageId", default)]
7299    pub client_user_message_id: String,
7300    #[serde(default)]
7301    pub id: String,
7302    #[serde(default)]
7303    pub input: Vec<UserInput>,
7304    /// Metadata retained with this input, including across reconnect and restoration.
7305    #[serde(
7306        rename = "responsesapiClientMetadata",
7307        default,
7308        skip_serializing_if = "Option::is_none"
7309    )]
7310    pub responsesapi_client_metadata: Option<std::collections::HashMap<String, String>>,
7311}
7312
7313/// `autoApprovalReview/strictReviewRequired` — a strict review gate opened.
7314#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7315pub struct StrictReviewRequiredNotification {
7316    /// Unix timestamp (ms) when this review started.
7317    #[serde(rename = "startedAtMs", default)]
7318    pub started_at_ms: i64,
7319    #[serde(rename = "threadId", default)]
7320    pub thread_id: String,
7321    #[serde(rename = "turnId", default)]
7322    pub turn_id: String,
7323}
7324
7325/// `thread/project/updated` — a thread's project assignment changed.
7326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7327pub struct ThreadProjectUpdatedNotification {
7328    #[serde(rename = "projectId", default)]
7329    pub project_id: Option<String>,
7330    #[serde(rename = "threadId", default)]
7331    pub thread_id: String,
7332}
7333
7334/// `thread/queue/changed` — the thread's queued submissions changed.
7335#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7336pub struct ThreadQueueChangedNotification {
7337    #[serde(rename = "threadId", default)]
7338    pub thread_id: String,
7339}
7340
7341/// `thread/reverted` — the thread was rolled back.
7342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7343pub struct ThreadRevertedNotification {
7344    #[serde(rename = "threadId", default)]
7345    pub thread_id: String,
7346}
7347
7348/// `thread/prediction/updated` — a prediction requested for a turn finished
7349/// (`openai/codex@main` 90abcfac, experimental).
7350#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7351#[serde(rename_all = "camelCase")]
7352pub struct ThreadPredictionUpdatedNotification {
7353    pub result: ThreadPredictionResult,
7354    #[serde(rename = "sourceTurnId", default)]
7355    pub source_turn_id: String,
7356    #[serde(rename = "threadId", default)]
7357    pub thread_id: String,
7358}
7359
7360/// Outcome of a thread prediction (`openai/codex@main` 90abcfac).
7361#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7362#[serde(tag = "type", rename_all = "camelCase")]
7363pub enum ThreadPredictionResult {
7364    Completed {
7365        #[serde(default, skip_serializing_if = "Option::is_none")]
7366        text: Option<String>,
7367    },
7368    Failed,
7369}
7370
7371/// In-app browser requirements (0.148 upstream).
7372#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7373#[serde(rename_all = "camelCase")]
7374pub struct InAppBrowserRequirements {
7375    #[serde(
7376        rename = "allowExternalBrowserSettingsImport",
7377        default,
7378        skip_serializing_if = "Option::is_none"
7379    )]
7380    pub allow_external_browser_settings_import: Option<bool>,
7381}
7382
7383/// One MCP-server-originated notification, relayed verbatim.
7384#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7385pub struct McpServerEventNotification {
7386    #[serde(default)]
7387    pub method: String,
7388    #[serde(default)]
7389    pub params: Value,
7390}
7391
7392/// `mcpServer/event/stream/notification` — an MCP server's own
7393/// notification stream, forwarded to subscribers.
7394#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7395pub struct McpServerEventStreamNotification {
7396    pub notification: McpServerEventNotification,
7397    #[serde(rename = "subscriptionId", default)]
7398    pub subscription_id: String,
7399}
7400
7401/// Allow/deny switch used across the browser-use / computer-use policy
7402/// surface (0.148 upstream).
7403#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7404pub enum AllowDenyRequirement {
7405    #[serde(rename = "allow")]
7406    Allow,
7407    #[serde(rename = "deny")]
7408    Deny,
7409}
7410
7411/// How long a granted browser-use access approval lasts.
7412#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7413pub enum BrowserUseAccessApprovalLifetime {
7414    #[serde(rename = "turn")]
7415    Turn,
7416    #[serde(rename = "thread")]
7417    Thread,
7418}
7419
7420/// Current thread-runtime MCP server connection state.
7421#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7422pub enum McpServerConnectionStatus {
7423    #[serde(rename = "notStarted")]
7424    NotStarted,
7425    #[serde(rename = "starting")]
7426    Starting,
7427    #[serde(rename = "connected")]
7428    Connected,
7429    #[serde(rename = "authenticationRequired")]
7430    AuthenticationRequired,
7431    #[serde(rename = "failed")]
7432    Failed,
7433    #[serde(rename = "cancelled")]
7434    Cancelled,
7435    #[serde(rename = "disabled")]
7436    Disabled,
7437}
7438
7439/// Per-origin browser-use policy (requirements side, camelCase wire).
7440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7441#[serde(rename_all = "camelCase")]
7442pub struct BrowserUseOriginPolicy {
7443    #[serde(default, skip_serializing_if = "Option::is_none")]
7444    pub access: Option<AllowDenyRequirement>,
7445    #[serde(
7446        rename = "accessApprovalLifetime",
7447        default,
7448        skip_serializing_if = "Option::is_none"
7449    )]
7450    pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
7451    #[serde(
7452        rename = "autoReview",
7453        default,
7454        skip_serializing_if = "Option::is_none"
7455    )]
7456    pub auto_review: Option<AllowDenyRequirement>,
7457    #[serde(default, skip_serializing_if = "Option::is_none")]
7458    pub downloads: Option<AllowDenyRequirement>,
7459    #[serde(
7460        rename = "fullCdpAccess",
7461        default,
7462        skip_serializing_if = "Option::is_none"
7463    )]
7464    pub full_cdp_access: Option<AllowDenyRequirement>,
7465    #[serde(
7466        rename = "persistentApproval",
7467        default,
7468        skip_serializing_if = "Option::is_none"
7469    )]
7470    pub persistent_approval: Option<bool>,
7471    #[serde(default, skip_serializing_if = "Option::is_none")]
7472    pub uploads: Option<AllowDenyRequirement>,
7473}
7474
7475/// Per-origin browser-use policy (config side, snake_case wire).
7476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7477pub struct BrowserUseOriginPolicyConfig {
7478    #[serde(default, skip_serializing_if = "Option::is_none")]
7479    pub access: Option<AllowDenyRequirement>,
7480    #[serde(default, skip_serializing_if = "Option::is_none")]
7481    pub downloads: Option<AllowDenyRequirement>,
7482    #[serde(default, skip_serializing_if = "Option::is_none")]
7483    pub full_cdp_access: Option<AllowDenyRequirement>,
7484    #[serde(default, skip_serializing_if = "Option::is_none")]
7485    pub uploads: Option<AllowDenyRequirement>,
7486}
7487
7488/// Browser-use configuration (config side, snake_case wire).
7489#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7490pub struct BrowserUseConfig {
7491    #[serde(default, skip_serializing_if = "Option::is_none")]
7492    pub allow_history_access: Option<bool>,
7493    #[serde(default, skip_serializing_if = "Option::is_none")]
7494    pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
7495    #[serde(default, skip_serializing_if = "Option::is_none")]
7496    pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
7497}
7498
7499/// Computer-use configuration (config side, snake_case wire).
7500#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7501pub struct ComputerUseConfig {
7502    #[serde(default, skip_serializing_if = "Option::is_none")]
7503    pub default_app_access: Option<AllowDenyRequirement>,
7504    #[serde(default, skip_serializing_if = "Option::is_none")]
7505    pub macos: Option<ComputerUseMacosConfig>,
7506    #[serde(default, skip_serializing_if = "Option::is_none")]
7507    pub windows: Option<ComputerUseWindowsConfig>,
7508}
7509
7510#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7511pub struct ComputerUseMacosConfig {
7512    #[serde(default, skip_serializing_if = "Option::is_none")]
7513    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7514}
7515
7516#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7517pub struct ComputerUseWindowsConfig {
7518    #[serde(default, skip_serializing_if = "Option::is_none")]
7519    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7520    #[serde(default, skip_serializing_if = "Option::is_none")]
7521    pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
7522}
7523
7524#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7525pub struct ComputerUseWindowsExeConfig {
7526    pub access: AllowDenyRequirement,
7527    #[serde(default, skip_serializing_if = "Option::is_none")]
7528    pub binary_name: Option<String>,
7529    #[serde(default)]
7530    pub product_name: String,
7531    #[serde(default)]
7532    pub publisher_name: String,
7533}
7534
7535/// Per-platform computer-use requirements (camelCase wire).
7536#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7537#[serde(rename_all = "camelCase")]
7538pub struct ComputerUseMacosRequirements {
7539    #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
7540    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7541}
7542
7543#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7544#[serde(rename_all = "camelCase")]
7545pub struct ComputerUseWindowsRequirements {
7546    #[serde(default, skip_serializing_if = "Option::is_none")]
7547    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7548    #[serde(default, skip_serializing_if = "Option::is_none")]
7549    pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
7550}
7551
7552#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7553#[serde(rename_all = "camelCase")]
7554pub struct ComputerUseWindowsExeRequirement {
7555    pub access: AllowDenyRequirement,
7556    #[serde(
7557        rename = "binaryName",
7558        default,
7559        skip_serializing_if = "Option::is_none"
7560    )]
7561    pub binary_name: Option<String>,
7562    #[serde(rename = "productName", default)]
7563    pub product_name: String,
7564    #[serde(rename = "publisherName", default)]
7565    pub publisher_name: String,
7566}
7567
7568#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7569pub enum SandboxMode {
7570    #[serde(rename = "read-only")]
7571    Read_only,
7572    #[serde(rename = "workspace-write")]
7573    Workspace_write,
7574    #[serde(rename = "danger-full-access")]
7575    Danger_full_access,
7576}
7577
7578#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7579#[serde(tag = "type", rename_all = "camelCase")]
7580pub enum SandboxPolicy {
7581    #[serde(rename = "dangerFullAccess")]
7582    DangerFullAccess,
7583    #[serde(rename = "readOnly")]
7584    ReadOnly {
7585        #[serde(
7586            rename = "networkAccess",
7587            default,
7588            skip_serializing_if = "Option::is_none"
7589        )]
7590        network_access: Option<bool>,
7591    },
7592    #[serde(rename = "externalSandbox")]
7593    ExternalSandbox {
7594        #[serde(
7595            rename = "networkAccess",
7596            default,
7597            skip_serializing_if = "Option::is_none"
7598        )]
7599        network_access: Option<Value>,
7600    },
7601    #[serde(rename = "workspaceWrite")]
7602    WorkspaceWrite {
7603        #[serde(
7604            rename = "excludeSlashTmp",
7605            default,
7606            skip_serializing_if = "Option::is_none"
7607        )]
7608        exclude_slash_tmp: Option<bool>,
7609        #[serde(
7610            rename = "excludeTmpdirEnvVar",
7611            default,
7612            skip_serializing_if = "Option::is_none"
7613        )]
7614        exclude_tmpdir_env_var: Option<bool>,
7615        #[serde(
7616            rename = "networkAccess",
7617            default,
7618            skip_serializing_if = "Option::is_none"
7619        )]
7620        network_access: Option<bool>,
7621        #[serde(
7622            rename = "writableRoots",
7623            default,
7624            skip_serializing_if = "Option::is_none"
7625        )]
7626        writable_roots: Option<Vec<AbsolutePathBuf>>,
7627    },
7628}
7629
7630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7631#[serde(rename_all = "snake_case")]
7632pub struct SandboxWorkspaceWrite {
7633    #[serde(default, skip_serializing_if = "Option::is_none")]
7634    pub exclude_slash_tmp: Option<bool>,
7635    #[serde(default, skip_serializing_if = "Option::is_none")]
7636    pub exclude_tmpdir_env_var: Option<bool>,
7637    #[serde(default, skip_serializing_if = "Option::is_none")]
7638    pub network_access: Option<bool>,
7639    #[serde(default, skip_serializing_if = "Option::is_none")]
7640    pub writable_roots: Option<Vec<String>>,
7641}
7642
7643#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7644#[serde(tag = "type", rename_all = "camelCase")]
7645pub enum ScheduledTaskSchedule {
7646    Hourly {
7647        #[serde(default, skip_serializing_if = "Option::is_none")]
7648        days: Option<Vec<ScheduledTaskWeekday>>,
7649        #[serde(rename = "intervalHours")]
7650        interval_hours: i64,
7651    },
7652    Daily {
7653        time: String,
7654    },
7655    Weekdays {
7656        time: String,
7657    },
7658    Weekly {
7659        days: Vec<ScheduledTaskWeekday>,
7660        time: String,
7661    },
7662}
7663
7664#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7665#[serde(rename_all = "camelCase")]
7666pub struct ScheduledTaskSummary {
7667    #[serde(default)]
7668    pub key: String,
7669    #[serde(default)]
7670    pub name: String,
7671    #[serde(default)]
7672    pub prompt: String,
7673    #[serde()]
7674    pub schedule: ScheduledTaskSchedule,
7675}
7676
7677#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7678pub enum ScheduledTaskWeekday {
7679    #[serde(rename = "MO")]
7680    MO,
7681    #[serde(rename = "TU")]
7682    TU,
7683    #[serde(rename = "WE")]
7684    WE,
7685    #[serde(rename = "TH")]
7686    TH,
7687    #[serde(rename = "FR")]
7688    FR,
7689    #[serde(rename = "SA")]
7690    SA,
7691    #[serde(rename = "SU")]
7692    SU,
7693}
7694
7695#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7696#[serde(rename_all = "camelCase")]
7697pub struct SendAddCreditsNudgeEmailParams {
7698    #[serde(rename = "creditType")]
7699    pub credit_type: AddCreditsNudgeCreditType,
7700}
7701
7702#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7703#[serde(rename_all = "camelCase")]
7704pub struct SendAddCreditsNudgeEmailResponse {
7705    #[serde()]
7706    pub status: AddCreditsNudgeEmailStatus,
7707}
7708
7709#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7710#[serde(rename_all = "camelCase")]
7711pub struct ServerRequestResolvedNotification {
7712    #[serde(rename = "requestId")]
7713    pub request_id: RequestId,
7714    #[serde(rename = "threadId", default)]
7715    pub thread_id: String,
7716}
7717
7718#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7719#[serde(rename_all = "camelCase")]
7720pub struct SessionMigration {
7721    #[serde(default)]
7722    pub cwd: String,
7723    #[serde(default)]
7724    pub path: String,
7725    #[serde(default, skip_serializing_if = "Option::is_none")]
7726    pub title: Option<String>,
7727}
7728
7729#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7730pub enum SessionSource {
7731    #[serde(rename = "cli")]
7732    Cli,
7733    #[serde(rename = "vscode")]
7734    Vscode,
7735    #[serde(rename = "exec")]
7736    Exec,
7737    #[serde(rename = "appServer")]
7738    AppServer,
7739    #[serde(rename = "unknown")]
7740    Unknown,
7741    #[serde(rename = "custom")]
7742    Custom(String),
7743    #[serde(rename = "subAgent")]
7744    SubAgent(SubAgentSource),
7745}
7746
7747#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7748#[serde(rename_all = "camelCase")]
7749pub struct Settings {
7750    #[serde(default, skip_serializing_if = "Option::is_none")]
7751    pub developer_instructions: Option<String>,
7752    #[serde(default)]
7753    pub model: String,
7754    #[serde(default, skip_serializing_if = "Option::is_none")]
7755    pub reasoning_effort: Option<ReasoningEffort>,
7756}
7757
7758#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7759#[serde(rename_all = "camelCase")]
7760pub struct SkillDependencies {
7761    #[serde(default)]
7762    pub tools: Vec<SkillToolDependency>,
7763}
7764
7765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7766#[serde(rename_all = "camelCase")]
7767pub struct SkillErrorInfo {
7768    #[serde(default)]
7769    pub message: String,
7770    #[serde(default)]
7771    pub path: String,
7772}
7773
7774#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7775#[serde(rename_all = "camelCase")]
7776pub struct SkillInterface {
7777    #[serde(
7778        rename = "brandColor",
7779        default,
7780        skip_serializing_if = "Option::is_none"
7781    )]
7782    pub brand_color: Option<String>,
7783    #[serde(
7784        rename = "defaultPrompt",
7785        default,
7786        skip_serializing_if = "Option::is_none"
7787    )]
7788    pub default_prompt: Option<String>,
7789    #[serde(
7790        rename = "displayName",
7791        default,
7792        skip_serializing_if = "Option::is_none"
7793    )]
7794    pub display_name: Option<String>,
7795    #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
7796    pub icon_large: Option<AbsolutePathBuf>,
7797    #[serde(
7798        rename = "iconLargeUrl",
7799        default,
7800        skip_serializing_if = "Option::is_none"
7801    )]
7802    pub icon_large_url: Option<String>,
7803    #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
7804    pub icon_small: Option<AbsolutePathBuf>,
7805    #[serde(
7806        rename = "iconSmallUrl",
7807        default,
7808        skip_serializing_if = "Option::is_none"
7809    )]
7810    pub icon_small_url: Option<String>,
7811    #[serde(
7812        rename = "shortDescription",
7813        default,
7814        skip_serializing_if = "Option::is_none"
7815    )]
7816    pub short_description: Option<String>,
7817}
7818
7819#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7820#[serde(rename_all = "camelCase")]
7821pub struct SkillMetadata {
7822    #[serde(default, skip_serializing_if = "Option::is_none")]
7823    pub dependencies: Option<SkillDependencies>,
7824    #[serde(default)]
7825    pub description: String,
7826    #[serde(default)]
7827    pub enabled: bool,
7828    #[serde(default, skip_serializing_if = "Option::is_none")]
7829    pub interface: Option<SkillInterface>,
7830    #[serde(default)]
7831    pub name: String,
7832    #[serde()]
7833    pub path: LegacyAppPathString,
7834    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7835    pub plugin_id: Option<String>,
7836    #[serde()]
7837    pub scope: SkillScope,
7838    #[serde(
7839        rename = "shortDescription",
7840        default,
7841        skip_serializing_if = "Option::is_none"
7842    )]
7843    pub short_description: Option<String>,
7844}
7845
7846#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7847#[serde(rename_all = "camelCase")]
7848pub struct SkillMigration {
7849    #[serde(default)]
7850    pub name: String,
7851}
7852
7853#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7854pub enum SkillScope {
7855    #[serde(rename = "user")]
7856    User,
7857    #[serde(rename = "repo")]
7858    Repo,
7859    #[serde(rename = "system")]
7860    System,
7861    #[serde(rename = "admin")]
7862    Admin,
7863}
7864
7865#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7866#[serde(rename_all = "camelCase")]
7867pub struct SkillSummary {
7868    #[serde(default)]
7869    pub description: String,
7870    #[serde(default)]
7871    pub enabled: bool,
7872    #[serde(default, skip_serializing_if = "Option::is_none")]
7873    pub interface: Option<SkillInterface>,
7874    #[serde(default)]
7875    pub name: String,
7876    #[serde(default, skip_serializing_if = "Option::is_none")]
7877    pub path: Option<LegacyAppPathString>,
7878    #[serde(
7879        rename = "shortDescription",
7880        default,
7881        skip_serializing_if = "Option::is_none"
7882    )]
7883    pub short_description: Option<String>,
7884}
7885
7886#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7887#[serde(rename_all = "camelCase")]
7888pub struct SkillToolDependency {
7889    #[serde(default, skip_serializing_if = "Option::is_none")]
7890    pub command: Option<String>,
7891    #[serde(default, skip_serializing_if = "Option::is_none")]
7892    pub description: Option<String>,
7893    #[serde(default, skip_serializing_if = "Option::is_none")]
7894    pub transport: Option<String>,
7895    #[serde(rename = "type", default)]
7896    pub type_: String,
7897    #[serde(default, skip_serializing_if = "Option::is_none")]
7898    pub url: Option<String>,
7899    #[serde(default)]
7900    pub value: String,
7901}
7902
7903#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7904#[serde(rename_all = "camelCase")]
7905pub struct SkillsChangedNotification {
7906    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7907    pub extra: serde_json::Map<String, Value>,
7908}
7909
7910#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7911#[serde(rename_all = "camelCase")]
7912pub struct SkillsConfigWriteParams {
7913    #[serde(default)]
7914    pub enabled: bool,
7915    #[serde(default, skip_serializing_if = "Option::is_none")]
7916    pub name: Option<String>,
7917    #[serde(default, skip_serializing_if = "Option::is_none")]
7918    pub path: Option<AbsolutePathBuf>,
7919}
7920
7921#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7922#[serde(rename_all = "camelCase")]
7923pub struct SkillsConfigWriteResponse {
7924    #[serde(rename = "effectiveEnabled", default)]
7925    pub effective_enabled: bool,
7926}
7927
7928#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7929#[serde(rename_all = "camelCase")]
7930pub struct SkillsExtraRootsSetParams {
7931    #[serde(rename = "extraRoots", default)]
7932    pub extra_roots: Vec<AbsolutePathBuf>,
7933}
7934
7935#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7936#[serde(rename_all = "camelCase")]
7937pub struct SkillsExtraRootsSetResponse {
7938    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7939    pub extra: serde_json::Map<String, Value>,
7940}
7941
7942#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7943#[serde(rename_all = "camelCase")]
7944pub struct SkillsListEntry {
7945    #[serde(default)]
7946    pub cwd: String,
7947    #[serde(default)]
7948    pub errors: Vec<SkillErrorInfo>,
7949    #[serde(default)]
7950    pub skills: Vec<SkillMetadata>,
7951}
7952
7953#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7954#[serde(rename_all = "camelCase")]
7955pub struct SkillsListParams {
7956    #[serde(default, skip_serializing_if = "Option::is_none")]
7957    pub cwds: Option<Vec<String>>,
7958    #[serde(
7959        rename = "forceReload",
7960        default,
7961        skip_serializing_if = "Option::is_none"
7962    )]
7963    pub force_reload: Option<bool>,
7964}
7965
7966#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7967#[serde(rename_all = "camelCase")]
7968pub struct SkillsListResponse {
7969    #[serde(default)]
7970    pub data: Vec<SkillsListEntry>,
7971}
7972
7973#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7974pub enum SortDirection {
7975    #[serde(rename = "asc")]
7976    Asc,
7977    #[serde(rename = "desc")]
7978    Desc,
7979}
7980
7981#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7982#[serde(rename_all = "camelCase")]
7983pub struct SpendControlLimitSnapshot {
7984    #[serde(default)]
7985    pub limit: String,
7986    #[serde(rename = "remainingPercent", default)]
7987    pub remaining_percent: i64,
7988    #[serde(rename = "resetsAt", default)]
7989    pub resets_at: i64,
7990    #[serde(default)]
7991    pub used: String,
7992}
7993
7994#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7995pub enum SubAgentActivityKind {
7996    #[serde(rename = "started")]
7997    Started,
7998    #[serde(rename = "interacted")]
7999    Interacted,
8000    #[serde(rename = "interrupted")]
8001    Interrupted,
8002    #[serde(rename = "completed")]
8003    Completed,
8004}
8005
8006#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
8007pub enum SubAgentSource {
8008    #[serde(rename = "review")]
8009    Review,
8010    #[serde(rename = "compact")]
8011    Compact,
8012    #[serde(rename = "memory_consolidation")]
8013    MemoryConsolidation,
8014    #[serde(rename = "thread_spawn")]
8015    ThreadSpawn {
8016        #[serde(default, skip_serializing_if = "Option::is_none")]
8017        agent_nickname: Option<String>,
8018        #[serde(default, skip_serializing_if = "Option::is_none")]
8019        agent_path: Option<AgentPath>,
8020        #[serde(default, skip_serializing_if = "Option::is_none")]
8021        agent_role: Option<String>,
8022        depth: i64,
8023        parent_thread_id: ThreadId,
8024    },
8025    #[serde(rename = "other")]
8026    Other(String),
8027}
8028
8029#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8030#[serde(rename_all = "camelCase")]
8031pub struct SubagentMigration {
8032    #[serde(default)]
8033    pub name: String,
8034}
8035
8036#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8037#[serde(rename_all = "camelCase")]
8038pub struct TerminalInteractionNotification {
8039    #[serde(rename = "itemId", default)]
8040    pub item_id: String,
8041    #[serde(rename = "processId", default)]
8042    pub process_id: String,
8043    #[serde(default)]
8044    pub stdin: String,
8045    #[serde(rename = "threadId", default)]
8046    pub thread_id: String,
8047    #[serde(rename = "turnId", default)]
8048    pub turn_id: String,
8049}
8050
8051#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8052#[serde(rename_all = "camelCase")]
8053pub struct TextElement {
8054    #[serde(rename = "byteRange", default)]
8055    pub byte_range: Value,
8056    #[serde(default, skip_serializing_if = "Option::is_none")]
8057    pub placeholder: Option<String>,
8058}
8059
8060#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8061#[serde(rename_all = "camelCase")]
8062pub struct TextPosition {
8063    #[serde(default)]
8064    pub column: i64,
8065    #[serde(default)]
8066    pub line: i64,
8067}
8068
8069#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8070#[serde(rename_all = "camelCase")]
8071pub struct TextRange {
8072    #[serde()]
8073    pub end: TextPosition,
8074    #[serde()]
8075    pub start: TextPosition,
8076}
8077
8078#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8079#[serde(rename_all = "camelCase")]
8080pub struct Thread {
8081    #[serde(
8082        rename = "agentNickname",
8083        default,
8084        skip_serializing_if = "Option::is_none"
8085    )]
8086    pub agent_nickname: Option<String>,
8087    #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
8088    pub agent_role: Option<String>,
8089    #[serde(rename = "cliVersion", default)]
8090    pub cli_version: String,
8091    #[serde(rename = "createdAt", default)]
8092    pub created_at: i64,
8093    #[serde(default)]
8094    pub cwd: Value,
8095    #[serde(default)]
8096    pub ephemeral: bool,
8097    #[serde(
8098        rename = "forkedFromId",
8099        default,
8100        skip_serializing_if = "Option::is_none"
8101    )]
8102    pub forked_from_id: Option<String>,
8103    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
8104    pub git_info: Option<GitInfo>,
8105    /// Persisted history contract chosen at thread creation (0.148 upstream);
8106    /// absent on older servers, which are always `legacy`.
8107    #[serde(
8108        rename = "historyMode",
8109        default,
8110        skip_serializing_if = "Option::is_none"
8111    )]
8112    pub history_mode: Option<ThreadHistoryMode>,
8113    /// Canonical project assignment owned by app-server, if any. Required
8114    /// upstream from 0.147 but kept tolerant for pre-project servers.
8115    #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
8116    pub project_id: Option<String>,
8117    #[serde(default)]
8118    pub id: String,
8119    /// Current configured model when loaded, otherwise the latest persisted
8120    /// model. Null when unavailable. Not per-turn execution telemetry.
8121    #[serde(default, skip_serializing_if = "Option::is_none")]
8122    pub model: Option<String>,
8123    #[serde(rename = "modelProvider", default)]
8124    pub model_provider: String,
8125    #[serde(default, skip_serializing_if = "Option::is_none")]
8126    pub name: Option<String>,
8127    /// Originator recorded when the thread was created, independent of its
8128    /// current client or executor. `None` when the recorded originator is
8129    /// unavailable.
8130    #[serde(default, skip_serializing_if = "Option::is_none")]
8131    pub originator: Option<String>,
8132    #[serde(
8133        rename = "parentThreadId",
8134        default,
8135        skip_serializing_if = "Option::is_none"
8136    )]
8137    pub parent_thread_id: Option<String>,
8138    #[serde(default, skip_serializing_if = "Option::is_none")]
8139    pub path: Option<String>,
8140    #[serde(default)]
8141    pub preview: String,
8142    /// Current configured reasoning effort when loaded, otherwise the latest
8143    /// persisted effort. Null when unset or unavailable. Not per-turn
8144    /// execution telemetry.
8145    #[serde(
8146        rename = "reasoningEffort",
8147        default,
8148        skip_serializing_if = "Option::is_none"
8149    )]
8150    pub reasoning_effort: Option<ReasoningEffort>,
8151    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
8152    pub recency_at: Option<i64>,
8153    #[serde(default, skip_serializing_if = "Option::is_none")]
8154    pub section: Option<ThreadSection>,
8155    #[serde(
8156        rename = "sectionEnteredAt",
8157        default,
8158        skip_serializing_if = "Option::is_none"
8159    )]
8160    pub section_entered_at: Option<i64>,
8161    #[serde(rename = "sessionId", default)]
8162    pub session_id: String,
8163    #[serde(default)]
8164    pub source: Value,
8165    #[serde(default)]
8166    pub status: Value,
8167    #[serde(
8168        rename = "threadSource",
8169        default,
8170        skip_serializing_if = "Option::is_none"
8171    )]
8172    pub thread_source: Option<ThreadSource>,
8173    #[serde(default)]
8174    pub turns: Vec<Turn>,
8175    #[serde(rename = "updatedAt", default)]
8176    pub updated_at: i64,
8177}
8178
8179#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8180pub enum ThreadActiveFlag {
8181    #[serde(rename = "waitingOnApproval")]
8182    WaitingOnApproval,
8183    #[serde(rename = "waitingOnUserInput")]
8184    WaitingOnUserInput,
8185}
8186
8187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8188#[serde(rename_all = "camelCase")]
8189pub struct ThreadApproveGuardianDeniedActionParams {
8190    #[serde(default)]
8191    pub event: Value,
8192    #[serde(rename = "threadId", default)]
8193    pub thread_id: String,
8194}
8195
8196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8197#[serde(rename_all = "camelCase")]
8198pub struct ThreadApproveGuardianDeniedActionResponse {
8199    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8200    pub extra: serde_json::Map<String, Value>,
8201}
8202
8203#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8204#[serde(rename_all = "camelCase")]
8205pub struct ThreadArchiveParams {
8206    #[serde(rename = "threadId", default)]
8207    pub thread_id: String,
8208}
8209
8210#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8211#[serde(rename_all = "camelCase")]
8212pub struct ThreadArchiveResponse {
8213    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8214    pub extra: serde_json::Map<String, Value>,
8215}
8216
8217#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8218#[serde(rename_all = "camelCase")]
8219pub struct ThreadArchivedNotification {
8220    #[serde(rename = "threadId", default)]
8221    pub thread_id: String,
8222}
8223
8224/// An independently persisted attachment associated with a thread.
8225#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8226#[serde(rename_all = "camelCase")]
8227pub struct ThreadAttachment {
8228    #[serde(rename = "attachmentType", default)]
8229    pub attachment_type: String,
8230    #[serde(rename = "createdAt", default)]
8231    pub created_at: i64,
8232    #[serde(default)]
8233    pub id: String,
8234    #[serde(rename = "identityKey", default)]
8235    pub identity_key: String,
8236    #[serde(default)]
8237    pub payload: Value,
8238}
8239
8240/// Result of attempting to associate an attachment with a thread.
8241#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8242pub enum ThreadAttachmentAddOutcome {
8243    #[serde(rename = "created")]
8244    Created,
8245    #[serde(rename = "existing")]
8246    Existing,
8247}
8248
8249/// Parameters for creating or locating an attachment on its owning thread.
8250#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8251#[serde(rename_all = "camelCase")]
8252pub struct ThreadAttachmentAddParams {
8253    #[serde(rename = "attachmentType", default)]
8254    pub attachment_type: String,
8255    #[serde(rename = "identityKey", default)]
8256    pub identity_key: String,
8257    #[serde(default)]
8258    pub payload: Value,
8259    #[serde(rename = "threadId", default)]
8260    pub thread_id: String,
8261}
8262
8263/// The created or existing attachment.
8264#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8265#[serde(rename_all = "camelCase")]
8266pub struct ThreadAttachmentAddResponse {
8267    pub attachment: ThreadAttachment,
8268    pub outcome: ThreadAttachmentAddOutcome,
8269}
8270
8271/// Parameters for listing attachments from one thread.
8272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8273#[serde(rename_all = "camelCase")]
8274pub struct ThreadAttachmentListParams {
8275    #[serde(default, skip_serializing_if = "Option::is_none")]
8276    pub cursor: Option<String>,
8277    #[serde(default, skip_serializing_if = "Option::is_none")]
8278    pub limit: Option<i64>,
8279    #[serde(rename = "threadId", default)]
8280    pub thread_id: String,
8281}
8282
8283/// One page of attachments associated with the requested thread.
8284#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8285#[serde(rename_all = "camelCase")]
8286pub struct ThreadAttachmentListResponse {
8287    #[serde(default)]
8288    pub data: Vec<ThreadAttachment>,
8289    #[serde(
8290        rename = "nextCursor",
8291        default,
8292        skip_serializing_if = "Option::is_none"
8293    )]
8294    pub next_cursor: Option<String>,
8295}
8296
8297/// The persisted attachment change represented by a notification.
8298#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8299pub enum ThreadAttachmentOperation {
8300    #[serde(rename = "created")]
8301    Created,
8302    #[serde(rename = "deleted")]
8303    Deleted,
8304}
8305
8306/// A thread that currently owns an attachment with the requested identity.
8307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8308#[serde(rename_all = "camelCase")]
8309pub struct ThreadAttachmentOwner {
8310    /// Whether the owning thread is archived, not whether it is currently executing a turn.
8311    #[serde(default)]
8312    pub archived: bool,
8313    #[serde(rename = "threadId", default)]
8314    pub thread_id: String,
8315}
8316
8317/// Parameters for reverse lookup by attachment identity within this server's store.
8318#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8319#[serde(rename_all = "camelCase")]
8320pub struct ThreadAttachmentOwnerListParams {
8321    /// Omitted or null returns all matches; false returns non-archived threads only.
8322    #[serde(default, skip_serializing_if = "Option::is_none")]
8323    pub archived: Option<bool>,
8324    #[serde(rename = "attachmentType", default)]
8325    pub attachment_type: String,
8326    #[serde(default, skip_serializing_if = "Option::is_none")]
8327    pub cursor: Option<String>,
8328    #[serde(rename = "identityKey", default)]
8329    pub identity_key: String,
8330    #[serde(default, skip_serializing_if = "Option::is_none")]
8331    pub limit: Option<i64>,
8332}
8333
8334/// One page of matching owners, including threads without their own user messages.
8335#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8336#[serde(rename_all = "camelCase")]
8337pub struct ThreadAttachmentOwnerListResponse {
8338    #[serde(default)]
8339    pub data: Vec<ThreadAttachmentOwner>,
8340    #[serde(
8341        rename = "nextCursor",
8342        default,
8343        skip_serializing_if = "Option::is_none"
8344    )]
8345    pub next_cursor: Option<String>,
8346}
8347
8348/// Parameters for deleting an attachment by its stable thread-local identity.
8349#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8350#[serde(rename_all = "camelCase")]
8351pub struct ThreadAttachmentRemoveParams {
8352    #[serde(rename = "attachmentType", default)]
8353    pub attachment_type: String,
8354    #[serde(rename = "identityKey", default)]
8355    pub identity_key: String,
8356    #[serde(rename = "threadId", default)]
8357    pub thread_id: String,
8358}
8359
8360/// Successful deletion does not return additional attachment data.
8361#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8362#[serde(rename_all = "camelCase")]
8363pub struct ThreadAttachmentRemoveResponse {
8364    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8365    pub extra: serde_json::Map<String, Value>,
8366}
8367
8368/// Notification published after a thread attachment is created or deleted.
8369#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8370#[serde(rename_all = "camelCase")]
8371pub struct ThreadAttachmentUpdatedNotification {
8372    #[serde(rename = "attachmentId", default)]
8373    pub attachment_id: String,
8374    #[serde(rename = "attachmentType", default)]
8375    pub attachment_type: String,
8376    #[serde(rename = "identityKey", default)]
8377    pub identity_key: String,
8378    pub operation: ThreadAttachmentOperation,
8379    #[serde(rename = "threadId", default)]
8380    pub thread_id: String,
8381}
8382
8383#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8384#[serde(rename_all = "camelCase")]
8385pub struct ThreadClosedNotification {
8386    #[serde(rename = "threadId", default)]
8387    pub thread_id: String,
8388}
8389
8390#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8391#[serde(rename_all = "camelCase")]
8392pub struct ThreadCompactStartParams {
8393    #[serde(rename = "threadId", default)]
8394    pub thread_id: String,
8395}
8396
8397#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8398#[serde(rename_all = "camelCase")]
8399pub struct ThreadCompactStartResponse {
8400    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8401    pub extra: serde_json::Map<String, Value>,
8402}
8403
8404#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8405#[serde(rename_all = "camelCase")]
8406pub struct ThreadDeleteParams {
8407    #[serde(rename = "threadId", default)]
8408    pub thread_id: String,
8409}
8410
8411#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8412#[serde(rename_all = "camelCase")]
8413pub struct ThreadDeleteResponse {
8414    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8415    pub extra: serde_json::Map<String, Value>,
8416}
8417
8418#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8419#[serde(rename_all = "camelCase")]
8420pub struct ThreadDeletedNotification {
8421    #[serde(rename = "threadId", default)]
8422    pub thread_id: String,
8423}
8424
8425#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8426#[serde(rename_all = "camelCase")]
8427pub struct ThreadForkParams {
8428    #[serde(
8429        rename = "approvalPolicy",
8430        default,
8431        skip_serializing_if = "Option::is_none"
8432    )]
8433    pub approval_policy: Option<AskForApproval>,
8434    #[serde(
8435        rename = "approvalsReviewer",
8436        default,
8437        skip_serializing_if = "Option::is_none"
8438    )]
8439    pub approvals_reviewer: Option<ApprovalsReviewer>,
8440    #[serde(
8441        rename = "baseInstructions",
8442        default,
8443        skip_serializing_if = "Option::is_none"
8444    )]
8445    pub base_instructions: Option<String>,
8446    #[serde(default, skip_serializing_if = "Option::is_none")]
8447    pub config: Option<Value>,
8448    #[serde(default, skip_serializing_if = "Option::is_none")]
8449    pub cwd: Option<String>,
8450    #[serde(
8451        rename = "developerInstructions",
8452        default,
8453        skip_serializing_if = "Option::is_none"
8454    )]
8455    pub developer_instructions: Option<String>,
8456    #[serde(default, skip_serializing_if = "Option::is_none")]
8457    pub ephemeral: Option<bool>,
8458    #[serde(
8459        rename = "excludeTurns",
8460        default,
8461        skip_serializing_if = "Option::is_none"
8462    )]
8463    pub exclude_turns: Option<bool>,
8464    #[serde(
8465        rename = "lastTurnId",
8466        default,
8467        skip_serializing_if = "Option::is_none"
8468    )]
8469    pub last_turn_id: Option<String>,
8470    #[serde(default, skip_serializing_if = "Option::is_none")]
8471    pub model: Option<String>,
8472    #[serde(
8473        rename = "modelProvider",
8474        default,
8475        skip_serializing_if = "Option::is_none"
8476    )]
8477    pub model_provider: Option<String>,
8478    #[serde(default, skip_serializing_if = "Option::is_none")]
8479    pub sandbox: Option<SandboxMode>,
8480    #[serde(
8481        rename = "serviceTier",
8482        default,
8483        skip_serializing_if = "Option::is_none"
8484    )]
8485    pub service_tier: Option<String>,
8486    #[serde(rename = "threadId", default)]
8487    pub thread_id: String,
8488    #[serde(
8489        rename = "threadSource",
8490        default,
8491        skip_serializing_if = "Option::is_none"
8492    )]
8493    pub thread_source: Option<ThreadSource>,
8494}
8495
8496#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8497#[serde(rename_all = "camelCase")]
8498pub struct ThreadForkResponse {
8499    #[serde(rename = "approvalPolicy")]
8500    pub approval_policy: AskForApproval,
8501    #[serde(rename = "approvalsReviewer", default)]
8502    pub approvals_reviewer: Value,
8503    #[serde()]
8504    pub cwd: AbsolutePathBuf,
8505    /// Saved list of disabled plugin IDs. Does not yet filter plugin
8506    /// capabilities.
8507    #[serde(rename = "disabledPluginIds", default)]
8508    pub disabled_plugin_ids: Vec<String>,
8509    #[serde(
8510        rename = "instructionSources",
8511        default,
8512        skip_serializing_if = "Option::is_none"
8513    )]
8514    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8515    #[serde(default)]
8516    pub model: String,
8517    #[serde(rename = "modelProvider", default)]
8518    pub model_provider: String,
8519    #[serde(
8520        rename = "reasoningEffort",
8521        default,
8522        skip_serializing_if = "Option::is_none"
8523    )]
8524    pub reasoning_effort: Option<ReasoningEffort>,
8525    #[serde(default)]
8526    pub sandbox: Value,
8527    #[serde(
8528        rename = "serviceTier",
8529        default,
8530        skip_serializing_if = "Option::is_none"
8531    )]
8532    pub service_tier: Option<String>,
8533    #[serde()]
8534    pub thread: Thread,
8535}
8536
8537#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8538#[serde(rename_all = "camelCase")]
8539pub struct ThreadGoal {
8540    #[serde(rename = "createdAt", default)]
8541    pub created_at: i64,
8542    #[serde(default)]
8543    pub objective: String,
8544    #[serde()]
8545    pub status: ThreadGoalStatus,
8546    #[serde(rename = "threadId", default)]
8547    pub thread_id: String,
8548    #[serde(rename = "timeUsedSeconds", default)]
8549    pub time_used_seconds: i64,
8550    #[serde(
8551        rename = "tokenBudget",
8552        default,
8553        skip_serializing_if = "Option::is_none"
8554    )]
8555    pub token_budget: Option<i64>,
8556    #[serde(rename = "tokensUsed", default)]
8557    pub tokens_used: i64,
8558    #[serde(rename = "updatedAt", default)]
8559    pub updated_at: i64,
8560}
8561
8562#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8563#[serde(rename_all = "camelCase")]
8564pub struct ThreadGoalClearParams {
8565    /// Missing provenance does not supply user authorization.
8566    #[serde(default, skip_serializing_if = "Option::is_none")]
8567    pub origin: Option<ThreadGoalMutationOrigin>,
8568    #[serde(rename = "threadId", default)]
8569    pub thread_id: String,
8570}
8571
8572#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8573#[serde(rename_all = "camelCase")]
8574pub struct ThreadGoalClearResponse {
8575    #[serde(default)]
8576    pub cleared: bool,
8577}
8578
8579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8580#[serde(rename_all = "camelCase")]
8581pub struct ThreadGoalClearedNotification {
8582    #[serde(rename = "threadId", default)]
8583    pub thread_id: String,
8584}
8585
8586#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8587#[serde(rename_all = "camelCase")]
8588pub struct ThreadGoalGetParams {
8589    #[serde(rename = "threadId", default)]
8590    pub thread_id: String,
8591}
8592
8593#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8594#[serde(rename_all = "camelCase")]
8595pub struct ThreadGoalGetResponse {
8596    #[serde(default, skip_serializing_if = "Option::is_none")]
8597    pub goal: Option<ThreadGoal>,
8598}
8599
8600/// Distinguishes explicit user actions from automatic goal lifecycle mutations.
8601#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8602pub enum ThreadGoalMutationOrigin {
8603    #[serde(rename = "user")]
8604    User,
8605    #[serde(rename = "automatic")]
8606    Automatic,
8607}
8608
8609#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8610#[serde(rename_all = "camelCase")]
8611pub struct ThreadGoalSetParams {
8612    #[serde(default, skip_serializing_if = "Option::is_none")]
8613    pub objective: Option<String>,
8614    /// Missing provenance does not supply user authorization.
8615    #[serde(default, skip_serializing_if = "Option::is_none")]
8616    pub origin: Option<ThreadGoalMutationOrigin>,
8617    #[serde(default, skip_serializing_if = "Option::is_none")]
8618    pub status: Option<ThreadGoalStatus>,
8619    #[serde(rename = "threadId", default)]
8620    pub thread_id: String,
8621    #[serde(
8622        rename = "tokenBudget",
8623        default,
8624        skip_serializing_if = "Option::is_none"
8625    )]
8626    pub token_budget: Option<i64>,
8627}
8628
8629#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8630#[serde(rename_all = "camelCase")]
8631pub struct ThreadGoalSetResponse {
8632    #[serde()]
8633    pub goal: ThreadGoal,
8634}
8635
8636#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8637pub enum ThreadGoalStatus {
8638    #[serde(rename = "active")]
8639    Active,
8640    #[serde(rename = "paused")]
8641    Paused,
8642    #[serde(rename = "blocked")]
8643    Blocked,
8644    #[serde(rename = "usageLimited")]
8645    UsageLimited,
8646    #[serde(rename = "budgetLimited")]
8647    BudgetLimited,
8648    #[serde(rename = "complete")]
8649    Complete,
8650}
8651
8652#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8653#[serde(rename_all = "camelCase")]
8654pub struct ThreadGoalUpdatedNotification {
8655    #[serde()]
8656    pub goal: ThreadGoal,
8657    #[serde(rename = "threadId", default)]
8658    pub thread_id: String,
8659    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8660    pub turn_id: Option<String>,
8661}
8662
8663#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
8664#[serde(transparent)]
8665pub struct ThreadId(pub String);
8666
8667#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8668#[serde(rename_all = "camelCase")]
8669pub struct ThreadInjectItemsParams {
8670    #[serde(default)]
8671    pub items: Vec<Value>,
8672    #[serde(rename = "threadId", default)]
8673    pub thread_id: String,
8674}
8675
8676#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8677#[serde(rename_all = "camelCase")]
8678pub struct ThreadInjectItemsResponse {
8679    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8680    pub extra: serde_json::Map<String, Value>,
8681}
8682
8683/// A thread item and its recorded lifecycle times. The payload stays flat on the wire.
8684#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8685#[serde(rename_all = "camelCase")]
8686pub struct ThreadItem {
8687    #[serde(flatten)]
8688    pub payload: ThreadItemPayload,
8689    /// Unix timestamp in milliseconds when the item started, if recorded.
8690    #[serde(
8691        rename = "startedAtMs",
8692        default,
8693        skip_serializing_if = "Option::is_none"
8694    )]
8695    pub started_at_ms: Option<i64>,
8696    /// Unix timestamp in milliseconds when the item completed, if recorded.
8697    #[serde(
8698        rename = "completedAtMs",
8699        default,
8700        skip_serializing_if = "Option::is_none"
8701    )]
8702    pub completed_at_ms: Option<i64>,
8703}
8704
8705impl ThreadItem {
8706    /// Creates an item with no recorded start or completion time.
8707    pub fn untimed(payload: ThreadItemPayload) -> Self {
8708        Self {
8709            payload,
8710            started_at_ms: None,
8711            completed_at_ms: None,
8712        }
8713    }
8714}
8715
8716impl From<ThreadItemPayload> for ThreadItem {
8717    fn from(payload: ThreadItemPayload) -> Self {
8718        Self::untimed(payload)
8719    }
8720}
8721
8722/// The type-tagged body of a [`ThreadItem`], flattened into it on the wire.
8723#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8724#[serde(tag = "type", rename_all = "camelCase")]
8725pub enum ThreadItemPayload {
8726    #[serde(rename = "userMessage")]
8727    UserMessage {
8728        #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
8729        client_id: Option<String>,
8730        content: Vec<UserInput>,
8731        id: String,
8732    },
8733    #[serde(rename = "hookPrompt")]
8734    HookPrompt {
8735        fragments: Vec<HookPromptFragment>,
8736        id: String,
8737    },
8738    #[serde(rename = "agentMessage")]
8739    AgentMessage {
8740        #[serde(default, skip_serializing_if = "Option::is_none")]
8741        delivery: Option<AgentMessageDelivery>,
8742        id: String,
8743        #[serde(
8744            rename = "memoryCitation",
8745            default,
8746            skip_serializing_if = "Option::is_none"
8747        )]
8748        memory_citation: Option<MemoryCitation>,
8749        #[serde(default, skip_serializing_if = "Option::is_none")]
8750        moderation: Option<AgentMessageModeration>,
8751        #[serde(default, skip_serializing_if = "Option::is_none")]
8752        phase: Option<MessagePhase>,
8753        #[serde(default, skip_serializing_if = "Option::is_none")]
8754        questions: Option<Vec<AsyncUserInputQuestion>>,
8755        text: String,
8756    },
8757    Plan {
8758        id: String,
8759        text: String,
8760    },
8761    Reasoning {
8762        #[serde(default, skip_serializing_if = "Option::is_none")]
8763        content: Option<Vec<String>>,
8764        id: String,
8765        #[serde(default, skip_serializing_if = "Option::is_none")]
8766        summary: Option<Vec<String>>,
8767    },
8768    #[serde(rename = "commandExecution")]
8769    CommandExecution {
8770        #[serde(
8771            rename = "aggregatedOutput",
8772            default,
8773            skip_serializing_if = "Option::is_none"
8774        )]
8775        aggregated_output: Option<String>,
8776        command: String,
8777        #[serde(rename = "commandActions")]
8778        command_actions: Vec<CommandAction>,
8779        cwd: Value,
8780        #[serde(
8781            rename = "durationMs",
8782            default,
8783            skip_serializing_if = "Option::is_none"
8784        )]
8785        duration_ms: Option<i64>,
8786        #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
8787        exit_code: Option<i64>,
8788        id: String,
8789        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8790        plugin_id: Option<String>,
8791        #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
8792        process_id: Option<String>,
8793        #[serde(
8794            rename = "scriptPath",
8795            default,
8796            skip_serializing_if = "Option::is_none"
8797        )]
8798        script_path: Option<String>,
8799        #[serde(default, skip_serializing_if = "Option::is_none")]
8800        source: Option<Value>,
8801        status: CommandExecutionStatus,
8802    },
8803    #[serde(rename = "fileChange")]
8804    FileChange {
8805        changes: Vec<FileUpdateChange>,
8806        id: String,
8807        status: PatchApplyStatus,
8808    },
8809    #[serde(rename = "mcpToolCall")]
8810    McpToolCall {
8811        #[serde(
8812            rename = "appContext",
8813            default,
8814            skip_serializing_if = "Option::is_none"
8815        )]
8816        app_context: Option<McpToolCallAppContext>,
8817        arguments: Value,
8818        #[serde(
8819            rename = "durationMs",
8820            default,
8821            skip_serializing_if = "Option::is_none"
8822        )]
8823        duration_ms: Option<i64>,
8824        /// Registration scope, not necessarily the server's execution
8825        /// environment.
8826        #[serde(
8827            rename = "environmentId",
8828            default,
8829            skip_serializing_if = "Option::is_none"
8830        )]
8831        environment_id: Option<String>,
8832        #[serde(default, skip_serializing_if = "Option::is_none")]
8833        error: Option<McpToolCallError>,
8834        id: String,
8835        /// Legacy compatibility field; prefer `mcp_app_ui.resource_uri` when
8836        /// available.
8837        #[serde(
8838            rename = "mcpAppResourceUri",
8839            default,
8840            skip_serializing_if = "Option::is_none"
8841        )]
8842        mcp_app_resource_uri: Option<String>,
8843        /// Presentation captured from the invoked descriptor; absent in
8844        /// older history.
8845        #[serde(rename = "mcpAppUi", default, skip_serializing_if = "Option::is_none")]
8846        mcp_app_ui: Option<McpAppUi>,
8847        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8848        plugin_id: Option<String>,
8849        #[serde(
8850            rename = "readOnlyHint",
8851            default,
8852            skip_serializing_if = "Option::is_none"
8853        )]
8854        read_only_hint: Option<bool>,
8855        #[serde(default, skip_serializing_if = "Option::is_none")]
8856        result: Option<McpToolCallResult>,
8857        server: String,
8858        status: McpToolCallStatus,
8859        tool: String,
8860    },
8861    #[serde(rename = "dynamicToolCall")]
8862    DynamicToolCall {
8863        arguments: Value,
8864        #[serde(
8865            rename = "contentItems",
8866            default,
8867            skip_serializing_if = "Option::is_none"
8868        )]
8869        content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
8870        #[serde(
8871            rename = "durationMs",
8872            default,
8873            skip_serializing_if = "Option::is_none"
8874        )]
8875        duration_ms: Option<i64>,
8876        id: String,
8877        #[serde(default, skip_serializing_if = "Option::is_none")]
8878        namespace: Option<String>,
8879        status: DynamicToolCallStatus,
8880        #[serde(default, skip_serializing_if = "Option::is_none")]
8881        success: Option<bool>,
8882        tool: String,
8883    },
8884    #[serde(rename = "collabAgentToolCall")]
8885    CollabAgentToolCall {
8886        #[serde(rename = "agentsStates")]
8887        agents_states: std::collections::BTreeMap<String, CollabAgentState>,
8888        id: String,
8889        #[serde(default, skip_serializing_if = "Option::is_none")]
8890        model: Option<String>,
8891        #[serde(default, skip_serializing_if = "Option::is_none")]
8892        prompt: Option<String>,
8893        #[serde(
8894            rename = "reasoningEffort",
8895            default,
8896            skip_serializing_if = "Option::is_none"
8897        )]
8898        reasoning_effort: Option<ReasoningEffort>,
8899        #[serde(rename = "receiverThreadIds")]
8900        receiver_thread_ids: Vec<String>,
8901        #[serde(rename = "senderThreadId")]
8902        sender_thread_id: String,
8903        status: Value,
8904        tool: Value,
8905    },
8906    #[serde(rename = "subAgentActivity")]
8907    SubAgentActivity {
8908        #[serde(rename = "agentPath")]
8909        agent_path: String,
8910        #[serde(rename = "agentThreadId")]
8911        agent_thread_id: String,
8912        id: String,
8913        kind: SubAgentActivityKind,
8914        /// Resolved model at sub-agent creation; absent from older records
8915        /// and other activities.
8916        #[serde(default, skip_serializing_if = "Option::is_none")]
8917        model: Option<String>,
8918        /// Resolved reasoning effort at sub-agent creation, when known.
8919        #[serde(
8920            rename = "reasoningEffort",
8921            default,
8922            skip_serializing_if = "Option::is_none"
8923        )]
8924        reasoning_effort: Option<ReasoningEffort>,
8925    },
8926    #[serde(rename = "webSearch")]
8927    WebSearch {
8928        #[serde(default, skip_serializing_if = "Option::is_none")]
8929        action: Option<WebSearchAction>,
8930        id: String,
8931        query: String,
8932        #[serde(default, skip_serializing_if = "Option::is_none")]
8933        results: Option<Vec<Value>>,
8934    },
8935    #[serde(rename = "imageView")]
8936    ImageView {
8937        id: String,
8938        path: LegacyAppPathString,
8939    },
8940    Sleep {
8941        #[serde(rename = "durationMs")]
8942        duration_ms: i64,
8943        id: String,
8944    },
8945    #[serde(rename = "imageGeneration")]
8946    ImageGeneration {
8947        #[serde(default, skip_serializing_if = "Option::is_none")]
8948        failure: Option<ImageGenerationFailure>,
8949        /// Image generation identifier, when provided by the image backend.
8950        #[serde(
8951            rename = "generationId",
8952            default,
8953            skip_serializing_if = "Option::is_none"
8954        )]
8955        generation_id: Option<String>,
8956        id: String,
8957        #[serde(flatten)]
8958        image: GeneratedImageRef,
8959        /// Observed local inputs for a completed generation, absent on older items.
8960        #[serde(
8961            rename = "inputImages",
8962            default,
8963            skip_serializing_if = "Option::is_none"
8964        )]
8965        input_images: Option<Vec<ImageGenerationInputImage>>,
8966        #[serde(
8967            rename = "revisedPrompt",
8968            default,
8969            skip_serializing_if = "Option::is_none"
8970        )]
8971        revised_prompt: Option<String>,
8972        #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
8973        saved_path: Option<AbsolutePathBuf>,
8974        status: String,
8975        #[serde(
8976            rename = "transparentBackground",
8977            default,
8978            skip_serializing_if = "Option::is_none"
8979        )]
8980        transparent_background: Option<bool>,
8981    },
8982    #[serde(rename = "enteredReviewMode")]
8983    EnteredReviewMode {
8984        id: String,
8985        review: String,
8986    },
8987    #[serde(rename = "exitedReviewMode")]
8988    ExitedReviewMode {
8989        id: String,
8990        review: String,
8991    },
8992    #[serde(rename = "contextCompaction")]
8993    ContextCompaction {
8994        id: String,
8995    },
8996    #[serde(rename = "functionCallOutput")]
8997    FunctionCallOutput {
8998        id: String,
8999        name: String,
9000        #[serde(default, skip_serializing_if = "Option::is_none")]
9001        namespace: Option<String>,
9002        output: FunctionCallOutputBody,
9003    },
9004}
9005
9006#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9007#[serde(untagged)]
9008pub enum ThreadListCwdFilter {
9009    Variant0(String),
9010    Variant1(Vec<String>),
9011}
9012
9013#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9014#[serde(rename_all = "camelCase")]
9015pub struct ThreadListParams {
9016    #[serde(default, skip_serializing_if = "Option::is_none")]
9017    pub archived: Option<bool>,
9018    /// Show local history visible to the current ChatGPT account. Defaults to
9019    /// false.
9020    #[serde(
9021        rename = "currentAccountOnly",
9022        default,
9023        skip_serializing_if = "Option::is_none"
9024    )]
9025    pub current_account_only: Option<bool>,
9026    #[serde(default, skip_serializing_if = "Option::is_none")]
9027    pub cursor: Option<String>,
9028    #[serde(default, skip_serializing_if = "Option::is_none")]
9029    pub cwd: Option<ThreadListCwdFilter>,
9030    /// Thread IDs to exclude before applying the result limit. Up to 100
9031    /// entries; invalid IDs or a larger list are rejected, never truncated.
9032    /// Send the same exclusions on each page. Omitted, null, or empty means
9033    /// no exclusions.
9034    #[serde(
9035        rename = "excludedThreadIds",
9036        default,
9037        skip_serializing_if = "Option::is_none"
9038    )]
9039    pub excluded_thread_ids: Option<Vec<String>>,
9040    /// Restrict results to up to 100 thread IDs before pagination. Omit or
9041    /// send null for unrestricted results. An empty list matches nothing.
9042    /// Exclusions still apply. Repeat the same IDs on each page. The local
9043    /// store uses indexed metadata for this filter.
9044    #[serde(
9045        rename = "includedThreadIds",
9046        default,
9047        skip_serializing_if = "Option::is_none"
9048    )]
9049    pub included_thread_ids: Option<Vec<String>>,
9050    #[serde(default, skip_serializing_if = "Option::is_none")]
9051    pub limit: Option<i64>,
9052    #[serde(
9053        rename = "modelProviders",
9054        default,
9055        skip_serializing_if = "Option::is_none"
9056    )]
9057    pub model_providers: Option<Vec<String>>,
9058    /// Optional originator allowlist, matching any supplied value exactly.
9059    /// Supported by hosted backends only; the local app-server rejects a
9060    /// nonempty list. Omitted or empty lists leave originators unrestricted.
9061    #[serde(default, skip_serializing_if = "Option::is_none")]
9062    pub originators: Option<Vec<String>>,
9063    #[serde(
9064        rename = "searchTerm",
9065        default,
9066        skip_serializing_if = "Option::is_none"
9067    )]
9068    pub search_term: Option<String>,
9069    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
9070    pub section_id: Option<String>,
9071    #[serde(
9072        rename = "sortDirection",
9073        default,
9074        skip_serializing_if = "Option::is_none"
9075    )]
9076    pub sort_direction: Option<SortDirection>,
9077    #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
9078    pub sort_key: Option<ThreadSortKey>,
9079    #[serde(
9080        rename = "sourceKinds",
9081        default,
9082        skip_serializing_if = "Option::is_none"
9083    )]
9084    pub source_kinds: Option<Vec<ThreadSourceKind>>,
9085    /// If true, the local store returns indexed metadata without scanning
9086    /// JSONL rollouts for repairs. Requests with `includedThreadIds` always
9087    /// use indexed metadata.
9088    #[serde(
9089        rename = "useStateDbOnly",
9090        default,
9091        skip_serializing_if = "Option::is_none"
9092    )]
9093    pub use_state_db_only: Option<bool>,
9094}
9095
9096#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9097#[serde(rename_all = "camelCase")]
9098pub struct ThreadListResponse {
9099    #[serde(
9100        rename = "backwardsCursor",
9101        default,
9102        skip_serializing_if = "Option::is_none"
9103    )]
9104    pub backwards_cursor: Option<String>,
9105    #[serde(default)]
9106    pub data: Vec<Thread>,
9107    #[serde(
9108        rename = "nextCursor",
9109        default,
9110        skip_serializing_if = "Option::is_none"
9111    )]
9112    pub next_cursor: Option<String>,
9113}
9114
9115#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9116#[serde(rename_all = "camelCase")]
9117pub struct ThreadLoadedListParams {
9118    #[serde(default, skip_serializing_if = "Option::is_none")]
9119    pub cursor: Option<String>,
9120    #[serde(default, skip_serializing_if = "Option::is_none")]
9121    pub limit: Option<i64>,
9122}
9123
9124#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9125#[serde(rename_all = "camelCase")]
9126pub struct ThreadLoadedListResponse {
9127    #[serde(default)]
9128    pub data: Vec<String>,
9129    #[serde(
9130        rename = "nextCursor",
9131        default,
9132        skip_serializing_if = "Option::is_none"
9133    )]
9134    pub next_cursor: Option<String>,
9135}
9136
9137#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9138#[serde(rename_all = "camelCase")]
9139pub struct ThreadMetadataGitInfoUpdateParams {
9140    #[serde(default, skip_serializing_if = "Option::is_none")]
9141    pub branch: Option<String>,
9142    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
9143    pub origin_url: Option<String>,
9144    #[serde(default, skip_serializing_if = "Option::is_none")]
9145    pub sha: Option<String>,
9146}
9147
9148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9149#[serde(rename_all = "camelCase")]
9150pub struct ThreadMetadataUpdateParams {
9151    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
9152    pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
9153    #[serde(rename = "threadId", default)]
9154    pub thread_id: String,
9155}
9156
9157#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9158#[serde(rename_all = "camelCase")]
9159pub struct ThreadMetadataUpdateResponse {
9160    #[serde()]
9161    pub thread: Thread,
9162}
9163
9164#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9165#[serde(rename_all = "camelCase")]
9166pub struct ThreadNameUpdatedNotification {
9167    #[serde(rename = "threadId", default)]
9168    pub thread_id: String,
9169    #[serde(
9170        rename = "threadName",
9171        default,
9172        skip_serializing_if = "Option::is_none"
9173    )]
9174    pub thread_name: Option<String>,
9175}
9176
9177#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9178#[serde(rename_all = "camelCase")]
9179pub struct ThreadReadParams {
9180    #[serde(
9181        rename = "includeTurns",
9182        default,
9183        skip_serializing_if = "Option::is_none"
9184    )]
9185    pub include_turns: Option<bool>,
9186    #[serde(rename = "threadId", default)]
9187    pub thread_id: String,
9188}
9189
9190#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9191#[serde(rename_all = "camelCase")]
9192pub struct ThreadReadResponse {
9193    #[serde()]
9194    pub thread: Thread,
9195}
9196
9197/// The first unread position in a durable local thread. A null position means read.
9198/// The opaque revision guards edits against activity or marks the caller has not seen.
9199#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9200#[serde(rename_all = "camelCase")]
9201pub struct ThreadReadState {
9202    #[serde(
9203        rename = "firstUnread",
9204        default,
9205        skip_serializing_if = "Option::is_none"
9206    )]
9207    pub first_unread: Option<ThreadUnreadPosition>,
9208    #[serde(default)]
9209    pub revision: String,
9210}
9211
9212#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9213#[serde(rename_all = "camelCase")]
9214pub struct ThreadReadStateChangedNotification {
9215    #[serde(rename = "readState")]
9216    pub read_state: ThreadReadState,
9217    #[serde(rename = "threadId", default)]
9218    pub thread_id: String,
9219}
9220
9221/// Broadcast after a successful move into, within, or out of a section.
9222#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
9223#[serde(rename_all = "camelCase")]
9224pub struct ThreadSectionChangedNotification {
9225    #[serde(rename = "threadId")]
9226    pub thread_id: String,
9227    /// Destination section, or `None` when the thread was removed from its
9228    /// section. Always present on the wire (`null` when removed).
9229    #[serde(rename = "sectionId")]
9230    pub section_id: Option<String>,
9231}
9232
9233#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9234#[serde(rename_all = "camelCase")]
9235pub struct ThreadRealtimeAudioChunk {
9236    #[serde(default)]
9237    pub data: String,
9238    #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
9239    pub item_id: Option<String>,
9240    #[serde(rename = "numChannels", default)]
9241    pub num_channels: i64,
9242    #[serde(rename = "sampleRate", default)]
9243    pub sample_rate: i64,
9244    #[serde(
9245        rename = "samplesPerChannel",
9246        default,
9247        skip_serializing_if = "Option::is_none"
9248    )]
9249    pub samples_per_channel: Option<i64>,
9250}
9251
9252#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9253#[serde(rename_all = "camelCase")]
9254pub struct ThreadRealtimeClosedNotification {
9255    #[serde(default, skip_serializing_if = "Option::is_none")]
9256    pub reason: Option<String>,
9257    #[serde(rename = "threadId", default)]
9258    pub thread_id: String,
9259}
9260
9261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9262#[serde(rename_all = "camelCase")]
9263pub struct ThreadRealtimeErrorNotification {
9264    #[serde(default)]
9265    pub message: String,
9266    #[serde(rename = "threadId", default)]
9267    pub thread_id: String,
9268}
9269
9270#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9271#[serde(rename_all = "camelCase")]
9272pub struct ThreadRealtimeItemAddedNotification {
9273    #[serde(default)]
9274    pub item: Value,
9275    #[serde(rename = "threadId", default)]
9276    pub thread_id: String,
9277}
9278
9279#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9280#[serde(rename_all = "camelCase")]
9281pub struct ThreadRealtimeOutputAudioDeltaNotification {
9282    #[serde()]
9283    pub audio: ThreadRealtimeAudioChunk,
9284    #[serde(rename = "threadId", default)]
9285    pub thread_id: String,
9286}
9287
9288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9289#[serde(rename_all = "camelCase")]
9290pub struct ThreadRealtimeSdpNotification {
9291    #[serde(default)]
9292    pub sdp: String,
9293    #[serde(rename = "threadId", default)]
9294    pub thread_id: String,
9295}
9296
9297#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9298#[serde(rename_all = "camelCase")]
9299pub struct ThreadRealtimeStartedNotification {
9300    #[serde(
9301        rename = "realtimeSessionId",
9302        default,
9303        skip_serializing_if = "Option::is_none"
9304    )]
9305    pub realtime_session_id: Option<String>,
9306    #[serde(rename = "threadId", default)]
9307    pub thread_id: String,
9308    #[serde()]
9309    pub version: RealtimeConversationVersion,
9310}
9311
9312#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9313#[serde(rename_all = "camelCase")]
9314pub struct ThreadRealtimeTranscriptDeltaNotification {
9315    #[serde(default)]
9316    pub delta: String,
9317    #[serde(default)]
9318    pub role: String,
9319    #[serde(rename = "threadId", default)]
9320    pub thread_id: String,
9321}
9322
9323#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9324#[serde(rename_all = "camelCase")]
9325pub struct ThreadRealtimeTranscriptDoneNotification {
9326    #[serde(default)]
9327    pub role: String,
9328    #[serde(default)]
9329    pub text: String,
9330    #[serde(rename = "threadId", default)]
9331    pub thread_id: String,
9332}
9333
9334#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9335#[serde(rename_all = "camelCase")]
9336pub struct ThreadResumeParams {
9337    #[serde(
9338        rename = "approvalPolicy",
9339        default,
9340        skip_serializing_if = "Option::is_none"
9341    )]
9342    pub approval_policy: Option<AskForApproval>,
9343    #[serde(
9344        rename = "approvalsReviewer",
9345        default,
9346        skip_serializing_if = "Option::is_none"
9347    )]
9348    pub approvals_reviewer: Option<ApprovalsReviewer>,
9349    #[serde(
9350        rename = "baseInstructions",
9351        default,
9352        skip_serializing_if = "Option::is_none"
9353    )]
9354    pub base_instructions: Option<String>,
9355    #[serde(default, skip_serializing_if = "Option::is_none")]
9356    pub config: Option<Value>,
9357    #[serde(default, skip_serializing_if = "Option::is_none")]
9358    pub cwd: Option<String>,
9359    #[serde(
9360        rename = "developerInstructions",
9361        default,
9362        skip_serializing_if = "Option::is_none"
9363    )]
9364    pub developer_instructions: Option<String>,
9365    #[serde(default, skip_serializing_if = "Option::is_none")]
9366    pub model: Option<String>,
9367    #[serde(
9368        rename = "modelProvider",
9369        default,
9370        skip_serializing_if = "Option::is_none"
9371    )]
9372    pub model_provider: Option<String>,
9373    #[serde(default, skip_serializing_if = "Option::is_none")]
9374    pub personality: Option<Personality>,
9375    #[serde(default, skip_serializing_if = "Option::is_none")]
9376    pub sandbox: Option<SandboxMode>,
9377    #[serde(
9378        rename = "serviceTier",
9379        default,
9380        skip_serializing_if = "Option::is_none"
9381    )]
9382    pub service_tier: Option<String>,
9383    #[serde(rename = "threadId", default)]
9384    pub thread_id: String,
9385    #[serde(
9386        rename = "excludeTurns",
9387        default,
9388        skip_serializing_if = "Option::is_none"
9389    )]
9390    pub exclude_turns: Option<bool>,
9391}
9392
9393#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9394#[serde(rename_all = "camelCase")]
9395pub struct ThreadResumeResponse {
9396    #[serde(rename = "approvalPolicy")]
9397    pub approval_policy: AskForApproval,
9398    #[serde(rename = "approvalsReviewer", default)]
9399    pub approvals_reviewer: Value,
9400    /// Effective collaboration mode. Absent when resuming from an older
9401    /// server.
9402    #[serde(
9403        rename = "collaborationMode",
9404        default,
9405        skip_serializing_if = "Option::is_none"
9406    )]
9407    pub collaboration_mode: Option<CollaborationMode>,
9408    #[serde()]
9409    pub cwd: AbsolutePathBuf,
9410    /// Saved list of disabled plugin IDs. Does not yet filter plugin
9411    /// capabilities.
9412    #[serde(rename = "disabledPluginIds", default)]
9413    pub disabled_plugin_ids: Vec<String>,
9414    #[serde(
9415        rename = "instructionSources",
9416        default,
9417        skip_serializing_if = "Option::is_none"
9418    )]
9419    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9420    /// Cursor for hydrating paginated items backwards via `thread/items/list`
9421    /// with `sortDirection: "desc"` (0.148 upstream).
9422    #[serde(
9423        rename = "itemsBackwardsCursor",
9424        default,
9425        skip_serializing_if = "Option::is_none"
9426    )]
9427    pub items_backwards_cursor: Option<String>,
9428    #[serde(default)]
9429    pub model: String,
9430    #[serde(rename = "modelProvider", default)]
9431    pub model_provider: String,
9432    #[serde(
9433        rename = "reasoningEffort",
9434        default,
9435        skip_serializing_if = "Option::is_none"
9436    )]
9437    pub reasoning_effort: Option<ReasoningEffort>,
9438    #[serde(default)]
9439    pub sandbox: Value,
9440    #[serde(
9441        rename = "serviceTier",
9442        default,
9443        skip_serializing_if = "Option::is_none"
9444    )]
9445    pub service_tier: Option<String>,
9446    #[serde()]
9447    pub thread: Thread,
9448    /// Cursor for hydrating paginated turns backwards via `thread/turns/list`
9449    /// with `sortDirection: "desc"` (0.148 upstream).
9450    #[serde(
9451        rename = "turnsBackwardsCursor",
9452        default,
9453        skip_serializing_if = "Option::is_none"
9454    )]
9455    pub turns_backwards_cursor: Option<String>,
9456}
9457
9458/// Persisted thread history contract (0.148 upstream).
9459#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9460pub enum ThreadHistoryMode {
9461    #[serde(rename = "legacy")]
9462    Legacy,
9463    #[serde(rename = "paginated")]
9464    Paginated,
9465}
9466
9467/// One item plus the turn that contains it, as returned by
9468/// `thread/items/list` (0.148 upstream).
9469#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9470#[serde(rename_all = "camelCase")]
9471pub struct ThreadItemEntry {
9472    /// Unix timestamp (milliseconds) when the item completed, if recorded by
9473    /// the producer.
9474    #[serde(
9475        rename = "completedAtMs",
9476        default,
9477        skip_serializing_if = "Option::is_none"
9478    )]
9479    pub completed_at_ms: Option<i64>,
9480    #[serde()]
9481    pub item: ThreadItem,
9482    /// EXPERIMENTAL upstream — the saved command output was omitted because
9483    /// the request set [`ThreadItemOutputDeferral::command_execution`]; fetch
9484    /// the complete item with `thread/items/read` (openai/codex#59601).
9485    /// Requires `experimentalApi`; absent (false) otherwise.
9486    #[serde(
9487        rename = "outputDeferred",
9488        default,
9489        skip_serializing_if = "std::ops::Not::not"
9490    )]
9491    pub output_deferred: bool,
9492    /// Unix timestamp (milliseconds) when the item started, if recorded by
9493    /// the producer.
9494    #[serde(
9495        rename = "startedAtMs",
9496        default,
9497        skip_serializing_if = "Option::is_none"
9498    )]
9499    pub started_at_ms: Option<i64>,
9500    #[serde(rename = "turnId", default)]
9501    pub turn_id: String,
9502}
9503
9504/// Params for `thread/items/list` — paginated item hydration (0.148 upstream).
9505#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9506#[serde(rename_all = "camelCase")]
9507pub struct ThreadItemsListParams {
9508    /// Opaque continuation cursor, or an exclusive item anchor in the
9509    /// requested visible turn (`openai/codex@main` de9e78e3). An item anchor
9510    /// requires a non-empty `turn_id`; ascending (the default) returns items
9511    /// after it, descending returns items before it. Continue with the
9512    /// returned string cursor.
9513    #[serde(default, skip_serializing_if = "Option::is_none")]
9514    pub cursor: Option<ThreadItemsListCursor>,
9515    /// For a single turn, choose which saved outputs to fetch separately by
9516    /// item ID (openai/codex#59601).
9517    #[serde(
9518        rename = "deferOutput",
9519        default,
9520        skip_serializing_if = "Option::is_none"
9521    )]
9522    pub defer_output: Option<ThreadItemOutputDeferral>,
9523    #[serde(default, skip_serializing_if = "Option::is_none")]
9524    pub limit: Option<u32>,
9525    #[serde(
9526        rename = "sortDirection",
9527        default,
9528        skip_serializing_if = "Option::is_none"
9529    )]
9530    pub sort_direction: Option<SortDirection>,
9531    #[serde(rename = "threadId", default)]
9532    pub thread_id: String,
9533    /// Optional turn id filter; omitted returns items across the thread.
9534    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
9535    pub turn_id: Option<String>,
9536}
9537
9538/// `thread/items/list` `deferOutput` selector — which saved outputs the
9539/// server should omit from the page so the client can fetch them separately
9540/// by item ID (openai/codex#59601). The stable schema exposes this as an
9541/// empty object; its fields are experimental upstream.
9542#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
9543#[serde(rename_all = "camelCase")]
9544pub struct ThreadItemOutputDeferral {
9545    /// EXPERIMENTAL upstream — defer nonempty output from successful
9546    /// commands. Requires `experimentalApi`.
9547    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9548    pub command_execution: bool,
9549}
9550
9551/// Starting position for a `thread/items/list` page: either the opaque
9552/// string cursor a previous page returned, or an item anchor
9553/// (`openai/codex@main` de9e78e3). Untagged, so a bare string stays a bare
9554/// string on the wire.
9555#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9556#[serde(untagged)]
9557pub enum ThreadItemsListCursor {
9558    Opaque(String),
9559    Anchor(ThreadItemsListAnchor),
9560}
9561
9562/// An exclusive item position within the requested visible turn
9563/// (`openai/codex@main` de9e78e3).
9564#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9565#[serde(tag = "type", rename_all = "camelCase")]
9566pub enum ThreadItemsListAnchor {
9567    Item {
9568        #[serde(rename = "itemId")]
9569        item_id: String,
9570    },
9571}
9572
9573/// Response to `thread/items/list` (0.148 upstream).
9574#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9575#[serde(rename_all = "camelCase")]
9576pub struct ThreadItemsListResponse {
9577    #[serde(
9578        rename = "backwardsCursor",
9579        default,
9580        skip_serializing_if = "Option::is_none"
9581    )]
9582    pub backwards_cursor: Option<String>,
9583    #[serde(default)]
9584    pub data: Vec<ThreadItemEntry>,
9585    #[serde(
9586        rename = "nextCursor",
9587        default,
9588        skip_serializing_if = "Option::is_none"
9589    )]
9590    pub next_cursor: Option<String>,
9591}
9592
9593/// EXPERIMENTAL upstream — a thread-scoped realtime item in the canonical
9594/// timeline (0.148). Top-level identity fields are camelCase on the wire
9595/// while variant payload fields are snake_case; mirrored exactly.
9596#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9597pub struct ThreadRealtimeItem {
9598    #[serde(default)]
9599    pub id: String,
9600    #[serde(rename = "realtimeSessionId", default)]
9601    pub realtime_session_id: String,
9602    /// Canonical observation time in Unix milliseconds for eligible voice
9603    /// calls.
9604    #[serde(
9605        rename = "observedAtMs",
9606        default,
9607        skip_serializing_if = "Option::is_none"
9608    )]
9609    pub observed_at_ms: Option<i64>,
9610    #[serde(flatten)]
9611    pub detail: ThreadRealtimeItemDetail,
9612}
9613
9614/// The `type`-tagged payload of a [`ThreadRealtimeItem`].
9615#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9616#[serde(tag = "type", rename_all = "camelCase")]
9617pub enum ThreadRealtimeItemDetail {
9618    #[serde(rename = "realtimeSessionStarted")]
9619    RealtimeSessionStarted,
9620    /// A sealed frame of one or more channel payloads sharing one ID,
9621    /// observation time, and seal. Persisted reads keep this shape; live and
9622    /// mixed timeline APIs present speech as `transcriptSegment`.
9623    #[serde(rename = "frame")]
9624    Frame {
9625        channels: ThreadRealtimeFrameChannels,
9626    },
9627    #[serde(rename = "transcriptSegment")]
9628    TranscriptSegment {
9629        role: ThreadRealtimeTranscriptRole,
9630        text: String,
9631    },
9632    #[serde(rename = "bemItemPromoted")]
9633    BemItemPromoted {
9634        item_id: String,
9635        presentation: ThreadRealtimeBemItemPresentation,
9636        turn_id: String,
9637    },
9638    #[serde(rename = "realtimeSessionClosed")]
9639    RealtimeSessionClosed {
9640        outcome: ThreadRealtimeSessionOutcome,
9641    },
9642    /// A realtime handoff was accepted as input to an agent turn.
9643    #[serde(rename = "turnInputAccepted")]
9644    TurnInputAccepted {
9645        handoff_id: String,
9646        input: String,
9647        input_item_id: String,
9648        mode: ThreadRealtimeHandoffMode,
9649        source_event_ids: Vec<String>,
9650        turn_id: String,
9651    },
9652    /// Input pending at session end was saved for a later turn.
9653    #[serde(rename = "sessionEndInputSaved")]
9654    SessionEndInputSaved {
9655        input: String,
9656        input_item_id: String,
9657        source_event_ids: Vec<String>,
9658    },
9659}
9660
9661/// EXPERIMENTAL upstream — channel payloads of a realtime `frame` item. A
9662/// frame holds at most one payload per channel; V1 requires its only
9663/// channel, `voice_transcript`.
9664#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
9665pub struct ThreadRealtimeFrameChannels {
9666    pub voice_transcript: ThreadRealtimeVoiceTranscript,
9667}
9668
9669/// EXPERIMENTAL upstream — the `voice_transcript` channel of a realtime frame.
9670#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
9671pub struct ThreadRealtimeVoiceTranscript {
9672    pub role: ThreadRealtimeTranscriptRole,
9673    pub text: String,
9674}
9675
9676/// EXPERIMENTAL upstream — whether a realtime handoff started a new turn or
9677/// steered an active one.
9678#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9679#[serde(rename_all = "camelCase")]
9680pub enum ThreadRealtimeHandoffMode {
9681    Start,
9682    Steer,
9683}
9684
9685/// EXPERIMENTAL upstream — one persisted realtime history entry at a
9686/// committed position (returned by the experimental `thread/realtime/list`).
9687#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9688pub struct ThreadRealtimeEntry {
9689    pub item: ThreadRealtimeItem,
9690    pub position: u64,
9691}
9692
9693/// EXPERIMENTAL upstream — sort order for persisted realtime history reads.
9694#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
9695#[serde(rename_all = "camelCase")]
9696pub enum ThreadRealtimeOrder {
9697    /// Sort by canonical observation time, then committed position.
9698    #[default]
9699    ObservedAt,
9700    /// Sort by committed position, including events sealed after older
9701    /// snapshots.
9702    Position,
9703}
9704
9705/// EXPERIMENTAL upstream — whether persisted realtime history is available
9706/// for a read.
9707#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9708#[serde(rename_all = "camelCase")]
9709pub enum ThreadRealtimeCoverage {
9710    Unsupported,
9711    Pending,
9712    Ready,
9713}
9714
9715/// EXPERIMENTAL upstream — how an existing agent item appears in a realtime
9716/// conversation (0.148).
9717#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9718#[serde(tag = "type", rename_all = "camelCase")]
9719pub enum ThreadRealtimeBemItemPresentation {
9720    #[serde(rename = "wholeItem")]
9721    WholeItem,
9722    #[serde(rename = "inlineMarkdown")]
9723    InlineMarkdown,
9724    #[serde(rename = "inlineVisualization")]
9725    InlineVisualization { index: u32 },
9726}
9727
9728/// EXPERIMENTAL upstream — `thread/realtime/item/started` params (0.148).
9729#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9730#[serde(rename_all = "camelCase")]
9731pub struct ThreadRealtimeItemStartedNotification {
9732    #[serde()]
9733    pub item: ThreadRealtimeItem,
9734    #[serde(rename = "threadId", default)]
9735    pub thread_id: String,
9736}
9737
9738/// EXPERIMENTAL upstream — `thread/realtime/item/completed` params (0.148).
9739#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9740#[serde(rename_all = "camelCase")]
9741pub struct ThreadRealtimeItemCompletedNotification {
9742    #[serde()]
9743    pub item: ThreadRealtimeItem,
9744    #[serde(rename = "threadId", default)]
9745    pub thread_id: String,
9746}
9747
9748/// EXPERIMENTAL upstream — `thread/realtime/item/transcript/delta` params:
9749/// text appended to an active realtime transcript item (0.148).
9750#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9751#[serde(rename_all = "camelCase")]
9752pub struct ThreadRealtimeItemTranscriptDeltaNotification {
9753    #[serde(default)]
9754    pub delta: String,
9755    #[serde(rename = "itemId", default)]
9756    pub item_id: String,
9757    #[serde(rename = "threadId", default)]
9758    pub thread_id: String,
9759}
9760
9761/// EXPERIMENTAL upstream — outcome of a closed realtime session (0.148).
9762#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9763pub enum ThreadRealtimeSessionOutcome {
9764    #[serde(rename = "ended")]
9765    Ended,
9766    #[serde(rename = "failed")]
9767    Failed,
9768}
9769
9770/// EXPERIMENTAL upstream — speaker role in a realtime transcript (0.148).
9771#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9772pub enum ThreadRealtimeTranscriptRole {
9773    #[serde(rename = "user")]
9774    User,
9775    #[serde(rename = "assistant")]
9776    Assistant,
9777}
9778
9779/// Params for `thread/revert` — replace a paginated thread's durable history
9780/// with the prefix before one turn; local file changes are untouched
9781/// (0.148 upstream).
9782#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9783#[serde(rename_all = "camelCase")]
9784pub struct ThreadRevertParams {
9785    /// Turn excluded from the replacement history, with every later turn.
9786    #[serde(rename = "beforeTurnId", default)]
9787    pub before_turn_id: String,
9788    #[serde(rename = "threadId", default)]
9789    pub thread_id: String,
9790}
9791
9792/// Response to `thread/revert` (0.148 upstream). `thread.turns` is always
9793/// empty; retained history hydrates through `thread/turns/list`.
9794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9795#[serde(rename_all = "camelCase")]
9796pub struct ThreadRevertResponse {
9797    #[serde(
9798        rename = "itemsBackwardsCursor",
9799        default,
9800        skip_serializing_if = "Option::is_none"
9801    )]
9802    pub items_backwards_cursor: Option<String>,
9803    #[serde()]
9804    pub thread: Thread,
9805    #[serde(
9806        rename = "turnsBackwardsCursor",
9807        default,
9808        skip_serializing_if = "Option::is_none"
9809    )]
9810    pub turns_backwards_cursor: Option<String>,
9811}
9812
9813#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9814#[serde(rename_all = "camelCase")]
9815pub struct ThreadSection {
9816    #[serde(default, skip_serializing_if = "Option::is_none")]
9817    pub appearance: Option<ThreadSectionAppearance>,
9818    #[serde(default)]
9819    pub id: String,
9820    #[serde(default)]
9821    pub name: String,
9822}
9823
9824#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9825#[serde(rename_all = "camelCase")]
9826pub struct ThreadSectionAppearance {
9827    #[serde(default, skip_serializing_if = "Option::is_none")]
9828    pub color: Option<String>,
9829    #[serde(default, skip_serializing_if = "Option::is_none")]
9830    pub icon: Option<String>,
9831}
9832
9833#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9834#[serde(rename_all = "camelCase")]
9835pub struct ThreadSectionCreateParams {
9836    #[serde(default, skip_serializing_if = "Option::is_none")]
9837    pub appearance: Option<ThreadSectionAppearance>,
9838    #[serde(default)]
9839    pub name: String,
9840}
9841
9842#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9843#[serde(rename_all = "camelCase")]
9844pub struct ThreadSectionCreateResponse {
9845    #[serde()]
9846    pub section: ThreadSection,
9847}
9848
9849#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9850#[serde(rename_all = "camelCase")]
9851pub struct ThreadSectionDeleteParams {
9852    #[serde(rename = "sectionId", default)]
9853    pub section_id: String,
9854}
9855
9856#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9857#[serde(rename_all = "camelCase")]
9858pub struct ThreadSectionDeleteResponse {
9859    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9860    pub extra: serde_json::Map<String, Value>,
9861}
9862
9863#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9864#[serde(rename_all = "camelCase")]
9865pub struct ThreadSectionListParams {
9866    #[serde(default, skip_serializing_if = "Option::is_none")]
9867    pub cursor: Option<String>,
9868    #[serde(default, skip_serializing_if = "Option::is_none")]
9869    pub limit: Option<i64>,
9870}
9871
9872#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9873#[serde(rename_all = "camelCase")]
9874pub struct ThreadSectionListResponse {
9875    #[serde(default)]
9876    pub data: Vec<ThreadSection>,
9877    #[serde(
9878        rename = "nextCursor",
9879        default,
9880        skip_serializing_if = "Option::is_none"
9881    )]
9882    pub next_cursor: Option<String>,
9883}
9884
9885#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9886#[serde(rename_all = "camelCase")]
9887pub struct ThreadSectionMoveParams {
9888    #[serde(
9889        rename = "beforeThreadId",
9890        default,
9891        skip_serializing_if = "Option::is_none"
9892    )]
9893    pub before_thread_id: Option<String>,
9894    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
9895    pub section_id: Option<String>,
9896    #[serde(rename = "threadId", default)]
9897    pub thread_id: String,
9898}
9899
9900#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9901#[serde(rename_all = "camelCase")]
9902pub struct ThreadSectionMoveResponse {
9903    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9904    pub extra: serde_json::Map<String, Value>,
9905}
9906
9907#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9908#[serde(rename_all = "camelCase")]
9909pub struct ThreadSectionUpdateParams {
9910    #[serde(default, skip_serializing_if = "Option::is_none")]
9911    pub appearance: Option<ThreadSectionAppearance>,
9912    #[serde(default)]
9913    pub name: String,
9914    #[serde(rename = "sectionId", default)]
9915    pub section_id: String,
9916}
9917
9918#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9919#[serde(rename_all = "camelCase")]
9920pub struct ThreadSectionUpdateResponse {
9921    #[serde()]
9922    pub section: ThreadSection,
9923}
9924
9925#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9926#[serde(rename_all = "camelCase")]
9927pub struct ThreadSetNameParams {
9928    #[serde(default)]
9929    pub name: String,
9930    #[serde(rename = "threadId", default)]
9931    pub thread_id: String,
9932}
9933
9934#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9935#[serde(rename_all = "camelCase")]
9936pub struct ThreadSetNameResponse {
9937    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9938    pub extra: serde_json::Map<String, Value>,
9939}
9940
9941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9942#[serde(rename_all = "camelCase")]
9943pub struct ThreadSettings {
9944    #[serde(
9945        rename = "activePermissionProfile",
9946        default,
9947        skip_serializing_if = "Option::is_none"
9948    )]
9949    pub active_permission_profile: Option<ActivePermissionProfile>,
9950    #[serde(rename = "approvalPolicy")]
9951    pub approval_policy: AskForApproval,
9952    #[serde(rename = "approvalsReviewer")]
9953    pub approvals_reviewer: ApprovalsReviewer,
9954    #[serde(rename = "collaborationMode")]
9955    pub collaboration_mode: CollaborationMode,
9956    #[serde()]
9957    pub cwd: AbsolutePathBuf,
9958    /// Saved list of disabled plugin IDs. Does not yet filter plugin
9959    /// capabilities.
9960    #[serde(rename = "disabledPluginIds", default)]
9961    pub disabled_plugin_ids: Vec<String>,
9962    #[serde(default, skip_serializing_if = "Option::is_none")]
9963    pub effort: Option<ReasoningEffort>,
9964    #[serde(default)]
9965    pub model: String,
9966    #[serde(rename = "modelProvider", default)]
9967    pub model_provider: String,
9968    #[serde(default, skip_serializing_if = "Option::is_none")]
9969    pub personality: Option<Personality>,
9970    #[serde(rename = "sandboxPolicy")]
9971    pub sandbox_policy: SandboxPolicy,
9972    #[serde(
9973        rename = "serviceTier",
9974        default,
9975        skip_serializing_if = "Option::is_none"
9976    )]
9977    pub service_tier: Option<String>,
9978    #[serde(default, skip_serializing_if = "Option::is_none")]
9979    pub summary: Option<ReasoningSummary>,
9980}
9981
9982#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9983#[serde(rename_all = "camelCase")]
9984pub struct ThreadSettingsUpdatedNotification {
9985    #[serde(rename = "threadId", default)]
9986    pub thread_id: String,
9987    #[serde(rename = "threadSettings")]
9988    pub thread_settings: ThreadSettings,
9989}
9990
9991#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9992#[serde(rename_all = "camelCase")]
9993pub struct ThreadShellCommandParams {
9994    #[serde(default)]
9995    pub command: String,
9996    #[serde(rename = "threadId", default)]
9997    pub thread_id: String,
9998    /// Maximum execution time in ms; defaults to one hour when omitted.
9999    /// Zero requests an immediate timeout, not unlimited (0.148 upstream).
10000    #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
10001    pub timeout_ms: Option<i64>,
10002}
10003
10004#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10005#[serde(rename_all = "camelCase")]
10006pub struct ThreadShellCommandResponse {
10007    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
10008    pub extra: serde_json::Map<String, Value>,
10009}
10010
10011#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10012pub enum ThreadSortKey {
10013    #[serde(rename = "created_at")]
10014    Created_at,
10015    #[serde(rename = "updated_at")]
10016    Updated_at,
10017    #[serde(rename = "recency_at")]
10018    Recency_at,
10019    #[serde(rename = "section_position")]
10020    Section_position,
10021}
10022
10023#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
10024#[serde(transparent)]
10025pub struct ThreadSource(pub String);
10026
10027#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10028pub enum ThreadSourceKind {
10029    #[serde(rename = "cli")]
10030    Cli,
10031    #[serde(rename = "vscode")]
10032    Vscode,
10033    #[serde(rename = "exec")]
10034    Exec,
10035    #[serde(rename = "appServer")]
10036    AppServer,
10037    #[serde(rename = "subAgent")]
10038    SubAgent,
10039    #[serde(rename = "subAgentReview")]
10040    SubAgentReview,
10041    #[serde(rename = "subAgentCompact")]
10042    SubAgentCompact,
10043    #[serde(rename = "subAgentThreadSpawn")]
10044    SubAgentThreadSpawn,
10045    #[serde(rename = "subAgentOther")]
10046    SubAgentOther,
10047    #[serde(rename = "unknown")]
10048    Unknown,
10049}
10050
10051#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10052#[serde(rename_all = "camelCase")]
10053pub struct ThreadStartParams {
10054    #[serde(
10055        rename = "approvalPolicy",
10056        default,
10057        skip_serializing_if = "Option::is_none"
10058    )]
10059    pub approval_policy: Option<AskForApproval>,
10060    #[serde(
10061        rename = "approvalsReviewer",
10062        default,
10063        skip_serializing_if = "Option::is_none"
10064    )]
10065    pub approvals_reviewer: Option<ApprovalsReviewer>,
10066    #[serde(
10067        rename = "baseInstructions",
10068        default,
10069        skip_serializing_if = "Option::is_none"
10070    )]
10071    pub base_instructions: Option<String>,
10072    #[serde(default, skip_serializing_if = "Option::is_none")]
10073    pub config: Option<Value>,
10074    #[serde(default, skip_serializing_if = "Option::is_none")]
10075    pub cwd: Option<String>,
10076    #[serde(
10077        rename = "developerInstructions",
10078        default,
10079        skip_serializing_if = "Option::is_none"
10080    )]
10081    pub developer_instructions: Option<String>,
10082    #[serde(default, skip_serializing_if = "Option::is_none")]
10083    pub ephemeral: Option<bool>,
10084    #[serde(default, skip_serializing_if = "Option::is_none")]
10085    pub model: Option<String>,
10086    #[serde(
10087        rename = "modelProvider",
10088        default,
10089        skip_serializing_if = "Option::is_none"
10090    )]
10091    pub model_provider: Option<String>,
10092    #[serde(default, skip_serializing_if = "Option::is_none")]
10093    pub personality: Option<Personality>,
10094    #[serde(default, skip_serializing_if = "Option::is_none")]
10095    pub sandbox: Option<SandboxMode>,
10096    #[serde(
10097        rename = "serviceName",
10098        default,
10099        skip_serializing_if = "Option::is_none"
10100    )]
10101    pub service_name: Option<String>,
10102    #[serde(
10103        rename = "serviceTier",
10104        default,
10105        skip_serializing_if = "Option::is_none"
10106    )]
10107    pub service_tier: Option<String>,
10108    #[serde(
10109        rename = "sessionStartSource",
10110        default,
10111        skip_serializing_if = "Option::is_none"
10112    )]
10113    pub session_start_source: Option<ThreadStartSource>,
10114    #[serde(
10115        rename = "threadSource",
10116        default,
10117        skip_serializing_if = "Option::is_none"
10118    )]
10119    pub thread_source: Option<ThreadSource>,
10120}
10121
10122#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10123#[serde(rename_all = "camelCase")]
10124pub struct ThreadStartResponse {
10125    #[serde(rename = "approvalPolicy")]
10126    pub approval_policy: AskForApproval,
10127    #[serde(rename = "approvalsReviewer", default)]
10128    pub approvals_reviewer: Value,
10129    #[serde()]
10130    pub cwd: AbsolutePathBuf,
10131    /// Saved list of disabled plugin IDs. Does not yet filter plugin
10132    /// capabilities.
10133    #[serde(rename = "disabledPluginIds", default)]
10134    pub disabled_plugin_ids: Vec<String>,
10135    #[serde(
10136        rename = "instructionSources",
10137        default,
10138        skip_serializing_if = "Option::is_none"
10139    )]
10140    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
10141    #[serde(default)]
10142    pub model: String,
10143    #[serde(rename = "modelProvider", default)]
10144    pub model_provider: String,
10145    #[serde(
10146        rename = "reasoningEffort",
10147        default,
10148        skip_serializing_if = "Option::is_none"
10149    )]
10150    pub reasoning_effort: Option<ReasoningEffort>,
10151    #[serde(default)]
10152    pub sandbox: Value,
10153    #[serde(
10154        rename = "serviceTier",
10155        default,
10156        skip_serializing_if = "Option::is_none"
10157    )]
10158    pub service_tier: Option<String>,
10159    #[serde()]
10160    pub thread: Thread,
10161}
10162
10163#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10164pub enum ThreadStartSource {
10165    #[serde(rename = "startup")]
10166    Startup,
10167    #[serde(rename = "clear")]
10168    Clear,
10169}
10170
10171#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10172#[serde(rename_all = "camelCase")]
10173pub struct ThreadStartedNotification {
10174    #[serde()]
10175    pub thread: Thread,
10176}
10177
10178#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10179#[serde(tag = "type", rename_all = "camelCase")]
10180pub enum ThreadStatus {
10181    #[serde(rename = "notLoaded")]
10182    NotLoaded,
10183    Idle,
10184    #[serde(rename = "systemError")]
10185    SystemError,
10186    Active {
10187        #[serde(rename = "activeFlags")]
10188        active_flags: Vec<ThreadActiveFlag>,
10189    },
10190}
10191
10192#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10193#[serde(rename_all = "camelCase")]
10194pub struct ThreadStatusChangedNotification {
10195    #[serde()]
10196    pub status: ThreadStatus,
10197    #[serde(rename = "threadId", default)]
10198    pub thread_id: String,
10199}
10200
10201#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10202#[serde(rename_all = "camelCase")]
10203pub struct ThreadTokenUsage {
10204    #[serde()]
10205    pub last: TokenUsageBreakdown,
10206    #[serde(
10207        rename = "modelContextWindow",
10208        default,
10209        skip_serializing_if = "Option::is_none"
10210    )]
10211    pub model_context_window: Option<i64>,
10212    #[serde()]
10213    pub total: TokenUsageBreakdown,
10214}
10215
10216#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10217#[serde(rename_all = "camelCase")]
10218pub struct ThreadTokenUsageUpdatedNotification {
10219    #[serde(rename = "threadId", default)]
10220    pub thread_id: String,
10221    #[serde(rename = "tokenUsage")]
10222    pub token_usage: ThreadTokenUsage,
10223    #[serde(rename = "turnId", default)]
10224    pub turn_id: String,
10225}
10226
10227#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10228#[serde(rename_all = "camelCase")]
10229pub struct ThreadUnarchiveParams {
10230    #[serde(rename = "threadId", default)]
10231    pub thread_id: String,
10232}
10233
10234#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10235#[serde(rename_all = "camelCase")]
10236pub struct ThreadUnarchiveResponse {
10237    #[serde()]
10238    pub thread: Thread,
10239}
10240
10241#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10242#[serde(rename_all = "camelCase")]
10243pub struct ThreadUnarchivedNotification {
10244    #[serde(rename = "threadId", default)]
10245    pub thread_id: String,
10246}
10247
10248#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10249#[serde(tag = "type", rename_all = "camelCase")]
10250pub enum ThreadUnreadPosition {
10251    /// Explicitly marked unread, including when the thread has no turns.
10252    #[serde(rename = "threadStart")]
10253    ThreadStart,
10254    /// The earliest completed result needing attention.
10255    Turn {
10256        #[serde(rename = "turnId")]
10257        turn_id: String,
10258    },
10259}
10260
10261/// EXPERIMENTAL upstream — one item or turn boundary in canonical rollout
10262/// order (0.148). Wire quirk mirrored exactly: the `item` variant uses
10263/// camelCase `turnId` while the turn-boundary variants use snake_case
10264/// `turn_id`/`started_at`/`completed_at`/`duration_ms`.
10265#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10266#[serde(tag = "type", rename_all = "camelCase")]
10267#[allow(clippy::large_enum_variant)] // transient per-entry wire value, not stored in bulk
10268pub enum ThreadTimelineEntry {
10269    Item {
10270        item: ThreadItem,
10271        position: u64,
10272        #[serde(rename = "turnId")]
10273        turn_id: String,
10274    },
10275    Realtime {
10276        item: ThreadRealtimeItem,
10277        position: u64,
10278    },
10279    TurnStarted {
10280        position: u64,
10281        #[serde(default, skip_serializing_if = "Option::is_none")]
10282        started_at: Option<i64>,
10283        turn_id: String,
10284    },
10285    TurnCompleted {
10286        #[serde(default, skip_serializing_if = "Option::is_none")]
10287        completed_at: Option<i64>,
10288        #[serde(default, skip_serializing_if = "Option::is_none")]
10289        duration_ms: Option<i64>,
10290        #[serde(default, skip_serializing_if = "Option::is_none")]
10291        error: Option<TurnError>,
10292        position: u64,
10293        #[serde(default, skip_serializing_if = "Option::is_none")]
10294        started_at: Option<i64>,
10295        status: TurnStatus,
10296        turn_id: String,
10297    },
10298}
10299
10300/// Params for `thread/turns/list` — paginated turn hydration (0.148 upstream).
10301#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10302#[serde(rename_all = "camelCase")]
10303pub struct ThreadTurnsListParams {
10304    #[serde(default, skip_serializing_if = "Option::is_none")]
10305    pub cursor: Option<String>,
10306    /// How much item detail to include per turn; defaults to summary.
10307    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
10308    pub items_view: Option<TurnItemsView>,
10309    #[serde(default, skip_serializing_if = "Option::is_none")]
10310    pub limit: Option<u32>,
10311    #[serde(
10312        rename = "sortDirection",
10313        default,
10314        skip_serializing_if = "Option::is_none"
10315    )]
10316    pub sort_direction: Option<SortDirection>,
10317    #[serde(rename = "threadId", default)]
10318    pub thread_id: String,
10319}
10320
10321/// Response to `thread/turns/list` (0.148 upstream).
10322#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10323#[serde(rename_all = "camelCase")]
10324pub struct ThreadTurnsListResponse {
10325    #[serde(
10326        rename = "backwardsCursor",
10327        default,
10328        skip_serializing_if = "Option::is_none"
10329    )]
10330    pub backwards_cursor: Option<String>,
10331    #[serde(default)]
10332    pub data: Vec<Turn>,
10333    #[serde(
10334        rename = "nextCursor",
10335        default,
10336        skip_serializing_if = "Option::is_none"
10337    )]
10338    pub next_cursor: Option<String>,
10339}
10340
10341#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10342#[serde(rename_all = "camelCase")]
10343pub struct ThreadUnsubscribeParams {
10344    #[serde(rename = "threadId", default)]
10345    pub thread_id: String,
10346}
10347
10348#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10349#[serde(rename_all = "camelCase")]
10350pub struct ThreadUnsubscribeResponse {
10351    #[serde()]
10352    pub status: ThreadUnsubscribeStatus,
10353}
10354
10355#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10356pub enum ThreadUnsubscribeStatus {
10357    #[serde(rename = "notLoaded")]
10358    NotLoaded,
10359    #[serde(rename = "notSubscribed")]
10360    NotSubscribed,
10361    #[serde(rename = "unsubscribed")]
10362    Unsubscribed,
10363}
10364
10365#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10366#[serde(rename_all = "camelCase")]
10367pub struct TokenUsageBreakdown {
10368    #[serde(
10369        rename = "cacheWriteInputTokens",
10370        default,
10371        skip_serializing_if = "Option::is_none"
10372    )]
10373    pub cache_write_input_tokens: Option<i64>,
10374    #[serde(rename = "cachedInputTokens", default)]
10375    pub cached_input_tokens: i64,
10376    #[serde(rename = "inputTokens", default)]
10377    pub input_tokens: i64,
10378    #[serde(rename = "outputTokens", default)]
10379    pub output_tokens: i64,
10380    #[serde(rename = "reasoningOutputTokens", default)]
10381    pub reasoning_output_tokens: i64,
10382    #[serde(rename = "totalTokens", default)]
10383    pub total_tokens: i64,
10384}
10385
10386#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10387#[serde(rename_all = "camelCase")]
10388pub struct Tool {
10389    #[serde(default, skip_serializing_if = "Option::is_none")]
10390    pub _meta: Option<Value>,
10391    #[serde(default, skip_serializing_if = "Option::is_none")]
10392    pub annotations: Option<Value>,
10393    #[serde(default, skip_serializing_if = "Option::is_none")]
10394    pub description: Option<String>,
10395    #[serde(default, skip_serializing_if = "Option::is_none")]
10396    pub icons: Option<Vec<Value>>,
10397    #[serde(rename = "inputSchema", default)]
10398    pub input_schema: Value,
10399    #[serde(default)]
10400    pub name: String,
10401    #[serde(
10402        rename = "outputSchema",
10403        default,
10404        skip_serializing_if = "Option::is_none"
10405    )]
10406    pub output_schema: Option<Value>,
10407    #[serde(default, skip_serializing_if = "Option::is_none")]
10408    pub title: Option<String>,
10409}
10410
10411#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10412#[serde(rename_all = "camelCase")]
10413pub struct ToolRequestUserInputAnswer {
10414    #[serde(default)]
10415    pub answers: Vec<String>,
10416}
10417
10418#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10419#[serde(rename_all = "camelCase")]
10420pub struct ToolRequestUserInputOption {
10421    #[serde(default)]
10422    pub description: String,
10423    #[serde(default)]
10424    pub label: String,
10425}
10426
10427#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10428#[serde(rename_all = "camelCase")]
10429pub struct ToolRequestUserInputParams {
10430    #[serde(
10431        rename = "autoResolutionMs",
10432        default,
10433        skip_serializing_if = "Option::is_none"
10434    )]
10435    pub auto_resolution_ms: Option<i64>,
10436    #[serde(rename = "isBlocking", default)]
10437    pub is_blocking: bool,
10438    #[serde(rename = "itemId", default)]
10439    pub item_id: String,
10440    #[serde(default)]
10441    pub questions: Vec<ToolRequestUserInputQuestion>,
10442    #[serde(rename = "threadId", default)]
10443    pub thread_id: String,
10444    #[serde(rename = "turnId", default)]
10445    pub turn_id: String,
10446}
10447
10448#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10449#[serde(rename_all = "camelCase")]
10450pub struct ToolRequestUserInputQuestion {
10451    #[serde(default)]
10452    pub header: String,
10453    #[serde(default)]
10454    pub id: String,
10455    #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
10456    pub is_other: Option<bool>,
10457    #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
10458    pub is_secret: Option<bool>,
10459    #[serde(default, skip_serializing_if = "Option::is_none")]
10460    pub options: Option<Vec<ToolRequestUserInputOption>>,
10461    #[serde(default)]
10462    pub question: String,
10463}
10464
10465#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10466#[serde(rename_all = "camelCase")]
10467pub struct ToolRequestUserInputResponse {
10468    #[serde(default)]
10469    pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
10470}
10471
10472#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10473#[serde(rename_all = "camelCase")]
10474pub struct ToolsV2 {
10475    #[serde(default, skip_serializing_if = "Option::is_none")]
10476    pub web_search: Option<WebSearchToolConfig>,
10477}
10478
10479#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10480#[serde(rename_all = "camelCase")]
10481pub struct Turn {
10482    #[serde(
10483        rename = "completedAt",
10484        default,
10485        skip_serializing_if = "Option::is_none"
10486    )]
10487    pub completed_at: Option<i64>,
10488    #[serde(
10489        rename = "durationMs",
10490        default,
10491        skip_serializing_if = "Option::is_none"
10492    )]
10493    pub duration_ms: Option<i64>,
10494    #[serde(default, skip_serializing_if = "Option::is_none")]
10495    pub error: Option<TurnError>,
10496    #[serde(default)]
10497    pub id: String,
10498    #[serde(default)]
10499    pub items: Vec<ThreadItem>,
10500    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
10501    pub items_view: Option<Value>,
10502    /// ID of the first turn in the chain of work that led to this turn. Pass
10503    /// this as `rootTurnId` when starting work on behalf of this turn. May be
10504    /// null in older history or a `review/start` response.
10505    #[serde(
10506        rename = "rootTurnId",
10507        default,
10508        skip_serializing_if = "Option::is_none"
10509    )]
10510    pub root_turn_id: Option<String>,
10511    #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
10512    pub started_at: Option<i64>,
10513    #[serde()]
10514    pub status: TurnStatus,
10515}
10516
10517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10518#[serde(rename_all = "camelCase")]
10519pub struct TurnCompletedNotification {
10520    #[serde(rename = "threadId", default)]
10521    pub thread_id: String,
10522    #[serde()]
10523    pub turn: Turn,
10524}
10525
10526#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10527#[serde(rename_all = "camelCase")]
10528pub struct TurnDiffUpdatedNotification {
10529    #[serde(default)]
10530    pub diff: String,
10531    #[serde(rename = "threadId", default)]
10532    pub thread_id: String,
10533    #[serde(rename = "turnId", default)]
10534    pub turn_id: String,
10535}
10536
10537#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10538#[serde(rename_all = "camelCase")]
10539pub struct TurnError {
10540    #[serde(
10541        rename = "additionalDetails",
10542        default,
10543        skip_serializing_if = "Option::is_none"
10544    )]
10545    pub additional_details: Option<String>,
10546    #[serde(
10547        rename = "codexErrorInfo",
10548        default,
10549        skip_serializing_if = "Option::is_none"
10550    )]
10551    pub codex_error_info: Option<CodexErrorInfo>,
10552    #[serde(default)]
10553    pub message: String,
10554    /// Public explanation and continuation instruction for a misalignment
10555    /// block (0.148 upstream).
10556    #[serde(default, skip_serializing_if = "Option::is_none")]
10557    pub misalignment: Option<MisalignmentErrorDetails>,
10558}
10559
10560#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10561#[serde(rename_all = "camelCase")]
10562pub struct TurnInterruptParams {
10563    #[serde(rename = "threadId", default)]
10564    pub thread_id: String,
10565    #[serde(rename = "turnId", default)]
10566    pub turn_id: String,
10567}
10568
10569#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10570#[serde(rename_all = "camelCase")]
10571pub struct TurnInterruptResponse {
10572    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
10573    pub extra: serde_json::Map<String, Value>,
10574}
10575
10576#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
10577pub enum TurnItemsView {
10578    #[serde(rename = "notLoaded")]
10579    NotLoaded,
10580    #[serde(rename = "summary")]
10581    Summary,
10582    #[serde(rename = "full")]
10583    Full,
10584}
10585
10586#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10587#[serde(rename_all = "camelCase")]
10588pub struct TurnModerationMetadataNotification {
10589    #[serde(default)]
10590    pub metadata: Value,
10591    #[serde(rename = "threadId", default)]
10592    pub thread_id: String,
10593    #[serde(rename = "turnId", default)]
10594    pub turn_id: String,
10595}
10596
10597#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10598#[serde(rename_all = "camelCase")]
10599pub struct TurnPlanStep {
10600    #[serde()]
10601    pub status: TurnPlanStepStatus,
10602    #[serde(default)]
10603    pub step: String,
10604}
10605
10606#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10607pub enum TurnPlanStepStatus {
10608    #[serde(rename = "pending")]
10609    Pending,
10610    #[serde(rename = "inProgress")]
10611    InProgress,
10612    #[serde(rename = "completed")]
10613    Completed,
10614}
10615
10616#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10617#[serde(rename_all = "camelCase")]
10618pub struct TurnPlanUpdatedNotification {
10619    #[serde(default, skip_serializing_if = "Option::is_none")]
10620    pub explanation: Option<String>,
10621    #[serde(default)]
10622    pub plan: Vec<TurnPlanStep>,
10623    #[serde(rename = "threadId", default)]
10624    pub thread_id: String,
10625    #[serde(rename = "turnId", default)]
10626    pub turn_id: String,
10627}
10628
10629#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10630#[serde(rename_all = "camelCase")]
10631pub struct TurnStartParams {
10632    #[serde(
10633        rename = "approvalPolicy",
10634        default,
10635        skip_serializing_if = "Option::is_none"
10636    )]
10637    pub approval_policy: Option<AskForApproval>,
10638    #[serde(
10639        rename = "approvalsReviewer",
10640        default,
10641        skip_serializing_if = "Option::is_none"
10642    )]
10643    pub approvals_reviewer: Option<ApprovalsReviewer>,
10644    #[serde(
10645        rename = "clientUserMessageId",
10646        default,
10647        skip_serializing_if = "Option::is_none"
10648    )]
10649    pub client_user_message_id: Option<String>,
10650    #[serde(default, skip_serializing_if = "Option::is_none")]
10651    pub cwd: Option<String>,
10652    /// Replace this thread's disabled plugin IDs. Omitted/null preserves the
10653    /// list; `[]` clears it.
10654    #[serde(
10655        rename = "disabledPluginIds",
10656        default,
10657        skip_serializing_if = "Option::is_none"
10658    )]
10659    pub disabled_plugin_ids: Option<Vec<String>>,
10660    #[serde(default, skip_serializing_if = "Option::is_none")]
10661    pub effort: Option<ReasoningEffort>,
10662    #[serde(default)]
10663    pub input: Vec<UserInput>,
10664    #[serde(default, skip_serializing_if = "Option::is_none")]
10665    pub model: Option<String>,
10666    #[serde(
10667        rename = "outputSchema",
10668        default,
10669        skip_serializing_if = "Option::is_none"
10670    )]
10671    pub output_schema: Option<Value>,
10672    /// ID of the turn that caused this new turn to start. Set this when
10673    /// starting work on behalf of another turn; leave unset for work started
10674    /// directly by the user. Ignored when adding input to an active turn.
10675    #[serde(
10676        rename = "parentTurnId",
10677        default,
10678        skip_serializing_if = "Option::is_none"
10679    )]
10680    pub parent_turn_id: Option<String>,
10681    #[serde(default, skip_serializing_if = "Option::is_none")]
10682    pub personality: Option<Personality>,
10683    /// ID of the first turn in the chain of work that led to this new turn.
10684    /// When setting `parent_turn_id`, set this to the parent turn's
10685    /// `root_turn_id` when known; if omitted, the new turn becomes its own
10686    /// root. Ignored when adding input to an active turn.
10687    #[serde(
10688        rename = "rootTurnId",
10689        default,
10690        skip_serializing_if = "Option::is_none"
10691    )]
10692    pub root_turn_id: Option<String>,
10693    #[serde(
10694        rename = "sandboxPolicy",
10695        default,
10696        skip_serializing_if = "Option::is_none"
10697    )]
10698    pub sandbox_policy: Option<SandboxPolicy>,
10699    #[serde(
10700        rename = "serviceTier",
10701        default,
10702        skip_serializing_if = "Option::is_none"
10703    )]
10704    pub service_tier: Option<String>,
10705    /// One-turn service-tier override; `"default"` for standard speed.
10706    /// Omitted or null inherits the thread's tier (0.148 upstream).
10707    #[serde(
10708        rename = "serviceTierForTurn",
10709        default,
10710        skip_serializing_if = "Option::is_none"
10711    )]
10712    pub service_tier_for_turn: Option<String>,
10713    #[serde(default, skip_serializing_if = "Option::is_none")]
10714    pub summary: Option<ReasoningSummary>,
10715    #[serde(rename = "threadId", default)]
10716    pub thread_id: String,
10717    /// Pre-computed tool output to inject when starting the turn
10718    /// (0.148 upstream).
10719    #[serde(
10720        rename = "toolOutput",
10721        default,
10722        skip_serializing_if = "Option::is_none"
10723    )]
10724    pub tool_output: Option<TurnToolOutput>,
10725    /// Optional source classification for the caller starting this turn;
10726    /// ignored when steering an already-active turn (0.148 upstream).
10727    #[serde(
10728        rename = "turnTrigger",
10729        default,
10730        skip_serializing_if = "Option::is_none"
10731    )]
10732    pub turn_trigger: Option<String>,
10733}
10734
10735#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10736#[serde(rename_all = "camelCase")]
10737pub struct TurnStartResponse {
10738    #[serde()]
10739    pub turn: Turn,
10740}
10741
10742#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10743#[serde(rename_all = "camelCase")]
10744pub struct TurnStartedNotification {
10745    #[serde(rename = "threadId", default)]
10746    pub thread_id: String,
10747    #[serde()]
10748    pub turn: Turn,
10749}
10750
10751#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10752pub enum TurnStatus {
10753    #[serde(rename = "completed")]
10754    Completed,
10755    #[serde(rename = "interrupted")]
10756    Interrupted,
10757    #[serde(rename = "failed")]
10758    Failed,
10759    #[serde(rename = "inProgress")]
10760    InProgress,
10761}
10762
10763/// A pre-computed tool output supplied when starting a turn
10764/// (`TurnStartParams.toolOutput`, 0.148 upstream).
10765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10766#[serde(rename_all = "camelCase")]
10767pub struct TurnToolOutput {
10768    #[serde(default)]
10769    pub name: String,
10770    #[serde(default, skip_serializing_if = "Option::is_none")]
10771    pub namespace: Option<String>,
10772    #[serde()]
10773    pub output: FunctionCallOutputBody,
10774    /// Requests retention of this output in the thread's model history
10775    /// (openai/codex#52686). Omitted from the wire when `false`.
10776    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
10777    pub retain: bool,
10778}
10779
10780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10781#[serde(rename_all = "camelCase")]
10782pub struct TurnSteerParams {
10783    #[serde(
10784        rename = "clientUserMessageId",
10785        default,
10786        skip_serializing_if = "Option::is_none"
10787    )]
10788    pub client_user_message_id: Option<String>,
10789    #[serde(rename = "expectedTurnId", default)]
10790    pub expected_turn_id: String,
10791    #[serde(default)]
10792    pub input: Vec<UserInput>,
10793    #[serde(rename = "threadId", default)]
10794    pub thread_id: String,
10795}
10796
10797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10798#[serde(rename_all = "camelCase")]
10799pub struct TurnSteerResponse {
10800    #[serde(rename = "turnId", default)]
10801    pub turn_id: String,
10802}
10803
10804#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10805#[serde(tag = "type", rename_all = "camelCase")]
10806pub enum UserInput {
10807    Text {
10808        text: String,
10809        #[serde(default, skip_serializing_if = "Option::is_none")]
10810        text_elements: Option<Vec<TextElement>>,
10811    },
10812    Image {
10813        #[serde(default, skip_serializing_if = "Option::is_none")]
10814        detail: Option<ImageDetail>,
10815        #[serde(flatten)]
10816        image: UserInputImageReference,
10817    },
10818    #[serde(rename = "localImage")]
10819    LocalImage {
10820        #[serde(default, skip_serializing_if = "Option::is_none")]
10821        detail: Option<ImageDetail>,
10822        path: String,
10823    },
10824    Audio {
10825        #[serde(flatten)]
10826        audio: UserInputAudioReference,
10827    },
10828    #[serde(rename = "localAudio")]
10829    LocalAudio {
10830        path: String,
10831    },
10832    Skill {
10833        name: String,
10834        path: String,
10835    },
10836    Mention {
10837        name: String,
10838        path: String,
10839    },
10840}
10841
10842/// How a [`UserInput::Image`] names its image: an inline `url` (data URL or
10843/// remote URL) or a previously uploaded `fileId`. Flattened into the variant;
10844/// untagged, so exactly one of the two keys is on the wire. Mirrors the v2
10845/// `ImageReference` upstream; the Responses-API twin used by tool outputs is
10846/// [`ImageReference`].
10847#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10848#[serde(untagged)]
10849pub enum UserInputImageReference {
10850    Inline {
10851        url: String,
10852    },
10853    File {
10854        #[serde(rename = "fileId")]
10855        file_id: String,
10856    },
10857}
10858
10859/// How a [`UserInput::Audio`] names its audio: an inline `url` or a
10860/// previously uploaded `fileId`. Flattened into the variant; untagged, so
10861/// exactly one of the two keys is on the wire. Mirrors the v2
10862/// `AudioReference` upstream; the Responses-API twin used by tool outputs is
10863/// [`AudioReference`].
10864#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10865#[serde(untagged)]
10866pub enum UserInputAudioReference {
10867    Inline {
10868        url: String,
10869    },
10870    File {
10871        #[serde(rename = "fileId")]
10872        file_id: String,
10873    },
10874}
10875
10876#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10877pub enum Verbosity {
10878    #[serde(rename = "low")]
10879    Low,
10880    #[serde(rename = "medium")]
10881    Medium,
10882    #[serde(rename = "high")]
10883    High,
10884}
10885
10886#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10887#[serde(rename_all = "camelCase")]
10888pub struct WarningNotification {
10889    #[serde(default)]
10890    pub message: String,
10891    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
10892    pub thread_id: Option<String>,
10893}
10894
10895#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10896#[serde(tag = "type", rename_all = "camelCase")]
10897pub enum WebSearchAction {
10898    Search {
10899        #[serde(default, skip_serializing_if = "Option::is_none")]
10900        queries: Option<Vec<String>>,
10901        #[serde(default, skip_serializing_if = "Option::is_none")]
10902        query: Option<String>,
10903    },
10904    #[serde(rename = "openPage")]
10905    OpenPage {
10906        #[serde(default, skip_serializing_if = "Option::is_none")]
10907        url: Option<String>,
10908    },
10909    #[serde(rename = "findInPage")]
10910    FindInPage {
10911        #[serde(default, skip_serializing_if = "Option::is_none")]
10912        pattern: Option<String>,
10913        #[serde(default, skip_serializing_if = "Option::is_none")]
10914        url: Option<String>,
10915    },
10916    Other,
10917}
10918
10919#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10920pub enum WebSearchContextSize {
10921    #[serde(rename = "low")]
10922    Low,
10923    #[serde(rename = "medium")]
10924    Medium,
10925    #[serde(rename = "high")]
10926    High,
10927}
10928
10929#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10930#[serde(rename_all = "camelCase")]
10931pub struct WebSearchLocation {
10932    #[serde(default, skip_serializing_if = "Option::is_none")]
10933    pub city: Option<String>,
10934    #[serde(default, skip_serializing_if = "Option::is_none")]
10935    pub country: Option<String>,
10936    #[serde(default, skip_serializing_if = "Option::is_none")]
10937    pub region: Option<String>,
10938    #[serde(default, skip_serializing_if = "Option::is_none")]
10939    pub timezone: Option<String>,
10940}
10941
10942#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10943pub enum WebSearchMode {
10944    #[serde(rename = "disabled")]
10945    Disabled,
10946    #[serde(rename = "cached")]
10947    Cached,
10948    #[serde(rename = "indexed")]
10949    Indexed,
10950    #[serde(rename = "live")]
10951    Live,
10952}
10953
10954/// Web search provider preference selected by the resolved model catalog
10955/// entry.
10956#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10957pub enum WebSearchProvider {
10958    #[serde(rename = "standalone")]
10959    Standalone,
10960    #[serde(rename = "search_mcp")]
10961    SearchMcp,
10962}
10963
10964#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10965#[serde(rename_all = "camelCase")]
10966pub struct WebSearchToolConfig {
10967    #[serde(default, skip_serializing_if = "Option::is_none")]
10968    pub allowed_domains: Option<Vec<String>>,
10969    #[serde(default, skip_serializing_if = "Option::is_none")]
10970    pub context_size: Option<WebSearchContextSize>,
10971    #[serde(default, skip_serializing_if = "Option::is_none")]
10972    pub location: Option<WebSearchLocation>,
10973}
10974
10975#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10976pub enum WindowsSandboxReadiness {
10977    #[serde(rename = "ready")]
10978    Ready,
10979    #[serde(rename = "notConfigured")]
10980    NotConfigured,
10981    #[serde(rename = "updateRequired")]
10982    UpdateRequired,
10983}
10984
10985#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10986#[serde(rename_all = "camelCase")]
10987pub struct WindowsSandboxReadinessResponse {
10988    #[serde()]
10989    pub status: WindowsSandboxReadiness,
10990}
10991
10992#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10993#[serde(rename_all = "camelCase")]
10994pub struct WindowsSandboxSetupCompletedNotification {
10995    #[serde(default, skip_serializing_if = "Option::is_none")]
10996    pub error: Option<String>,
10997    #[serde()]
10998    pub mode: WindowsSandboxSetupMode,
10999    #[serde(default)]
11000    pub success: bool,
11001}
11002
11003#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11004pub enum WindowsSandboxSetupMode {
11005    #[serde(rename = "elevated")]
11006    Elevated,
11007    #[serde(rename = "unelevated")]
11008    Unelevated,
11009}
11010
11011/// A Windows sandbox implementation a managed policy may allow
11012/// ([`ConfigRequirements::allowed_windows_sandbox_implementations`]). Grows
11013/// `mxc` beyond the two [`WindowsSandboxSetupMode`] values.
11014#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11015pub enum WindowsSandboxImplementation {
11016    #[serde(rename = "elevated")]
11017    Elevated,
11018    #[serde(rename = "unelevated")]
11019    Unelevated,
11020    #[serde(rename = "mxc")]
11021    Mxc,
11022}
11023
11024#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11025#[serde(rename_all = "camelCase")]
11026pub struct WindowsSandboxSetupStartParams {
11027    #[serde(default, skip_serializing_if = "Option::is_none")]
11028    pub cwd: Option<AbsolutePathBuf>,
11029    #[serde()]
11030    pub mode: WindowsSandboxSetupMode,
11031}
11032
11033#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
11034#[serde(rename_all = "camelCase")]
11035pub struct WindowsSandboxSetupStartResponse {
11036    #[serde(default)]
11037    pub started: bool,
11038}
11039
11040#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
11041#[serde(rename_all = "camelCase")]
11042pub struct WindowsWorldWritableWarningNotification {
11043    #[serde(rename = "extraCount", default)]
11044    pub extra_count: i64,
11045    #[serde(rename = "failedScan", default)]
11046    pub failed_scan: bool,
11047    #[serde(rename = "samplePaths", default)]
11048    pub sample_paths: Vec<String>,
11049}
11050
11051#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11052#[serde(rename_all = "camelCase")]
11053pub struct WorkspaceMessage {
11054    #[serde(
11055        rename = "archivedAt",
11056        default,
11057        skip_serializing_if = "Option::is_none"
11058    )]
11059    pub archived_at: Option<i64>,
11060    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
11061    pub created_at: Option<i64>,
11062    #[serde(rename = "messageBody", default)]
11063    pub message_body: String,
11064    #[serde(rename = "messageId", default)]
11065    pub message_id: String,
11066    #[serde(rename = "messageType")]
11067    pub message_type: WorkspaceMessageType,
11068}
11069
11070#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11071pub enum WorkspaceMessageType {
11072    #[serde(rename = "headline")]
11073    Headline,
11074    #[serde(rename = "announcement")]
11075    Announcement,
11076    #[serde(rename = "unknown")]
11077    Unknown,
11078}
11079
11080#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11081pub enum WriteStatus {
11082    #[serde(rename = "ok")]
11083    Ok,
11084    #[serde(rename = "okOverridden")]
11085    OkOverridden,
11086}