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

codex_codes/protocol_generated/
types.rs
