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, Copy, PartialEq, Eq, Serialize, Deserialize)]
7005pub struct AgentMessageModeration {
7006    pub moderated: bool,
7007}
7008
7009/// Where the CLI stores auth credentials.
7010#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7011pub enum CliAuthCredentialsStoreMode {
7012    #[serde(rename = "file")]
7013    File,
7014    #[serde(rename = "keyring")]
7015    Keyring,
7016    #[serde(rename = "auto")]
7017    Auto,
7018    #[serde(rename = "ephemeral")]
7019    Ephemeral,
7020}
7021
7022/// A project grouping threads, owned by app-server.
7023#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7024pub struct Project {
7025    #[serde(rename = "createdAt", default)]
7026    pub created_at: i64,
7027    #[serde(default)]
7028    pub id: String,
7029    #[serde(default)]
7030    pub metadata: std::collections::HashMap<String, String>,
7031    #[serde(default)]
7032    pub name: String,
7033    #[serde(default)]
7034    pub position: i64,
7035    /// Newest non-archived member thread's recency, in Unix seconds;
7036    /// absent/null when none exist (0.148 upstream).
7037    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7038    pub recency_at: Option<i64>,
7039    #[serde(default)]
7040    pub roots: Vec<ProjectRoot>,
7041    #[serde(rename = "updatedAt", default)]
7042    pub updated_at: i64,
7043}
7044
7045/// Sort order for project listings (0.148 upstream).
7046#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7047pub enum ProjectSortKey {
7048    #[serde(rename = "position")]
7049    Position,
7050    #[serde(rename = "recencyAt")]
7051    RecencyAt,
7052}
7053
7054#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7055pub enum ProjectChangeType {
7056    #[serde(rename = "created")]
7057    Created,
7058    #[serde(rename = "updated")]
7059    Updated,
7060    #[serde(rename = "deleted")]
7061    Deleted,
7062}
7063
7064/// `project/changed` — a project was created, updated, or deleted.
7065#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7066pub struct ProjectChangedNotification {
7067    #[serde(rename = "changeType")]
7068    pub change_type: ProjectChangeType,
7069    #[serde(rename = "projectId", default)]
7070    pub project_id: String,
7071}
7072
7073#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7074pub struct ProjectRoot {
7075    pub path: AbsolutePathBuf,
7076}
7077
7078/// A user submission waiting in a thread's queue.
7079#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7080pub struct QueuedSubmission {
7081    #[serde(rename = "clientUserMessageId", default)]
7082    pub client_user_message_id: String,
7083    #[serde(default)]
7084    pub id: String,
7085    #[serde(default)]
7086    pub input: Vec<UserInput>,
7087    /// Metadata retained with this input, including across reconnect and restoration.
7088    #[serde(
7089        rename = "responsesapiClientMetadata",
7090        default,
7091        skip_serializing_if = "Option::is_none"
7092    )]
7093    pub responsesapi_client_metadata: Option<std::collections::HashMap<String, String>>,
7094}
7095
7096/// `autoApprovalReview/strictReviewRequired` — a strict review gate opened.
7097#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7098pub struct StrictReviewRequiredNotification {
7099    /// Unix timestamp (ms) when this review started.
7100    #[serde(rename = "startedAtMs", default)]
7101    pub started_at_ms: i64,
7102    #[serde(rename = "threadId", default)]
7103    pub thread_id: String,
7104    #[serde(rename = "turnId", default)]
7105    pub turn_id: String,
7106}
7107
7108/// `thread/project/updated` — a thread's project assignment changed.
7109#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7110pub struct ThreadProjectUpdatedNotification {
7111    #[serde(rename = "projectId", default)]
7112    pub project_id: Option<String>,
7113    #[serde(rename = "threadId", default)]
7114    pub thread_id: String,
7115}
7116
7117/// `thread/queue/changed` — the thread's queued submissions changed.
7118#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7119pub struct ThreadQueueChangedNotification {
7120    #[serde(rename = "threadId", default)]
7121    pub thread_id: String,
7122}
7123
7124/// `thread/reverted` — the thread was rolled back.
7125#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7126pub struct ThreadRevertedNotification {
7127    #[serde(rename = "threadId", default)]
7128    pub thread_id: String,
7129}
7130
7131/// `thread/prediction/updated` — a prediction requested for a turn finished
7132/// (`openai/codex@main` 90abcfac, experimental).
7133#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7134#[serde(rename_all = "camelCase")]
7135pub struct ThreadPredictionUpdatedNotification {
7136    pub result: ThreadPredictionResult,
7137    #[serde(rename = "sourceTurnId", default)]
7138    pub source_turn_id: String,
7139    #[serde(rename = "threadId", default)]
7140    pub thread_id: String,
7141}
7142
7143/// Outcome of a thread prediction (`openai/codex@main` 90abcfac).
7144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7145#[serde(tag = "type", rename_all = "camelCase")]
7146pub enum ThreadPredictionResult {
7147    Completed {
7148        #[serde(default, skip_serializing_if = "Option::is_none")]
7149        text: Option<String>,
7150    },
7151    Failed,
7152}
7153
7154/// In-app browser requirements (0.148 upstream).
7155#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7156#[serde(rename_all = "camelCase")]
7157pub struct InAppBrowserRequirements {
7158    #[serde(
7159        rename = "allowExternalBrowserSettingsImport",
7160        default,
7161        skip_serializing_if = "Option::is_none"
7162    )]
7163    pub allow_external_browser_settings_import: Option<bool>,
7164}
7165
7166/// One MCP-server-originated notification, relayed verbatim.
7167#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7168pub struct McpServerEventNotification {
7169    #[serde(default)]
7170    pub method: String,
7171    #[serde(default)]
7172    pub params: Value,
7173}
7174
7175/// `mcpServer/event/stream/notification` — an MCP server's own
7176/// notification stream, forwarded to subscribers.
7177#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7178pub struct McpServerEventStreamNotification {
7179    pub notification: McpServerEventNotification,
7180    #[serde(rename = "subscriptionId", default)]
7181    pub subscription_id: String,
7182}
7183
7184/// Allow/deny switch used across the browser-use / computer-use policy
7185/// surface (0.148 upstream).
7186#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7187pub enum AllowDenyRequirement {
7188    #[serde(rename = "allow")]
7189    Allow,
7190    #[serde(rename = "deny")]
7191    Deny,
7192}
7193
7194/// How long a granted browser-use access approval lasts.
7195#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7196pub enum BrowserUseAccessApprovalLifetime {
7197    #[serde(rename = "turn")]
7198    Turn,
7199    #[serde(rename = "thread")]
7200    Thread,
7201}
7202
7203/// Current thread-runtime MCP server connection state.
7204#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7205pub enum McpServerConnectionStatus {
7206    #[serde(rename = "notStarted")]
7207    NotStarted,
7208    #[serde(rename = "starting")]
7209    Starting,
7210    #[serde(rename = "connected")]
7211    Connected,
7212    #[serde(rename = "authenticationRequired")]
7213    AuthenticationRequired,
7214    #[serde(rename = "failed")]
7215    Failed,
7216    #[serde(rename = "cancelled")]
7217    Cancelled,
7218    #[serde(rename = "disabled")]
7219    Disabled,
7220}
7221
7222/// Per-origin browser-use policy (requirements side, camelCase wire).
7223#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7224#[serde(rename_all = "camelCase")]
7225pub struct BrowserUseOriginPolicy {
7226    #[serde(default, skip_serializing_if = "Option::is_none")]
7227    pub access: Option<AllowDenyRequirement>,
7228    #[serde(
7229        rename = "accessApprovalLifetime",
7230        default,
7231        skip_serializing_if = "Option::is_none"
7232    )]
7233    pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
7234    #[serde(
7235        rename = "autoReview",
7236        default,
7237        skip_serializing_if = "Option::is_none"
7238    )]
7239    pub auto_review: Option<AllowDenyRequirement>,
7240    #[serde(default, skip_serializing_if = "Option::is_none")]
7241    pub downloads: Option<AllowDenyRequirement>,
7242    #[serde(
7243        rename = "fullCdpAccess",
7244        default,
7245        skip_serializing_if = "Option::is_none"
7246    )]
7247    pub full_cdp_access: Option<AllowDenyRequirement>,
7248    #[serde(
7249        rename = "persistentApproval",
7250        default,
7251        skip_serializing_if = "Option::is_none"
7252    )]
7253    pub persistent_approval: Option<bool>,
7254    #[serde(default, skip_serializing_if = "Option::is_none")]
7255    pub uploads: Option<AllowDenyRequirement>,
7256}
7257
7258/// Per-origin browser-use policy (config side, snake_case wire).
7259#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7260pub struct BrowserUseOriginPolicyConfig {
7261    #[serde(default, skip_serializing_if = "Option::is_none")]
7262    pub access: Option<AllowDenyRequirement>,
7263    #[serde(default, skip_serializing_if = "Option::is_none")]
7264    pub downloads: Option<AllowDenyRequirement>,
7265    #[serde(default, skip_serializing_if = "Option::is_none")]
7266    pub full_cdp_access: Option<AllowDenyRequirement>,
7267    #[serde(default, skip_serializing_if = "Option::is_none")]
7268    pub uploads: Option<AllowDenyRequirement>,
7269}
7270
7271/// Browser-use configuration (config side, snake_case wire).
7272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7273pub struct BrowserUseConfig {
7274    #[serde(default, skip_serializing_if = "Option::is_none")]
7275    pub allow_history_access: Option<bool>,
7276    #[serde(default, skip_serializing_if = "Option::is_none")]
7277    pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
7278    #[serde(default, skip_serializing_if = "Option::is_none")]
7279    pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
7280}
7281
7282/// Computer-use configuration (config side, snake_case wire).
7283#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7284pub struct ComputerUseConfig {
7285    #[serde(default, skip_serializing_if = "Option::is_none")]
7286    pub default_app_access: Option<AllowDenyRequirement>,
7287    #[serde(default, skip_serializing_if = "Option::is_none")]
7288    pub macos: Option<ComputerUseMacosConfig>,
7289    #[serde(default, skip_serializing_if = "Option::is_none")]
7290    pub windows: Option<ComputerUseWindowsConfig>,
7291}
7292
7293#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7294pub struct ComputerUseMacosConfig {
7295    #[serde(default, skip_serializing_if = "Option::is_none")]
7296    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7297}
7298
7299#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7300pub struct ComputerUseWindowsConfig {
7301    #[serde(default, skip_serializing_if = "Option::is_none")]
7302    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7303    #[serde(default, skip_serializing_if = "Option::is_none")]
7304    pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
7305}
7306
7307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7308pub struct ComputerUseWindowsExeConfig {
7309    pub access: AllowDenyRequirement,
7310    #[serde(default, skip_serializing_if = "Option::is_none")]
7311    pub binary_name: Option<String>,
7312    #[serde(default)]
7313    pub product_name: String,
7314    #[serde(default)]
7315    pub publisher_name: String,
7316}
7317
7318/// Per-platform computer-use requirements (camelCase wire).
7319#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7320#[serde(rename_all = "camelCase")]
7321pub struct ComputerUseMacosRequirements {
7322    #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
7323    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7324}
7325
7326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7327#[serde(rename_all = "camelCase")]
7328pub struct ComputerUseWindowsRequirements {
7329    #[serde(default, skip_serializing_if = "Option::is_none")]
7330    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7331    #[serde(default, skip_serializing_if = "Option::is_none")]
7332    pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
7333}
7334
7335#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7336#[serde(rename_all = "camelCase")]
7337pub struct ComputerUseWindowsExeRequirement {
7338    pub access: AllowDenyRequirement,
7339    #[serde(
7340        rename = "binaryName",
7341        default,
7342        skip_serializing_if = "Option::is_none"
7343    )]
7344    pub binary_name: Option<String>,
7345    #[serde(rename = "productName", default)]
7346    pub product_name: String,
7347    #[serde(rename = "publisherName", default)]
7348    pub publisher_name: String,
7349}
7350
7351#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7352pub enum SandboxMode {
7353    #[serde(rename = "read-only")]
7354    Read_only,
7355    #[serde(rename = "workspace-write")]
7356    Workspace_write,
7357    #[serde(rename = "danger-full-access")]
7358    Danger_full_access,
7359}
7360
7361#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7362#[serde(tag = "type", rename_all = "camelCase")]
7363pub enum SandboxPolicy {
7364    #[serde(rename = "dangerFullAccess")]
7365    DangerFullAccess,
7366    #[serde(rename = "readOnly")]
7367    ReadOnly {
7368        #[serde(
7369            rename = "networkAccess",
7370            default,
7371            skip_serializing_if = "Option::is_none"
7372        )]
7373        network_access: Option<bool>,
7374    },
7375    #[serde(rename = "externalSandbox")]
7376    ExternalSandbox {
7377        #[serde(
7378            rename = "networkAccess",
7379            default,
7380            skip_serializing_if = "Option::is_none"
7381        )]
7382        network_access: Option<Value>,
7383    },
7384    #[serde(rename = "workspaceWrite")]
7385    WorkspaceWrite {
7386        #[serde(
7387            rename = "excludeSlashTmp",
7388            default,
7389            skip_serializing_if = "Option::is_none"
7390        )]
7391        exclude_slash_tmp: Option<bool>,
7392        #[serde(
7393            rename = "excludeTmpdirEnvVar",
7394            default,
7395            skip_serializing_if = "Option::is_none"
7396        )]
7397        exclude_tmpdir_env_var: Option<bool>,
7398        #[serde(
7399            rename = "networkAccess",
7400            default,
7401            skip_serializing_if = "Option::is_none"
7402        )]
7403        network_access: Option<bool>,
7404        #[serde(
7405            rename = "writableRoots",
7406            default,
7407            skip_serializing_if = "Option::is_none"
7408        )]
7409        writable_roots: Option<Vec<AbsolutePathBuf>>,
7410    },
7411}
7412
7413#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7414#[serde(rename_all = "snake_case")]
7415pub struct SandboxWorkspaceWrite {
7416    #[serde(default, skip_serializing_if = "Option::is_none")]
7417    pub exclude_slash_tmp: Option<bool>,
7418    #[serde(default, skip_serializing_if = "Option::is_none")]
7419    pub exclude_tmpdir_env_var: Option<bool>,
7420    #[serde(default, skip_serializing_if = "Option::is_none")]
7421    pub network_access: Option<bool>,
7422    #[serde(default, skip_serializing_if = "Option::is_none")]
7423    pub writable_roots: Option<Vec<String>>,
7424}
7425
7426#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7427#[serde(tag = "type", rename_all = "camelCase")]
7428pub enum ScheduledTaskSchedule {
7429    Hourly {
7430        #[serde(default, skip_serializing_if = "Option::is_none")]
7431        days: Option<Vec<ScheduledTaskWeekday>>,
7432        #[serde(rename = "intervalHours")]
7433        interval_hours: i64,
7434    },
7435    Daily {
7436        time: String,
7437    },
7438    Weekdays {
7439        time: String,
7440    },
7441    Weekly {
7442        days: Vec<ScheduledTaskWeekday>,
7443        time: String,
7444    },
7445}
7446
7447#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7448#[serde(rename_all = "camelCase")]
7449pub struct ScheduledTaskSummary {
7450    #[serde(default)]
7451    pub key: String,
7452    #[serde(default)]
7453    pub name: String,
7454    #[serde(default)]
7455    pub prompt: String,
7456    #[serde()]
7457    pub schedule: ScheduledTaskSchedule,
7458}
7459
7460#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7461pub enum ScheduledTaskWeekday {
7462    #[serde(rename = "MO")]
7463    MO,
7464    #[serde(rename = "TU")]
7465    TU,
7466    #[serde(rename = "WE")]
7467    WE,
7468    #[serde(rename = "TH")]
7469    TH,
7470    #[serde(rename = "FR")]
7471    FR,
7472    #[serde(rename = "SA")]
7473    SA,
7474    #[serde(rename = "SU")]
7475    SU,
7476}
7477
7478#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7479#[serde(rename_all = "camelCase")]
7480pub struct SendAddCreditsNudgeEmailParams {
7481    #[serde(rename = "creditType")]
7482    pub credit_type: AddCreditsNudgeCreditType,
7483}
7484
7485#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7486#[serde(rename_all = "camelCase")]
7487pub struct SendAddCreditsNudgeEmailResponse {
7488    #[serde()]
7489    pub status: AddCreditsNudgeEmailStatus,
7490}
7491
7492#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7493#[serde(rename_all = "camelCase")]
7494pub struct ServerRequestResolvedNotification {
7495    #[serde(rename = "requestId")]
7496    pub request_id: RequestId,
7497    #[serde(rename = "threadId", default)]
7498    pub thread_id: String,
7499}
7500
7501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7502#[serde(rename_all = "camelCase")]
7503pub struct SessionMigration {
7504    #[serde(default)]
7505    pub cwd: String,
7506    #[serde(default)]
7507    pub path: String,
7508    #[serde(default, skip_serializing_if = "Option::is_none")]
7509    pub title: Option<String>,
7510}
7511
7512#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7513pub enum SessionSource {
7514    #[serde(rename = "cli")]
7515    Cli,
7516    #[serde(rename = "vscode")]
7517    Vscode,
7518    #[serde(rename = "exec")]
7519    Exec,
7520    #[serde(rename = "appServer")]
7521    AppServer,
7522    #[serde(rename = "unknown")]
7523    Unknown,
7524    #[serde(rename = "custom")]
7525    Custom(String),
7526    #[serde(rename = "subAgent")]
7527    SubAgent(SubAgentSource),
7528}
7529
7530#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7531#[serde(rename_all = "camelCase")]
7532pub struct Settings {
7533    #[serde(default, skip_serializing_if = "Option::is_none")]
7534    pub developer_instructions: Option<String>,
7535    #[serde(default)]
7536    pub model: String,
7537    #[serde(default, skip_serializing_if = "Option::is_none")]
7538    pub reasoning_effort: Option<ReasoningEffort>,
7539}
7540
7541#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7542#[serde(rename_all = "camelCase")]
7543pub struct SkillDependencies {
7544    #[serde(default)]
7545    pub tools: Vec<SkillToolDependency>,
7546}
7547
7548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7549#[serde(rename_all = "camelCase")]
7550pub struct SkillErrorInfo {
7551    #[serde(default)]
7552    pub message: String,
7553    #[serde(default)]
7554    pub path: String,
7555}
7556
7557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7558#[serde(rename_all = "camelCase")]
7559pub struct SkillInterface {
7560    #[serde(
7561        rename = "brandColor",
7562        default,
7563        skip_serializing_if = "Option::is_none"
7564    )]
7565    pub brand_color: Option<String>,
7566    #[serde(
7567        rename = "defaultPrompt",
7568        default,
7569        skip_serializing_if = "Option::is_none"
7570    )]
7571    pub default_prompt: Option<String>,
7572    #[serde(
7573        rename = "displayName",
7574        default,
7575        skip_serializing_if = "Option::is_none"
7576    )]
7577    pub display_name: Option<String>,
7578    #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
7579    pub icon_large: Option<AbsolutePathBuf>,
7580    #[serde(
7581        rename = "iconLargeUrl",
7582        default,
7583        skip_serializing_if = "Option::is_none"
7584    )]
7585    pub icon_large_url: Option<String>,
7586    #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
7587    pub icon_small: Option<AbsolutePathBuf>,
7588    #[serde(
7589        rename = "iconSmallUrl",
7590        default,
7591        skip_serializing_if = "Option::is_none"
7592    )]
7593    pub icon_small_url: Option<String>,
7594    #[serde(
7595        rename = "shortDescription",
7596        default,
7597        skip_serializing_if = "Option::is_none"
7598    )]
7599    pub short_description: Option<String>,
7600}
7601
7602#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7603#[serde(rename_all = "camelCase")]
7604pub struct SkillMetadata {
7605    #[serde(default, skip_serializing_if = "Option::is_none")]
7606    pub dependencies: Option<SkillDependencies>,
7607    #[serde(default)]
7608    pub description: String,
7609    #[serde(default)]
7610    pub enabled: bool,
7611    #[serde(default, skip_serializing_if = "Option::is_none")]
7612    pub interface: Option<SkillInterface>,
7613    #[serde(default)]
7614    pub name: String,
7615    #[serde()]
7616    pub path: LegacyAppPathString,
7617    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7618    pub plugin_id: Option<String>,
7619    #[serde()]
7620    pub scope: SkillScope,
7621    #[serde(
7622        rename = "shortDescription",
7623        default,
7624        skip_serializing_if = "Option::is_none"
7625    )]
7626    pub short_description: Option<String>,
7627}
7628
7629#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7630#[serde(rename_all = "camelCase")]
7631pub struct SkillMigration {
7632    #[serde(default)]
7633    pub name: String,
7634}
7635
7636#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7637pub enum SkillScope {
7638    #[serde(rename = "user")]
7639    User,
7640    #[serde(rename = "repo")]
7641    Repo,
7642    #[serde(rename = "system")]
7643    System,
7644    #[serde(rename = "admin")]
7645    Admin,
7646}
7647
7648#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7649#[serde(rename_all = "camelCase")]
7650pub struct SkillSummary {
7651    #[serde(default)]
7652    pub description: String,
7653    #[serde(default)]
7654    pub enabled: bool,
7655    #[serde(default, skip_serializing_if = "Option::is_none")]
7656    pub interface: Option<SkillInterface>,
7657    #[serde(default)]
7658    pub name: String,
7659    #[serde(default, skip_serializing_if = "Option::is_none")]
7660    pub path: Option<LegacyAppPathString>,
7661    #[serde(
7662        rename = "shortDescription",
7663        default,
7664        skip_serializing_if = "Option::is_none"
7665    )]
7666    pub short_description: Option<String>,
7667}
7668
7669#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7670#[serde(rename_all = "camelCase")]
7671pub struct SkillToolDependency {
7672    #[serde(default, skip_serializing_if = "Option::is_none")]
7673    pub command: Option<String>,
7674    #[serde(default, skip_serializing_if = "Option::is_none")]
7675    pub description: Option<String>,
7676    #[serde(default, skip_serializing_if = "Option::is_none")]
7677    pub transport: Option<String>,
7678    #[serde(rename = "type", default)]
7679    pub type_: String,
7680    #[serde(default, skip_serializing_if = "Option::is_none")]
7681    pub url: Option<String>,
7682    #[serde(default)]
7683    pub value: String,
7684}
7685
7686#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7687#[serde(rename_all = "camelCase")]
7688pub struct SkillsChangedNotification {
7689    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7690    pub extra: serde_json::Map<String, Value>,
7691}
7692
7693#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7694#[serde(rename_all = "camelCase")]
7695pub struct SkillsConfigWriteParams {
7696    #[serde(default)]
7697    pub enabled: bool,
7698    #[serde(default, skip_serializing_if = "Option::is_none")]
7699    pub name: Option<String>,
7700    #[serde(default, skip_serializing_if = "Option::is_none")]
7701    pub path: Option<AbsolutePathBuf>,
7702}
7703
7704#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7705#[serde(rename_all = "camelCase")]
7706pub struct SkillsConfigWriteResponse {
7707    #[serde(rename = "effectiveEnabled", default)]
7708    pub effective_enabled: bool,
7709}
7710
7711#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7712#[serde(rename_all = "camelCase")]
7713pub struct SkillsExtraRootsSetParams {
7714    #[serde(rename = "extraRoots", default)]
7715    pub extra_roots: Vec<AbsolutePathBuf>,
7716}
7717
7718#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7719#[serde(rename_all = "camelCase")]
7720pub struct SkillsExtraRootsSetResponse {
7721    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7722    pub extra: serde_json::Map<String, Value>,
7723}
7724
7725#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7726#[serde(rename_all = "camelCase")]
7727pub struct SkillsListEntry {
7728    #[serde(default)]
7729    pub cwd: String,
7730    #[serde(default)]
7731    pub errors: Vec<SkillErrorInfo>,
7732    #[serde(default)]
7733    pub skills: Vec<SkillMetadata>,
7734}
7735
7736#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7737#[serde(rename_all = "camelCase")]
7738pub struct SkillsListParams {
7739    #[serde(default, skip_serializing_if = "Option::is_none")]
7740    pub cwds: Option<Vec<String>>,
7741    #[serde(
7742        rename = "forceReload",
7743        default,
7744        skip_serializing_if = "Option::is_none"
7745    )]
7746    pub force_reload: Option<bool>,
7747}
7748
7749#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7750#[serde(rename_all = "camelCase")]
7751pub struct SkillsListResponse {
7752    #[serde(default)]
7753    pub data: Vec<SkillsListEntry>,
7754}
7755
7756#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7757pub enum SortDirection {
7758    #[serde(rename = "asc")]
7759    Asc,
7760    #[serde(rename = "desc")]
7761    Desc,
7762}
7763
7764#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7765#[serde(rename_all = "camelCase")]
7766pub struct SpendControlLimitSnapshot {
7767    #[serde(default)]
7768    pub limit: String,
7769    #[serde(rename = "remainingPercent", default)]
7770    pub remaining_percent: i64,
7771    #[serde(rename = "resetsAt", default)]
7772    pub resets_at: i64,
7773    #[serde(default)]
7774    pub used: String,
7775}
7776
7777#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7778pub enum SubAgentActivityKind {
7779    #[serde(rename = "started")]
7780    Started,
7781    #[serde(rename = "interacted")]
7782    Interacted,
7783    #[serde(rename = "interrupted")]
7784    Interrupted,
7785    #[serde(rename = "completed")]
7786    Completed,
7787}
7788
7789#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7790pub enum SubAgentSource {
7791    #[serde(rename = "review")]
7792    Review,
7793    #[serde(rename = "compact")]
7794    Compact,
7795    #[serde(rename = "memory_consolidation")]
7796    MemoryConsolidation,
7797    #[serde(rename = "thread_spawn")]
7798    ThreadSpawn {
7799        #[serde(default, skip_serializing_if = "Option::is_none")]
7800        agent_nickname: Option<String>,
7801        #[serde(default, skip_serializing_if = "Option::is_none")]
7802        agent_path: Option<AgentPath>,
7803        #[serde(default, skip_serializing_if = "Option::is_none")]
7804        agent_role: Option<String>,
7805        depth: i64,
7806        parent_thread_id: ThreadId,
7807    },
7808    #[serde(rename = "other")]
7809    Other(String),
7810}
7811
7812#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7813#[serde(rename_all = "camelCase")]
7814pub struct SubagentMigration {
7815    #[serde(default)]
7816    pub name: String,
7817}
7818
7819#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7820#[serde(rename_all = "camelCase")]
7821pub struct TerminalInteractionNotification {
7822    #[serde(rename = "itemId", default)]
7823    pub item_id: String,
7824    #[serde(rename = "processId", default)]
7825    pub process_id: String,
7826    #[serde(default)]
7827    pub stdin: String,
7828    #[serde(rename = "threadId", default)]
7829    pub thread_id: String,
7830    #[serde(rename = "turnId", default)]
7831    pub turn_id: String,
7832}
7833
7834#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7835#[serde(rename_all = "camelCase")]
7836pub struct TextElement {
7837    #[serde(rename = "byteRange", default)]
7838    pub byte_range: Value,
7839    #[serde(default, skip_serializing_if = "Option::is_none")]
7840    pub placeholder: Option<String>,
7841}
7842
7843#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7844#[serde(rename_all = "camelCase")]
7845pub struct TextPosition {
7846    #[serde(default)]
7847    pub column: i64,
7848    #[serde(default)]
7849    pub line: i64,
7850}
7851
7852#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7853#[serde(rename_all = "camelCase")]
7854pub struct TextRange {
7855    #[serde()]
7856    pub end: TextPosition,
7857    #[serde()]
7858    pub start: TextPosition,
7859}
7860
7861#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7862#[serde(rename_all = "camelCase")]
7863pub struct Thread {
7864    #[serde(
7865        rename = "agentNickname",
7866        default,
7867        skip_serializing_if = "Option::is_none"
7868    )]
7869    pub agent_nickname: Option<String>,
7870    #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
7871    pub agent_role: Option<String>,
7872    #[serde(rename = "cliVersion", default)]
7873    pub cli_version: String,
7874    #[serde(rename = "createdAt", default)]
7875    pub created_at: i64,
7876    #[serde(default)]
7877    pub cwd: Value,
7878    #[serde(default)]
7879    pub ephemeral: bool,
7880    #[serde(
7881        rename = "forkedFromId",
7882        default,
7883        skip_serializing_if = "Option::is_none"
7884    )]
7885    pub forked_from_id: Option<String>,
7886    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
7887    pub git_info: Option<GitInfo>,
7888    /// Persisted history contract chosen at thread creation (0.148 upstream);
7889    /// absent on older servers, which are always `legacy`.
7890    #[serde(
7891        rename = "historyMode",
7892        default,
7893        skip_serializing_if = "Option::is_none"
7894    )]
7895    pub history_mode: Option<ThreadHistoryMode>,
7896    /// Canonical project assignment owned by app-server, if any. Required
7897    /// upstream from 0.147 but kept tolerant for pre-project servers.
7898    #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
7899    pub project_id: Option<String>,
7900    #[serde(default)]
7901    pub id: String,
7902    /// Current configured model when loaded, otherwise the latest persisted
7903    /// model. Null when unavailable. Not per-turn execution telemetry.
7904    #[serde(default, skip_serializing_if = "Option::is_none")]
7905    pub model: Option<String>,
7906    #[serde(rename = "modelProvider", default)]
7907    pub model_provider: String,
7908    #[serde(default, skip_serializing_if = "Option::is_none")]
7909    pub name: Option<String>,
7910    /// Originator recorded when the thread was created, independent of its
7911    /// current client or executor. `None` when the recorded originator is
7912    /// unavailable.
7913    #[serde(default, skip_serializing_if = "Option::is_none")]
7914    pub originator: Option<String>,
7915    #[serde(
7916        rename = "parentThreadId",
7917        default,
7918        skip_serializing_if = "Option::is_none"
7919    )]
7920    pub parent_thread_id: Option<String>,
7921    #[serde(default, skip_serializing_if = "Option::is_none")]
7922    pub path: Option<String>,
7923    #[serde(default)]
7924    pub preview: String,
7925    /// Current configured reasoning effort when loaded, otherwise the latest
7926    /// persisted effort. Null when unset or unavailable. Not per-turn
7927    /// execution telemetry.
7928    #[serde(
7929        rename = "reasoningEffort",
7930        default,
7931        skip_serializing_if = "Option::is_none"
7932    )]
7933    pub reasoning_effort: Option<ReasoningEffort>,
7934    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7935    pub recency_at: Option<i64>,
7936    #[serde(default, skip_serializing_if = "Option::is_none")]
7937    pub section: Option<ThreadSection>,
7938    #[serde(
7939        rename = "sectionEnteredAt",
7940        default,
7941        skip_serializing_if = "Option::is_none"
7942    )]
7943    pub section_entered_at: Option<i64>,
7944    #[serde(rename = "sessionId", default)]
7945    pub session_id: String,
7946    #[serde(default)]
7947    pub source: Value,
7948    #[serde(default)]
7949    pub status: Value,
7950    #[serde(
7951        rename = "threadSource",
7952        default,
7953        skip_serializing_if = "Option::is_none"
7954    )]
7955    pub thread_source: Option<ThreadSource>,
7956    #[serde(default)]
7957    pub turns: Vec<Turn>,
7958    #[serde(rename = "updatedAt", default)]
7959    pub updated_at: i64,
7960}
7961
7962#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7963pub enum ThreadActiveFlag {
7964    #[serde(rename = "waitingOnApproval")]
7965    WaitingOnApproval,
7966    #[serde(rename = "waitingOnUserInput")]
7967    WaitingOnUserInput,
7968}
7969
7970#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7971#[serde(rename_all = "camelCase")]
7972pub struct ThreadApproveGuardianDeniedActionParams {
7973    #[serde(default)]
7974    pub event: Value,
7975    #[serde(rename = "threadId", default)]
7976    pub thread_id: String,
7977}
7978
7979#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7980#[serde(rename_all = "camelCase")]
7981pub struct ThreadApproveGuardianDeniedActionResponse {
7982    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7983    pub extra: serde_json::Map<String, Value>,
7984}
7985
7986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7987#[serde(rename_all = "camelCase")]
7988pub struct ThreadArchiveParams {
7989    #[serde(rename = "threadId", default)]
7990    pub thread_id: String,
7991}
7992
7993#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7994#[serde(rename_all = "camelCase")]
7995pub struct ThreadArchiveResponse {
7996    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7997    pub extra: serde_json::Map<String, Value>,
7998}
7999
8000#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8001#[serde(rename_all = "camelCase")]
8002pub struct ThreadArchivedNotification {
8003    #[serde(rename = "threadId", default)]
8004    pub thread_id: String,
8005}
8006
8007/// An independently persisted attachment associated with a thread.
8008#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8009#[serde(rename_all = "camelCase")]
8010pub struct ThreadAttachment {
8011    #[serde(rename = "attachmentType", default)]
8012    pub attachment_type: String,
8013    #[serde(rename = "createdAt", default)]
8014    pub created_at: i64,
8015    #[serde(default)]
8016    pub id: String,
8017    #[serde(rename = "identityKey", default)]
8018    pub identity_key: String,
8019    #[serde(default)]
8020    pub payload: Value,
8021}
8022
8023/// Result of attempting to associate an attachment with a thread.
8024#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8025pub enum ThreadAttachmentAddOutcome {
8026    #[serde(rename = "created")]
8027    Created,
8028    #[serde(rename = "existing")]
8029    Existing,
8030}
8031
8032/// Parameters for creating or locating an attachment on its owning thread.
8033#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8034#[serde(rename_all = "camelCase")]
8035pub struct ThreadAttachmentAddParams {
8036    #[serde(rename = "attachmentType", default)]
8037    pub attachment_type: String,
8038    #[serde(rename = "identityKey", default)]
8039    pub identity_key: String,
8040    #[serde(default)]
8041    pub payload: Value,
8042    #[serde(rename = "threadId", default)]
8043    pub thread_id: String,
8044}
8045
8046/// The created or existing attachment.
8047#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8048#[serde(rename_all = "camelCase")]
8049pub struct ThreadAttachmentAddResponse {
8050    pub attachment: ThreadAttachment,
8051    pub outcome: ThreadAttachmentAddOutcome,
8052}
8053
8054/// Parameters for listing attachments from one thread.
8055#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8056#[serde(rename_all = "camelCase")]
8057pub struct ThreadAttachmentListParams {
8058    #[serde(default, skip_serializing_if = "Option::is_none")]
8059    pub cursor: Option<String>,
8060    #[serde(default, skip_serializing_if = "Option::is_none")]
8061    pub limit: Option<i64>,
8062    #[serde(rename = "threadId", default)]
8063    pub thread_id: String,
8064}
8065
8066/// One page of attachments associated with the requested thread.
8067#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8068#[serde(rename_all = "camelCase")]
8069pub struct ThreadAttachmentListResponse {
8070    #[serde(default)]
8071    pub data: Vec<ThreadAttachment>,
8072    #[serde(
8073        rename = "nextCursor",
8074        default,
8075        skip_serializing_if = "Option::is_none"
8076    )]
8077    pub next_cursor: Option<String>,
8078}
8079
8080/// The persisted attachment change represented by a notification.
8081#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8082pub enum ThreadAttachmentOperation {
8083    #[serde(rename = "created")]
8084    Created,
8085    #[serde(rename = "deleted")]
8086    Deleted,
8087}
8088
8089/// A thread that currently owns an attachment with the requested identity.
8090#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8091#[serde(rename_all = "camelCase")]
8092pub struct ThreadAttachmentOwner {
8093    /// Whether the owning thread is archived, not whether it is currently executing a turn.
8094    #[serde(default)]
8095    pub archived: bool,
8096    #[serde(rename = "threadId", default)]
8097    pub thread_id: String,
8098}
8099
8100/// Parameters for reverse lookup by attachment identity within this server's store.
8101#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8102#[serde(rename_all = "camelCase")]
8103pub struct ThreadAttachmentOwnerListParams {
8104    /// Omitted or null returns all matches; false returns non-archived threads only.
8105    #[serde(default, skip_serializing_if = "Option::is_none")]
8106    pub archived: Option<bool>,
8107    #[serde(rename = "attachmentType", default)]
8108    pub attachment_type: String,
8109    #[serde(default, skip_serializing_if = "Option::is_none")]
8110    pub cursor: Option<String>,
8111    #[serde(rename = "identityKey", default)]
8112    pub identity_key: String,
8113    #[serde(default, skip_serializing_if = "Option::is_none")]
8114    pub limit: Option<i64>,
8115}
8116
8117/// One page of matching owners, including threads without their own user messages.
8118#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8119#[serde(rename_all = "camelCase")]
8120pub struct ThreadAttachmentOwnerListResponse {
8121    #[serde(default)]
8122    pub data: Vec<ThreadAttachmentOwner>,
8123    #[serde(
8124        rename = "nextCursor",
8125        default,
8126        skip_serializing_if = "Option::is_none"
8127    )]
8128    pub next_cursor: Option<String>,
8129}
8130
8131/// Parameters for deleting an attachment by its stable thread-local identity.
8132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8133#[serde(rename_all = "camelCase")]
8134pub struct ThreadAttachmentRemoveParams {
8135    #[serde(rename = "attachmentType", default)]
8136    pub attachment_type: String,
8137    #[serde(rename = "identityKey", default)]
8138    pub identity_key: String,
8139    #[serde(rename = "threadId", default)]
8140    pub thread_id: String,
8141}
8142
8143/// Successful deletion does not return additional attachment data.
8144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8145#[serde(rename_all = "camelCase")]
8146pub struct ThreadAttachmentRemoveResponse {
8147    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8148    pub extra: serde_json::Map<String, Value>,
8149}
8150
8151/// Notification published after a thread attachment is created or deleted.
8152#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8153#[serde(rename_all = "camelCase")]
8154pub struct ThreadAttachmentUpdatedNotification {
8155    #[serde(rename = "attachmentId", default)]
8156    pub attachment_id: String,
8157    #[serde(rename = "attachmentType", default)]
8158    pub attachment_type: String,
8159    #[serde(rename = "identityKey", default)]
8160    pub identity_key: String,
8161    pub operation: ThreadAttachmentOperation,
8162    #[serde(rename = "threadId", default)]
8163    pub thread_id: String,
8164}
8165
8166#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8167#[serde(rename_all = "camelCase")]
8168pub struct ThreadClosedNotification {
8169    #[serde(rename = "threadId", default)]
8170    pub thread_id: String,
8171}
8172
8173#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8174#[serde(rename_all = "camelCase")]
8175pub struct ThreadCompactStartParams {
8176    #[serde(rename = "threadId", default)]
8177    pub thread_id: String,
8178}
8179
8180#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8181#[serde(rename_all = "camelCase")]
8182pub struct ThreadCompactStartResponse {
8183    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8184    pub extra: serde_json::Map<String, Value>,
8185}
8186
8187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8188#[serde(rename_all = "camelCase")]
8189pub struct ThreadDeleteParams {
8190    #[serde(rename = "threadId", default)]
8191    pub thread_id: String,
8192}
8193
8194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8195#[serde(rename_all = "camelCase")]
8196pub struct ThreadDeleteResponse {
8197    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8198    pub extra: serde_json::Map<String, Value>,
8199}
8200
8201#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8202#[serde(rename_all = "camelCase")]
8203pub struct ThreadDeletedNotification {
8204    #[serde(rename = "threadId", default)]
8205    pub thread_id: String,
8206}
8207
8208#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8209#[serde(rename_all = "camelCase")]
8210pub struct ThreadForkParams {
8211    #[serde(
8212        rename = "approvalPolicy",
8213        default,
8214        skip_serializing_if = "Option::is_none"
8215    )]
8216    pub approval_policy: Option<AskForApproval>,
8217    #[serde(
8218        rename = "approvalsReviewer",
8219        default,
8220        skip_serializing_if = "Option::is_none"
8221    )]
8222    pub approvals_reviewer: Option<ApprovalsReviewer>,
8223    #[serde(
8224        rename = "baseInstructions",
8225        default,
8226        skip_serializing_if = "Option::is_none"
8227    )]
8228    pub base_instructions: Option<String>,
8229    #[serde(default, skip_serializing_if = "Option::is_none")]
8230    pub config: Option<Value>,
8231    #[serde(default, skip_serializing_if = "Option::is_none")]
8232    pub cwd: Option<String>,
8233    #[serde(
8234        rename = "developerInstructions",
8235        default,
8236        skip_serializing_if = "Option::is_none"
8237    )]
8238    pub developer_instructions: Option<String>,
8239    #[serde(default, skip_serializing_if = "Option::is_none")]
8240    pub ephemeral: Option<bool>,
8241    #[serde(
8242        rename = "excludeTurns",
8243        default,
8244        skip_serializing_if = "Option::is_none"
8245    )]
8246    pub exclude_turns: Option<bool>,
8247    #[serde(
8248        rename = "lastTurnId",
8249        default,
8250        skip_serializing_if = "Option::is_none"
8251    )]
8252    pub last_turn_id: Option<String>,
8253    #[serde(default, skip_serializing_if = "Option::is_none")]
8254    pub model: Option<String>,
8255    #[serde(
8256        rename = "modelProvider",
8257        default,
8258        skip_serializing_if = "Option::is_none"
8259    )]
8260    pub model_provider: Option<String>,
8261    #[serde(default, skip_serializing_if = "Option::is_none")]
8262    pub sandbox: Option<SandboxMode>,
8263    #[serde(
8264        rename = "serviceTier",
8265        default,
8266        skip_serializing_if = "Option::is_none"
8267    )]
8268    pub service_tier: Option<String>,
8269    #[serde(rename = "threadId", default)]
8270    pub thread_id: String,
8271    #[serde(
8272        rename = "threadSource",
8273        default,
8274        skip_serializing_if = "Option::is_none"
8275    )]
8276    pub thread_source: Option<ThreadSource>,
8277}
8278
8279#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8280#[serde(rename_all = "camelCase")]
8281pub struct ThreadForkResponse {
8282    #[serde(rename = "approvalPolicy")]
8283    pub approval_policy: AskForApproval,
8284    #[serde(rename = "approvalsReviewer", default)]
8285    pub approvals_reviewer: Value,
8286    #[serde()]
8287    pub cwd: AbsolutePathBuf,
8288    /// Saved list of disabled plugin IDs. Does not yet filter plugin
8289    /// capabilities.
8290    #[serde(rename = "disabledPluginIds", default)]
8291    pub disabled_plugin_ids: Vec<String>,
8292    #[serde(
8293        rename = "instructionSources",
8294        default,
8295        skip_serializing_if = "Option::is_none"
8296    )]
8297    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8298    #[serde(default)]
8299    pub model: String,
8300    #[serde(rename = "modelProvider", default)]
8301    pub model_provider: String,
8302    #[serde(
8303        rename = "reasoningEffort",
8304        default,
8305        skip_serializing_if = "Option::is_none"
8306    )]
8307    pub reasoning_effort: Option<ReasoningEffort>,
8308    #[serde(default)]
8309    pub sandbox: Value,
8310    #[serde(
8311        rename = "serviceTier",
8312        default,
8313        skip_serializing_if = "Option::is_none"
8314    )]
8315    pub service_tier: Option<String>,
8316    #[serde()]
8317    pub thread: Thread,
8318}
8319
8320#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8321#[serde(rename_all = "camelCase")]
8322pub struct ThreadGoal {
8323    #[serde(rename = "createdAt", default)]
8324    pub created_at: i64,
8325    #[serde(default)]
8326    pub objective: String,
8327    #[serde()]
8328    pub status: ThreadGoalStatus,
8329    #[serde(rename = "threadId", default)]
8330    pub thread_id: String,
8331    #[serde(rename = "timeUsedSeconds", default)]
8332    pub time_used_seconds: i64,
8333    #[serde(
8334        rename = "tokenBudget",
8335        default,
8336        skip_serializing_if = "Option::is_none"
8337    )]
8338    pub token_budget: Option<i64>,
8339    #[serde(rename = "tokensUsed", default)]
8340    pub tokens_used: i64,
8341    #[serde(rename = "updatedAt", default)]
8342    pub updated_at: i64,
8343}
8344
8345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8346#[serde(rename_all = "camelCase")]
8347pub struct ThreadGoalClearParams {
8348    /// Missing provenance does not supply user authorization.
8349    #[serde(default, skip_serializing_if = "Option::is_none")]
8350    pub origin: Option<ThreadGoalMutationOrigin>,
8351    #[serde(rename = "threadId", default)]
8352    pub thread_id: String,
8353}
8354
8355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8356#[serde(rename_all = "camelCase")]
8357pub struct ThreadGoalClearResponse {
8358    #[serde(default)]
8359    pub cleared: bool,
8360}
8361
8362#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8363#[serde(rename_all = "camelCase")]
8364pub struct ThreadGoalClearedNotification {
8365    #[serde(rename = "threadId", default)]
8366    pub thread_id: String,
8367}
8368
8369#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8370#[serde(rename_all = "camelCase")]
8371pub struct ThreadGoalGetParams {
8372    #[serde(rename = "threadId", default)]
8373    pub thread_id: String,
8374}
8375
8376#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8377#[serde(rename_all = "camelCase")]
8378pub struct ThreadGoalGetResponse {
8379    #[serde(default, skip_serializing_if = "Option::is_none")]
8380    pub goal: Option<ThreadGoal>,
8381}
8382
8383/// Distinguishes explicit user actions from automatic goal lifecycle mutations.
8384#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8385pub enum ThreadGoalMutationOrigin {
8386    #[serde(rename = "user")]
8387    User,
8388    #[serde(rename = "automatic")]
8389    Automatic,
8390}
8391
8392#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8393#[serde(rename_all = "camelCase")]
8394pub struct ThreadGoalSetParams {
8395    #[serde(default, skip_serializing_if = "Option::is_none")]
8396    pub objective: Option<String>,
8397    /// Missing provenance does not supply user authorization.
8398    #[serde(default, skip_serializing_if = "Option::is_none")]
8399    pub origin: Option<ThreadGoalMutationOrigin>,
8400    #[serde(default, skip_serializing_if = "Option::is_none")]
8401    pub status: Option<ThreadGoalStatus>,
8402    #[serde(rename = "threadId", default)]
8403    pub thread_id: String,
8404    #[serde(
8405        rename = "tokenBudget",
8406        default,
8407        skip_serializing_if = "Option::is_none"
8408    )]
8409    pub token_budget: Option<i64>,
8410}
8411
8412#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8413#[serde(rename_all = "camelCase")]
8414pub struct ThreadGoalSetResponse {
8415    #[serde()]
8416    pub goal: ThreadGoal,
8417}
8418
8419#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8420pub enum ThreadGoalStatus {
8421    #[serde(rename = "active")]
8422    Active,
8423    #[serde(rename = "paused")]
8424    Paused,
8425    #[serde(rename = "blocked")]
8426    Blocked,
8427    #[serde(rename = "usageLimited")]
8428    UsageLimited,
8429    #[serde(rename = "budgetLimited")]
8430    BudgetLimited,
8431    #[serde(rename = "complete")]
8432    Complete,
8433}
8434
8435#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8436#[serde(rename_all = "camelCase")]
8437pub struct ThreadGoalUpdatedNotification {
8438    #[serde()]
8439    pub goal: ThreadGoal,
8440    #[serde(rename = "threadId", default)]
8441    pub thread_id: String,
8442    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8443    pub turn_id: Option<String>,
8444}
8445
8446#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
8447#[serde(transparent)]
8448pub struct ThreadId(pub String);
8449
8450#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8451#[serde(rename_all = "camelCase")]
8452pub struct ThreadInjectItemsParams {
8453    #[serde(default)]
8454    pub items: Vec<Value>,
8455    #[serde(rename = "threadId", default)]
8456    pub thread_id: String,
8457}
8458
8459#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8460#[serde(rename_all = "camelCase")]
8461pub struct ThreadInjectItemsResponse {
8462    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8463    pub extra: serde_json::Map<String, Value>,
8464}
8465
8466/// A thread item and its recorded lifecycle times. The payload stays flat on the wire.
8467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8468#[serde(rename_all = "camelCase")]
8469pub struct ThreadItem {
8470    #[serde(flatten)]
8471    pub payload: ThreadItemPayload,
8472    /// Unix timestamp in milliseconds when the item started, if recorded.
8473    #[serde(
8474        rename = "startedAtMs",
8475        default,
8476        skip_serializing_if = "Option::is_none"
8477    )]
8478    pub started_at_ms: Option<i64>,
8479    /// Unix timestamp in milliseconds when the item completed, if recorded.
8480    #[serde(
8481        rename = "completedAtMs",
8482        default,
8483        skip_serializing_if = "Option::is_none"
8484    )]
8485    pub completed_at_ms: Option<i64>,
8486}
8487
8488impl ThreadItem {
8489    /// Creates an item with no recorded start or completion time.
8490    pub fn untimed(payload: ThreadItemPayload) -> Self {
8491        Self {
8492            payload,
8493            started_at_ms: None,
8494            completed_at_ms: None,
8495        }
8496    }
8497}
8498
8499impl From<ThreadItemPayload> for ThreadItem {
8500    fn from(payload: ThreadItemPayload) -> Self {
8501        Self::untimed(payload)
8502    }
8503}
8504
8505/// The type-tagged body of a [`ThreadItem`], flattened into it on the wire.
8506#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8507#[serde(tag = "type", rename_all = "camelCase")]
8508pub enum ThreadItemPayload {
8509    #[serde(rename = "userMessage")]
8510    UserMessage {
8511        #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
8512        client_id: Option<String>,
8513        content: Vec<UserInput>,
8514        id: String,
8515    },
8516    #[serde(rename = "hookPrompt")]
8517    HookPrompt {
8518        fragments: Vec<HookPromptFragment>,
8519        id: String,
8520    },
8521    #[serde(rename = "agentMessage")]
8522    AgentMessage {
8523        #[serde(default, skip_serializing_if = "Option::is_none")]
8524        delivery: Option<AgentMessageDelivery>,
8525        id: String,
8526        #[serde(
8527            rename = "memoryCitation",
8528            default,
8529            skip_serializing_if = "Option::is_none"
8530        )]
8531        memory_citation: Option<MemoryCitation>,
8532        #[serde(default, skip_serializing_if = "Option::is_none")]
8533        moderation: Option<AgentMessageModeration>,
8534        #[serde(default, skip_serializing_if = "Option::is_none")]
8535        phase: Option<MessagePhase>,
8536        #[serde(default, skip_serializing_if = "Option::is_none")]
8537        questions: Option<Vec<AsyncUserInputQuestion>>,
8538        text: String,
8539    },
8540    Plan {
8541        id: String,
8542        text: String,
8543    },
8544    Reasoning {
8545        #[serde(default, skip_serializing_if = "Option::is_none")]
8546        content: Option<Vec<String>>,
8547        id: String,
8548        #[serde(default, skip_serializing_if = "Option::is_none")]
8549        summary: Option<Vec<String>>,
8550    },
8551    #[serde(rename = "commandExecution")]
8552    CommandExecution {
8553        #[serde(
8554            rename = "aggregatedOutput",
8555            default,
8556            skip_serializing_if = "Option::is_none"
8557        )]
8558        aggregated_output: Option<String>,
8559        command: String,
8560        #[serde(rename = "commandActions")]
8561        command_actions: Vec<CommandAction>,
8562        cwd: Value,
8563        #[serde(
8564            rename = "durationMs",
8565            default,
8566            skip_serializing_if = "Option::is_none"
8567        )]
8568        duration_ms: Option<i64>,
8569        #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
8570        exit_code: Option<i64>,
8571        id: String,
8572        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8573        plugin_id: Option<String>,
8574        #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
8575        process_id: Option<String>,
8576        #[serde(
8577            rename = "scriptPath",
8578            default,
8579            skip_serializing_if = "Option::is_none"
8580        )]
8581        script_path: Option<String>,
8582        #[serde(default, skip_serializing_if = "Option::is_none")]
8583        source: Option<Value>,
8584        status: CommandExecutionStatus,
8585    },
8586    #[serde(rename = "fileChange")]
8587    FileChange {
8588        changes: Vec<FileUpdateChange>,
8589        id: String,
8590        status: PatchApplyStatus,
8591    },
8592    #[serde(rename = "mcpToolCall")]
8593    McpToolCall {
8594        #[serde(
8595            rename = "appContext",
8596            default,
8597            skip_serializing_if = "Option::is_none"
8598        )]
8599        app_context: Option<McpToolCallAppContext>,
8600        arguments: Value,
8601        #[serde(
8602            rename = "durationMs",
8603            default,
8604            skip_serializing_if = "Option::is_none"
8605        )]
8606        duration_ms: Option<i64>,
8607        #[serde(default, skip_serializing_if = "Option::is_none")]
8608        error: Option<McpToolCallError>,
8609        id: String,
8610        /// Legacy compatibility field; prefer `mcp_app_ui.resource_uri` when
8611        /// available.
8612        #[serde(
8613            rename = "mcpAppResourceUri",
8614            default,
8615            skip_serializing_if = "Option::is_none"
8616        )]
8617        mcp_app_resource_uri: Option<String>,
8618        /// Presentation captured from the invoked descriptor; absent in
8619        /// older history.
8620        #[serde(rename = "mcpAppUi", default, skip_serializing_if = "Option::is_none")]
8621        mcp_app_ui: Option<McpAppUi>,
8622        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8623        plugin_id: Option<String>,
8624        #[serde(
8625            rename = "readOnlyHint",
8626            default,
8627            skip_serializing_if = "Option::is_none"
8628        )]
8629        read_only_hint: Option<bool>,
8630        #[serde(default, skip_serializing_if = "Option::is_none")]
8631        result: Option<McpToolCallResult>,
8632        server: String,
8633        status: McpToolCallStatus,
8634        tool: String,
8635    },
8636    #[serde(rename = "dynamicToolCall")]
8637    DynamicToolCall {
8638        arguments: Value,
8639        #[serde(
8640            rename = "contentItems",
8641            default,
8642            skip_serializing_if = "Option::is_none"
8643        )]
8644        content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
8645        #[serde(
8646            rename = "durationMs",
8647            default,
8648            skip_serializing_if = "Option::is_none"
8649        )]
8650        duration_ms: Option<i64>,
8651        id: String,
8652        #[serde(default, skip_serializing_if = "Option::is_none")]
8653        namespace: Option<String>,
8654        status: DynamicToolCallStatus,
8655        #[serde(default, skip_serializing_if = "Option::is_none")]
8656        success: Option<bool>,
8657        tool: String,
8658    },
8659    #[serde(rename = "collabAgentToolCall")]
8660    CollabAgentToolCall {
8661        #[serde(rename = "agentsStates")]
8662        agents_states: std::collections::BTreeMap<String, CollabAgentState>,
8663        id: String,
8664        #[serde(default, skip_serializing_if = "Option::is_none")]
8665        model: Option<String>,
8666        #[serde(default, skip_serializing_if = "Option::is_none")]
8667        prompt: Option<String>,
8668        #[serde(
8669            rename = "reasoningEffort",
8670            default,
8671            skip_serializing_if = "Option::is_none"
8672        )]
8673        reasoning_effort: Option<ReasoningEffort>,
8674        #[serde(rename = "receiverThreadIds")]
8675        receiver_thread_ids: Vec<String>,
8676        #[serde(rename = "senderThreadId")]
8677        sender_thread_id: String,
8678        status: Value,
8679        tool: Value,
8680    },
8681    #[serde(rename = "subAgentActivity")]
8682    SubAgentActivity {
8683        #[serde(rename = "agentPath")]
8684        agent_path: String,
8685        #[serde(rename = "agentThreadId")]
8686        agent_thread_id: String,
8687        id: String,
8688        kind: SubAgentActivityKind,
8689        /// Resolved model at sub-agent creation; absent from older records
8690        /// and other activities.
8691        #[serde(default, skip_serializing_if = "Option::is_none")]
8692        model: Option<String>,
8693        /// Resolved reasoning effort at sub-agent creation, when known.
8694        #[serde(
8695            rename = "reasoningEffort",
8696            default,
8697            skip_serializing_if = "Option::is_none"
8698        )]
8699        reasoning_effort: Option<ReasoningEffort>,
8700    },
8701    #[serde(rename = "webSearch")]
8702    WebSearch {
8703        #[serde(default, skip_serializing_if = "Option::is_none")]
8704        action: Option<WebSearchAction>,
8705        id: String,
8706        query: String,
8707        #[serde(default, skip_serializing_if = "Option::is_none")]
8708        results: Option<Vec<Value>>,
8709    },
8710    #[serde(rename = "imageView")]
8711    ImageView {
8712        id: String,
8713        path: LegacyAppPathString,
8714    },
8715    Sleep {
8716        #[serde(rename = "durationMs")]
8717        duration_ms: i64,
8718        id: String,
8719    },
8720    #[serde(rename = "imageGeneration")]
8721    ImageGeneration {
8722        #[serde(default, skip_serializing_if = "Option::is_none")]
8723        failure: Option<ImageGenerationFailure>,
8724        /// Image generation identifier, when provided by the image backend.
8725        #[serde(
8726            rename = "generationId",
8727            default,
8728            skip_serializing_if = "Option::is_none"
8729        )]
8730        generation_id: Option<String>,
8731        id: String,
8732        #[serde(flatten)]
8733        image: GeneratedImageRef,
8734        /// Observed local inputs for a completed generation, absent on older items.
8735        #[serde(
8736            rename = "inputImages",
8737            default,
8738            skip_serializing_if = "Option::is_none"
8739        )]
8740        input_images: Option<Vec<ImageGenerationInputImage>>,
8741        #[serde(
8742            rename = "revisedPrompt",
8743            default,
8744            skip_serializing_if = "Option::is_none"
8745        )]
8746        revised_prompt: Option<String>,
8747        #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
8748        saved_path: Option<AbsolutePathBuf>,
8749        status: String,
8750        #[serde(
8751            rename = "transparentBackground",
8752            default,
8753            skip_serializing_if = "Option::is_none"
8754        )]
8755        transparent_background: Option<bool>,
8756    },
8757    #[serde(rename = "enteredReviewMode")]
8758    EnteredReviewMode {
8759        id: String,
8760        review: String,
8761    },
8762    #[serde(rename = "exitedReviewMode")]
8763    ExitedReviewMode {
8764        id: String,
8765        review: String,
8766    },
8767    #[serde(rename = "contextCompaction")]
8768    ContextCompaction {
8769        id: String,
8770    },
8771    #[serde(rename = "functionCallOutput")]
8772    FunctionCallOutput {
8773        id: String,
8774        name: String,
8775        #[serde(default, skip_serializing_if = "Option::is_none")]
8776        namespace: Option<String>,
8777        output: FunctionCallOutputBody,
8778    },
8779}
8780
8781#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8782#[serde(untagged)]
8783pub enum ThreadListCwdFilter {
8784    Variant0(String),
8785    Variant1(Vec<String>),
8786}
8787
8788#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8789#[serde(rename_all = "camelCase")]
8790pub struct ThreadListParams {
8791    #[serde(default, skip_serializing_if = "Option::is_none")]
8792    pub archived: Option<bool>,
8793    /// Show local history visible to the current ChatGPT account. Defaults to
8794    /// false.
8795    #[serde(
8796        rename = "currentAccountOnly",
8797        default,
8798        skip_serializing_if = "Option::is_none"
8799    )]
8800    pub current_account_only: Option<bool>,
8801    #[serde(default, skip_serializing_if = "Option::is_none")]
8802    pub cursor: Option<String>,
8803    #[serde(default, skip_serializing_if = "Option::is_none")]
8804    pub cwd: Option<ThreadListCwdFilter>,
8805    /// Thread IDs to exclude before applying the result limit. Up to 100
8806    /// entries; invalid IDs or a larger list are rejected, never truncated.
8807    /// Send the same exclusions on each page. Omitted, null, or empty means
8808    /// no exclusions.
8809    #[serde(
8810        rename = "excludedThreadIds",
8811        default,
8812        skip_serializing_if = "Option::is_none"
8813    )]
8814    pub excluded_thread_ids: Option<Vec<String>>,
8815    #[serde(default, skip_serializing_if = "Option::is_none")]
8816    pub limit: Option<i64>,
8817    #[serde(
8818        rename = "modelProviders",
8819        default,
8820        skip_serializing_if = "Option::is_none"
8821    )]
8822    pub model_providers: Option<Vec<String>>,
8823    /// Optional originator allowlist, matching any supplied value exactly.
8824    /// Supported by hosted backends only; the local app-server rejects a
8825    /// nonempty list. Omitted or empty lists leave originators unrestricted.
8826    #[serde(default, skip_serializing_if = "Option::is_none")]
8827    pub originators: Option<Vec<String>>,
8828    #[serde(
8829        rename = "searchTerm",
8830        default,
8831        skip_serializing_if = "Option::is_none"
8832    )]
8833    pub search_term: Option<String>,
8834    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8835    pub section_id: Option<String>,
8836    #[serde(
8837        rename = "sortDirection",
8838        default,
8839        skip_serializing_if = "Option::is_none"
8840    )]
8841    pub sort_direction: Option<SortDirection>,
8842    #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
8843    pub sort_key: Option<ThreadSortKey>,
8844    #[serde(
8845        rename = "sourceKinds",
8846        default,
8847        skip_serializing_if = "Option::is_none"
8848    )]
8849    pub source_kinds: Option<Vec<ThreadSourceKind>>,
8850    #[serde(
8851        rename = "useStateDbOnly",
8852        default,
8853        skip_serializing_if = "Option::is_none"
8854    )]
8855    pub use_state_db_only: Option<bool>,
8856}
8857
8858#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8859#[serde(rename_all = "camelCase")]
8860pub struct ThreadListResponse {
8861    #[serde(
8862        rename = "backwardsCursor",
8863        default,
8864        skip_serializing_if = "Option::is_none"
8865    )]
8866    pub backwards_cursor: Option<String>,
8867    #[serde(default)]
8868    pub data: Vec<Thread>,
8869    #[serde(
8870        rename = "nextCursor",
8871        default,
8872        skip_serializing_if = "Option::is_none"
8873    )]
8874    pub next_cursor: Option<String>,
8875}
8876
8877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8878#[serde(rename_all = "camelCase")]
8879pub struct ThreadLoadedListParams {
8880    #[serde(default, skip_serializing_if = "Option::is_none")]
8881    pub cursor: Option<String>,
8882    #[serde(default, skip_serializing_if = "Option::is_none")]
8883    pub limit: Option<i64>,
8884}
8885
8886#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8887#[serde(rename_all = "camelCase")]
8888pub struct ThreadLoadedListResponse {
8889    #[serde(default)]
8890    pub data: Vec<String>,
8891    #[serde(
8892        rename = "nextCursor",
8893        default,
8894        skip_serializing_if = "Option::is_none"
8895    )]
8896    pub next_cursor: Option<String>,
8897}
8898
8899#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8900#[serde(rename_all = "camelCase")]
8901pub struct ThreadMetadataGitInfoUpdateParams {
8902    #[serde(default, skip_serializing_if = "Option::is_none")]
8903    pub branch: Option<String>,
8904    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
8905    pub origin_url: Option<String>,
8906    #[serde(default, skip_serializing_if = "Option::is_none")]
8907    pub sha: Option<String>,
8908}
8909
8910#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8911#[serde(rename_all = "camelCase")]
8912pub struct ThreadMetadataUpdateParams {
8913    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
8914    pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
8915    #[serde(rename = "threadId", default)]
8916    pub thread_id: String,
8917}
8918
8919#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8920#[serde(rename_all = "camelCase")]
8921pub struct ThreadMetadataUpdateResponse {
8922    #[serde()]
8923    pub thread: Thread,
8924}
8925
8926#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8927#[serde(rename_all = "camelCase")]
8928pub struct ThreadNameUpdatedNotification {
8929    #[serde(rename = "threadId", default)]
8930    pub thread_id: String,
8931    #[serde(
8932        rename = "threadName",
8933        default,
8934        skip_serializing_if = "Option::is_none"
8935    )]
8936    pub thread_name: Option<String>,
8937}
8938
8939#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8940#[serde(rename_all = "camelCase")]
8941pub struct ThreadReadParams {
8942    #[serde(
8943        rename = "includeTurns",
8944        default,
8945        skip_serializing_if = "Option::is_none"
8946    )]
8947    pub include_turns: Option<bool>,
8948    #[serde(rename = "threadId", default)]
8949    pub thread_id: String,
8950}
8951
8952#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8953#[serde(rename_all = "camelCase")]
8954pub struct ThreadReadResponse {
8955    #[serde()]
8956    pub thread: Thread,
8957}
8958
8959/// The first unread position in a durable local thread. A null position means read.
8960/// The opaque revision guards edits against activity or marks the caller has not seen.
8961#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8962#[serde(rename_all = "camelCase")]
8963pub struct ThreadReadState {
8964    #[serde(
8965        rename = "firstUnread",
8966        default,
8967        skip_serializing_if = "Option::is_none"
8968    )]
8969    pub first_unread: Option<ThreadUnreadPosition>,
8970    #[serde(default)]
8971    pub revision: String,
8972}
8973
8974#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8975#[serde(rename_all = "camelCase")]
8976pub struct ThreadReadStateChangedNotification {
8977    #[serde(rename = "readState")]
8978    pub read_state: ThreadReadState,
8979    #[serde(rename = "threadId", default)]
8980    pub thread_id: String,
8981}
8982
8983/// Broadcast after a successful move into, within, or out of a section.
8984#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
8985#[serde(rename_all = "camelCase")]
8986pub struct ThreadSectionChangedNotification {
8987    #[serde(rename = "threadId")]
8988    pub thread_id: String,
8989    /// Destination section, or `None` when the thread was removed from its
8990    /// section. Always present on the wire (`null` when removed).
8991    #[serde(rename = "sectionId")]
8992    pub section_id: Option<String>,
8993}
8994
8995#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8996#[serde(rename_all = "camelCase")]
8997pub struct ThreadRealtimeAudioChunk {
8998    #[serde(default)]
8999    pub data: String,
9000    #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
9001    pub item_id: Option<String>,
9002    #[serde(rename = "numChannels", default)]
9003    pub num_channels: i64,
9004    #[serde(rename = "sampleRate", default)]
9005    pub sample_rate: i64,
9006    #[serde(
9007        rename = "samplesPerChannel",
9008        default,
9009        skip_serializing_if = "Option::is_none"
9010    )]
9011    pub samples_per_channel: Option<i64>,
9012}
9013
9014#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9015#[serde(rename_all = "camelCase")]
9016pub struct ThreadRealtimeClosedNotification {
9017    #[serde(default, skip_serializing_if = "Option::is_none")]
9018    pub reason: Option<String>,
9019    #[serde(rename = "threadId", default)]
9020    pub thread_id: String,
9021}
9022
9023#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9024#[serde(rename_all = "camelCase")]
9025pub struct ThreadRealtimeErrorNotification {
9026    #[serde(default)]
9027    pub message: String,
9028    #[serde(rename = "threadId", default)]
9029    pub thread_id: String,
9030}
9031
9032#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9033#[serde(rename_all = "camelCase")]
9034pub struct ThreadRealtimeItemAddedNotification {
9035    #[serde(default)]
9036    pub item: Value,
9037    #[serde(rename = "threadId", default)]
9038    pub thread_id: String,
9039}
9040
9041#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9042#[serde(rename_all = "camelCase")]
9043pub struct ThreadRealtimeOutputAudioDeltaNotification {
9044    #[serde()]
9045    pub audio: ThreadRealtimeAudioChunk,
9046    #[serde(rename = "threadId", default)]
9047    pub thread_id: String,
9048}
9049
9050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9051#[serde(rename_all = "camelCase")]
9052pub struct ThreadRealtimeSdpNotification {
9053    #[serde(default)]
9054    pub sdp: String,
9055    #[serde(rename = "threadId", default)]
9056    pub thread_id: String,
9057}
9058
9059#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9060#[serde(rename_all = "camelCase")]
9061pub struct ThreadRealtimeStartedNotification {
9062    #[serde(
9063        rename = "realtimeSessionId",
9064        default,
9065        skip_serializing_if = "Option::is_none"
9066    )]
9067    pub realtime_session_id: Option<String>,
9068    #[serde(rename = "threadId", default)]
9069    pub thread_id: String,
9070    #[serde()]
9071    pub version: RealtimeConversationVersion,
9072}
9073
9074#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9075#[serde(rename_all = "camelCase")]
9076pub struct ThreadRealtimeTranscriptDeltaNotification {
9077    #[serde(default)]
9078    pub delta: String,
9079    #[serde(default)]
9080    pub role: String,
9081    #[serde(rename = "threadId", default)]
9082    pub thread_id: String,
9083}
9084
9085#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9086#[serde(rename_all = "camelCase")]
9087pub struct ThreadRealtimeTranscriptDoneNotification {
9088    #[serde(default)]
9089    pub role: String,
9090    #[serde(default)]
9091    pub text: String,
9092    #[serde(rename = "threadId", default)]
9093    pub thread_id: String,
9094}
9095
9096#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9097#[serde(rename_all = "camelCase")]
9098pub struct ThreadResumeParams {
9099    #[serde(
9100        rename = "approvalPolicy",
9101        default,
9102        skip_serializing_if = "Option::is_none"
9103    )]
9104    pub approval_policy: Option<AskForApproval>,
9105    #[serde(
9106        rename = "approvalsReviewer",
9107        default,
9108        skip_serializing_if = "Option::is_none"
9109    )]
9110    pub approvals_reviewer: Option<ApprovalsReviewer>,
9111    #[serde(
9112        rename = "baseInstructions",
9113        default,
9114        skip_serializing_if = "Option::is_none"
9115    )]
9116    pub base_instructions: Option<String>,
9117    #[serde(default, skip_serializing_if = "Option::is_none")]
9118    pub config: Option<Value>,
9119    #[serde(default, skip_serializing_if = "Option::is_none")]
9120    pub cwd: Option<String>,
9121    #[serde(
9122        rename = "developerInstructions",
9123        default,
9124        skip_serializing_if = "Option::is_none"
9125    )]
9126    pub developer_instructions: Option<String>,
9127    #[serde(default, skip_serializing_if = "Option::is_none")]
9128    pub model: Option<String>,
9129    #[serde(
9130        rename = "modelProvider",
9131        default,
9132        skip_serializing_if = "Option::is_none"
9133    )]
9134    pub model_provider: Option<String>,
9135    #[serde(default, skip_serializing_if = "Option::is_none")]
9136    pub personality: Option<Personality>,
9137    #[serde(default, skip_serializing_if = "Option::is_none")]
9138    pub sandbox: Option<SandboxMode>,
9139    #[serde(
9140        rename = "serviceTier",
9141        default,
9142        skip_serializing_if = "Option::is_none"
9143    )]
9144    pub service_tier: Option<String>,
9145    #[serde(rename = "threadId", default)]
9146    pub thread_id: String,
9147    #[serde(
9148        rename = "excludeTurns",
9149        default,
9150        skip_serializing_if = "Option::is_none"
9151    )]
9152    pub exclude_turns: Option<bool>,
9153}
9154
9155#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9156#[serde(rename_all = "camelCase")]
9157pub struct ThreadResumeResponse {
9158    #[serde(rename = "approvalPolicy")]
9159    pub approval_policy: AskForApproval,
9160    #[serde(rename = "approvalsReviewer", default)]
9161    pub approvals_reviewer: Value,
9162    /// Effective collaboration mode. Absent when resuming from an older
9163    /// server.
9164    #[serde(
9165        rename = "collaborationMode",
9166        default,
9167        skip_serializing_if = "Option::is_none"
9168    )]
9169    pub collaboration_mode: Option<CollaborationMode>,
9170    #[serde()]
9171    pub cwd: AbsolutePathBuf,
9172    /// Saved list of disabled plugin IDs. Does not yet filter plugin
9173    /// capabilities.
9174    #[serde(rename = "disabledPluginIds", default)]
9175    pub disabled_plugin_ids: Vec<String>,
9176    #[serde(
9177        rename = "instructionSources",
9178        default,
9179        skip_serializing_if = "Option::is_none"
9180    )]
9181    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9182    /// Cursor for hydrating paginated items backwards via `thread/items/list`
9183    /// with `sortDirection: "desc"` (0.148 upstream).
9184    #[serde(
9185        rename = "itemsBackwardsCursor",
9186        default,
9187        skip_serializing_if = "Option::is_none"
9188    )]
9189    pub items_backwards_cursor: Option<String>,
9190    #[serde(default)]
9191    pub model: String,
9192    #[serde(rename = "modelProvider", default)]
9193    pub model_provider: String,
9194    #[serde(
9195        rename = "reasoningEffort",
9196        default,
9197        skip_serializing_if = "Option::is_none"
9198    )]
9199    pub reasoning_effort: Option<ReasoningEffort>,
9200    #[serde(default)]
9201    pub sandbox: Value,
9202    #[serde(
9203        rename = "serviceTier",
9204        default,
9205        skip_serializing_if = "Option::is_none"
9206    )]
9207    pub service_tier: Option<String>,
9208    #[serde()]
9209    pub thread: Thread,
9210    /// Cursor for hydrating paginated turns backwards via `thread/turns/list`
9211    /// with `sortDirection: "desc"` (0.148 upstream).
9212    #[serde(
9213        rename = "turnsBackwardsCursor",
9214        default,
9215        skip_serializing_if = "Option::is_none"
9216    )]
9217    pub turns_backwards_cursor: Option<String>,
9218}
9219
9220/// Persisted thread history contract (0.148 upstream).
9221#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9222pub enum ThreadHistoryMode {
9223    #[serde(rename = "legacy")]
9224    Legacy,
9225    #[serde(rename = "paginated")]
9226    Paginated,
9227}
9228
9229/// One item plus the turn that contains it, as returned by
9230/// `thread/items/list` (0.148 upstream).
9231#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9232#[serde(rename_all = "camelCase")]
9233pub struct ThreadItemEntry {
9234    /// Unix timestamp (milliseconds) when the item completed, if recorded by
9235    /// the producer.
9236    #[serde(
9237        rename = "completedAtMs",
9238        default,
9239        skip_serializing_if = "Option::is_none"
9240    )]
9241    pub completed_at_ms: Option<i64>,
9242    #[serde()]
9243    pub item: ThreadItem,
9244    /// EXPERIMENTAL upstream — the saved command output was omitted because
9245    /// the request set [`ThreadItemOutputDeferral::command_execution`]; fetch
9246    /// the complete item with `thread/items/read` (openai/codex#59601).
9247    /// Requires `experimentalApi`; absent (false) otherwise.
9248    #[serde(
9249        rename = "outputDeferred",
9250        default,
9251        skip_serializing_if = "std::ops::Not::not"
9252    )]
9253    pub output_deferred: bool,
9254    /// Unix timestamp (milliseconds) when the item started, if recorded by
9255    /// the producer.
9256    #[serde(
9257        rename = "startedAtMs",
9258        default,
9259        skip_serializing_if = "Option::is_none"
9260    )]
9261    pub started_at_ms: Option<i64>,
9262    #[serde(rename = "turnId", default)]
9263    pub turn_id: String,
9264}
9265
9266/// Params for `thread/items/list` — paginated item hydration (0.148 upstream).
9267#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9268#[serde(rename_all = "camelCase")]
9269pub struct ThreadItemsListParams {
9270    /// Opaque continuation cursor, or an exclusive item anchor in the
9271    /// requested visible turn (`openai/codex@main` de9e78e3). An item anchor
9272    /// requires a non-empty `turn_id`; ascending (the default) returns items
9273    /// after it, descending returns items before it. Continue with the
9274    /// returned string cursor.
9275    #[serde(default, skip_serializing_if = "Option::is_none")]
9276    pub cursor: Option<ThreadItemsListCursor>,
9277    /// For a single turn, choose which saved outputs to fetch separately by
9278    /// item ID (openai/codex#59601).
9279    #[serde(
9280        rename = "deferOutput",
9281        default,
9282        skip_serializing_if = "Option::is_none"
9283    )]
9284    pub defer_output: Option<ThreadItemOutputDeferral>,
9285    #[serde(default, skip_serializing_if = "Option::is_none")]
9286    pub limit: Option<u32>,
9287    #[serde(
9288        rename = "sortDirection",
9289        default,
9290        skip_serializing_if = "Option::is_none"
9291    )]
9292    pub sort_direction: Option<SortDirection>,
9293    #[serde(rename = "threadId", default)]
9294    pub thread_id: String,
9295    /// Optional turn id filter; omitted returns items across the thread.
9296    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
9297    pub turn_id: Option<String>,
9298}
9299
9300/// `thread/items/list` `deferOutput` selector — which saved outputs the
9301/// server should omit from the page so the client can fetch them separately
9302/// by item ID (openai/codex#59601). The stable schema exposes this as an
9303/// empty object; its fields are experimental upstream.
9304#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
9305#[serde(rename_all = "camelCase")]
9306pub struct ThreadItemOutputDeferral {
9307    /// EXPERIMENTAL upstream — defer nonempty output from successful
9308    /// commands. Requires `experimentalApi`.
9309    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9310    pub command_execution: bool,
9311}
9312
9313/// Starting position for a `thread/items/list` page: either the opaque
9314/// string cursor a previous page returned, or an item anchor
9315/// (`openai/codex@main` de9e78e3). Untagged, so a bare string stays a bare
9316/// string on the wire.
9317#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9318#[serde(untagged)]
9319pub enum ThreadItemsListCursor {
9320    Opaque(String),
9321    Anchor(ThreadItemsListAnchor),
9322}
9323
9324/// An exclusive item position within the requested visible turn
9325/// (`openai/codex@main` de9e78e3).
9326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9327#[serde(tag = "type", rename_all = "camelCase")]
9328pub enum ThreadItemsListAnchor {
9329    Item {
9330        #[serde(rename = "itemId")]
9331        item_id: String,
9332    },
9333}
9334
9335/// Response to `thread/items/list` (0.148 upstream).
9336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9337#[serde(rename_all = "camelCase")]
9338pub struct ThreadItemsListResponse {
9339    #[serde(
9340        rename = "backwardsCursor",
9341        default,
9342        skip_serializing_if = "Option::is_none"
9343    )]
9344    pub backwards_cursor: Option<String>,
9345    #[serde(default)]
9346    pub data: Vec<ThreadItemEntry>,
9347    #[serde(
9348        rename = "nextCursor",
9349        default,
9350        skip_serializing_if = "Option::is_none"
9351    )]
9352    pub next_cursor: Option<String>,
9353}
9354
9355/// EXPERIMENTAL upstream — a thread-scoped realtime item in the canonical
9356/// timeline (0.148). Top-level identity fields are camelCase on the wire
9357/// while variant payload fields are snake_case; mirrored exactly.
9358#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9359pub struct ThreadRealtimeItem {
9360    #[serde(default)]
9361    pub id: String,
9362    #[serde(rename = "realtimeSessionId", default)]
9363    pub realtime_session_id: String,
9364    #[serde(flatten)]
9365    pub detail: ThreadRealtimeItemDetail,
9366}
9367
9368/// The `type`-tagged payload of a [`ThreadRealtimeItem`].
9369#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9370#[serde(tag = "type", rename_all = "camelCase")]
9371pub enum ThreadRealtimeItemDetail {
9372    #[serde(rename = "realtimeSessionStarted")]
9373    RealtimeSessionStarted,
9374    #[serde(rename = "transcriptSegment")]
9375    TranscriptSegment {
9376        role: ThreadRealtimeTranscriptRole,
9377        text: String,
9378    },
9379    #[serde(rename = "bemItemPromoted")]
9380    BemItemPromoted {
9381        item_id: String,
9382        presentation: ThreadRealtimeBemItemPresentation,
9383        turn_id: String,
9384    },
9385    #[serde(rename = "realtimeSessionClosed")]
9386    RealtimeSessionClosed {
9387        outcome: ThreadRealtimeSessionOutcome,
9388    },
9389}
9390
9391/// EXPERIMENTAL upstream — how an existing agent item appears in a realtime
9392/// conversation (0.148).
9393#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9394#[serde(tag = "type", rename_all = "camelCase")]
9395pub enum ThreadRealtimeBemItemPresentation {
9396    #[serde(rename = "wholeItem")]
9397    WholeItem,
9398    #[serde(rename = "inlineMarkdown")]
9399    InlineMarkdown,
9400    #[serde(rename = "inlineVisualization")]
9401    InlineVisualization { index: u32 },
9402}
9403
9404/// EXPERIMENTAL upstream — `thread/realtime/item/started` params (0.148).
9405#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9406#[serde(rename_all = "camelCase")]
9407pub struct ThreadRealtimeItemStartedNotification {
9408    #[serde()]
9409    pub item: ThreadRealtimeItem,
9410    #[serde(rename = "threadId", default)]
9411    pub thread_id: String,
9412}
9413
9414/// EXPERIMENTAL upstream — `thread/realtime/item/completed` params (0.148).
9415#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9416#[serde(rename_all = "camelCase")]
9417pub struct ThreadRealtimeItemCompletedNotification {
9418    #[serde()]
9419    pub item: ThreadRealtimeItem,
9420    #[serde(rename = "threadId", default)]
9421    pub thread_id: String,
9422}
9423
9424/// EXPERIMENTAL upstream — `thread/realtime/item/transcript/delta` params:
9425/// text appended to an active realtime transcript item (0.148).
9426#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9427#[serde(rename_all = "camelCase")]
9428pub struct ThreadRealtimeItemTranscriptDeltaNotification {
9429    #[serde(default)]
9430    pub delta: String,
9431    #[serde(rename = "itemId", default)]
9432    pub item_id: String,
9433    #[serde(rename = "threadId", default)]
9434    pub thread_id: String,
9435}
9436
9437/// EXPERIMENTAL upstream — outcome of a closed realtime session (0.148).
9438#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9439pub enum ThreadRealtimeSessionOutcome {
9440    #[serde(rename = "ended")]
9441    Ended,
9442    #[serde(rename = "failed")]
9443    Failed,
9444}
9445
9446/// EXPERIMENTAL upstream — speaker role in a realtime transcript (0.148).
9447#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9448pub enum ThreadRealtimeTranscriptRole {
9449    #[serde(rename = "user")]
9450    User,
9451    #[serde(rename = "assistant")]
9452    Assistant,
9453}
9454
9455/// Params for `thread/revert` — replace a paginated thread's durable history
9456/// with the prefix before one turn; local file changes are untouched
9457/// (0.148 upstream).
9458#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9459#[serde(rename_all = "camelCase")]
9460pub struct ThreadRevertParams {
9461    /// Turn excluded from the replacement history, with every later turn.
9462    #[serde(rename = "beforeTurnId", default)]
9463    pub before_turn_id: String,
9464    #[serde(rename = "threadId", default)]
9465    pub thread_id: String,
9466}
9467
9468/// Response to `thread/revert` (0.148 upstream). `thread.turns` is always
9469/// empty; retained history hydrates through `thread/turns/list`.
9470#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9471#[serde(rename_all = "camelCase")]
9472pub struct ThreadRevertResponse {
9473    #[serde(
9474        rename = "itemsBackwardsCursor",
9475        default,
9476        skip_serializing_if = "Option::is_none"
9477    )]
9478    pub items_backwards_cursor: Option<String>,
9479    #[serde()]
9480    pub thread: Thread,
9481    #[serde(
9482        rename = "turnsBackwardsCursor",
9483        default,
9484        skip_serializing_if = "Option::is_none"
9485    )]
9486    pub turns_backwards_cursor: Option<String>,
9487}
9488
9489#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9490#[serde(rename_all = "camelCase")]
9491pub struct ThreadSection {
9492    #[serde(default, skip_serializing_if = "Option::is_none")]
9493    pub appearance: Option<ThreadSectionAppearance>,
9494    #[serde(default)]
9495    pub id: String,
9496    #[serde(default)]
9497    pub name: String,
9498}
9499
9500#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9501#[serde(rename_all = "camelCase")]
9502pub struct ThreadSectionAppearance {
9503    #[serde(default, skip_serializing_if = "Option::is_none")]
9504    pub color: Option<String>,
9505    #[serde(default, skip_serializing_if = "Option::is_none")]
9506    pub icon: Option<String>,
9507}
9508
9509#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9510#[serde(rename_all = "camelCase")]
9511pub struct ThreadSectionCreateParams {
9512    #[serde(default, skip_serializing_if = "Option::is_none")]
9513    pub appearance: Option<ThreadSectionAppearance>,
9514    #[serde(default)]
9515    pub name: String,
9516}
9517
9518#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9519#[serde(rename_all = "camelCase")]
9520pub struct ThreadSectionCreateResponse {
9521    #[serde()]
9522    pub section: ThreadSection,
9523}
9524
9525#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9526#[serde(rename_all = "camelCase")]
9527pub struct ThreadSectionDeleteParams {
9528    #[serde(rename = "sectionId", default)]
9529    pub section_id: String,
9530}
9531
9532#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9533#[serde(rename_all = "camelCase")]
9534pub struct ThreadSectionDeleteResponse {
9535    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9536    pub extra: serde_json::Map<String, Value>,
9537}
9538
9539#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9540#[serde(rename_all = "camelCase")]
9541pub struct ThreadSectionListParams {
9542    #[serde(default, skip_serializing_if = "Option::is_none")]
9543    pub cursor: Option<String>,
9544    #[serde(default, skip_serializing_if = "Option::is_none")]
9545    pub limit: Option<i64>,
9546}
9547
9548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9549#[serde(rename_all = "camelCase")]
9550pub struct ThreadSectionListResponse {
9551    #[serde(default)]
9552    pub data: Vec<ThreadSection>,
9553    #[serde(
9554        rename = "nextCursor",
9555        default,
9556        skip_serializing_if = "Option::is_none"
9557    )]
9558    pub next_cursor: Option<String>,
9559}
9560
9561#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9562#[serde(rename_all = "camelCase")]
9563pub struct ThreadSectionMoveParams {
9564    #[serde(
9565        rename = "beforeThreadId",
9566        default,
9567        skip_serializing_if = "Option::is_none"
9568    )]
9569    pub before_thread_id: Option<String>,
9570    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
9571    pub section_id: Option<String>,
9572    #[serde(rename = "threadId", default)]
9573    pub thread_id: String,
9574}
9575
9576#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9577#[serde(rename_all = "camelCase")]
9578pub struct ThreadSectionMoveResponse {
9579    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9580    pub extra: serde_json::Map<String, Value>,
9581}
9582
9583#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9584#[serde(rename_all = "camelCase")]
9585pub struct ThreadSectionUpdateParams {
9586    #[serde(default, skip_serializing_if = "Option::is_none")]
9587    pub appearance: Option<ThreadSectionAppearance>,
9588    #[serde(default)]
9589    pub name: String,
9590    #[serde(rename = "sectionId", default)]
9591    pub section_id: String,
9592}
9593
9594#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9595#[serde(rename_all = "camelCase")]
9596pub struct ThreadSectionUpdateResponse {
9597    #[serde()]
9598    pub section: ThreadSection,
9599}
9600
9601#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9602#[serde(rename_all = "camelCase")]
9603pub struct ThreadSetNameParams {
9604    #[serde(default)]
9605    pub name: String,
9606    #[serde(rename = "threadId", default)]
9607    pub thread_id: String,
9608}
9609
9610#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9611#[serde(rename_all = "camelCase")]
9612pub struct ThreadSetNameResponse {
9613    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9614    pub extra: serde_json::Map<String, Value>,
9615}
9616
9617#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9618#[serde(rename_all = "camelCase")]
9619pub struct ThreadSettings {
9620    #[serde(
9621        rename = "activePermissionProfile",
9622        default,
9623        skip_serializing_if = "Option::is_none"
9624    )]
9625    pub active_permission_profile: Option<ActivePermissionProfile>,
9626    #[serde(rename = "approvalPolicy")]
9627    pub approval_policy: AskForApproval,
9628    #[serde(rename = "approvalsReviewer")]
9629    pub approvals_reviewer: ApprovalsReviewer,
9630    #[serde(rename = "collaborationMode")]
9631    pub collaboration_mode: CollaborationMode,
9632    #[serde()]
9633    pub cwd: AbsolutePathBuf,
9634    /// Saved list of disabled plugin IDs. Does not yet filter plugin
9635    /// capabilities.
9636    #[serde(rename = "disabledPluginIds", default)]
9637    pub disabled_plugin_ids: Vec<String>,
9638    #[serde(default, skip_serializing_if = "Option::is_none")]
9639    pub effort: Option<ReasoningEffort>,
9640    #[serde(default)]
9641    pub model: String,
9642    #[serde(rename = "modelProvider", default)]
9643    pub model_provider: String,
9644    #[serde(default, skip_serializing_if = "Option::is_none")]
9645    pub personality: Option<Personality>,
9646    #[serde(rename = "sandboxPolicy")]
9647    pub sandbox_policy: SandboxPolicy,
9648    #[serde(
9649        rename = "serviceTier",
9650        default,
9651        skip_serializing_if = "Option::is_none"
9652    )]
9653    pub service_tier: Option<String>,
9654    #[serde(default, skip_serializing_if = "Option::is_none")]
9655    pub summary: Option<ReasoningSummary>,
9656}
9657
9658#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9659#[serde(rename_all = "camelCase")]
9660pub struct ThreadSettingsUpdatedNotification {
9661    #[serde(rename = "threadId", default)]
9662    pub thread_id: String,
9663    #[serde(rename = "threadSettings")]
9664    pub thread_settings: ThreadSettings,
9665}
9666
9667#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9668#[serde(rename_all = "camelCase")]
9669pub struct ThreadShellCommandParams {
9670    #[serde(default)]
9671    pub command: String,
9672    #[serde(rename = "threadId", default)]
9673    pub thread_id: String,
9674    /// Maximum execution time in ms; defaults to one hour when omitted.
9675    /// Zero requests an immediate timeout, not unlimited (0.148 upstream).
9676    #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
9677    pub timeout_ms: Option<i64>,
9678}
9679
9680#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9681#[serde(rename_all = "camelCase")]
9682pub struct ThreadShellCommandResponse {
9683    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9684    pub extra: serde_json::Map<String, Value>,
9685}
9686
9687#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9688pub enum ThreadSortKey {
9689    #[serde(rename = "created_at")]
9690    Created_at,
9691    #[serde(rename = "updated_at")]
9692    Updated_at,
9693    #[serde(rename = "recency_at")]
9694    Recency_at,
9695    #[serde(rename = "section_position")]
9696    Section_position,
9697}
9698
9699#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
9700#[serde(transparent)]
9701pub struct ThreadSource(pub String);
9702
9703#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9704pub enum ThreadSourceKind {
9705    #[serde(rename = "cli")]
9706    Cli,
9707    #[serde(rename = "vscode")]
9708    Vscode,
9709    #[serde(rename = "exec")]
9710    Exec,
9711    #[serde(rename = "appServer")]
9712    AppServer,
9713    #[serde(rename = "subAgent")]
9714    SubAgent,
9715    #[serde(rename = "subAgentReview")]
9716    SubAgentReview,
9717    #[serde(rename = "subAgentCompact")]
9718    SubAgentCompact,
9719    #[serde(rename = "subAgentThreadSpawn")]
9720    SubAgentThreadSpawn,
9721    #[serde(rename = "subAgentOther")]
9722    SubAgentOther,
9723    #[serde(rename = "unknown")]
9724    Unknown,
9725}
9726
9727#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9728#[serde(rename_all = "camelCase")]
9729pub struct ThreadStartParams {
9730    #[serde(
9731        rename = "approvalPolicy",
9732        default,
9733        skip_serializing_if = "Option::is_none"
9734    )]
9735    pub approval_policy: Option<AskForApproval>,
9736    #[serde(
9737        rename = "approvalsReviewer",
9738        default,
9739        skip_serializing_if = "Option::is_none"
9740    )]
9741    pub approvals_reviewer: Option<ApprovalsReviewer>,
9742    #[serde(
9743        rename = "baseInstructions",
9744        default,
9745        skip_serializing_if = "Option::is_none"
9746    )]
9747    pub base_instructions: Option<String>,
9748    #[serde(default, skip_serializing_if = "Option::is_none")]
9749    pub config: Option<Value>,
9750    #[serde(default, skip_serializing_if = "Option::is_none")]
9751    pub cwd: Option<String>,
9752    #[serde(
9753        rename = "developerInstructions",
9754        default,
9755        skip_serializing_if = "Option::is_none"
9756    )]
9757    pub developer_instructions: Option<String>,
9758    #[serde(default, skip_serializing_if = "Option::is_none")]
9759    pub ephemeral: Option<bool>,
9760    #[serde(default, skip_serializing_if = "Option::is_none")]
9761    pub model: Option<String>,
9762    #[serde(
9763        rename = "modelProvider",
9764        default,
9765        skip_serializing_if = "Option::is_none"
9766    )]
9767    pub model_provider: Option<String>,
9768    #[serde(default, skip_serializing_if = "Option::is_none")]
9769    pub personality: Option<Personality>,
9770    #[serde(default, skip_serializing_if = "Option::is_none")]
9771    pub sandbox: Option<SandboxMode>,
9772    #[serde(
9773        rename = "serviceName",
9774        default,
9775        skip_serializing_if = "Option::is_none"
9776    )]
9777    pub service_name: Option<String>,
9778    #[serde(
9779        rename = "serviceTier",
9780        default,
9781        skip_serializing_if = "Option::is_none"
9782    )]
9783    pub service_tier: Option<String>,
9784    #[serde(
9785        rename = "sessionStartSource",
9786        default,
9787        skip_serializing_if = "Option::is_none"
9788    )]
9789    pub session_start_source: Option<ThreadStartSource>,
9790    #[serde(
9791        rename = "threadSource",
9792        default,
9793        skip_serializing_if = "Option::is_none"
9794    )]
9795    pub thread_source: Option<ThreadSource>,
9796}
9797
9798#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9799#[serde(rename_all = "camelCase")]
9800pub struct ThreadStartResponse {
9801    #[serde(rename = "approvalPolicy")]
9802    pub approval_policy: AskForApproval,
9803    #[serde(rename = "approvalsReviewer", default)]
9804    pub approvals_reviewer: Value,
9805    #[serde()]
9806    pub cwd: AbsolutePathBuf,
9807    /// Saved list of disabled plugin IDs. Does not yet filter plugin
9808    /// capabilities.
9809    #[serde(rename = "disabledPluginIds", default)]
9810    pub disabled_plugin_ids: Vec<String>,
9811    #[serde(
9812        rename = "instructionSources",
9813        default,
9814        skip_serializing_if = "Option::is_none"
9815    )]
9816    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9817    #[serde(default)]
9818    pub model: String,
9819    #[serde(rename = "modelProvider", default)]
9820    pub model_provider: String,
9821    #[serde(
9822        rename = "reasoningEffort",
9823        default,
9824        skip_serializing_if = "Option::is_none"
9825    )]
9826    pub reasoning_effort: Option<ReasoningEffort>,
9827    #[serde(default)]
9828    pub sandbox: Value,
9829    #[serde(
9830        rename = "serviceTier",
9831        default,
9832        skip_serializing_if = "Option::is_none"
9833    )]
9834    pub service_tier: Option<String>,
9835    #[serde()]
9836    pub thread: Thread,
9837}
9838
9839#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9840pub enum ThreadStartSource {
9841    #[serde(rename = "startup")]
9842    Startup,
9843    #[serde(rename = "clear")]
9844    Clear,
9845}
9846
9847#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9848#[serde(rename_all = "camelCase")]
9849pub struct ThreadStartedNotification {
9850    #[serde()]
9851    pub thread: Thread,
9852}
9853
9854#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9855#[serde(tag = "type", rename_all = "camelCase")]
9856pub enum ThreadStatus {
9857    #[serde(rename = "notLoaded")]
9858    NotLoaded,
9859    Idle,
9860    #[serde(rename = "systemError")]
9861    SystemError,
9862    Active {
9863        #[serde(rename = "activeFlags")]
9864        active_flags: Vec<ThreadActiveFlag>,
9865    },
9866}
9867
9868#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9869#[serde(rename_all = "camelCase")]
9870pub struct ThreadStatusChangedNotification {
9871    #[serde()]
9872    pub status: ThreadStatus,
9873    #[serde(rename = "threadId", default)]
9874    pub thread_id: String,
9875}
9876
9877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9878#[serde(rename_all = "camelCase")]
9879pub struct ThreadTokenUsage {
9880    #[serde()]
9881    pub last: TokenUsageBreakdown,
9882    #[serde(
9883        rename = "modelContextWindow",
9884        default,
9885        skip_serializing_if = "Option::is_none"
9886    )]
9887    pub model_context_window: Option<i64>,
9888    #[serde()]
9889    pub total: TokenUsageBreakdown,
9890}
9891
9892#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9893#[serde(rename_all = "camelCase")]
9894pub struct ThreadTokenUsageUpdatedNotification {
9895    #[serde(rename = "threadId", default)]
9896    pub thread_id: String,
9897    #[serde(rename = "tokenUsage")]
9898    pub token_usage: ThreadTokenUsage,
9899    #[serde(rename = "turnId", default)]
9900    pub turn_id: String,
9901}
9902
9903#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9904#[serde(rename_all = "camelCase")]
9905pub struct ThreadUnarchiveParams {
9906    #[serde(rename = "threadId", default)]
9907    pub thread_id: String,
9908}
9909
9910#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9911#[serde(rename_all = "camelCase")]
9912pub struct ThreadUnarchiveResponse {
9913    #[serde()]
9914    pub thread: Thread,
9915}
9916
9917#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9918#[serde(rename_all = "camelCase")]
9919pub struct ThreadUnarchivedNotification {
9920    #[serde(rename = "threadId", default)]
9921    pub thread_id: String,
9922}
9923
9924#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9925#[serde(tag = "type", rename_all = "camelCase")]
9926pub enum ThreadUnreadPosition {
9927    /// Explicitly marked unread, including when the thread has no turns.
9928    #[serde(rename = "threadStart")]
9929    ThreadStart,
9930    /// The earliest completed result needing attention.
9931    Turn {
9932        #[serde(rename = "turnId")]
9933        turn_id: String,
9934    },
9935}
9936
9937/// EXPERIMENTAL upstream — one item or turn boundary in canonical rollout
9938/// order (0.148). Wire quirk mirrored exactly: the `item` variant uses
9939/// camelCase `turnId` while the turn-boundary variants use snake_case
9940/// `turn_id`/`started_at`/`completed_at`/`duration_ms`.
9941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9942#[serde(tag = "type", rename_all = "camelCase")]
9943#[allow(clippy::large_enum_variant)] // transient per-entry wire value, not stored in bulk
9944pub enum ThreadTimelineEntry {
9945    Item {
9946        item: ThreadItem,
9947        position: u64,
9948        #[serde(rename = "turnId")]
9949        turn_id: String,
9950    },
9951    Realtime {
9952        item: ThreadRealtimeItem,
9953        position: u64,
9954    },
9955    TurnStarted {
9956        position: u64,
9957        #[serde(default, skip_serializing_if = "Option::is_none")]
9958        started_at: Option<i64>,
9959        turn_id: String,
9960    },
9961    TurnCompleted {
9962        #[serde(default, skip_serializing_if = "Option::is_none")]
9963        completed_at: Option<i64>,
9964        #[serde(default, skip_serializing_if = "Option::is_none")]
9965        duration_ms: Option<i64>,
9966        #[serde(default, skip_serializing_if = "Option::is_none")]
9967        error: Option<TurnError>,
9968        position: u64,
9969        #[serde(default, skip_serializing_if = "Option::is_none")]
9970        started_at: Option<i64>,
9971        status: TurnStatus,
9972        turn_id: String,
9973    },
9974}
9975
9976/// Params for `thread/turns/list` — paginated turn hydration (0.148 upstream).
9977#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9978#[serde(rename_all = "camelCase")]
9979pub struct ThreadTurnsListParams {
9980    #[serde(default, skip_serializing_if = "Option::is_none")]
9981    pub cursor: Option<String>,
9982    /// How much item detail to include per turn; defaults to summary.
9983    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9984    pub items_view: Option<TurnItemsView>,
9985    #[serde(default, skip_serializing_if = "Option::is_none")]
9986    pub limit: Option<u32>,
9987    #[serde(
9988        rename = "sortDirection",
9989        default,
9990        skip_serializing_if = "Option::is_none"
9991    )]
9992    pub sort_direction: Option<SortDirection>,
9993    #[serde(rename = "threadId", default)]
9994    pub thread_id: String,
9995}
9996
9997/// Response to `thread/turns/list` (0.148 upstream).
9998#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9999#[serde(rename_all = "camelCase")]
10000pub struct ThreadTurnsListResponse {
10001    #[serde(
10002        rename = "backwardsCursor",
10003        default,
10004        skip_serializing_if = "Option::is_none"
10005    )]
10006    pub backwards_cursor: Option<String>,
10007    #[serde(default)]
10008    pub data: Vec<Turn>,
10009    #[serde(
10010        rename = "nextCursor",
10011        default,
10012        skip_serializing_if = "Option::is_none"
10013    )]
10014    pub next_cursor: Option<String>,
10015}
10016
10017#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10018#[serde(rename_all = "camelCase")]
10019pub struct ThreadUnsubscribeParams {
10020    #[serde(rename = "threadId", default)]
10021    pub thread_id: String,
10022}
10023
10024#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10025#[serde(rename_all = "camelCase")]
10026pub struct ThreadUnsubscribeResponse {
10027    #[serde()]
10028    pub status: ThreadUnsubscribeStatus,
10029}
10030
10031#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10032pub enum ThreadUnsubscribeStatus {
10033    #[serde(rename = "notLoaded")]
10034    NotLoaded,
10035    #[serde(rename = "notSubscribed")]
10036    NotSubscribed,
10037    #[serde(rename = "unsubscribed")]
10038    Unsubscribed,
10039}
10040
10041#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10042#[serde(rename_all = "camelCase")]
10043pub struct TokenUsageBreakdown {
10044    #[serde(
10045        rename = "cacheWriteInputTokens",
10046        default,
10047        skip_serializing_if = "Option::is_none"
10048    )]
10049    pub cache_write_input_tokens: Option<i64>,
10050    #[serde(rename = "cachedInputTokens", default)]
10051    pub cached_input_tokens: i64,
10052    #[serde(rename = "inputTokens", default)]
10053    pub input_tokens: i64,
10054    #[serde(rename = "outputTokens", default)]
10055    pub output_tokens: i64,
10056    #[serde(rename = "reasoningOutputTokens", default)]
10057    pub reasoning_output_tokens: i64,
10058    #[serde(rename = "totalTokens", default)]
10059    pub total_tokens: i64,
10060}
10061
10062#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10063#[serde(rename_all = "camelCase")]
10064pub struct Tool {
10065    #[serde(default, skip_serializing_if = "Option::is_none")]
10066    pub _meta: Option<Value>,
10067    #[serde(default, skip_serializing_if = "Option::is_none")]
10068    pub annotations: Option<Value>,
10069    #[serde(default, skip_serializing_if = "Option::is_none")]
10070    pub description: Option<String>,
10071    #[serde(default, skip_serializing_if = "Option::is_none")]
10072    pub icons: Option<Vec<Value>>,
10073    #[serde(rename = "inputSchema", default)]
10074    pub input_schema: Value,
10075    #[serde(default)]
10076    pub name: String,
10077    #[serde(
10078        rename = "outputSchema",
10079        default,
10080        skip_serializing_if = "Option::is_none"
10081    )]
10082    pub output_schema: Option<Value>,
10083    #[serde(default, skip_serializing_if = "Option::is_none")]
10084    pub title: Option<String>,
10085}
10086
10087#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10088#[serde(rename_all = "camelCase")]
10089pub struct ToolRequestUserInputAnswer {
10090    #[serde(default)]
10091    pub answers: Vec<String>,
10092}
10093
10094#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10095#[serde(rename_all = "camelCase")]
10096pub struct ToolRequestUserInputOption {
10097    #[serde(default)]
10098    pub description: String,
10099    #[serde(default)]
10100    pub label: String,
10101}
10102
10103#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10104#[serde(rename_all = "camelCase")]
10105pub struct ToolRequestUserInputParams {
10106    #[serde(
10107        rename = "autoResolutionMs",
10108        default,
10109        skip_serializing_if = "Option::is_none"
10110    )]
10111    pub auto_resolution_ms: Option<i64>,
10112    #[serde(rename = "isBlocking", default)]
10113    pub is_blocking: bool,
10114    #[serde(rename = "itemId", default)]
10115    pub item_id: String,
10116    #[serde(default)]
10117    pub questions: Vec<ToolRequestUserInputQuestion>,
10118    #[serde(rename = "threadId", default)]
10119    pub thread_id: String,
10120    #[serde(rename = "turnId", default)]
10121    pub turn_id: String,
10122}
10123
10124#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10125#[serde(rename_all = "camelCase")]
10126pub struct ToolRequestUserInputQuestion {
10127    #[serde(default)]
10128    pub header: String,
10129    #[serde(default)]
10130    pub id: String,
10131    #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
10132    pub is_other: Option<bool>,
10133    #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
10134    pub is_secret: Option<bool>,
10135    #[serde(default, skip_serializing_if = "Option::is_none")]
10136    pub options: Option<Vec<ToolRequestUserInputOption>>,
10137    #[serde(default)]
10138    pub question: String,
10139}
10140
10141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10142#[serde(rename_all = "camelCase")]
10143pub struct ToolRequestUserInputResponse {
10144    #[serde(default)]
10145    pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
10146}
10147
10148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10149#[serde(rename_all = "camelCase")]
10150pub struct ToolsV2 {
10151    #[serde(default, skip_serializing_if = "Option::is_none")]
10152    pub web_search: Option<WebSearchToolConfig>,
10153}
10154
10155#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10156#[serde(rename_all = "camelCase")]
10157pub struct Turn {
10158    #[serde(
10159        rename = "completedAt",
10160        default,
10161        skip_serializing_if = "Option::is_none"
10162    )]
10163    pub completed_at: Option<i64>,
10164    #[serde(
10165        rename = "durationMs",
10166        default,
10167        skip_serializing_if = "Option::is_none"
10168    )]
10169    pub duration_ms: Option<i64>,
10170    #[serde(default, skip_serializing_if = "Option::is_none")]
10171    pub error: Option<TurnError>,
10172    #[serde(default)]
10173    pub id: String,
10174    #[serde(default)]
10175    pub items: Vec<ThreadItem>,
10176    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
10177    pub items_view: Option<Value>,
10178    /// ID of the first turn in the chain of work that led to this turn. Pass
10179    /// this as `rootTurnId` when starting work on behalf of this turn. May be
10180    /// null in older history or a `review/start` response.
10181    #[serde(
10182        rename = "rootTurnId",
10183        default,
10184        skip_serializing_if = "Option::is_none"
10185    )]
10186    pub root_turn_id: Option<String>,
10187    #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
10188    pub started_at: Option<i64>,
10189    #[serde()]
10190    pub status: TurnStatus,
10191}
10192
10193#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10194#[serde(rename_all = "camelCase")]
10195pub struct TurnCompletedNotification {
10196    #[serde(rename = "threadId", default)]
10197    pub thread_id: String,
10198    #[serde()]
10199    pub turn: Turn,
10200}
10201
10202#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10203#[serde(rename_all = "camelCase")]
10204pub struct TurnDiffUpdatedNotification {
10205    #[serde(default)]
10206    pub diff: String,
10207    #[serde(rename = "threadId", default)]
10208    pub thread_id: String,
10209    #[serde(rename = "turnId", default)]
10210    pub turn_id: String,
10211}
10212
10213#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10214#[serde(rename_all = "camelCase")]
10215pub struct TurnError {
10216    #[serde(
10217        rename = "additionalDetails",
10218        default,
10219        skip_serializing_if = "Option::is_none"
10220    )]
10221    pub additional_details: Option<String>,
10222    #[serde(
10223        rename = "codexErrorInfo",
10224        default,
10225        skip_serializing_if = "Option::is_none"
10226    )]
10227    pub codex_error_info: Option<CodexErrorInfo>,
10228    #[serde(default)]
10229    pub message: String,
10230    /// Public explanation and continuation instruction for a misalignment
10231    /// block (0.148 upstream).
10232    #[serde(default, skip_serializing_if = "Option::is_none")]
10233    pub misalignment: Option<MisalignmentErrorDetails>,
10234}
10235
10236#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10237#[serde(rename_all = "camelCase")]
10238pub struct TurnInterruptParams {
10239    #[serde(rename = "threadId", default)]
10240    pub thread_id: String,
10241    #[serde(rename = "turnId", default)]
10242    pub turn_id: String,
10243}
10244
10245#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10246#[serde(rename_all = "camelCase")]
10247pub struct TurnInterruptResponse {
10248    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
10249    pub extra: serde_json::Map<String, Value>,
10250}
10251
10252#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
10253pub enum TurnItemsView {
10254    #[serde(rename = "notLoaded")]
10255    NotLoaded,
10256    #[serde(rename = "summary")]
10257    Summary,
10258    #[serde(rename = "full")]
10259    Full,
10260}
10261
10262#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10263#[serde(rename_all = "camelCase")]
10264pub struct TurnModerationMetadataNotification {
10265    #[serde(default)]
10266    pub metadata: Value,
10267    #[serde(rename = "threadId", default)]
10268    pub thread_id: String,
10269    #[serde(rename = "turnId", default)]
10270    pub turn_id: String,
10271}
10272
10273#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10274#[serde(rename_all = "camelCase")]
10275pub struct TurnPlanStep {
10276    #[serde()]
10277    pub status: TurnPlanStepStatus,
10278    #[serde(default)]
10279    pub step: String,
10280}
10281
10282#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10283pub enum TurnPlanStepStatus {
10284    #[serde(rename = "pending")]
10285    Pending,
10286    #[serde(rename = "inProgress")]
10287    InProgress,
10288    #[serde(rename = "completed")]
10289    Completed,
10290}
10291
10292#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10293#[serde(rename_all = "camelCase")]
10294pub struct TurnPlanUpdatedNotification {
10295    #[serde(default, skip_serializing_if = "Option::is_none")]
10296    pub explanation: Option<String>,
10297    #[serde(default)]
10298    pub plan: Vec<TurnPlanStep>,
10299    #[serde(rename = "threadId", default)]
10300    pub thread_id: String,
10301    #[serde(rename = "turnId", default)]
10302    pub turn_id: String,
10303}
10304
10305#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10306#[serde(rename_all = "camelCase")]
10307pub struct TurnStartParams {
10308    #[serde(
10309        rename = "approvalPolicy",
10310        default,
10311        skip_serializing_if = "Option::is_none"
10312    )]
10313    pub approval_policy: Option<AskForApproval>,
10314    #[serde(
10315        rename = "approvalsReviewer",
10316        default,
10317        skip_serializing_if = "Option::is_none"
10318    )]
10319    pub approvals_reviewer: Option<ApprovalsReviewer>,
10320    #[serde(
10321        rename = "clientUserMessageId",
10322        default,
10323        skip_serializing_if = "Option::is_none"
10324    )]
10325    pub client_user_message_id: Option<String>,
10326    #[serde(default, skip_serializing_if = "Option::is_none")]
10327    pub cwd: Option<String>,
10328    /// Replace this thread's disabled plugin IDs. Omitted/null preserves the
10329    /// list; `[]` clears it.
10330    #[serde(
10331        rename = "disabledPluginIds",
10332        default,
10333        skip_serializing_if = "Option::is_none"
10334    )]
10335    pub disabled_plugin_ids: Option<Vec<String>>,
10336    #[serde(default, skip_serializing_if = "Option::is_none")]
10337    pub effort: Option<ReasoningEffort>,
10338    #[serde(default)]
10339    pub input: Vec<UserInput>,
10340    #[serde(default, skip_serializing_if = "Option::is_none")]
10341    pub model: Option<String>,
10342    #[serde(
10343        rename = "outputSchema",
10344        default,
10345        skip_serializing_if = "Option::is_none"
10346    )]
10347    pub output_schema: Option<Value>,
10348    /// ID of the turn that caused this new turn to start. Set this when
10349    /// starting work on behalf of another turn; leave unset for work started
10350    /// directly by the user. Ignored when adding input to an active turn.
10351    #[serde(
10352        rename = "parentTurnId",
10353        default,
10354        skip_serializing_if = "Option::is_none"
10355    )]
10356    pub parent_turn_id: Option<String>,
10357    #[serde(default, skip_serializing_if = "Option::is_none")]
10358    pub personality: Option<Personality>,
10359    /// ID of the first turn in the chain of work that led to this new turn.
10360    /// When setting `parent_turn_id`, set this to the parent turn's
10361    /// `root_turn_id` when known; if omitted, the new turn becomes its own
10362    /// root. Ignored when adding input to an active turn.
10363    #[serde(
10364        rename = "rootTurnId",
10365        default,
10366        skip_serializing_if = "Option::is_none"
10367    )]
10368    pub root_turn_id: Option<String>,
10369    #[serde(
10370        rename = "sandboxPolicy",
10371        default,
10372        skip_serializing_if = "Option::is_none"
10373    )]
10374    pub sandbox_policy: Option<SandboxPolicy>,
10375    #[serde(
10376        rename = "serviceTier",
10377        default,
10378        skip_serializing_if = "Option::is_none"
10379    )]
10380    pub service_tier: Option<String>,
10381    /// One-turn service-tier override; `"default"` for standard speed.
10382    /// Omitted or null inherits the thread's tier (0.148 upstream).
10383    #[serde(
10384        rename = "serviceTierForTurn",
10385        default,
10386        skip_serializing_if = "Option::is_none"
10387    )]
10388    pub service_tier_for_turn: Option<String>,
10389    #[serde(default, skip_serializing_if = "Option::is_none")]
10390    pub summary: Option<ReasoningSummary>,
10391    #[serde(rename = "threadId", default)]
10392    pub thread_id: String,
10393    /// Pre-computed tool output to inject when starting the turn
10394    /// (0.148 upstream).
10395    #[serde(
10396        rename = "toolOutput",
10397        default,
10398        skip_serializing_if = "Option::is_none"
10399    )]
10400    pub tool_output: Option<TurnToolOutput>,
10401    /// Optional source classification for the caller starting this turn;
10402    /// ignored when steering an already-active turn (0.148 upstream).
10403    #[serde(
10404        rename = "turnTrigger",
10405        default,
10406        skip_serializing_if = "Option::is_none"
10407    )]
10408    pub turn_trigger: Option<String>,
10409}
10410
10411#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10412#[serde(rename_all = "camelCase")]
10413pub struct TurnStartResponse {
10414    #[serde()]
10415    pub turn: Turn,
10416}
10417
10418#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10419#[serde(rename_all = "camelCase")]
10420pub struct TurnStartedNotification {
10421    #[serde(rename = "threadId", default)]
10422    pub thread_id: String,
10423    #[serde()]
10424    pub turn: Turn,
10425}
10426
10427#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10428pub enum TurnStatus {
10429    #[serde(rename = "completed")]
10430    Completed,
10431    #[serde(rename = "interrupted")]
10432    Interrupted,
10433    #[serde(rename = "failed")]
10434    Failed,
10435    #[serde(rename = "inProgress")]
10436    InProgress,
10437}
10438
10439/// A pre-computed tool output supplied when starting a turn
10440/// (`TurnStartParams.toolOutput`, 0.148 upstream).
10441#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10442#[serde(rename_all = "camelCase")]
10443pub struct TurnToolOutput {
10444    #[serde(default)]
10445    pub name: String,
10446    #[serde(default, skip_serializing_if = "Option::is_none")]
10447    pub namespace: Option<String>,
10448    #[serde()]
10449    pub output: FunctionCallOutputBody,
10450    /// Requests retention of this output in the thread's model history
10451    /// (openai/codex#52686). Omitted from the wire when `false`.
10452    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
10453    pub retain: bool,
10454}
10455
10456#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10457#[serde(rename_all = "camelCase")]
10458pub struct TurnSteerParams {
10459    #[serde(
10460        rename = "clientUserMessageId",
10461        default,
10462        skip_serializing_if = "Option::is_none"
10463    )]
10464    pub client_user_message_id: Option<String>,
10465    #[serde(rename = "expectedTurnId", default)]
10466    pub expected_turn_id: String,
10467    #[serde(default)]
10468    pub input: Vec<UserInput>,
10469    #[serde(rename = "threadId", default)]
10470    pub thread_id: String,
10471}
10472
10473#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10474#[serde(rename_all = "camelCase")]
10475pub struct TurnSteerResponse {
10476    #[serde(rename = "turnId", default)]
10477    pub turn_id: String,
10478}
10479
10480#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10481#[serde(tag = "type", rename_all = "camelCase")]
10482pub enum UserInput {
10483    Text {
10484        text: String,
10485        #[serde(default, skip_serializing_if = "Option::is_none")]
10486        text_elements: Option<Vec<TextElement>>,
10487    },
10488    Image {
10489        #[serde(default, skip_serializing_if = "Option::is_none")]
10490        detail: Option<ImageDetail>,
10491        #[serde(flatten)]
10492        image: UserInputImageReference,
10493    },
10494    #[serde(rename = "localImage")]
10495    LocalImage {
10496        #[serde(default, skip_serializing_if = "Option::is_none")]
10497        detail: Option<ImageDetail>,
10498        path: String,
10499    },
10500    Audio {
10501        #[serde(flatten)]
10502        audio: UserInputAudioReference,
10503    },
10504    #[serde(rename = "localAudio")]
10505    LocalAudio {
10506        path: String,
10507    },
10508    Skill {
10509        name: String,
10510        path: String,
10511    },
10512    Mention {
10513        name: String,
10514        path: String,
10515    },
10516}
10517
10518/// How a [`UserInput::Image`] names its image: an inline `url` (data URL or
10519/// remote URL) or a previously uploaded `fileId`. Flattened into the variant;
10520/// untagged, so exactly one of the two keys is on the wire. Mirrors the v2
10521/// `ImageReference` upstream; the Responses-API twin used by tool outputs is
10522/// [`ImageReference`].
10523#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10524#[serde(untagged)]
10525pub enum UserInputImageReference {
10526    Inline {
10527        url: String,
10528    },
10529    File {
10530        #[serde(rename = "fileId")]
10531        file_id: String,
10532    },
10533}
10534
10535/// How a [`UserInput::Audio`] names its audio: an inline `url` or a
10536/// previously uploaded `fileId`. Flattened into the variant; untagged, so
10537/// exactly one of the two keys is on the wire. Mirrors the v2
10538/// `AudioReference` upstream.
10539#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10540#[serde(untagged)]
10541pub enum UserInputAudioReference {
10542    Inline {
10543        url: String,
10544    },
10545    File {
10546        #[serde(rename = "fileId")]
10547        file_id: String,
10548    },
10549}
10550
10551#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10552pub enum Verbosity {
10553    #[serde(rename = "low")]
10554    Low,
10555    #[serde(rename = "medium")]
10556    Medium,
10557    #[serde(rename = "high")]
10558    High,
10559}
10560
10561#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10562#[serde(rename_all = "camelCase")]
10563pub struct WarningNotification {
10564    #[serde(default)]
10565    pub message: String,
10566    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
10567    pub thread_id: Option<String>,
10568}
10569
10570#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10571#[serde(tag = "type", rename_all = "camelCase")]
10572pub enum WebSearchAction {
10573    Search {
10574        #[serde(default, skip_serializing_if = "Option::is_none")]
10575        queries: Option<Vec<String>>,
10576        #[serde(default, skip_serializing_if = "Option::is_none")]
10577        query: Option<String>,
10578    },
10579    #[serde(rename = "openPage")]
10580    OpenPage {
10581        #[serde(default, skip_serializing_if = "Option::is_none")]
10582        url: Option<String>,
10583    },
10584    #[serde(rename = "findInPage")]
10585    FindInPage {
10586        #[serde(default, skip_serializing_if = "Option::is_none")]
10587        pattern: Option<String>,
10588        #[serde(default, skip_serializing_if = "Option::is_none")]
10589        url: Option<String>,
10590    },
10591    Other,
10592}
10593
10594#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10595pub enum WebSearchContextSize {
10596    #[serde(rename = "low")]
10597    Low,
10598    #[serde(rename = "medium")]
10599    Medium,
10600    #[serde(rename = "high")]
10601    High,
10602}
10603
10604#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10605#[serde(rename_all = "camelCase")]
10606pub struct WebSearchLocation {
10607    #[serde(default, skip_serializing_if = "Option::is_none")]
10608    pub city: Option<String>,
10609    #[serde(default, skip_serializing_if = "Option::is_none")]
10610    pub country: Option<String>,
10611    #[serde(default, skip_serializing_if = "Option::is_none")]
10612    pub region: Option<String>,
10613    #[serde(default, skip_serializing_if = "Option::is_none")]
10614    pub timezone: Option<String>,
10615}
10616
10617#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10618pub enum WebSearchMode {
10619    #[serde(rename = "disabled")]
10620    Disabled,
10621    #[serde(rename = "cached")]
10622    Cached,
10623    #[serde(rename = "indexed")]
10624    Indexed,
10625    #[serde(rename = "live")]
10626    Live,
10627}
10628
10629/// Web search provider preference selected by the resolved model catalog
10630/// entry.
10631#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10632pub enum WebSearchProvider {
10633    #[serde(rename = "standalone")]
10634    Standalone,
10635    #[serde(rename = "search_mcp")]
10636    SearchMcp,
10637}
10638
10639#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10640#[serde(rename_all = "camelCase")]
10641pub struct WebSearchToolConfig {
10642    #[serde(default, skip_serializing_if = "Option::is_none")]
10643    pub allowed_domains: Option<Vec<String>>,
10644    #[serde(default, skip_serializing_if = "Option::is_none")]
10645    pub context_size: Option<WebSearchContextSize>,
10646    #[serde(default, skip_serializing_if = "Option::is_none")]
10647    pub location: Option<WebSearchLocation>,
10648}
10649
10650#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10651pub enum WindowsSandboxReadiness {
10652    #[serde(rename = "ready")]
10653    Ready,
10654    #[serde(rename = "notConfigured")]
10655    NotConfigured,
10656    #[serde(rename = "updateRequired")]
10657    UpdateRequired,
10658}
10659
10660#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10661#[serde(rename_all = "camelCase")]
10662pub struct WindowsSandboxReadinessResponse {
10663    #[serde()]
10664    pub status: WindowsSandboxReadiness,
10665}
10666
10667#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10668#[serde(rename_all = "camelCase")]
10669pub struct WindowsSandboxSetupCompletedNotification {
10670    #[serde(default, skip_serializing_if = "Option::is_none")]
10671    pub error: Option<String>,
10672    #[serde()]
10673    pub mode: WindowsSandboxSetupMode,
10674    #[serde(default)]
10675    pub success: bool,
10676}
10677
10678#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10679pub enum WindowsSandboxSetupMode {
10680    #[serde(rename = "elevated")]
10681    Elevated,
10682    #[serde(rename = "unelevated")]
10683    Unelevated,
10684}
10685
10686/// A Windows sandbox implementation a managed policy may allow
10687/// ([`ConfigRequirements::allowed_windows_sandbox_implementations`]). Grows
10688/// `mxc` beyond the two [`WindowsSandboxSetupMode`] values.
10689#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10690pub enum WindowsSandboxImplementation {
10691    #[serde(rename = "elevated")]
10692    Elevated,
10693    #[serde(rename = "unelevated")]
10694    Unelevated,
10695    #[serde(rename = "mxc")]
10696    Mxc,
10697}
10698
10699#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10700#[serde(rename_all = "camelCase")]
10701pub struct WindowsSandboxSetupStartParams {
10702    #[serde(default, skip_serializing_if = "Option::is_none")]
10703    pub cwd: Option<AbsolutePathBuf>,
10704    #[serde()]
10705    pub mode: WindowsSandboxSetupMode,
10706}
10707
10708#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10709#[serde(rename_all = "camelCase")]
10710pub struct WindowsSandboxSetupStartResponse {
10711    #[serde(default)]
10712    pub started: bool,
10713}
10714
10715#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10716#[serde(rename_all = "camelCase")]
10717pub struct WindowsWorldWritableWarningNotification {
10718    #[serde(rename = "extraCount", default)]
10719    pub extra_count: i64,
10720    #[serde(rename = "failedScan", default)]
10721    pub failed_scan: bool,
10722    #[serde(rename = "samplePaths", default)]
10723    pub sample_paths: Vec<String>,
10724}
10725
10726#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10727#[serde(rename_all = "camelCase")]
10728pub struct WorkspaceMessage {
10729    #[serde(
10730        rename = "archivedAt",
10731        default,
10732        skip_serializing_if = "Option::is_none"
10733    )]
10734    pub archived_at: Option<i64>,
10735    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
10736    pub created_at: Option<i64>,
10737    #[serde(rename = "messageBody", default)]
10738    pub message_body: String,
10739    #[serde(rename = "messageId", default)]
10740    pub message_id: String,
10741    #[serde(rename = "messageType")]
10742    pub message_type: WorkspaceMessageType,
10743}
10744
10745#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10746pub enum WorkspaceMessageType {
10747    #[serde(rename = "headline")]
10748    Headline,
10749    #[serde(rename = "announcement")]
10750    Announcement,
10751    #[serde(rename = "unknown")]
10752    Unknown,
10753}
10754
10755#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10756pub enum WriteStatus {
10757    #[serde(rename = "ok")]
10758    Ok,
10759    #[serde(rename = "okOverridden")]
10760    OkOverridden,
10761}