Skip to main content

codex_codes/protocol_generated/
types.rs

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