Skip to main content

codex_codes/protocol_generated/
types.rs

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