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