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