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