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