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