Skip to main content

codex_codes/protocol_generated/
types.rs

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