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