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

codex_codes/protocol_generated/
types.rs
