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