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