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