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