Skip to main content

codex_codes/protocol_generated/
types.rs

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