Skip to main content

codex_codes/protocol_generated/
types.rs

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