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