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(default, skip_serializing_if = "Option::is_none")]
2995    pub extensions: Option<Value>,
2996    #[serde(
2997        rename = "mcpServerOpenaiFormElicitation",
2998        default,
2999        skip_serializing_if = "Option::is_none"
3000    )]
3001    pub mcp_server_openai_form_elicitation: Option<bool>,
3002    #[serde(
3003        rename = "optOutNotificationMethods",
3004        default,
3005        skip_serializing_if = "Option::is_none"
3006    )]
3007    pub opt_out_notification_methods: Option<Vec<String>>,
3008    #[serde(
3009        rename = "requestAttestation",
3010        default,
3011        skip_serializing_if = "Option::is_none"
3012    )]
3013    pub request_attestation: Option<bool>,
3014}
3015
3016#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3017#[serde(rename_all = "camelCase")]
3018pub struct InitializeParams {
3019    #[serde(default, skip_serializing_if = "Option::is_none")]
3020    pub capabilities: Option<InitializeCapabilities>,
3021    #[serde(rename = "clientInfo")]
3022    pub client_info: ClientInfo,
3023}
3024
3025#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3026#[serde(rename_all = "camelCase")]
3027pub struct InitializeResponse {
3028    #[serde(rename = "codexHome", default)]
3029    pub codex_home: Value,
3030    #[serde(rename = "platformFamily", default)]
3031    pub platform_family: String,
3032    #[serde(rename = "platformOs", default)]
3033    pub platform_os: String,
3034    #[serde(rename = "userAgent", default)]
3035    pub user_agent: String,
3036}
3037
3038#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
3039pub enum InputModality {
3040    #[serde(rename = "text")]
3041    Text,
3042    #[serde(rename = "image")]
3043    Image,
3044    #[serde(rename = "audio")]
3045    Audio,
3046}
3047
3048#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3049#[serde(rename_all = "camelCase")]
3050pub struct InstalledApp {
3051    #[serde(default)]
3052    pub callable: bool,
3053    #[serde(default)]
3054    pub enabled: bool,
3055    #[serde(default)]
3056    pub id: String,
3057    #[serde(
3058        rename = "runtimeName",
3059        default,
3060        skip_serializing_if = "Option::is_none"
3061    )]
3062    pub runtime_name: Option<String>,
3063}
3064
3065#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3066#[serde(rename_all = "camelCase")]
3067pub struct ItemCompletedNotification {
3068    #[serde(rename = "completedAtMs", default)]
3069    pub completed_at_ms: i64,
3070    #[serde()]
3071    pub item: ThreadItem,
3072    #[serde(rename = "threadId", default)]
3073    pub thread_id: String,
3074    #[serde(rename = "turnId", default)]
3075    pub turn_id: String,
3076}
3077
3078#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3079#[serde(rename_all = "camelCase")]
3080pub struct ItemGuardianApprovalReviewCompletedNotification {
3081    #[serde()]
3082    pub action: GuardianApprovalReviewAction,
3083    #[serde(rename = "completedAtMs", default)]
3084    pub completed_at_ms: i64,
3085    #[serde(rename = "decisionSource")]
3086    pub decision_source: AutoReviewDecisionSource,
3087    #[serde()]
3088    pub review: GuardianApprovalReview,
3089    #[serde(rename = "reviewId", default)]
3090    pub review_id: String,
3091    #[serde(rename = "startedAtMs", default)]
3092    pub started_at_ms: i64,
3093    #[serde(
3094        rename = "targetItemId",
3095        default,
3096        skip_serializing_if = "Option::is_none"
3097    )]
3098    pub target_item_id: Option<String>,
3099    #[serde(rename = "threadId", default)]
3100    pub thread_id: String,
3101    #[serde(rename = "turnId", default)]
3102    pub turn_id: String,
3103}
3104
3105#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3106#[serde(rename_all = "camelCase")]
3107pub struct ItemGuardianApprovalReviewStartedNotification {
3108    #[serde()]
3109    pub action: GuardianApprovalReviewAction,
3110    #[serde()]
3111    pub review: GuardianApprovalReview,
3112    #[serde(rename = "reviewId", default)]
3113    pub review_id: String,
3114    #[serde(rename = "startedAtMs", default)]
3115    pub started_at_ms: i64,
3116    #[serde(
3117        rename = "targetItemId",
3118        default,
3119        skip_serializing_if = "Option::is_none"
3120    )]
3121    pub target_item_id: Option<String>,
3122    #[serde(rename = "threadId", default)]
3123    pub thread_id: String,
3124    #[serde(rename = "turnId", default)]
3125    pub turn_id: String,
3126}
3127
3128#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3129#[serde(rename_all = "camelCase")]
3130pub struct ItemStartedNotification {
3131    #[serde()]
3132    pub item: ThreadItem,
3133    #[serde(rename = "startedAtMs", default)]
3134    pub started_at_ms: i64,
3135    #[serde(rename = "threadId", default)]
3136    pub thread_id: String,
3137    #[serde(rename = "turnId", default)]
3138    pub turn_id: String,
3139}
3140
3141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3142#[serde(rename_all = "camelCase")]
3143pub struct JSONRPCResponse {
3144    #[serde()]
3145    pub id: RequestId,
3146    #[serde(default)]
3147    pub result: Value,
3148}
3149
3150#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
3151#[serde(transparent)]
3152pub struct LegacyAppPathString(pub String);
3153
3154#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3155#[serde(rename_all = "camelCase")]
3156pub struct ListMcpServerStatusParams {
3157    #[serde(default, skip_serializing_if = "Option::is_none")]
3158    pub cursor: Option<String>,
3159    #[serde(default, skip_serializing_if = "Option::is_none")]
3160    pub detail: Option<McpServerStatusDetail>,
3161    #[serde(default, skip_serializing_if = "Option::is_none")]
3162    pub limit: Option<i64>,
3163    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3164    pub thread_id: Option<String>,
3165}
3166
3167#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3168#[serde(rename_all = "camelCase")]
3169pub struct ListMcpServerStatusResponse {
3170    #[serde(default)]
3171    pub data: Vec<McpServerStatus>,
3172    #[serde(
3173        rename = "nextCursor",
3174        default,
3175        skip_serializing_if = "Option::is_none"
3176    )]
3177    pub next_cursor: Option<String>,
3178}
3179
3180#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3181#[serde(tag = "type", rename_all = "camelCase")]
3182pub enum LoginAccountParams {
3183    #[serde(rename = "apiKey")]
3184    ApiKey {
3185        #[serde(rename = "apiKey")]
3186        api_key: String,
3187    },
3188    Chatgpt {
3189        #[serde(rename = "appBrand", default, skip_serializing_if = "Option::is_none")]
3190        app_brand: Option<LoginAppBrand>,
3191        #[serde(
3192            rename = "codexStreamlinedLogin",
3193            default,
3194            skip_serializing_if = "Option::is_none"
3195        )]
3196        codex_streamlined_login: Option<bool>,
3197        #[serde(
3198            rename = "useHostedLoginSuccessPage",
3199            default,
3200            skip_serializing_if = "Option::is_none"
3201        )]
3202        use_hosted_login_success_page: Option<bool>,
3203    },
3204    #[serde(rename = "chatgptDeviceCode")]
3205    ChatgptDeviceCode,
3206    #[serde(rename = "chatgptAuthTokens")]
3207    ChatgptAuthTokens {
3208        #[serde(rename = "accessToken")]
3209        access_token: String,
3210        #[serde(rename = "chatgptAccountId")]
3211        chatgpt_account_id: String,
3212        #[serde(
3213            rename = "chatgptPlanType",
3214            default,
3215            skip_serializing_if = "Option::is_none"
3216        )]
3217        chatgpt_plan_type: Option<String>,
3218    },
3219    #[serde(rename = "amazonBedrock")]
3220    AmazonBedrock {
3221        #[serde(rename = "apiKey")]
3222        api_key: String,
3223        region: String,
3224    },
3225}
3226
3227#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3228#[serde(tag = "type", rename_all = "camelCase")]
3229pub enum LoginAccountResponse {
3230    #[serde(rename = "apiKey")]
3231    ApiKey,
3232    Chatgpt {
3233        #[serde(rename = "authUrl")]
3234        auth_url: String,
3235        #[serde(rename = "loginId")]
3236        login_id: String,
3237    },
3238    #[serde(rename = "chatgptDeviceCode")]
3239    ChatgptDeviceCode {
3240        #[serde(rename = "loginId")]
3241        login_id: String,
3242        #[serde(rename = "userCode")]
3243        user_code: String,
3244        #[serde(rename = "verificationUrl")]
3245        verification_url: String,
3246    },
3247    #[serde(rename = "chatgptAuthTokens")]
3248    ChatgptAuthTokens,
3249    #[serde(rename = "amazonBedrock")]
3250    AmazonBedrock,
3251}
3252
3253#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3254pub enum LoginAppBrand {
3255    #[serde(rename = "codex")]
3256    Codex,
3257    #[serde(rename = "chatgpt")]
3258    Chatgpt,
3259}
3260
3261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3262#[serde(rename_all = "camelCase")]
3263pub struct LogoutAccountResponse {
3264    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
3265    pub extra: serde_json::Map<String, Value>,
3266}
3267
3268#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3269#[serde(rename_all = "camelCase")]
3270pub struct MarketplaceAddParams {
3271    #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
3272    pub ref_name: Option<String>,
3273    #[serde(default)]
3274    pub source: String,
3275    #[serde(
3276        rename = "sparsePaths",
3277        default,
3278        skip_serializing_if = "Option::is_none"
3279    )]
3280    pub sparse_paths: Option<Vec<String>>,
3281}
3282
3283#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3284#[serde(rename_all = "camelCase")]
3285pub struct MarketplaceAddResponse {
3286    #[serde(rename = "alreadyAdded", default)]
3287    pub already_added: bool,
3288    #[serde(rename = "installedRoot")]
3289    pub installed_root: AbsolutePathBuf,
3290    #[serde(rename = "marketplaceName", default)]
3291    pub marketplace_name: String,
3292}
3293
3294#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3295#[serde(rename_all = "camelCase")]
3296pub struct MarketplaceInterface {
3297    #[serde(
3298        rename = "displayName",
3299        default,
3300        skip_serializing_if = "Option::is_none"
3301    )]
3302    pub display_name: Option<String>,
3303}
3304
3305#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3306#[serde(rename_all = "camelCase")]
3307pub struct MarketplaceLoadErrorInfo {
3308    #[serde(rename = "marketplacePath")]
3309    pub marketplace_path: AbsolutePathBuf,
3310    #[serde(default)]
3311    pub message: String,
3312}
3313
3314#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3315#[serde(rename_all = "camelCase")]
3316pub struct MarketplaceRemoveParams {
3317    #[serde(rename = "marketplaceName", default)]
3318    pub marketplace_name: String,
3319}
3320
3321#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3322#[serde(rename_all = "camelCase")]
3323pub struct MarketplaceRemoveResponse {
3324    #[serde(
3325        rename = "installedRoot",
3326        default,
3327        skip_serializing_if = "Option::is_none"
3328    )]
3329    pub installed_root: Option<AbsolutePathBuf>,
3330    #[serde(rename = "marketplaceName", default)]
3331    pub marketplace_name: String,
3332}
3333
3334#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3335#[serde(rename_all = "camelCase")]
3336pub struct MarketplaceUpgradeErrorInfo {
3337    #[serde(rename = "marketplaceName", default)]
3338    pub marketplace_name: String,
3339    #[serde(default)]
3340    pub message: String,
3341}
3342
3343#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3344#[serde(rename_all = "camelCase")]
3345pub struct MarketplaceUpgradeParams {
3346    #[serde(
3347        rename = "marketplaceName",
3348        default,
3349        skip_serializing_if = "Option::is_none"
3350    )]
3351    pub marketplace_name: Option<String>,
3352}
3353
3354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3355#[serde(rename_all = "camelCase")]
3356pub struct MarketplaceUpgradeResponse {
3357    #[serde(default)]
3358    pub errors: Vec<MarketplaceUpgradeErrorInfo>,
3359    #[serde(rename = "selectedMarketplaces", default)]
3360    pub selected_marketplaces: Vec<String>,
3361    #[serde(rename = "upgradedRoots", default)]
3362    pub upgraded_roots: Vec<AbsolutePathBuf>,
3363}
3364
3365#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3366pub enum McpAuthStatus {
3367    #[serde(rename = "unknown")]
3368    Unknown,
3369    #[serde(rename = "unsupported")]
3370    Unsupported,
3371    #[serde(rename = "notLoggedIn")]
3372    NotLoggedIn,
3373    #[serde(rename = "bearerToken")]
3374    BearerToken,
3375    #[serde(rename = "oAuth")]
3376    OAuth,
3377}
3378
3379#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3380pub enum McpElicitationArrayType {
3381    #[serde(rename = "array")]
3382    Array,
3383}
3384
3385#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3386#[serde(rename_all = "camelCase")]
3387pub struct McpElicitationBooleanSchema {
3388    #[serde(default, skip_serializing_if = "Option::is_none")]
3389    pub default: Option<bool>,
3390    #[serde(default, skip_serializing_if = "Option::is_none")]
3391    pub description: Option<String>,
3392    #[serde(default, skip_serializing_if = "Option::is_none")]
3393    pub title: Option<String>,
3394    #[serde(rename = "type")]
3395    pub type_: McpElicitationBooleanType,
3396}
3397
3398#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3399pub enum McpElicitationBooleanType {
3400    #[serde(rename = "boolean")]
3401    Boolean,
3402}
3403
3404#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3405#[serde(rename_all = "camelCase")]
3406pub struct McpElicitationConstOption {
3407    #[serde(rename = "const", default)]
3408    pub const_: String,
3409    #[serde(default)]
3410    pub title: String,
3411}
3412
3413#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3414#[serde(untagged)]
3415pub enum McpElicitationEnumSchema {
3416    McpElicitationSingleSelectEnumSchema(McpElicitationSingleSelectEnumSchema),
3417    McpElicitationMultiSelectEnumSchema(McpElicitationMultiSelectEnumSchema),
3418    McpElicitationLegacyTitledEnumSchema(McpElicitationLegacyTitledEnumSchema),
3419}
3420
3421#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3422#[serde(rename_all = "camelCase")]
3423pub struct McpElicitationLegacyTitledEnumSchema {
3424    #[serde(default, skip_serializing_if = "Option::is_none")]
3425    pub default: Option<String>,
3426    #[serde(default, skip_serializing_if = "Option::is_none")]
3427    pub description: Option<String>,
3428    #[serde(rename = "enum", default)]
3429    pub enum_: Vec<String>,
3430    #[serde(rename = "enumNames", default, skip_serializing_if = "Option::is_none")]
3431    pub enum_names: Option<Vec<String>>,
3432    #[serde(default, skip_serializing_if = "Option::is_none")]
3433    pub title: Option<String>,
3434    #[serde(rename = "type")]
3435    pub type_: McpElicitationStringType,
3436}
3437
3438#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3439#[serde(untagged)]
3440pub enum McpElicitationMultiSelectEnumSchema {
3441    McpElicitationUntitledMultiSelectEnumSchema(McpElicitationUntitledMultiSelectEnumSchema),
3442    McpElicitationTitledMultiSelectEnumSchema(McpElicitationTitledMultiSelectEnumSchema),
3443}
3444
3445#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3446#[serde(rename_all = "camelCase")]
3447pub struct McpElicitationNumberSchema {
3448    #[serde(default, skip_serializing_if = "Option::is_none")]
3449    pub default: Option<f64>,
3450    #[serde(default, skip_serializing_if = "Option::is_none")]
3451    pub description: Option<String>,
3452    #[serde(default, skip_serializing_if = "Option::is_none")]
3453    pub maximum: Option<f64>,
3454    #[serde(default, skip_serializing_if = "Option::is_none")]
3455    pub minimum: Option<f64>,
3456    #[serde(default, skip_serializing_if = "Option::is_none")]
3457    pub title: Option<String>,
3458    #[serde(rename = "type")]
3459    pub type_: McpElicitationNumberType,
3460}
3461
3462#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3463pub enum McpElicitationNumberType {
3464    #[serde(rename = "number")]
3465    Number,
3466    #[serde(rename = "integer")]
3467    Integer,
3468}
3469
3470#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3471pub enum McpElicitationObjectType {
3472    #[serde(rename = "object")]
3473    Object,
3474}
3475
3476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3477#[serde(untagged)]
3478pub enum McpElicitationPrimitiveSchema {
3479    McpElicitationEnumSchema(McpElicitationEnumSchema),
3480    McpElicitationStringSchema(McpElicitationStringSchema),
3481    McpElicitationNumberSchema(McpElicitationNumberSchema),
3482    McpElicitationBooleanSchema(McpElicitationBooleanSchema),
3483}
3484
3485#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3486#[serde(rename_all = "camelCase")]
3487pub struct McpElicitationSchema {
3488    #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
3489    pub schema: Option<String>,
3490    #[serde(default)]
3491    pub properties: std::collections::BTreeMap<String, McpElicitationPrimitiveSchema>,
3492    #[serde(default, skip_serializing_if = "Option::is_none")]
3493    pub required: Option<Vec<String>>,
3494    #[serde(rename = "type")]
3495    pub type_: McpElicitationObjectType,
3496}
3497
3498#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3499#[serde(untagged)]
3500pub enum McpElicitationSingleSelectEnumSchema {
3501    McpElicitationUntitledSingleSelectEnumSchema(McpElicitationUntitledSingleSelectEnumSchema),
3502    McpElicitationTitledSingleSelectEnumSchema(McpElicitationTitledSingleSelectEnumSchema),
3503}
3504
3505#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3506pub enum McpElicitationStringFormat {
3507    #[serde(rename = "email")]
3508    Email,
3509    #[serde(rename = "uri")]
3510    Uri,
3511    #[serde(rename = "date")]
3512    Date,
3513    #[serde(rename = "date-time")]
3514    Date_time,
3515}
3516
3517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3518#[serde(rename_all = "camelCase")]
3519pub struct McpElicitationStringSchema {
3520    #[serde(default, skip_serializing_if = "Option::is_none")]
3521    pub default: Option<String>,
3522    #[serde(default, skip_serializing_if = "Option::is_none")]
3523    pub description: Option<String>,
3524    #[serde(default, skip_serializing_if = "Option::is_none")]
3525    pub format: Option<McpElicitationStringFormat>,
3526    #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
3527    pub max_length: Option<i64>,
3528    #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
3529    pub min_length: Option<i64>,
3530    #[serde(default, skip_serializing_if = "Option::is_none")]
3531    pub title: Option<String>,
3532    #[serde(rename = "type")]
3533    pub type_: McpElicitationStringType,
3534}
3535
3536#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3537pub enum McpElicitationStringType {
3538    #[serde(rename = "string")]
3539    String,
3540}
3541
3542#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3543#[serde(rename_all = "camelCase")]
3544pub struct McpElicitationTitledEnumItems {
3545    #[serde(rename = "anyOf", default)]
3546    pub any_of: Vec<McpElicitationConstOption>,
3547}
3548
3549#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3550#[serde(rename_all = "camelCase")]
3551pub struct McpElicitationTitledMultiSelectEnumSchema {
3552    #[serde(default, skip_serializing_if = "Option::is_none")]
3553    pub default: Option<Vec<String>>,
3554    #[serde(default, skip_serializing_if = "Option::is_none")]
3555    pub description: Option<String>,
3556    #[serde()]
3557    pub items: McpElicitationTitledEnumItems,
3558    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
3559    pub max_items: Option<i64>,
3560    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
3561    pub min_items: Option<i64>,
3562    #[serde(default, skip_serializing_if = "Option::is_none")]
3563    pub title: Option<String>,
3564    #[serde(rename = "type")]
3565    pub type_: McpElicitationArrayType,
3566}
3567
3568#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3569#[serde(rename_all = "camelCase")]
3570pub struct McpElicitationTitledSingleSelectEnumSchema {
3571    #[serde(default, skip_serializing_if = "Option::is_none")]
3572    pub default: Option<String>,
3573    #[serde(default, skip_serializing_if = "Option::is_none")]
3574    pub description: Option<String>,
3575    #[serde(rename = "oneOf", default)]
3576    pub one_of: Vec<McpElicitationConstOption>,
3577    #[serde(default, skip_serializing_if = "Option::is_none")]
3578    pub title: Option<String>,
3579    #[serde(rename = "type")]
3580    pub type_: McpElicitationStringType,
3581}
3582
3583#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3584#[serde(rename_all = "camelCase")]
3585pub struct McpElicitationUntitledEnumItems {
3586    #[serde(rename = "enum", default)]
3587    pub enum_: Vec<String>,
3588    #[serde(rename = "type")]
3589    pub type_: McpElicitationStringType,
3590}
3591
3592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3593#[serde(rename_all = "camelCase")]
3594pub struct McpElicitationUntitledMultiSelectEnumSchema {
3595    #[serde(default, skip_serializing_if = "Option::is_none")]
3596    pub default: Option<Vec<String>>,
3597    #[serde(default, skip_serializing_if = "Option::is_none")]
3598    pub description: Option<String>,
3599    #[serde()]
3600    pub items: McpElicitationUntitledEnumItems,
3601    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
3602    pub max_items: Option<i64>,
3603    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
3604    pub min_items: Option<i64>,
3605    #[serde(default, skip_serializing_if = "Option::is_none")]
3606    pub title: Option<String>,
3607    #[serde(rename = "type")]
3608    pub type_: McpElicitationArrayType,
3609}
3610
3611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3612#[serde(rename_all = "camelCase")]
3613pub struct McpElicitationUntitledSingleSelectEnumSchema {
3614    #[serde(default, skip_serializing_if = "Option::is_none")]
3615    pub default: Option<String>,
3616    #[serde(default, skip_serializing_if = "Option::is_none")]
3617    pub description: Option<String>,
3618    #[serde(rename = "enum", default)]
3619    pub enum_: Vec<String>,
3620    #[serde(default, skip_serializing_if = "Option::is_none")]
3621    pub title: Option<String>,
3622    #[serde(rename = "type")]
3623    pub type_: McpElicitationStringType,
3624}
3625
3626#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3627#[serde(rename_all = "camelCase")]
3628pub struct McpResourceReadParams {
3629    #[serde(default)]
3630    pub server: String,
3631    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3632    pub thread_id: Option<String>,
3633    #[serde(default)]
3634    pub uri: String,
3635}
3636
3637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3638#[serde(rename_all = "camelCase")]
3639pub struct McpResourceReadResponse {
3640    #[serde(default)]
3641    pub contents: Vec<ResourceContent>,
3642}
3643
3644#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3645pub enum McpServerElicitationAction {
3646    #[serde(rename = "accept")]
3647    Accept,
3648    #[serde(rename = "decline")]
3649    Decline,
3650    #[serde(rename = "cancel")]
3651    Cancel,
3652}
3653
3654#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3655#[serde(tag = "mode", rename_all = "camelCase")]
3656pub enum McpServerElicitationRequestParams {
3657    Form {
3658        #[serde(default, skip_serializing_if = "Option::is_none")]
3659        _meta: Option<Value>,
3660        message: String,
3661        #[serde(rename = "requestedSchema")]
3662        requested_schema: McpElicitationSchema,
3663    },
3664    #[serde(rename = "openai/form")]
3665    OpenaiForm {
3666        #[serde(default, skip_serializing_if = "Option::is_none")]
3667        _meta: Option<Value>,
3668        message: String,
3669        #[serde(rename = "requestedSchema")]
3670        requested_schema: Value,
3671    },
3672    Url {
3673        #[serde(default, skip_serializing_if = "Option::is_none")]
3674        _meta: Option<Value>,
3675        #[serde(rename = "elicitationId")]
3676        elicitation_id: String,
3677        message: String,
3678        url: String,
3679    },
3680}
3681
3682#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3683#[serde(rename_all = "camelCase")]
3684pub struct McpServerElicitationRequestResponse {
3685    #[serde(default, skip_serializing_if = "Option::is_none")]
3686    pub _meta: Option<Value>,
3687    #[serde()]
3688    pub action: McpServerElicitationAction,
3689    #[serde(default, skip_serializing_if = "Option::is_none")]
3690    pub content: Option<Value>,
3691}
3692
3693#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3694#[serde(rename_all = "camelCase")]
3695pub struct McpServerInfo {
3696    #[serde(default, skip_serializing_if = "Option::is_none")]
3697    pub description: Option<String>,
3698    #[serde(default, skip_serializing_if = "Option::is_none")]
3699    pub icons: Option<Vec<Value>>,
3700    #[serde(default)]
3701    pub name: String,
3702    #[serde(default, skip_serializing_if = "Option::is_none")]
3703    pub title: Option<String>,
3704    #[serde(default)]
3705    pub version: String,
3706    #[serde(
3707        rename = "websiteUrl",
3708        default,
3709        skip_serializing_if = "Option::is_none"
3710    )]
3711    pub website_url: Option<String>,
3712}
3713
3714#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3715#[serde(rename_all = "camelCase")]
3716pub struct McpServerMigration {
3717    #[serde(default)]
3718    pub name: String,
3719}
3720
3721#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3722#[serde(rename_all = "camelCase")]
3723pub struct McpServerOauthLoginCompletedNotification {
3724    #[serde(default, skip_serializing_if = "Option::is_none")]
3725    pub error: Option<String>,
3726    #[serde(default)]
3727    pub name: String,
3728    #[serde(default)]
3729    pub success: bool,
3730    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3731    pub thread_id: Option<String>,
3732}
3733
3734#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3735#[serde(rename_all = "camelCase")]
3736pub struct McpServerOauthLoginParams {
3737    #[serde(default)]
3738    pub name: String,
3739    #[serde(default, skip_serializing_if = "Option::is_none")]
3740    pub scopes: Option<Vec<String>>,
3741    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3742    pub thread_id: Option<String>,
3743    #[serde(
3744        rename = "timeoutSecs",
3745        default,
3746        skip_serializing_if = "Option::is_none"
3747    )]
3748    pub timeout_secs: Option<i64>,
3749}
3750
3751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3752#[serde(rename_all = "camelCase")]
3753pub struct McpServerOauthLoginResponse {
3754    #[serde(rename = "authorizationUrl", default)]
3755    pub authorization_url: String,
3756}
3757
3758#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3759#[serde(rename_all = "camelCase")]
3760pub struct McpServerRefreshResponse {
3761    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
3762    pub extra: serde_json::Map<String, Value>,
3763}
3764
3765#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3766pub enum McpServerStartupFailureReason {
3767    #[serde(rename = "reauthenticationRequired")]
3768    ReauthenticationRequired,
3769}
3770
3771#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3772pub enum McpServerStartupState {
3773    #[serde(rename = "starting")]
3774    Starting,
3775    #[serde(rename = "ready")]
3776    Ready,
3777    #[serde(rename = "failed")]
3778    Failed,
3779    #[serde(rename = "cancelled")]
3780    Cancelled,
3781}
3782
3783#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3784#[serde(rename_all = "camelCase")]
3785pub struct McpServerStatus {
3786    #[serde(rename = "authStatus")]
3787    pub auth_status: McpAuthStatus,
3788    #[serde(default)]
3789    pub name: String,
3790    #[serde(rename = "resourceTemplates", default)]
3791    pub resource_templates: Vec<ResourceTemplate>,
3792    #[serde(default)]
3793    pub resources: Vec<Resource>,
3794    #[serde(
3795        rename = "serverInfo",
3796        default,
3797        skip_serializing_if = "Option::is_none"
3798    )]
3799    pub server_info: Option<McpServerInfo>,
3800    #[serde(default)]
3801    pub tools: std::collections::BTreeMap<String, Tool>,
3802}
3803
3804#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3805pub enum McpServerStatusDetail {
3806    #[serde(rename = "full")]
3807    Full,
3808    #[serde(rename = "toolsAndAuthOnly")]
3809    ToolsAndAuthOnly,
3810}
3811
3812#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3813#[serde(rename_all = "camelCase")]
3814pub struct McpServerStatusUpdatedNotification {
3815    #[serde(default, skip_serializing_if = "Option::is_none")]
3816    pub error: Option<String>,
3817    #[serde(
3818        rename = "failureReason",
3819        default,
3820        skip_serializing_if = "Option::is_none"
3821    )]
3822    pub failure_reason: Option<McpServerStartupFailureReason>,
3823    #[serde(default)]
3824    pub name: String,
3825    #[serde()]
3826    pub status: McpServerStartupState,
3827    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3828    pub thread_id: Option<String>,
3829}
3830
3831#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3832#[serde(rename_all = "camelCase")]
3833pub struct McpServerToolCallParams {
3834    #[serde(default, skip_serializing_if = "Option::is_none")]
3835    pub _meta: Option<Value>,
3836    #[serde(default, skip_serializing_if = "Option::is_none")]
3837    pub arguments: Option<Value>,
3838    #[serde(default)]
3839    pub server: String,
3840    #[serde(rename = "threadId", default)]
3841    pub thread_id: String,
3842    #[serde(default)]
3843    pub tool: String,
3844}
3845
3846#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3847#[serde(rename_all = "camelCase")]
3848pub struct McpServerToolCallResponse {
3849    #[serde(default, skip_serializing_if = "Option::is_none")]
3850    pub _meta: Option<Value>,
3851    #[serde(default)]
3852    pub content: Vec<Value>,
3853    #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
3854    pub is_error: Option<bool>,
3855    #[serde(
3856        rename = "structuredContent",
3857        default,
3858        skip_serializing_if = "Option::is_none"
3859    )]
3860    pub structured_content: Option<Value>,
3861}
3862
3863#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3864#[serde(rename_all = "camelCase")]
3865pub struct McpToolCallAppContext {
3866    #[serde(
3867        rename = "actionName",
3868        default,
3869        skip_serializing_if = "Option::is_none"
3870    )]
3871    pub action_name: Option<String>,
3872    #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
3873    pub app_name: Option<String>,
3874    #[serde(rename = "connectorId", default)]
3875    pub connector_id: String,
3876    #[serde(rename = "linkId", default, skip_serializing_if = "Option::is_none")]
3877    pub link_id: Option<String>,
3878    #[serde(
3879        rename = "resourceUri",
3880        default,
3881        skip_serializing_if = "Option::is_none"
3882    )]
3883    pub resource_uri: Option<String>,
3884}
3885
3886#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3887#[serde(rename_all = "camelCase")]
3888pub struct McpToolCallError {
3889    #[serde(default)]
3890    pub message: String,
3891}
3892
3893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3894#[serde(rename_all = "camelCase")]
3895pub struct McpToolCallProgressNotification {
3896    #[serde(rename = "itemId", default)]
3897    pub item_id: String,
3898    #[serde(default)]
3899    pub message: String,
3900    #[serde(rename = "threadId", default)]
3901    pub thread_id: String,
3902    #[serde(rename = "turnId", default)]
3903    pub turn_id: String,
3904}
3905
3906#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3907#[serde(rename_all = "camelCase")]
3908pub struct McpToolCallResult {
3909    #[serde(default, skip_serializing_if = "Option::is_none")]
3910    pub _meta: Option<Value>,
3911    #[serde(default)]
3912    pub content: Vec<Value>,
3913    #[serde(
3914        rename = "structuredContent",
3915        default,
3916        skip_serializing_if = "Option::is_none"
3917    )]
3918    pub structured_content: Option<Value>,
3919}
3920
3921#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3922pub enum McpToolCallStatus {
3923    #[serde(rename = "inProgress")]
3924    InProgress,
3925    #[serde(rename = "completed")]
3926    Completed,
3927    #[serde(rename = "failed")]
3928    Failed,
3929}
3930
3931#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3932#[serde(rename_all = "camelCase")]
3933pub struct MemoryCitation {
3934    #[serde(default)]
3935    pub entries: Vec<MemoryCitationEntry>,
3936    #[serde(rename = "threadIds", default)]
3937    pub thread_ids: Vec<String>,
3938}
3939
3940#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3941#[serde(rename_all = "camelCase")]
3942pub struct MemoryCitationEntry {
3943    #[serde(rename = "lineEnd", default)]
3944    pub line_end: i64,
3945    #[serde(rename = "lineStart", default)]
3946    pub line_start: i64,
3947    #[serde(default)]
3948    pub note: String,
3949    #[serde(default)]
3950    pub path: String,
3951}
3952
3953#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3954pub enum MergeStrategy {
3955    #[serde(rename = "replace")]
3956    Replace,
3957    #[serde(rename = "upsert")]
3958    Upsert,
3959}
3960
3961#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
3962pub enum MessagePhase {
3963    #[serde(rename = "commentary")]
3964    Commentary,
3965    #[serde(rename = "final_answer")]
3966    FinalAnswer,
3967}
3968
3969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3970#[serde(rename_all = "camelCase")]
3971pub struct MigrationDetails {
3972    #[serde(default, skip_serializing_if = "Option::is_none")]
3973    pub commands: Option<Vec<CommandMigration>>,
3974    #[serde(default, skip_serializing_if = "Option::is_none")]
3975    pub hooks: Option<Vec<HookMigration>>,
3976    #[serde(
3977        rename = "mcpServers",
3978        default,
3979        skip_serializing_if = "Option::is_none"
3980    )]
3981    pub mcp_servers: Option<Vec<McpServerMigration>>,
3982    #[serde(default, skip_serializing_if = "Option::is_none")]
3983    pub memory: Option<Vec<String>>,
3984    #[serde(default, skip_serializing_if = "Option::is_none")]
3985    pub plugins: Option<Vec<PluginsMigration>>,
3986    #[serde(default, skip_serializing_if = "Option::is_none")]
3987    pub sessions: Option<Vec<SessionMigration>>,
3988    #[serde(default, skip_serializing_if = "Option::is_none")]
3989    pub skills: Option<Vec<SkillMigration>>,
3990    #[serde(default, skip_serializing_if = "Option::is_none")]
3991    pub subagents: Option<Vec<SubagentMigration>>,
3992}
3993
3994#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3995pub enum ModeKind {
3996    #[serde(rename = "plan")]
3997    Plan,
3998    #[serde(rename = "default")]
3999    Default,
4000}
4001
4002#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4003#[serde(rename_all = "camelCase")]
4004pub struct Model {
4005    #[serde(
4006        rename = "additionalSpeedTiers",
4007        default,
4008        skip_serializing_if = "Option::is_none"
4009    )]
4010    pub additional_speed_tiers: Option<Vec<String>>,
4011    #[serde(
4012        rename = "availabilityNux",
4013        default,
4014        skip_serializing_if = "Option::is_none"
4015    )]
4016    pub availability_nux: Option<ModelAvailabilityNux>,
4017    #[serde(rename = "defaultReasoningEffort")]
4018    pub default_reasoning_effort: ReasoningEffort,
4019    #[serde(
4020        rename = "defaultServiceTier",
4021        default,
4022        skip_serializing_if = "Option::is_none"
4023    )]
4024    pub default_service_tier: Option<String>,
4025    #[serde(default)]
4026    pub description: String,
4027    #[serde(rename = "displayName", default)]
4028    pub display_name: String,
4029    #[serde(default)]
4030    pub hidden: bool,
4031    #[serde(default)]
4032    pub id: String,
4033    #[serde(
4034        rename = "inputModalities",
4035        default,
4036        skip_serializing_if = "Option::is_none"
4037    )]
4038    pub input_modalities: Option<Vec<InputModality>>,
4039    #[serde(rename = "isDefault", default)]
4040    pub is_default: bool,
4041    #[serde(default)]
4042    pub model: String,
4043    #[serde(
4044        rename = "modelSpecialty",
4045        default,
4046        skip_serializing_if = "Option::is_none"
4047    )]
4048    pub model_specialty: Option<String>,
4049    #[serde(
4050        rename = "serviceTiers",
4051        default,
4052        skip_serializing_if = "Option::is_none"
4053    )]
4054    pub service_tiers: Option<Vec<ModelServiceTier>>,
4055    #[serde(rename = "supportedReasoningEfforts", default)]
4056    pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
4057    #[serde(
4058        rename = "supportsPersonality",
4059        default,
4060        skip_serializing_if = "Option::is_none"
4061    )]
4062    pub supports_personality: Option<bool>,
4063    #[serde(default, skip_serializing_if = "Option::is_none")]
4064    pub upgrade: Option<String>,
4065    #[serde(
4066        rename = "upgradeInfo",
4067        default,
4068        skip_serializing_if = "Option::is_none"
4069    )]
4070    pub upgrade_info: Option<ModelUpgradeInfo>,
4071}
4072
4073#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4074#[serde(rename_all = "camelCase")]
4075pub struct ModelAvailabilityNux {
4076    #[serde(default)]
4077    pub message: String,
4078}
4079
4080#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4081#[serde(rename_all = "camelCase")]
4082pub struct ModelListParams {
4083    #[serde(default, skip_serializing_if = "Option::is_none")]
4084    pub cursor: Option<String>,
4085    #[serde(
4086        rename = "includeHidden",
4087        default,
4088        skip_serializing_if = "Option::is_none"
4089    )]
4090    pub include_hidden: Option<bool>,
4091    #[serde(default, skip_serializing_if = "Option::is_none")]
4092    pub limit: Option<i64>,
4093}
4094
4095#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4096#[serde(rename_all = "camelCase")]
4097pub struct ModelListResponse {
4098    #[serde(default)]
4099    pub data: Vec<Model>,
4100    #[serde(
4101        rename = "nextCursor",
4102        default,
4103        skip_serializing_if = "Option::is_none"
4104    )]
4105    pub next_cursor: Option<String>,
4106}
4107
4108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4109#[serde(rename_all = "camelCase")]
4110pub struct ModelProviderCapabilitiesReadParams {
4111    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4112    pub extra: serde_json::Map<String, Value>,
4113}
4114
4115#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4116#[serde(rename_all = "camelCase")]
4117pub struct ModelProviderCapabilitiesReadResponse {
4118    #[serde(rename = "imageGeneration", default)]
4119    pub image_generation: bool,
4120    #[serde(rename = "namespaceTools", default)]
4121    pub namespace_tools: bool,
4122    #[serde(rename = "webSearch", default)]
4123    pub web_search: bool,
4124}
4125
4126#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4127pub enum ModelRerouteReason {
4128    #[serde(rename = "highRiskCyberActivity")]
4129    HighRiskCyberActivity,
4130}
4131
4132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4133#[serde(rename_all = "camelCase")]
4134pub struct ModelReroutedNotification {
4135    #[serde(rename = "fromModel", default)]
4136    pub from_model: String,
4137    #[serde()]
4138    pub reason: ModelRerouteReason,
4139    #[serde(rename = "threadId", default)]
4140    pub thread_id: String,
4141    #[serde(rename = "toModel", default)]
4142    pub to_model: String,
4143    #[serde(rename = "turnId", default)]
4144    pub turn_id: String,
4145}
4146
4147#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4148#[serde(rename_all = "camelCase")]
4149pub struct ModelSafetyBufferingUpdatedNotification {
4150    #[serde(
4151        rename = "fasterModel",
4152        default,
4153        skip_serializing_if = "Option::is_none"
4154    )]
4155    pub faster_model: Option<String>,
4156    #[serde(default)]
4157    pub model: String,
4158    #[serde(default)]
4159    pub reasons: Vec<String>,
4160    #[serde(rename = "showBufferingUi", default)]
4161    pub show_buffering_ui: bool,
4162    #[serde(rename = "threadId", default)]
4163    pub thread_id: String,
4164    #[serde(rename = "turnId", default)]
4165    pub turn_id: String,
4166    #[serde(rename = "useCases", default)]
4167    pub use_cases: Vec<String>,
4168}
4169
4170#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4171#[serde(rename_all = "camelCase")]
4172pub struct ModelServiceTier {
4173    #[serde(default)]
4174    pub description: String,
4175    #[serde(default)]
4176    pub id: String,
4177    #[serde(default)]
4178    pub name: String,
4179}
4180
4181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4182#[serde(rename_all = "camelCase")]
4183pub struct ModelUpgradeInfo {
4184    #[serde(
4185        rename = "migrationMarkdown",
4186        default,
4187        skip_serializing_if = "Option::is_none"
4188    )]
4189    pub migration_markdown: Option<String>,
4190    #[serde(default)]
4191    pub model: String,
4192    #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
4193    pub model_link: Option<String>,
4194    #[serde(
4195        rename = "upgradeCopy",
4196        default,
4197        skip_serializing_if = "Option::is_none"
4198    )]
4199    pub upgrade_copy: Option<String>,
4200}
4201
4202#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4203pub enum ModelVerification {
4204    #[serde(rename = "trustedAccessForCyber")]
4205    TrustedAccessForCyber,
4206}
4207
4208#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4209#[serde(rename_all = "camelCase")]
4210pub struct ModelVerificationNotification {
4211    #[serde(rename = "threadId", default)]
4212    pub thread_id: String,
4213    #[serde(rename = "turnId", default)]
4214    pub turn_id: String,
4215    #[serde(default)]
4216    pub verifications: Vec<ModelVerification>,
4217}
4218
4219#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4220#[serde(rename_all = "camelCase")]
4221pub struct ModelsRequirements {
4222    #[serde(rename = "newThread", default, skip_serializing_if = "Option::is_none")]
4223    pub new_thread: Option<NewThreadModelDefaults>,
4224}
4225
4226#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4227pub enum NetworkAccess {
4228    #[serde(rename = "restricted")]
4229    Restricted,
4230    #[serde(rename = "enabled")]
4231    Enabled,
4232}
4233
4234#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4235#[serde(rename_all = "camelCase")]
4236pub struct NetworkApprovalContext {
4237    #[serde(default)]
4238    pub host: String,
4239    #[serde()]
4240    pub protocol: NetworkApprovalProtocol,
4241}
4242
4243#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4244pub enum NetworkApprovalProtocol {
4245    #[serde(rename = "http")]
4246    Http,
4247    #[serde(rename = "https")]
4248    Https,
4249    #[serde(rename = "socks5Tcp")]
4250    Socks5Tcp,
4251    #[serde(rename = "socks5Udp")]
4252    Socks5Udp,
4253}
4254
4255#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4256#[serde(rename_all = "camelCase")]
4257pub struct NetworkPolicyAmendment {
4258    #[serde()]
4259    pub action: NetworkPolicyRuleAction,
4260    #[serde(default)]
4261    pub host: String,
4262}
4263
4264#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4265pub enum NetworkPolicyRuleAction {
4266    #[serde(rename = "allow")]
4267    Allow,
4268    #[serde(rename = "deny")]
4269    Deny,
4270}
4271
4272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4273#[serde(rename_all = "camelCase")]
4274pub struct NewThreadModelDefaults {
4275    #[serde(default, skip_serializing_if = "Option::is_none")]
4276    pub model: Option<String>,
4277    #[serde(
4278        rename = "modelReasoningEffort",
4279        default,
4280        skip_serializing_if = "Option::is_none"
4281    )]
4282    pub model_reasoning_effort: Option<ReasoningEffort>,
4283    #[serde(
4284        rename = "serviceTier",
4285        default,
4286        skip_serializing_if = "Option::is_none"
4287    )]
4288    pub service_tier: Option<String>,
4289}
4290
4291#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4292pub enum NonSteerableTurnKind {
4293    #[serde(rename = "review")]
4294    Review,
4295    #[serde(rename = "compact")]
4296    Compact,
4297}
4298
4299#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4300#[serde(rename_all = "camelCase")]
4301pub struct OverriddenMetadata {
4302    #[serde(rename = "effectiveValue", default)]
4303    pub effective_value: Value,
4304    #[serde(default)]
4305    pub message: String,
4306    #[serde(rename = "overridingLayer")]
4307    pub overriding_layer: ConfigLayerMetadata,
4308}
4309
4310#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4311#[serde(tag = "type", rename_all = "camelCase")]
4312pub enum ParsedCommand {
4313    Read {
4314        cmd: String,
4315        name: String,
4316        path: String,
4317    },
4318    List_files {
4319        cmd: String,
4320        #[serde(default, skip_serializing_if = "Option::is_none")]
4321        path: Option<String>,
4322    },
4323    Search {
4324        cmd: String,
4325        #[serde(default, skip_serializing_if = "Option::is_none")]
4326        path: Option<String>,
4327        #[serde(default, skip_serializing_if = "Option::is_none")]
4328        query: Option<String>,
4329    },
4330    Unknown {
4331        cmd: String,
4332    },
4333}
4334
4335#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4336pub enum PatchApplyStatus {
4337    #[serde(rename = "inProgress")]
4338    InProgress,
4339    #[serde(rename = "completed")]
4340    Completed,
4341    #[serde(rename = "failed")]
4342    Failed,
4343    #[serde(rename = "declined")]
4344    Declined,
4345}
4346
4347#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4348#[serde(tag = "type", rename_all = "camelCase")]
4349pub enum PatchChangeKind {
4350    Add,
4351    Delete,
4352    Update {
4353        #[serde(default, skip_serializing_if = "Option::is_none")]
4354        move_path: Option<String>,
4355    },
4356}
4357
4358#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4359pub enum PermissionGrantScope {
4360    #[serde(rename = "turn")]
4361    Turn,
4362    #[serde(rename = "session")]
4363    Session,
4364}
4365
4366#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4367#[serde(rename_all = "camelCase")]
4368pub struct PermissionProfileListParams {
4369    #[serde(default, skip_serializing_if = "Option::is_none")]
4370    pub cursor: Option<String>,
4371    #[serde(default, skip_serializing_if = "Option::is_none")]
4372    pub cwd: Option<String>,
4373    #[serde(default, skip_serializing_if = "Option::is_none")]
4374    pub limit: Option<i64>,
4375}
4376
4377#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4378#[serde(rename_all = "camelCase")]
4379pub struct PermissionProfileListResponse {
4380    #[serde(default)]
4381    pub data: Vec<PermissionProfileSummary>,
4382    #[serde(
4383        rename = "nextCursor",
4384        default,
4385        skip_serializing_if = "Option::is_none"
4386    )]
4387    pub next_cursor: Option<String>,
4388}
4389
4390#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4391#[serde(rename_all = "camelCase")]
4392pub struct PermissionProfileSummary {
4393    #[serde(default)]
4394    pub allowed: bool,
4395    #[serde(default, skip_serializing_if = "Option::is_none")]
4396    pub description: Option<String>,
4397    #[serde(default)]
4398    pub id: String,
4399}
4400
4401#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4402#[serde(rename_all = "camelCase")]
4403pub struct PermissionsRequestApprovalParams {
4404    #[serde()]
4405    pub cwd: AbsolutePathBuf,
4406    #[serde(
4407        rename = "environmentId",
4408        default,
4409        skip_serializing_if = "Option::is_none"
4410    )]
4411    pub environment_id: Option<String>,
4412    #[serde(rename = "itemId", default)]
4413    pub item_id: String,
4414    #[serde()]
4415    pub permissions: RequestPermissionProfile,
4416    #[serde(default, skip_serializing_if = "Option::is_none")]
4417    pub reason: Option<String>,
4418    #[serde(rename = "startedAtMs", default)]
4419    pub started_at_ms: i64,
4420    #[serde(rename = "threadId", default)]
4421    pub thread_id: String,
4422    #[serde(rename = "turnId", default)]
4423    pub turn_id: String,
4424}
4425
4426#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4427#[serde(rename_all = "camelCase")]
4428pub struct PermissionsRequestApprovalResponse {
4429    #[serde()]
4430    pub permissions: GrantedPermissionProfile,
4431    #[serde(default, skip_serializing_if = "Option::is_none")]
4432    pub scope: Option<Value>,
4433    #[serde(
4434        rename = "strictAutoReview",
4435        default,
4436        skip_serializing_if = "Option::is_none"
4437    )]
4438    pub strict_auto_review: Option<bool>,
4439}
4440
4441#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4442pub enum Personality {
4443    #[serde(rename = "none")]
4444    None,
4445    #[serde(rename = "friendly")]
4446    Friendly,
4447    #[serde(rename = "pragmatic")]
4448    Pragmatic,
4449}
4450
4451#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4452#[serde(rename_all = "camelCase")]
4453pub struct PlanDeltaNotification {
4454    #[serde(default)]
4455    pub delta: String,
4456    #[serde(rename = "itemId", default)]
4457    pub item_id: String,
4458    #[serde(rename = "threadId", default)]
4459    pub thread_id: String,
4460    #[serde(rename = "turnId", default)]
4461    pub turn_id: String,
4462}
4463
4464#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4465pub enum PlanType {
4466    #[serde(rename = "free")]
4467    Free,
4468    #[serde(rename = "go")]
4469    Go,
4470    #[serde(rename = "plus")]
4471    Plus,
4472    #[serde(rename = "pro")]
4473    Pro,
4474    #[serde(rename = "prolite")]
4475    Prolite,
4476    #[serde(rename = "team")]
4477    Team,
4478    #[serde(rename = "self_serve_business_prolite")]
4479    Self_serve_business_prolite,
4480    #[serde(rename = "self_serve_business_usage_based")]
4481    Self_serve_business_usage_based,
4482    #[serde(rename = "business")]
4483    Business,
4484    #[serde(rename = "ent26")]
4485    Ent26,
4486    #[serde(rename = "enterprise_cbp_automation")]
4487    Enterprise_cbp_automation,
4488    #[serde(rename = "enterprise_cbp_usage_based")]
4489    Enterprise_cbp_usage_based,
4490    #[serde(rename = "enterprise")]
4491    Enterprise,
4492    #[serde(rename = "edu")]
4493    Edu,
4494    #[serde(rename = "unknown")]
4495    Unknown,
4496}
4497
4498#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4499pub enum PluginAuthPolicy {
4500    #[serde(rename = "ON_INSTALL")]
4501    ON_INSTALL,
4502    #[serde(rename = "ON_USE")]
4503    ON_USE,
4504}
4505
4506#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4507pub enum PluginAvailability {
4508    #[serde(rename = "DISABLED_BY_ADMIN")]
4509    DISABLEDBYADMIN,
4510    AVAILABLE,
4511}
4512
4513#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4514#[serde(rename_all = "camelCase")]
4515pub struct PluginDetail {
4516    #[serde(rename = "appTemplates", default)]
4517    pub app_templates: Vec<AppTemplateSummary>,
4518    #[serde(default)]
4519    pub apps: Vec<AppSummary>,
4520    #[serde(default, skip_serializing_if = "Option::is_none")]
4521    pub description: Option<String>,
4522    #[serde(default)]
4523    pub hooks: Vec<PluginHookSummary>,
4524    #[serde(rename = "marketplaceName", default)]
4525    pub marketplace_name: String,
4526    #[serde(
4527        rename = "marketplacePath",
4528        default,
4529        skip_serializing_if = "Option::is_none"
4530    )]
4531    pub marketplace_path: Option<AbsolutePathBuf>,
4532    #[serde(rename = "mcpServers", default)]
4533    pub mcp_servers: Vec<String>,
4534    #[serde(
4535        rename = "scheduledTasks",
4536        default,
4537        skip_serializing_if = "Option::is_none"
4538    )]
4539    pub scheduled_tasks: Option<Vec<ScheduledTaskSummary>>,
4540    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
4541    pub share_url: Option<String>,
4542    #[serde(default)]
4543    pub skills: Vec<SkillSummary>,
4544    #[serde()]
4545    pub summary: PluginSummary,
4546}
4547
4548#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4549pub enum PluginDisabledReason {
4550    #[serde(rename = "disabled_by_admin")]
4551    Disabled_by_admin,
4552    #[serde(rename = "plan_not_eligible")]
4553    Plan_not_eligible,
4554    #[serde(rename = "required_app_unavailable")]
4555    Required_app_unavailable,
4556    #[serde(rename = "unknown")]
4557    Unknown,
4558}
4559
4560#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4561#[serde(rename_all = "camelCase")]
4562pub struct PluginHookSummary {
4563    #[serde(rename = "eventName")]
4564    pub event_name: HookEventName,
4565    #[serde(default)]
4566    pub key: String,
4567}
4568
4569#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4570#[serde(rename_all = "camelCase")]
4571pub struct PluginInstallParams {
4572    #[serde(
4573        rename = "marketplacePath",
4574        default,
4575        skip_serializing_if = "Option::is_none"
4576    )]
4577    pub marketplace_path: Option<AbsolutePathBuf>,
4578    #[serde(rename = "pluginName", default)]
4579    pub plugin_name: String,
4580    #[serde(
4581        rename = "remoteMarketplaceName",
4582        default,
4583        skip_serializing_if = "Option::is_none"
4584    )]
4585    pub remote_marketplace_name: Option<String>,
4586}
4587
4588#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4589pub enum PluginInstallPolicy {
4590    #[serde(rename = "NOT_AVAILABLE")]
4591    NOT_AVAILABLE,
4592    #[serde(rename = "AVAILABLE")]
4593    AVAILABLE,
4594    #[serde(rename = "INSTALLED_BY_DEFAULT")]
4595    INSTALLED_BY_DEFAULT,
4596}
4597
4598#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4599pub enum PluginInstallPolicySource {
4600    #[serde(rename = "WORKSPACE_SETTING")]
4601    WORKSPACE_SETTING,
4602    #[serde(rename = "IMPLICIT_CANONICAL_APP")]
4603    IMPLICIT_CANONICAL_APP,
4604}
4605
4606#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4607#[serde(rename_all = "camelCase")]
4608pub struct PluginInstallResponse {
4609    #[serde(rename = "appsNeedingAuth", default)]
4610    pub apps_needing_auth: Vec<AppSummary>,
4611    #[serde(rename = "authPolicy")]
4612    pub auth_policy: PluginAuthPolicy,
4613}
4614
4615#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4616#[serde(rename_all = "camelCase")]
4617pub struct PluginInstalledParams {
4618    #[serde(default, skip_serializing_if = "Option::is_none")]
4619    pub cwds: Option<Vec<AbsolutePathBuf>>,
4620    #[serde(
4621        rename = "installSuggestionPluginNames",
4622        default,
4623        skip_serializing_if = "Option::is_none"
4624    )]
4625    pub install_suggestion_plugin_names: Option<Vec<String>>,
4626}
4627
4628#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4629#[serde(rename_all = "camelCase")]
4630pub struct PluginInstalledResponse {
4631    #[serde(
4632        rename = "marketplaceLoadErrors",
4633        default,
4634        skip_serializing_if = "Option::is_none"
4635    )]
4636    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
4637    #[serde(default)]
4638    pub marketplaces: Vec<PluginMarketplaceEntry>,
4639}
4640
4641#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4642#[serde(rename_all = "camelCase")]
4643pub struct PluginInterface {
4644    #[serde(
4645        rename = "brandColor",
4646        default,
4647        skip_serializing_if = "Option::is_none"
4648    )]
4649    pub brand_color: Option<String>,
4650    #[serde(default)]
4651    pub capabilities: Vec<String>,
4652    #[serde(default, skip_serializing_if = "Option::is_none")]
4653    pub category: Option<String>,
4654    #[serde(
4655        rename = "composerIcon",
4656        default,
4657        skip_serializing_if = "Option::is_none"
4658    )]
4659    pub composer_icon: Option<AbsolutePathBuf>,
4660    #[serde(
4661        rename = "composerIconUrl",
4662        default,
4663        skip_serializing_if = "Option::is_none"
4664    )]
4665    pub composer_icon_url: Option<String>,
4666    #[serde(
4667        rename = "defaultPrompt",
4668        default,
4669        skip_serializing_if = "Option::is_none"
4670    )]
4671    pub default_prompt: Option<Vec<String>>,
4672    #[serde(
4673        rename = "developerName",
4674        default,
4675        skip_serializing_if = "Option::is_none"
4676    )]
4677    pub developer_name: Option<String>,
4678    #[serde(
4679        rename = "displayName",
4680        default,
4681        skip_serializing_if = "Option::is_none"
4682    )]
4683    pub display_name: Option<String>,
4684    #[serde(default, skip_serializing_if = "Option::is_none")]
4685    pub logo: Option<AbsolutePathBuf>,
4686    #[serde(rename = "logoDark", default, skip_serializing_if = "Option::is_none")]
4687    pub logo_dark: Option<AbsolutePathBuf>,
4688    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
4689    pub logo_url: Option<String>,
4690    #[serde(
4691        rename = "logoUrlDark",
4692        default,
4693        skip_serializing_if = "Option::is_none"
4694    )]
4695    pub logo_url_dark: Option<String>,
4696    #[serde(
4697        rename = "longDescription",
4698        default,
4699        skip_serializing_if = "Option::is_none"
4700    )]
4701    pub long_description: Option<String>,
4702    #[serde(
4703        rename = "privacyPolicyUrl",
4704        default,
4705        skip_serializing_if = "Option::is_none"
4706    )]
4707    pub privacy_policy_url: Option<String>,
4708    #[serde(rename = "screenshotUrls", default)]
4709    pub screenshot_urls: Vec<String>,
4710    #[serde(default)]
4711    pub screenshots: Vec<AbsolutePathBuf>,
4712    #[serde(
4713        rename = "shortDescription",
4714        default,
4715        skip_serializing_if = "Option::is_none"
4716    )]
4717    pub short_description: Option<String>,
4718    #[serde(
4719        rename = "termsOfServiceUrl",
4720        default,
4721        skip_serializing_if = "Option::is_none"
4722    )]
4723    pub terms_of_service_url: Option<String>,
4724    #[serde(
4725        rename = "websiteUrl",
4726        default,
4727        skip_serializing_if = "Option::is_none"
4728    )]
4729    pub website_url: Option<String>,
4730}
4731
4732#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4733pub enum PluginListMarketplaceKind {
4734    #[serde(rename = "local")]
4735    Local,
4736    #[serde(rename = "vertical")]
4737    Vertical,
4738    #[serde(rename = "workspace-directory")]
4739    Workspace_directory,
4740    #[serde(rename = "shared-with-me")]
4741    Shared_with_me,
4742    #[serde(rename = "created-by-me-remote")]
4743    Created_by_me_remote,
4744}
4745
4746#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4747#[serde(rename_all = "camelCase")]
4748pub struct PluginListParams {
4749    #[serde(default, skip_serializing_if = "Option::is_none")]
4750    pub cwds: Option<Vec<AbsolutePathBuf>>,
4751    #[serde(
4752        rename = "forceRefetch",
4753        default,
4754        skip_serializing_if = "Option::is_none"
4755    )]
4756    pub force_refetch: Option<bool>,
4757    #[serde(
4758        rename = "marketplaceKinds",
4759        default,
4760        skip_serializing_if = "Option::is_none"
4761    )]
4762    pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
4763}
4764
4765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4766#[serde(rename_all = "camelCase")]
4767pub struct PluginListResponse {
4768    #[serde(
4769        rename = "featuredPluginIds",
4770        default,
4771        skip_serializing_if = "Option::is_none"
4772    )]
4773    pub featured_plugin_ids: Option<Vec<String>>,
4774    #[serde(
4775        rename = "marketplaceLoadErrors",
4776        default,
4777        skip_serializing_if = "Option::is_none"
4778    )]
4779    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
4780    #[serde(default)]
4781    pub marketplaces: Vec<PluginMarketplaceEntry>,
4782}
4783
4784#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4785#[serde(rename_all = "camelCase")]
4786pub struct PluginMarketplaceEntry {
4787    #[serde(default, skip_serializing_if = "Option::is_none")]
4788    pub interface: Option<MarketplaceInterface>,
4789    #[serde(default)]
4790    pub name: String,
4791    #[serde(default, skip_serializing_if = "Option::is_none")]
4792    pub path: Option<AbsolutePathBuf>,
4793    #[serde(default)]
4794    pub plugins: Vec<PluginSummary>,
4795}
4796
4797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4798#[serde(rename_all = "camelCase")]
4799pub struct PluginReadParams {
4800    #[serde(
4801        rename = "marketplacePath",
4802        default,
4803        skip_serializing_if = "Option::is_none"
4804    )]
4805    pub marketplace_path: Option<AbsolutePathBuf>,
4806    #[serde(rename = "pluginName", default)]
4807    pub plugin_name: String,
4808    #[serde(
4809        rename = "remoteMarketplaceName",
4810        default,
4811        skip_serializing_if = "Option::is_none"
4812    )]
4813    pub remote_marketplace_name: Option<String>,
4814}
4815
4816#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4817#[serde(rename_all = "camelCase")]
4818pub struct PluginReadResponse {
4819    #[serde()]
4820    pub plugin: PluginDetail,
4821}
4822
4823#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4824#[serde(rename_all = "camelCase")]
4825pub struct PluginShareCheckoutParams {
4826    #[serde(rename = "remotePluginId", default)]
4827    pub remote_plugin_id: String,
4828}
4829
4830#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4831#[serde(rename_all = "camelCase")]
4832pub struct PluginShareCheckoutResponse {
4833    #[serde(rename = "marketplaceName", default)]
4834    pub marketplace_name: String,
4835    #[serde(rename = "marketplacePath")]
4836    pub marketplace_path: AbsolutePathBuf,
4837    #[serde(rename = "pluginId", default)]
4838    pub plugin_id: String,
4839    #[serde(rename = "pluginName", default)]
4840    pub plugin_name: String,
4841    #[serde(rename = "pluginPath")]
4842    pub plugin_path: AbsolutePathBuf,
4843    #[serde(rename = "remotePluginId", default)]
4844    pub remote_plugin_id: String,
4845    #[serde(
4846        rename = "remoteVersion",
4847        default,
4848        skip_serializing_if = "Option::is_none"
4849    )]
4850    pub remote_version: Option<String>,
4851}
4852
4853#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4854#[serde(rename_all = "camelCase")]
4855pub struct PluginShareContext {
4856    #[serde(
4857        rename = "canPublishToWorkspace",
4858        default,
4859        skip_serializing_if = "Option::is_none"
4860    )]
4861    pub can_publish_to_workspace: Option<bool>,
4862    #[serde(
4863        rename = "creatorAccountUserId",
4864        default,
4865        skip_serializing_if = "Option::is_none"
4866    )]
4867    pub creator_account_user_id: Option<String>,
4868    #[serde(
4869        rename = "creatorName",
4870        default,
4871        skip_serializing_if = "Option::is_none"
4872    )]
4873    pub creator_name: Option<String>,
4874    #[serde(default, skip_serializing_if = "Option::is_none")]
4875    pub discoverability: Option<PluginShareDiscoverability>,
4876    #[serde(rename = "remotePluginId", default)]
4877    pub remote_plugin_id: String,
4878    #[serde(
4879        rename = "remoteVersion",
4880        default,
4881        skip_serializing_if = "Option::is_none"
4882    )]
4883    pub remote_version: Option<String>,
4884    #[serde(
4885        rename = "sharePrincipals",
4886        default,
4887        skip_serializing_if = "Option::is_none"
4888    )]
4889    pub share_principals: Option<Vec<PluginSharePrincipal>>,
4890    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
4891    pub share_url: Option<String>,
4892}
4893
4894#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4895#[serde(rename_all = "camelCase")]
4896pub struct PluginShareDeleteParams {
4897    #[serde(rename = "remotePluginId", default)]
4898    pub remote_plugin_id: String,
4899}
4900
4901#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4902#[serde(rename_all = "camelCase")]
4903pub struct PluginShareDeleteResponse {
4904    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4905    pub extra: serde_json::Map<String, Value>,
4906}
4907
4908#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4909pub enum PluginShareDiscoverability {
4910    #[serde(rename = "LISTED")]
4911    LISTED,
4912    #[serde(rename = "UNLISTED")]
4913    UNLISTED,
4914    #[serde(rename = "PRIVATE")]
4915    PRIVATE,
4916}
4917
4918#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4919#[serde(rename_all = "camelCase")]
4920pub struct PluginShareListItem {
4921    #[serde(
4922        rename = "localPluginPath",
4923        default,
4924        skip_serializing_if = "Option::is_none"
4925    )]
4926    pub local_plugin_path: Option<AbsolutePathBuf>,
4927    #[serde()]
4928    pub plugin: PluginSummary,
4929}
4930
4931#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4932#[serde(rename_all = "camelCase")]
4933pub struct PluginShareListParams {
4934    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4935    pub extra: serde_json::Map<String, Value>,
4936}
4937
4938#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4939#[serde(rename_all = "camelCase")]
4940pub struct PluginShareListResponse {
4941    #[serde(default)]
4942    pub data: Vec<PluginShareListItem>,
4943}
4944
4945#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4946#[serde(rename_all = "camelCase")]
4947pub struct PluginSharePrincipal {
4948    #[serde(default)]
4949    pub name: String,
4950    #[serde(rename = "principalId", default)]
4951    pub principal_id: String,
4952    #[serde(rename = "principalType")]
4953    pub principal_type: PluginSharePrincipalType,
4954    #[serde()]
4955    pub role: PluginSharePrincipalRole,
4956}
4957
4958#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4959pub enum PluginSharePrincipalRole {
4960    #[serde(rename = "reader")]
4961    Reader,
4962    #[serde(rename = "editor")]
4963    Editor,
4964    #[serde(rename = "owner")]
4965    Owner,
4966}
4967
4968#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4969pub enum PluginSharePrincipalType {
4970    #[serde(rename = "user")]
4971    User,
4972    #[serde(rename = "group")]
4973    Group,
4974    #[serde(rename = "workspace")]
4975    Workspace,
4976}
4977
4978#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4979#[serde(rename_all = "camelCase")]
4980pub struct PluginShareSaveParams {
4981    #[serde(default, skip_serializing_if = "Option::is_none")]
4982    pub discoverability: Option<PluginShareDiscoverability>,
4983    #[serde(rename = "pluginPath")]
4984    pub plugin_path: AbsolutePathBuf,
4985    #[serde(
4986        rename = "remotePluginId",
4987        default,
4988        skip_serializing_if = "Option::is_none"
4989    )]
4990    pub remote_plugin_id: Option<String>,
4991    #[serde(
4992        rename = "shareTargets",
4993        default,
4994        skip_serializing_if = "Option::is_none"
4995    )]
4996    pub share_targets: Option<Vec<PluginShareTarget>>,
4997}
4998
4999#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5000#[serde(rename_all = "camelCase")]
5001pub struct PluginShareSaveResponse {
5002    #[serde(
5003        rename = "canPublishToWorkspace",
5004        default,
5005        skip_serializing_if = "Option::is_none"
5006    )]
5007    pub can_publish_to_workspace: Option<bool>,
5008    #[serde(rename = "remotePluginId", default)]
5009    pub remote_plugin_id: String,
5010    #[serde(rename = "shareUrl", default)]
5011    pub share_url: String,
5012}
5013
5014#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5015#[serde(rename_all = "camelCase")]
5016pub struct PluginShareTarget {
5017    #[serde(rename = "principalId", default)]
5018    pub principal_id: String,
5019    #[serde(rename = "principalType")]
5020    pub principal_type: PluginSharePrincipalType,
5021    #[serde()]
5022    pub role: PluginShareTargetRole,
5023}
5024
5025#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5026pub enum PluginShareTargetRole {
5027    #[serde(rename = "reader")]
5028    Reader,
5029    #[serde(rename = "editor")]
5030    Editor,
5031}
5032
5033#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5034pub enum PluginShareUpdateDiscoverability {
5035    #[serde(rename = "UNLISTED")]
5036    UNLISTED,
5037    #[serde(rename = "PRIVATE")]
5038    PRIVATE,
5039    #[serde(rename = "LISTED")]
5040    LISTED,
5041}
5042
5043#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5044#[serde(rename_all = "camelCase")]
5045pub struct PluginShareUpdateTargetsParams {
5046    #[serde()]
5047    pub discoverability: PluginShareUpdateDiscoverability,
5048    #[serde(rename = "remotePluginId", default)]
5049    pub remote_plugin_id: String,
5050    #[serde(rename = "shareTargets", default)]
5051    pub share_targets: Vec<PluginShareTarget>,
5052}
5053
5054#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5055#[serde(rename_all = "camelCase")]
5056pub struct PluginShareUpdateTargetsResponse {
5057    #[serde()]
5058    pub discoverability: PluginShareDiscoverability,
5059    #[serde(default)]
5060    pub principals: Vec<PluginSharePrincipal>,
5061}
5062
5063#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5064#[serde(rename_all = "camelCase")]
5065pub struct PluginSkillReadParams {
5066    #[serde(rename = "remoteMarketplaceName", default)]
5067    pub remote_marketplace_name: String,
5068    #[serde(rename = "remotePluginId", default)]
5069    pub remote_plugin_id: String,
5070    #[serde(rename = "skillName", default)]
5071    pub skill_name: String,
5072}
5073
5074#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5075#[serde(rename_all = "camelCase")]
5076pub struct PluginSkillReadResponse {
5077    #[serde(default, skip_serializing_if = "Option::is_none")]
5078    pub contents: Option<String>,
5079}
5080
5081#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5082#[serde(tag = "type", rename_all = "camelCase")]
5083pub enum PluginSource {
5084    Local {
5085        path: AbsolutePathBuf,
5086    },
5087    Git {
5088        #[serde(default, skip_serializing_if = "Option::is_none")]
5089        path: Option<String>,
5090        #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
5091        ref_name: Option<String>,
5092        #[serde(default, skip_serializing_if = "Option::is_none")]
5093        sha: Option<String>,
5094        url: String,
5095    },
5096    Npm {
5097        package: String,
5098        #[serde(default, skip_serializing_if = "Option::is_none")]
5099        registry: Option<String>,
5100        #[serde(default, skip_serializing_if = "Option::is_none")]
5101        version: Option<String>,
5102    },
5103    Remote,
5104}
5105
5106#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5107#[serde(rename_all = "camelCase")]
5108pub struct PluginSummary {
5109    #[serde(rename = "authPolicy")]
5110    pub auth_policy: PluginAuthPolicy,
5111    #[serde(default, skip_serializing_if = "Option::is_none")]
5112    pub availability: Option<Value>,
5113    #[serde(
5114        rename = "disabledReason",
5115        default,
5116        skip_serializing_if = "Option::is_none"
5117    )]
5118    pub disabled_reason: Option<PluginDisabledReason>,
5119    #[serde(
5120        rename = "eligiblePlanTypes",
5121        default,
5122        skip_serializing_if = "Option::is_none"
5123    )]
5124    pub eligible_plan_types: Option<Vec<String>>,
5125    #[serde(default)]
5126    pub enabled: bool,
5127    #[serde(default)]
5128    pub id: String,
5129    #[serde(rename = "installPolicy")]
5130    pub install_policy: PluginInstallPolicy,
5131    #[serde(
5132        rename = "installPolicySource",
5133        default,
5134        skip_serializing_if = "Option::is_none"
5135    )]
5136    pub install_policy_source: Option<PluginInstallPolicySource>,
5137    #[serde(default)]
5138    pub installed: bool,
5139    #[serde(
5140        rename = "installedAt",
5141        default,
5142        skip_serializing_if = "Option::is_none"
5143    )]
5144    pub installed_at: Option<i64>,
5145    #[serde(default, skip_serializing_if = "Option::is_none")]
5146    pub interface: Option<PluginInterface>,
5147    #[serde(default, skip_serializing_if = "Option::is_none")]
5148    pub keywords: Option<Vec<String>>,
5149    #[serde(
5150        rename = "localVersion",
5151        default,
5152        skip_serializing_if = "Option::is_none"
5153    )]
5154    pub local_version: Option<String>,
5155    #[serde(
5156        rename = "mustShowInstallationInterstitial",
5157        default,
5158        skip_serializing_if = "Option::is_none"
5159    )]
5160    pub must_show_installation_interstitial: Option<bool>,
5161    #[serde(default)]
5162    pub name: String,
5163    #[serde(
5164        rename = "remotePluginId",
5165        default,
5166        skip_serializing_if = "Option::is_none"
5167    )]
5168    pub remote_plugin_id: Option<String>,
5169    #[serde(
5170        rename = "shareContext",
5171        default,
5172        skip_serializing_if = "Option::is_none"
5173    )]
5174    pub share_context: Option<PluginShareContext>,
5175    #[serde()]
5176    pub source: PluginSource,
5177    #[serde(default, skip_serializing_if = "Option::is_none")]
5178    pub version: Option<String>,
5179}
5180
5181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5182#[serde(rename_all = "camelCase")]
5183pub struct PluginUninstallParams {
5184    #[serde(rename = "pluginId", default)]
5185    pub plugin_id: String,
5186}
5187
5188#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5189#[serde(rename_all = "camelCase")]
5190pub struct PluginUninstallResponse {
5191    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5192    pub extra: serde_json::Map<String, Value>,
5193}
5194
5195#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5196#[serde(rename_all = "camelCase")]
5197pub struct PluginsMigration {
5198    #[serde(rename = "marketplaceName", default)]
5199    pub marketplace_name: String,
5200    #[serde(rename = "pluginNames", default)]
5201    pub plugin_names: Vec<String>,
5202}
5203
5204#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5205#[serde(rename_all = "camelCase")]
5206pub struct ProcessExitedNotification {
5207    #[serde(rename = "exitCode", default)]
5208    pub exit_code: i64,
5209    #[serde(rename = "processHandle", default)]
5210    pub process_handle: String,
5211    #[serde(default)]
5212    pub stderr: String,
5213    #[serde(rename = "stderrCapReached", default)]
5214    pub stderr_cap_reached: bool,
5215    #[serde(default)]
5216    pub stdout: String,
5217    #[serde(rename = "stdoutCapReached", default)]
5218    pub stdout_cap_reached: bool,
5219}
5220
5221#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5222#[serde(rename_all = "camelCase")]
5223pub struct ProcessOutputDeltaNotification {
5224    #[serde(rename = "capReached", default)]
5225    pub cap_reached: bool,
5226    #[serde(rename = "deltaBase64", default)]
5227    pub delta_base64: String,
5228    #[serde(rename = "processHandle", default)]
5229    pub process_handle: String,
5230    #[serde(default)]
5231    pub stream: Value,
5232}
5233
5234#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5235pub enum ProcessOutputStream {
5236    #[serde(rename = "stdout")]
5237    Stdout,
5238    #[serde(rename = "stderr")]
5239    Stderr,
5240}
5241
5242#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5243pub enum RateLimitReachedType {
5244    #[serde(rename = "rate_limit_reached")]
5245    Rate_limit_reached,
5246    #[serde(rename = "workspace_owner_credits_depleted")]
5247    Workspace_owner_credits_depleted,
5248    #[serde(rename = "workspace_member_credits_depleted")]
5249    Workspace_member_credits_depleted,
5250    #[serde(rename = "workspace_owner_usage_limit_reached")]
5251    Workspace_owner_usage_limit_reached,
5252    #[serde(rename = "workspace_member_usage_limit_reached")]
5253    Workspace_member_usage_limit_reached,
5254}
5255
5256#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5257#[serde(rename_all = "camelCase")]
5258pub struct RateLimitResetCredit {
5259    #[serde(default, skip_serializing_if = "Option::is_none")]
5260    pub description: Option<String>,
5261    #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
5262    pub expires_at: Option<i64>,
5263    #[serde(rename = "grantedAt", default)]
5264    pub granted_at: i64,
5265    #[serde(default)]
5266    pub id: String,
5267    #[serde(rename = "resetType")]
5268    pub reset_type: RateLimitResetType,
5269    #[serde()]
5270    pub status: RateLimitResetCreditStatus,
5271    #[serde(default, skip_serializing_if = "Option::is_none")]
5272    pub title: Option<String>,
5273}
5274
5275#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5276pub enum RateLimitResetCreditStatus {
5277    #[serde(rename = "available")]
5278    Available,
5279    #[serde(rename = "redeeming")]
5280    Redeeming,
5281    #[serde(rename = "redeemed")]
5282    Redeemed,
5283    #[serde(rename = "unknown")]
5284    Unknown,
5285}
5286
5287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5288#[serde(rename_all = "camelCase")]
5289pub struct RateLimitResetCreditsSummary {
5290    #[serde(rename = "availableCount", default)]
5291    pub available_count: i64,
5292    #[serde(default, skip_serializing_if = "Option::is_none")]
5293    pub credits: Option<Vec<RateLimitResetCredit>>,
5294}
5295
5296#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5297pub enum RateLimitResetType {
5298    #[serde(rename = "codexRateLimits")]
5299    CodexRateLimits,
5300    #[serde(rename = "unknown")]
5301    Unknown,
5302}
5303
5304#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5305#[serde(rename_all = "camelCase")]
5306pub struct RateLimitSnapshot {
5307    #[serde(default, skip_serializing_if = "Option::is_none")]
5308    pub credits: Option<CreditsSnapshot>,
5309    #[serde(
5310        rename = "individualLimit",
5311        default,
5312        skip_serializing_if = "Option::is_none"
5313    )]
5314    pub individual_limit: Option<SpendControlLimitSnapshot>,
5315    #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
5316    pub limit_id: Option<String>,
5317    #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
5318    pub limit_name: Option<String>,
5319    #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
5320    pub plan_type: Option<PlanType>,
5321    #[serde(default, skip_serializing_if = "Option::is_none")]
5322    pub primary: Option<RateLimitWindow>,
5323    #[serde(
5324        rename = "rateLimitReachedType",
5325        default,
5326        skip_serializing_if = "Option::is_none"
5327    )]
5328    pub rate_limit_reached_type: Option<RateLimitReachedType>,
5329    #[serde(default, skip_serializing_if = "Option::is_none")]
5330    pub secondary: Option<RateLimitWindow>,
5331    #[serde(
5332        rename = "spendControlReached",
5333        default,
5334        skip_serializing_if = "Option::is_none"
5335    )]
5336    pub spend_control_reached: Option<bool>,
5337}
5338
5339#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5340#[serde(rename_all = "camelCase")]
5341pub struct RateLimitWindow {
5342    #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
5343    pub resets_at: Option<i64>,
5344    #[serde(rename = "usedPercent", default)]
5345    pub used_percent: i64,
5346    #[serde(
5347        rename = "windowDurationMins",
5348        default,
5349        skip_serializing_if = "Option::is_none"
5350    )]
5351    pub window_duration_mins: Option<i64>,
5352}
5353
5354#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5355pub enum RealtimeConversationVersion {
5356    #[serde(rename = "v1")]
5357    V1,
5358    #[serde(rename = "v2")]
5359    V2,
5360    #[serde(rename = "v3")]
5361    V3,
5362}
5363
5364/// A non-empty reasoning effort value advertised by the model.
5365#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
5366#[serde(transparent)]
5367pub struct ReasoningEffort(pub String);
5368
5369#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5370#[serde(rename_all = "camelCase")]
5371pub struct ReasoningEffortOption {
5372    #[serde(default)]
5373    pub description: String,
5374    #[serde(rename = "reasoningEffort")]
5375    pub reasoning_effort: ReasoningEffort,
5376}
5377
5378#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5379pub enum ReasoningSummary {
5380    #[serde(rename = "auto")]
5381    Auto,
5382    #[serde(rename = "concise")]
5383    Concise,
5384    #[serde(rename = "detailed")]
5385    Detailed,
5386    #[serde(rename = "none")]
5387    None,
5388}
5389
5390#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5391#[serde(rename_all = "camelCase")]
5392pub struct ReasoningSummaryPartAddedNotification {
5393    #[serde(rename = "itemId", default)]
5394    pub item_id: String,
5395    #[serde(rename = "summaryIndex", default)]
5396    pub summary_index: i64,
5397    #[serde(rename = "threadId", default)]
5398    pub thread_id: String,
5399    #[serde(rename = "turnId", default)]
5400    pub turn_id: String,
5401}
5402
5403#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5404#[serde(rename_all = "camelCase")]
5405pub struct ReasoningSummaryTextDeltaNotification {
5406    #[serde(default)]
5407    pub delta: String,
5408    #[serde(rename = "itemId", default)]
5409    pub item_id: String,
5410    #[serde(rename = "summaryIndex", default)]
5411    pub summary_index: i64,
5412    #[serde(rename = "threadId", default)]
5413    pub thread_id: String,
5414    #[serde(rename = "turnId", default)]
5415    pub turn_id: String,
5416}
5417
5418#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5419#[serde(rename_all = "camelCase")]
5420pub struct ReasoningTextDeltaNotification {
5421    #[serde(rename = "contentIndex", default)]
5422    pub content_index: i64,
5423    #[serde(default)]
5424    pub delta: String,
5425    #[serde(rename = "itemId", default)]
5426    pub item_id: String,
5427    #[serde(rename = "threadId", default)]
5428    pub thread_id: String,
5429    #[serde(rename = "turnId", default)]
5430    pub turn_id: String,
5431}
5432
5433#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5434pub enum RemoteControlConnectionStatus {
5435    #[serde(rename = "disabled")]
5436    Disabled,
5437    #[serde(rename = "connecting")]
5438    Connecting,
5439    #[serde(rename = "connected")]
5440    Connected,
5441    #[serde(rename = "errored")]
5442    Errored,
5443}
5444
5445#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5446#[serde(rename_all = "camelCase")]
5447pub struct RemoteControlStatusChangedNotification {
5448    #[serde(
5449        rename = "environmentId",
5450        default,
5451        skip_serializing_if = "Option::is_none"
5452    )]
5453    pub environment_id: Option<String>,
5454    #[serde(rename = "installationId", default)]
5455    pub installation_id: String,
5456    #[serde(rename = "serverName", default)]
5457    pub server_name: String,
5458    #[serde()]
5459    pub status: RemoteControlConnectionStatus,
5460}
5461
5462#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5463#[serde(untagged)]
5464pub enum RequestId {
5465    Variant0(String),
5466    Variant1(i64),
5467}
5468
5469#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5470#[serde(rename_all = "camelCase")]
5471pub struct RequestPermissionProfile {
5472    #[serde(
5473        rename = "fileSystem",
5474        default,
5475        skip_serializing_if = "Option::is_none"
5476    )]
5477    pub file_system: Option<AdditionalFileSystemPermissions>,
5478    #[serde(default, skip_serializing_if = "Option::is_none")]
5479    pub network: Option<AdditionalNetworkPermissions>,
5480}
5481
5482#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5483pub enum ResidencyRequirement {
5484    #[serde(rename = "us")]
5485    Us,
5486}
5487
5488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5489#[serde(rename_all = "camelCase")]
5490pub struct Resource {
5491    #[serde(default, skip_serializing_if = "Option::is_none")]
5492    pub _meta: Option<Value>,
5493    #[serde(default, skip_serializing_if = "Option::is_none")]
5494    pub annotations: Option<Value>,
5495    #[serde(default, skip_serializing_if = "Option::is_none")]
5496    pub description: Option<String>,
5497    #[serde(default, skip_serializing_if = "Option::is_none")]
5498    pub icons: Option<Vec<Value>>,
5499    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
5500    pub mime_type: Option<String>,
5501    #[serde(default)]
5502    pub name: String,
5503    #[serde(default, skip_serializing_if = "Option::is_none")]
5504    pub size: Option<i64>,
5505    #[serde(default, skip_serializing_if = "Option::is_none")]
5506    pub title: Option<String>,
5507    #[serde(default)]
5508    pub uri: String,
5509}
5510
5511#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5512#[serde(untagged)]
5513pub enum ResourceContent {
5514    Variant0(Value),
5515    Variant1(Value),
5516}
5517
5518#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5519#[serde(rename_all = "camelCase")]
5520pub struct ResourceTemplate {
5521    #[serde(default, skip_serializing_if = "Option::is_none")]
5522    pub annotations: Option<Value>,
5523    #[serde(default, skip_serializing_if = "Option::is_none")]
5524    pub description: Option<String>,
5525    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
5526    pub mime_type: Option<String>,
5527    #[serde(default)]
5528    pub name: String,
5529    #[serde(default, skip_serializing_if = "Option::is_none")]
5530    pub title: Option<String>,
5531    #[serde(rename = "uriTemplate", default)]
5532    pub uri_template: String,
5533}
5534
5535#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5536pub enum ReviewDecision {
5537    #[serde(rename = "approved")]
5538    Approved,
5539    #[serde(rename = "approved_execpolicy_amendment")]
5540    ApprovedExecpolicyAmendment {
5541        proposed_execpolicy_amendment: Vec<String>,
5542    },
5543    #[serde(rename = "approved_for_session")]
5544    ApprovedForSession,
5545    #[serde(rename = "network_policy_amendment")]
5546    NetworkPolicyAmendment {
5547        network_policy_amendment: NetworkPolicyAmendment,
5548    },
5549    #[serde(rename = "denied")]
5550    Denied { rejection: String },
5551    #[serde(rename = "timed_out")]
5552    TimedOut,
5553    #[serde(rename = "abort")]
5554    Abort,
5555}
5556
5557#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5558pub enum ReviewDelivery {
5559    #[serde(rename = "inline")]
5560    Inline,
5561    #[serde(rename = "detached")]
5562    Detached,
5563}
5564
5565#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5566#[serde(rename_all = "camelCase")]
5567pub struct ReviewStartParams {
5568    #[serde(default, skip_serializing_if = "Option::is_none")]
5569    pub delivery: Option<ReviewDelivery>,
5570    #[serde()]
5571    pub target: ReviewTarget,
5572    #[serde(rename = "threadId", default)]
5573    pub thread_id: String,
5574}
5575
5576#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5577#[serde(rename_all = "camelCase")]
5578pub struct ReviewStartResponse {
5579    #[serde(rename = "reviewThreadId", default)]
5580    pub review_thread_id: String,
5581    #[serde()]
5582    pub turn: Turn,
5583}
5584
5585#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5586#[serde(tag = "type", rename_all = "camelCase")]
5587pub enum ReviewTarget {
5588    #[serde(rename = "uncommittedChanges")]
5589    UncommittedChanges,
5590    #[serde(rename = "baseBranch")]
5591    BaseBranch {
5592        branch: String,
5593    },
5594    Commit {
5595        sha: String,
5596        #[serde(default, skip_serializing_if = "Option::is_none")]
5597        title: Option<String>,
5598    },
5599    Custom {
5600        instructions: String,
5601    },
5602}
5603
5604#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5605pub enum SandboxMode {
5606    #[serde(rename = "read-only")]
5607    Read_only,
5608    #[serde(rename = "workspace-write")]
5609    Workspace_write,
5610    #[serde(rename = "danger-full-access")]
5611    Danger_full_access,
5612}
5613
5614#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5615#[serde(tag = "type", rename_all = "camelCase")]
5616pub enum SandboxPolicy {
5617    #[serde(rename = "dangerFullAccess")]
5618    DangerFullAccess,
5619    #[serde(rename = "readOnly")]
5620    ReadOnly {
5621        #[serde(
5622            rename = "networkAccess",
5623            default,
5624            skip_serializing_if = "Option::is_none"
5625        )]
5626        network_access: Option<bool>,
5627    },
5628    #[serde(rename = "externalSandbox")]
5629    ExternalSandbox {
5630        #[serde(
5631            rename = "networkAccess",
5632            default,
5633            skip_serializing_if = "Option::is_none"
5634        )]
5635        network_access: Option<Value>,
5636    },
5637    #[serde(rename = "workspaceWrite")]
5638    WorkspaceWrite {
5639        #[serde(
5640            rename = "excludeSlashTmp",
5641            default,
5642            skip_serializing_if = "Option::is_none"
5643        )]
5644        exclude_slash_tmp: Option<bool>,
5645        #[serde(
5646            rename = "excludeTmpdirEnvVar",
5647            default,
5648            skip_serializing_if = "Option::is_none"
5649        )]
5650        exclude_tmpdir_env_var: Option<bool>,
5651        #[serde(
5652            rename = "networkAccess",
5653            default,
5654            skip_serializing_if = "Option::is_none"
5655        )]
5656        network_access: Option<bool>,
5657        #[serde(
5658            rename = "writableRoots",
5659            default,
5660            skip_serializing_if = "Option::is_none"
5661        )]
5662        writable_roots: Option<Vec<AbsolutePathBuf>>,
5663    },
5664}
5665
5666#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5667#[serde(rename_all = "camelCase")]
5668pub struct SandboxWorkspaceWrite {
5669    #[serde(default, skip_serializing_if = "Option::is_none")]
5670    pub exclude_slash_tmp: Option<bool>,
5671    #[serde(default, skip_serializing_if = "Option::is_none")]
5672    pub exclude_tmpdir_env_var: Option<bool>,
5673    #[serde(default, skip_serializing_if = "Option::is_none")]
5674    pub network_access: Option<bool>,
5675    #[serde(default, skip_serializing_if = "Option::is_none")]
5676    pub writable_roots: Option<Vec<String>>,
5677}
5678
5679#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5680#[serde(tag = "type", rename_all = "camelCase")]
5681pub enum ScheduledTaskSchedule {
5682    Hourly {
5683        #[serde(default, skip_serializing_if = "Option::is_none")]
5684        days: Option<Vec<ScheduledTaskWeekday>>,
5685        #[serde(rename = "intervalHours")]
5686        interval_hours: i64,
5687    },
5688    Daily {
5689        time: String,
5690    },
5691    Weekdays {
5692        time: String,
5693    },
5694    Weekly {
5695        days: Vec<ScheduledTaskWeekday>,
5696        time: String,
5697    },
5698}
5699
5700#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5701#[serde(rename_all = "camelCase")]
5702pub struct ScheduledTaskSummary {
5703    #[serde(default)]
5704    pub key: String,
5705    #[serde(default)]
5706    pub name: String,
5707    #[serde(default)]
5708    pub prompt: String,
5709    #[serde()]
5710    pub schedule: ScheduledTaskSchedule,
5711}
5712
5713#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5714pub enum ScheduledTaskWeekday {
5715    #[serde(rename = "MO")]
5716    MO,
5717    #[serde(rename = "TU")]
5718    TU,
5719    #[serde(rename = "WE")]
5720    WE,
5721    #[serde(rename = "TH")]
5722    TH,
5723    #[serde(rename = "FR")]
5724    FR,
5725    #[serde(rename = "SA")]
5726    SA,
5727    #[serde(rename = "SU")]
5728    SU,
5729}
5730
5731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5732#[serde(rename_all = "camelCase")]
5733pub struct SendAddCreditsNudgeEmailParams {
5734    #[serde(rename = "creditType")]
5735    pub credit_type: AddCreditsNudgeCreditType,
5736}
5737
5738#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5739#[serde(rename_all = "camelCase")]
5740pub struct SendAddCreditsNudgeEmailResponse {
5741    #[serde()]
5742    pub status: AddCreditsNudgeEmailStatus,
5743}
5744
5745#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5746#[serde(rename_all = "camelCase")]
5747pub struct ServerRequestResolvedNotification {
5748    #[serde(rename = "requestId")]
5749    pub request_id: RequestId,
5750    #[serde(rename = "threadId", default)]
5751    pub thread_id: String,
5752}
5753
5754#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5755#[serde(rename_all = "camelCase")]
5756pub struct SessionMigration {
5757    #[serde(default)]
5758    pub cwd: String,
5759    #[serde(default)]
5760    pub path: String,
5761    #[serde(default, skip_serializing_if = "Option::is_none")]
5762    pub title: Option<String>,
5763}
5764
5765#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5766pub enum SessionSource {
5767    #[serde(rename = "cli")]
5768    Cli,
5769    #[serde(rename = "vscode")]
5770    Vscode,
5771    #[serde(rename = "exec")]
5772    Exec,
5773    #[serde(rename = "appServer")]
5774    AppServer,
5775    #[serde(rename = "unknown")]
5776    Unknown,
5777    #[serde(rename = "custom")]
5778    Custom(String),
5779    #[serde(rename = "subAgent")]
5780    SubAgent(SubAgentSource),
5781}
5782
5783#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5784#[serde(rename_all = "camelCase")]
5785pub struct Settings {
5786    #[serde(default, skip_serializing_if = "Option::is_none")]
5787    pub developer_instructions: Option<String>,
5788    #[serde(default)]
5789    pub model: String,
5790    #[serde(default, skip_serializing_if = "Option::is_none")]
5791    pub reasoning_effort: Option<ReasoningEffort>,
5792}
5793
5794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5795#[serde(rename_all = "camelCase")]
5796pub struct SkillDependencies {
5797    #[serde(default)]
5798    pub tools: Vec<SkillToolDependency>,
5799}
5800
5801#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5802#[serde(rename_all = "camelCase")]
5803pub struct SkillErrorInfo {
5804    #[serde(default)]
5805    pub message: String,
5806    #[serde(default)]
5807    pub path: String,
5808}
5809
5810#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5811#[serde(rename_all = "camelCase")]
5812pub struct SkillInterface {
5813    #[serde(
5814        rename = "brandColor",
5815        default,
5816        skip_serializing_if = "Option::is_none"
5817    )]
5818    pub brand_color: Option<String>,
5819    #[serde(
5820        rename = "defaultPrompt",
5821        default,
5822        skip_serializing_if = "Option::is_none"
5823    )]
5824    pub default_prompt: Option<String>,
5825    #[serde(
5826        rename = "displayName",
5827        default,
5828        skip_serializing_if = "Option::is_none"
5829    )]
5830    pub display_name: Option<String>,
5831    #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
5832    pub icon_large: Option<AbsolutePathBuf>,
5833    #[serde(
5834        rename = "iconLargeUrl",
5835        default,
5836        skip_serializing_if = "Option::is_none"
5837    )]
5838    pub icon_large_url: Option<String>,
5839    #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
5840    pub icon_small: Option<AbsolutePathBuf>,
5841    #[serde(
5842        rename = "iconSmallUrl",
5843        default,
5844        skip_serializing_if = "Option::is_none"
5845    )]
5846    pub icon_small_url: Option<String>,
5847    #[serde(
5848        rename = "shortDescription",
5849        default,
5850        skip_serializing_if = "Option::is_none"
5851    )]
5852    pub short_description: Option<String>,
5853}
5854
5855#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5856#[serde(rename_all = "camelCase")]
5857pub struct SkillMetadata {
5858    #[serde(default, skip_serializing_if = "Option::is_none")]
5859    pub dependencies: Option<SkillDependencies>,
5860    #[serde(default)]
5861    pub description: String,
5862    #[serde(default)]
5863    pub enabled: bool,
5864    #[serde(default, skip_serializing_if = "Option::is_none")]
5865    pub interface: Option<SkillInterface>,
5866    #[serde(default)]
5867    pub name: String,
5868    #[serde()]
5869    pub path: AbsolutePathBuf,
5870    #[serde()]
5871    pub scope: SkillScope,
5872    #[serde(
5873        rename = "shortDescription",
5874        default,
5875        skip_serializing_if = "Option::is_none"
5876    )]
5877    pub short_description: Option<String>,
5878}
5879
5880#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5881#[serde(rename_all = "camelCase")]
5882pub struct SkillMigration {
5883    #[serde(default)]
5884    pub name: String,
5885}
5886
5887#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5888pub enum SkillScope {
5889    #[serde(rename = "user")]
5890    User,
5891    #[serde(rename = "repo")]
5892    Repo,
5893    #[serde(rename = "system")]
5894    System,
5895    #[serde(rename = "admin")]
5896    Admin,
5897}
5898
5899#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5900#[serde(rename_all = "camelCase")]
5901pub struct SkillSummary {
5902    #[serde(default)]
5903    pub description: String,
5904    #[serde(default)]
5905    pub enabled: bool,
5906    #[serde(default, skip_serializing_if = "Option::is_none")]
5907    pub interface: Option<SkillInterface>,
5908    #[serde(default)]
5909    pub name: String,
5910    #[serde(default, skip_serializing_if = "Option::is_none")]
5911    pub path: Option<AbsolutePathBuf>,
5912    #[serde(
5913        rename = "shortDescription",
5914        default,
5915        skip_serializing_if = "Option::is_none"
5916    )]
5917    pub short_description: Option<String>,
5918}
5919
5920#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5921#[serde(rename_all = "camelCase")]
5922pub struct SkillToolDependency {
5923    #[serde(default, skip_serializing_if = "Option::is_none")]
5924    pub command: Option<String>,
5925    #[serde(default, skip_serializing_if = "Option::is_none")]
5926    pub description: Option<String>,
5927    #[serde(default, skip_serializing_if = "Option::is_none")]
5928    pub transport: Option<String>,
5929    #[serde(rename = "type", default)]
5930    pub type_: String,
5931    #[serde(default, skip_serializing_if = "Option::is_none")]
5932    pub url: Option<String>,
5933    #[serde(default)]
5934    pub value: String,
5935}
5936
5937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5938#[serde(rename_all = "camelCase")]
5939pub struct SkillsChangedNotification {
5940    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5941    pub extra: serde_json::Map<String, Value>,
5942}
5943
5944#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5945#[serde(rename_all = "camelCase")]
5946pub struct SkillsConfigWriteParams {
5947    #[serde(default)]
5948    pub enabled: bool,
5949    #[serde(default, skip_serializing_if = "Option::is_none")]
5950    pub name: Option<String>,
5951    #[serde(default, skip_serializing_if = "Option::is_none")]
5952    pub path: Option<AbsolutePathBuf>,
5953}
5954
5955#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5956#[serde(rename_all = "camelCase")]
5957pub struct SkillsConfigWriteResponse {
5958    #[serde(rename = "effectiveEnabled", default)]
5959    pub effective_enabled: bool,
5960}
5961
5962#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5963#[serde(rename_all = "camelCase")]
5964pub struct SkillsExtraRootsSetParams {
5965    #[serde(rename = "extraRoots", default)]
5966    pub extra_roots: Vec<AbsolutePathBuf>,
5967}
5968
5969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5970#[serde(rename_all = "camelCase")]
5971pub struct SkillsExtraRootsSetResponse {
5972    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5973    pub extra: serde_json::Map<String, Value>,
5974}
5975
5976#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5977#[serde(rename_all = "camelCase")]
5978pub struct SkillsListEntry {
5979    #[serde(default)]
5980    pub cwd: String,
5981    #[serde(default)]
5982    pub errors: Vec<SkillErrorInfo>,
5983    #[serde(default)]
5984    pub skills: Vec<SkillMetadata>,
5985}
5986
5987#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5988#[serde(rename_all = "camelCase")]
5989pub struct SkillsListParams {
5990    #[serde(default, skip_serializing_if = "Option::is_none")]
5991    pub cwds: Option<Vec<String>>,
5992    #[serde(
5993        rename = "forceReload",
5994        default,
5995        skip_serializing_if = "Option::is_none"
5996    )]
5997    pub force_reload: Option<bool>,
5998}
5999
6000#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6001#[serde(rename_all = "camelCase")]
6002pub struct SkillsListResponse {
6003    #[serde(default)]
6004    pub data: Vec<SkillsListEntry>,
6005}
6006
6007#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6008pub enum SortDirection {
6009    #[serde(rename = "asc")]
6010    Asc,
6011    #[serde(rename = "desc")]
6012    Desc,
6013}
6014
6015#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6016#[serde(rename_all = "camelCase")]
6017pub struct SpendControlLimitSnapshot {
6018    #[serde(default)]
6019    pub limit: String,
6020    #[serde(rename = "remainingPercent", default)]
6021    pub remaining_percent: i64,
6022    #[serde(rename = "resetsAt", default)]
6023    pub resets_at: i64,
6024    #[serde(default)]
6025    pub used: String,
6026}
6027
6028#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6029pub enum SubAgentActivityKind {
6030    #[serde(rename = "started")]
6031    Started,
6032    #[serde(rename = "interacted")]
6033    Interacted,
6034    #[serde(rename = "interrupted")]
6035    Interrupted,
6036}
6037
6038#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6039pub enum SubAgentSource {
6040    #[serde(rename = "review")]
6041    Review,
6042    #[serde(rename = "compact")]
6043    Compact,
6044    #[serde(rename = "memory_consolidation")]
6045    MemoryConsolidation,
6046    #[serde(rename = "thread_spawn")]
6047    ThreadSpawn {
6048        #[serde(default, skip_serializing_if = "Option::is_none")]
6049        agent_nickname: Option<String>,
6050        #[serde(default, skip_serializing_if = "Option::is_none")]
6051        agent_path: Option<AgentPath>,
6052        #[serde(default, skip_serializing_if = "Option::is_none")]
6053        agent_role: Option<String>,
6054        depth: i64,
6055        parent_thread_id: ThreadId,
6056    },
6057    #[serde(rename = "other")]
6058    Other(String),
6059}
6060
6061#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6062#[serde(rename_all = "camelCase")]
6063pub struct SubagentMigration {
6064    #[serde(default)]
6065    pub name: String,
6066}
6067
6068#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6069#[serde(rename_all = "camelCase")]
6070pub struct TerminalInteractionNotification {
6071    #[serde(rename = "itemId", default)]
6072    pub item_id: String,
6073    #[serde(rename = "processId", default)]
6074    pub process_id: String,
6075    #[serde(default)]
6076    pub stdin: String,
6077    #[serde(rename = "threadId", default)]
6078    pub thread_id: String,
6079    #[serde(rename = "turnId", default)]
6080    pub turn_id: String,
6081}
6082
6083#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6084#[serde(rename_all = "camelCase")]
6085pub struct TextElement {
6086    #[serde(rename = "byteRange", default)]
6087    pub byte_range: Value,
6088    #[serde(default, skip_serializing_if = "Option::is_none")]
6089    pub placeholder: Option<String>,
6090}
6091
6092#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6093#[serde(rename_all = "camelCase")]
6094pub struct TextPosition {
6095    #[serde(default)]
6096    pub column: i64,
6097    #[serde(default)]
6098    pub line: i64,
6099}
6100
6101#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6102#[serde(rename_all = "camelCase")]
6103pub struct TextRange {
6104    #[serde()]
6105    pub end: TextPosition,
6106    #[serde()]
6107    pub start: TextPosition,
6108}
6109
6110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6111#[serde(rename_all = "camelCase")]
6112pub struct Thread {
6113    #[serde(
6114        rename = "agentNickname",
6115        default,
6116        skip_serializing_if = "Option::is_none"
6117    )]
6118    pub agent_nickname: Option<String>,
6119    #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
6120    pub agent_role: Option<String>,
6121    #[serde(rename = "cliVersion", default)]
6122    pub cli_version: String,
6123    #[serde(rename = "createdAt", default)]
6124    pub created_at: i64,
6125    #[serde(default)]
6126    pub cwd: Value,
6127    #[serde(default)]
6128    pub ephemeral: bool,
6129    #[serde(
6130        rename = "forkedFromId",
6131        default,
6132        skip_serializing_if = "Option::is_none"
6133    )]
6134    pub forked_from_id: Option<String>,
6135    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
6136    pub git_info: Option<GitInfo>,
6137    #[serde(default)]
6138    pub id: String,
6139    #[serde(rename = "modelProvider", default)]
6140    pub model_provider: String,
6141    #[serde(default, skip_serializing_if = "Option::is_none")]
6142    pub name: Option<String>,
6143    #[serde(
6144        rename = "parentThreadId",
6145        default,
6146        skip_serializing_if = "Option::is_none"
6147    )]
6148    pub parent_thread_id: Option<String>,
6149    #[serde(default, skip_serializing_if = "Option::is_none")]
6150    pub path: Option<String>,
6151    #[serde(default)]
6152    pub preview: String,
6153    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
6154    pub recency_at: Option<i64>,
6155    #[serde(default, skip_serializing_if = "Option::is_none")]
6156    pub section: Option<ThreadSection>,
6157    #[serde(
6158        rename = "sectionEnteredAt",
6159        default,
6160        skip_serializing_if = "Option::is_none"
6161    )]
6162    pub section_entered_at: Option<i64>,
6163    #[serde(rename = "sessionId", default)]
6164    pub session_id: String,
6165    #[serde(default)]
6166    pub source: Value,
6167    #[serde(default)]
6168    pub status: Value,
6169    #[serde(
6170        rename = "threadSource",
6171        default,
6172        skip_serializing_if = "Option::is_none"
6173    )]
6174    pub thread_source: Option<ThreadSource>,
6175    #[serde(default)]
6176    pub turns: Vec<Turn>,
6177    #[serde(rename = "updatedAt", default)]
6178    pub updated_at: i64,
6179}
6180
6181#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6182pub enum ThreadActiveFlag {
6183    #[serde(rename = "waitingOnApproval")]
6184    WaitingOnApproval,
6185    #[serde(rename = "waitingOnUserInput")]
6186    WaitingOnUserInput,
6187}
6188
6189#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6190#[serde(rename_all = "camelCase")]
6191pub struct ThreadApproveGuardianDeniedActionParams {
6192    #[serde(default)]
6193    pub event: Value,
6194    #[serde(rename = "threadId", default)]
6195    pub thread_id: String,
6196}
6197
6198#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6199#[serde(rename_all = "camelCase")]
6200pub struct ThreadApproveGuardianDeniedActionResponse {
6201    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6202    pub extra: serde_json::Map<String, Value>,
6203}
6204
6205#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6206#[serde(rename_all = "camelCase")]
6207pub struct ThreadArchiveParams {
6208    #[serde(rename = "threadId", default)]
6209    pub thread_id: String,
6210}
6211
6212#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6213#[serde(rename_all = "camelCase")]
6214pub struct ThreadArchiveResponse {
6215    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6216    pub extra: serde_json::Map<String, Value>,
6217}
6218
6219#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6220#[serde(rename_all = "camelCase")]
6221pub struct ThreadArchivedNotification {
6222    #[serde(rename = "threadId", default)]
6223    pub thread_id: String,
6224}
6225
6226#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6227#[serde(rename_all = "camelCase")]
6228pub struct ThreadClosedNotification {
6229    #[serde(rename = "threadId", default)]
6230    pub thread_id: String,
6231}
6232
6233#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6234#[serde(rename_all = "camelCase")]
6235pub struct ThreadCompactStartParams {
6236    #[serde(rename = "threadId", default)]
6237    pub thread_id: String,
6238}
6239
6240#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6241#[serde(rename_all = "camelCase")]
6242pub struct ThreadCompactStartResponse {
6243    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6244    pub extra: serde_json::Map<String, Value>,
6245}
6246
6247#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6248#[serde(rename_all = "camelCase")]
6249pub struct ThreadDeleteParams {
6250    #[serde(rename = "threadId", default)]
6251    pub thread_id: String,
6252}
6253
6254#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6255#[serde(rename_all = "camelCase")]
6256pub struct ThreadDeleteResponse {
6257    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6258    pub extra: serde_json::Map<String, Value>,
6259}
6260
6261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6262#[serde(rename_all = "camelCase")]
6263pub struct ThreadDeletedNotification {
6264    #[serde(rename = "threadId", default)]
6265    pub thread_id: String,
6266}
6267
6268#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6269#[serde(rename_all = "camelCase")]
6270pub struct ThreadForkParams {
6271    #[serde(
6272        rename = "approvalPolicy",
6273        default,
6274        skip_serializing_if = "Option::is_none"
6275    )]
6276    pub approval_policy: Option<AskForApproval>,
6277    #[serde(
6278        rename = "approvalsReviewer",
6279        default,
6280        skip_serializing_if = "Option::is_none"
6281    )]
6282    pub approvals_reviewer: Option<ApprovalsReviewer>,
6283    #[serde(
6284        rename = "baseInstructions",
6285        default,
6286        skip_serializing_if = "Option::is_none"
6287    )]
6288    pub base_instructions: Option<String>,
6289    #[serde(default, skip_serializing_if = "Option::is_none")]
6290    pub config: Option<Value>,
6291    #[serde(default, skip_serializing_if = "Option::is_none")]
6292    pub cwd: Option<String>,
6293    #[serde(
6294        rename = "developerInstructions",
6295        default,
6296        skip_serializing_if = "Option::is_none"
6297    )]
6298    pub developer_instructions: Option<String>,
6299    #[serde(default, skip_serializing_if = "Option::is_none")]
6300    pub ephemeral: Option<bool>,
6301    #[serde(
6302        rename = "lastTurnId",
6303        default,
6304        skip_serializing_if = "Option::is_none"
6305    )]
6306    pub last_turn_id: Option<String>,
6307    #[serde(default, skip_serializing_if = "Option::is_none")]
6308    pub model: Option<String>,
6309    #[serde(
6310        rename = "modelProvider",
6311        default,
6312        skip_serializing_if = "Option::is_none"
6313    )]
6314    pub model_provider: Option<String>,
6315    #[serde(default, skip_serializing_if = "Option::is_none")]
6316    pub sandbox: Option<SandboxMode>,
6317    #[serde(
6318        rename = "serviceTier",
6319        default,
6320        skip_serializing_if = "Option::is_none"
6321    )]
6322    pub service_tier: Option<String>,
6323    #[serde(rename = "threadId", default)]
6324    pub thread_id: String,
6325    #[serde(
6326        rename = "threadSource",
6327        default,
6328        skip_serializing_if = "Option::is_none"
6329    )]
6330    pub thread_source: Option<ThreadSource>,
6331}
6332
6333#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6334#[serde(rename_all = "camelCase")]
6335pub struct ThreadForkResponse {
6336    #[serde(rename = "approvalPolicy")]
6337    pub approval_policy: AskForApproval,
6338    #[serde(rename = "approvalsReviewer", default)]
6339    pub approvals_reviewer: Value,
6340    #[serde()]
6341    pub cwd: AbsolutePathBuf,
6342    #[serde(
6343        rename = "instructionSources",
6344        default,
6345        skip_serializing_if = "Option::is_none"
6346    )]
6347    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
6348    #[serde(default)]
6349    pub model: String,
6350    #[serde(rename = "modelProvider", default)]
6351    pub model_provider: String,
6352    #[serde(
6353        rename = "reasoningEffort",
6354        default,
6355        skip_serializing_if = "Option::is_none"
6356    )]
6357    pub reasoning_effort: Option<ReasoningEffort>,
6358    #[serde(default)]
6359    pub sandbox: Value,
6360    #[serde(
6361        rename = "serviceTier",
6362        default,
6363        skip_serializing_if = "Option::is_none"
6364    )]
6365    pub service_tier: Option<String>,
6366    #[serde()]
6367    pub thread: Thread,
6368}
6369
6370#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6371#[serde(rename_all = "camelCase")]
6372pub struct ThreadGoal {
6373    #[serde(rename = "createdAt", default)]
6374    pub created_at: i64,
6375    #[serde(default)]
6376    pub objective: String,
6377    #[serde()]
6378    pub status: ThreadGoalStatus,
6379    #[serde(rename = "threadId", default)]
6380    pub thread_id: String,
6381    #[serde(rename = "timeUsedSeconds", default)]
6382    pub time_used_seconds: i64,
6383    #[serde(
6384        rename = "tokenBudget",
6385        default,
6386        skip_serializing_if = "Option::is_none"
6387    )]
6388    pub token_budget: Option<i64>,
6389    #[serde(rename = "tokensUsed", default)]
6390    pub tokens_used: i64,
6391    #[serde(rename = "updatedAt", default)]
6392    pub updated_at: i64,
6393}
6394
6395#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6396#[serde(rename_all = "camelCase")]
6397pub struct ThreadGoalClearParams {
6398    #[serde(rename = "threadId", default)]
6399    pub thread_id: String,
6400}
6401
6402#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6403#[serde(rename_all = "camelCase")]
6404pub struct ThreadGoalClearResponse {
6405    #[serde(default)]
6406    pub cleared: bool,
6407}
6408
6409#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6410#[serde(rename_all = "camelCase")]
6411pub struct ThreadGoalClearedNotification {
6412    #[serde(rename = "threadId", default)]
6413    pub thread_id: String,
6414}
6415
6416#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6417#[serde(rename_all = "camelCase")]
6418pub struct ThreadGoalGetParams {
6419    #[serde(rename = "threadId", default)]
6420    pub thread_id: String,
6421}
6422
6423#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6424#[serde(rename_all = "camelCase")]
6425pub struct ThreadGoalGetResponse {
6426    #[serde(default, skip_serializing_if = "Option::is_none")]
6427    pub goal: Option<ThreadGoal>,
6428}
6429
6430#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6431#[serde(rename_all = "camelCase")]
6432pub struct ThreadGoalSetParams {
6433    #[serde(default, skip_serializing_if = "Option::is_none")]
6434    pub objective: Option<String>,
6435    #[serde(default, skip_serializing_if = "Option::is_none")]
6436    pub status: Option<ThreadGoalStatus>,
6437    #[serde(rename = "threadId", default)]
6438    pub thread_id: String,
6439    #[serde(
6440        rename = "tokenBudget",
6441        default,
6442        skip_serializing_if = "Option::is_none"
6443    )]
6444    pub token_budget: Option<i64>,
6445}
6446
6447#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6448#[serde(rename_all = "camelCase")]
6449pub struct ThreadGoalSetResponse {
6450    #[serde()]
6451    pub goal: ThreadGoal,
6452}
6453
6454#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6455pub enum ThreadGoalStatus {
6456    #[serde(rename = "active")]
6457    Active,
6458    #[serde(rename = "paused")]
6459    Paused,
6460    #[serde(rename = "blocked")]
6461    Blocked,
6462    #[serde(rename = "usageLimited")]
6463    UsageLimited,
6464    #[serde(rename = "budgetLimited")]
6465    BudgetLimited,
6466    #[serde(rename = "complete")]
6467    Complete,
6468}
6469
6470#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6471#[serde(rename_all = "camelCase")]
6472pub struct ThreadGoalUpdatedNotification {
6473    #[serde()]
6474    pub goal: ThreadGoal,
6475    #[serde(rename = "threadId", default)]
6476    pub thread_id: String,
6477    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
6478    pub turn_id: Option<String>,
6479}
6480
6481#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
6482#[serde(transparent)]
6483pub struct ThreadId(pub String);
6484
6485#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6486#[serde(rename_all = "camelCase")]
6487pub struct ThreadInjectItemsParams {
6488    #[serde(default)]
6489    pub items: Vec<Value>,
6490    #[serde(rename = "threadId", default)]
6491    pub thread_id: String,
6492}
6493
6494#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6495#[serde(rename_all = "camelCase")]
6496pub struct ThreadInjectItemsResponse {
6497    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6498    pub extra: serde_json::Map<String, Value>,
6499}
6500
6501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6502#[serde(tag = "type", rename_all = "camelCase")]
6503pub enum ThreadItem {
6504    #[serde(rename = "userMessage")]
6505    UserMessage {
6506        #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
6507        client_id: Option<String>,
6508        content: Vec<UserInput>,
6509        id: String,
6510    },
6511    #[serde(rename = "hookPrompt")]
6512    HookPrompt {
6513        fragments: Vec<HookPromptFragment>,
6514        id: String,
6515    },
6516    #[serde(rename = "agentMessage")]
6517    AgentMessage {
6518        id: String,
6519        #[serde(
6520            rename = "memoryCitation",
6521            default,
6522            skip_serializing_if = "Option::is_none"
6523        )]
6524        memory_citation: Option<MemoryCitation>,
6525        #[serde(default, skip_serializing_if = "Option::is_none")]
6526        phase: Option<MessagePhase>,
6527        text: String,
6528    },
6529    Plan {
6530        id: String,
6531        text: String,
6532    },
6533    Reasoning {
6534        #[serde(default, skip_serializing_if = "Option::is_none")]
6535        content: Option<Vec<String>>,
6536        id: String,
6537        #[serde(default, skip_serializing_if = "Option::is_none")]
6538        summary: Option<Vec<String>>,
6539    },
6540    #[serde(rename = "commandExecution")]
6541    CommandExecution {
6542        #[serde(
6543            rename = "aggregatedOutput",
6544            default,
6545            skip_serializing_if = "Option::is_none"
6546        )]
6547        aggregated_output: Option<String>,
6548        command: String,
6549        #[serde(rename = "commandActions")]
6550        command_actions: Vec<CommandAction>,
6551        cwd: Value,
6552        #[serde(
6553            rename = "durationMs",
6554            default,
6555            skip_serializing_if = "Option::is_none"
6556        )]
6557        duration_ms: Option<i64>,
6558        #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
6559        exit_code: Option<i64>,
6560        id: String,
6561        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
6562        plugin_id: Option<String>,
6563        #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
6564        process_id: Option<String>,
6565        #[serde(
6566            rename = "scriptPath",
6567            default,
6568            skip_serializing_if = "Option::is_none"
6569        )]
6570        script_path: Option<String>,
6571        #[serde(default, skip_serializing_if = "Option::is_none")]
6572        source: Option<Value>,
6573        status: CommandExecutionStatus,
6574    },
6575    #[serde(rename = "fileChange")]
6576    FileChange {
6577        changes: Vec<FileUpdateChange>,
6578        id: String,
6579        status: PatchApplyStatus,
6580    },
6581    #[serde(rename = "mcpToolCall")]
6582    McpToolCall {
6583        #[serde(
6584            rename = "appContext",
6585            default,
6586            skip_serializing_if = "Option::is_none"
6587        )]
6588        app_context: Option<McpToolCallAppContext>,
6589        arguments: Value,
6590        #[serde(
6591            rename = "durationMs",
6592            default,
6593            skip_serializing_if = "Option::is_none"
6594        )]
6595        duration_ms: Option<i64>,
6596        #[serde(default, skip_serializing_if = "Option::is_none")]
6597        error: Option<McpToolCallError>,
6598        id: String,
6599        #[serde(
6600            rename = "mcpAppResourceUri",
6601            default,
6602            skip_serializing_if = "Option::is_none"
6603        )]
6604        mcp_app_resource_uri: Option<String>,
6605        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
6606        plugin_id: Option<String>,
6607        #[serde(
6608            rename = "readOnlyHint",
6609            default,
6610            skip_serializing_if = "Option::is_none"
6611        )]
6612        read_only_hint: Option<bool>,
6613        #[serde(default, skip_serializing_if = "Option::is_none")]
6614        result: Option<McpToolCallResult>,
6615        server: String,
6616        status: McpToolCallStatus,
6617        tool: String,
6618    },
6619    #[serde(rename = "dynamicToolCall")]
6620    DynamicToolCall {
6621        arguments: Value,
6622        #[serde(
6623            rename = "contentItems",
6624            default,
6625            skip_serializing_if = "Option::is_none"
6626        )]
6627        content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
6628        #[serde(
6629            rename = "durationMs",
6630            default,
6631            skip_serializing_if = "Option::is_none"
6632        )]
6633        duration_ms: Option<i64>,
6634        id: String,
6635        #[serde(default, skip_serializing_if = "Option::is_none")]
6636        namespace: Option<String>,
6637        status: DynamicToolCallStatus,
6638        #[serde(default, skip_serializing_if = "Option::is_none")]
6639        success: Option<bool>,
6640        tool: String,
6641    },
6642    #[serde(rename = "collabAgentToolCall")]
6643    CollabAgentToolCall {
6644        #[serde(rename = "agentsStates")]
6645        agents_states: std::collections::BTreeMap<String, CollabAgentState>,
6646        id: String,
6647        #[serde(default, skip_serializing_if = "Option::is_none")]
6648        model: Option<String>,
6649        #[serde(default, skip_serializing_if = "Option::is_none")]
6650        prompt: Option<String>,
6651        #[serde(
6652            rename = "reasoningEffort",
6653            default,
6654            skip_serializing_if = "Option::is_none"
6655        )]
6656        reasoning_effort: Option<ReasoningEffort>,
6657        #[serde(rename = "receiverThreadIds")]
6658        receiver_thread_ids: Vec<String>,
6659        #[serde(rename = "senderThreadId")]
6660        sender_thread_id: String,
6661        status: Value,
6662        tool: Value,
6663    },
6664    #[serde(rename = "subAgentActivity")]
6665    SubAgentActivity {
6666        #[serde(rename = "agentPath")]
6667        agent_path: String,
6668        #[serde(rename = "agentThreadId")]
6669        agent_thread_id: String,
6670        id: String,
6671        kind: SubAgentActivityKind,
6672    },
6673    #[serde(rename = "webSearch")]
6674    WebSearch {
6675        #[serde(default, skip_serializing_if = "Option::is_none")]
6676        action: Option<WebSearchAction>,
6677        id: String,
6678        query: String,
6679        #[serde(default, skip_serializing_if = "Option::is_none")]
6680        results: Option<Vec<Value>>,
6681    },
6682    #[serde(rename = "imageView")]
6683    ImageView {
6684        id: String,
6685        path: LegacyAppPathString,
6686    },
6687    Sleep {
6688        #[serde(rename = "durationMs")]
6689        duration_ms: i64,
6690        id: String,
6691    },
6692    #[serde(rename = "imageGeneration")]
6693    ImageGeneration {
6694        id: String,
6695        result: String,
6696        #[serde(
6697            rename = "revisedPrompt",
6698            default,
6699            skip_serializing_if = "Option::is_none"
6700        )]
6701        revised_prompt: Option<String>,
6702        #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
6703        saved_path: Option<AbsolutePathBuf>,
6704        status: String,
6705    },
6706    #[serde(rename = "enteredReviewMode")]
6707    EnteredReviewMode {
6708        id: String,
6709        review: String,
6710    },
6711    #[serde(rename = "exitedReviewMode")]
6712    ExitedReviewMode {
6713        id: String,
6714        review: String,
6715    },
6716    #[serde(rename = "contextCompaction")]
6717    ContextCompaction {
6718        id: String,
6719    },
6720}
6721
6722#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6723#[serde(untagged)]
6724pub enum ThreadListCwdFilter {
6725    Variant0(String),
6726    Variant1(Vec<String>),
6727}
6728
6729#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6730#[serde(rename_all = "camelCase")]
6731pub struct ThreadListParams {
6732    #[serde(default, skip_serializing_if = "Option::is_none")]
6733    pub archived: Option<bool>,
6734    #[serde(default, skip_serializing_if = "Option::is_none")]
6735    pub cursor: Option<String>,
6736    #[serde(default, skip_serializing_if = "Option::is_none")]
6737    pub cwd: Option<ThreadListCwdFilter>,
6738    #[serde(default, skip_serializing_if = "Option::is_none")]
6739    pub limit: Option<i64>,
6740    #[serde(
6741        rename = "modelProviders",
6742        default,
6743        skip_serializing_if = "Option::is_none"
6744    )]
6745    pub model_providers: Option<Vec<String>>,
6746    #[serde(
6747        rename = "searchTerm",
6748        default,
6749        skip_serializing_if = "Option::is_none"
6750    )]
6751    pub search_term: Option<String>,
6752    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
6753    pub section_id: Option<String>,
6754    #[serde(
6755        rename = "sortDirection",
6756        default,
6757        skip_serializing_if = "Option::is_none"
6758    )]
6759    pub sort_direction: Option<SortDirection>,
6760    #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
6761    pub sort_key: Option<ThreadSortKey>,
6762    #[serde(
6763        rename = "sourceKinds",
6764        default,
6765        skip_serializing_if = "Option::is_none"
6766    )]
6767    pub source_kinds: Option<Vec<ThreadSourceKind>>,
6768    #[serde(
6769        rename = "useStateDbOnly",
6770        default,
6771        skip_serializing_if = "Option::is_none"
6772    )]
6773    pub use_state_db_only: Option<bool>,
6774}
6775
6776#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6777#[serde(rename_all = "camelCase")]
6778pub struct ThreadListResponse {
6779    #[serde(
6780        rename = "backwardsCursor",
6781        default,
6782        skip_serializing_if = "Option::is_none"
6783    )]
6784    pub backwards_cursor: Option<String>,
6785    #[serde(default)]
6786    pub data: Vec<Thread>,
6787    #[serde(
6788        rename = "nextCursor",
6789        default,
6790        skip_serializing_if = "Option::is_none"
6791    )]
6792    pub next_cursor: Option<String>,
6793}
6794
6795#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6796#[serde(rename_all = "camelCase")]
6797pub struct ThreadLoadedListParams {
6798    #[serde(default, skip_serializing_if = "Option::is_none")]
6799    pub cursor: Option<String>,
6800    #[serde(default, skip_serializing_if = "Option::is_none")]
6801    pub limit: Option<i64>,
6802}
6803
6804#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6805#[serde(rename_all = "camelCase")]
6806pub struct ThreadLoadedListResponse {
6807    #[serde(default)]
6808    pub data: Vec<String>,
6809    #[serde(
6810        rename = "nextCursor",
6811        default,
6812        skip_serializing_if = "Option::is_none"
6813    )]
6814    pub next_cursor: Option<String>,
6815}
6816
6817#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6818#[serde(rename_all = "camelCase")]
6819pub struct ThreadMetadataGitInfoUpdateParams {
6820    #[serde(default, skip_serializing_if = "Option::is_none")]
6821    pub branch: Option<String>,
6822    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
6823    pub origin_url: Option<String>,
6824    #[serde(default, skip_serializing_if = "Option::is_none")]
6825    pub sha: Option<String>,
6826}
6827
6828#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6829#[serde(rename_all = "camelCase")]
6830pub struct ThreadMetadataUpdateParams {
6831    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
6832    pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
6833    #[serde(rename = "threadId", default)]
6834    pub thread_id: String,
6835}
6836
6837#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6838#[serde(rename_all = "camelCase")]
6839pub struct ThreadMetadataUpdateResponse {
6840    #[serde()]
6841    pub thread: Thread,
6842}
6843
6844#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6845#[serde(rename_all = "camelCase")]
6846pub struct ThreadNameUpdatedNotification {
6847    #[serde(rename = "threadId", default)]
6848    pub thread_id: String,
6849    #[serde(
6850        rename = "threadName",
6851        default,
6852        skip_serializing_if = "Option::is_none"
6853    )]
6854    pub thread_name: Option<String>,
6855}
6856
6857#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6858#[serde(rename_all = "camelCase")]
6859pub struct ThreadReadParams {
6860    #[serde(
6861        rename = "includeTurns",
6862        default,
6863        skip_serializing_if = "Option::is_none"
6864    )]
6865    pub include_turns: Option<bool>,
6866    #[serde(rename = "threadId", default)]
6867    pub thread_id: String,
6868}
6869
6870#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6871#[serde(rename_all = "camelCase")]
6872pub struct ThreadReadResponse {
6873    #[serde()]
6874    pub thread: Thread,
6875}
6876
6877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6878#[serde(rename_all = "camelCase")]
6879pub struct ThreadRealtimeAudioChunk {
6880    #[serde(default)]
6881    pub data: String,
6882    #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
6883    pub item_id: Option<String>,
6884    #[serde(rename = "numChannels", default)]
6885    pub num_channels: i64,
6886    #[serde(rename = "sampleRate", default)]
6887    pub sample_rate: i64,
6888    #[serde(
6889        rename = "samplesPerChannel",
6890        default,
6891        skip_serializing_if = "Option::is_none"
6892    )]
6893    pub samples_per_channel: Option<i64>,
6894}
6895
6896#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6897#[serde(rename_all = "camelCase")]
6898pub struct ThreadRealtimeClosedNotification {
6899    #[serde(default, skip_serializing_if = "Option::is_none")]
6900    pub reason: Option<String>,
6901    #[serde(rename = "threadId", default)]
6902    pub thread_id: String,
6903}
6904
6905#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6906#[serde(rename_all = "camelCase")]
6907pub struct ThreadRealtimeErrorNotification {
6908    #[serde(default)]
6909    pub message: String,
6910    #[serde(rename = "threadId", default)]
6911    pub thread_id: String,
6912}
6913
6914#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6915#[serde(rename_all = "camelCase")]
6916pub struct ThreadRealtimeItemAddedNotification {
6917    #[serde(default)]
6918    pub item: Value,
6919    #[serde(rename = "threadId", default)]
6920    pub thread_id: String,
6921}
6922
6923#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6924#[serde(rename_all = "camelCase")]
6925pub struct ThreadRealtimeOutputAudioDeltaNotification {
6926    #[serde()]
6927    pub audio: ThreadRealtimeAudioChunk,
6928    #[serde(rename = "threadId", default)]
6929    pub thread_id: String,
6930}
6931
6932#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6933#[serde(rename_all = "camelCase")]
6934pub struct ThreadRealtimeSdpNotification {
6935    #[serde(default)]
6936    pub sdp: String,
6937    #[serde(rename = "threadId", default)]
6938    pub thread_id: String,
6939}
6940
6941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6942#[serde(rename_all = "camelCase")]
6943pub struct ThreadRealtimeStartedNotification {
6944    #[serde(
6945        rename = "realtimeSessionId",
6946        default,
6947        skip_serializing_if = "Option::is_none"
6948    )]
6949    pub realtime_session_id: Option<String>,
6950    #[serde(rename = "threadId", default)]
6951    pub thread_id: String,
6952    #[serde()]
6953    pub version: RealtimeConversationVersion,
6954}
6955
6956#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6957#[serde(rename_all = "camelCase")]
6958pub struct ThreadRealtimeTranscriptDeltaNotification {
6959    #[serde(default)]
6960    pub delta: String,
6961    #[serde(default)]
6962    pub role: String,
6963    #[serde(rename = "threadId", default)]
6964    pub thread_id: String,
6965}
6966
6967#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6968#[serde(rename_all = "camelCase")]
6969pub struct ThreadRealtimeTranscriptDoneNotification {
6970    #[serde(default)]
6971    pub role: String,
6972    #[serde(default)]
6973    pub text: String,
6974    #[serde(rename = "threadId", default)]
6975    pub thread_id: String,
6976}
6977
6978#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6979#[serde(rename_all = "camelCase")]
6980pub struct ThreadResumeParams {
6981    #[serde(
6982        rename = "approvalPolicy",
6983        default,
6984        skip_serializing_if = "Option::is_none"
6985    )]
6986    pub approval_policy: Option<AskForApproval>,
6987    #[serde(
6988        rename = "approvalsReviewer",
6989        default,
6990        skip_serializing_if = "Option::is_none"
6991    )]
6992    pub approvals_reviewer: Option<ApprovalsReviewer>,
6993    #[serde(
6994        rename = "baseInstructions",
6995        default,
6996        skip_serializing_if = "Option::is_none"
6997    )]
6998    pub base_instructions: Option<String>,
6999    #[serde(default, skip_serializing_if = "Option::is_none")]
7000    pub config: Option<Value>,
7001    #[serde(default, skip_serializing_if = "Option::is_none")]
7002    pub cwd: Option<String>,
7003    #[serde(
7004        rename = "developerInstructions",
7005        default,
7006        skip_serializing_if = "Option::is_none"
7007    )]
7008    pub developer_instructions: Option<String>,
7009    #[serde(default, skip_serializing_if = "Option::is_none")]
7010    pub model: Option<String>,
7011    #[serde(
7012        rename = "modelProvider",
7013        default,
7014        skip_serializing_if = "Option::is_none"
7015    )]
7016    pub model_provider: Option<String>,
7017    #[serde(default, skip_serializing_if = "Option::is_none")]
7018    pub personality: Option<Personality>,
7019    #[serde(default, skip_serializing_if = "Option::is_none")]
7020    pub sandbox: Option<SandboxMode>,
7021    #[serde(
7022        rename = "serviceTier",
7023        default,
7024        skip_serializing_if = "Option::is_none"
7025    )]
7026    pub service_tier: Option<String>,
7027    #[serde(rename = "threadId", default)]
7028    pub thread_id: String,
7029}
7030
7031#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7032#[serde(rename_all = "camelCase")]
7033pub struct ThreadResumeResponse {
7034    #[serde(rename = "approvalPolicy")]
7035    pub approval_policy: AskForApproval,
7036    #[serde(rename = "approvalsReviewer", default)]
7037    pub approvals_reviewer: Value,
7038    #[serde()]
7039    pub cwd: AbsolutePathBuf,
7040    #[serde(
7041        rename = "instructionSources",
7042        default,
7043        skip_serializing_if = "Option::is_none"
7044    )]
7045    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
7046    #[serde(default)]
7047    pub model: String,
7048    #[serde(rename = "modelProvider", default)]
7049    pub model_provider: String,
7050    #[serde(
7051        rename = "reasoningEffort",
7052        default,
7053        skip_serializing_if = "Option::is_none"
7054    )]
7055    pub reasoning_effort: Option<ReasoningEffort>,
7056    #[serde(default)]
7057    pub sandbox: Value,
7058    #[serde(
7059        rename = "serviceTier",
7060        default,
7061        skip_serializing_if = "Option::is_none"
7062    )]
7063    pub service_tier: Option<String>,
7064    #[serde()]
7065    pub thread: Thread,
7066}
7067
7068#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7069#[serde(rename_all = "camelCase")]
7070pub struct ThreadRollbackParams {
7071    #[serde(rename = "numTurns", default)]
7072    pub num_turns: i64,
7073    #[serde(rename = "threadId", default)]
7074    pub thread_id: String,
7075}
7076
7077#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7078#[serde(rename_all = "camelCase")]
7079pub struct ThreadRollbackResponse {
7080    #[serde(default)]
7081    pub thread: Value,
7082}
7083
7084#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7085#[serde(rename_all = "camelCase")]
7086pub struct ThreadSection {
7087    #[serde(default)]
7088    pub id: String,
7089    #[serde(default)]
7090    pub name: String,
7091}
7092
7093#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7094#[serde(rename_all = "camelCase")]
7095pub struct ThreadSectionCreateParams {
7096    #[serde(default)]
7097    pub name: String,
7098}
7099
7100#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7101#[serde(rename_all = "camelCase")]
7102pub struct ThreadSectionCreateResponse {
7103    #[serde()]
7104    pub section: ThreadSection,
7105}
7106
7107#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7108#[serde(rename_all = "camelCase")]
7109pub struct ThreadSectionDeleteParams {
7110    #[serde(rename = "sectionId", default)]
7111    pub section_id: String,
7112}
7113
7114#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7115#[serde(rename_all = "camelCase")]
7116pub struct ThreadSectionDeleteResponse {
7117    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7118    pub extra: serde_json::Map<String, Value>,
7119}
7120
7121#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7122#[serde(rename_all = "camelCase")]
7123pub struct ThreadSectionListParams {
7124    #[serde(default, skip_serializing_if = "Option::is_none")]
7125    pub cursor: Option<String>,
7126    #[serde(default, skip_serializing_if = "Option::is_none")]
7127    pub limit: Option<i64>,
7128}
7129
7130#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7131#[serde(rename_all = "camelCase")]
7132pub struct ThreadSectionListResponse {
7133    #[serde(default)]
7134    pub data: Vec<ThreadSection>,
7135    #[serde(
7136        rename = "nextCursor",
7137        default,
7138        skip_serializing_if = "Option::is_none"
7139    )]
7140    pub next_cursor: Option<String>,
7141}
7142
7143#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7144#[serde(rename_all = "camelCase")]
7145pub struct ThreadSectionMoveParams {
7146    #[serde(
7147        rename = "beforeThreadId",
7148        default,
7149        skip_serializing_if = "Option::is_none"
7150    )]
7151    pub before_thread_id: Option<String>,
7152    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
7153    pub section_id: Option<String>,
7154    #[serde(rename = "threadId", default)]
7155    pub thread_id: String,
7156}
7157
7158#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7159#[serde(rename_all = "camelCase")]
7160pub struct ThreadSectionMoveResponse {
7161    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7162    pub extra: serde_json::Map<String, Value>,
7163}
7164
7165#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7166#[serde(rename_all = "camelCase")]
7167pub struct ThreadSectionUpdateParams {
7168    #[serde(default)]
7169    pub name: String,
7170    #[serde(rename = "sectionId", default)]
7171    pub section_id: String,
7172}
7173
7174#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7175#[serde(rename_all = "camelCase")]
7176pub struct ThreadSectionUpdateResponse {
7177    #[serde()]
7178    pub section: ThreadSection,
7179}
7180
7181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7182#[serde(rename_all = "camelCase")]
7183pub struct ThreadSetNameParams {
7184    #[serde(default)]
7185    pub name: String,
7186    #[serde(rename = "threadId", default)]
7187    pub thread_id: String,
7188}
7189
7190#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7191#[serde(rename_all = "camelCase")]
7192pub struct ThreadSetNameResponse {
7193    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7194    pub extra: serde_json::Map<String, Value>,
7195}
7196
7197#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7198#[serde(rename_all = "camelCase")]
7199pub struct ThreadSettings {
7200    #[serde(
7201        rename = "activePermissionProfile",
7202        default,
7203        skip_serializing_if = "Option::is_none"
7204    )]
7205    pub active_permission_profile: Option<ActivePermissionProfile>,
7206    #[serde(rename = "approvalPolicy")]
7207    pub approval_policy: AskForApproval,
7208    #[serde(rename = "approvalsReviewer")]
7209    pub approvals_reviewer: ApprovalsReviewer,
7210    #[serde(rename = "collaborationMode")]
7211    pub collaboration_mode: CollaborationMode,
7212    #[serde()]
7213    pub cwd: AbsolutePathBuf,
7214    #[serde(default, skip_serializing_if = "Option::is_none")]
7215    pub effort: Option<ReasoningEffort>,
7216    #[serde(default)]
7217    pub model: String,
7218    #[serde(rename = "modelProvider", default)]
7219    pub model_provider: String,
7220    #[serde(default, skip_serializing_if = "Option::is_none")]
7221    pub personality: Option<Personality>,
7222    #[serde(rename = "sandboxPolicy")]
7223    pub sandbox_policy: SandboxPolicy,
7224    #[serde(
7225        rename = "serviceTier",
7226        default,
7227        skip_serializing_if = "Option::is_none"
7228    )]
7229    pub service_tier: Option<String>,
7230    #[serde(default, skip_serializing_if = "Option::is_none")]
7231    pub summary: Option<ReasoningSummary>,
7232}
7233
7234#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7235#[serde(rename_all = "camelCase")]
7236pub struct ThreadSettingsUpdatedNotification {
7237    #[serde(rename = "threadId", default)]
7238    pub thread_id: String,
7239    #[serde(rename = "threadSettings")]
7240    pub thread_settings: ThreadSettings,
7241}
7242
7243#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7244#[serde(rename_all = "camelCase")]
7245pub struct ThreadShellCommandParams {
7246    #[serde(default)]
7247    pub command: String,
7248    #[serde(rename = "threadId", default)]
7249    pub thread_id: String,
7250}
7251
7252#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7253#[serde(rename_all = "camelCase")]
7254pub struct ThreadShellCommandResponse {
7255    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7256    pub extra: serde_json::Map<String, Value>,
7257}
7258
7259#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7260pub enum ThreadSortKey {
7261    #[serde(rename = "created_at")]
7262    Created_at,
7263    #[serde(rename = "updated_at")]
7264    Updated_at,
7265    #[serde(rename = "recency_at")]
7266    Recency_at,
7267    #[serde(rename = "section_position")]
7268    Section_position,
7269}
7270
7271#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
7272#[serde(transparent)]
7273pub struct ThreadSource(pub String);
7274
7275#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7276pub enum ThreadSourceKind {
7277    #[serde(rename = "cli")]
7278    Cli,
7279    #[serde(rename = "vscode")]
7280    Vscode,
7281    #[serde(rename = "exec")]
7282    Exec,
7283    #[serde(rename = "appServer")]
7284    AppServer,
7285    #[serde(rename = "subAgent")]
7286    SubAgent,
7287    #[serde(rename = "subAgentReview")]
7288    SubAgentReview,
7289    #[serde(rename = "subAgentCompact")]
7290    SubAgentCompact,
7291    #[serde(rename = "subAgentThreadSpawn")]
7292    SubAgentThreadSpawn,
7293    #[serde(rename = "subAgentOther")]
7294    SubAgentOther,
7295    #[serde(rename = "unknown")]
7296    Unknown,
7297}
7298
7299#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7300#[serde(rename_all = "camelCase")]
7301pub struct ThreadStartParams {
7302    #[serde(
7303        rename = "approvalPolicy",
7304        default,
7305        skip_serializing_if = "Option::is_none"
7306    )]
7307    pub approval_policy: Option<AskForApproval>,
7308    #[serde(
7309        rename = "approvalsReviewer",
7310        default,
7311        skip_serializing_if = "Option::is_none"
7312    )]
7313    pub approvals_reviewer: Option<ApprovalsReviewer>,
7314    #[serde(
7315        rename = "baseInstructions",
7316        default,
7317        skip_serializing_if = "Option::is_none"
7318    )]
7319    pub base_instructions: Option<String>,
7320    #[serde(default, skip_serializing_if = "Option::is_none")]
7321    pub config: Option<Value>,
7322    #[serde(default, skip_serializing_if = "Option::is_none")]
7323    pub cwd: Option<String>,
7324    #[serde(
7325        rename = "developerInstructions",
7326        default,
7327        skip_serializing_if = "Option::is_none"
7328    )]
7329    pub developer_instructions: Option<String>,
7330    #[serde(default, skip_serializing_if = "Option::is_none")]
7331    pub ephemeral: Option<bool>,
7332    #[serde(default, skip_serializing_if = "Option::is_none")]
7333    pub model: Option<String>,
7334    #[serde(
7335        rename = "modelProvider",
7336        default,
7337        skip_serializing_if = "Option::is_none"
7338    )]
7339    pub model_provider: Option<String>,
7340    #[serde(default, skip_serializing_if = "Option::is_none")]
7341    pub personality: Option<Personality>,
7342    #[serde(default, skip_serializing_if = "Option::is_none")]
7343    pub sandbox: Option<SandboxMode>,
7344    #[serde(
7345        rename = "serviceName",
7346        default,
7347        skip_serializing_if = "Option::is_none"
7348    )]
7349    pub service_name: Option<String>,
7350    #[serde(
7351        rename = "serviceTier",
7352        default,
7353        skip_serializing_if = "Option::is_none"
7354    )]
7355    pub service_tier: Option<String>,
7356    #[serde(
7357        rename = "sessionStartSource",
7358        default,
7359        skip_serializing_if = "Option::is_none"
7360    )]
7361    pub session_start_source: Option<ThreadStartSource>,
7362    #[serde(
7363        rename = "threadSource",
7364        default,
7365        skip_serializing_if = "Option::is_none"
7366    )]
7367    pub thread_source: Option<ThreadSource>,
7368}
7369
7370#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7371#[serde(rename_all = "camelCase")]
7372pub struct ThreadStartResponse {
7373    #[serde(rename = "approvalPolicy")]
7374    pub approval_policy: AskForApproval,
7375    #[serde(rename = "approvalsReviewer", default)]
7376    pub approvals_reviewer: Value,
7377    #[serde()]
7378    pub cwd: AbsolutePathBuf,
7379    #[serde(
7380        rename = "instructionSources",
7381        default,
7382        skip_serializing_if = "Option::is_none"
7383    )]
7384    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
7385    #[serde(default)]
7386    pub model: String,
7387    #[serde(rename = "modelProvider", default)]
7388    pub model_provider: String,
7389    #[serde(
7390        rename = "reasoningEffort",
7391        default,
7392        skip_serializing_if = "Option::is_none"
7393    )]
7394    pub reasoning_effort: Option<ReasoningEffort>,
7395    #[serde(default)]
7396    pub sandbox: Value,
7397    #[serde(
7398        rename = "serviceTier",
7399        default,
7400        skip_serializing_if = "Option::is_none"
7401    )]
7402    pub service_tier: Option<String>,
7403    #[serde()]
7404    pub thread: Thread,
7405}
7406
7407#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7408pub enum ThreadStartSource {
7409    #[serde(rename = "startup")]
7410    Startup,
7411    #[serde(rename = "clear")]
7412    Clear,
7413}
7414
7415#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7416#[serde(rename_all = "camelCase")]
7417pub struct ThreadStartedNotification {
7418    #[serde()]
7419    pub thread: Thread,
7420}
7421
7422#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7423#[serde(tag = "type", rename_all = "camelCase")]
7424pub enum ThreadStatus {
7425    #[serde(rename = "notLoaded")]
7426    NotLoaded,
7427    Idle,
7428    #[serde(rename = "systemError")]
7429    SystemError,
7430    Active {
7431        #[serde(rename = "activeFlags")]
7432        active_flags: Vec<ThreadActiveFlag>,
7433    },
7434}
7435
7436#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7437#[serde(rename_all = "camelCase")]
7438pub struct ThreadStatusChangedNotification {
7439    #[serde()]
7440    pub status: ThreadStatus,
7441    #[serde(rename = "threadId", default)]
7442    pub thread_id: String,
7443}
7444
7445#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7446#[serde(rename_all = "camelCase")]
7447pub struct ThreadTokenUsage {
7448    #[serde()]
7449    pub last: TokenUsageBreakdown,
7450    #[serde(
7451        rename = "modelContextWindow",
7452        default,
7453        skip_serializing_if = "Option::is_none"
7454    )]
7455    pub model_context_window: Option<i64>,
7456    #[serde()]
7457    pub total: TokenUsageBreakdown,
7458}
7459
7460#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7461#[serde(rename_all = "camelCase")]
7462pub struct ThreadTokenUsageUpdatedNotification {
7463    #[serde(rename = "threadId", default)]
7464    pub thread_id: String,
7465    #[serde(rename = "tokenUsage")]
7466    pub token_usage: ThreadTokenUsage,
7467    #[serde(rename = "turnId", default)]
7468    pub turn_id: String,
7469}
7470
7471#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7472#[serde(rename_all = "camelCase")]
7473pub struct ThreadUnarchiveParams {
7474    #[serde(rename = "threadId", default)]
7475    pub thread_id: String,
7476}
7477
7478#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7479#[serde(rename_all = "camelCase")]
7480pub struct ThreadUnarchiveResponse {
7481    #[serde()]
7482    pub thread: Thread,
7483}
7484
7485#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7486#[serde(rename_all = "camelCase")]
7487pub struct ThreadUnarchivedNotification {
7488    #[serde(rename = "threadId", default)]
7489    pub thread_id: String,
7490}
7491
7492#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7493#[serde(rename_all = "camelCase")]
7494pub struct ThreadUnsubscribeParams {
7495    #[serde(rename = "threadId", default)]
7496    pub thread_id: String,
7497}
7498
7499#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7500#[serde(rename_all = "camelCase")]
7501pub struct ThreadUnsubscribeResponse {
7502    #[serde()]
7503    pub status: ThreadUnsubscribeStatus,
7504}
7505
7506#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7507pub enum ThreadUnsubscribeStatus {
7508    #[serde(rename = "notLoaded")]
7509    NotLoaded,
7510    #[serde(rename = "notSubscribed")]
7511    NotSubscribed,
7512    #[serde(rename = "unsubscribed")]
7513    Unsubscribed,
7514}
7515
7516#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7517#[serde(rename_all = "camelCase")]
7518pub struct TokenUsageBreakdown {
7519    #[serde(
7520        rename = "cacheWriteInputTokens",
7521        default,
7522        skip_serializing_if = "Option::is_none"
7523    )]
7524    pub cache_write_input_tokens: Option<i64>,
7525    #[serde(rename = "cachedInputTokens", default)]
7526    pub cached_input_tokens: i64,
7527    #[serde(rename = "inputTokens", default)]
7528    pub input_tokens: i64,
7529    #[serde(rename = "outputTokens", default)]
7530    pub output_tokens: i64,
7531    #[serde(rename = "reasoningOutputTokens", default)]
7532    pub reasoning_output_tokens: i64,
7533    #[serde(rename = "totalTokens", default)]
7534    pub total_tokens: i64,
7535}
7536
7537#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7538#[serde(rename_all = "camelCase")]
7539pub struct Tool {
7540    #[serde(default, skip_serializing_if = "Option::is_none")]
7541    pub _meta: Option<Value>,
7542    #[serde(default, skip_serializing_if = "Option::is_none")]
7543    pub annotations: Option<Value>,
7544    #[serde(default, skip_serializing_if = "Option::is_none")]
7545    pub description: Option<String>,
7546    #[serde(default, skip_serializing_if = "Option::is_none")]
7547    pub icons: Option<Vec<Value>>,
7548    #[serde(rename = "inputSchema", default)]
7549    pub input_schema: Value,
7550    #[serde(default)]
7551    pub name: String,
7552    #[serde(
7553        rename = "outputSchema",
7554        default,
7555        skip_serializing_if = "Option::is_none"
7556    )]
7557    pub output_schema: Option<Value>,
7558    #[serde(default, skip_serializing_if = "Option::is_none")]
7559    pub title: Option<String>,
7560}
7561
7562#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7563#[serde(rename_all = "camelCase")]
7564pub struct ToolRequestUserInputAnswer {
7565    #[serde(default)]
7566    pub answers: Vec<String>,
7567}
7568
7569#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7570#[serde(rename_all = "camelCase")]
7571pub struct ToolRequestUserInputOption {
7572    #[serde(default)]
7573    pub description: String,
7574    #[serde(default)]
7575    pub label: String,
7576}
7577
7578#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7579#[serde(rename_all = "camelCase")]
7580pub struct ToolRequestUserInputParams {
7581    #[serde(
7582        rename = "autoResolutionMs",
7583        default,
7584        skip_serializing_if = "Option::is_none"
7585    )]
7586    pub auto_resolution_ms: Option<i64>,
7587    #[serde(rename = "isBlocking", default)]
7588    pub is_blocking: bool,
7589    #[serde(rename = "itemId", default)]
7590    pub item_id: String,
7591    #[serde(default)]
7592    pub questions: Vec<ToolRequestUserInputQuestion>,
7593    #[serde(rename = "threadId", default)]
7594    pub thread_id: String,
7595    #[serde(rename = "turnId", default)]
7596    pub turn_id: String,
7597}
7598
7599#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7600#[serde(rename_all = "camelCase")]
7601pub struct ToolRequestUserInputQuestion {
7602    #[serde(default)]
7603    pub header: String,
7604    #[serde(default)]
7605    pub id: String,
7606    #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
7607    pub is_other: Option<bool>,
7608    #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
7609    pub is_secret: Option<bool>,
7610    #[serde(default, skip_serializing_if = "Option::is_none")]
7611    pub options: Option<Vec<ToolRequestUserInputOption>>,
7612    #[serde(default)]
7613    pub question: String,
7614}
7615
7616#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7617#[serde(rename_all = "camelCase")]
7618pub struct ToolRequestUserInputResponse {
7619    #[serde(default)]
7620    pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
7621}
7622
7623#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7624#[serde(rename_all = "camelCase")]
7625pub struct ToolsV2 {
7626    #[serde(default, skip_serializing_if = "Option::is_none")]
7627    pub web_search: Option<WebSearchToolConfig>,
7628}
7629
7630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7631#[serde(rename_all = "camelCase")]
7632pub struct Turn {
7633    #[serde(
7634        rename = "completedAt",
7635        default,
7636        skip_serializing_if = "Option::is_none"
7637    )]
7638    pub completed_at: Option<i64>,
7639    #[serde(
7640        rename = "durationMs",
7641        default,
7642        skip_serializing_if = "Option::is_none"
7643    )]
7644    pub duration_ms: Option<i64>,
7645    #[serde(default, skip_serializing_if = "Option::is_none")]
7646    pub error: Option<TurnError>,
7647    #[serde(default)]
7648    pub id: String,
7649    #[serde(default)]
7650    pub items: Vec<ThreadItem>,
7651    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
7652    pub items_view: Option<Value>,
7653    #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
7654    pub started_at: Option<i64>,
7655    #[serde()]
7656    pub status: TurnStatus,
7657}
7658
7659#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7660#[serde(rename_all = "camelCase")]
7661pub struct TurnCompletedNotification {
7662    #[serde(rename = "threadId", default)]
7663    pub thread_id: String,
7664    #[serde()]
7665    pub turn: Turn,
7666}
7667
7668#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7669#[serde(rename_all = "camelCase")]
7670pub struct TurnDiffUpdatedNotification {
7671    #[serde(default)]
7672    pub diff: String,
7673    #[serde(rename = "threadId", default)]
7674    pub thread_id: String,
7675    #[serde(rename = "turnId", default)]
7676    pub turn_id: String,
7677}
7678
7679#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7680#[serde(rename_all = "camelCase")]
7681pub struct TurnError {
7682    #[serde(
7683        rename = "additionalDetails",
7684        default,
7685        skip_serializing_if = "Option::is_none"
7686    )]
7687    pub additional_details: Option<String>,
7688    #[serde(
7689        rename = "codexErrorInfo",
7690        default,
7691        skip_serializing_if = "Option::is_none"
7692    )]
7693    pub codex_error_info: Option<CodexErrorInfo>,
7694    #[serde(default)]
7695    pub message: String,
7696}
7697
7698#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7699#[serde(rename_all = "camelCase")]
7700pub struct TurnInterruptParams {
7701    #[serde(rename = "threadId", default)]
7702    pub thread_id: String,
7703    #[serde(rename = "turnId", default)]
7704    pub turn_id: String,
7705}
7706
7707#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7708#[serde(rename_all = "camelCase")]
7709pub struct TurnInterruptResponse {
7710    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7711    pub extra: serde_json::Map<String, Value>,
7712}
7713
7714#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
7715pub enum TurnItemsView {
7716    #[serde(rename = "notLoaded")]
7717    NotLoaded,
7718    #[serde(rename = "summary")]
7719    Summary,
7720    #[serde(rename = "full")]
7721    Full,
7722}
7723
7724#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7725#[serde(rename_all = "camelCase")]
7726pub struct TurnModerationMetadataNotification {
7727    #[serde(default)]
7728    pub metadata: Value,
7729    #[serde(rename = "threadId", default)]
7730    pub thread_id: String,
7731    #[serde(rename = "turnId", default)]
7732    pub turn_id: String,
7733}
7734
7735#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7736#[serde(rename_all = "camelCase")]
7737pub struct TurnPlanStep {
7738    #[serde()]
7739    pub status: TurnPlanStepStatus,
7740    #[serde(default)]
7741    pub step: String,
7742}
7743
7744#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7745pub enum TurnPlanStepStatus {
7746    #[serde(rename = "pending")]
7747    Pending,
7748    #[serde(rename = "inProgress")]
7749    InProgress,
7750    #[serde(rename = "completed")]
7751    Completed,
7752}
7753
7754#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7755#[serde(rename_all = "camelCase")]
7756pub struct TurnPlanUpdatedNotification {
7757    #[serde(default, skip_serializing_if = "Option::is_none")]
7758    pub explanation: Option<String>,
7759    #[serde(default)]
7760    pub plan: Vec<TurnPlanStep>,
7761    #[serde(rename = "threadId", default)]
7762    pub thread_id: String,
7763    #[serde(rename = "turnId", default)]
7764    pub turn_id: String,
7765}
7766
7767#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7768#[serde(rename_all = "camelCase")]
7769pub struct TurnStartParams {
7770    #[serde(
7771        rename = "approvalPolicy",
7772        default,
7773        skip_serializing_if = "Option::is_none"
7774    )]
7775    pub approval_policy: Option<AskForApproval>,
7776    #[serde(
7777        rename = "approvalsReviewer",
7778        default,
7779        skip_serializing_if = "Option::is_none"
7780    )]
7781    pub approvals_reviewer: Option<ApprovalsReviewer>,
7782    #[serde(
7783        rename = "clientUserMessageId",
7784        default,
7785        skip_serializing_if = "Option::is_none"
7786    )]
7787    pub client_user_message_id: Option<String>,
7788    #[serde(default, skip_serializing_if = "Option::is_none")]
7789    pub cwd: Option<String>,
7790    #[serde(default, skip_serializing_if = "Option::is_none")]
7791    pub effort: Option<ReasoningEffort>,
7792    #[serde(default)]
7793    pub input: Vec<UserInput>,
7794    #[serde(default, skip_serializing_if = "Option::is_none")]
7795    pub model: Option<String>,
7796    #[serde(
7797        rename = "outputSchema",
7798        default,
7799        skip_serializing_if = "Option::is_none"
7800    )]
7801    pub output_schema: Option<Value>,
7802    #[serde(default, skip_serializing_if = "Option::is_none")]
7803    pub personality: Option<Personality>,
7804    #[serde(
7805        rename = "sandboxPolicy",
7806        default,
7807        skip_serializing_if = "Option::is_none"
7808    )]
7809    pub sandbox_policy: Option<SandboxPolicy>,
7810    #[serde(
7811        rename = "serviceTier",
7812        default,
7813        skip_serializing_if = "Option::is_none"
7814    )]
7815    pub service_tier: Option<String>,
7816    #[serde(default, skip_serializing_if = "Option::is_none")]
7817    pub summary: Option<ReasoningSummary>,
7818    #[serde(rename = "threadId", default)]
7819    pub thread_id: String,
7820}
7821
7822#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7823#[serde(rename_all = "camelCase")]
7824pub struct TurnStartResponse {
7825    #[serde()]
7826    pub turn: Turn,
7827}
7828
7829#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7830#[serde(rename_all = "camelCase")]
7831pub struct TurnStartedNotification {
7832    #[serde(rename = "threadId", default)]
7833    pub thread_id: String,
7834    #[serde()]
7835    pub turn: Turn,
7836}
7837
7838#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7839pub enum TurnStatus {
7840    #[serde(rename = "completed")]
7841    Completed,
7842    #[serde(rename = "interrupted")]
7843    Interrupted,
7844    #[serde(rename = "failed")]
7845    Failed,
7846    #[serde(rename = "inProgress")]
7847    InProgress,
7848}
7849
7850#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7851#[serde(rename_all = "camelCase")]
7852pub struct TurnSteerParams {
7853    #[serde(
7854        rename = "clientUserMessageId",
7855        default,
7856        skip_serializing_if = "Option::is_none"
7857    )]
7858    pub client_user_message_id: Option<String>,
7859    #[serde(rename = "expectedTurnId", default)]
7860    pub expected_turn_id: String,
7861    #[serde(default)]
7862    pub input: Vec<UserInput>,
7863    #[serde(rename = "threadId", default)]
7864    pub thread_id: String,
7865}
7866
7867#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7868#[serde(rename_all = "camelCase")]
7869pub struct TurnSteerResponse {
7870    #[serde(rename = "turnId", default)]
7871    pub turn_id: String,
7872}
7873
7874#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7875#[serde(tag = "type", rename_all = "camelCase")]
7876pub enum UserInput {
7877    Text {
7878        text: String,
7879        #[serde(default, skip_serializing_if = "Option::is_none")]
7880        text_elements: Option<Vec<TextElement>>,
7881    },
7882    Image {
7883        #[serde(default, skip_serializing_if = "Option::is_none")]
7884        detail: Option<ImageDetail>,
7885        url: String,
7886    },
7887    #[serde(rename = "localImage")]
7888    LocalImage {
7889        #[serde(default, skip_serializing_if = "Option::is_none")]
7890        detail: Option<ImageDetail>,
7891        path: String,
7892    },
7893    Audio {
7894        url: String,
7895    },
7896    #[serde(rename = "localAudio")]
7897    LocalAudio {
7898        path: String,
7899    },
7900    Skill {
7901        name: String,
7902        path: String,
7903    },
7904    Mention {
7905        name: String,
7906        path: String,
7907    },
7908}
7909
7910#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7911pub enum Verbosity {
7912    #[serde(rename = "low")]
7913    Low,
7914    #[serde(rename = "medium")]
7915    Medium,
7916    #[serde(rename = "high")]
7917    High,
7918}
7919
7920#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7921#[serde(rename_all = "camelCase")]
7922pub struct WarningNotification {
7923    #[serde(default)]
7924    pub message: String,
7925    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
7926    pub thread_id: Option<String>,
7927}
7928
7929#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7930#[serde(tag = "type", rename_all = "camelCase")]
7931pub enum WebSearchAction {
7932    Search {
7933        #[serde(default, skip_serializing_if = "Option::is_none")]
7934        queries: Option<Vec<String>>,
7935        #[serde(default, skip_serializing_if = "Option::is_none")]
7936        query: Option<String>,
7937    },
7938    #[serde(rename = "openPage")]
7939    OpenPage {
7940        #[serde(default, skip_serializing_if = "Option::is_none")]
7941        url: Option<String>,
7942    },
7943    #[serde(rename = "findInPage")]
7944    FindInPage {
7945        #[serde(default, skip_serializing_if = "Option::is_none")]
7946        pattern: Option<String>,
7947        #[serde(default, skip_serializing_if = "Option::is_none")]
7948        url: Option<String>,
7949    },
7950    Other,
7951}
7952
7953#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7954pub enum WebSearchContextSize {
7955    #[serde(rename = "low")]
7956    Low,
7957    #[serde(rename = "medium")]
7958    Medium,
7959    #[serde(rename = "high")]
7960    High,
7961}
7962
7963#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7964#[serde(rename_all = "camelCase")]
7965pub struct WebSearchLocation {
7966    #[serde(default, skip_serializing_if = "Option::is_none")]
7967    pub city: Option<String>,
7968    #[serde(default, skip_serializing_if = "Option::is_none")]
7969    pub country: Option<String>,
7970    #[serde(default, skip_serializing_if = "Option::is_none")]
7971    pub region: Option<String>,
7972    #[serde(default, skip_serializing_if = "Option::is_none")]
7973    pub timezone: Option<String>,
7974}
7975
7976#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7977pub enum WebSearchMode {
7978    #[serde(rename = "disabled")]
7979    Disabled,
7980    #[serde(rename = "cached")]
7981    Cached,
7982    #[serde(rename = "indexed")]
7983    Indexed,
7984    #[serde(rename = "live")]
7985    Live,
7986}
7987
7988#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7989#[serde(rename_all = "camelCase")]
7990pub struct WebSearchToolConfig {
7991    #[serde(default, skip_serializing_if = "Option::is_none")]
7992    pub allowed_domains: Option<Vec<String>>,
7993    #[serde(default, skip_serializing_if = "Option::is_none")]
7994    pub context_size: Option<WebSearchContextSize>,
7995    #[serde(default, skip_serializing_if = "Option::is_none")]
7996    pub location: Option<WebSearchLocation>,
7997}
7998
7999#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8000pub enum WindowsSandboxReadiness {
8001    #[serde(rename = "ready")]
8002    Ready,
8003    #[serde(rename = "notConfigured")]
8004    NotConfigured,
8005    #[serde(rename = "updateRequired")]
8006    UpdateRequired,
8007}
8008
8009#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8010#[serde(rename_all = "camelCase")]
8011pub struct WindowsSandboxReadinessResponse {
8012    #[serde()]
8013    pub status: WindowsSandboxReadiness,
8014}
8015
8016#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8017#[serde(rename_all = "camelCase")]
8018pub struct WindowsSandboxSetupCompletedNotification {
8019    #[serde(default, skip_serializing_if = "Option::is_none")]
8020    pub error: Option<String>,
8021    #[serde()]
8022    pub mode: WindowsSandboxSetupMode,
8023    #[serde(default)]
8024    pub success: bool,
8025}
8026
8027#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8028pub enum WindowsSandboxSetupMode {
8029    #[serde(rename = "elevated")]
8030    Elevated,
8031    #[serde(rename = "unelevated")]
8032    Unelevated,
8033}
8034
8035#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8036#[serde(rename_all = "camelCase")]
8037pub struct WindowsSandboxSetupStartParams {
8038    #[serde(default, skip_serializing_if = "Option::is_none")]
8039    pub cwd: Option<AbsolutePathBuf>,
8040    #[serde()]
8041    pub mode: WindowsSandboxSetupMode,
8042}
8043
8044#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8045#[serde(rename_all = "camelCase")]
8046pub struct WindowsSandboxSetupStartResponse {
8047    #[serde(default)]
8048    pub started: bool,
8049}
8050
8051#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8052#[serde(rename_all = "camelCase")]
8053pub struct WindowsWorldWritableWarningNotification {
8054    #[serde(rename = "extraCount", default)]
8055    pub extra_count: i64,
8056    #[serde(rename = "failedScan", default)]
8057    pub failed_scan: bool,
8058    #[serde(rename = "samplePaths", default)]
8059    pub sample_paths: Vec<String>,
8060}
8061
8062#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8063#[serde(rename_all = "camelCase")]
8064pub struct WorkspaceMessage {
8065    #[serde(
8066        rename = "archivedAt",
8067        default,
8068        skip_serializing_if = "Option::is_none"
8069    )]
8070    pub archived_at: Option<i64>,
8071    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
8072    pub created_at: Option<i64>,
8073    #[serde(rename = "messageBody", default)]
8074    pub message_body: String,
8075    #[serde(rename = "messageId", default)]
8076    pub message_id: String,
8077    #[serde(rename = "messageType")]
8078    pub message_type: WorkspaceMessageType,
8079}
8080
8081#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8082pub enum WorkspaceMessageType {
8083    #[serde(rename = "headline")]
8084    Headline,
8085    #[serde(rename = "announcement")]
8086    Announcement,
8087    #[serde(rename = "unknown")]
8088    Unknown,
8089}
8090
8091#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8092pub enum WriteStatus {
8093    #[serde(rename = "ok")]
8094    Ok,
8095    #[serde(rename = "okOverridden")]
8096    OkOverridden,
8097}