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        region: String,
4052    },
4053    #[serde(rename = "amazonBedrockAccessKeys")]
4054    AmazonBedrockAccessKeys {
4055        #[serde(rename = "accessKeyId")]
4056        access_key_id: String,
4057        region: String,
4058        #[serde(rename = "secretAccessKey")]
4059        secret_access_key: String,
4060        #[serde(
4061            rename = "sessionToken",
4062            default,
4063            skip_serializing_if = "Option::is_none"
4064        )]
4065        session_token: Option<String>,
4066    },
4067}
4068
4069#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4070#[serde(tag = "type", rename_all = "camelCase")]
4071pub enum LoginAccountResponse {
4072    #[serde(rename = "apiKey")]
4073    ApiKey,
4074    Chatgpt {
4075        #[serde(rename = "authUrl")]
4076        auth_url: String,
4077        #[serde(rename = "loginId")]
4078        login_id: String,
4079    },
4080    #[serde(rename = "chatgptDeviceCode")]
4081    ChatgptDeviceCode {
4082        #[serde(rename = "loginId")]
4083        login_id: String,
4084        #[serde(rename = "userCode")]
4085        user_code: String,
4086        #[serde(rename = "verificationUrl")]
4087        verification_url: String,
4088    },
4089    #[serde(rename = "chatgptAuthTokens")]
4090    ChatgptAuthTokens,
4091    #[serde(rename = "amazonBedrock")]
4092    AmazonBedrock,
4093}
4094
4095#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4096pub enum LoginAppBrand {
4097    #[serde(rename = "codex")]
4098    Codex,
4099    #[serde(rename = "chatgpt")]
4100    Chatgpt,
4101}
4102
4103#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4104#[serde(rename_all = "camelCase")]
4105pub struct LogoutAccountResponse {
4106    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4107    pub extra: serde_json::Map<String, Value>,
4108}
4109
4110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4111#[serde(rename_all = "camelCase")]
4112pub struct MarketplaceAddParams {
4113    #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
4114    pub ref_name: Option<String>,
4115    #[serde(default)]
4116    pub source: String,
4117    #[serde(
4118        rename = "sparsePaths",
4119        default,
4120        skip_serializing_if = "Option::is_none"
4121    )]
4122    pub sparse_paths: Option<Vec<String>>,
4123}
4124
4125#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4126#[serde(rename_all = "camelCase")]
4127pub struct MarketplaceAddResponse {
4128    #[serde(rename = "alreadyAdded", default)]
4129    pub already_added: bool,
4130    #[serde(rename = "installedRoot")]
4131    pub installed_root: AbsolutePathBuf,
4132    #[serde(rename = "marketplaceName", default)]
4133    pub marketplace_name: String,
4134}
4135
4136#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4137#[serde(rename_all = "camelCase")]
4138pub struct MarketplaceInterface {
4139    #[serde(
4140        rename = "displayName",
4141        default,
4142        skip_serializing_if = "Option::is_none"
4143    )]
4144    pub display_name: Option<String>,
4145}
4146
4147#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4148#[serde(rename_all = "camelCase")]
4149pub struct MarketplaceLoadErrorInfo {
4150    #[serde(rename = "marketplacePath")]
4151    pub marketplace_path: AbsolutePathBuf,
4152    #[serde(default)]
4153    pub message: String,
4154}
4155
4156#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4157#[serde(rename_all = "camelCase")]
4158pub struct MarketplaceRemoveParams {
4159    #[serde(rename = "marketplaceName", default)]
4160    pub marketplace_name: String,
4161}
4162
4163#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4164#[serde(rename_all = "camelCase")]
4165pub struct MarketplaceRemoveResponse {
4166    #[serde(
4167        rename = "installedRoot",
4168        default,
4169        skip_serializing_if = "Option::is_none"
4170    )]
4171    pub installed_root: Option<AbsolutePathBuf>,
4172    #[serde(rename = "marketplaceName", default)]
4173    pub marketplace_name: String,
4174}
4175
4176#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4177#[serde(rename_all = "camelCase")]
4178pub struct MarketplaceUpgradeErrorInfo {
4179    #[serde(rename = "marketplaceName", default)]
4180    pub marketplace_name: String,
4181    #[serde(default)]
4182    pub message: String,
4183}
4184
4185#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4186#[serde(rename_all = "camelCase")]
4187pub struct MarketplaceUpgradeParams {
4188    #[serde(
4189        rename = "marketplaceName",
4190        default,
4191        skip_serializing_if = "Option::is_none"
4192    )]
4193    pub marketplace_name: Option<String>,
4194}
4195
4196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4197#[serde(rename_all = "camelCase")]
4198pub struct MarketplaceUpgradeResponse {
4199    #[serde(default)]
4200    pub errors: Vec<MarketplaceUpgradeErrorInfo>,
4201    #[serde(rename = "selectedMarketplaces", default)]
4202    pub selected_marketplaces: Vec<String>,
4203    #[serde(rename = "upgradedRoots", default)]
4204    pub upgraded_roots: Vec<AbsolutePathBuf>,
4205}
4206
4207#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4208pub enum McpAuthStatus {
4209    #[serde(rename = "unknown")]
4210    Unknown,
4211    #[serde(rename = "unsupported")]
4212    Unsupported,
4213    #[serde(rename = "notLoggedIn")]
4214    NotLoggedIn,
4215    #[serde(rename = "bearerToken")]
4216    BearerToken,
4217    #[serde(rename = "oAuth")]
4218    OAuth,
4219}
4220
4221#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4222pub enum McpElicitationArrayType {
4223    #[serde(rename = "array")]
4224    Array,
4225}
4226
4227#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4228#[serde(rename_all = "camelCase")]
4229pub struct McpElicitationBooleanSchema {
4230    #[serde(default, skip_serializing_if = "Option::is_none")]
4231    pub default: Option<bool>,
4232    #[serde(default, skip_serializing_if = "Option::is_none")]
4233    pub description: Option<String>,
4234    #[serde(default, skip_serializing_if = "Option::is_none")]
4235    pub title: Option<String>,
4236    #[serde(rename = "type")]
4237    pub type_: McpElicitationBooleanType,
4238}
4239
4240#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4241pub enum McpElicitationBooleanType {
4242    #[serde(rename = "boolean")]
4243    Boolean,
4244}
4245
4246#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4247#[serde(rename_all = "camelCase")]
4248pub struct McpElicitationConstOption {
4249    #[serde(rename = "const", default)]
4250    pub const_: String,
4251    #[serde(default)]
4252    pub title: String,
4253}
4254
4255#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4256#[serde(untagged)]
4257pub enum McpElicitationEnumSchema {
4258    McpElicitationSingleSelectEnumSchema(McpElicitationSingleSelectEnumSchema),
4259    McpElicitationMultiSelectEnumSchema(McpElicitationMultiSelectEnumSchema),
4260    McpElicitationLegacyTitledEnumSchema(McpElicitationLegacyTitledEnumSchema),
4261}
4262
4263#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4264#[serde(rename_all = "camelCase")]
4265pub struct McpElicitationLegacyTitledEnumSchema {
4266    #[serde(default, skip_serializing_if = "Option::is_none")]
4267    pub default: Option<String>,
4268    #[serde(default, skip_serializing_if = "Option::is_none")]
4269    pub description: Option<String>,
4270    #[serde(rename = "enum", default)]
4271    pub enum_: Vec<String>,
4272    #[serde(rename = "enumNames", default, skip_serializing_if = "Option::is_none")]
4273    pub enum_names: Option<Vec<String>>,
4274    #[serde(default, skip_serializing_if = "Option::is_none")]
4275    pub title: Option<String>,
4276    #[serde(rename = "type")]
4277    pub type_: McpElicitationStringType,
4278}
4279
4280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4281#[serde(untagged)]
4282pub enum McpElicitationMultiSelectEnumSchema {
4283    McpElicitationUntitledMultiSelectEnumSchema(McpElicitationUntitledMultiSelectEnumSchema),
4284    McpElicitationTitledMultiSelectEnumSchema(McpElicitationTitledMultiSelectEnumSchema),
4285}
4286
4287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4288#[serde(rename_all = "camelCase")]
4289pub struct McpElicitationNumberSchema {
4290    #[serde(default, skip_serializing_if = "Option::is_none")]
4291    pub default: Option<f64>,
4292    #[serde(default, skip_serializing_if = "Option::is_none")]
4293    pub description: Option<String>,
4294    #[serde(default, skip_serializing_if = "Option::is_none")]
4295    pub maximum: Option<f64>,
4296    #[serde(default, skip_serializing_if = "Option::is_none")]
4297    pub minimum: Option<f64>,
4298    #[serde(default, skip_serializing_if = "Option::is_none")]
4299    pub title: Option<String>,
4300    #[serde(rename = "type")]
4301    pub type_: McpElicitationNumberType,
4302}
4303
4304#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4305pub enum McpElicitationNumberType {
4306    #[serde(rename = "number")]
4307    Number,
4308    #[serde(rename = "integer")]
4309    Integer,
4310}
4311
4312#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4313pub enum McpElicitationObjectType {
4314    #[serde(rename = "object")]
4315    Object,
4316}
4317
4318#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4319#[serde(untagged)]
4320pub enum McpElicitationPrimitiveSchema {
4321    McpElicitationEnumSchema(McpElicitationEnumSchema),
4322    McpElicitationStringSchema(McpElicitationStringSchema),
4323    McpElicitationNumberSchema(McpElicitationNumberSchema),
4324    McpElicitationBooleanSchema(McpElicitationBooleanSchema),
4325}
4326
4327#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4328#[serde(rename_all = "camelCase")]
4329pub struct McpElicitationSchema {
4330    #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
4331    pub schema: Option<String>,
4332    #[serde(default)]
4333    pub properties: std::collections::BTreeMap<String, McpElicitationPrimitiveSchema>,
4334    #[serde(default, skip_serializing_if = "Option::is_none")]
4335    pub required: Option<Vec<String>>,
4336    #[serde(rename = "type")]
4337    pub type_: McpElicitationObjectType,
4338}
4339
4340#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4341#[serde(untagged)]
4342pub enum McpElicitationSingleSelectEnumSchema {
4343    McpElicitationUntitledSingleSelectEnumSchema(McpElicitationUntitledSingleSelectEnumSchema),
4344    McpElicitationTitledSingleSelectEnumSchema(McpElicitationTitledSingleSelectEnumSchema),
4345}
4346
4347#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4348pub enum McpElicitationStringFormat {
4349    #[serde(rename = "email")]
4350    Email,
4351    #[serde(rename = "uri")]
4352    Uri,
4353    #[serde(rename = "date")]
4354    Date,
4355    #[serde(rename = "date-time")]
4356    Date_time,
4357}
4358
4359#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4360#[serde(rename_all = "camelCase")]
4361pub struct McpElicitationStringSchema {
4362    #[serde(default, skip_serializing_if = "Option::is_none")]
4363    pub default: Option<String>,
4364    #[serde(default, skip_serializing_if = "Option::is_none")]
4365    pub description: Option<String>,
4366    #[serde(default, skip_serializing_if = "Option::is_none")]
4367    pub format: Option<McpElicitationStringFormat>,
4368    #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
4369    pub max_length: Option<i64>,
4370    #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
4371    pub min_length: Option<i64>,
4372    #[serde(default, skip_serializing_if = "Option::is_none")]
4373    pub title: Option<String>,
4374    #[serde(rename = "type")]
4375    pub type_: McpElicitationStringType,
4376}
4377
4378#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4379pub enum McpElicitationStringType {
4380    #[serde(rename = "string")]
4381    String,
4382}
4383
4384#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4385#[serde(rename_all = "camelCase")]
4386pub struct McpElicitationTitledEnumItems {
4387    #[serde(rename = "anyOf", default)]
4388    pub any_of: Vec<McpElicitationConstOption>,
4389}
4390
4391#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4392#[serde(rename_all = "camelCase")]
4393pub struct McpElicitationTitledMultiSelectEnumSchema {
4394    #[serde(default, skip_serializing_if = "Option::is_none")]
4395    pub default: Option<Vec<String>>,
4396    #[serde(default, skip_serializing_if = "Option::is_none")]
4397    pub description: Option<String>,
4398    #[serde()]
4399    pub items: McpElicitationTitledEnumItems,
4400    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4401    pub max_items: Option<i64>,
4402    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4403    pub min_items: Option<i64>,
4404    #[serde(default, skip_serializing_if = "Option::is_none")]
4405    pub title: Option<String>,
4406    #[serde(rename = "type")]
4407    pub type_: McpElicitationArrayType,
4408}
4409
4410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4411#[serde(rename_all = "camelCase")]
4412pub struct McpElicitationTitledSingleSelectEnumSchema {
4413    #[serde(default, skip_serializing_if = "Option::is_none")]
4414    pub default: Option<String>,
4415    #[serde(default, skip_serializing_if = "Option::is_none")]
4416    pub description: Option<String>,
4417    #[serde(rename = "oneOf", default)]
4418    pub one_of: Vec<McpElicitationConstOption>,
4419    #[serde(default, skip_serializing_if = "Option::is_none")]
4420    pub title: Option<String>,
4421    #[serde(rename = "type")]
4422    pub type_: McpElicitationStringType,
4423}
4424
4425#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4426#[serde(rename_all = "camelCase")]
4427pub struct McpElicitationUntitledEnumItems {
4428    #[serde(rename = "enum", default)]
4429    pub enum_: Vec<String>,
4430    #[serde(rename = "type")]
4431    pub type_: McpElicitationStringType,
4432}
4433
4434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4435#[serde(rename_all = "camelCase")]
4436pub struct McpElicitationUntitledMultiSelectEnumSchema {
4437    #[serde(default, skip_serializing_if = "Option::is_none")]
4438    pub default: Option<Vec<String>>,
4439    #[serde(default, skip_serializing_if = "Option::is_none")]
4440    pub description: Option<String>,
4441    #[serde()]
4442    pub items: McpElicitationUntitledEnumItems,
4443    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4444    pub max_items: Option<i64>,
4445    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4446    pub min_items: Option<i64>,
4447    #[serde(default, skip_serializing_if = "Option::is_none")]
4448    pub title: Option<String>,
4449    #[serde(rename = "type")]
4450    pub type_: McpElicitationArrayType,
4451}
4452
4453#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4454#[serde(rename_all = "camelCase")]
4455pub struct McpElicitationUntitledSingleSelectEnumSchema {
4456    #[serde(default, skip_serializing_if = "Option::is_none")]
4457    pub default: Option<String>,
4458    #[serde(default, skip_serializing_if = "Option::is_none")]
4459    pub description: Option<String>,
4460    #[serde(rename = "enum", default)]
4461    pub enum_: Vec<String>,
4462    #[serde(default, skip_serializing_if = "Option::is_none")]
4463    pub title: Option<String>,
4464    #[serde(rename = "type")]
4465    pub type_: McpElicitationStringType,
4466}
4467
4468#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4469#[serde(rename_all = "camelCase")]
4470pub struct McpResourceReadParams {
4471    /// Additional MCP request metadata. Account and turn routing keys are reserved.
4472    #[serde(rename = "_meta", default, skip_serializing_if = "Option::is_none")]
4473    pub meta: Option<serde_json::Map<String, Value>>,
4474    #[serde(
4475        rename = "connectorId",
4476        default,
4477        skip_serializing_if = "Option::is_none"
4478    )]
4479    pub connector_id: Option<String>,
4480    /// Exact registration scope; omission preserves legacy name-only selection.
4481    #[serde(
4482        rename = "environmentId",
4483        default,
4484        skip_serializing_if = "Option::is_none"
4485    )]
4486    pub environment_id: Option<String>,
4487    /// Originating MCP tool call used to select the resource's app.
4488    #[serde(
4489        rename = "originCallId",
4490        default,
4491        skip_serializing_if = "Option::is_none"
4492    )]
4493    pub origin_call_id: Option<String>,
4494    #[serde(default)]
4495    pub server: String,
4496    /// Explicit hosted app/account. Omit to retain legacy resource discovery.
4497    #[serde(default, skip_serializing_if = "Option::is_none")]
4498    pub target: Option<McpResourceReadTarget>,
4499    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4500    pub thread_id: Option<String>,
4501    #[serde(default)]
4502    pub uri: String,
4503}
4504
4505/// Explicit hosted app/account selector for `mcpServer/resource/read`.
4506#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4507#[serde(rename_all = "camelCase")]
4508pub struct McpResourceReadTarget {
4509    #[serde(rename = "connectorId", default)]
4510    pub connector_id: String,
4511    /// Null explicitly requests no-auth access, subject to the app's resource
4512    /// policy. Always serialized (the wire field is required but nullable).
4513    #[serde(rename = "linkId", default)]
4514    pub link_id: Option<String>,
4515}
4516
4517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4518#[serde(rename_all = "camelCase")]
4519pub struct McpResourceReadResponse {
4520    #[serde(default)]
4521    pub contents: Vec<ResourceContent>,
4522    /// Originating call when the server applied app-specific resource
4523    /// scoping.
4524    #[serde(
4525        rename = "originCallId",
4526        default,
4527        skip_serializing_if = "Option::is_none"
4528    )]
4529    pub origin_call_id: Option<String>,
4530}
4531
4532#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4533pub enum McpServerElicitationAction {
4534    #[serde(rename = "accept")]
4535    Accept,
4536    #[serde(rename = "decline")]
4537    Decline,
4538    #[serde(rename = "cancel")]
4539    Cancel,
4540}
4541
4542#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4543#[serde(tag = "mode", rename_all = "camelCase")]
4544pub enum McpServerElicitationRequestParams {
4545    Form {
4546        #[serde(default, skip_serializing_if = "Option::is_none")]
4547        _meta: Option<Value>,
4548        message: String,
4549        #[serde(rename = "requestedSchema")]
4550        requested_schema: McpElicitationSchema,
4551    },
4552    #[serde(rename = "openai/form")]
4553    OpenaiForm {
4554        #[serde(default, skip_serializing_if = "Option::is_none")]
4555        _meta: Option<Value>,
4556        message: String,
4557        #[serde(rename = "requestedSchema")]
4558        requested_schema: Value,
4559    },
4560    #[serde(rename = "openaiForm")]
4561    OpenAiElicitationForm {
4562        #[serde(default, skip_serializing_if = "Option::is_none")]
4563        _meta: Option<Value>,
4564        message: String,
4565        #[serde(rename = "requestedSchema")]
4566        requested_schema: Value,
4567    },
4568    Url {
4569        #[serde(default, skip_serializing_if = "Option::is_none")]
4570        _meta: Option<Value>,
4571        #[serde(rename = "elicitationId")]
4572        elicitation_id: String,
4573        message: String,
4574        url: String,
4575    },
4576}
4577
4578#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4579#[serde(rename_all = "camelCase")]
4580pub struct McpServerElicitationRequestResponse {
4581    #[serde(default, skip_serializing_if = "Option::is_none")]
4582    pub _meta: Option<Value>,
4583    #[serde()]
4584    pub action: McpServerElicitationAction,
4585    #[serde(default, skip_serializing_if = "Option::is_none")]
4586    pub content: Option<Value>,
4587}
4588
4589#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4590#[serde(rename_all = "camelCase")]
4591pub struct McpServerInfo {
4592    #[serde(default, skip_serializing_if = "Option::is_none")]
4593    pub description: Option<String>,
4594    #[serde(default, skip_serializing_if = "Option::is_none")]
4595    pub icons: Option<Vec<Value>>,
4596    #[serde(default)]
4597    pub name: String,
4598    #[serde(default, skip_serializing_if = "Option::is_none")]
4599    pub title: Option<String>,
4600    #[serde(default)]
4601    pub version: String,
4602    #[serde(
4603        rename = "websiteUrl",
4604        default,
4605        skip_serializing_if = "Option::is_none"
4606    )]
4607    pub website_url: Option<String>,
4608}
4609
4610#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4611#[serde(rename_all = "camelCase")]
4612pub struct McpServerMigration {
4613    #[serde(default)]
4614    pub name: String,
4615}
4616
4617#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4618#[serde(rename_all = "camelCase")]
4619pub struct McpServerOauthLoginCompletedNotification {
4620    #[serde(default, skip_serializing_if = "Option::is_none")]
4621    pub error: Option<String>,
4622    /// Identifies the explicit login attempt. Older servers omit this field.
4623    #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4624    pub login_id: Option<String>,
4625    #[serde(default)]
4626    pub name: String,
4627    #[serde(default)]
4628    pub success: bool,
4629    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4630    pub thread_id: Option<String>,
4631}
4632
4633#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4634#[serde(rename_all = "camelCase")]
4635pub struct McpServerOauthLoginParams {
4636    #[serde(
4637        rename = "clientRegistration",
4638        default,
4639        skip_serializing_if = "Option::is_none"
4640    )]
4641    pub client_registration: Option<McpServerOauthClientRegistration>,
4642    /// Exact registration scope; omission preserves legacy name-only selection.
4643    #[serde(
4644        rename = "environmentId",
4645        default,
4646        skip_serializing_if = "Option::is_none"
4647    )]
4648    pub environment_id: Option<String>,
4649    #[serde(default)]
4650    pub name: String,
4651    #[serde(default, skip_serializing_if = "Option::is_none")]
4652    pub scopes: Option<Vec<String>>,
4653    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4654    pub thread_id: Option<String>,
4655    #[serde(
4656        rename = "timeoutSecs",
4657        default,
4658        skip_serializing_if = "Option::is_none"
4659    )]
4660    pub timeout_secs: Option<i64>,
4661}
4662
4663#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4664#[serde(rename_all = "camelCase")]
4665pub struct McpServerOauthLoginResponse {
4666    #[serde(rename = "authorizationUrl", default)]
4667    pub authorization_url: String,
4668    /// Identifies this login attempt across the response and completion
4669    /// notification. Older servers omit this field; current servers always
4670    /// return it.
4671    #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4672    pub login_id: Option<String>,
4673}
4674
4675#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4676#[serde(rename_all = "camelCase")]
4677pub struct McpServerRefreshResponse {
4678    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4679    pub extra: serde_json::Map<String, Value>,
4680}
4681
4682#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4683pub enum McpServerStartupFailureReason {
4684    #[serde(rename = "reauthenticationRequired")]
4685    ReauthenticationRequired,
4686}
4687
4688#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4689pub enum McpServerStartupState {
4690    #[serde(rename = "starting")]
4691    Starting,
4692    #[serde(rename = "ready")]
4693    Ready,
4694    #[serde(rename = "failed")]
4695    Failed,
4696    #[serde(rename = "cancelled")]
4697    Cancelled,
4698}
4699
4700#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4701#[serde(rename_all = "camelCase")]
4702pub struct McpServerStatus {
4703    #[serde(rename = "authStatus")]
4704    pub auth_status: McpAuthStatus,
4705    /// Environment that contributed this registration; `None` for a
4706    /// thread-wide server. Older servers omit this field.
4707    #[serde(
4708        rename = "environmentId",
4709        default,
4710        skip_serializing_if = "Option::is_none"
4711    )]
4712    pub environment_id: Option<String>,
4713    /// HTTP origin of the effective configured endpoint, including plugin
4714    /// servers. Excludes credentials, path, query, and fragment; `None` for
4715    /// non-HTTP transports.
4716    #[serde(
4717        rename = "httpOrigin",
4718        default,
4719        skip_serializing_if = "Option::is_none"
4720    )]
4721    pub http_origin: Option<String>,
4722    /// Current thread-runtime connection state; absent when unavailable.
4723    #[serde(
4724        rename = "runtimeStatus",
4725        default,
4726        skip_serializing_if = "Option::is_none"
4727    )]
4728    pub runtime_status: Option<McpServerConnectionStatus>,
4729    #[serde(default)]
4730    pub name: String,
4731    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
4732    pub plugin_id: Option<String>,
4733    #[serde(rename = "resourceTemplates", default)]
4734    pub resource_templates: Vec<ResourceTemplate>,
4735    #[serde(default)]
4736    pub resources: Vec<Resource>,
4737    /// Capabilities advertised by the initialized MCP server; `None` when
4738    /// unavailable.
4739    #[serde(
4740        rename = "serverCapabilities",
4741        default,
4742        skip_serializing_if = "Option::is_none"
4743    )]
4744    pub server_capabilities: Option<Value>,
4745    #[serde(
4746        rename = "serverInfo",
4747        default,
4748        skip_serializing_if = "Option::is_none"
4749    )]
4750    pub server_info: Option<McpServerInfo>,
4751    /// Opaque `_meta` from the first page of the corresponding MCP tool
4752    /// catalog; `None` when unavailable.
4753    #[serde(
4754        rename = "toolListMeta",
4755        default,
4756        skip_serializing_if = "Option::is_none"
4757    )]
4758    pub tool_list_meta: Option<Value>,
4759    #[serde(default)]
4760    pub tools: std::collections::BTreeMap<String, Tool>,
4761    /// Tool discovery failed and no catalog was returned. `None` when a
4762    /// catalog is returned, including cached or empty catalogs.
4763    #[serde(
4764        rename = "toolsError",
4765        default,
4766        skip_serializing_if = "Option::is_none"
4767    )]
4768    pub tools_error: Option<String>,
4769}
4770
4771#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4772pub enum McpServerStatusDetail {
4773    #[serde(rename = "full")]
4774    Full,
4775    #[serde(rename = "toolsAndAuthOnly")]
4776    ToolsAndAuthOnly,
4777}
4778
4779#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4780#[serde(rename_all = "camelCase")]
4781pub struct McpServerStatusUpdatedNotification {
4782    /// Registration scope, not necessarily the server's execution environment.
4783    #[serde(
4784        rename = "environmentId",
4785        default,
4786        skip_serializing_if = "Option::is_none"
4787    )]
4788    pub environment_id: Option<String>,
4789    #[serde(default, skip_serializing_if = "Option::is_none")]
4790    pub error: Option<String>,
4791    #[serde(
4792        rename = "failureReason",
4793        default,
4794        skip_serializing_if = "Option::is_none"
4795    )]
4796    pub failure_reason: Option<McpServerStartupFailureReason>,
4797    #[serde(default)]
4798    pub name: String,
4799    #[serde()]
4800    pub status: McpServerStartupState,
4801    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4802    pub thread_id: Option<String>,
4803}
4804
4805#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4806#[serde(rename_all = "camelCase")]
4807pub struct McpServerToolCallParams {
4808    #[serde(default, skip_serializing_if = "Option::is_none")]
4809    pub _meta: Option<Value>,
4810    #[serde(default, skip_serializing_if = "Option::is_none")]
4811    pub arguments: Option<Value>,
4812    /// Exact registration scope; omission preserves legacy name-only selection.
4813    #[serde(
4814        rename = "environmentId",
4815        default,
4816        skip_serializing_if = "Option::is_none"
4817    )]
4818    pub environment_id: Option<String>,
4819    #[serde(default)]
4820    pub server: String,
4821    #[serde(rename = "threadId", default)]
4822    pub thread_id: String,
4823    #[serde(default)]
4824    pub tool: String,
4825}
4826
4827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4828#[serde(rename_all = "camelCase")]
4829pub struct McpServerToolCallResponse {
4830    #[serde(default, skip_serializing_if = "Option::is_none")]
4831    pub _meta: Option<Value>,
4832    #[serde(default)]
4833    pub content: Vec<Value>,
4834    #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
4835    pub is_error: Option<bool>,
4836    #[serde(
4837        rename = "structuredContent",
4838        default,
4839        skip_serializing_if = "Option::is_none"
4840    )]
4841    pub structured_content: Option<Value>,
4842}
4843
4844/// UI resource and display preference for model invocations, captured from
4845/// the tool descriptor (`ThreadItemPayload::McpToolCall::mcp_app_ui`).
4846#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
4847#[serde(rename_all = "camelCase")]
4848pub struct McpAppUi {
4849    #[serde(rename = "resourceUri")]
4850    pub resource_uri: String,
4851    #[serde(rename = "preferredModelDisplayMode")]
4852    pub preferred_model_display_mode: McpAppDisplayMode,
4853}
4854
4855#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4856pub enum McpAppDisplayMode {
4857    #[serde(rename = "inline")]
4858    Inline,
4859    #[serde(rename = "fullscreen")]
4860    Fullscreen,
4861}
4862
4863#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4864#[serde(rename_all = "camelCase")]
4865pub struct McpToolCallAppContext {
4866    #[serde(
4867        rename = "actionName",
4868        default,
4869        skip_serializing_if = "Option::is_none"
4870    )]
4871    pub action_name: Option<String>,
4872    #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
4873    pub app_name: Option<String>,
4874    #[serde(rename = "connectorId", default)]
4875    pub connector_id: String,
4876    #[serde(rename = "linkId", default, skip_serializing_if = "Option::is_none")]
4877    pub link_id: Option<String>,
4878    #[serde(
4879        rename = "resourceUri",
4880        default,
4881        skip_serializing_if = "Option::is_none"
4882    )]
4883    pub resource_uri: Option<String>,
4884}
4885
4886#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4887#[serde(rename_all = "camelCase")]
4888pub struct McpToolCallError {
4889    #[serde(default)]
4890    pub message: String,
4891}
4892
4893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4894#[serde(rename_all = "camelCase")]
4895pub struct McpToolCallProgressNotification {
4896    #[serde(rename = "itemId", default)]
4897    pub item_id: String,
4898    #[serde(default)]
4899    pub message: String,
4900    #[serde(rename = "threadId", default)]
4901    pub thread_id: String,
4902    #[serde(rename = "turnId", default)]
4903    pub turn_id: String,
4904}
4905
4906#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4907#[serde(rename_all = "camelCase")]
4908pub struct McpToolCallResult {
4909    #[serde(default, skip_serializing_if = "Option::is_none")]
4910    pub _meta: Option<Value>,
4911    #[serde(default)]
4912    pub content: Vec<Value>,
4913    #[serde(
4914        rename = "structuredContent",
4915        default,
4916        skip_serializing_if = "Option::is_none"
4917    )]
4918    pub structured_content: Option<Value>,
4919}
4920
4921#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4922pub enum McpToolCallStatus {
4923    #[serde(rename = "inProgress")]
4924    InProgress,
4925    #[serde(rename = "completed")]
4926    Completed,
4927    #[serde(rename = "failed")]
4928    Failed,
4929}
4930
4931#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4932#[serde(rename_all = "camelCase")]
4933pub struct MemoryCitation {
4934    #[serde(default)]
4935    pub entries: Vec<MemoryCitationEntry>,
4936    #[serde(rename = "threadIds", default)]
4937    pub thread_ids: Vec<String>,
4938}
4939
4940#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4941#[serde(rename_all = "camelCase")]
4942pub struct MemoryCitationEntry {
4943    #[serde(rename = "lineEnd", default)]
4944    pub line_end: i64,
4945    #[serde(rename = "lineStart", default)]
4946    pub line_start: i64,
4947    #[serde(default)]
4948    pub note: String,
4949    #[serde(default)]
4950    pub path: String,
4951}
4952
4953#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4954pub enum MergeStrategy {
4955    #[serde(rename = "replace")]
4956    Replace,
4957    #[serde(rename = "upsert")]
4958    Upsert,
4959}
4960
4961#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4962pub enum MessagePhase {
4963    #[serde(rename = "commentary")]
4964    Commentary,
4965    /// Stable answer text that may be followed by more assistant output or
4966    /// tools (openai/codex#51241).
4967    #[serde(rename = "partial_answer")]
4968    PartialAnswer,
4969    #[serde(rename = "final_answer")]
4970    FinalAnswer,
4971}
4972
4973#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4974#[serde(rename_all = "camelCase")]
4975pub struct MigrationDetails {
4976    #[serde(default, skip_serializing_if = "Option::is_none")]
4977    pub commands: Option<Vec<CommandMigration>>,
4978    #[serde(default, skip_serializing_if = "Option::is_none")]
4979    pub hooks: Option<Vec<HookMigration>>,
4980    #[serde(
4981        rename = "mcpServers",
4982        default,
4983        skip_serializing_if = "Option::is_none"
4984    )]
4985    pub mcp_servers: Option<Vec<McpServerMigration>>,
4986    #[serde(default, skip_serializing_if = "Option::is_none")]
4987    pub memory: Option<Vec<String>>,
4988    #[serde(default, skip_serializing_if = "Option::is_none")]
4989    pub plugins: Option<Vec<PluginsMigration>>,
4990    #[serde(default, skip_serializing_if = "Option::is_none")]
4991    pub sessions: Option<Vec<SessionMigration>>,
4992    #[serde(default, skip_serializing_if = "Option::is_none")]
4993    pub skills: Option<Vec<SkillMigration>>,
4994    #[serde(default, skip_serializing_if = "Option::is_none")]
4995    pub subagents: Option<Vec<SubagentMigration>>,
4996}
4997
4998/// Public explanation and continuation instruction attached to a
4999/// misalignment-blocked turn error (0.148 upstream).
5000#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5001#[serde(rename_all = "camelCase")]
5002pub struct MisalignmentErrorDetails {
5003    #[serde(
5004        rename = "detailedExplanation",
5005        default,
5006        skip_serializing_if = "Option::is_none"
5007    )]
5008    pub detailed_explanation: Option<String>,
5009    /// Open-ended classification; accept categories added upstream.
5010    #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
5011    pub error_type: Option<String>,
5012    /// Opaque server-issued block target. Presence alone does not enable
5013    /// target-based continuation (openai/codex#51217).
5014    #[serde(
5015        rename = "reviewTarget",
5016        default,
5017        skip_serializing_if = "Option::is_none"
5018    )]
5019    pub review_target: Option<String>,
5020    /// Instruction to submit as the next turn's user input if continuation
5021    /// is confirmed.
5022    #[serde(default, skip_serializing_if = "Option::is_none")]
5023    pub steer: Option<MisalignmentSteer>,
5024}
5025
5026/// The steering instruction inside [`MisalignmentErrorDetails`].
5027#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5028#[serde(rename_all = "camelCase")]
5029pub struct MisalignmentSteer {
5030    #[serde(default)]
5031    pub message: String,
5032}
5033
5034#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5035pub enum ModeKind {
5036    #[serde(rename = "plan")]
5037    Plan,
5038    #[serde(rename = "default")]
5039    Default,
5040}
5041
5042#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5043#[serde(rename_all = "camelCase")]
5044pub struct Model {
5045    #[serde(
5046        rename = "additionalSpeedTiers",
5047        default,
5048        skip_serializing_if = "Option::is_none"
5049    )]
5050    pub additional_speed_tiers: Option<Vec<String>>,
5051    #[serde(
5052        rename = "availabilityNux",
5053        default,
5054        skip_serializing_if = "Option::is_none"
5055    )]
5056    pub availability_nux: Option<ModelAvailabilityNux>,
5057    /// `None` when the catalog does not provide access-program metadata.
5058    #[serde(
5059        rename = "availableAccessPrograms",
5060        default,
5061        skip_serializing_if = "Option::is_none"
5062    )]
5063    pub available_access_programs: Option<ModelAccessPrograms>,
5064    #[serde(rename = "defaultReasoningEffort")]
5065    pub default_reasoning_effort: ReasoningEffort,
5066    #[serde(
5067        rename = "defaultServiceTier",
5068        default,
5069        skip_serializing_if = "Option::is_none"
5070    )]
5071    pub default_service_tier: Option<String>,
5072    #[serde(default)]
5073    pub description: String,
5074    #[serde(rename = "displayName", default)]
5075    pub display_name: String,
5076    #[serde(default)]
5077    pub hidden: bool,
5078    #[serde(default)]
5079    pub id: String,
5080    #[serde(
5081        rename = "inputModalities",
5082        default,
5083        skip_serializing_if = "Option::is_none"
5084    )]
5085    pub input_modalities: Option<Vec<InputModality>>,
5086    #[serde(rename = "isDefault", default)]
5087    pub is_default: bool,
5088    #[serde(default)]
5089    pub model: String,
5090    #[serde(
5091        rename = "modelSpecialty",
5092        default,
5093        skip_serializing_if = "Option::is_none"
5094    )]
5095    pub model_specialty: Option<String>,
5096    #[serde(
5097        rename = "multiAgentVersion",
5098        default,
5099        skip_serializing_if = "Option::is_none"
5100    )]
5101    pub multi_agent_version: Option<MultiAgentVersion>,
5102    #[serde(
5103        rename = "serviceTiers",
5104        default,
5105        skip_serializing_if = "Option::is_none"
5106    )]
5107    pub service_tiers: Option<Vec<ModelServiceTier>>,
5108    #[serde(rename = "supportedReasoningEfforts", default)]
5109    pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
5110    /// Deprecated upstream: always `false`; models no longer support
5111    /// personality selection.
5112    #[serde(
5113        rename = "supportsPersonality",
5114        default,
5115        skip_serializing_if = "Option::is_none"
5116    )]
5117    pub supports_personality: Option<bool>,
5118    #[serde(default, skip_serializing_if = "Option::is_none")]
5119    pub upgrade: Option<String>,
5120    #[serde(
5121        rename = "upgradeInfo",
5122        default,
5123        skip_serializing_if = "Option::is_none"
5124    )]
5125    pub upgrade_info: Option<ModelUpgradeInfo>,
5126}
5127
5128/// Caller-specific explicit access programs advertised by model discovery.
5129#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5130#[serde(rename_all = "camelCase")]
5131pub struct ModelAccessPrograms {
5132    /// Accepted explicit selections.
5133    #[serde(default)]
5134    pub cyber: Vec<CyberAccessProgram>,
5135}
5136
5137#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5138#[serde(rename_all = "camelCase")]
5139pub struct ModelAvailabilityNux {
5140    #[serde(default)]
5141    pub message: String,
5142}
5143
5144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5145#[serde(rename_all = "camelCase")]
5146pub struct ModelListParams {
5147    #[serde(default, skip_serializing_if = "Option::is_none")]
5148    pub cursor: Option<String>,
5149    #[serde(
5150        rename = "includeHidden",
5151        default,
5152        skip_serializing_if = "Option::is_none"
5153    )]
5154    pub include_hidden: Option<bool>,
5155    #[serde(default, skip_serializing_if = "Option::is_none")]
5156    pub limit: Option<i64>,
5157    /// List models for this configured provider instead of the app-server
5158    /// default.
5159    #[serde(
5160        rename = "modelProvider",
5161        default,
5162        skip_serializing_if = "Option::is_none"
5163    )]
5164    pub model_provider: Option<String>,
5165}
5166
5167#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5168#[serde(rename_all = "camelCase")]
5169pub struct ModelListResponse {
5170    #[serde(default)]
5171    pub data: Vec<Model>,
5172    #[serde(
5173        rename = "nextCursor",
5174        default,
5175        skip_serializing_if = "Option::is_none"
5176    )]
5177    pub next_cursor: Option<String>,
5178}
5179
5180#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5181#[serde(rename_all = "camelCase")]
5182pub struct ModelProviderCapabilitiesReadParams {
5183    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5184    pub extra: serde_json::Map<String, Value>,
5185}
5186
5187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5188#[serde(rename_all = "camelCase")]
5189pub struct ModelProviderCapabilitiesReadResponse {
5190    #[serde(rename = "imageGeneration", default)]
5191    pub image_generation: bool,
5192    #[serde(rename = "webSearch", default)]
5193    pub web_search: bool,
5194}
5195
5196/// Params for `modelProvider/list`. Takes no fields.
5197#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5198#[serde(rename_all = "camelCase")]
5199pub struct ModelProviderListParams {
5200    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5201    pub extra: serde_json::Map<String, Value>,
5202}
5203
5204/// Response to `modelProvider/list`: every configured model provider.
5205#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5206#[serde(rename_all = "camelCase")]
5207pub struct ModelProviderListResponse {
5208    pub data: Vec<ModelProviderSummary>,
5209    #[serde(rename = "defaultProviderId")]
5210    pub default_provider_id: String,
5211    #[serde(rename = "canChangeDefault")]
5212    pub can_change_default: bool,
5213}
5214
5215/// One entry in [`ModelProviderListResponse::data`].
5216#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5217#[serde(rename_all = "camelCase")]
5218pub struct ModelProviderSummary {
5219    pub id: String,
5220    pub name: String,
5221    /// Whether a supported configuration field can be edited in the active user layer.
5222    #[serde(rename = "canEdit")]
5223    pub can_edit: bool,
5224    /// Null when the endpoint is absent or cannot be safely displayed.
5225    #[serde(rename = "baseUrl", default)]
5226    pub base_url: Option<String>,
5227    pub settings: ProviderSettings,
5228}
5229
5230/// Provider-specific configuration fields visible to clients.
5231#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5232#[serde(tag = "type", rename_all = "camelCase")]
5233pub enum ProviderSettings {
5234    #[serde(rename = "openai")]
5235    OpenAi,
5236    #[serde(rename = "customGateway")]
5237    CustomGateway { auth: GatewayAuth },
5238    #[serde(rename = "bedrock")]
5239    Bedrock {
5240        #[serde(default)]
5241        profile: Option<String>,
5242        #[serde(default)]
5243        region: Option<String>,
5244    },
5245    #[serde(rename = "gcp")]
5246    Gcp {
5247        #[serde(rename = "projectId", default)]
5248        project_id: Option<String>,
5249        #[serde(default)]
5250        location: Option<String>,
5251        /// Path on the app-server host, without credential-file contents.
5252        #[serde(rename = "credentialFile", default)]
5253        credential_file: Option<String>,
5254    },
5255}
5256
5257/// How a custom gateway provider authenticates.
5258#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5259#[serde(tag = "mode", rename_all = "camelCase")]
5260pub enum GatewayAuth {
5261    #[serde(rename = "none")]
5262    None,
5263    #[serde(rename = "environmentVariable")]
5264    EnvironmentVariable {
5265        #[serde(rename = "envKey")]
5266        env_key: String,
5267    },
5268    /// Authentication is configured outside the gateway form. Preserve it on edits.
5269    #[serde(rename = "externallyConfigured")]
5270    ExternallyConfigured {
5271        #[serde(rename = "envKey", default)]
5272        env_key: Option<String>,
5273    },
5274}
5275
5276/// Params for `modelProvider/config/write`.
5277#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5278#[serde(rename_all = "camelCase")]
5279pub struct ModelProviderConfigWriteParams {
5280    pub settings: ProviderSettingsPatch,
5281}
5282
5283/// Params for `modelProvider/default/set`; the response is a
5284/// [`ConfigWriteResponse`].
5285#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5286#[serde(rename_all = "camelCase")]
5287pub struct ModelProviderDefaultSetParams {
5288    /// Configured provider to use by default for new threads and unscoped
5289    /// model lists.
5290    pub provider_id: String,
5291}
5292
5293/// Response to `modelProvider/config/write`: the provider as written.
5294#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5295#[serde(rename_all = "camelCase")]
5296pub struct ModelProviderConfigWriteResponse {
5297    pub provider: ModelProviderSummary,
5298}
5299
5300/// Omitted patch fields preserve their values. Explicit null clears a nullable field.
5301///
5302/// Nullable patch fields are `Option<Option<String>>`: `None` omits the field
5303/// (preserve), `Some(None)` sends `null` (clear), `Some(Some(v))` sets it.
5304#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5305#[serde(tag = "type", rename_all = "camelCase")]
5306pub enum ProviderSettingsPatch {
5307    #[serde(rename = "customGateway")]
5308    CustomGateway {
5309        /// Omit or pass null to allocate a new custom provider ID.
5310        #[serde(
5311            rename = "providerId",
5312            default,
5313            skip_serializing_if = "Option::is_none"
5314        )]
5315        provider_id: Option<String>,
5316        /// Omit to preserve the name. Unlike the other fields it cannot be cleared.
5317        #[serde(
5318            default,
5319            deserialize_with = "deserialize_patch_name",
5320            skip_serializing_if = "Option::is_none"
5321        )]
5322        name: Option<String>,
5323        #[serde(
5324            rename = "baseUrl",
5325            default,
5326            deserialize_with = "deserialize_patch_field",
5327            skip_serializing_if = "Option::is_none"
5328        )]
5329        base_url: Option<Option<String>>,
5330        #[serde(
5331            rename = "envKey",
5332            default,
5333            deserialize_with = "deserialize_patch_field",
5334            skip_serializing_if = "Option::is_none"
5335        )]
5336        env_key: Option<Option<String>>,
5337    },
5338    /// AWS configuration fields for built-in Bedrock providers.
5339    #[serde(rename = "bedrock")]
5340    Bedrock {
5341        #[serde(rename = "providerId")]
5342        provider_id: BedrockProviderId,
5343        #[serde(
5344            default,
5345            deserialize_with = "deserialize_patch_field",
5346            skip_serializing_if = "Option::is_none"
5347        )]
5348        profile: Option<Option<String>>,
5349        #[serde(
5350            default,
5351            deserialize_with = "deserialize_patch_field",
5352            skip_serializing_if = "Option::is_none"
5353        )]
5354        region: Option<Option<String>>,
5355    },
5356    /// GCP configuration fields. Credential-file paths refer to the app-server host.
5357    #[serde(rename = "gcp")]
5358    Gcp {
5359        #[serde(rename = "providerId")]
5360        provider_id: GcpProviderId,
5361        #[serde(
5362            rename = "projectId",
5363            default,
5364            deserialize_with = "deserialize_patch_field",
5365            skip_serializing_if = "Option::is_none"
5366        )]
5367        project_id: Option<Option<String>>,
5368        #[serde(
5369            default,
5370            deserialize_with = "deserialize_patch_field",
5371            skip_serializing_if = "Option::is_none"
5372        )]
5373        location: Option<Option<String>>,
5374        #[serde(
5375            rename = "credentialFile",
5376            default,
5377            deserialize_with = "deserialize_patch_field",
5378            skip_serializing_if = "Option::is_none"
5379        )]
5380        credential_file: Option<Option<String>>,
5381    },
5382}
5383
5384/// A present field (even `null`) becomes `Some`; a missing one falls back to `None` via `default`.
5385fn deserialize_patch_field<'de, D>(deserializer: D) -> Result<Option<Option<String>>, D::Error>
5386where
5387    D: serde::Deserializer<'de>,
5388{
5389    Option::<String>::deserialize(deserializer).map(Some)
5390}
5391
5392/// A missing name preserves it, but an explicitly supplied name must be a string.
5393fn deserialize_patch_name<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
5394where
5395    D: serde::Deserializer<'de>,
5396{
5397    String::deserialize(deserializer).map(Some)
5398}
5399
5400/// Built-in Bedrock provider IDs accepted by [`ProviderSettingsPatch::Bedrock`].
5401#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
5402pub enum BedrockProviderId {
5403    #[serde(rename = "amazon-bedrock")]
5404    AmazonBedrock,
5405    #[serde(rename = "amazon-bedrock-runtime")]
5406    AmazonBedrockRuntime,
5407}
5408
5409/// Built-in GCP provider IDs accepted by [`ProviderSettingsPatch::Gcp`].
5410#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
5411pub enum GcpProviderId {
5412    #[serde(rename = "gcp")]
5413    Gcp,
5414}
5415
5416/// Structured JSON-RPC error data. Unknown errors must retain the client's normal fallback.
5417///
5418/// Carried in [`crate::JsonRpcErrorData::data`] when a thread's stored model
5419/// provider can't be used for resume or new input.
5420#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5421#[serde(tag = "type", rename_all = "camelCase")]
5422pub enum ModelProviderError {
5423    #[serde(rename = "modelProviderMismatch")]
5424    ModelProviderMismatch {
5425        #[serde(rename = "modelProvider")]
5426        model_provider: String,
5427        #[serde(rename = "currentModelProvider")]
5428        current_model_provider: String,
5429    },
5430    #[serde(rename = "modelProviderNotConfigured")]
5431    ModelProviderNotConfigured {
5432        #[serde(rename = "modelProvider")]
5433        model_provider: String,
5434    },
5435    #[serde(rename = "modelProviderPolicyConflict")]
5436    ModelProviderPolicyConflict {
5437        #[serde(rename = "modelProvider")]
5438        model_provider: String,
5439        #[serde(rename = "requiredModelProvider")]
5440        required_model_provider: String,
5441    },
5442}
5443
5444#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5445pub enum ModelRerouteReason {
5446    #[serde(rename = "highRiskCyberActivity")]
5447    HighRiskCyberActivity,
5448}
5449
5450#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5451#[serde(rename_all = "camelCase")]
5452pub struct ModelReroutedNotification {
5453    #[serde(rename = "fromModel", default)]
5454    pub from_model: String,
5455    #[serde()]
5456    pub reason: ModelRerouteReason,
5457    #[serde(rename = "threadId", default)]
5458    pub thread_id: String,
5459    #[serde(rename = "toModel", default)]
5460    pub to_model: String,
5461    #[serde(rename = "turnId", default)]
5462    pub turn_id: String,
5463}
5464
5465#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5466#[serde(rename_all = "camelCase")]
5467pub struct ModelSafetyBufferingUpdatedNotification {
5468    #[serde(
5469        rename = "fasterModel",
5470        default,
5471        skip_serializing_if = "Option::is_none"
5472    )]
5473    pub faster_model: Option<String>,
5474    #[serde(default)]
5475    pub model: String,
5476    #[serde(default)]
5477    pub reasons: Vec<String>,
5478    #[serde(rename = "showBufferingUi", default)]
5479    pub show_buffering_ui: bool,
5480    #[serde(rename = "threadId", default)]
5481    pub thread_id: String,
5482    #[serde(rename = "turnId", default)]
5483    pub turn_id: String,
5484    #[serde(rename = "useCases", default)]
5485    pub use_cases: Vec<String>,
5486}
5487
5488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5489#[serde(rename_all = "camelCase")]
5490pub struct ModelServiceTier {
5491    #[serde(default)]
5492    pub description: String,
5493    #[serde(default)]
5494    pub id: String,
5495    #[serde(default)]
5496    pub name: String,
5497}
5498
5499#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5500#[serde(rename_all = "camelCase")]
5501pub struct ModelUpgradeInfo {
5502    #[serde(
5503        rename = "migrationMarkdown",
5504        default,
5505        skip_serializing_if = "Option::is_none"
5506    )]
5507    pub migration_markdown: Option<String>,
5508    #[serde(default)]
5509    pub model: String,
5510    /// Informational Unix timestamp for this upgrade's scheduled
5511    /// retirement, if known.
5512    #[serde(
5513        rename = "retirementAt",
5514        default,
5515        skip_serializing_if = "Option::is_none"
5516    )]
5517    pub retirement_at: Option<i64>,
5518    #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
5519    pub model_link: Option<String>,
5520    #[serde(
5521        rename = "upgradeCopy",
5522        default,
5523        skip_serializing_if = "Option::is_none"
5524    )]
5525    pub upgrade_copy: Option<String>,
5526}
5527
5528#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5529pub enum ModelVerification {
5530    #[serde(rename = "trustedAccessForCyber")]
5531    TrustedAccessForCyber,
5532}
5533
5534#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5535#[serde(rename_all = "camelCase")]
5536pub struct ModelVerificationNotification {
5537    #[serde(rename = "threadId", default)]
5538    pub thread_id: String,
5539    #[serde(rename = "turnId", default)]
5540    pub turn_id: String,
5541    #[serde(default)]
5542    pub verifications: Vec<ModelVerification>,
5543}
5544
5545#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5546#[serde(rename_all = "camelCase")]
5547pub struct ModelsRequirements {
5548    #[serde(rename = "newThread", default, skip_serializing_if = "Option::is_none")]
5549    pub new_thread: Option<NewThreadModelDefaults>,
5550}
5551
5552#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5553pub enum MultiAgentVersion {
5554    #[serde(rename = "disabled")]
5555    Disabled,
5556    #[serde(rename = "v1")]
5557    V1,
5558    #[serde(rename = "v2")]
5559    V2,
5560}
5561
5562#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5563pub enum NetworkAccess {
5564    #[serde(rename = "restricted")]
5565    Restricted,
5566    #[serde(rename = "enabled")]
5567    Enabled,
5568}
5569
5570#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5571#[serde(rename_all = "camelCase")]
5572pub struct NetworkApprovalContext {
5573    #[serde(default)]
5574    pub host: String,
5575    #[serde()]
5576    pub protocol: NetworkApprovalProtocol,
5577}
5578
5579#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5580pub enum NetworkApprovalProtocol {
5581    #[serde(rename = "http")]
5582    Http,
5583    #[serde(rename = "https")]
5584    Https,
5585    #[serde(rename = "socks5Tcp")]
5586    Socks5Tcp,
5587    #[serde(rename = "socks5Udp")]
5588    Socks5Udp,
5589}
5590
5591#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5592#[serde(rename_all = "camelCase")]
5593pub struct NetworkPolicyAmendment {
5594    #[serde()]
5595    pub action: NetworkPolicyRuleAction,
5596    #[serde(default)]
5597    pub host: String,
5598}
5599
5600#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5601pub enum NetworkPolicyRuleAction {
5602    #[serde(rename = "allow")]
5603    Allow,
5604    #[serde(rename = "deny")]
5605    Deny,
5606}
5607
5608#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5609#[serde(rename_all = "camelCase")]
5610pub struct NewThreadModelDefaults {
5611    #[serde(default, skip_serializing_if = "Option::is_none")]
5612    pub model: Option<String>,
5613    #[serde(
5614        rename = "modelReasoningEffort",
5615        default,
5616        skip_serializing_if = "Option::is_none"
5617    )]
5618    pub model_reasoning_effort: Option<ReasoningEffort>,
5619    #[serde(
5620        rename = "serviceTier",
5621        default,
5622        skip_serializing_if = "Option::is_none"
5623    )]
5624    pub service_tier: Option<String>,
5625}
5626
5627#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5628pub enum NonSteerableTurnKind {
5629    #[serde(rename = "review")]
5630    Review,
5631    #[serde(rename = "compact")]
5632    Compact,
5633}
5634
5635/// An OpenTelemetry exporter pinned by managed requirements.
5636#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5637#[serde(rename_all = "kebab-case")]
5638pub enum OtelExporter {
5639    None,
5640    Statsig,
5641    OtlpHttp {
5642        endpoint: String,
5643        /// Header names are retained; values are redacted by the server.
5644        headers: std::collections::BTreeMap<String, String>,
5645        protocol: OtelHttpProtocol,
5646        #[serde(default, skip_serializing_if = "Option::is_none")]
5647        tls: Option<OtelTlsConfig>,
5648    },
5649    OtlpGrpc {
5650        endpoint: String,
5651        /// Header names are retained; values are redacted by the server.
5652        headers: std::collections::BTreeMap<String, String>,
5653        #[serde(default, skip_serializing_if = "Option::is_none")]
5654        tls: Option<OtelTlsConfig>,
5655    },
5656}
5657
5658#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5659#[serde(rename_all = "kebab-case")]
5660pub enum OtelHttpProtocol {
5661    Binary,
5662    Json,
5663}
5664
5665/// OpenTelemetry settings enforced by managed requirements
5666/// (`ConfigRequirements::otel`). Keys are snake_case on the wire.
5667#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5668#[serde(rename_all = "snake_case")]
5669pub struct OtelRequirements {
5670    /// Absolute path of a managed executable whose output supplies OTLP HTTP
5671    /// export headers. Only honored from local system/MDM requirements, never
5672    /// from cloud requirements.
5673    #[serde(default, skip_serializing_if = "Option::is_none")]
5674    pub headers_helper: Option<String>,
5675    /// How often, in milliseconds, `headers_helper` is re-run to refresh the
5676    /// export headers.
5677    #[serde(default, skip_serializing_if = "Option::is_none")]
5678    pub headers_helper_refresh_interval_ms: Option<std::num::NonZeroU64>,
5679    #[serde(default, skip_serializing_if = "Option::is_none")]
5680    pub tool_result: Option<OtelToolResultLogConfig>,
5681    #[serde(default, skip_serializing_if = "Option::is_none")]
5682    pub log_sse_deltas: Option<bool>,
5683    #[serde(default, skip_serializing_if = "Option::is_none")]
5684    pub log_user_prompt: Option<bool>,
5685    #[serde(default, skip_serializing_if = "Option::is_none")]
5686    pub log_agent_responses: Option<bool>,
5687    #[serde(default, skip_serializing_if = "Option::is_none")]
5688    pub log_guardian_assessments: Option<bool>,
5689    #[serde(default, skip_serializing_if = "Option::is_none")]
5690    pub environment: Option<String>,
5691    #[serde(default, skip_serializing_if = "Option::is_none")]
5692    pub exporter: Option<OtelExporter>,
5693    #[serde(default, skip_serializing_if = "Option::is_none")]
5694    pub trace_exporter: Option<OtelExporter>,
5695    #[serde(default, skip_serializing_if = "Option::is_none")]
5696    pub metrics_exporter: Option<OtelExporter>,
5697    #[serde(default, skip_serializing_if = "Option::is_none")]
5698    pub span_attributes: Option<std::collections::BTreeMap<String, String>>,
5699    #[serde(default, skip_serializing_if = "Option::is_none")]
5700    pub tracestate:
5701        Option<std::collections::BTreeMap<String, std::collections::BTreeMap<String, String>>>,
5702}
5703
5704#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
5705#[serde(rename_all = "kebab-case")]
5706pub struct OtelTlsConfig {
5707    #[serde(default, skip_serializing_if = "Option::is_none")]
5708    pub ca_certificate: Option<String>,
5709    #[serde(default, skip_serializing_if = "Option::is_none")]
5710    pub client_certificate: Option<String>,
5711    #[serde(default, skip_serializing_if = "Option::is_none")]
5712    pub client_private_key: Option<String>,
5713}
5714
5715#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
5716#[serde(rename_all = "snake_case")]
5717pub struct OtelToolResultLogConfig {
5718    pub max_bytes: u64,
5719}
5720
5721#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5722#[serde(rename_all = "camelCase")]
5723pub struct OverriddenMetadata {
5724    #[serde(rename = "effectiveValue", default)]
5725    pub effective_value: Value,
5726    #[serde(default)]
5727    pub message: String,
5728    #[serde(rename = "overridingLayer")]
5729    pub overriding_layer: ConfigLayerMetadata,
5730}
5731
5732#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5733#[serde(tag = "type", rename_all = "camelCase")]
5734pub enum ParsedCommand {
5735    Read {
5736        cmd: String,
5737        name: String,
5738        path: String,
5739    },
5740    List_files {
5741        cmd: String,
5742        #[serde(default, skip_serializing_if = "Option::is_none")]
5743        path: Option<String>,
5744    },
5745    Search {
5746        cmd: String,
5747        #[serde(default, skip_serializing_if = "Option::is_none")]
5748        path: Option<String>,
5749        #[serde(default, skip_serializing_if = "Option::is_none")]
5750        query: Option<String>,
5751    },
5752    Unknown {
5753        cmd: String,
5754    },
5755}
5756
5757#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5758pub enum PatchApplyStatus {
5759    #[serde(rename = "inProgress")]
5760    InProgress,
5761    #[serde(rename = "completed")]
5762    Completed,
5763    #[serde(rename = "failed")]
5764    Failed,
5765    #[serde(rename = "declined")]
5766    Declined,
5767}
5768
5769#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5770#[serde(tag = "type", rename_all = "camelCase")]
5771pub enum PatchChangeKind {
5772    Add,
5773    Delete,
5774    Update {
5775        #[serde(default, skip_serializing_if = "Option::is_none")]
5776        move_path: Option<String>,
5777    },
5778}
5779
5780#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5781pub enum PermissionGrantScope {
5782    #[serde(rename = "turn")]
5783    Turn,
5784    #[serde(rename = "session")]
5785    Session,
5786}
5787
5788#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5789#[serde(rename_all = "camelCase")]
5790pub struct PermissionProfileListParams {
5791    #[serde(default, skip_serializing_if = "Option::is_none")]
5792    pub cursor: Option<String>,
5793    #[serde(default, skip_serializing_if = "Option::is_none")]
5794    pub cwd: Option<String>,
5795    #[serde(default, skip_serializing_if = "Option::is_none")]
5796    pub limit: Option<i64>,
5797}
5798
5799#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5800#[serde(rename_all = "camelCase")]
5801pub struct PermissionProfileListResponse {
5802    #[serde(default)]
5803    pub data: Vec<PermissionProfileSummary>,
5804    #[serde(
5805        rename = "nextCursor",
5806        default,
5807        skip_serializing_if = "Option::is_none"
5808    )]
5809    pub next_cursor: Option<String>,
5810}
5811
5812#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5813#[serde(rename_all = "camelCase")]
5814pub struct PermissionProfileSummary {
5815    #[serde(default)]
5816    pub allowed: bool,
5817    #[serde(default, skip_serializing_if = "Option::is_none")]
5818    pub description: Option<String>,
5819    #[serde(default)]
5820    pub id: String,
5821}
5822
5823#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5824#[serde(rename_all = "camelCase")]
5825pub struct PermissionsRequestApprovalParams {
5826    #[serde()]
5827    pub cwd: LegacyAppPathString,
5828    #[serde(
5829        rename = "environmentId",
5830        default,
5831        skip_serializing_if = "Option::is_none"
5832    )]
5833    pub environment_id: Option<String>,
5834    #[serde(rename = "itemId", default)]
5835    pub item_id: String,
5836    #[serde()]
5837    pub permissions: RequestPermissionProfile,
5838    #[serde(default, skip_serializing_if = "Option::is_none")]
5839    pub reason: Option<String>,
5840    #[serde(rename = "startedAtMs", default)]
5841    pub started_at_ms: i64,
5842    #[serde(rename = "threadId", default)]
5843    pub thread_id: String,
5844    #[serde(rename = "turnId", default)]
5845    pub turn_id: String,
5846}
5847
5848#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5849#[serde(rename_all = "camelCase")]
5850pub struct PermissionsRequestApprovalResponse {
5851    #[serde()]
5852    pub permissions: GrantedPermissionProfile,
5853    #[serde(default, skip_serializing_if = "Option::is_none")]
5854    pub scope: Option<Value>,
5855    #[serde(
5856        rename = "strictAutoReview",
5857        default,
5858        skip_serializing_if = "Option::is_none"
5859    )]
5860    pub strict_auto_review: Option<bool>,
5861}
5862
5863/// Deprecated upstream: `friendly` and `pragmatic` no longer select a style,
5864/// and `Model::supports_personality` is now always `false`. The setting is
5865/// still reported and accepted on the wire; changing it on a turn does not
5866/// rewrite the thread's existing instructions.
5867#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5868pub enum Personality {
5869    #[serde(rename = "none")]
5870    None,
5871    #[serde(rename = "friendly")]
5872    Friendly,
5873    #[serde(rename = "pragmatic")]
5874    Pragmatic,
5875}
5876
5877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5878#[serde(rename_all = "camelCase")]
5879pub struct PlanDeltaNotification {
5880    #[serde(default)]
5881    pub delta: String,
5882    #[serde(rename = "itemId", default)]
5883    pub item_id: String,
5884    #[serde(rename = "threadId", default)]
5885    pub thread_id: String,
5886    #[serde(rename = "turnId", default)]
5887    pub turn_id: String,
5888}
5889
5890#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5891pub enum PlanType {
5892    #[serde(rename = "free")]
5893    Free,
5894    #[serde(rename = "go")]
5895    Go,
5896    #[serde(rename = "plus")]
5897    Plus,
5898    #[serde(rename = "pro")]
5899    Pro,
5900    #[serde(rename = "prolite")]
5901    Prolite,
5902    #[serde(rename = "promax")]
5903    Promax,
5904    #[serde(rename = "edu_plus")]
5905    Edu_plus,
5906    #[serde(rename = "edu_pro")]
5907    Edu_pro,
5908    #[serde(rename = "team")]
5909    Team,
5910    #[serde(rename = "self_serve_business_prolite")]
5911    Self_serve_business_prolite,
5912    #[serde(rename = "self_serve_business_usage_based")]
5913    Self_serve_business_usage_based,
5914    #[serde(rename = "business")]
5915    Business,
5916    #[serde(rename = "ent26")]
5917    Ent26,
5918    #[serde(rename = "enterprise_cbp_automation")]
5919    Enterprise_cbp_automation,
5920    #[serde(rename = "enterprise_cbp_usage_based")]
5921    Enterprise_cbp_usage_based,
5922    #[serde(rename = "enterprise")]
5923    Enterprise,
5924    #[serde(rename = "edu")]
5925    Edu,
5926    #[serde(rename = "sci")]
5927    Sci,
5928    #[serde(rename = "sci_plus")]
5929    Sci_plus,
5930    #[serde(rename = "unknown")]
5931    Unknown,
5932}
5933
5934#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5935pub enum PluginAuthPolicy {
5936    #[serde(rename = "ON_INSTALL")]
5937    ON_INSTALL,
5938    #[serde(rename = "ON_USE")]
5939    ON_USE,
5940}
5941
5942#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5943pub enum PluginAvailability {
5944    #[serde(rename = "DISABLED_BY_ADMIN")]
5945    DISABLEDBYADMIN,
5946    AVAILABLE,
5947}
5948
5949#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5950#[serde(rename_all = "camelCase")]
5951pub struct PluginDetail {
5952    #[serde(rename = "appTemplates", default)]
5953    pub app_templates: Vec<AppTemplateSummary>,
5954    #[serde(default)]
5955    pub apps: Vec<AppSummary>,
5956    #[serde(default, skip_serializing_if = "Option::is_none")]
5957    pub description: Option<String>,
5958    #[serde(default)]
5959    pub hooks: Vec<PluginHookSummary>,
5960    #[serde(rename = "marketplaceName", default)]
5961    pub marketplace_name: String,
5962    #[serde(
5963        rename = "marketplacePath",
5964        default,
5965        skip_serializing_if = "Option::is_none"
5966    )]
5967    pub marketplace_path: Option<AbsolutePathBuf>,
5968    #[serde(rename = "mcpServers", default)]
5969    pub mcp_servers: Vec<String>,
5970    /// The declared onboarding skill, when the plugin and visible skill are enabled.
5971    #[serde(
5972        rename = "onboardingSkill",
5973        default,
5974        skip_serializing_if = "Option::is_none"
5975    )]
5976    pub onboarding_skill: Option<SkillSummary>,
5977    #[serde(
5978        rename = "scheduledTasks",
5979        default,
5980        skip_serializing_if = "Option::is_none"
5981    )]
5982    pub scheduled_tasks: Option<Vec<ScheduledTaskSummary>>,
5983    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5984    pub share_url: Option<String>,
5985    #[serde(default)]
5986    pub skills: Vec<SkillSummary>,
5987    #[serde()]
5988    pub summary: PluginSummary,
5989}
5990
5991#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5992pub enum PluginDisabledReason {
5993    #[serde(rename = "disabled_by_admin")]
5994    Disabled_by_admin,
5995    #[serde(rename = "plan_not_eligible")]
5996    Plan_not_eligible,
5997    #[serde(rename = "required_app_unavailable")]
5998    Required_app_unavailable,
5999    #[serde(rename = "unknown")]
6000    Unknown,
6001}
6002
6003#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6004#[serde(rename_all = "camelCase")]
6005pub struct PluginHookSummary {
6006    #[serde(rename = "eventName")]
6007    pub event_name: HookEventName,
6008    #[serde(default)]
6009    pub key: String,
6010}
6011
6012#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6013#[serde(rename_all = "camelCase")]
6014pub struct PluginInstallParams {
6015    #[serde(
6016        rename = "installAttemptId",
6017        default,
6018        skip_serializing_if = "Option::is_none"
6019    )]
6020    pub install_attempt_id: Option<String>,
6021    #[serde(
6022        rename = "marketplacePath",
6023        default,
6024        skip_serializing_if = "Option::is_none"
6025    )]
6026    pub marketplace_path: Option<AbsolutePathBuf>,
6027    #[serde(rename = "pluginName", default)]
6028    pub plugin_name: String,
6029    #[serde(
6030        rename = "remoteMarketplaceName",
6031        default,
6032        skip_serializing_if = "Option::is_none"
6033    )]
6034    pub remote_marketplace_name: Option<String>,
6035}
6036
6037#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6038pub enum PluginInstallPolicy {
6039    #[serde(rename = "NOT_AVAILABLE")]
6040    NOT_AVAILABLE,
6041    #[serde(rename = "AVAILABLE")]
6042    AVAILABLE,
6043    #[serde(rename = "INSTALLED_BY_DEFAULT")]
6044    INSTALLED_BY_DEFAULT,
6045}
6046
6047#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6048pub enum PluginInstallPolicySource {
6049    #[serde(rename = "WORKSPACE_SETTING")]
6050    WORKSPACE_SETTING,
6051    #[serde(rename = "IMPLICIT_CANONICAL_APP")]
6052    IMPLICIT_CANONICAL_APP,
6053}
6054
6055#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6056#[serde(rename_all = "camelCase")]
6057pub struct PluginInstallResponse {
6058    #[serde(rename = "appsNeedingAuth", default)]
6059    pub apps_needing_auth: Vec<AppSummary>,
6060    #[serde(rename = "authPolicy")]
6061    pub auth_policy: PluginAuthPolicy,
6062}
6063
6064#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6065#[serde(rename_all = "camelCase")]
6066pub struct PluginInstalledParams {
6067    #[serde(default, skip_serializing_if = "Option::is_none")]
6068    pub cwds: Option<Vec<AbsolutePathBuf>>,
6069    #[serde(
6070        rename = "installSuggestionPluginNames",
6071        default,
6072        skip_serializing_if = "Option::is_none"
6073    )]
6074    pub install_suggestion_plugin_names: Option<Vec<String>>,
6075}
6076
6077#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6078#[serde(rename_all = "camelCase")]
6079pub struct PluginInstalledResponse {
6080    #[serde(
6081        rename = "marketplaceLoadErrors",
6082        default,
6083        skip_serializing_if = "Option::is_none"
6084    )]
6085    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
6086    #[serde(default)]
6087    pub marketplaces: Vec<PluginMarketplaceEntry>,
6088}
6089
6090#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6091#[serde(rename_all = "camelCase")]
6092pub struct PluginInterface {
6093    #[serde(
6094        rename = "brandColor",
6095        default,
6096        skip_serializing_if = "Option::is_none"
6097    )]
6098    pub brand_color: Option<String>,
6099    #[serde(default)]
6100    pub capabilities: Vec<String>,
6101    #[serde(default, skip_serializing_if = "Option::is_none")]
6102    pub category: Option<String>,
6103    #[serde(
6104        rename = "composerIcon",
6105        default,
6106        skip_serializing_if = "Option::is_none"
6107    )]
6108    pub composer_icon: Option<AbsolutePathBuf>,
6109    #[serde(
6110        rename = "composerIconUrl",
6111        default,
6112        skip_serializing_if = "Option::is_none"
6113    )]
6114    pub composer_icon_url: Option<String>,
6115    #[serde(
6116        rename = "defaultPrompt",
6117        default,
6118        skip_serializing_if = "Option::is_none"
6119    )]
6120    pub default_prompt: Option<Vec<String>>,
6121    #[serde(
6122        rename = "developerName",
6123        default,
6124        skip_serializing_if = "Option::is_none"
6125    )]
6126    pub developer_name: Option<String>,
6127    #[serde(
6128        rename = "displayName",
6129        default,
6130        skip_serializing_if = "Option::is_none"
6131    )]
6132    pub display_name: Option<String>,
6133    #[serde(default, skip_serializing_if = "Option::is_none")]
6134    pub logo: Option<AbsolutePathBuf>,
6135    #[serde(rename = "logoDark", default, skip_serializing_if = "Option::is_none")]
6136    pub logo_dark: Option<AbsolutePathBuf>,
6137    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
6138    pub logo_url: Option<String>,
6139    #[serde(
6140        rename = "logoUrlDark",
6141        default,
6142        skip_serializing_if = "Option::is_none"
6143    )]
6144    pub logo_url_dark: Option<String>,
6145    #[serde(
6146        rename = "longDescription",
6147        default,
6148        skip_serializing_if = "Option::is_none"
6149    )]
6150    pub long_description: Option<String>,
6151    #[serde(
6152        rename = "privacyPolicyUrl",
6153        default,
6154        skip_serializing_if = "Option::is_none"
6155    )]
6156    pub privacy_policy_url: Option<String>,
6157    #[serde(rename = "screenshotUrls", default)]
6158    pub screenshot_urls: Vec<String>,
6159    #[serde(default)]
6160    pub screenshots: Vec<AbsolutePathBuf>,
6161    #[serde(
6162        rename = "shortDescription",
6163        default,
6164        skip_serializing_if = "Option::is_none"
6165    )]
6166    pub short_description: Option<String>,
6167    #[serde(
6168        rename = "termsOfServiceUrl",
6169        default,
6170        skip_serializing_if = "Option::is_none"
6171    )]
6172    pub terms_of_service_url: Option<String>,
6173    #[serde(
6174        rename = "websiteUrl",
6175        default,
6176        skip_serializing_if = "Option::is_none"
6177    )]
6178    pub website_url: Option<String>,
6179}
6180
6181#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6182pub enum PluginListMarketplaceKind {
6183    #[serde(rename = "local")]
6184    Local,
6185    #[serde(rename = "vertical")]
6186    Vertical,
6187    #[serde(rename = "workspace-directory")]
6188    Workspace_directory,
6189    #[serde(rename = "shared-with-me")]
6190    Shared_with_me,
6191    #[serde(rename = "created-by-me-remote")]
6192    Created_by_me_remote,
6193}
6194
6195#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6196#[serde(rename_all = "camelCase")]
6197pub struct PluginListParams {
6198    #[serde(default, skip_serializing_if = "Option::is_none")]
6199    pub cwds: Option<Vec<AbsolutePathBuf>>,
6200    #[serde(
6201        rename = "forceRefetch",
6202        default,
6203        skip_serializing_if = "Option::is_none"
6204    )]
6205    pub force_refetch: Option<bool>,
6206    #[serde(
6207        rename = "marketplaceKinds",
6208        default,
6209        skip_serializing_if = "Option::is_none"
6210    )]
6211    pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
6212}
6213
6214#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6215#[serde(rename_all = "camelCase")]
6216pub struct PluginListResponse {
6217    #[serde(
6218        rename = "featuredPluginIds",
6219        default,
6220        skip_serializing_if = "Option::is_none"
6221    )]
6222    pub featured_plugin_ids: Option<Vec<String>>,
6223    #[serde(
6224        rename = "marketplaceLoadErrors",
6225        default,
6226        skip_serializing_if = "Option::is_none"
6227    )]
6228    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
6229    #[serde(default)]
6230    pub marketplaces: Vec<PluginMarketplaceEntry>,
6231}
6232
6233#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6234#[serde(rename_all = "camelCase")]
6235pub struct PluginMarketplaceEntry {
6236    #[serde(default, skip_serializing_if = "Option::is_none")]
6237    pub interface: Option<MarketplaceInterface>,
6238    #[serde(default)]
6239    pub name: String,
6240    #[serde(default, skip_serializing_if = "Option::is_none")]
6241    pub path: Option<AbsolutePathBuf>,
6242    #[serde(default)]
6243    pub plugins: Vec<PluginSummary>,
6244}
6245
6246#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6247#[serde(rename_all = "camelCase")]
6248pub struct PluginReadParams {
6249    #[serde(
6250        rename = "marketplacePath",
6251        default,
6252        skip_serializing_if = "Option::is_none"
6253    )]
6254    pub marketplace_path: Option<AbsolutePathBuf>,
6255    #[serde(rename = "pluginName", default)]
6256    pub plugin_name: String,
6257    #[serde(
6258        rename = "remoteMarketplaceName",
6259        default,
6260        skip_serializing_if = "Option::is_none"
6261    )]
6262    pub remote_marketplace_name: Option<String>,
6263}
6264
6265#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6266#[serde(rename_all = "camelCase")]
6267pub struct PluginReadResponse {
6268    #[serde()]
6269    pub plugin: PluginDetail,
6270}
6271
6272/// Runtime categories affected by this change, not just capabilities
6273/// currently present. Flags describe declarations before runtime policy
6274/// filtering. Updates OR the old and new bundle flags; enablement changes and
6275/// cached reinstalls use the cached bundle; removals retain the old bundle's
6276/// flags.
6277#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6278#[serde(rename_all = "camelCase")]
6279pub struct PluginReconcileChangedPlugin {
6280    #[serde(rename = "hasApps", default)]
6281    pub has_apps: bool,
6282    #[serde(rename = "hasHooks", default)]
6283    pub has_hooks: bool,
6284    #[serde(rename = "hasMcps", default)]
6285    pub has_mcps: bool,
6286    /// Whether either bundle declares skill roots; not a validated inventory
6287    /// of enabled skills.
6288    #[serde(rename = "hasSkills", default)]
6289    pub has_skills: bool,
6290    /// Local plugin ID (`name@marketplace`), matching `PluginSummary.id`.
6291    #[serde(default)]
6292    pub id: String,
6293}
6294
6295#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6296#[serde(rename_all = "camelCase")]
6297pub struct PluginReconcileParams {
6298    /// Optional client-provided reason recorded with the reconciliation
6299    /// attempt.
6300    #[serde(default, skip_serializing_if = "Option::is_none")]
6301    pub reason: Option<String>,
6302}
6303
6304/// Bundle and installed-state changes observed by this pass, not a
6305/// runtime-readiness acknowledgement or a cumulative diff since the client's
6306/// last request. Other metadata-only changes are not listed.
6307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6308#[serde(rename_all = "camelCase")]
6309pub struct PluginReconcileResponse {
6310    /// Plugins affected by bundle changes, enablement changes, or removals.
6311    /// Installed-state changes compare against the previous cached snapshot,
6312    /// including cached reinstalls. Removal hints survive cache cleanup
6313    /// failures; unchanged plugins are omitted.
6314    #[serde(rename = "changedPlugins", default)]
6315    pub changed_plugins: Vec<PluginReconcileChangedPlugin>,
6316    /// Subset of failures for which the requested bundle could not be
6317    /// materialized. A previously cached version may still be available.
6318    #[serde(rename = "failedMaterializationRemotePluginIds", default)]
6319    pub failed_materialization_remote_plugin_ids: Vec<String>,
6320    /// Backend remote plugin IDs whose bundle or identity update failed.
6321    #[serde(rename = "failedRemotePluginIds", default)]
6322    pub failed_remote_plugin_ids: Vec<String>,
6323}
6324
6325#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6326#[serde(rename_all = "camelCase")]
6327pub struct PluginShareCheckoutParams {
6328    #[serde(rename = "remotePluginId", default)]
6329    pub remote_plugin_id: String,
6330}
6331
6332#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6333#[serde(rename_all = "camelCase")]
6334pub struct PluginShareCheckoutResponse {
6335    #[serde(rename = "marketplaceName", default)]
6336    pub marketplace_name: String,
6337    #[serde(rename = "marketplacePath")]
6338    pub marketplace_path: AbsolutePathBuf,
6339    #[serde(rename = "pluginId", default)]
6340    pub plugin_id: String,
6341    #[serde(rename = "pluginName", default)]
6342    pub plugin_name: String,
6343    #[serde(rename = "pluginPath")]
6344    pub plugin_path: AbsolutePathBuf,
6345    #[serde(rename = "remotePluginId", default)]
6346    pub remote_plugin_id: String,
6347    #[serde(
6348        rename = "remoteVersion",
6349        default,
6350        skip_serializing_if = "Option::is_none"
6351    )]
6352    pub remote_version: Option<String>,
6353}
6354
6355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6356#[serde(rename_all = "camelCase")]
6357pub struct PluginShareContext {
6358    #[serde(
6359        rename = "canPublishToWorkspace",
6360        default,
6361        skip_serializing_if = "Option::is_none"
6362    )]
6363    pub can_publish_to_workspace: Option<bool>,
6364    #[serde(
6365        rename = "creatorAccountUserId",
6366        default,
6367        skip_serializing_if = "Option::is_none"
6368    )]
6369    pub creator_account_user_id: Option<String>,
6370    #[serde(
6371        rename = "creatorName",
6372        default,
6373        skip_serializing_if = "Option::is_none"
6374    )]
6375    pub creator_name: Option<String>,
6376    #[serde(default, skip_serializing_if = "Option::is_none")]
6377    pub discoverability: Option<PluginShareDiscoverability>,
6378    #[serde(rename = "remotePluginId", default)]
6379    pub remote_plugin_id: String,
6380    #[serde(
6381        rename = "remoteVersion",
6382        default,
6383        skip_serializing_if = "Option::is_none"
6384    )]
6385    pub remote_version: Option<String>,
6386    #[serde(
6387        rename = "sharePrincipals",
6388        default,
6389        skip_serializing_if = "Option::is_none"
6390    )]
6391    pub share_principals: Option<Vec<PluginSharePrincipal>>,
6392    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
6393    pub share_url: Option<String>,
6394}
6395
6396#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6397#[serde(rename_all = "camelCase")]
6398pub struct PluginShareDeleteParams {
6399    #[serde(rename = "remotePluginId", default)]
6400    pub remote_plugin_id: String,
6401}
6402
6403#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6404#[serde(rename_all = "camelCase")]
6405pub struct PluginShareDeleteResponse {
6406    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6407    pub extra: serde_json::Map<String, Value>,
6408}
6409
6410#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6411pub enum PluginShareDiscoverability {
6412    #[serde(rename = "LISTED")]
6413    LISTED,
6414    #[serde(rename = "UNLISTED")]
6415    UNLISTED,
6416    #[serde(rename = "PRIVATE")]
6417    PRIVATE,
6418}
6419
6420#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6421#[serde(rename_all = "camelCase")]
6422pub struct PluginShareListItem {
6423    #[serde(
6424        rename = "localPluginPath",
6425        default,
6426        skip_serializing_if = "Option::is_none"
6427    )]
6428    pub local_plugin_path: Option<AbsolutePathBuf>,
6429    #[serde()]
6430    pub plugin: PluginSummary,
6431}
6432
6433#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6434#[serde(rename_all = "camelCase")]
6435pub struct PluginShareListParams {
6436    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6437    pub extra: serde_json::Map<String, Value>,
6438}
6439
6440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6441#[serde(rename_all = "camelCase")]
6442pub struct PluginShareListResponse {
6443    #[serde(default)]
6444    pub data: Vec<PluginShareListItem>,
6445}
6446
6447#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6448#[serde(rename_all = "camelCase")]
6449pub struct PluginSharePrincipal {
6450    #[serde(default)]
6451    pub name: String,
6452    #[serde(rename = "principalId", default)]
6453    pub principal_id: String,
6454    #[serde(rename = "principalType")]
6455    pub principal_type: PluginSharePrincipalType,
6456    #[serde()]
6457    pub role: PluginSharePrincipalRole,
6458}
6459
6460#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6461pub enum PluginSharePrincipalRole {
6462    #[serde(rename = "reader")]
6463    Reader,
6464    #[serde(rename = "editor")]
6465    Editor,
6466    #[serde(rename = "owner")]
6467    Owner,
6468}
6469
6470#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6471pub enum PluginSharePrincipalType {
6472    #[serde(rename = "user")]
6473    User,
6474    #[serde(rename = "group")]
6475    Group,
6476    #[serde(rename = "workspace")]
6477    Workspace,
6478}
6479
6480#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6481#[serde(rename_all = "camelCase")]
6482pub struct PluginShareSaveParams {
6483    #[serde(default, skip_serializing_if = "Option::is_none")]
6484    pub discoverability: Option<PluginShareDiscoverability>,
6485    #[serde(rename = "pluginPath")]
6486    pub plugin_path: AbsolutePathBuf,
6487    #[serde(
6488        rename = "remotePluginId",
6489        default,
6490        skip_serializing_if = "Option::is_none"
6491    )]
6492    pub remote_plugin_id: Option<String>,
6493    #[serde(
6494        rename = "shareTargets",
6495        default,
6496        skip_serializing_if = "Option::is_none"
6497    )]
6498    pub share_targets: Option<Vec<PluginShareTarget>>,
6499}
6500
6501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6502#[serde(rename_all = "camelCase")]
6503pub struct PluginShareSaveResponse {
6504    #[serde(
6505        rename = "canPublishToWorkspace",
6506        default,
6507        skip_serializing_if = "Option::is_none"
6508    )]
6509    pub can_publish_to_workspace: Option<bool>,
6510    #[serde(rename = "remotePluginId", default)]
6511    pub remote_plugin_id: String,
6512    #[serde(rename = "shareUrl", default)]
6513    pub share_url: String,
6514}
6515
6516#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6517#[serde(rename_all = "camelCase")]
6518pub struct PluginShareTarget {
6519    #[serde(rename = "principalId", default)]
6520    pub principal_id: String,
6521    #[serde(rename = "principalType")]
6522    pub principal_type: PluginSharePrincipalType,
6523    #[serde()]
6524    pub role: PluginShareTargetRole,
6525}
6526
6527#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6528pub enum PluginShareTargetRole {
6529    #[serde(rename = "reader")]
6530    Reader,
6531    #[serde(rename = "editor")]
6532    Editor,
6533}
6534
6535#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6536pub enum PluginShareUpdateDiscoverability {
6537    #[serde(rename = "UNLISTED")]
6538    UNLISTED,
6539    #[serde(rename = "PRIVATE")]
6540    PRIVATE,
6541    #[serde(rename = "LISTED")]
6542    LISTED,
6543}
6544
6545#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6546#[serde(rename_all = "camelCase")]
6547pub struct PluginShareUpdateTargetsParams {
6548    #[serde()]
6549    pub discoverability: PluginShareUpdateDiscoverability,
6550    #[serde(rename = "remotePluginId", default)]
6551    pub remote_plugin_id: String,
6552    #[serde(rename = "shareTargets", default)]
6553    pub share_targets: Vec<PluginShareTarget>,
6554}
6555
6556#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6557#[serde(rename_all = "camelCase")]
6558pub struct PluginShareUpdateTargetsResponse {
6559    #[serde()]
6560    pub discoverability: PluginShareDiscoverability,
6561    #[serde(default)]
6562    pub principals: Vec<PluginSharePrincipal>,
6563}
6564
6565#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6566#[serde(rename_all = "camelCase")]
6567pub struct PluginSkillReadParams {
6568    #[serde(rename = "remoteMarketplaceName", default)]
6569    pub remote_marketplace_name: String,
6570    #[serde(rename = "remotePluginId", default)]
6571    pub remote_plugin_id: String,
6572    #[serde(rename = "skillName", default)]
6573    pub skill_name: String,
6574}
6575
6576#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6577#[serde(rename_all = "camelCase")]
6578pub struct PluginSkillReadResponse {
6579    #[serde(default, skip_serializing_if = "Option::is_none")]
6580    pub contents: Option<String>,
6581}
6582
6583#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6584#[serde(tag = "type", rename_all = "camelCase")]
6585pub enum PluginSource {
6586    Local {
6587        path: AbsolutePathBuf,
6588    },
6589    Git {
6590        #[serde(default, skip_serializing_if = "Option::is_none")]
6591        path: Option<String>,
6592        #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
6593        ref_name: Option<String>,
6594        #[serde(default, skip_serializing_if = "Option::is_none")]
6595        sha: Option<String>,
6596        url: String,
6597    },
6598    Npm {
6599        package: String,
6600        #[serde(default, skip_serializing_if = "Option::is_none")]
6601        registry: Option<String>,
6602        #[serde(default, skip_serializing_if = "Option::is_none")]
6603        version: Option<String>,
6604    },
6605    Remote,
6606}
6607
6608#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6609#[serde(rename_all = "camelCase")]
6610pub struct PluginSummary {
6611    #[serde(rename = "authPolicy")]
6612    pub auth_policy: PluginAuthPolicy,
6613    #[serde(default, skip_serializing_if = "Option::is_none")]
6614    pub availability: Option<Value>,
6615    #[serde(
6616        rename = "disabledReason",
6617        default,
6618        skip_serializing_if = "Option::is_none"
6619    )]
6620    pub disabled_reason: Option<PluginDisabledReason>,
6621    #[serde(
6622        rename = "eligiblePlanTypes",
6623        default,
6624        skip_serializing_if = "Option::is_none"
6625    )]
6626    pub eligible_plan_types: Option<Vec<String>>,
6627    #[serde(default)]
6628    pub enabled: bool,
6629    #[serde(default)]
6630    pub id: String,
6631    #[serde(rename = "installPolicy")]
6632    pub install_policy: PluginInstallPolicy,
6633    #[serde(
6634        rename = "installPolicySource",
6635        default,
6636        skip_serializing_if = "Option::is_none"
6637    )]
6638    pub install_policy_source: Option<PluginInstallPolicySource>,
6639    #[serde(default)]
6640    pub installed: bool,
6641    #[serde(
6642        rename = "installedAt",
6643        default,
6644        skip_serializing_if = "Option::is_none"
6645    )]
6646    pub installed_at: Option<i64>,
6647    #[serde(default, skip_serializing_if = "Option::is_none")]
6648    pub interface: Option<PluginInterface>,
6649    #[serde(default, skip_serializing_if = "Option::is_none")]
6650    pub keywords: Option<Vec<String>>,
6651    #[serde(
6652        rename = "localVersion",
6653        default,
6654        skip_serializing_if = "Option::is_none"
6655    )]
6656    pub local_version: Option<String>,
6657    #[serde(
6658        rename = "mustShowInstallationInterstitial",
6659        default,
6660        skip_serializing_if = "Option::is_none"
6661    )]
6662    pub must_show_installation_interstitial: Option<bool>,
6663    #[serde(default)]
6664    pub name: String,
6665    #[serde(
6666        rename = "remotePluginId",
6667        default,
6668        skip_serializing_if = "Option::is_none"
6669    )]
6670    pub remote_plugin_id: Option<String>,
6671    #[serde(
6672        rename = "shareContext",
6673        default,
6674        skip_serializing_if = "Option::is_none"
6675    )]
6676    pub share_context: Option<PluginShareContext>,
6677    #[serde()]
6678    pub source: PluginSource,
6679    #[serde(default, skip_serializing_if = "Option::is_none")]
6680    pub version: Option<String>,
6681}
6682
6683#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6684#[serde(rename_all = "camelCase")]
6685pub struct PluginUninstallParams {
6686    #[serde(rename = "pluginId", default)]
6687    pub plugin_id: String,
6688}
6689
6690#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6691#[serde(rename_all = "camelCase")]
6692pub struct PluginUninstallResponse {
6693    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6694    pub extra: serde_json::Map<String, Value>,
6695}
6696
6697#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6698#[serde(rename_all = "camelCase")]
6699pub struct PluginsMigration {
6700    #[serde(rename = "marketplaceName", default)]
6701    pub marketplace_name: String,
6702    #[serde(rename = "pluginNames", default)]
6703    pub plugin_names: Vec<String>,
6704}
6705
6706#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6707#[serde(rename_all = "camelCase")]
6708pub struct ProcessExitedNotification {
6709    #[serde(rename = "exitCode", default)]
6710    pub exit_code: i64,
6711    /// Whether output collection hit its post-exit deadline before seeing EOF
6712    /// or reaching the requested byte cap on either stream. Older servers omit
6713    /// this field.
6714    #[serde(
6715        rename = "outputDrainTimedOut",
6716        default,
6717        skip_serializing_if = "Option::is_none"
6718    )]
6719    pub output_drain_timed_out: Option<bool>,
6720    #[serde(rename = "processHandle", default)]
6721    pub process_handle: String,
6722    #[serde(default)]
6723    pub stderr: String,
6724    #[serde(rename = "stderrCapReached", default)]
6725    pub stderr_cap_reached: bool,
6726    #[serde(default)]
6727    pub stdout: String,
6728    #[serde(rename = "stdoutCapReached", default)]
6729    pub stdout_cap_reached: bool,
6730}
6731
6732#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6733#[serde(rename_all = "camelCase")]
6734pub struct ProcessOutputDeltaNotification {
6735    #[serde(rename = "capReached", default)]
6736    pub cap_reached: bool,
6737    #[serde(rename = "deltaBase64", default)]
6738    pub delta_base64: String,
6739    #[serde(rename = "processHandle", default)]
6740    pub process_handle: String,
6741    #[serde(default)]
6742    pub stream: Value,
6743}
6744
6745#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6746pub enum ProcessOutputStream {
6747    #[serde(rename = "stdout")]
6748    Stdout,
6749    #[serde(rename = "stderr")]
6750    Stderr,
6751}
6752
6753#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6754pub enum RateLimitReachedType {
6755    #[serde(rename = "rate_limit_reached")]
6756    Rate_limit_reached,
6757    #[serde(rename = "workspace_owner_credits_depleted")]
6758    Workspace_owner_credits_depleted,
6759    #[serde(rename = "workspace_member_credits_depleted")]
6760    Workspace_member_credits_depleted,
6761    #[serde(rename = "workspace_owner_usage_limit_reached")]
6762    Workspace_owner_usage_limit_reached,
6763    #[serde(rename = "workspace_member_usage_limit_reached")]
6764    Workspace_member_usage_limit_reached,
6765}
6766
6767#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6768#[serde(rename_all = "camelCase")]
6769pub struct RateLimitResetCredit {
6770    #[serde(default, skip_serializing_if = "Option::is_none")]
6771    pub description: Option<String>,
6772    #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
6773    pub expires_at: Option<i64>,
6774    #[serde(rename = "grantedAt", default)]
6775    pub granted_at: i64,
6776    #[serde(default)]
6777    pub id: String,
6778    #[serde(rename = "resetType")]
6779    pub reset_type: RateLimitResetType,
6780    #[serde()]
6781    pub status: RateLimitResetCreditStatus,
6782    #[serde(default, skip_serializing_if = "Option::is_none")]
6783    pub title: Option<String>,
6784}
6785
6786#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6787pub enum RateLimitResetCreditStatus {
6788    #[serde(rename = "available")]
6789    Available,
6790    #[serde(rename = "redeeming")]
6791    Redeeming,
6792    #[serde(rename = "redeemed")]
6793    Redeemed,
6794    #[serde(rename = "unknown")]
6795    Unknown,
6796}
6797
6798#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6799#[serde(rename_all = "camelCase")]
6800pub struct RateLimitResetCreditsSummary {
6801    #[serde(rename = "availableCount", default)]
6802    pub available_count: i64,
6803    #[serde(default, skip_serializing_if = "Option::is_none")]
6804    pub credits: Option<Vec<RateLimitResetCredit>>,
6805}
6806
6807#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6808pub enum RateLimitResetType {
6809    #[serde(rename = "codexRateLimits")]
6810    CodexRateLimits,
6811    #[serde(rename = "unknown")]
6812    Unknown,
6813}
6814
6815#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6816#[serde(rename_all = "camelCase")]
6817pub struct RateLimitSnapshot {
6818    #[serde(default, skip_serializing_if = "Option::is_none")]
6819    pub credits: Option<CreditsSnapshot>,
6820    #[serde(
6821        rename = "individualLimit",
6822        default,
6823        skip_serializing_if = "Option::is_none"
6824    )]
6825    pub individual_limit: Option<SpendControlLimitSnapshot>,
6826    #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
6827    pub limit_id: Option<String>,
6828    #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
6829    pub limit_name: Option<String>,
6830    /// Normal model whose display name and reasoning options describe this
6831    /// quota alias.
6832    #[serde(
6833        rename = "normalModelSlug",
6834        default,
6835        skip_serializing_if = "Option::is_none"
6836    )]
6837    pub normal_model_slug: Option<String>,
6838    #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
6839    pub plan_type: Option<PlanType>,
6840    #[serde(default, skip_serializing_if = "Option::is_none")]
6841    pub primary: Option<RateLimitWindow>,
6842    #[serde(
6843        rename = "rateLimitReachedType",
6844        default,
6845        skip_serializing_if = "Option::is_none"
6846    )]
6847    pub rate_limit_reached_type: Option<RateLimitReachedType>,
6848    #[serde(default, skip_serializing_if = "Option::is_none")]
6849    pub secondary: Option<RateLimitWindow>,
6850    #[serde(
6851        rename = "spendControlReached",
6852        default,
6853        skip_serializing_if = "Option::is_none"
6854    )]
6855    pub spend_control_reached: Option<bool>,
6856}
6857
6858#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6859#[serde(rename_all = "camelCase")]
6860pub struct RateLimitWindow {
6861    #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
6862    pub resets_at: Option<i64>,
6863    #[serde(rename = "usedPercent", default)]
6864    pub used_percent: i64,
6865    #[serde(
6866        rename = "windowDurationMins",
6867        default,
6868        skip_serializing_if = "Option::is_none"
6869    )]
6870    pub window_duration_mins: Option<i64>,
6871}
6872
6873#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6874pub enum RealtimeConversationVersion {
6875    #[serde(rename = "v1")]
6876    V1,
6877    #[serde(rename = "v2")]
6878    V2,
6879    #[serde(rename = "v3")]
6880    V3,
6881}
6882
6883/// A non-empty reasoning effort value advertised by the model.
6884#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
6885#[serde(transparent)]
6886pub struct ReasoningEffort(pub String);
6887
6888#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6889#[serde(rename_all = "camelCase")]
6890pub struct ReasoningEffortOption {
6891    #[serde(default)]
6892    pub description: String,
6893    #[serde(rename = "reasoningEffort")]
6894    pub reasoning_effort: ReasoningEffort,
6895}
6896
6897#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6898pub enum ReasoningSummary {
6899    #[serde(rename = "auto")]
6900    Auto,
6901    #[serde(rename = "concise")]
6902    Concise,
6903    #[serde(rename = "detailed")]
6904    Detailed,
6905    #[serde(rename = "none")]
6906    None,
6907}
6908
6909#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6910#[serde(rename_all = "camelCase")]
6911pub struct ReasoningSummaryPartAddedNotification {
6912    #[serde(rename = "itemId", default)]
6913    pub item_id: String,
6914    #[serde(rename = "summaryIndex", default)]
6915    pub summary_index: i64,
6916    #[serde(rename = "threadId", default)]
6917    pub thread_id: String,
6918    #[serde(rename = "turnId", default)]
6919    pub turn_id: String,
6920}
6921
6922#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6923#[serde(rename_all = "camelCase")]
6924pub struct ReasoningSummaryTextDeltaNotification {
6925    #[serde(default)]
6926    pub delta: String,
6927    #[serde(rename = "itemId", default)]
6928    pub item_id: String,
6929    #[serde(rename = "summaryIndex", default)]
6930    pub summary_index: i64,
6931    #[serde(rename = "threadId", default)]
6932    pub thread_id: String,
6933    #[serde(rename = "turnId", default)]
6934    pub turn_id: String,
6935}
6936
6937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6938#[serde(rename_all = "camelCase")]
6939pub struct ReasoningTextDeltaNotification {
6940    #[serde(rename = "contentIndex", default)]
6941    pub content_index: i64,
6942    #[serde(default)]
6943    pub delta: String,
6944    #[serde(rename = "itemId", default)]
6945    pub item_id: String,
6946    #[serde(rename = "threadId", default)]
6947    pub thread_id: String,
6948    #[serde(rename = "turnId", default)]
6949    pub turn_id: String,
6950}
6951
6952#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6953pub enum RemoteControlConnectionStatus {
6954    #[serde(rename = "disabled")]
6955    Disabled,
6956    #[serde(rename = "connecting")]
6957    Connecting,
6958    #[serde(rename = "connected")]
6959    Connected,
6960    #[serde(rename = "errored")]
6961    Errored,
6962}
6963
6964#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6965#[serde(rename_all = "camelCase")]
6966pub struct RemoteControlStatusChangedNotification {
6967    #[serde(
6968        rename = "environmentId",
6969        default,
6970        skip_serializing_if = "Option::is_none"
6971    )]
6972    pub environment_id: Option<String>,
6973    #[serde(rename = "installationId", default)]
6974    pub installation_id: String,
6975    #[serde(rename = "serverName", default)]
6976    pub server_name: String,
6977    #[serde()]
6978    pub status: RemoteControlConnectionStatus,
6979}
6980
6981#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6982#[serde(untagged)]
6983pub enum RequestId {
6984    Variant0(String),
6985    Variant1(i64),
6986}
6987
6988#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6989#[serde(rename_all = "camelCase")]
6990pub struct RequestPermissionProfile {
6991    #[serde(
6992        rename = "fileSystem",
6993        default,
6994        skip_serializing_if = "Option::is_none"
6995    )]
6996    pub file_system: Option<AdditionalFileSystemPermissions>,
6997    #[serde(default, skip_serializing_if = "Option::is_none")]
6998    pub network: Option<AdditionalNetworkPermissions>,
6999}
7000
7001#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7002pub enum ResidencyRequirement {
7003    #[serde(rename = "us")]
7004    Us,
7005}
7006
7007#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7008#[serde(rename_all = "camelCase")]
7009pub struct Resource {
7010    #[serde(default, skip_serializing_if = "Option::is_none")]
7011    pub _meta: Option<Value>,
7012    #[serde(default, skip_serializing_if = "Option::is_none")]
7013    pub annotations: Option<Value>,
7014    #[serde(default, skip_serializing_if = "Option::is_none")]
7015    pub description: Option<String>,
7016    #[serde(default, skip_serializing_if = "Option::is_none")]
7017    pub icons: Option<Vec<Value>>,
7018    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
7019    pub mime_type: Option<String>,
7020    #[serde(default)]
7021    pub name: String,
7022    #[serde(default, skip_serializing_if = "Option::is_none")]
7023    pub size: Option<i64>,
7024    #[serde(default, skip_serializing_if = "Option::is_none")]
7025    pub title: Option<String>,
7026    #[serde(default)]
7027    pub uri: String,
7028}
7029
7030#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7031#[serde(untagged)]
7032pub enum ResourceContent {
7033    Variant0(Value),
7034    Variant1(Value),
7035}
7036
7037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7038#[serde(rename_all = "camelCase")]
7039pub struct ResourceTemplate {
7040    #[serde(default, skip_serializing_if = "Option::is_none")]
7041    pub annotations: Option<Value>,
7042    #[serde(default, skip_serializing_if = "Option::is_none")]
7043    pub description: Option<String>,
7044    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
7045    pub mime_type: Option<String>,
7046    #[serde(default)]
7047    pub name: String,
7048    #[serde(default, skip_serializing_if = "Option::is_none")]
7049    pub title: Option<String>,
7050    #[serde(rename = "uriTemplate", default)]
7051    pub uri_template: String,
7052}
7053
7054/// Usage metadata reported for one upstream response (0.148 upstream).
7055#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7056#[serde(rename_all = "camelCase")]
7057pub struct ResponseUsageMetadata {
7058    #[serde(default, skip_serializing_if = "Option::is_none")]
7059    pub amount: Option<String>,
7060    #[serde(default, skip_serializing_if = "Option::is_none")]
7061    pub metadata: Option<Value>,
7062}
7063
7064#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7065pub enum ReviewDecision {
7066    #[serde(rename = "approved")]
7067    Approved,
7068    #[serde(rename = "approved_execpolicy_amendment")]
7069    ApprovedExecpolicyAmendment {
7070        proposed_execpolicy_amendment: Vec<String>,
7071    },
7072    #[serde(rename = "approved_for_session")]
7073    ApprovedForSession,
7074    #[serde(rename = "approved_mcp_policy_amendment")]
7075    ApprovedMcpPolicyAmendment,
7076    #[serde(rename = "network_policy_amendment")]
7077    NetworkPolicyAmendment {
7078        network_policy_amendment: NetworkPolicyAmendment,
7079    },
7080    #[serde(rename = "denied")]
7081    Denied { rejection: String },
7082    #[serde(rename = "timed_out")]
7083    TimedOut,
7084    #[serde(rename = "abort")]
7085    Abort,
7086}
7087
7088#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7089pub enum ReviewDelivery {
7090    #[serde(rename = "inline")]
7091    Inline,
7092}
7093
7094#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7095#[serde(rename_all = "camelCase")]
7096pub struct ReviewStartParams {
7097    /// Reviews run inline on the supplied thread. Omit this field or pass
7098    /// `inline`. To review on a separate thread, start a thread first and use
7099    /// its id.
7100    #[serde(default, skip_serializing_if = "Option::is_none")]
7101    pub delivery: Option<ReviewDelivery>,
7102    #[serde()]
7103    pub target: ReviewTarget,
7104    #[serde(rename = "threadId", default)]
7105    pub thread_id: String,
7106}
7107
7108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7109#[serde(rename_all = "camelCase")]
7110pub struct ReviewStartResponse {
7111    /// The thread id supplied to `review/start`.
7112    #[serde(rename = "reviewThreadId", default)]
7113    pub review_thread_id: String,
7114    #[serde()]
7115    pub turn: Turn,
7116}
7117
7118#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7119#[serde(tag = "type", rename_all = "camelCase")]
7120pub enum ReviewTarget {
7121    #[serde(rename = "uncommittedChanges")]
7122    UncommittedChanges,
7123    #[serde(rename = "baseBranch")]
7124    BaseBranch {
7125        branch: String,
7126    },
7127    Commit {
7128        sha: String,
7129        #[serde(default, skip_serializing_if = "Option::is_none")]
7130        title: Option<String>,
7131    },
7132    Custom {
7133        instructions: String,
7134    },
7135}
7136
7137/// Delivery mode for an agent message item (0.147: currently only `async`).
7138#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7139pub enum AgentMessageDelivery {
7140    #[serde(rename = "async")]
7141    Async,
7142}
7143
7144/// Moderation state attached to an agent message item.
7145#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7146pub struct AgentMessageModeration {
7147    pub moderated: bool,
7148    #[serde(default, skip_serializing_if = "Option::is_none")]
7149    pub display: Option<AgentMessageDisplay>,
7150}
7151
7152/// The only supported version of the answer display contract (wire value `1`).
7153#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
7154#[serde(try_from = "u8", into = "u8")]
7155pub struct AgentMessageDisplayVersion;
7156
7157impl TryFrom<u8> for AgentMessageDisplayVersion {
7158    type Error = &'static str;
7159
7160    fn try_from(version: u8) -> Result<Self, Self::Error> {
7161        match version {
7162            1 => Ok(Self),
7163            _ => Err("unsupported answer display version"),
7164        }
7165    }
7166}
7167
7168impl From<AgentMessageDisplayVersion> for u8 {
7169    fn from(_: AgentMessageDisplayVersion) -> Self {
7170        1
7171    }
7172}
7173
7174/// How Chat should present a recovered answer.
7175#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7176#[serde(tag = "mode", rename_all = "camelCase")]
7177pub enum AgentMessageDisplay {
7178    Show {
7179        version: AgentMessageDisplayVersion,
7180        #[serde(default, skip_serializing_if = "Option::is_none")]
7181        annotation: Option<AnswerAnnotation>,
7182        #[serde(rename = "trustedContacts")]
7183        trusted_contacts: TrustedContacts,
7184    },
7185    Hide {
7186        version: AgentMessageDisplayVersion,
7187        replacement: AnswerReplacement,
7188    },
7189    Block {
7190        version: AgentMessageDisplayVersion,
7191        reason: BlockReason,
7192    },
7193}
7194
7195/// An annotation Chat shows alongside a displayed answer.
7196#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7197#[serde(tag = "kind", rename_all = "camelCase")]
7198pub enum AnswerAnnotation {
7199    WellbeingHelpline { subject: HelplineSubject },
7200}
7201
7202/// Whether a wellbeing helpline annotation refers to the answer or the prompt.
7203#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7204#[serde(rename_all = "camelCase")]
7205pub enum HelplineSubject {
7206    Answer,
7207    Prompt,
7208}
7209
7210/// Whether Chat should check the user's trusted contacts before showing an answer.
7211#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7212#[serde(rename_all = "camelCase")]
7213pub enum TrustedContacts {
7214    Check,
7215    Skip,
7216}
7217
7218/// What Chat shows in place of a hidden answer.
7219#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7220#[serde(tag = "kind", rename_all = "camelCase")]
7221pub enum AnswerReplacement {
7222    WellbeingPromptHelpline {},
7223}
7224
7225/// Why an answer is blocked.
7226#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7227#[serde(tag = "kind", rename_all = "camelCase")]
7228pub enum BlockReason {
7229    Protection {
7230        /// Identifies the same moderation row that Chat writes on the live path.
7231        #[serde(rename = "protectionType")]
7232        protection_type: String,
7233    },
7234    Cyber {
7235        #[serde(
7236            default,
7237            rename = "trustedAccess",
7238            skip_serializing_if = "Option::is_none"
7239        )]
7240        trusted_access: Option<bool>,
7241    },
7242}
7243
7244/// Where the CLI stores auth credentials.
7245#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7246pub enum CliAuthCredentialsStoreMode {
7247    #[serde(rename = "file")]
7248    File,
7249    #[serde(rename = "keyring")]
7250    Keyring,
7251    #[serde(rename = "auto")]
7252    Auto,
7253    #[serde(rename = "ephemeral")]
7254    Ephemeral,
7255}
7256
7257/// A project grouping threads, owned by app-server.
7258#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7259pub struct Project {
7260    #[serde(rename = "createdAt", default)]
7261    pub created_at: i64,
7262    #[serde(default)]
7263    pub id: String,
7264    #[serde(default)]
7265    pub metadata: std::collections::HashMap<String, String>,
7266    #[serde(default)]
7267    pub name: String,
7268    /// Newest non-archived member thread's recency, in Unix seconds;
7269    /// absent/null when none exist (0.148 upstream).
7270    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7271    pub recency_at: Option<i64>,
7272    #[serde(default)]
7273    pub roots: Vec<ProjectRoot>,
7274    #[serde(rename = "updatedAt", default)]
7275    pub updated_at: i64,
7276}
7277
7278/// Sort order for project listings (0.148 upstream).
7279#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7280pub enum ProjectSortKey {
7281    #[serde(rename = "position")]
7282    Position,
7283    #[serde(rename = "recencyAt")]
7284    RecencyAt,
7285}
7286
7287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7288pub enum ProjectChangeType {
7289    #[serde(rename = "created")]
7290    Created,
7291    #[serde(rename = "updated")]
7292    Updated,
7293    #[serde(rename = "deleted")]
7294    Deleted,
7295}
7296
7297/// `project/changed` — a project was created, updated, or deleted.
7298#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7299pub struct ProjectChangedNotification {
7300    #[serde(rename = "changeType")]
7301    pub change_type: ProjectChangeType,
7302    #[serde(rename = "projectId", default)]
7303    pub project_id: String,
7304}
7305
7306#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7307pub struct ProjectRoot {
7308    pub path: AbsolutePathBuf,
7309}
7310
7311/// A user submission waiting in a thread's queue.
7312#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7313pub struct QueuedSubmission {
7314    #[serde(rename = "clientUserMessageId", default)]
7315    pub client_user_message_id: String,
7316    #[serde(default)]
7317    pub id: String,
7318    #[serde(default)]
7319    pub input: Vec<UserInput>,
7320    /// Metadata retained with this input, including across reconnect and restoration.
7321    #[serde(
7322        rename = "responsesapiClientMetadata",
7323        default,
7324        skip_serializing_if = "Option::is_none"
7325    )]
7326    pub responsesapi_client_metadata: Option<std::collections::HashMap<String, String>>,
7327}
7328
7329/// `autoApprovalReview/strictReviewRequired` — a strict review gate opened.
7330#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7331pub struct StrictReviewRequiredNotification {
7332    /// Unix timestamp (ms) when this review started.
7333    #[serde(rename = "startedAtMs", default)]
7334    pub started_at_ms: i64,
7335    #[serde(rename = "threadId", default)]
7336    pub thread_id: String,
7337    #[serde(rename = "turnId", default)]
7338    pub turn_id: String,
7339}
7340
7341/// `thread/project/updated` — a thread's project assignment changed.
7342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7343pub struct ThreadProjectUpdatedNotification {
7344    #[serde(rename = "projectId", default)]
7345    pub project_id: Option<String>,
7346    #[serde(rename = "threadId", default)]
7347    pub thread_id: String,
7348}
7349
7350/// `thread/queue/changed` — the thread's queued submissions changed.
7351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7352pub struct ThreadQueueChangedNotification {
7353    #[serde(rename = "threadId", default)]
7354    pub thread_id: String,
7355}
7356
7357/// `thread/reverted` — the thread was rolled back.
7358#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7359pub struct ThreadRevertedNotification {
7360    #[serde(rename = "threadId", default)]
7361    pub thread_id: String,
7362}
7363
7364/// `thread/prediction/updated` — a prediction requested for a turn finished
7365/// (`openai/codex@main` 90abcfac, experimental).
7366#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7367#[serde(rename_all = "camelCase")]
7368pub struct ThreadPredictionUpdatedNotification {
7369    pub result: ThreadPredictionResult,
7370    #[serde(rename = "sourceTurnId", default)]
7371    pub source_turn_id: String,
7372    #[serde(rename = "threadId", default)]
7373    pub thread_id: String,
7374}
7375
7376/// Outcome of a thread prediction (`openai/codex@main` 90abcfac).
7377#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7378#[serde(tag = "type", rename_all = "camelCase")]
7379pub enum ThreadPredictionResult {
7380    Completed {
7381        #[serde(default, skip_serializing_if = "Option::is_none")]
7382        text: Option<String>,
7383    },
7384    Failed,
7385}
7386
7387/// In-app browser requirements (0.148 upstream).
7388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7389#[serde(rename_all = "camelCase")]
7390pub struct InAppBrowserRequirements {
7391    #[serde(
7392        rename = "allowExternalBrowserSettingsImport",
7393        default,
7394        skip_serializing_if = "Option::is_none"
7395    )]
7396    pub allow_external_browser_settings_import: Option<bool>,
7397}
7398
7399/// One MCP-server-originated notification, relayed verbatim.
7400#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7401pub struct McpServerEventNotification {
7402    #[serde(default)]
7403    pub method: String,
7404    #[serde(default)]
7405    pub params: Value,
7406}
7407
7408/// `mcpServer/event/stream/notification` — an MCP server's own
7409/// notification stream, forwarded to subscribers.
7410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7411pub struct McpServerEventStreamNotification {
7412    pub notification: McpServerEventNotification,
7413    #[serde(rename = "subscriptionId", default)]
7414    pub subscription_id: String,
7415}
7416
7417/// Allow/deny switch used across the browser-use / computer-use policy
7418/// surface (0.148 upstream).
7419#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7420pub enum AllowDenyRequirement {
7421    #[serde(rename = "allow")]
7422    Allow,
7423    #[serde(rename = "deny")]
7424    Deny,
7425}
7426
7427/// How long a granted browser-use access approval lasts.
7428#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7429pub enum BrowserUseAccessApprovalLifetime {
7430    #[serde(rename = "turn")]
7431    Turn,
7432    #[serde(rename = "thread")]
7433    Thread,
7434}
7435
7436/// Current thread-runtime MCP server connection state.
7437#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7438pub enum McpServerConnectionStatus {
7439    #[serde(rename = "notStarted")]
7440    NotStarted,
7441    #[serde(rename = "starting")]
7442    Starting,
7443    #[serde(rename = "connected")]
7444    Connected,
7445    #[serde(rename = "authenticationRequired")]
7446    AuthenticationRequired,
7447    #[serde(rename = "failed")]
7448    Failed,
7449    #[serde(rename = "cancelled")]
7450    Cancelled,
7451    #[serde(rename = "disabled")]
7452    Disabled,
7453}
7454
7455/// Per-origin browser-use policy (requirements side, camelCase wire).
7456#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7457#[serde(rename_all = "camelCase")]
7458pub struct BrowserUseOriginPolicy {
7459    #[serde(default, skip_serializing_if = "Option::is_none")]
7460    pub access: Option<AllowDenyRequirement>,
7461    #[serde(
7462        rename = "accessApprovalLifetime",
7463        default,
7464        skip_serializing_if = "Option::is_none"
7465    )]
7466    pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
7467    #[serde(
7468        rename = "autoReview",
7469        default,
7470        skip_serializing_if = "Option::is_none"
7471    )]
7472    pub auto_review: Option<AllowDenyRequirement>,
7473    #[serde(default, skip_serializing_if = "Option::is_none")]
7474    pub downloads: Option<AllowDenyRequirement>,
7475    #[serde(
7476        rename = "fullCdpAccess",
7477        default,
7478        skip_serializing_if = "Option::is_none"
7479    )]
7480    pub full_cdp_access: Option<AllowDenyRequirement>,
7481    #[serde(
7482        rename = "persistentApproval",
7483        default,
7484        skip_serializing_if = "Option::is_none"
7485    )]
7486    pub persistent_approval: Option<bool>,
7487    #[serde(default, skip_serializing_if = "Option::is_none")]
7488    pub uploads: Option<AllowDenyRequirement>,
7489}
7490
7491/// Per-origin browser-use policy (config side, snake_case wire).
7492#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7493pub struct BrowserUseOriginPolicyConfig {
7494    #[serde(default, skip_serializing_if = "Option::is_none")]
7495    pub access: Option<AllowDenyRequirement>,
7496    #[serde(default, skip_serializing_if = "Option::is_none")]
7497    pub downloads: Option<AllowDenyRequirement>,
7498    #[serde(default, skip_serializing_if = "Option::is_none")]
7499    pub full_cdp_access: Option<AllowDenyRequirement>,
7500    #[serde(default, skip_serializing_if = "Option::is_none")]
7501    pub uploads: Option<AllowDenyRequirement>,
7502}
7503
7504/// Browser-use configuration (config side, snake_case wire).
7505#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7506pub struct BrowserUseConfig {
7507    #[serde(default, skip_serializing_if = "Option::is_none")]
7508    pub allow_history_access: Option<bool>,
7509    #[serde(default, skip_serializing_if = "Option::is_none")]
7510    pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
7511    #[serde(default, skip_serializing_if = "Option::is_none")]
7512    pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
7513}
7514
7515/// Computer-use configuration (config side, snake_case wire).
7516#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7517pub struct ComputerUseConfig {
7518    #[serde(default, skip_serializing_if = "Option::is_none")]
7519    pub default_app_access: Option<AllowDenyRequirement>,
7520    #[serde(default, skip_serializing_if = "Option::is_none")]
7521    pub macos: Option<ComputerUseMacosConfig>,
7522    #[serde(default, skip_serializing_if = "Option::is_none")]
7523    pub windows: Option<ComputerUseWindowsConfig>,
7524}
7525
7526#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7527pub struct ComputerUseMacosConfig {
7528    #[serde(default, skip_serializing_if = "Option::is_none")]
7529    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7530}
7531
7532#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7533pub struct ComputerUseWindowsConfig {
7534    #[serde(default, skip_serializing_if = "Option::is_none")]
7535    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7536    #[serde(default, skip_serializing_if = "Option::is_none")]
7537    pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
7538}
7539
7540#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7541pub struct ComputerUseWindowsExeConfig {
7542    pub access: AllowDenyRequirement,
7543    #[serde(default, skip_serializing_if = "Option::is_none")]
7544    pub binary_name: Option<String>,
7545    #[serde(default)]
7546    pub product_name: String,
7547    #[serde(default)]
7548    pub publisher_name: String,
7549}
7550
7551/// Per-platform computer-use requirements (camelCase wire).
7552#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7553#[serde(rename_all = "camelCase")]
7554pub struct ComputerUseMacosRequirements {
7555    #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
7556    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7557}
7558
7559#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7560#[serde(rename_all = "camelCase")]
7561pub struct ComputerUseWindowsRequirements {
7562    #[serde(default, skip_serializing_if = "Option::is_none")]
7563    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7564    #[serde(default, skip_serializing_if = "Option::is_none")]
7565    pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
7566}
7567
7568#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7569#[serde(rename_all = "camelCase")]
7570pub struct ComputerUseWindowsExeRequirement {
7571    pub access: AllowDenyRequirement,
7572    #[serde(
7573        rename = "binaryName",
7574        default,
7575        skip_serializing_if = "Option::is_none"
7576    )]
7577    pub binary_name: Option<String>,
7578    #[serde(rename = "productName", default)]
7579    pub product_name: String,
7580    #[serde(rename = "publisherName", default)]
7581    pub publisher_name: String,
7582}
7583
7584#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7585pub enum SandboxMode {
7586    #[serde(rename = "read-only")]
7587    Read_only,
7588    #[serde(rename = "workspace-write")]
7589    Workspace_write,
7590    #[serde(rename = "danger-full-access")]
7591    Danger_full_access,
7592}
7593
7594#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7595#[serde(tag = "type", rename_all = "camelCase")]
7596pub enum SandboxPolicy {
7597    #[serde(rename = "dangerFullAccess")]
7598    DangerFullAccess,
7599    #[serde(rename = "readOnly")]
7600    ReadOnly {
7601        #[serde(
7602            rename = "networkAccess",
7603            default,
7604            skip_serializing_if = "Option::is_none"
7605        )]
7606        network_access: Option<bool>,
7607    },
7608    #[serde(rename = "externalSandbox")]
7609    ExternalSandbox {
7610        #[serde(
7611            rename = "networkAccess",
7612            default,
7613            skip_serializing_if = "Option::is_none"
7614        )]
7615        network_access: Option<Value>,
7616    },
7617    #[serde(rename = "workspaceWrite")]
7618    WorkspaceWrite {
7619        #[serde(
7620            rename = "excludeSlashTmp",
7621            default,
7622            skip_serializing_if = "Option::is_none"
7623        )]
7624        exclude_slash_tmp: Option<bool>,
7625        #[serde(
7626            rename = "excludeTmpdirEnvVar",
7627            default,
7628            skip_serializing_if = "Option::is_none"
7629        )]
7630        exclude_tmpdir_env_var: Option<bool>,
7631        #[serde(
7632            rename = "networkAccess",
7633            default,
7634            skip_serializing_if = "Option::is_none"
7635        )]
7636        network_access: Option<bool>,
7637        #[serde(
7638            rename = "writableRoots",
7639            default,
7640            skip_serializing_if = "Option::is_none"
7641        )]
7642        writable_roots: Option<Vec<AbsolutePathBuf>>,
7643    },
7644}
7645
7646#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7647#[serde(rename_all = "snake_case")]
7648pub struct SandboxWorkspaceWrite {
7649    #[serde(default, skip_serializing_if = "Option::is_none")]
7650    pub exclude_slash_tmp: Option<bool>,
7651    #[serde(default, skip_serializing_if = "Option::is_none")]
7652    pub exclude_tmpdir_env_var: Option<bool>,
7653    #[serde(default, skip_serializing_if = "Option::is_none")]
7654    pub network_access: Option<bool>,
7655    #[serde(default, skip_serializing_if = "Option::is_none")]
7656    pub writable_roots: Option<Vec<String>>,
7657}
7658
7659#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7660#[serde(tag = "type", rename_all = "camelCase")]
7661pub enum ScheduledTaskSchedule {
7662    Hourly {
7663        #[serde(default, skip_serializing_if = "Option::is_none")]
7664        days: Option<Vec<ScheduledTaskWeekday>>,
7665        #[serde(rename = "intervalHours")]
7666        interval_hours: i64,
7667    },
7668    Daily {
7669        time: String,
7670    },
7671    Weekdays {
7672        time: String,
7673    },
7674    Weekly {
7675        days: Vec<ScheduledTaskWeekday>,
7676        time: String,
7677    },
7678}
7679
7680#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7681#[serde(rename_all = "camelCase")]
7682pub struct ScheduledTaskSummary {
7683    #[serde(default)]
7684    pub key: String,
7685    #[serde(default)]
7686    pub name: String,
7687    #[serde(default)]
7688    pub prompt: String,
7689    #[serde()]
7690    pub schedule: ScheduledTaskSchedule,
7691}
7692
7693#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7694pub enum ScheduledTaskWeekday {
7695    #[serde(rename = "MO")]
7696    MO,
7697    #[serde(rename = "TU")]
7698    TU,
7699    #[serde(rename = "WE")]
7700    WE,
7701    #[serde(rename = "TH")]
7702    TH,
7703    #[serde(rename = "FR")]
7704    FR,
7705    #[serde(rename = "SA")]
7706    SA,
7707    #[serde(rename = "SU")]
7708    SU,
7709}
7710
7711#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7712#[serde(rename_all = "camelCase")]
7713pub struct SendAddCreditsNudgeEmailParams {
7714    #[serde(rename = "creditType")]
7715    pub credit_type: AddCreditsNudgeCreditType,
7716}
7717
7718#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7719#[serde(rename_all = "camelCase")]
7720pub struct SendAddCreditsNudgeEmailResponse {
7721    #[serde()]
7722    pub status: AddCreditsNudgeEmailStatus,
7723}
7724
7725#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7726#[serde(rename_all = "camelCase")]
7727pub struct ServerRequestResolvedNotification {
7728    #[serde(rename = "requestId")]
7729    pub request_id: RequestId,
7730    #[serde(rename = "threadId", default)]
7731    pub thread_id: String,
7732}
7733
7734#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7735#[serde(rename_all = "camelCase")]
7736pub struct SessionMigration {
7737    #[serde(default)]
7738    pub cwd: String,
7739    #[serde(default)]
7740    pub path: String,
7741    #[serde(default, skip_serializing_if = "Option::is_none")]
7742    pub title: Option<String>,
7743}
7744
7745#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7746pub enum SessionSource {
7747    #[serde(rename = "cli")]
7748    Cli,
7749    #[serde(rename = "vscode")]
7750    Vscode,
7751    #[serde(rename = "exec")]
7752    Exec,
7753    #[serde(rename = "appServer")]
7754    AppServer,
7755    #[serde(rename = "unknown")]
7756    Unknown,
7757    #[serde(rename = "custom")]
7758    Custom(String),
7759    #[serde(rename = "subAgent")]
7760    SubAgent(SubAgentSource),
7761}
7762
7763#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7764#[serde(rename_all = "camelCase")]
7765pub struct Settings {
7766    #[serde(default, skip_serializing_if = "Option::is_none")]
7767    pub developer_instructions: Option<String>,
7768    #[serde(default)]
7769    pub model: String,
7770    #[serde(default, skip_serializing_if = "Option::is_none")]
7771    pub reasoning_effort: Option<ReasoningEffort>,
7772}
7773
7774#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7775#[serde(rename_all = "camelCase")]
7776pub struct SkillDependencies {
7777    #[serde(default)]
7778    pub tools: Vec<SkillToolDependency>,
7779}
7780
7781#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7782#[serde(rename_all = "camelCase")]
7783pub struct SkillErrorInfo {
7784    #[serde(default)]
7785    pub message: String,
7786    #[serde(default)]
7787    pub path: String,
7788}
7789
7790#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7791#[serde(rename_all = "camelCase")]
7792pub struct SkillInterface {
7793    #[serde(
7794        rename = "brandColor",
7795        default,
7796        skip_serializing_if = "Option::is_none"
7797    )]
7798    pub brand_color: Option<String>,
7799    #[serde(
7800        rename = "defaultPrompt",
7801        default,
7802        skip_serializing_if = "Option::is_none"
7803    )]
7804    pub default_prompt: Option<String>,
7805    #[serde(
7806        rename = "displayName",
7807        default,
7808        skip_serializing_if = "Option::is_none"
7809    )]
7810    pub display_name: Option<String>,
7811    #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
7812    pub icon_large: Option<AbsolutePathBuf>,
7813    #[serde(
7814        rename = "iconLargeUrl",
7815        default,
7816        skip_serializing_if = "Option::is_none"
7817    )]
7818    pub icon_large_url: Option<String>,
7819    #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
7820    pub icon_small: Option<AbsolutePathBuf>,
7821    #[serde(
7822        rename = "iconSmallUrl",
7823        default,
7824        skip_serializing_if = "Option::is_none"
7825    )]
7826    pub icon_small_url: Option<String>,
7827    #[serde(
7828        rename = "shortDescription",
7829        default,
7830        skip_serializing_if = "Option::is_none"
7831    )]
7832    pub short_description: Option<String>,
7833}
7834
7835#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7836#[serde(rename_all = "camelCase")]
7837pub struct SkillMetadata {
7838    #[serde(default, skip_serializing_if = "Option::is_none")]
7839    pub dependencies: Option<SkillDependencies>,
7840    #[serde(default)]
7841    pub description: String,
7842    #[serde(default)]
7843    pub enabled: bool,
7844    #[serde(default, skip_serializing_if = "Option::is_none")]
7845    pub interface: Option<SkillInterface>,
7846    #[serde(default)]
7847    pub name: String,
7848    #[serde()]
7849    pub path: LegacyAppPathString,
7850    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7851    pub plugin_id: Option<String>,
7852    #[serde()]
7853    pub scope: SkillScope,
7854    #[serde(
7855        rename = "shortDescription",
7856        default,
7857        skip_serializing_if = "Option::is_none"
7858    )]
7859    pub short_description: Option<String>,
7860}
7861
7862#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7863#[serde(rename_all = "camelCase")]
7864pub struct SkillMigration {
7865    #[serde(default)]
7866    pub name: String,
7867}
7868
7869#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7870pub enum SkillScope {
7871    #[serde(rename = "user")]
7872    User,
7873    #[serde(rename = "repo")]
7874    Repo,
7875    #[serde(rename = "system")]
7876    System,
7877    #[serde(rename = "admin")]
7878    Admin,
7879}
7880
7881#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7882#[serde(rename_all = "camelCase")]
7883pub struct SkillSummary {
7884    #[serde(default)]
7885    pub description: String,
7886    #[serde(default)]
7887    pub enabled: bool,
7888    #[serde(default, skip_serializing_if = "Option::is_none")]
7889    pub interface: Option<SkillInterface>,
7890    #[serde(default)]
7891    pub name: String,
7892    #[serde(default, skip_serializing_if = "Option::is_none")]
7893    pub path: Option<LegacyAppPathString>,
7894    #[serde(
7895        rename = "shortDescription",
7896        default,
7897        skip_serializing_if = "Option::is_none"
7898    )]
7899    pub short_description: Option<String>,
7900}
7901
7902#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7903#[serde(rename_all = "camelCase")]
7904pub struct SkillToolDependency {
7905    #[serde(default, skip_serializing_if = "Option::is_none")]
7906    pub command: Option<String>,
7907    #[serde(default, skip_serializing_if = "Option::is_none")]
7908    pub description: Option<String>,
7909    #[serde(default, skip_serializing_if = "Option::is_none")]
7910    pub transport: Option<String>,
7911    #[serde(rename = "type", default)]
7912    pub type_: String,
7913    #[serde(default, skip_serializing_if = "Option::is_none")]
7914    pub url: Option<String>,
7915    #[serde(default)]
7916    pub value: String,
7917}
7918
7919#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7920#[serde(rename_all = "camelCase")]
7921pub struct SkillsChangedNotification {
7922    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7923    pub extra: serde_json::Map<String, Value>,
7924}
7925
7926#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7927#[serde(rename_all = "camelCase")]
7928pub struct SkillsConfigWriteParams {
7929    #[serde(default)]
7930    pub enabled: bool,
7931    #[serde(default, skip_serializing_if = "Option::is_none")]
7932    pub name: Option<String>,
7933    #[serde(default, skip_serializing_if = "Option::is_none")]
7934    pub path: Option<AbsolutePathBuf>,
7935}
7936
7937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7938#[serde(rename_all = "camelCase")]
7939pub struct SkillsConfigWriteResponse {
7940    #[serde(rename = "effectiveEnabled", default)]
7941    pub effective_enabled: bool,
7942}
7943
7944#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7945#[serde(rename_all = "camelCase")]
7946pub struct SkillsExtraRootsSetParams {
7947    #[serde(rename = "extraRoots", default)]
7948    pub extra_roots: Vec<AbsolutePathBuf>,
7949}
7950
7951#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7952#[serde(rename_all = "camelCase")]
7953pub struct SkillsExtraRootsSetResponse {
7954    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7955    pub extra: serde_json::Map<String, Value>,
7956}
7957
7958#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7959#[serde(rename_all = "camelCase")]
7960pub struct SkillsListEntry {
7961    #[serde(default)]
7962    pub cwd: String,
7963    #[serde(default)]
7964    pub errors: Vec<SkillErrorInfo>,
7965    #[serde(default)]
7966    pub skills: Vec<SkillMetadata>,
7967}
7968
7969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7970#[serde(rename_all = "camelCase")]
7971pub struct SkillsListParams {
7972    #[serde(default, skip_serializing_if = "Option::is_none")]
7973    pub cwds: Option<Vec<String>>,
7974    #[serde(
7975        rename = "forceReload",
7976        default,
7977        skip_serializing_if = "Option::is_none"
7978    )]
7979    pub force_reload: Option<bool>,
7980}
7981
7982#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7983#[serde(rename_all = "camelCase")]
7984pub struct SkillsListResponse {
7985    #[serde(default)]
7986    pub data: Vec<SkillsListEntry>,
7987}
7988
7989#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7990pub enum SortDirection {
7991    #[serde(rename = "asc")]
7992    Asc,
7993    #[serde(rename = "desc")]
7994    Desc,
7995}
7996
7997#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7998#[serde(rename_all = "camelCase")]
7999pub struct SpendControlLimitSnapshot {
8000    #[serde(default)]
8001    pub limit: String,
8002    #[serde(rename = "remainingPercent", default)]
8003    pub remaining_percent: i64,
8004    #[serde(rename = "resetsAt", default)]
8005    pub resets_at: i64,
8006    #[serde(default)]
8007    pub used: String,
8008}
8009
8010#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8011pub enum SubAgentActivityKind {
8012    #[serde(rename = "started")]
8013    Started,
8014    #[serde(rename = "interacted")]
8015    Interacted,
8016    #[serde(rename = "interrupted")]
8017    Interrupted,
8018    #[serde(rename = "completed")]
8019    Completed,
8020}
8021
8022#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
8023pub enum SubAgentSource {
8024    #[serde(rename = "review")]
8025    Review,
8026    #[serde(rename = "compact")]
8027    Compact,
8028    #[serde(rename = "memory_consolidation")]
8029    MemoryConsolidation,
8030    #[serde(rename = "thread_spawn")]
8031    ThreadSpawn {
8032        #[serde(default, skip_serializing_if = "Option::is_none")]
8033        agent_nickname: Option<String>,
8034        #[serde(default, skip_serializing_if = "Option::is_none")]
8035        agent_path: Option<AgentPath>,
8036        #[serde(default, skip_serializing_if = "Option::is_none")]
8037        agent_role: Option<String>,
8038        depth: i64,
8039        parent_thread_id: ThreadId,
8040    },
8041    #[serde(rename = "other")]
8042    Other(String),
8043}
8044
8045#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8046#[serde(rename_all = "camelCase")]
8047pub struct SubagentMigration {
8048    #[serde(default)]
8049    pub name: String,
8050}
8051
8052#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8053#[serde(rename_all = "camelCase")]
8054pub struct TerminalInteractionNotification {
8055    #[serde(rename = "itemId", default)]
8056    pub item_id: String,
8057    #[serde(rename = "processId", default)]
8058    pub process_id: String,
8059    #[serde(default)]
8060    pub stdin: String,
8061    #[serde(rename = "threadId", default)]
8062    pub thread_id: String,
8063    #[serde(rename = "turnId", default)]
8064    pub turn_id: String,
8065}
8066
8067#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8068#[serde(rename_all = "camelCase")]
8069pub struct TextElement {
8070    #[serde(rename = "byteRange", default)]
8071    pub byte_range: Value,
8072    #[serde(default, skip_serializing_if = "Option::is_none")]
8073    pub placeholder: Option<String>,
8074}
8075
8076#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8077#[serde(rename_all = "camelCase")]
8078pub struct TextPosition {
8079    #[serde(default)]
8080    pub column: i64,
8081    #[serde(default)]
8082    pub line: i64,
8083}
8084
8085#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8086#[serde(rename_all = "camelCase")]
8087pub struct TextRange {
8088    #[serde()]
8089    pub end: TextPosition,
8090    #[serde()]
8091    pub start: TextPosition,
8092}
8093
8094#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8095#[serde(rename_all = "camelCase")]
8096pub struct Thread {
8097    #[serde(
8098        rename = "agentNickname",
8099        default,
8100        skip_serializing_if = "Option::is_none"
8101    )]
8102    pub agent_nickname: Option<String>,
8103    #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
8104    pub agent_role: Option<String>,
8105    #[serde(rename = "cliVersion", default)]
8106    pub cli_version: String,
8107    #[serde(rename = "createdAt", default)]
8108    pub created_at: i64,
8109    #[serde(default)]
8110    pub cwd: Value,
8111    #[serde(default)]
8112    pub ephemeral: bool,
8113    #[serde(
8114        rename = "forkedFromId",
8115        default,
8116        skip_serializing_if = "Option::is_none"
8117    )]
8118    pub forked_from_id: Option<String>,
8119    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
8120    pub git_info: Option<GitInfo>,
8121    /// Persisted history contract chosen at thread creation (0.148 upstream);
8122    /// absent on older servers, which are always `legacy`.
8123    #[serde(
8124        rename = "historyMode",
8125        default,
8126        skip_serializing_if = "Option::is_none"
8127    )]
8128    pub history_mode: Option<ThreadHistoryMode>,
8129    /// Canonical project assignment owned by app-server, if any. Required
8130    /// upstream from 0.147 but kept tolerant for pre-project servers.
8131    #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
8132    pub project_id: Option<String>,
8133    #[serde(default)]
8134    pub id: String,
8135    /// Current configured model when loaded, otherwise the latest persisted
8136    /// model. Null when unavailable. Not per-turn execution telemetry.
8137    #[serde(default, skip_serializing_if = "Option::is_none")]
8138    pub model: Option<String>,
8139    #[serde(rename = "modelProvider", default)]
8140    pub model_provider: String,
8141    #[serde(default, skip_serializing_if = "Option::is_none")]
8142    pub name: Option<String>,
8143    /// Originator recorded when the thread was created, independent of its
8144    /// current client or executor. `None` when the recorded originator is
8145    /// unavailable.
8146    #[serde(default, skip_serializing_if = "Option::is_none")]
8147    pub originator: Option<String>,
8148    #[serde(
8149        rename = "parentThreadId",
8150        default,
8151        skip_serializing_if = "Option::is_none"
8152    )]
8153    pub parent_thread_id: Option<String>,
8154    #[serde(default, skip_serializing_if = "Option::is_none")]
8155    pub path: Option<String>,
8156    #[serde(default)]
8157    pub preview: String,
8158    /// Current configured reasoning effort when loaded, otherwise the latest
8159    /// persisted effort. Null when unset or unavailable. Not per-turn
8160    /// execution telemetry.
8161    #[serde(
8162        rename = "reasoningEffort",
8163        default,
8164        skip_serializing_if = "Option::is_none"
8165    )]
8166    pub reasoning_effort: Option<ReasoningEffort>,
8167    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
8168    pub recency_at: Option<i64>,
8169    #[serde(default, skip_serializing_if = "Option::is_none")]
8170    pub section: Option<ThreadSection>,
8171    #[serde(
8172        rename = "sectionEnteredAt",
8173        default,
8174        skip_serializing_if = "Option::is_none"
8175    )]
8176    pub section_entered_at: Option<i64>,
8177    #[serde(rename = "sessionId", default)]
8178    pub session_id: String,
8179    #[serde(default)]
8180    pub source: Value,
8181    #[serde(default)]
8182    pub status: Value,
8183    #[serde(
8184        rename = "threadSource",
8185        default,
8186        skip_serializing_if = "Option::is_none"
8187    )]
8188    pub thread_source: Option<ThreadSource>,
8189    #[serde(default)]
8190    pub turns: Vec<Turn>,
8191    #[serde(rename = "updatedAt", default)]
8192    pub updated_at: i64,
8193}
8194
8195#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8196pub enum ThreadActiveFlag {
8197    #[serde(rename = "waitingOnApproval")]
8198    WaitingOnApproval,
8199    #[serde(rename = "waitingOnUserInput")]
8200    WaitingOnUserInput,
8201}
8202
8203#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8204#[serde(rename_all = "camelCase")]
8205pub struct ThreadApproveGuardianDeniedActionParams {
8206    #[serde(default)]
8207    pub event: Value,
8208    #[serde(rename = "threadId", default)]
8209    pub thread_id: String,
8210}
8211
8212#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8213#[serde(rename_all = "camelCase")]
8214pub struct ThreadApproveGuardianDeniedActionResponse {
8215    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8216    pub extra: serde_json::Map<String, Value>,
8217}
8218
8219#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8220#[serde(rename_all = "camelCase")]
8221pub struct ThreadArchiveParams {
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 ThreadArchiveResponse {
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 ThreadArchivedNotification {
8236    #[serde(rename = "threadId", default)]
8237    pub thread_id: String,
8238}
8239
8240/// An independently persisted attachment associated with a thread.
8241#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8242#[serde(rename_all = "camelCase")]
8243pub struct ThreadAttachment {
8244    #[serde(rename = "attachmentType", default)]
8245    pub attachment_type: String,
8246    #[serde(rename = "createdAt", default)]
8247    pub created_at: i64,
8248    #[serde(default)]
8249    pub id: String,
8250    #[serde(rename = "identityKey", default)]
8251    pub identity_key: String,
8252    #[serde(default)]
8253    pub payload: Value,
8254}
8255
8256/// Result of attempting to associate an attachment with a thread.
8257#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8258pub enum ThreadAttachmentAddOutcome {
8259    #[serde(rename = "created")]
8260    Created,
8261    #[serde(rename = "existing")]
8262    Existing,
8263}
8264
8265/// Parameters for creating or locating an attachment on its owning thread.
8266#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8267#[serde(rename_all = "camelCase")]
8268pub struct ThreadAttachmentAddParams {
8269    #[serde(rename = "attachmentType", default)]
8270    pub attachment_type: String,
8271    #[serde(rename = "identityKey", default)]
8272    pub identity_key: String,
8273    #[serde(default)]
8274    pub payload: Value,
8275    #[serde(rename = "threadId", default)]
8276    pub thread_id: String,
8277}
8278
8279/// The created or existing attachment.
8280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8281#[serde(rename_all = "camelCase")]
8282pub struct ThreadAttachmentAddResponse {
8283    pub attachment: ThreadAttachment,
8284    pub outcome: ThreadAttachmentAddOutcome,
8285}
8286
8287/// Parameters for listing attachments from one thread.
8288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8289#[serde(rename_all = "camelCase")]
8290pub struct ThreadAttachmentListParams {
8291    #[serde(default, skip_serializing_if = "Option::is_none")]
8292    pub cursor: Option<String>,
8293    #[serde(default, skip_serializing_if = "Option::is_none")]
8294    pub limit: Option<i64>,
8295    #[serde(rename = "threadId", default)]
8296    pub thread_id: String,
8297}
8298
8299/// One page of attachments associated with the requested thread.
8300#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8301#[serde(rename_all = "camelCase")]
8302pub struct ThreadAttachmentListResponse {
8303    #[serde(default)]
8304    pub data: Vec<ThreadAttachment>,
8305    #[serde(
8306        rename = "nextCursor",
8307        default,
8308        skip_serializing_if = "Option::is_none"
8309    )]
8310    pub next_cursor: Option<String>,
8311}
8312
8313/// The persisted attachment change represented by a notification.
8314#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8315pub enum ThreadAttachmentOperation {
8316    #[serde(rename = "created")]
8317    Created,
8318    #[serde(rename = "deleted")]
8319    Deleted,
8320}
8321
8322/// A thread that currently owns an attachment with the requested identity.
8323#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8324#[serde(rename_all = "camelCase")]
8325pub struct ThreadAttachmentOwner {
8326    /// Whether the owning thread is archived, not whether it is currently executing a turn.
8327    #[serde(default)]
8328    pub archived: bool,
8329    #[serde(rename = "threadId", default)]
8330    pub thread_id: String,
8331}
8332
8333/// Parameters for reverse lookup by attachment identity within this server's store.
8334#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8335#[serde(rename_all = "camelCase")]
8336pub struct ThreadAttachmentOwnerListParams {
8337    /// Omitted or null returns all matches; false returns non-archived threads only.
8338    #[serde(default, skip_serializing_if = "Option::is_none")]
8339    pub archived: Option<bool>,
8340    #[serde(rename = "attachmentType", default)]
8341    pub attachment_type: String,
8342    #[serde(default, skip_serializing_if = "Option::is_none")]
8343    pub cursor: Option<String>,
8344    #[serde(rename = "identityKey", default)]
8345    pub identity_key: String,
8346    #[serde(default, skip_serializing_if = "Option::is_none")]
8347    pub limit: Option<i64>,
8348}
8349
8350/// One page of matching owners, including threads without their own user messages.
8351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8352#[serde(rename_all = "camelCase")]
8353pub struct ThreadAttachmentOwnerListResponse {
8354    #[serde(default)]
8355    pub data: Vec<ThreadAttachmentOwner>,
8356    #[serde(
8357        rename = "nextCursor",
8358        default,
8359        skip_serializing_if = "Option::is_none"
8360    )]
8361    pub next_cursor: Option<String>,
8362}
8363
8364/// Parameters for deleting an attachment by its stable thread-local identity.
8365#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8366#[serde(rename_all = "camelCase")]
8367pub struct ThreadAttachmentRemoveParams {
8368    #[serde(rename = "attachmentType", default)]
8369    pub attachment_type: String,
8370    #[serde(rename = "identityKey", default)]
8371    pub identity_key: String,
8372    #[serde(rename = "threadId", default)]
8373    pub thread_id: String,
8374}
8375
8376/// Successful deletion does not return additional attachment data.
8377#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8378#[serde(rename_all = "camelCase")]
8379pub struct ThreadAttachmentRemoveResponse {
8380    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8381    pub extra: serde_json::Map<String, Value>,
8382}
8383
8384/// Notification published after a thread attachment is created or deleted.
8385#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8386#[serde(rename_all = "camelCase")]
8387pub struct ThreadAttachmentUpdatedNotification {
8388    #[serde(rename = "attachmentId", default)]
8389    pub attachment_id: String,
8390    #[serde(rename = "attachmentType", default)]
8391    pub attachment_type: String,
8392    #[serde(rename = "identityKey", default)]
8393    pub identity_key: String,
8394    pub operation: ThreadAttachmentOperation,
8395    #[serde(rename = "threadId", default)]
8396    pub thread_id: String,
8397}
8398
8399#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8400#[serde(rename_all = "camelCase")]
8401pub struct ThreadClosedNotification {
8402    #[serde(rename = "threadId", default)]
8403    pub thread_id: String,
8404}
8405
8406#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8407#[serde(rename_all = "camelCase")]
8408pub struct ThreadCompactStartParams {
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 ThreadCompactStartResponse {
8416    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8417    pub extra: serde_json::Map<String, Value>,
8418}
8419
8420#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8421#[serde(rename_all = "camelCase")]
8422pub struct ThreadDeleteParams {
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 ThreadDeleteResponse {
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 ThreadDeletedNotification {
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 ThreadForkParams {
8444    #[serde(
8445        rename = "approvalPolicy",
8446        default,
8447        skip_serializing_if = "Option::is_none"
8448    )]
8449    pub approval_policy: Option<AskForApproval>,
8450    #[serde(
8451        rename = "approvalsReviewer",
8452        default,
8453        skip_serializing_if = "Option::is_none"
8454    )]
8455    pub approvals_reviewer: Option<ApprovalsReviewer>,
8456    #[serde(
8457        rename = "baseInstructions",
8458        default,
8459        skip_serializing_if = "Option::is_none"
8460    )]
8461    pub base_instructions: Option<String>,
8462    #[serde(default, skip_serializing_if = "Option::is_none")]
8463    pub config: Option<Value>,
8464    #[serde(default, skip_serializing_if = "Option::is_none")]
8465    pub cwd: Option<String>,
8466    #[serde(
8467        rename = "developerInstructions",
8468        default,
8469        skip_serializing_if = "Option::is_none"
8470    )]
8471    pub developer_instructions: Option<String>,
8472    #[serde(default, skip_serializing_if = "Option::is_none")]
8473    pub ephemeral: Option<bool>,
8474    #[serde(
8475        rename = "excludeTurns",
8476        default,
8477        skip_serializing_if = "Option::is_none"
8478    )]
8479    pub exclude_turns: Option<bool>,
8480    #[serde(
8481        rename = "lastTurnId",
8482        default,
8483        skip_serializing_if = "Option::is_none"
8484    )]
8485    pub last_turn_id: Option<String>,
8486    #[serde(default, skip_serializing_if = "Option::is_none")]
8487    pub model: Option<String>,
8488    #[serde(
8489        rename = "modelProvider",
8490        default,
8491        skip_serializing_if = "Option::is_none"
8492    )]
8493    pub model_provider: Option<String>,
8494    #[serde(default, skip_serializing_if = "Option::is_none")]
8495    pub sandbox: Option<SandboxMode>,
8496    #[serde(
8497        rename = "serviceTier",
8498        default,
8499        skip_serializing_if = "Option::is_none"
8500    )]
8501    pub service_tier: Option<String>,
8502    #[serde(rename = "threadId", default)]
8503    pub thread_id: String,
8504    #[serde(
8505        rename = "threadSource",
8506        default,
8507        skip_serializing_if = "Option::is_none"
8508    )]
8509    pub thread_source: Option<ThreadSource>,
8510}
8511
8512#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8513#[serde(rename_all = "camelCase")]
8514pub struct ThreadForkResponse {
8515    #[serde(rename = "approvalPolicy")]
8516    pub approval_policy: AskForApproval,
8517    #[serde(rename = "approvalsReviewer", default)]
8518    pub approvals_reviewer: Value,
8519    #[serde()]
8520    pub cwd: AbsolutePathBuf,
8521    /// Saved list of disabled plugin IDs. Does not yet filter plugin
8522    /// capabilities.
8523    #[serde(rename = "disabledPluginIds", default)]
8524    pub disabled_plugin_ids: Vec<String>,
8525    #[serde(
8526        rename = "instructionSources",
8527        default,
8528        skip_serializing_if = "Option::is_none"
8529    )]
8530    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8531    #[serde(default)]
8532    pub model: String,
8533    #[serde(rename = "modelProvider", default)]
8534    pub model_provider: String,
8535    #[serde(
8536        rename = "reasoningEffort",
8537        default,
8538        skip_serializing_if = "Option::is_none"
8539    )]
8540    pub reasoning_effort: Option<ReasoningEffort>,
8541    #[serde(default)]
8542    pub sandbox: Value,
8543    #[serde(
8544        rename = "serviceTier",
8545        default,
8546        skip_serializing_if = "Option::is_none"
8547    )]
8548    pub service_tier: Option<String>,
8549    #[serde()]
8550    pub thread: Thread,
8551}
8552
8553#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8554#[serde(rename_all = "camelCase")]
8555pub struct ThreadGoal {
8556    #[serde(rename = "createdAt", default)]
8557    pub created_at: i64,
8558    #[serde(default)]
8559    pub objective: String,
8560    #[serde()]
8561    pub status: ThreadGoalStatus,
8562    #[serde(rename = "threadId", default)]
8563    pub thread_id: String,
8564    #[serde(rename = "timeUsedSeconds", default)]
8565    pub time_used_seconds: i64,
8566    #[serde(
8567        rename = "tokenBudget",
8568        default,
8569        skip_serializing_if = "Option::is_none"
8570    )]
8571    pub token_budget: Option<i64>,
8572    #[serde(rename = "tokensUsed", default)]
8573    pub tokens_used: i64,
8574    #[serde(rename = "updatedAt", default)]
8575    pub updated_at: i64,
8576}
8577
8578#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8579#[serde(rename_all = "camelCase")]
8580pub struct ThreadGoalClearParams {
8581    /// Missing provenance does not supply user authorization.
8582    #[serde(default, skip_serializing_if = "Option::is_none")]
8583    pub origin: Option<ThreadGoalMutationOrigin>,
8584    #[serde(rename = "threadId", default)]
8585    pub thread_id: String,
8586}
8587
8588#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8589#[serde(rename_all = "camelCase")]
8590pub struct ThreadGoalClearResponse {
8591    #[serde(default)]
8592    pub cleared: bool,
8593}
8594
8595#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8596#[serde(rename_all = "camelCase")]
8597pub struct ThreadGoalClearedNotification {
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 ThreadGoalGetParams {
8605    #[serde(rename = "threadId", default)]
8606    pub thread_id: String,
8607}
8608
8609#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8610#[serde(rename_all = "camelCase")]
8611pub struct ThreadGoalGetResponse {
8612    #[serde(default, skip_serializing_if = "Option::is_none")]
8613    pub goal: Option<ThreadGoal>,
8614}
8615
8616/// Distinguishes explicit user actions from automatic goal lifecycle mutations.
8617#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8618pub enum ThreadGoalMutationOrigin {
8619    #[serde(rename = "user")]
8620    User,
8621    #[serde(rename = "automatic")]
8622    Automatic,
8623}
8624
8625#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8626#[serde(rename_all = "camelCase")]
8627pub struct ThreadGoalSetParams {
8628    #[serde(default, skip_serializing_if = "Option::is_none")]
8629    pub objective: Option<String>,
8630    /// Missing provenance does not supply user authorization.
8631    #[serde(default, skip_serializing_if = "Option::is_none")]
8632    pub origin: Option<ThreadGoalMutationOrigin>,
8633    #[serde(default, skip_serializing_if = "Option::is_none")]
8634    pub status: Option<ThreadGoalStatus>,
8635    #[serde(rename = "threadId", default)]
8636    pub thread_id: String,
8637    #[serde(
8638        rename = "tokenBudget",
8639        default,
8640        skip_serializing_if = "Option::is_none"
8641    )]
8642    pub token_budget: Option<i64>,
8643}
8644
8645#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8646#[serde(rename_all = "camelCase")]
8647pub struct ThreadGoalSetResponse {
8648    #[serde()]
8649    pub goal: ThreadGoal,
8650}
8651
8652#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8653pub enum ThreadGoalStatus {
8654    #[serde(rename = "active")]
8655    Active,
8656    #[serde(rename = "paused")]
8657    Paused,
8658    #[serde(rename = "blocked")]
8659    Blocked,
8660    #[serde(rename = "usageLimited")]
8661    UsageLimited,
8662    #[serde(rename = "budgetLimited")]
8663    BudgetLimited,
8664    #[serde(rename = "complete")]
8665    Complete,
8666}
8667
8668#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8669#[serde(rename_all = "camelCase")]
8670pub struct ThreadGoalUpdatedNotification {
8671    #[serde()]
8672    pub goal: ThreadGoal,
8673    #[serde(rename = "threadId", default)]
8674    pub thread_id: String,
8675    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8676    pub turn_id: Option<String>,
8677}
8678
8679#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
8680#[serde(transparent)]
8681pub struct ThreadId(pub String);
8682
8683#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8684#[serde(rename_all = "camelCase")]
8685pub struct ThreadInjectItemsParams {
8686    #[serde(default)]
8687    pub items: Vec<Value>,
8688    #[serde(rename = "threadId", default)]
8689    pub thread_id: String,
8690}
8691
8692#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8693#[serde(rename_all = "camelCase")]
8694pub struct ThreadInjectItemsResponse {
8695    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8696    pub extra: serde_json::Map<String, Value>,
8697}
8698
8699/// A thread item and its recorded lifecycle times. The payload stays flat on the wire.
8700#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8701#[serde(rename_all = "camelCase")]
8702pub struct ThreadItem {
8703    #[serde(flatten)]
8704    pub payload: ThreadItemPayload,
8705    /// Unix timestamp in milliseconds when the item started, if recorded.
8706    #[serde(
8707        rename = "startedAtMs",
8708        default,
8709        skip_serializing_if = "Option::is_none"
8710    )]
8711    pub started_at_ms: Option<i64>,
8712    /// Unix timestamp in milliseconds when the item completed, if recorded.
8713    #[serde(
8714        rename = "completedAtMs",
8715        default,
8716        skip_serializing_if = "Option::is_none"
8717    )]
8718    pub completed_at_ms: Option<i64>,
8719}
8720
8721impl ThreadItem {
8722    /// Creates an item with no recorded start or completion time.
8723    pub fn untimed(payload: ThreadItemPayload) -> Self {
8724        Self {
8725            payload,
8726            started_at_ms: None,
8727            completed_at_ms: None,
8728        }
8729    }
8730}
8731
8732impl From<ThreadItemPayload> for ThreadItem {
8733    fn from(payload: ThreadItemPayload) -> Self {
8734        Self::untimed(payload)
8735    }
8736}
8737
8738/// The type-tagged body of a [`ThreadItem`], flattened into it on the wire.
8739#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8740#[serde(tag = "type", rename_all = "camelCase")]
8741pub enum ThreadItemPayload {
8742    #[serde(rename = "userMessage")]
8743    UserMessage {
8744        #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
8745        client_id: Option<String>,
8746        content: Vec<UserInput>,
8747        id: String,
8748    },
8749    #[serde(rename = "hookPrompt")]
8750    HookPrompt {
8751        fragments: Vec<HookPromptFragment>,
8752        id: String,
8753    },
8754    #[serde(rename = "agentMessage")]
8755    AgentMessage {
8756        #[serde(default, skip_serializing_if = "Option::is_none")]
8757        delivery: Option<AgentMessageDelivery>,
8758        id: String,
8759        #[serde(
8760            rename = "memoryCitation",
8761            default,
8762            skip_serializing_if = "Option::is_none"
8763        )]
8764        memory_citation: Option<MemoryCitation>,
8765        #[serde(default, skip_serializing_if = "Option::is_none")]
8766        moderation: Option<AgentMessageModeration>,
8767        #[serde(default, skip_serializing_if = "Option::is_none")]
8768        phase: Option<MessagePhase>,
8769        #[serde(default, skip_serializing_if = "Option::is_none")]
8770        questions: Option<Vec<AsyncUserInputQuestion>>,
8771        text: String,
8772    },
8773    Plan {
8774        id: String,
8775        text: String,
8776    },
8777    Reasoning {
8778        #[serde(default, skip_serializing_if = "Option::is_none")]
8779        content: Option<Vec<String>>,
8780        id: String,
8781        #[serde(default, skip_serializing_if = "Option::is_none")]
8782        summary: Option<Vec<String>>,
8783    },
8784    #[serde(rename = "commandExecution")]
8785    CommandExecution {
8786        #[serde(
8787            rename = "aggregatedOutput",
8788            default,
8789            skip_serializing_if = "Option::is_none"
8790        )]
8791        aggregated_output: Option<String>,
8792        command: String,
8793        #[serde(rename = "commandActions")]
8794        command_actions: Vec<CommandAction>,
8795        cwd: Value,
8796        #[serde(
8797            rename = "durationMs",
8798            default,
8799            skip_serializing_if = "Option::is_none"
8800        )]
8801        duration_ms: Option<i64>,
8802        #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
8803        exit_code: Option<i64>,
8804        id: String,
8805        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8806        plugin_id: Option<String>,
8807        #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
8808        process_id: Option<String>,
8809        #[serde(
8810            rename = "scriptPath",
8811            default,
8812            skip_serializing_if = "Option::is_none"
8813        )]
8814        script_path: Option<String>,
8815        #[serde(default, skip_serializing_if = "Option::is_none")]
8816        source: Option<Value>,
8817        status: CommandExecutionStatus,
8818    },
8819    #[serde(rename = "fileChange")]
8820    FileChange {
8821        changes: Vec<FileUpdateChange>,
8822        id: String,
8823        status: PatchApplyStatus,
8824    },
8825    #[serde(rename = "mcpToolCall")]
8826    McpToolCall {
8827        #[serde(
8828            rename = "appContext",
8829            default,
8830            skip_serializing_if = "Option::is_none"
8831        )]
8832        app_context: Option<McpToolCallAppContext>,
8833        arguments: Value,
8834        #[serde(
8835            rename = "durationMs",
8836            default,
8837            skip_serializing_if = "Option::is_none"
8838        )]
8839        duration_ms: Option<i64>,
8840        /// Registration scope, not necessarily the server's execution
8841        /// environment.
8842        #[serde(
8843            rename = "environmentId",
8844            default,
8845            skip_serializing_if = "Option::is_none"
8846        )]
8847        environment_id: Option<String>,
8848        #[serde(default, skip_serializing_if = "Option::is_none")]
8849        error: Option<McpToolCallError>,
8850        id: String,
8851        /// Legacy compatibility field; prefer `mcp_app_ui.resource_uri` when
8852        /// available.
8853        #[serde(
8854            rename = "mcpAppResourceUri",
8855            default,
8856            skip_serializing_if = "Option::is_none"
8857        )]
8858        mcp_app_resource_uri: Option<String>,
8859        /// Presentation captured from the invoked descriptor; absent in
8860        /// older history.
8861        #[serde(rename = "mcpAppUi", default, skip_serializing_if = "Option::is_none")]
8862        mcp_app_ui: Option<McpAppUi>,
8863        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8864        plugin_id: Option<String>,
8865        #[serde(
8866            rename = "readOnlyHint",
8867            default,
8868            skip_serializing_if = "Option::is_none"
8869        )]
8870        read_only_hint: Option<bool>,
8871        #[serde(default, skip_serializing_if = "Option::is_none")]
8872        result: Option<McpToolCallResult>,
8873        server: String,
8874        status: McpToolCallStatus,
8875        tool: String,
8876    },
8877    #[serde(rename = "dynamicToolCall")]
8878    DynamicToolCall {
8879        arguments: Value,
8880        #[serde(
8881            rename = "contentItems",
8882            default,
8883            skip_serializing_if = "Option::is_none"
8884        )]
8885        content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
8886        #[serde(
8887            rename = "durationMs",
8888            default,
8889            skip_serializing_if = "Option::is_none"
8890        )]
8891        duration_ms: Option<i64>,
8892        id: String,
8893        #[serde(default, skip_serializing_if = "Option::is_none")]
8894        namespace: Option<String>,
8895        status: DynamicToolCallStatus,
8896        #[serde(default, skip_serializing_if = "Option::is_none")]
8897        success: Option<bool>,
8898        tool: String,
8899    },
8900    #[serde(rename = "collabAgentToolCall")]
8901    CollabAgentToolCall {
8902        #[serde(rename = "agentsStates")]
8903        agents_states: std::collections::BTreeMap<String, CollabAgentState>,
8904        id: String,
8905        #[serde(default, skip_serializing_if = "Option::is_none")]
8906        model: Option<String>,
8907        #[serde(default, skip_serializing_if = "Option::is_none")]
8908        prompt: Option<String>,
8909        #[serde(
8910            rename = "reasoningEffort",
8911            default,
8912            skip_serializing_if = "Option::is_none"
8913        )]
8914        reasoning_effort: Option<ReasoningEffort>,
8915        #[serde(rename = "receiverThreadIds")]
8916        receiver_thread_ids: Vec<String>,
8917        #[serde(rename = "senderThreadId")]
8918        sender_thread_id: String,
8919        status: Value,
8920        tool: Value,
8921    },
8922    #[serde(rename = "subAgentActivity")]
8923    SubAgentActivity {
8924        #[serde(rename = "agentPath")]
8925        agent_path: String,
8926        #[serde(rename = "agentThreadId")]
8927        agent_thread_id: String,
8928        id: String,
8929        kind: SubAgentActivityKind,
8930        /// Resolved model at sub-agent creation; absent from older records
8931        /// and other activities.
8932        #[serde(default, skip_serializing_if = "Option::is_none")]
8933        model: Option<String>,
8934        /// Resolved reasoning effort at sub-agent creation, when known.
8935        #[serde(
8936            rename = "reasoningEffort",
8937            default,
8938            skip_serializing_if = "Option::is_none"
8939        )]
8940        reasoning_effort: Option<ReasoningEffort>,
8941    },
8942    #[serde(rename = "webSearch")]
8943    WebSearch {
8944        #[serde(default, skip_serializing_if = "Option::is_none")]
8945        action: Option<WebSearchAction>,
8946        id: String,
8947        query: String,
8948        #[serde(default, skip_serializing_if = "Option::is_none")]
8949        results: Option<Vec<Value>>,
8950    },
8951    #[serde(rename = "imageView")]
8952    ImageView {
8953        id: String,
8954        path: LegacyAppPathString,
8955    },
8956    Sleep {
8957        #[serde(rename = "durationMs")]
8958        duration_ms: i64,
8959        id: String,
8960    },
8961    #[serde(rename = "imageGeneration")]
8962    ImageGeneration {
8963        #[serde(default, skip_serializing_if = "Option::is_none")]
8964        failure: Option<ImageGenerationFailure>,
8965        /// Image generation identifier, when provided by the image backend.
8966        #[serde(
8967            rename = "generationId",
8968            default,
8969            skip_serializing_if = "Option::is_none"
8970        )]
8971        generation_id: Option<String>,
8972        id: String,
8973        #[serde(flatten)]
8974        image: GeneratedImageRef,
8975        /// Observed local inputs for a completed generation, absent on older items.
8976        #[serde(
8977            rename = "inputImages",
8978            default,
8979            skip_serializing_if = "Option::is_none"
8980        )]
8981        input_images: Option<Vec<ImageGenerationInputImage>>,
8982        #[serde(
8983            rename = "revisedPrompt",
8984            default,
8985            skip_serializing_if = "Option::is_none"
8986        )]
8987        revised_prompt: Option<String>,
8988        #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
8989        saved_path: Option<AbsolutePathBuf>,
8990        status: String,
8991        #[serde(
8992            rename = "transparentBackground",
8993            default,
8994            skip_serializing_if = "Option::is_none"
8995        )]
8996        transparent_background: Option<bool>,
8997    },
8998    #[serde(rename = "enteredReviewMode")]
8999    EnteredReviewMode {
9000        id: String,
9001        review: String,
9002    },
9003    #[serde(rename = "exitedReviewMode")]
9004    ExitedReviewMode {
9005        id: String,
9006        review: String,
9007    },
9008    #[serde(rename = "contextCompaction")]
9009    ContextCompaction {
9010        id: String,
9011    },
9012    #[serde(rename = "functionCallOutput")]
9013    FunctionCallOutput {
9014        id: String,
9015        name: String,
9016        #[serde(default, skip_serializing_if = "Option::is_none")]
9017        namespace: Option<String>,
9018        output: FunctionCallOutputBody,
9019    },
9020}
9021
9022#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9023#[serde(untagged)]
9024pub enum ThreadListCwdFilter {
9025    Variant0(String),
9026    Variant1(Vec<String>),
9027}
9028
9029#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9030#[serde(rename_all = "camelCase")]
9031pub struct ThreadListParams {
9032    #[serde(default, skip_serializing_if = "Option::is_none")]
9033    pub archived: Option<bool>,
9034    /// Show local history visible to the current ChatGPT account. Defaults to
9035    /// false.
9036    #[serde(
9037        rename = "currentAccountOnly",
9038        default,
9039        skip_serializing_if = "Option::is_none"
9040    )]
9041    pub current_account_only: Option<bool>,
9042    #[serde(default, skip_serializing_if = "Option::is_none")]
9043    pub cursor: Option<String>,
9044    #[serde(default, skip_serializing_if = "Option::is_none")]
9045    pub cwd: Option<ThreadListCwdFilter>,
9046    /// Thread IDs to exclude before applying the result limit. Up to 100
9047    /// entries; invalid IDs or a larger list are rejected, never truncated.
9048    /// Send the same exclusions on each page. Omitted, null, or empty means
9049    /// no exclusions.
9050    #[serde(
9051        rename = "excludedThreadIds",
9052        default,
9053        skip_serializing_if = "Option::is_none"
9054    )]
9055    pub excluded_thread_ids: Option<Vec<String>>,
9056    /// Restrict results to up to 100 thread IDs before pagination. Omit or
9057    /// send null for unrestricted results. An empty list matches nothing.
9058    /// Exclusions still apply. Repeat the same IDs on each page. The local
9059    /// store uses indexed metadata for this filter.
9060    #[serde(
9061        rename = "includedThreadIds",
9062        default,
9063        skip_serializing_if = "Option::is_none"
9064    )]
9065    pub included_thread_ids: Option<Vec<String>>,
9066    #[serde(default, skip_serializing_if = "Option::is_none")]
9067    pub limit: Option<i64>,
9068    #[serde(
9069        rename = "modelProviders",
9070        default,
9071        skip_serializing_if = "Option::is_none"
9072    )]
9073    pub model_providers: Option<Vec<String>>,
9074    /// Optional originator allowlist, matching any supplied value exactly.
9075    /// Supported by hosted backends only; the local app-server rejects a
9076    /// nonempty list. Omitted or empty lists leave originators unrestricted.
9077    #[serde(default, skip_serializing_if = "Option::is_none")]
9078    pub originators: Option<Vec<String>>,
9079    #[serde(
9080        rename = "searchTerm",
9081        default,
9082        skip_serializing_if = "Option::is_none"
9083    )]
9084    pub search_term: Option<String>,
9085    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
9086    pub section_id: Option<String>,
9087    #[serde(
9088        rename = "sortDirection",
9089        default,
9090        skip_serializing_if = "Option::is_none"
9091    )]
9092    pub sort_direction: Option<SortDirection>,
9093    #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
9094    pub sort_key: Option<ThreadSortKey>,
9095    #[serde(
9096        rename = "sourceKinds",
9097        default,
9098        skip_serializing_if = "Option::is_none"
9099    )]
9100    pub source_kinds: Option<Vec<ThreadSourceKind>>,
9101    /// If true, the local store returns indexed metadata without scanning
9102    /// JSONL rollouts for repairs. Requests with `includedThreadIds` always
9103    /// use indexed metadata.
9104    #[serde(
9105        rename = "useStateDbOnly",
9106        default,
9107        skip_serializing_if = "Option::is_none"
9108    )]
9109    pub use_state_db_only: Option<bool>,
9110}
9111
9112#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9113#[serde(rename_all = "camelCase")]
9114pub struct ThreadListResponse {
9115    #[serde(
9116        rename = "backwardsCursor",
9117        default,
9118        skip_serializing_if = "Option::is_none"
9119    )]
9120    pub backwards_cursor: Option<String>,
9121    #[serde(default)]
9122    pub data: Vec<Thread>,
9123    #[serde(
9124        rename = "nextCursor",
9125        default,
9126        skip_serializing_if = "Option::is_none"
9127    )]
9128    pub next_cursor: Option<String>,
9129}
9130
9131#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9132#[serde(rename_all = "camelCase")]
9133pub struct ThreadLoadedListParams {
9134    #[serde(default, skip_serializing_if = "Option::is_none")]
9135    pub cursor: Option<String>,
9136    #[serde(default, skip_serializing_if = "Option::is_none")]
9137    pub limit: Option<i64>,
9138}
9139
9140#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9141#[serde(rename_all = "camelCase")]
9142pub struct ThreadLoadedListResponse {
9143    #[serde(default)]
9144    pub data: Vec<String>,
9145    #[serde(
9146        rename = "nextCursor",
9147        default,
9148        skip_serializing_if = "Option::is_none"
9149    )]
9150    pub next_cursor: Option<String>,
9151}
9152
9153#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9154#[serde(rename_all = "camelCase")]
9155pub struct ThreadMetadataGitInfoUpdateParams {
9156    #[serde(default, skip_serializing_if = "Option::is_none")]
9157    pub branch: Option<String>,
9158    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
9159    pub origin_url: Option<String>,
9160    #[serde(default, skip_serializing_if = "Option::is_none")]
9161    pub sha: Option<String>,
9162}
9163
9164#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9165#[serde(rename_all = "camelCase")]
9166pub struct ThreadMetadataUpdateParams {
9167    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
9168    pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
9169    #[serde(rename = "threadId", default)]
9170    pub thread_id: String,
9171}
9172
9173#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9174#[serde(rename_all = "camelCase")]
9175pub struct ThreadMetadataUpdateResponse {
9176    #[serde()]
9177    pub thread: Thread,
9178}
9179
9180#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9181#[serde(rename_all = "camelCase")]
9182pub struct ThreadNameUpdatedNotification {
9183    #[serde(rename = "threadId", default)]
9184    pub thread_id: String,
9185    #[serde(
9186        rename = "threadName",
9187        default,
9188        skip_serializing_if = "Option::is_none"
9189    )]
9190    pub thread_name: Option<String>,
9191}
9192
9193#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9194#[serde(rename_all = "camelCase")]
9195pub struct ThreadReadParams {
9196    #[serde(
9197        rename = "includeTurns",
9198        default,
9199        skip_serializing_if = "Option::is_none"
9200    )]
9201    pub include_turns: Option<bool>,
9202    #[serde(rename = "threadId", default)]
9203    pub thread_id: String,
9204}
9205
9206#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9207#[serde(rename_all = "camelCase")]
9208pub struct ThreadReadResponse {
9209    #[serde()]
9210    pub thread: Thread,
9211}
9212
9213/// The first unread position in a durable local thread. A null position means read.
9214/// The opaque revision guards edits against activity or marks the caller has not seen.
9215#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9216#[serde(rename_all = "camelCase")]
9217pub struct ThreadReadState {
9218    #[serde(
9219        rename = "firstUnread",
9220        default,
9221        skip_serializing_if = "Option::is_none"
9222    )]
9223    pub first_unread: Option<ThreadUnreadPosition>,
9224    #[serde(default)]
9225    pub revision: String,
9226}
9227
9228#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9229#[serde(rename_all = "camelCase")]
9230pub struct ThreadReadStateChangedNotification {
9231    #[serde(rename = "readState")]
9232    pub read_state: ThreadReadState,
9233    #[serde(rename = "threadId", default)]
9234    pub thread_id: String,
9235}
9236
9237/// Broadcast after a successful move into, within, or out of a section.
9238#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
9239#[serde(rename_all = "camelCase")]
9240pub struct ThreadSectionChangedNotification {
9241    #[serde(rename = "threadId")]
9242    pub thread_id: String,
9243    /// Destination section, or `None` when the thread was removed from its
9244    /// section. Always present on the wire (`null` when removed).
9245    #[serde(rename = "sectionId")]
9246    pub section_id: Option<String>,
9247}
9248
9249#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9250#[serde(rename_all = "camelCase")]
9251pub struct ThreadRealtimeAudioChunk {
9252    #[serde(default)]
9253    pub data: String,
9254    #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
9255    pub item_id: Option<String>,
9256    #[serde(rename = "numChannels", default)]
9257    pub num_channels: i64,
9258    #[serde(rename = "sampleRate", default)]
9259    pub sample_rate: i64,
9260    #[serde(
9261        rename = "samplesPerChannel",
9262        default,
9263        skip_serializing_if = "Option::is_none"
9264    )]
9265    pub samples_per_channel: Option<i64>,
9266}
9267
9268#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9269#[serde(rename_all = "camelCase")]
9270pub struct ThreadRealtimeClosedNotification {
9271    #[serde(default, skip_serializing_if = "Option::is_none")]
9272    pub reason: Option<String>,
9273    #[serde(rename = "threadId", default)]
9274    pub thread_id: String,
9275}
9276
9277#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9278#[serde(rename_all = "camelCase")]
9279pub struct ThreadRealtimeErrorNotification {
9280    #[serde(default)]
9281    pub message: String,
9282    #[serde(rename = "threadId", default)]
9283    pub thread_id: String,
9284}
9285
9286#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9287#[serde(rename_all = "camelCase")]
9288pub struct ThreadRealtimeItemAddedNotification {
9289    #[serde(default)]
9290    pub item: Value,
9291    #[serde(rename = "threadId", default)]
9292    pub thread_id: String,
9293}
9294
9295#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9296#[serde(rename_all = "camelCase")]
9297pub struct ThreadRealtimeOutputAudioDeltaNotification {
9298    #[serde()]
9299    pub audio: ThreadRealtimeAudioChunk,
9300    #[serde(rename = "threadId", default)]
9301    pub thread_id: String,
9302}
9303
9304#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9305#[serde(rename_all = "camelCase")]
9306pub struct ThreadRealtimeSdpNotification {
9307    #[serde(default)]
9308    pub sdp: String,
9309    #[serde(rename = "threadId", default)]
9310    pub thread_id: String,
9311}
9312
9313#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9314#[serde(rename_all = "camelCase")]
9315pub struct ThreadRealtimeStartedNotification {
9316    #[serde(
9317        rename = "realtimeSessionId",
9318        default,
9319        skip_serializing_if = "Option::is_none"
9320    )]
9321    pub realtime_session_id: Option<String>,
9322    #[serde(rename = "threadId", default)]
9323    pub thread_id: String,
9324    #[serde()]
9325    pub version: RealtimeConversationVersion,
9326}
9327
9328#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9329#[serde(rename_all = "camelCase")]
9330pub struct ThreadRealtimeTranscriptDeltaNotification {
9331    #[serde(default)]
9332    pub delta: String,
9333    #[serde(default)]
9334    pub role: String,
9335    #[serde(rename = "threadId", default)]
9336    pub thread_id: String,
9337}
9338
9339#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9340#[serde(rename_all = "camelCase")]
9341pub struct ThreadRealtimeTranscriptDoneNotification {
9342    #[serde(default)]
9343    pub role: String,
9344    #[serde(default)]
9345    pub text: String,
9346    #[serde(rename = "threadId", default)]
9347    pub thread_id: String,
9348}
9349
9350#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9351#[serde(rename_all = "camelCase")]
9352pub struct ThreadResumeParams {
9353    #[serde(
9354        rename = "approvalPolicy",
9355        default,
9356        skip_serializing_if = "Option::is_none"
9357    )]
9358    pub approval_policy: Option<AskForApproval>,
9359    #[serde(
9360        rename = "approvalsReviewer",
9361        default,
9362        skip_serializing_if = "Option::is_none"
9363    )]
9364    pub approvals_reviewer: Option<ApprovalsReviewer>,
9365    #[serde(
9366        rename = "baseInstructions",
9367        default,
9368        skip_serializing_if = "Option::is_none"
9369    )]
9370    pub base_instructions: Option<String>,
9371    #[serde(default, skip_serializing_if = "Option::is_none")]
9372    pub config: Option<Value>,
9373    #[serde(default, skip_serializing_if = "Option::is_none")]
9374    pub cwd: Option<String>,
9375    #[serde(
9376        rename = "developerInstructions",
9377        default,
9378        skip_serializing_if = "Option::is_none"
9379    )]
9380    pub developer_instructions: Option<String>,
9381    #[serde(default, skip_serializing_if = "Option::is_none")]
9382    pub model: Option<String>,
9383    #[serde(
9384        rename = "modelProvider",
9385        default,
9386        skip_serializing_if = "Option::is_none"
9387    )]
9388    pub model_provider: Option<String>,
9389    #[serde(default, skip_serializing_if = "Option::is_none")]
9390    pub personality: Option<Personality>,
9391    #[serde(default, skip_serializing_if = "Option::is_none")]
9392    pub sandbox: Option<SandboxMode>,
9393    #[serde(
9394        rename = "serviceTier",
9395        default,
9396        skip_serializing_if = "Option::is_none"
9397    )]
9398    pub service_tier: Option<String>,
9399    #[serde(rename = "threadId", default)]
9400    pub thread_id: String,
9401    #[serde(
9402        rename = "excludeTurns",
9403        default,
9404        skip_serializing_if = "Option::is_none"
9405    )]
9406    pub exclude_turns: Option<bool>,
9407}
9408
9409#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9410#[serde(rename_all = "camelCase")]
9411pub struct ThreadResumeResponse {
9412    #[serde(rename = "approvalPolicy")]
9413    pub approval_policy: AskForApproval,
9414    #[serde(rename = "approvalsReviewer", default)]
9415    pub approvals_reviewer: Value,
9416    /// Effective collaboration mode. Absent when resuming from an older
9417    /// server.
9418    #[serde(
9419        rename = "collaborationMode",
9420        default,
9421        skip_serializing_if = "Option::is_none"
9422    )]
9423    pub collaboration_mode: Option<CollaborationMode>,
9424    #[serde()]
9425    pub cwd: AbsolutePathBuf,
9426    /// Saved list of disabled plugin IDs. Does not yet filter plugin
9427    /// capabilities.
9428    #[serde(rename = "disabledPluginIds", default)]
9429    pub disabled_plugin_ids: Vec<String>,
9430    #[serde(
9431        rename = "instructionSources",
9432        default,
9433        skip_serializing_if = "Option::is_none"
9434    )]
9435    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9436    /// Cursor for hydrating paginated items backwards via `thread/items/list`
9437    /// with `sortDirection: "desc"` (0.148 upstream).
9438    #[serde(
9439        rename = "itemsBackwardsCursor",
9440        default,
9441        skip_serializing_if = "Option::is_none"
9442    )]
9443    pub items_backwards_cursor: Option<String>,
9444    #[serde(default)]
9445    pub model: String,
9446    #[serde(rename = "modelProvider", default)]
9447    pub model_provider: String,
9448    #[serde(
9449        rename = "reasoningEffort",
9450        default,
9451        skip_serializing_if = "Option::is_none"
9452    )]
9453    pub reasoning_effort: Option<ReasoningEffort>,
9454    #[serde(default)]
9455    pub sandbox: Value,
9456    #[serde(
9457        rename = "serviceTier",
9458        default,
9459        skip_serializing_if = "Option::is_none"
9460    )]
9461    pub service_tier: Option<String>,
9462    #[serde()]
9463    pub thread: Thread,
9464    /// Cursor for hydrating paginated turns backwards via `thread/turns/list`
9465    /// with `sortDirection: "desc"` (0.148 upstream).
9466    #[serde(
9467        rename = "turnsBackwardsCursor",
9468        default,
9469        skip_serializing_if = "Option::is_none"
9470    )]
9471    pub turns_backwards_cursor: Option<String>,
9472}
9473
9474/// Persisted thread history contract (0.148 upstream).
9475#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9476pub enum ThreadHistoryMode {
9477    #[serde(rename = "legacy")]
9478    Legacy,
9479    #[serde(rename = "paginated")]
9480    Paginated,
9481}
9482
9483/// One item plus the turn that contains it, as returned by
9484/// `thread/items/list` (0.148 upstream).
9485#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9486#[serde(rename_all = "camelCase")]
9487pub struct ThreadItemEntry {
9488    /// Unix timestamp (milliseconds) when the item completed, if recorded by
9489    /// the producer.
9490    #[serde(
9491        rename = "completedAtMs",
9492        default,
9493        skip_serializing_if = "Option::is_none"
9494    )]
9495    pub completed_at_ms: Option<i64>,
9496    #[serde()]
9497    pub item: ThreadItem,
9498    /// EXPERIMENTAL upstream — the saved command output was omitted because
9499    /// the request set [`ThreadItemOutputDeferral::command_execution`]; fetch
9500    /// the complete item with `thread/items/read` (openai/codex#59601).
9501    /// Requires `experimentalApi`; absent (false) otherwise.
9502    #[serde(
9503        rename = "outputDeferred",
9504        default,
9505        skip_serializing_if = "std::ops::Not::not"
9506    )]
9507    pub output_deferred: bool,
9508    /// Unix timestamp (milliseconds) when the item started, if recorded by
9509    /// the producer.
9510    #[serde(
9511        rename = "startedAtMs",
9512        default,
9513        skip_serializing_if = "Option::is_none"
9514    )]
9515    pub started_at_ms: Option<i64>,
9516    #[serde(rename = "turnId", default)]
9517    pub turn_id: String,
9518}
9519
9520/// Params for `thread/items/list` — paginated item hydration (0.148 upstream).
9521#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9522#[serde(rename_all = "camelCase")]
9523pub struct ThreadItemsListParams {
9524    /// Opaque continuation cursor, or an exclusive item anchor in the
9525    /// requested visible turn (`openai/codex@main` de9e78e3). An item anchor
9526    /// requires a non-empty `turn_id`; ascending (the default) returns items
9527    /// after it, descending returns items before it. Continue with the
9528    /// returned string cursor.
9529    #[serde(default, skip_serializing_if = "Option::is_none")]
9530    pub cursor: Option<ThreadItemsListCursor>,
9531    /// For a single turn, choose which saved outputs to fetch separately by
9532    /// item ID (openai/codex#59601).
9533    #[serde(
9534        rename = "deferOutput",
9535        default,
9536        skip_serializing_if = "Option::is_none"
9537    )]
9538    pub defer_output: Option<ThreadItemOutputDeferral>,
9539    #[serde(default, skip_serializing_if = "Option::is_none")]
9540    pub limit: Option<u32>,
9541    #[serde(
9542        rename = "sortDirection",
9543        default,
9544        skip_serializing_if = "Option::is_none"
9545    )]
9546    pub sort_direction: Option<SortDirection>,
9547    #[serde(rename = "threadId", default)]
9548    pub thread_id: String,
9549    /// Optional turn id filter; omitted returns items across the thread.
9550    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
9551    pub turn_id: Option<String>,
9552}
9553
9554/// `thread/items/list` `deferOutput` selector — which saved outputs the
9555/// server should omit from the page so the client can fetch them separately
9556/// by item ID (openai/codex#59601). The stable schema exposes this as an
9557/// empty object; its fields are experimental upstream.
9558#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
9559#[serde(rename_all = "camelCase")]
9560pub struct ThreadItemOutputDeferral {
9561    /// EXPERIMENTAL upstream — defer nonempty output from successful
9562    /// commands. Requires `experimentalApi`.
9563    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9564    pub command_execution: bool,
9565}
9566
9567/// Starting position for a `thread/items/list` page: either the opaque
9568/// string cursor a previous page returned, or an item anchor
9569/// (`openai/codex@main` de9e78e3). Untagged, so a bare string stays a bare
9570/// string on the wire.
9571#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9572#[serde(untagged)]
9573pub enum ThreadItemsListCursor {
9574    Opaque(String),
9575    Anchor(ThreadItemsListAnchor),
9576}
9577
9578/// An exclusive item position within the requested visible turn
9579/// (`openai/codex@main` de9e78e3).
9580#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9581#[serde(tag = "type", rename_all = "camelCase")]
9582pub enum ThreadItemsListAnchor {
9583    Item {
9584        #[serde(rename = "itemId")]
9585        item_id: String,
9586    },
9587}
9588
9589/// Response to `thread/items/list` (0.148 upstream).
9590#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9591#[serde(rename_all = "camelCase")]
9592pub struct ThreadItemsListResponse {
9593    #[serde(
9594        rename = "backwardsCursor",
9595        default,
9596        skip_serializing_if = "Option::is_none"
9597    )]
9598    pub backwards_cursor: Option<String>,
9599    #[serde(default)]
9600    pub data: Vec<ThreadItemEntry>,
9601    #[serde(
9602        rename = "nextCursor",
9603        default,
9604        skip_serializing_if = "Option::is_none"
9605    )]
9606    pub next_cursor: Option<String>,
9607}
9608
9609/// EXPERIMENTAL upstream — a thread-scoped realtime item in the canonical
9610/// timeline (0.148). Top-level identity fields are camelCase on the wire
9611/// while variant payload fields are snake_case; mirrored exactly.
9612#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9613pub struct ThreadRealtimeItem {
9614    #[serde(default)]
9615    pub id: String,
9616    #[serde(rename = "realtimeSessionId", default)]
9617    pub realtime_session_id: String,
9618    /// Canonical observation time in Unix milliseconds for eligible voice
9619    /// calls.
9620    #[serde(
9621        rename = "observedAtMs",
9622        default,
9623        skip_serializing_if = "Option::is_none"
9624    )]
9625    pub observed_at_ms: Option<i64>,
9626    #[serde(flatten)]
9627    pub detail: ThreadRealtimeItemDetail,
9628}
9629
9630/// The `type`-tagged payload of a [`ThreadRealtimeItem`].
9631#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9632#[serde(tag = "type", rename_all = "camelCase")]
9633pub enum ThreadRealtimeItemDetail {
9634    #[serde(rename = "realtimeSessionStarted")]
9635    RealtimeSessionStarted,
9636    /// A sealed frame of one or more channel payloads sharing one ID,
9637    /// observation time, and seal. Persisted reads keep this shape; live and
9638    /// mixed timeline APIs present speech as `transcriptSegment`.
9639    #[serde(rename = "frame")]
9640    Frame {
9641        channels: ThreadRealtimeFrameChannels,
9642    },
9643    #[serde(rename = "transcriptSegment")]
9644    TranscriptSegment {
9645        role: ThreadRealtimeTranscriptRole,
9646        text: String,
9647    },
9648    #[serde(rename = "bemItemPromoted")]
9649    BemItemPromoted {
9650        item_id: String,
9651        presentation: ThreadRealtimeBemItemPresentation,
9652        turn_id: String,
9653    },
9654    #[serde(rename = "realtimeSessionClosed")]
9655    RealtimeSessionClosed {
9656        outcome: ThreadRealtimeSessionOutcome,
9657    },
9658    /// A realtime handoff was accepted as input to an agent turn.
9659    #[serde(rename = "turnInputAccepted")]
9660    TurnInputAccepted {
9661        handoff_id: String,
9662        input: String,
9663        input_item_id: String,
9664        mode: ThreadRealtimeHandoffMode,
9665        source_event_ids: Vec<String>,
9666        turn_id: String,
9667    },
9668    /// Input pending at session end was saved for a later turn.
9669    #[serde(rename = "sessionEndInputSaved")]
9670    SessionEndInputSaved {
9671        input: String,
9672        input_item_id: String,
9673        source_event_ids: Vec<String>,
9674    },
9675}
9676
9677/// EXPERIMENTAL upstream — channel payloads of a realtime `frame` item. A
9678/// frame holds at most one payload per channel; V1 requires its only
9679/// channel, `voice_transcript`.
9680#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
9681pub struct ThreadRealtimeFrameChannels {
9682    pub voice_transcript: ThreadRealtimeVoiceTranscript,
9683}
9684
9685/// EXPERIMENTAL upstream — the `voice_transcript` channel of a realtime frame.
9686#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
9687pub struct ThreadRealtimeVoiceTranscript {
9688    pub role: ThreadRealtimeTranscriptRole,
9689    pub text: String,
9690}
9691
9692/// EXPERIMENTAL upstream — whether a realtime handoff started a new turn or
9693/// steered an active one.
9694#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9695#[serde(rename_all = "camelCase")]
9696pub enum ThreadRealtimeHandoffMode {
9697    Start,
9698    Steer,
9699}
9700
9701/// EXPERIMENTAL upstream — one persisted realtime history entry at a
9702/// committed position (returned by the experimental `thread/realtime/list`).
9703#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9704pub struct ThreadRealtimeEntry {
9705    pub item: ThreadRealtimeItem,
9706    pub position: u64,
9707}
9708
9709/// EXPERIMENTAL upstream — sort order for persisted realtime history reads.
9710#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
9711#[serde(rename_all = "camelCase")]
9712pub enum ThreadRealtimeOrder {
9713    /// Sort by canonical observation time, then committed position.
9714    #[default]
9715    ObservedAt,
9716    /// Sort by committed position, including events sealed after older
9717    /// snapshots.
9718    Position,
9719}
9720
9721/// EXPERIMENTAL upstream — whether persisted realtime history is available
9722/// for a read.
9723#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9724#[serde(rename_all = "camelCase")]
9725pub enum ThreadRealtimeCoverage {
9726    Unsupported,
9727    Pending,
9728    Ready,
9729}
9730
9731/// EXPERIMENTAL upstream — how an existing agent item appears in a realtime
9732/// conversation (0.148).
9733#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9734#[serde(tag = "type", rename_all = "camelCase")]
9735pub enum ThreadRealtimeBemItemPresentation {
9736    #[serde(rename = "wholeItem")]
9737    WholeItem,
9738    #[serde(rename = "inlineMarkdown")]
9739    InlineMarkdown,
9740    #[serde(rename = "inlineVisualization")]
9741    InlineVisualization { index: u32 },
9742}
9743
9744/// EXPERIMENTAL upstream — `thread/realtime/item/started` params (0.148).
9745#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9746#[serde(rename_all = "camelCase")]
9747pub struct ThreadRealtimeItemStartedNotification {
9748    #[serde()]
9749    pub item: ThreadRealtimeItem,
9750    #[serde(rename = "threadId", default)]
9751    pub thread_id: String,
9752}
9753
9754/// EXPERIMENTAL upstream — `thread/realtime/item/completed` params (0.148).
9755#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9756#[serde(rename_all = "camelCase")]
9757pub struct ThreadRealtimeItemCompletedNotification {
9758    #[serde()]
9759    pub item: ThreadRealtimeItem,
9760    #[serde(rename = "threadId", default)]
9761    pub thread_id: String,
9762}
9763
9764/// EXPERIMENTAL upstream — `thread/realtime/item/transcript/delta` params:
9765/// text appended to an active realtime transcript item (0.148).
9766#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9767#[serde(rename_all = "camelCase")]
9768pub struct ThreadRealtimeItemTranscriptDeltaNotification {
9769    #[serde(default)]
9770    pub delta: String,
9771    #[serde(rename = "itemId", default)]
9772    pub item_id: String,
9773    #[serde(rename = "threadId", default)]
9774    pub thread_id: String,
9775}
9776
9777/// EXPERIMENTAL upstream — outcome of a closed realtime session (0.148).
9778#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9779pub enum ThreadRealtimeSessionOutcome {
9780    #[serde(rename = "ended")]
9781    Ended,
9782    #[serde(rename = "failed")]
9783    Failed,
9784}
9785
9786/// EXPERIMENTAL upstream — speaker role in a realtime transcript (0.148).
9787#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9788pub enum ThreadRealtimeTranscriptRole {
9789    #[serde(rename = "user")]
9790    User,
9791    #[serde(rename = "assistant")]
9792    Assistant,
9793}
9794
9795/// Params for `thread/revert` — replace a paginated thread's durable history
9796/// with the prefix before one turn; local file changes are untouched
9797/// (0.148 upstream).
9798#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9799#[serde(rename_all = "camelCase")]
9800pub struct ThreadRevertParams {
9801    /// Turn excluded from the replacement history, with every later turn.
9802    #[serde(rename = "beforeTurnId", default)]
9803    pub before_turn_id: String,
9804    #[serde(rename = "threadId", default)]
9805    pub thread_id: String,
9806}
9807
9808/// Response to `thread/revert` (0.148 upstream). `thread.turns` is always
9809/// empty; retained history hydrates through `thread/turns/list`.
9810#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9811#[serde(rename_all = "camelCase")]
9812pub struct ThreadRevertResponse {
9813    #[serde(
9814        rename = "itemsBackwardsCursor",
9815        default,
9816        skip_serializing_if = "Option::is_none"
9817    )]
9818    pub items_backwards_cursor: Option<String>,
9819    #[serde()]
9820    pub thread: Thread,
9821    #[serde(
9822        rename = "turnsBackwardsCursor",
9823        default,
9824        skip_serializing_if = "Option::is_none"
9825    )]
9826    pub turns_backwards_cursor: Option<String>,
9827}
9828
9829/// One thread matched by a `thread/search` query.
9830#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9831#[serde(rename_all = "camelCase")]
9832pub struct ThreadSearchResult {
9833    pub thread: Thread,
9834    #[serde(default)]
9835    pub snippet: String,
9836}
9837
9838/// `thread/search/partial` — a best-effort incremental batch for
9839/// `thread/search/stream` (experimental). Match `request_id` to the request on
9840/// this connection. Only a small subset of verified matches may be emitted;
9841/// rows are unique and arrive in discovery order, but may be dropped under
9842/// load or fall outside the final sorted page. Replace provisional rows with
9843/// the authoritative final response. No partials follow it or an error.
9844#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9845#[serde(rename_all = "camelCase")]
9846pub struct ThreadSearchPartialNotification {
9847    #[serde(rename = "requestId")]
9848    pub request_id: RequestId,
9849    #[serde(default)]
9850    pub data: Vec<ThreadSearchResult>,
9851}
9852
9853#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9854#[serde(rename_all = "camelCase")]
9855pub struct ThreadSection {
9856    #[serde(default, skip_serializing_if = "Option::is_none")]
9857    pub appearance: Option<ThreadSectionAppearance>,
9858    #[serde(default)]
9859    pub id: String,
9860    #[serde(default)]
9861    pub name: String,
9862}
9863
9864#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9865#[serde(rename_all = "camelCase")]
9866pub struct ThreadSectionAppearance {
9867    #[serde(default, skip_serializing_if = "Option::is_none")]
9868    pub color: Option<String>,
9869    #[serde(default, skip_serializing_if = "Option::is_none")]
9870    pub icon: Option<String>,
9871}
9872
9873#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9874#[serde(rename_all = "camelCase")]
9875pub struct ThreadSectionCreateParams {
9876    #[serde(default, skip_serializing_if = "Option::is_none")]
9877    pub appearance: Option<ThreadSectionAppearance>,
9878    #[serde(default)]
9879    pub name: String,
9880}
9881
9882#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9883#[serde(rename_all = "camelCase")]
9884pub struct ThreadSectionCreateResponse {
9885    #[serde()]
9886    pub section: ThreadSection,
9887}
9888
9889#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9890#[serde(rename_all = "camelCase")]
9891pub struct ThreadSectionDeleteParams {
9892    #[serde(rename = "sectionId", default)]
9893    pub section_id: String,
9894}
9895
9896#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9897#[serde(rename_all = "camelCase")]
9898pub struct ThreadSectionDeleteResponse {
9899    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9900    pub extra: serde_json::Map<String, Value>,
9901}
9902
9903#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9904#[serde(rename_all = "camelCase")]
9905pub struct ThreadSectionListParams {
9906    #[serde(default, skip_serializing_if = "Option::is_none")]
9907    pub cursor: Option<String>,
9908    #[serde(default, skip_serializing_if = "Option::is_none")]
9909    pub limit: Option<i64>,
9910}
9911
9912#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9913#[serde(rename_all = "camelCase")]
9914pub struct ThreadSectionListResponse {
9915    #[serde(default)]
9916    pub data: Vec<ThreadSection>,
9917    #[serde(
9918        rename = "nextCursor",
9919        default,
9920        skip_serializing_if = "Option::is_none"
9921    )]
9922    pub next_cursor: Option<String>,
9923}
9924
9925#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9926#[serde(rename_all = "camelCase")]
9927pub struct ThreadSectionMoveParams {
9928    #[serde(
9929        rename = "beforeThreadId",
9930        default,
9931        skip_serializing_if = "Option::is_none"
9932    )]
9933    pub before_thread_id: Option<String>,
9934    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
9935    pub section_id: Option<String>,
9936    #[serde(rename = "threadId", default)]
9937    pub thread_id: String,
9938}
9939
9940#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9941#[serde(rename_all = "camelCase")]
9942pub struct ThreadSectionMoveResponse {
9943    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9944    pub extra: serde_json::Map<String, Value>,
9945}
9946
9947#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9948#[serde(rename_all = "camelCase")]
9949pub struct ThreadSectionUpdateParams {
9950    #[serde(default, skip_serializing_if = "Option::is_none")]
9951    pub appearance: Option<ThreadSectionAppearance>,
9952    #[serde(default)]
9953    pub name: String,
9954    #[serde(rename = "sectionId", default)]
9955    pub section_id: String,
9956}
9957
9958#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9959#[serde(rename_all = "camelCase")]
9960pub struct ThreadSectionUpdateResponse {
9961    #[serde()]
9962    pub section: ThreadSection,
9963}
9964
9965#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9966#[serde(rename_all = "camelCase")]
9967pub struct ThreadSetNameParams {
9968    #[serde(default)]
9969    pub name: String,
9970    #[serde(rename = "threadId", default)]
9971    pub thread_id: String,
9972}
9973
9974#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9975#[serde(rename_all = "camelCase")]
9976pub struct ThreadSetNameResponse {
9977    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9978    pub extra: serde_json::Map<String, Value>,
9979}
9980
9981#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9982#[serde(rename_all = "camelCase")]
9983pub struct ThreadSettings {
9984    #[serde(
9985        rename = "activePermissionProfile",
9986        default,
9987        skip_serializing_if = "Option::is_none"
9988    )]
9989    pub active_permission_profile: Option<ActivePermissionProfile>,
9990    #[serde(rename = "approvalPolicy")]
9991    pub approval_policy: AskForApproval,
9992    #[serde(rename = "approvalsReviewer")]
9993    pub approvals_reviewer: ApprovalsReviewer,
9994    #[serde(rename = "collaborationMode")]
9995    pub collaboration_mode: CollaborationMode,
9996    #[serde()]
9997    pub cwd: AbsolutePathBuf,
9998    /// Saved list of disabled plugin IDs. Does not yet filter plugin
9999    /// capabilities.
10000    #[serde(rename = "disabledPluginIds", default)]
10001    pub disabled_plugin_ids: Vec<String>,
10002    #[serde(default, skip_serializing_if = "Option::is_none")]
10003    pub effort: Option<ReasoningEffort>,
10004    #[serde(default)]
10005    pub model: String,
10006    #[serde(rename = "modelProvider", default)]
10007    pub model_provider: String,
10008    #[serde(default, skip_serializing_if = "Option::is_none")]
10009    pub personality: Option<Personality>,
10010    #[serde(rename = "sandboxPolicy")]
10011    pub sandbox_policy: SandboxPolicy,
10012    #[serde(
10013        rename = "serviceTier",
10014        default,
10015        skip_serializing_if = "Option::is_none"
10016    )]
10017    pub service_tier: Option<String>,
10018    #[serde(default, skip_serializing_if = "Option::is_none")]
10019    pub summary: Option<ReasoningSummary>,
10020}
10021
10022#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10023#[serde(rename_all = "camelCase")]
10024pub struct ThreadSettingsUpdatedNotification {
10025    #[serde(rename = "threadId", default)]
10026    pub thread_id: String,
10027    #[serde(rename = "threadSettings")]
10028    pub thread_settings: ThreadSettings,
10029}
10030
10031#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10032#[serde(rename_all = "camelCase")]
10033pub struct ThreadShellCommandParams {
10034    #[serde(default)]
10035    pub command: String,
10036    #[serde(rename = "threadId", default)]
10037    pub thread_id: String,
10038    /// Maximum execution time in ms; defaults to one hour when omitted.
10039    /// Zero requests an immediate timeout, not unlimited (0.148 upstream).
10040    #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
10041    pub timeout_ms: Option<i64>,
10042}
10043
10044#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10045#[serde(rename_all = "camelCase")]
10046pub struct ThreadShellCommandResponse {
10047    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
10048    pub extra: serde_json::Map<String, Value>,
10049}
10050
10051#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10052pub enum ThreadSortKey {
10053    #[serde(rename = "created_at")]
10054    Created_at,
10055    #[serde(rename = "updated_at")]
10056    Updated_at,
10057    #[serde(rename = "recency_at")]
10058    Recency_at,
10059    #[serde(rename = "section_position")]
10060    Section_position,
10061}
10062
10063#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
10064#[serde(transparent)]
10065pub struct ThreadSource(pub String);
10066
10067#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10068pub enum ThreadSourceKind {
10069    #[serde(rename = "cli")]
10070    Cli,
10071    #[serde(rename = "vscode")]
10072    Vscode,
10073    #[serde(rename = "exec")]
10074    Exec,
10075    #[serde(rename = "appServer")]
10076    AppServer,
10077    #[serde(rename = "subAgent")]
10078    SubAgent,
10079    #[serde(rename = "subAgentReview")]
10080    SubAgentReview,
10081    #[serde(rename = "subAgentCompact")]
10082    SubAgentCompact,
10083    #[serde(rename = "subAgentThreadSpawn")]
10084    SubAgentThreadSpawn,
10085    #[serde(rename = "subAgentOther")]
10086    SubAgentOther,
10087    #[serde(rename = "unknown")]
10088    Unknown,
10089}
10090
10091#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10092#[serde(rename_all = "camelCase")]
10093pub struct ThreadStartParams {
10094    #[serde(
10095        rename = "approvalPolicy",
10096        default,
10097        skip_serializing_if = "Option::is_none"
10098    )]
10099    pub approval_policy: Option<AskForApproval>,
10100    #[serde(
10101        rename = "approvalsReviewer",
10102        default,
10103        skip_serializing_if = "Option::is_none"
10104    )]
10105    pub approvals_reviewer: Option<ApprovalsReviewer>,
10106    #[serde(
10107        rename = "baseInstructions",
10108        default,
10109        skip_serializing_if = "Option::is_none"
10110    )]
10111    pub base_instructions: Option<String>,
10112    #[serde(default, skip_serializing_if = "Option::is_none")]
10113    pub config: Option<Value>,
10114    #[serde(default, skip_serializing_if = "Option::is_none")]
10115    pub cwd: Option<String>,
10116    #[serde(
10117        rename = "developerInstructions",
10118        default,
10119        skip_serializing_if = "Option::is_none"
10120    )]
10121    pub developer_instructions: Option<String>,
10122    #[serde(default, skip_serializing_if = "Option::is_none")]
10123    pub ephemeral: Option<bool>,
10124    #[serde(default, skip_serializing_if = "Option::is_none")]
10125    pub model: Option<String>,
10126    #[serde(
10127        rename = "modelProvider",
10128        default,
10129        skip_serializing_if = "Option::is_none"
10130    )]
10131    pub model_provider: Option<String>,
10132    #[serde(default, skip_serializing_if = "Option::is_none")]
10133    pub personality: Option<Personality>,
10134    #[serde(default, skip_serializing_if = "Option::is_none")]
10135    pub sandbox: Option<SandboxMode>,
10136    #[serde(
10137        rename = "serviceName",
10138        default,
10139        skip_serializing_if = "Option::is_none"
10140    )]
10141    pub service_name: Option<String>,
10142    #[serde(
10143        rename = "serviceTier",
10144        default,
10145        skip_serializing_if = "Option::is_none"
10146    )]
10147    pub service_tier: Option<String>,
10148    #[serde(
10149        rename = "sessionStartSource",
10150        default,
10151        skip_serializing_if = "Option::is_none"
10152    )]
10153    pub session_start_source: Option<ThreadStartSource>,
10154    #[serde(
10155        rename = "threadSource",
10156        default,
10157        skip_serializing_if = "Option::is_none"
10158    )]
10159    pub thread_source: Option<ThreadSource>,
10160}
10161
10162#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10163#[serde(rename_all = "camelCase")]
10164pub struct ThreadStartResponse {
10165    #[serde(rename = "approvalPolicy")]
10166    pub approval_policy: AskForApproval,
10167    #[serde(rename = "approvalsReviewer", default)]
10168    pub approvals_reviewer: Value,
10169    #[serde()]
10170    pub cwd: AbsolutePathBuf,
10171    /// Saved list of disabled plugin IDs. Does not yet filter plugin
10172    /// capabilities.
10173    #[serde(rename = "disabledPluginIds", default)]
10174    pub disabled_plugin_ids: Vec<String>,
10175    #[serde(
10176        rename = "instructionSources",
10177        default,
10178        skip_serializing_if = "Option::is_none"
10179    )]
10180    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
10181    #[serde(default)]
10182    pub model: String,
10183    #[serde(rename = "modelProvider", default)]
10184    pub model_provider: String,
10185    #[serde(
10186        rename = "reasoningEffort",
10187        default,
10188        skip_serializing_if = "Option::is_none"
10189    )]
10190    pub reasoning_effort: Option<ReasoningEffort>,
10191    #[serde(default)]
10192    pub sandbox: Value,
10193    #[serde(
10194        rename = "serviceTier",
10195        default,
10196        skip_serializing_if = "Option::is_none"
10197    )]
10198    pub service_tier: Option<String>,
10199    #[serde()]
10200    pub thread: Thread,
10201}
10202
10203#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10204pub enum ThreadStartSource {
10205    #[serde(rename = "startup")]
10206    Startup,
10207    #[serde(rename = "clear")]
10208    Clear,
10209}
10210
10211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10212#[serde(rename_all = "camelCase")]
10213pub struct ThreadStartedNotification {
10214    #[serde()]
10215    pub thread: Thread,
10216}
10217
10218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10219#[serde(tag = "type", rename_all = "camelCase")]
10220pub enum ThreadStatus {
10221    #[serde(rename = "notLoaded")]
10222    NotLoaded,
10223    Idle,
10224    #[serde(rename = "systemError")]
10225    SystemError,
10226    Active {
10227        #[serde(rename = "activeFlags")]
10228        active_flags: Vec<ThreadActiveFlag>,
10229    },
10230}
10231
10232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10233#[serde(rename_all = "camelCase")]
10234pub struct ThreadStatusChangedNotification {
10235    #[serde()]
10236    pub status: ThreadStatus,
10237    #[serde(rename = "threadId", default)]
10238    pub thread_id: String,
10239}
10240
10241#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10242#[serde(rename_all = "camelCase")]
10243pub struct ThreadTokenUsage {
10244    #[serde()]
10245    pub last: TokenUsageBreakdown,
10246    #[serde(
10247        rename = "modelContextWindow",
10248        default,
10249        skip_serializing_if = "Option::is_none"
10250    )]
10251    pub model_context_window: Option<i64>,
10252    #[serde()]
10253    pub total: TokenUsageBreakdown,
10254}
10255
10256#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10257#[serde(rename_all = "camelCase")]
10258pub struct ThreadTokenUsageUpdatedNotification {
10259    #[serde(rename = "threadId", default)]
10260    pub thread_id: String,
10261    #[serde(rename = "tokenUsage")]
10262    pub token_usage: ThreadTokenUsage,
10263    #[serde(rename = "turnId", default)]
10264    pub turn_id: String,
10265}
10266
10267#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10268#[serde(rename_all = "camelCase")]
10269pub struct ThreadUnarchiveParams {
10270    #[serde(rename = "threadId", default)]
10271    pub thread_id: String,
10272}
10273
10274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10275#[serde(rename_all = "camelCase")]
10276pub struct ThreadUnarchiveResponse {
10277    #[serde()]
10278    pub thread: Thread,
10279}
10280
10281#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10282#[serde(rename_all = "camelCase")]
10283pub struct ThreadUnarchivedNotification {
10284    #[serde(rename = "threadId", default)]
10285    pub thread_id: String,
10286}
10287
10288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10289#[serde(tag = "type", rename_all = "camelCase")]
10290pub enum ThreadUnreadPosition {
10291    /// Explicitly marked unread, including when the thread has no turns.
10292    #[serde(rename = "threadStart")]
10293    ThreadStart,
10294    /// The earliest completed result needing attention.
10295    Turn {
10296        #[serde(rename = "turnId")]
10297        turn_id: String,
10298    },
10299}
10300
10301/// EXPERIMENTAL upstream — one item or turn boundary in canonical rollout
10302/// order (0.148). Wire quirk mirrored exactly: the `item` variant uses
10303/// camelCase `turnId` while the turn-boundary variants use snake_case
10304/// `turn_id`/`started_at`/`completed_at`/`duration_ms`.
10305#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10306#[serde(tag = "type", rename_all = "camelCase")]
10307#[allow(clippy::large_enum_variant)] // transient per-entry wire value, not stored in bulk
10308pub enum ThreadTimelineEntry {
10309    Item {
10310        item: ThreadItem,
10311        position: u64,
10312        #[serde(rename = "turnId")]
10313        turn_id: String,
10314    },
10315    Realtime {
10316        item: ThreadRealtimeItem,
10317        position: u64,
10318    },
10319    TurnStarted {
10320        position: u64,
10321        #[serde(default, skip_serializing_if = "Option::is_none")]
10322        started_at: Option<i64>,
10323        turn_id: String,
10324    },
10325    TurnCompleted {
10326        #[serde(default, skip_serializing_if = "Option::is_none")]
10327        completed_at: Option<i64>,
10328        #[serde(default, skip_serializing_if = "Option::is_none")]
10329        duration_ms: Option<i64>,
10330        #[serde(default, skip_serializing_if = "Option::is_none")]
10331        error: Option<TurnError>,
10332        position: u64,
10333        #[serde(default, skip_serializing_if = "Option::is_none")]
10334        started_at: Option<i64>,
10335        status: TurnStatus,
10336        turn_id: String,
10337    },
10338}
10339
10340/// Params for `thread/turns/list` — paginated turn hydration (0.148 upstream).
10341#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10342#[serde(rename_all = "camelCase")]
10343pub struct ThreadTurnsListParams {
10344    #[serde(default, skip_serializing_if = "Option::is_none")]
10345    pub cursor: Option<String>,
10346    /// How much item detail to include per turn; defaults to summary.
10347    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
10348    pub items_view: Option<TurnItemsView>,
10349    #[serde(default, skip_serializing_if = "Option::is_none")]
10350    pub limit: Option<u32>,
10351    #[serde(
10352        rename = "sortDirection",
10353        default,
10354        skip_serializing_if = "Option::is_none"
10355    )]
10356    pub sort_direction: Option<SortDirection>,
10357    #[serde(rename = "threadId", default)]
10358    pub thread_id: String,
10359}
10360
10361/// Response to `thread/turns/list` (0.148 upstream).
10362#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10363#[serde(rename_all = "camelCase")]
10364pub struct ThreadTurnsListResponse {
10365    #[serde(
10366        rename = "backwardsCursor",
10367        default,
10368        skip_serializing_if = "Option::is_none"
10369    )]
10370    pub backwards_cursor: Option<String>,
10371    #[serde(default)]
10372    pub data: Vec<Turn>,
10373    #[serde(
10374        rename = "nextCursor",
10375        default,
10376        skip_serializing_if = "Option::is_none"
10377    )]
10378    pub next_cursor: Option<String>,
10379}
10380
10381#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10382#[serde(rename_all = "camelCase")]
10383pub struct ThreadUnsubscribeParams {
10384    #[serde(rename = "threadId", default)]
10385    pub thread_id: String,
10386}
10387
10388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10389#[serde(rename_all = "camelCase")]
10390pub struct ThreadUnsubscribeResponse {
10391    #[serde()]
10392    pub status: ThreadUnsubscribeStatus,
10393}
10394
10395#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10396pub enum ThreadUnsubscribeStatus {
10397    #[serde(rename = "notLoaded")]
10398    NotLoaded,
10399    #[serde(rename = "notSubscribed")]
10400    NotSubscribed,
10401    #[serde(rename = "unsubscribed")]
10402    Unsubscribed,
10403}
10404
10405#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10406#[serde(rename_all = "camelCase")]
10407pub struct TokenUsageBreakdown {
10408    #[serde(
10409        rename = "cacheWriteInputTokens",
10410        default,
10411        skip_serializing_if = "Option::is_none"
10412    )]
10413    pub cache_write_input_tokens: Option<i64>,
10414    #[serde(rename = "cachedInputTokens", default)]
10415    pub cached_input_tokens: i64,
10416    #[serde(rename = "inputTokens", default)]
10417    pub input_tokens: i64,
10418    #[serde(rename = "outputTokens", default)]
10419    pub output_tokens: i64,
10420    #[serde(rename = "reasoningOutputTokens", default)]
10421    pub reasoning_output_tokens: i64,
10422    #[serde(rename = "totalTokens", default)]
10423    pub total_tokens: i64,
10424}
10425
10426#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10427#[serde(rename_all = "camelCase")]
10428pub struct Tool {
10429    #[serde(default, skip_serializing_if = "Option::is_none")]
10430    pub _meta: Option<Value>,
10431    #[serde(default, skip_serializing_if = "Option::is_none")]
10432    pub annotations: Option<Value>,
10433    #[serde(default, skip_serializing_if = "Option::is_none")]
10434    pub description: Option<String>,
10435    #[serde(default, skip_serializing_if = "Option::is_none")]
10436    pub icons: Option<Vec<Value>>,
10437    #[serde(rename = "inputSchema", default)]
10438    pub input_schema: Value,
10439    #[serde(default)]
10440    pub name: String,
10441    #[serde(
10442        rename = "outputSchema",
10443        default,
10444        skip_serializing_if = "Option::is_none"
10445    )]
10446    pub output_schema: Option<Value>,
10447    #[serde(default, skip_serializing_if = "Option::is_none")]
10448    pub title: Option<String>,
10449}
10450
10451#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10452#[serde(rename_all = "camelCase")]
10453pub struct ToolRequestUserInputAnswer {
10454    #[serde(default)]
10455    pub answers: Vec<String>,
10456}
10457
10458#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10459#[serde(rename_all = "camelCase")]
10460pub struct ToolRequestUserInputOption {
10461    #[serde(default)]
10462    pub description: String,
10463    #[serde(default)]
10464    pub label: String,
10465}
10466
10467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10468#[serde(rename_all = "camelCase")]
10469pub struct ToolRequestUserInputParams {
10470    #[serde(
10471        rename = "autoResolutionMs",
10472        default,
10473        skip_serializing_if = "Option::is_none"
10474    )]
10475    pub auto_resolution_ms: Option<i64>,
10476    #[serde(rename = "isBlocking", default)]
10477    pub is_blocking: bool,
10478    #[serde(rename = "itemId", default)]
10479    pub item_id: String,
10480    #[serde(default)]
10481    pub questions: Vec<ToolRequestUserInputQuestion>,
10482    #[serde(rename = "threadId", default)]
10483    pub thread_id: String,
10484    #[serde(rename = "turnId", default)]
10485    pub turn_id: String,
10486}
10487
10488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10489#[serde(rename_all = "camelCase")]
10490pub struct ToolRequestUserInputQuestion {
10491    #[serde(default)]
10492    pub header: String,
10493    #[serde(default)]
10494    pub id: String,
10495    #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
10496    pub is_other: Option<bool>,
10497    #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
10498    pub is_secret: Option<bool>,
10499    #[serde(default, skip_serializing_if = "Option::is_none")]
10500    pub options: Option<Vec<ToolRequestUserInputOption>>,
10501    #[serde(default)]
10502    pub question: String,
10503}
10504
10505#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10506#[serde(rename_all = "camelCase")]
10507pub struct ToolRequestUserInputResponse {
10508    #[serde(default)]
10509    pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
10510}
10511
10512#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10513#[serde(rename_all = "camelCase")]
10514pub struct ToolsV2 {
10515    #[serde(default, skip_serializing_if = "Option::is_none")]
10516    pub web_search: Option<WebSearchToolConfig>,
10517}
10518
10519#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10520#[serde(rename_all = "camelCase")]
10521pub struct Turn {
10522    #[serde(
10523        rename = "completedAt",
10524        default,
10525        skip_serializing_if = "Option::is_none"
10526    )]
10527    pub completed_at: Option<i64>,
10528    #[serde(
10529        rename = "durationMs",
10530        default,
10531        skip_serializing_if = "Option::is_none"
10532    )]
10533    pub duration_ms: Option<i64>,
10534    #[serde(default, skip_serializing_if = "Option::is_none")]
10535    pub error: Option<TurnError>,
10536    #[serde(default)]
10537    pub id: String,
10538    #[serde(default)]
10539    pub items: Vec<ThreadItem>,
10540    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
10541    pub items_view: Option<Value>,
10542    /// ID of the first turn in the chain of work that led to this turn. Pass
10543    /// this as `rootTurnId` when starting work on behalf of this turn. May be
10544    /// null in older history or a `review/start` response.
10545    #[serde(
10546        rename = "rootTurnId",
10547        default,
10548        skip_serializing_if = "Option::is_none"
10549    )]
10550    pub root_turn_id: Option<String>,
10551    #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
10552    pub started_at: Option<i64>,
10553    #[serde()]
10554    pub status: TurnStatus,
10555}
10556
10557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10558#[serde(rename_all = "camelCase")]
10559pub struct TurnCompletedNotification {
10560    #[serde(rename = "threadId", default)]
10561    pub thread_id: String,
10562    #[serde()]
10563    pub turn: Turn,
10564}
10565
10566#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10567#[serde(rename_all = "camelCase")]
10568pub struct TurnDiffUpdatedNotification {
10569    #[serde(default)]
10570    pub diff: String,
10571    #[serde(rename = "threadId", default)]
10572    pub thread_id: String,
10573    #[serde(rename = "turnId", default)]
10574    pub turn_id: String,
10575}
10576
10577#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10578#[serde(rename_all = "camelCase")]
10579pub struct TurnError {
10580    #[serde(
10581        rename = "additionalDetails",
10582        default,
10583        skip_serializing_if = "Option::is_none"
10584    )]
10585    pub additional_details: Option<String>,
10586    #[serde(
10587        rename = "codexErrorInfo",
10588        default,
10589        skip_serializing_if = "Option::is_none"
10590    )]
10591    pub codex_error_info: Option<CodexErrorInfo>,
10592    #[serde(default)]
10593    pub message: String,
10594    /// Public explanation and continuation instruction for a misalignment
10595    /// block (0.148 upstream).
10596    #[serde(default, skip_serializing_if = "Option::is_none")]
10597    pub misalignment: Option<MisalignmentErrorDetails>,
10598}
10599
10600#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10601#[serde(rename_all = "camelCase")]
10602pub struct TurnInterruptParams {
10603    #[serde(rename = "threadId", default)]
10604    pub thread_id: String,
10605    #[serde(rename = "turnId", default)]
10606    pub turn_id: String,
10607}
10608
10609#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10610#[serde(rename_all = "camelCase")]
10611pub struct TurnInterruptResponse {
10612    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
10613    pub extra: serde_json::Map<String, Value>,
10614}
10615
10616#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
10617pub enum TurnItemsView {
10618    #[serde(rename = "notLoaded")]
10619    NotLoaded,
10620    #[serde(rename = "summary")]
10621    Summary,
10622    #[serde(rename = "full")]
10623    Full,
10624}
10625
10626#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10627#[serde(rename_all = "camelCase")]
10628pub struct TurnModerationMetadataNotification {
10629    #[serde(default)]
10630    pub metadata: Value,
10631    #[serde(rename = "threadId", default)]
10632    pub thread_id: String,
10633    #[serde(rename = "turnId", default)]
10634    pub turn_id: String,
10635}
10636
10637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10638#[serde(rename_all = "camelCase")]
10639pub struct TurnPlanStep {
10640    #[serde()]
10641    pub status: TurnPlanStepStatus,
10642    #[serde(default)]
10643    pub step: String,
10644}
10645
10646#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10647pub enum TurnPlanStepStatus {
10648    #[serde(rename = "pending")]
10649    Pending,
10650    #[serde(rename = "inProgress")]
10651    InProgress,
10652    #[serde(rename = "completed")]
10653    Completed,
10654}
10655
10656#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10657#[serde(rename_all = "camelCase")]
10658pub struct TurnPlanUpdatedNotification {
10659    #[serde(default, skip_serializing_if = "Option::is_none")]
10660    pub explanation: Option<String>,
10661    #[serde(default)]
10662    pub plan: Vec<TurnPlanStep>,
10663    #[serde(rename = "threadId", default)]
10664    pub thread_id: String,
10665    #[serde(rename = "turnId", default)]
10666    pub turn_id: String,
10667}
10668
10669#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10670#[serde(rename_all = "camelCase")]
10671pub struct TurnStartParams {
10672    #[serde(
10673        rename = "approvalPolicy",
10674        default,
10675        skip_serializing_if = "Option::is_none"
10676    )]
10677    pub approval_policy: Option<AskForApproval>,
10678    #[serde(
10679        rename = "approvalsReviewer",
10680        default,
10681        skip_serializing_if = "Option::is_none"
10682    )]
10683    pub approvals_reviewer: Option<ApprovalsReviewer>,
10684    #[serde(
10685        rename = "clientUserMessageId",
10686        default,
10687        skip_serializing_if = "Option::is_none"
10688    )]
10689    pub client_user_message_id: Option<String>,
10690    #[serde(default, skip_serializing_if = "Option::is_none")]
10691    pub cwd: Option<String>,
10692    /// Replace this thread's disabled plugin IDs. Omitted/null preserves the
10693    /// list; `[]` clears it.
10694    #[serde(
10695        rename = "disabledPluginIds",
10696        default,
10697        skip_serializing_if = "Option::is_none"
10698    )]
10699    pub disabled_plugin_ids: Option<Vec<String>>,
10700    #[serde(default, skip_serializing_if = "Option::is_none")]
10701    pub effort: Option<ReasoningEffort>,
10702    #[serde(default)]
10703    pub input: Vec<UserInput>,
10704    #[serde(default, skip_serializing_if = "Option::is_none")]
10705    pub model: Option<String>,
10706    #[serde(
10707        rename = "outputSchema",
10708        default,
10709        skip_serializing_if = "Option::is_none"
10710    )]
10711    pub output_schema: Option<Value>,
10712    /// ID of the turn that caused this new turn to start. Set this when
10713    /// starting work on behalf of another turn; leave unset for work started
10714    /// directly by the user. Ignored when adding input to an active turn.
10715    #[serde(
10716        rename = "parentTurnId",
10717        default,
10718        skip_serializing_if = "Option::is_none"
10719    )]
10720    pub parent_turn_id: Option<String>,
10721    #[serde(default, skip_serializing_if = "Option::is_none")]
10722    pub personality: Option<Personality>,
10723    /// ID of the first turn in the chain of work that led to this new turn.
10724    /// When setting `parent_turn_id`, set this to the parent turn's
10725    /// `root_turn_id` when known; if omitted, the new turn becomes its own
10726    /// root. Ignored when adding input to an active turn.
10727    #[serde(
10728        rename = "rootTurnId",
10729        default,
10730        skip_serializing_if = "Option::is_none"
10731    )]
10732    pub root_turn_id: Option<String>,
10733    #[serde(
10734        rename = "sandboxPolicy",
10735        default,
10736        skip_serializing_if = "Option::is_none"
10737    )]
10738    pub sandbox_policy: Option<SandboxPolicy>,
10739    #[serde(
10740        rename = "serviceTier",
10741        default,
10742        skip_serializing_if = "Option::is_none"
10743    )]
10744    pub service_tier: Option<String>,
10745    /// One-turn service-tier override; `"default"` for standard speed.
10746    /// Omitted or null inherits the thread's tier (0.148 upstream).
10747    #[serde(
10748        rename = "serviceTierForTurn",
10749        default,
10750        skip_serializing_if = "Option::is_none"
10751    )]
10752    pub service_tier_for_turn: Option<String>,
10753    #[serde(default, skip_serializing_if = "Option::is_none")]
10754    pub summary: Option<ReasoningSummary>,
10755    #[serde(rename = "threadId", default)]
10756    pub thread_id: String,
10757    /// Pre-computed tool output to inject when starting the turn
10758    /// (0.148 upstream).
10759    #[serde(
10760        rename = "toolOutput",
10761        default,
10762        skip_serializing_if = "Option::is_none"
10763    )]
10764    pub tool_output: Option<TurnToolOutput>,
10765    /// Optional source classification for the caller starting this turn;
10766    /// ignored when steering an already-active turn (0.148 upstream).
10767    #[serde(
10768        rename = "turnTrigger",
10769        default,
10770        skip_serializing_if = "Option::is_none"
10771    )]
10772    pub turn_trigger: Option<String>,
10773}
10774
10775#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10776#[serde(rename_all = "camelCase")]
10777pub struct TurnStartResponse {
10778    #[serde()]
10779    pub turn: Turn,
10780}
10781
10782#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10783#[serde(rename_all = "camelCase")]
10784pub struct TurnStartedNotification {
10785    #[serde(rename = "threadId", default)]
10786    pub thread_id: String,
10787    #[serde()]
10788    pub turn: Turn,
10789}
10790
10791#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10792pub enum TurnStatus {
10793    #[serde(rename = "completed")]
10794    Completed,
10795    #[serde(rename = "interrupted")]
10796    Interrupted,
10797    #[serde(rename = "failed")]
10798    Failed,
10799    #[serde(rename = "inProgress")]
10800    InProgress,
10801}
10802
10803/// A pre-computed tool output supplied when starting a turn
10804/// (`TurnStartParams.toolOutput`, 0.148 upstream).
10805#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10806#[serde(rename_all = "camelCase")]
10807pub struct TurnToolOutput {
10808    #[serde(default)]
10809    pub name: String,
10810    #[serde(default, skip_serializing_if = "Option::is_none")]
10811    pub namespace: Option<String>,
10812    #[serde()]
10813    pub output: FunctionCallOutputBody,
10814    /// Requests retention of this output in the thread's model history
10815    /// (openai/codex#52686). Omitted from the wire when `false`.
10816    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
10817    pub retain: bool,
10818}
10819
10820#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10821#[serde(rename_all = "camelCase")]
10822pub struct TurnSteerParams {
10823    #[serde(
10824        rename = "clientUserMessageId",
10825        default,
10826        skip_serializing_if = "Option::is_none"
10827    )]
10828    pub client_user_message_id: Option<String>,
10829    #[serde(rename = "expectedTurnId", default)]
10830    pub expected_turn_id: String,
10831    #[serde(default)]
10832    pub input: Vec<UserInput>,
10833    #[serde(rename = "threadId", default)]
10834    pub thread_id: String,
10835}
10836
10837#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10838#[serde(rename_all = "camelCase")]
10839pub struct TurnSteerResponse {
10840    #[serde(rename = "turnId", default)]
10841    pub turn_id: String,
10842}
10843
10844#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10845#[serde(tag = "type", rename_all = "camelCase")]
10846pub enum UserInput {
10847    Text {
10848        text: String,
10849        #[serde(default, skip_serializing_if = "Option::is_none")]
10850        text_elements: Option<Vec<TextElement>>,
10851    },
10852    Image {
10853        #[serde(default, skip_serializing_if = "Option::is_none")]
10854        detail: Option<ImageDetail>,
10855        #[serde(flatten)]
10856        image: UserInputImageReference,
10857    },
10858    #[serde(rename = "localImage")]
10859    LocalImage {
10860        #[serde(default, skip_serializing_if = "Option::is_none")]
10861        detail: Option<ImageDetail>,
10862        path: String,
10863    },
10864    Audio {
10865        #[serde(flatten)]
10866        audio: UserInputAudioReference,
10867    },
10868    #[serde(rename = "localAudio")]
10869    LocalAudio {
10870        path: String,
10871    },
10872    Skill {
10873        name: String,
10874        path: String,
10875    },
10876    Mention {
10877        name: String,
10878        path: String,
10879    },
10880}
10881
10882/// How a [`UserInput::Image`] names its image: an inline `url` (data URL or
10883/// remote URL) or a previously uploaded `fileId`. Flattened into the variant;
10884/// untagged, so exactly one of the two keys is on the wire. Mirrors the v2
10885/// `ImageReference` upstream; the Responses-API twin used by tool outputs is
10886/// [`ImageReference`].
10887#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10888#[serde(untagged)]
10889pub enum UserInputImageReference {
10890    Inline {
10891        url: String,
10892    },
10893    File {
10894        #[serde(rename = "fileId")]
10895        file_id: String,
10896    },
10897}
10898
10899/// How a [`UserInput::Audio`] names its audio: an inline `url` or a
10900/// previously uploaded `fileId`. Flattened into the variant; untagged, so
10901/// exactly one of the two keys is on the wire. Mirrors the v2
10902/// `AudioReference` upstream; the Responses-API twin used by tool outputs is
10903/// [`AudioReference`].
10904#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10905#[serde(untagged)]
10906pub enum UserInputAudioReference {
10907    Inline {
10908        url: String,
10909    },
10910    File {
10911        #[serde(rename = "fileId")]
10912        file_id: String,
10913    },
10914}
10915
10916#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10917pub enum Verbosity {
10918    #[serde(rename = "low")]
10919    Low,
10920    #[serde(rename = "medium")]
10921    Medium,
10922    #[serde(rename = "high")]
10923    High,
10924}
10925
10926#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10927#[serde(rename_all = "camelCase")]
10928pub struct WarningNotification {
10929    #[serde(default)]
10930    pub message: String,
10931    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
10932    pub thread_id: Option<String>,
10933}
10934
10935#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10936#[serde(tag = "type", rename_all = "camelCase")]
10937pub enum WebSearchAction {
10938    Search {
10939        #[serde(default, skip_serializing_if = "Option::is_none")]
10940        queries: Option<Vec<String>>,
10941        #[serde(default, skip_serializing_if = "Option::is_none")]
10942        query: Option<String>,
10943    },
10944    #[serde(rename = "openPage")]
10945    OpenPage {
10946        #[serde(default, skip_serializing_if = "Option::is_none")]
10947        url: Option<String>,
10948    },
10949    #[serde(rename = "findInPage")]
10950    FindInPage {
10951        #[serde(default, skip_serializing_if = "Option::is_none")]
10952        pattern: Option<String>,
10953        #[serde(default, skip_serializing_if = "Option::is_none")]
10954        url: Option<String>,
10955    },
10956    Other,
10957}
10958
10959#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10960pub enum WebSearchContextSize {
10961    #[serde(rename = "low")]
10962    Low,
10963    #[serde(rename = "medium")]
10964    Medium,
10965    #[serde(rename = "high")]
10966    High,
10967}
10968
10969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10970#[serde(rename_all = "camelCase")]
10971pub struct WebSearchLocation {
10972    #[serde(default, skip_serializing_if = "Option::is_none")]
10973    pub city: Option<String>,
10974    #[serde(default, skip_serializing_if = "Option::is_none")]
10975    pub country: Option<String>,
10976    #[serde(default, skip_serializing_if = "Option::is_none")]
10977    pub region: Option<String>,
10978    #[serde(default, skip_serializing_if = "Option::is_none")]
10979    pub timezone: Option<String>,
10980}
10981
10982#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10983pub enum WebSearchMode {
10984    #[serde(rename = "disabled")]
10985    Disabled,
10986    #[serde(rename = "cached")]
10987    Cached,
10988    #[serde(rename = "indexed")]
10989    Indexed,
10990    #[serde(rename = "live")]
10991    Live,
10992}
10993
10994/// Web search provider preference selected by the resolved model catalog
10995/// entry.
10996#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10997pub enum WebSearchProvider {
10998    #[serde(rename = "standalone")]
10999    Standalone,
11000    #[serde(rename = "search_mcp")]
11001    SearchMcp,
11002}
11003
11004#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
11005#[serde(rename_all = "camelCase")]
11006pub struct WebSearchToolConfig {
11007    #[serde(default, skip_serializing_if = "Option::is_none")]
11008    pub allowed_domains: Option<Vec<String>>,
11009    #[serde(default, skip_serializing_if = "Option::is_none")]
11010    pub context_size: Option<WebSearchContextSize>,
11011    #[serde(default, skip_serializing_if = "Option::is_none")]
11012    pub location: Option<WebSearchLocation>,
11013}
11014
11015#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11016pub enum WindowsSandboxReadiness {
11017    #[serde(rename = "ready")]
11018    Ready,
11019    #[serde(rename = "notConfigured")]
11020    NotConfigured,
11021    #[serde(rename = "updateRequired")]
11022    UpdateRequired,
11023}
11024
11025#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11026#[serde(rename_all = "camelCase")]
11027pub struct WindowsSandboxReadinessResponse {
11028    #[serde()]
11029    pub status: WindowsSandboxReadiness,
11030}
11031
11032#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11033#[serde(rename_all = "camelCase")]
11034pub struct WindowsSandboxSetupCompletedNotification {
11035    #[serde(default, skip_serializing_if = "Option::is_none")]
11036    pub error: Option<String>,
11037    #[serde()]
11038    pub mode: WindowsSandboxSetupMode,
11039    #[serde(default)]
11040    pub success: bool,
11041}
11042
11043#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11044pub enum WindowsSandboxSetupMode {
11045    #[serde(rename = "elevated")]
11046    Elevated,
11047    #[serde(rename = "unelevated")]
11048    Unelevated,
11049}
11050
11051/// A Windows sandbox implementation a managed policy may allow
11052/// ([`ConfigRequirements::allowed_windows_sandbox_implementations`]). Grows
11053/// `mxc` beyond the two [`WindowsSandboxSetupMode`] values.
11054#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11055pub enum WindowsSandboxImplementation {
11056    #[serde(rename = "elevated")]
11057    Elevated,
11058    #[serde(rename = "unelevated")]
11059    Unelevated,
11060    #[serde(rename = "mxc")]
11061    Mxc,
11062}
11063
11064#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11065#[serde(rename_all = "camelCase")]
11066pub struct WindowsSandboxSetupStartParams {
11067    #[serde(default, skip_serializing_if = "Option::is_none")]
11068    pub cwd: Option<AbsolutePathBuf>,
11069    #[serde()]
11070    pub mode: WindowsSandboxSetupMode,
11071}
11072
11073#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
11074#[serde(rename_all = "camelCase")]
11075pub struct WindowsSandboxSetupStartResponse {
11076    #[serde(default)]
11077    pub started: bool,
11078}
11079
11080#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
11081#[serde(rename_all = "camelCase")]
11082pub struct WindowsWorldWritableWarningNotification {
11083    #[serde(rename = "extraCount", default)]
11084    pub extra_count: i64,
11085    #[serde(rename = "failedScan", default)]
11086    pub failed_scan: bool,
11087    #[serde(rename = "samplePaths", default)]
11088    pub sample_paths: Vec<String>,
11089}
11090
11091#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11092#[serde(rename_all = "camelCase")]
11093pub struct WorkspaceMessage {
11094    #[serde(
11095        rename = "archivedAt",
11096        default,
11097        skip_serializing_if = "Option::is_none"
11098    )]
11099    pub archived_at: Option<i64>,
11100    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
11101    pub created_at: Option<i64>,
11102    #[serde(rename = "messageBody", default)]
11103    pub message_body: String,
11104    #[serde(rename = "messageId", default)]
11105    pub message_id: String,
11106    #[serde(rename = "messageType")]
11107    pub message_type: WorkspaceMessageType,
11108}
11109
11110#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11111pub enum WorkspaceMessageType {
11112    #[serde(rename = "headline")]
11113    Headline,
11114    #[serde(rename = "announcement")]
11115    Announcement,
11116    #[serde(rename = "unknown")]
11117    Unknown,
11118}
11119
11120#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11121pub enum WriteStatus {
11122    #[serde(rename = "ok")]
11123    Ok,
11124    #[serde(rename = "okOverridden")]
11125    OkOverridden,
11126}