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