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

codex_codes/protocol_generated/
types.rs
