Skip to main content

codex_codes/protocol_generated/
types.rs

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