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