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