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