Skip to main content

codex_codes/protocol_generated/
types.rs

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