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}
358
359#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
360#[serde(rename_all = "camelCase")]
361pub struct AppTemplateSummary {
362    #[serde(
363        rename = "canonicalConnectorId",
364        default,
365        skip_serializing_if = "Option::is_none"
366    )]
367    pub canonical_connector_id: Option<String>,
368    #[serde(default, skip_serializing_if = "Option::is_none")]
369    pub description: Option<String>,
370    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
371    pub logo_url: Option<String>,
372    #[serde(
373        rename = "logoUrlDark",
374        default,
375        skip_serializing_if = "Option::is_none"
376    )]
377    pub logo_url_dark: Option<String>,
378    #[serde(rename = "materializedAppIds", default)]
379    pub materialized_app_ids: Vec<String>,
380    #[serde(default)]
381    pub name: String,
382    #[serde(default, skip_serializing_if = "Option::is_none")]
383    pub reason: Option<AppTemplateUnavailableReason>,
384    #[serde(rename = "templateId", default)]
385    pub template_id: String,
386}
387
388#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
389pub enum AppTemplateUnavailableReason {
390    #[serde(rename = "NOT_CONFIGURED_FOR_WORKSPACE")]
391    NOT_CONFIGURED_FOR_WORKSPACE,
392    #[serde(rename = "NO_ACTIVE_WORKSPACE")]
393    NO_ACTIVE_WORKSPACE,
394}
395
396#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
397#[serde(rename_all = "camelCase")]
398pub struct ApplyPatchApprovalParams {
399    #[serde(rename = "callId", default)]
400    pub call_id: String,
401    #[serde(rename = "conversationId")]
402    pub conversation_id: ThreadId,
403    #[serde(rename = "fileChanges", default)]
404    pub file_changes: std::collections::BTreeMap<String, FileChange>,
405    #[serde(rename = "grantRoot", default, skip_serializing_if = "Option::is_none")]
406    pub grant_root: Option<String>,
407    #[serde(default, skip_serializing_if = "Option::is_none")]
408    pub reason: Option<String>,
409}
410
411#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
412#[serde(rename_all = "camelCase")]
413pub struct ApplyPatchApprovalResponse {
414    #[serde()]
415    pub decision: ReviewDecision,
416}
417
418#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
419pub enum ApprovalsReviewer {
420    #[serde(rename = "user")]
421    User,
422    #[serde(rename = "auto_review")]
423    Auto_review,
424    #[serde(rename = "guardian_subagent")]
425    Guardian_subagent,
426}
427
428#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
429#[serde(rename_all = "camelCase")]
430pub struct AppsListParams {
431    #[serde(default, skip_serializing_if = "Option::is_none")]
432    pub cursor: Option<String>,
433    #[serde(
434        rename = "forceRefetch",
435        default,
436        skip_serializing_if = "Option::is_none"
437    )]
438    pub force_refetch: Option<bool>,
439    #[serde(default, skip_serializing_if = "Option::is_none")]
440    pub limit: Option<i64>,
441    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
442    pub thread_id: Option<String>,
443}
444
445#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
446#[serde(rename_all = "camelCase")]
447pub struct AppsListResponse {
448    #[serde(default)]
449    pub data: Vec<AppInfo>,
450    #[serde(
451        rename = "nextCursor",
452        default,
453        skip_serializing_if = "Option::is_none"
454    )]
455    pub next_cursor: Option<String>,
456}
457
458#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
459pub enum AskForApproval {
460    #[serde(rename = "untrusted")]
461    Untrusted,
462    #[serde(rename = "on-failure")]
463    OnFailure,
464    #[serde(rename = "on-request")]
465    OnRequest,
466    #[serde(rename = "never")]
467    Never,
468    #[serde(rename = "granular")]
469    Granular {
470        mcp_elicitations: bool,
471        #[serde(default, skip_serializing_if = "Option::is_none")]
472        request_permissions: Option<bool>,
473        rules: bool,
474        sandbox_approval: bool,
475        #[serde(default, skip_serializing_if = "Option::is_none")]
476        skill_approval: Option<bool>,
477    },
478}
479
480#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
481#[serde(rename_all = "camelCase")]
482pub struct AttestationGenerateParams {
483    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
484    pub extra: serde_json::Map<String, Value>,
485}
486
487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
488#[serde(rename_all = "camelCase")]
489pub struct AttestationGenerateResponse {
490    #[serde(default)]
491    pub token: String,
492}
493
494#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
495pub enum AuthMode {
496    #[serde(rename = "apikey")]
497    Apikey,
498    #[serde(rename = "chatgpt")]
499    Chatgpt,
500    #[serde(rename = "chatgptAuthTokens")]
501    ChatgptAuthTokens,
502    #[serde(rename = "agentIdentity")]
503    AgentIdentity,
504    #[serde(rename = "personalAccessToken")]
505    PersonalAccessToken,
506    #[serde(rename = "bedrockApiKey")]
507    BedrockApiKey,
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, Eq)]
5151pub enum SubAgentActivityKind {
5152    #[serde(rename = "started")]
5153    Started,
5154    #[serde(rename = "interacted")]
5155    Interacted,
5156    #[serde(rename = "interrupted")]
5157    Interrupted,
5158}
5159
5160#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5161pub enum SubAgentSource {
5162    #[serde(rename = "review")]
5163    Review,
5164    #[serde(rename = "compact")]
5165    Compact,
5166    #[serde(rename = "memory_consolidation")]
5167    MemoryConsolidation,
5168    #[serde(rename = "thread_spawn")]
5169    ThreadSpawn {
5170        #[serde(default, skip_serializing_if = "Option::is_none")]
5171        agent_nickname: Option<String>,
5172        #[serde(default, skip_serializing_if = "Option::is_none")]
5173        agent_path: Option<AgentPath>,
5174        #[serde(default, skip_serializing_if = "Option::is_none")]
5175        agent_role: Option<String>,
5176        depth: i64,
5177        parent_thread_id: ThreadId,
5178    },
5179    #[serde(rename = "other")]
5180    Other(String),
5181}
5182
5183#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5184#[serde(rename_all = "camelCase")]
5185pub struct SubagentMigration {
5186    #[serde(default)]
5187    pub name: String,
5188}
5189
5190#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5191#[serde(rename_all = "camelCase")]
5192pub struct TerminalInteractionNotification {
5193    #[serde(rename = "itemId", default)]
5194    pub item_id: String,
5195    #[serde(rename = "processId", default)]
5196    pub process_id: String,
5197    #[serde(default)]
5198    pub stdin: String,
5199    #[serde(rename = "threadId", default)]
5200    pub thread_id: String,
5201    #[serde(rename = "turnId", default)]
5202    pub turn_id: String,
5203}
5204
5205#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5206#[serde(rename_all = "camelCase")]
5207pub struct TextElement {
5208    #[serde(rename = "byteRange", default)]
5209    pub byte_range: Value,
5210    #[serde(default, skip_serializing_if = "Option::is_none")]
5211    pub placeholder: Option<String>,
5212}
5213
5214#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5215#[serde(rename_all = "camelCase")]
5216pub struct TextPosition {
5217    #[serde(default)]
5218    pub column: i64,
5219    #[serde(default)]
5220    pub line: i64,
5221}
5222
5223#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5224#[serde(rename_all = "camelCase")]
5225pub struct TextRange {
5226    #[serde()]
5227    pub end: TextPosition,
5228    #[serde()]
5229    pub start: TextPosition,
5230}
5231
5232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5233#[serde(rename_all = "camelCase")]
5234pub struct Thread {
5235    #[serde(
5236        rename = "agentNickname",
5237        default,
5238        skip_serializing_if = "Option::is_none"
5239    )]
5240    pub agent_nickname: Option<String>,
5241    #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
5242    pub agent_role: Option<String>,
5243    #[serde(rename = "cliVersion", default)]
5244    pub cli_version: String,
5245    #[serde(rename = "createdAt", default)]
5246    pub created_at: i64,
5247    #[serde(default)]
5248    pub cwd: Value,
5249    #[serde(default)]
5250    pub ephemeral: bool,
5251    #[serde(
5252        rename = "forkedFromId",
5253        default,
5254        skip_serializing_if = "Option::is_none"
5255    )]
5256    pub forked_from_id: Option<String>,
5257    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
5258    pub git_info: Option<GitInfo>,
5259    #[serde(default)]
5260    pub id: String,
5261    #[serde(rename = "modelProvider", default)]
5262    pub model_provider: String,
5263    #[serde(default, skip_serializing_if = "Option::is_none")]
5264    pub name: Option<String>,
5265    #[serde(
5266        rename = "parentThreadId",
5267        default,
5268        skip_serializing_if = "Option::is_none"
5269    )]
5270    pub parent_thread_id: Option<String>,
5271    #[serde(default, skip_serializing_if = "Option::is_none")]
5272    pub path: Option<String>,
5273    #[serde(default)]
5274    pub preview: String,
5275    #[serde(rename = "sessionId", default)]
5276    pub session_id: String,
5277    #[serde(default)]
5278    pub source: Value,
5279    #[serde(default)]
5280    pub status: Value,
5281    #[serde(
5282        rename = "threadSource",
5283        default,
5284        skip_serializing_if = "Option::is_none"
5285    )]
5286    pub thread_source: Option<ThreadSource>,
5287    #[serde(default)]
5288    pub turns: Vec<Turn>,
5289    #[serde(rename = "updatedAt", default)]
5290    pub updated_at: i64,
5291}
5292
5293#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5294pub enum ThreadActiveFlag {
5295    #[serde(rename = "waitingOnApproval")]
5296    WaitingOnApproval,
5297    #[serde(rename = "waitingOnUserInput")]
5298    WaitingOnUserInput,
5299}
5300
5301#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5302#[serde(rename_all = "camelCase")]
5303pub struct ThreadApproveGuardianDeniedActionParams {
5304    #[serde(default)]
5305    pub event: Value,
5306    #[serde(rename = "threadId", default)]
5307    pub thread_id: String,
5308}
5309
5310#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5311#[serde(rename_all = "camelCase")]
5312pub struct ThreadApproveGuardianDeniedActionResponse {
5313    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5314    pub extra: serde_json::Map<String, Value>,
5315}
5316
5317#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5318#[serde(rename_all = "camelCase")]
5319pub struct ThreadArchiveParams {
5320    #[serde(rename = "threadId", default)]
5321    pub thread_id: String,
5322}
5323
5324#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5325#[serde(rename_all = "camelCase")]
5326pub struct ThreadArchiveResponse {
5327    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5328    pub extra: serde_json::Map<String, Value>,
5329}
5330
5331#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5332#[serde(rename_all = "camelCase")]
5333pub struct ThreadArchivedNotification {
5334    #[serde(rename = "threadId", default)]
5335    pub thread_id: String,
5336}
5337
5338#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5339#[serde(rename_all = "camelCase")]
5340pub struct ThreadClosedNotification {
5341    #[serde(rename = "threadId", default)]
5342    pub thread_id: String,
5343}
5344
5345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5346#[serde(rename_all = "camelCase")]
5347pub struct ThreadCompactStartParams {
5348    #[serde(rename = "threadId", default)]
5349    pub thread_id: String,
5350}
5351
5352#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5353#[serde(rename_all = "camelCase")]
5354pub struct ThreadCompactStartResponse {
5355    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5356    pub extra: serde_json::Map<String, Value>,
5357}
5358
5359#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5360#[serde(rename_all = "camelCase")]
5361pub struct ThreadDeleteParams {
5362    #[serde(rename = "threadId", default)]
5363    pub thread_id: String,
5364}
5365
5366#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5367#[serde(rename_all = "camelCase")]
5368pub struct ThreadDeleteResponse {
5369    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5370    pub extra: serde_json::Map<String, Value>,
5371}
5372
5373#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5374#[serde(rename_all = "camelCase")]
5375pub struct ThreadDeletedNotification {
5376    #[serde(rename = "threadId", default)]
5377    pub thread_id: String,
5378}
5379
5380#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5381#[serde(rename_all = "camelCase")]
5382pub struct ThreadForkParams {
5383    #[serde(
5384        rename = "approvalPolicy",
5385        default,
5386        skip_serializing_if = "Option::is_none"
5387    )]
5388    pub approval_policy: Option<AskForApproval>,
5389    #[serde(
5390        rename = "approvalsReviewer",
5391        default,
5392        skip_serializing_if = "Option::is_none"
5393    )]
5394    pub approvals_reviewer: Option<ApprovalsReviewer>,
5395    #[serde(
5396        rename = "baseInstructions",
5397        default,
5398        skip_serializing_if = "Option::is_none"
5399    )]
5400    pub base_instructions: Option<String>,
5401    #[serde(default, skip_serializing_if = "Option::is_none")]
5402    pub config: Option<Value>,
5403    #[serde(default, skip_serializing_if = "Option::is_none")]
5404    pub cwd: Option<String>,
5405    #[serde(
5406        rename = "developerInstructions",
5407        default,
5408        skip_serializing_if = "Option::is_none"
5409    )]
5410    pub developer_instructions: Option<String>,
5411    #[serde(default, skip_serializing_if = "Option::is_none")]
5412    pub ephemeral: Option<bool>,
5413    #[serde(default, skip_serializing_if = "Option::is_none")]
5414    pub model: Option<String>,
5415    #[serde(
5416        rename = "modelProvider",
5417        default,
5418        skip_serializing_if = "Option::is_none"
5419    )]
5420    pub model_provider: Option<String>,
5421    #[serde(default, skip_serializing_if = "Option::is_none")]
5422    pub sandbox: Option<SandboxMode>,
5423    #[serde(
5424        rename = "serviceTier",
5425        default,
5426        skip_serializing_if = "Option::is_none"
5427    )]
5428    pub service_tier: Option<String>,
5429    #[serde(rename = "threadId", default)]
5430    pub thread_id: String,
5431    #[serde(
5432        rename = "threadSource",
5433        default,
5434        skip_serializing_if = "Option::is_none"
5435    )]
5436    pub thread_source: Option<ThreadSource>,
5437}
5438
5439#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5440#[serde(rename_all = "camelCase")]
5441pub struct ThreadForkResponse {
5442    #[serde(rename = "approvalPolicy")]
5443    pub approval_policy: AskForApproval,
5444    #[serde(rename = "approvalsReviewer", default)]
5445    pub approvals_reviewer: Value,
5446    #[serde()]
5447    pub cwd: AbsolutePathBuf,
5448    #[serde(
5449        rename = "instructionSources",
5450        default,
5451        skip_serializing_if = "Option::is_none"
5452    )]
5453    pub instruction_sources: Option<Vec<AbsolutePathBuf>>,
5454    #[serde(default)]
5455    pub model: String,
5456    #[serde(rename = "modelProvider", default)]
5457    pub model_provider: String,
5458    #[serde(
5459        rename = "reasoningEffort",
5460        default,
5461        skip_serializing_if = "Option::is_none"
5462    )]
5463    pub reasoning_effort: Option<ReasoningEffort>,
5464    #[serde(default)]
5465    pub sandbox: Value,
5466    #[serde(
5467        rename = "serviceTier",
5468        default,
5469        skip_serializing_if = "Option::is_none"
5470    )]
5471    pub service_tier: Option<String>,
5472    #[serde()]
5473    pub thread: Thread,
5474}
5475
5476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5477#[serde(rename_all = "camelCase")]
5478pub struct ThreadGoal {
5479    #[serde(rename = "createdAt", default)]
5480    pub created_at: i64,
5481    #[serde(default)]
5482    pub objective: String,
5483    #[serde()]
5484    pub status: ThreadGoalStatus,
5485    #[serde(rename = "threadId", default)]
5486    pub thread_id: String,
5487    #[serde(rename = "timeUsedSeconds", default)]
5488    pub time_used_seconds: i64,
5489    #[serde(
5490        rename = "tokenBudget",
5491        default,
5492        skip_serializing_if = "Option::is_none"
5493    )]
5494    pub token_budget: Option<i64>,
5495    #[serde(rename = "tokensUsed", default)]
5496    pub tokens_used: i64,
5497    #[serde(rename = "updatedAt", default)]
5498    pub updated_at: i64,
5499}
5500
5501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5502#[serde(rename_all = "camelCase")]
5503pub struct ThreadGoalClearParams {
5504    #[serde(rename = "threadId", default)]
5505    pub thread_id: String,
5506}
5507
5508#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5509#[serde(rename_all = "camelCase")]
5510pub struct ThreadGoalClearResponse {
5511    #[serde(default)]
5512    pub cleared: bool,
5513}
5514
5515#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5516#[serde(rename_all = "camelCase")]
5517pub struct ThreadGoalClearedNotification {
5518    #[serde(rename = "threadId", default)]
5519    pub thread_id: String,
5520}
5521
5522#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5523#[serde(rename_all = "camelCase")]
5524pub struct ThreadGoalGetParams {
5525    #[serde(rename = "threadId", default)]
5526    pub thread_id: String,
5527}
5528
5529#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5530#[serde(rename_all = "camelCase")]
5531pub struct ThreadGoalGetResponse {
5532    #[serde(default, skip_serializing_if = "Option::is_none")]
5533    pub goal: Option<ThreadGoal>,
5534}
5535
5536#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5537#[serde(rename_all = "camelCase")]
5538pub struct ThreadGoalSetParams {
5539    #[serde(default, skip_serializing_if = "Option::is_none")]
5540    pub objective: Option<String>,
5541    #[serde(default, skip_serializing_if = "Option::is_none")]
5542    pub status: Option<ThreadGoalStatus>,
5543    #[serde(rename = "threadId", default)]
5544    pub thread_id: String,
5545    #[serde(
5546        rename = "tokenBudget",
5547        default,
5548        skip_serializing_if = "Option::is_none"
5549    )]
5550    pub token_budget: Option<i64>,
5551}
5552
5553#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5554#[serde(rename_all = "camelCase")]
5555pub struct ThreadGoalSetResponse {
5556    #[serde()]
5557    pub goal: ThreadGoal,
5558}
5559
5560#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5561pub enum ThreadGoalStatus {
5562    #[serde(rename = "active")]
5563    Active,
5564    #[serde(rename = "paused")]
5565    Paused,
5566    #[serde(rename = "blocked")]
5567    Blocked,
5568    #[serde(rename = "usageLimited")]
5569    UsageLimited,
5570    #[serde(rename = "budgetLimited")]
5571    BudgetLimited,
5572    #[serde(rename = "complete")]
5573    Complete,
5574}
5575
5576#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5577#[serde(rename_all = "camelCase")]
5578pub struct ThreadGoalUpdatedNotification {
5579    #[serde()]
5580    pub goal: ThreadGoal,
5581    #[serde(rename = "threadId", default)]
5582    pub thread_id: String,
5583    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
5584    pub turn_id: Option<String>,
5585}
5586
5587#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
5588#[serde(transparent)]
5589pub struct ThreadId(pub String);
5590
5591#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5592#[serde(rename_all = "camelCase")]
5593pub struct ThreadInjectItemsParams {
5594    #[serde(default)]
5595    pub items: Vec<Value>,
5596    #[serde(rename = "threadId", default)]
5597    pub thread_id: String,
5598}
5599
5600#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5601#[serde(rename_all = "camelCase")]
5602pub struct ThreadInjectItemsResponse {
5603    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5604    pub extra: serde_json::Map<String, Value>,
5605}
5606
5607#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5608#[serde(tag = "type", rename_all = "camelCase")]
5609pub enum ThreadItem {
5610    #[serde(rename = "userMessage")]
5611    UserMessage {
5612        #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
5613        client_id: Option<String>,
5614        content: Vec<UserInput>,
5615        id: String,
5616    },
5617    #[serde(rename = "hookPrompt")]
5618    HookPrompt {
5619        fragments: Vec<HookPromptFragment>,
5620        id: String,
5621    },
5622    #[serde(rename = "agentMessage")]
5623    AgentMessage {
5624        id: String,
5625        #[serde(
5626            rename = "memoryCitation",
5627            default,
5628            skip_serializing_if = "Option::is_none"
5629        )]
5630        memory_citation: Option<MemoryCitation>,
5631        #[serde(default, skip_serializing_if = "Option::is_none")]
5632        phase: Option<MessagePhase>,
5633        text: String,
5634    },
5635    Plan {
5636        id: String,
5637        text: String,
5638    },
5639    Reasoning {
5640        #[serde(default, skip_serializing_if = "Option::is_none")]
5641        content: Option<Vec<String>>,
5642        id: String,
5643        #[serde(default, skip_serializing_if = "Option::is_none")]
5644        summary: Option<Vec<String>>,
5645    },
5646    #[serde(rename = "commandExecution")]
5647    CommandExecution {
5648        #[serde(
5649            rename = "aggregatedOutput",
5650            default,
5651            skip_serializing_if = "Option::is_none"
5652        )]
5653        aggregated_output: Option<String>,
5654        command: String,
5655        #[serde(rename = "commandActions")]
5656        command_actions: Vec<CommandAction>,
5657        cwd: Value,
5658        #[serde(
5659            rename = "durationMs",
5660            default,
5661            skip_serializing_if = "Option::is_none"
5662        )]
5663        duration_ms: Option<i64>,
5664        #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
5665        exit_code: Option<i64>,
5666        id: String,
5667        #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
5668        process_id: Option<String>,
5669        #[serde(default, skip_serializing_if = "Option::is_none")]
5670        source: Option<Value>,
5671        status: CommandExecutionStatus,
5672    },
5673    #[serde(rename = "fileChange")]
5674    FileChange {
5675        changes: Vec<FileUpdateChange>,
5676        id: String,
5677        status: PatchApplyStatus,
5678    },
5679    #[serde(rename = "mcpToolCall")]
5680    McpToolCall {
5681        arguments: Value,
5682        #[serde(
5683            rename = "durationMs",
5684            default,
5685            skip_serializing_if = "Option::is_none"
5686        )]
5687        duration_ms: Option<i64>,
5688        #[serde(default, skip_serializing_if = "Option::is_none")]
5689        error: Option<McpToolCallError>,
5690        id: String,
5691        #[serde(
5692            rename = "mcpAppResourceUri",
5693            default,
5694            skip_serializing_if = "Option::is_none"
5695        )]
5696        mcp_app_resource_uri: Option<String>,
5697        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
5698        plugin_id: Option<String>,
5699        #[serde(default, skip_serializing_if = "Option::is_none")]
5700        result: Option<McpToolCallResult>,
5701        server: String,
5702        status: McpToolCallStatus,
5703        tool: String,
5704    },
5705    #[serde(rename = "dynamicToolCall")]
5706    DynamicToolCall {
5707        arguments: Value,
5708        #[serde(
5709            rename = "contentItems",
5710            default,
5711            skip_serializing_if = "Option::is_none"
5712        )]
5713        content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
5714        #[serde(
5715            rename = "durationMs",
5716            default,
5717            skip_serializing_if = "Option::is_none"
5718        )]
5719        duration_ms: Option<i64>,
5720        id: String,
5721        #[serde(default, skip_serializing_if = "Option::is_none")]
5722        namespace: Option<String>,
5723        status: DynamicToolCallStatus,
5724        #[serde(default, skip_serializing_if = "Option::is_none")]
5725        success: Option<bool>,
5726        tool: String,
5727    },
5728    #[serde(rename = "collabAgentToolCall")]
5729    CollabAgentToolCall {
5730        #[serde(rename = "agentsStates")]
5731        agents_states: std::collections::BTreeMap<String, CollabAgentState>,
5732        id: String,
5733        #[serde(default, skip_serializing_if = "Option::is_none")]
5734        model: Option<String>,
5735        #[serde(default, skip_serializing_if = "Option::is_none")]
5736        prompt: Option<String>,
5737        #[serde(
5738            rename = "reasoningEffort",
5739            default,
5740            skip_serializing_if = "Option::is_none"
5741        )]
5742        reasoning_effort: Option<ReasoningEffort>,
5743        #[serde(rename = "receiverThreadIds")]
5744        receiver_thread_ids: Vec<String>,
5745        #[serde(rename = "senderThreadId")]
5746        sender_thread_id: String,
5747        status: Value,
5748        tool: Value,
5749    },
5750    #[serde(rename = "subAgentActivity")]
5751    SubAgentActivity {
5752        #[serde(rename = "agentPath")]
5753        agent_path: String,
5754        #[serde(rename = "agentThreadId")]
5755        agent_thread_id: String,
5756        id: String,
5757        kind: SubAgentActivityKind,
5758    },
5759    #[serde(rename = "webSearch")]
5760    WebSearch {
5761        #[serde(default, skip_serializing_if = "Option::is_none")]
5762        action: Option<WebSearchAction>,
5763        id: String,
5764        query: String,
5765    },
5766    #[serde(rename = "imageView")]
5767    ImageView {
5768        id: String,
5769        path: AbsolutePathBuf,
5770    },
5771    #[serde(rename = "imageGeneration")]
5772    ImageGeneration {
5773        id: String,
5774        result: String,
5775        #[serde(
5776            rename = "revisedPrompt",
5777            default,
5778            skip_serializing_if = "Option::is_none"
5779        )]
5780        revised_prompt: Option<String>,
5781        #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
5782        saved_path: Option<AbsolutePathBuf>,
5783        status: String,
5784    },
5785    #[serde(rename = "enteredReviewMode")]
5786    EnteredReviewMode {
5787        id: String,
5788        review: String,
5789    },
5790    #[serde(rename = "exitedReviewMode")]
5791    ExitedReviewMode {
5792        id: String,
5793        review: String,
5794    },
5795    #[serde(rename = "contextCompaction")]
5796    ContextCompaction {
5797        id: String,
5798    },
5799}
5800
5801#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5802#[serde(untagged)]
5803pub enum ThreadListCwdFilter {
5804    Variant0(String),
5805    Variant1(Vec<String>),
5806}
5807
5808#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5809#[serde(rename_all = "camelCase")]
5810pub struct ThreadListParams {
5811    #[serde(default, skip_serializing_if = "Option::is_none")]
5812    pub archived: Option<bool>,
5813    #[serde(default, skip_serializing_if = "Option::is_none")]
5814    pub cursor: Option<String>,
5815    #[serde(default, skip_serializing_if = "Option::is_none")]
5816    pub cwd: Option<ThreadListCwdFilter>,
5817    #[serde(default, skip_serializing_if = "Option::is_none")]
5818    pub limit: Option<i64>,
5819    #[serde(
5820        rename = "modelProviders",
5821        default,
5822        skip_serializing_if = "Option::is_none"
5823    )]
5824    pub model_providers: Option<Vec<String>>,
5825    #[serde(
5826        rename = "searchTerm",
5827        default,
5828        skip_serializing_if = "Option::is_none"
5829    )]
5830    pub search_term: Option<String>,
5831    #[serde(
5832        rename = "sortDirection",
5833        default,
5834        skip_serializing_if = "Option::is_none"
5835    )]
5836    pub sort_direction: Option<SortDirection>,
5837    #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
5838    pub sort_key: Option<ThreadSortKey>,
5839    #[serde(
5840        rename = "sourceKinds",
5841        default,
5842        skip_serializing_if = "Option::is_none"
5843    )]
5844    pub source_kinds: Option<Vec<ThreadSourceKind>>,
5845    #[serde(
5846        rename = "useStateDbOnly",
5847        default,
5848        skip_serializing_if = "Option::is_none"
5849    )]
5850    pub use_state_db_only: Option<bool>,
5851}
5852
5853#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5854#[serde(rename_all = "camelCase")]
5855pub struct ThreadListResponse {
5856    #[serde(
5857        rename = "backwardsCursor",
5858        default,
5859        skip_serializing_if = "Option::is_none"
5860    )]
5861    pub backwards_cursor: Option<String>,
5862    #[serde(default)]
5863    pub data: Vec<Thread>,
5864    #[serde(
5865        rename = "nextCursor",
5866        default,
5867        skip_serializing_if = "Option::is_none"
5868    )]
5869    pub next_cursor: Option<String>,
5870}
5871
5872#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5873#[serde(rename_all = "camelCase")]
5874pub struct ThreadLoadedListParams {
5875    #[serde(default, skip_serializing_if = "Option::is_none")]
5876    pub cursor: Option<String>,
5877    #[serde(default, skip_serializing_if = "Option::is_none")]
5878    pub limit: Option<i64>,
5879}
5880
5881#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5882#[serde(rename_all = "camelCase")]
5883pub struct ThreadLoadedListResponse {
5884    #[serde(default)]
5885    pub data: Vec<String>,
5886    #[serde(
5887        rename = "nextCursor",
5888        default,
5889        skip_serializing_if = "Option::is_none"
5890    )]
5891    pub next_cursor: Option<String>,
5892}
5893
5894#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5895#[serde(rename_all = "camelCase")]
5896pub struct ThreadMetadataGitInfoUpdateParams {
5897    #[serde(default, skip_serializing_if = "Option::is_none")]
5898    pub branch: Option<String>,
5899    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
5900    pub origin_url: Option<String>,
5901    #[serde(default, skip_serializing_if = "Option::is_none")]
5902    pub sha: Option<String>,
5903}
5904
5905#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5906#[serde(rename_all = "camelCase")]
5907pub struct ThreadMetadataUpdateParams {
5908    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
5909    pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
5910    #[serde(rename = "threadId", default)]
5911    pub thread_id: String,
5912}
5913
5914#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5915#[serde(rename_all = "camelCase")]
5916pub struct ThreadMetadataUpdateResponse {
5917    #[serde()]
5918    pub thread: Thread,
5919}
5920
5921#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5922#[serde(rename_all = "camelCase")]
5923pub struct ThreadNameUpdatedNotification {
5924    #[serde(rename = "threadId", default)]
5925    pub thread_id: String,
5926    #[serde(
5927        rename = "threadName",
5928        default,
5929        skip_serializing_if = "Option::is_none"
5930    )]
5931    pub thread_name: Option<String>,
5932}
5933
5934#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5935#[serde(rename_all = "camelCase")]
5936pub struct ThreadReadParams {
5937    #[serde(
5938        rename = "includeTurns",
5939        default,
5940        skip_serializing_if = "Option::is_none"
5941    )]
5942    pub include_turns: Option<bool>,
5943    #[serde(rename = "threadId", default)]
5944    pub thread_id: String,
5945}
5946
5947#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5948#[serde(rename_all = "camelCase")]
5949pub struct ThreadReadResponse {
5950    #[serde()]
5951    pub thread: Thread,
5952}
5953
5954#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5955#[serde(rename_all = "camelCase")]
5956pub struct ThreadRealtimeAudioChunk {
5957    #[serde(default)]
5958    pub data: String,
5959    #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
5960    pub item_id: Option<String>,
5961    #[serde(rename = "numChannels", default)]
5962    pub num_channels: i64,
5963    #[serde(rename = "sampleRate", default)]
5964    pub sample_rate: i64,
5965    #[serde(
5966        rename = "samplesPerChannel",
5967        default,
5968        skip_serializing_if = "Option::is_none"
5969    )]
5970    pub samples_per_channel: Option<i64>,
5971}
5972
5973#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5974#[serde(rename_all = "camelCase")]
5975pub struct ThreadRealtimeClosedNotification {
5976    #[serde(default, skip_serializing_if = "Option::is_none")]
5977    pub reason: Option<String>,
5978    #[serde(rename = "threadId", default)]
5979    pub thread_id: String,
5980}
5981
5982#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5983#[serde(rename_all = "camelCase")]
5984pub struct ThreadRealtimeErrorNotification {
5985    #[serde(default)]
5986    pub message: String,
5987    #[serde(rename = "threadId", default)]
5988    pub thread_id: String,
5989}
5990
5991#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5992#[serde(rename_all = "camelCase")]
5993pub struct ThreadRealtimeItemAddedNotification {
5994    #[serde(default)]
5995    pub item: Value,
5996    #[serde(rename = "threadId", default)]
5997    pub thread_id: String,
5998}
5999
6000#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6001#[serde(rename_all = "camelCase")]
6002pub struct ThreadRealtimeOutputAudioDeltaNotification {
6003    #[serde()]
6004    pub audio: ThreadRealtimeAudioChunk,
6005    #[serde(rename = "threadId", default)]
6006    pub thread_id: String,
6007}
6008
6009#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6010#[serde(rename_all = "camelCase")]
6011pub struct ThreadRealtimeSdpNotification {
6012    #[serde(default)]
6013    pub sdp: String,
6014    #[serde(rename = "threadId", default)]
6015    pub thread_id: String,
6016}
6017
6018#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6019#[serde(rename_all = "camelCase")]
6020pub struct ThreadRealtimeStartedNotification {
6021    #[serde(
6022        rename = "realtimeSessionId",
6023        default,
6024        skip_serializing_if = "Option::is_none"
6025    )]
6026    pub realtime_session_id: Option<String>,
6027    #[serde(rename = "threadId", default)]
6028    pub thread_id: String,
6029    #[serde()]
6030    pub version: RealtimeConversationVersion,
6031}
6032
6033#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6034#[serde(rename_all = "camelCase")]
6035pub struct ThreadRealtimeTranscriptDeltaNotification {
6036    #[serde(default)]
6037    pub delta: String,
6038    #[serde(default)]
6039    pub role: String,
6040    #[serde(rename = "threadId", default)]
6041    pub thread_id: String,
6042}
6043
6044#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6045#[serde(rename_all = "camelCase")]
6046pub struct ThreadRealtimeTranscriptDoneNotification {
6047    #[serde(default)]
6048    pub role: String,
6049    #[serde(default)]
6050    pub text: String,
6051    #[serde(rename = "threadId", default)]
6052    pub thread_id: String,
6053}
6054
6055#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6056#[serde(rename_all = "camelCase")]
6057pub struct ThreadResumeParams {
6058    #[serde(
6059        rename = "approvalPolicy",
6060        default,
6061        skip_serializing_if = "Option::is_none"
6062    )]
6063    pub approval_policy: Option<AskForApproval>,
6064    #[serde(
6065        rename = "approvalsReviewer",
6066        default,
6067        skip_serializing_if = "Option::is_none"
6068    )]
6069    pub approvals_reviewer: Option<ApprovalsReviewer>,
6070    #[serde(
6071        rename = "baseInstructions",
6072        default,
6073        skip_serializing_if = "Option::is_none"
6074    )]
6075    pub base_instructions: Option<String>,
6076    #[serde(default, skip_serializing_if = "Option::is_none")]
6077    pub config: Option<Value>,
6078    #[serde(default, skip_serializing_if = "Option::is_none")]
6079    pub cwd: Option<String>,
6080    #[serde(
6081        rename = "developerInstructions",
6082        default,
6083        skip_serializing_if = "Option::is_none"
6084    )]
6085    pub developer_instructions: Option<String>,
6086    #[serde(default, skip_serializing_if = "Option::is_none")]
6087    pub model: Option<String>,
6088    #[serde(
6089        rename = "modelProvider",
6090        default,
6091        skip_serializing_if = "Option::is_none"
6092    )]
6093    pub model_provider: Option<String>,
6094    #[serde(default, skip_serializing_if = "Option::is_none")]
6095    pub personality: Option<Personality>,
6096    #[serde(default, skip_serializing_if = "Option::is_none")]
6097    pub sandbox: Option<SandboxMode>,
6098    #[serde(
6099        rename = "serviceTier",
6100        default,
6101        skip_serializing_if = "Option::is_none"
6102    )]
6103    pub service_tier: Option<String>,
6104    #[serde(rename = "threadId", default)]
6105    pub thread_id: String,
6106}
6107
6108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6109#[serde(rename_all = "camelCase")]
6110pub struct ThreadResumeResponse {
6111    #[serde(rename = "approvalPolicy")]
6112    pub approval_policy: AskForApproval,
6113    #[serde(rename = "approvalsReviewer", default)]
6114    pub approvals_reviewer: Value,
6115    #[serde()]
6116    pub cwd: AbsolutePathBuf,
6117    #[serde(
6118        rename = "instructionSources",
6119        default,
6120        skip_serializing_if = "Option::is_none"
6121    )]
6122    pub instruction_sources: Option<Vec<AbsolutePathBuf>>,
6123    #[serde(default)]
6124    pub model: String,
6125    #[serde(rename = "modelProvider", default)]
6126    pub model_provider: String,
6127    #[serde(
6128        rename = "reasoningEffort",
6129        default,
6130        skip_serializing_if = "Option::is_none"
6131    )]
6132    pub reasoning_effort: Option<ReasoningEffort>,
6133    #[serde(default)]
6134    pub sandbox: Value,
6135    #[serde(
6136        rename = "serviceTier",
6137        default,
6138        skip_serializing_if = "Option::is_none"
6139    )]
6140    pub service_tier: Option<String>,
6141    #[serde()]
6142    pub thread: Thread,
6143}
6144
6145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6146#[serde(rename_all = "camelCase")]
6147pub struct ThreadRollbackParams {
6148    #[serde(rename = "numTurns", default)]
6149    pub num_turns: i64,
6150    #[serde(rename = "threadId", default)]
6151    pub thread_id: String,
6152}
6153
6154#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6155#[serde(rename_all = "camelCase")]
6156pub struct ThreadRollbackResponse {
6157    #[serde(default)]
6158    pub thread: Value,
6159}
6160
6161#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6162#[serde(rename_all = "camelCase")]
6163pub struct ThreadSetNameParams {
6164    #[serde(default)]
6165    pub name: String,
6166    #[serde(rename = "threadId", default)]
6167    pub thread_id: String,
6168}
6169
6170#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6171#[serde(rename_all = "camelCase")]
6172pub struct ThreadSetNameResponse {
6173    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6174    pub extra: serde_json::Map<String, Value>,
6175}
6176
6177#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6178#[serde(rename_all = "camelCase")]
6179pub struct ThreadSettings {
6180    #[serde(
6181        rename = "activePermissionProfile",
6182        default,
6183        skip_serializing_if = "Option::is_none"
6184    )]
6185    pub active_permission_profile: Option<ActivePermissionProfile>,
6186    #[serde(rename = "approvalPolicy")]
6187    pub approval_policy: AskForApproval,
6188    #[serde(rename = "approvalsReviewer")]
6189    pub approvals_reviewer: ApprovalsReviewer,
6190    #[serde(rename = "collaborationMode")]
6191    pub collaboration_mode: CollaborationMode,
6192    #[serde()]
6193    pub cwd: AbsolutePathBuf,
6194    #[serde(default, skip_serializing_if = "Option::is_none")]
6195    pub effort: Option<ReasoningEffort>,
6196    #[serde(default)]
6197    pub model: String,
6198    #[serde(rename = "modelProvider", default)]
6199    pub model_provider: String,
6200    #[serde(default, skip_serializing_if = "Option::is_none")]
6201    pub personality: Option<Personality>,
6202    #[serde(rename = "sandboxPolicy")]
6203    pub sandbox_policy: SandboxPolicy,
6204    #[serde(
6205        rename = "serviceTier",
6206        default,
6207        skip_serializing_if = "Option::is_none"
6208    )]
6209    pub service_tier: Option<String>,
6210    #[serde(default, skip_serializing_if = "Option::is_none")]
6211    pub summary: Option<ReasoningSummary>,
6212}
6213
6214#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6215#[serde(rename_all = "camelCase")]
6216pub struct ThreadSettingsUpdatedNotification {
6217    #[serde(rename = "threadId", default)]
6218    pub thread_id: String,
6219    #[serde(rename = "threadSettings")]
6220    pub thread_settings: ThreadSettings,
6221}
6222
6223#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6224#[serde(rename_all = "camelCase")]
6225pub struct ThreadShellCommandParams {
6226    #[serde(default)]
6227    pub command: String,
6228    #[serde(rename = "threadId", default)]
6229    pub thread_id: String,
6230}
6231
6232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6233#[serde(rename_all = "camelCase")]
6234pub struct ThreadShellCommandResponse {
6235    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6236    pub extra: serde_json::Map<String, Value>,
6237}
6238
6239#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6240pub enum ThreadSortKey {
6241    #[serde(rename = "created_at")]
6242    Created_at,
6243    #[serde(rename = "updated_at")]
6244    Updated_at,
6245}
6246
6247#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
6248#[serde(transparent)]
6249pub struct ThreadSource(pub String);
6250
6251#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6252pub enum ThreadSourceKind {
6253    #[serde(rename = "cli")]
6254    Cli,
6255    #[serde(rename = "vscode")]
6256    Vscode,
6257    #[serde(rename = "exec")]
6258    Exec,
6259    #[serde(rename = "appServer")]
6260    AppServer,
6261    #[serde(rename = "subAgent")]
6262    SubAgent,
6263    #[serde(rename = "subAgentReview")]
6264    SubAgentReview,
6265    #[serde(rename = "subAgentCompact")]
6266    SubAgentCompact,
6267    #[serde(rename = "subAgentThreadSpawn")]
6268    SubAgentThreadSpawn,
6269    #[serde(rename = "subAgentOther")]
6270    SubAgentOther,
6271    #[serde(rename = "unknown")]
6272    Unknown,
6273}
6274
6275#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6276#[serde(rename_all = "camelCase")]
6277pub struct ThreadStartParams {
6278    #[serde(
6279        rename = "approvalPolicy",
6280        default,
6281        skip_serializing_if = "Option::is_none"
6282    )]
6283    pub approval_policy: Option<AskForApproval>,
6284    #[serde(
6285        rename = "approvalsReviewer",
6286        default,
6287        skip_serializing_if = "Option::is_none"
6288    )]
6289    pub approvals_reviewer: Option<ApprovalsReviewer>,
6290    #[serde(
6291        rename = "baseInstructions",
6292        default,
6293        skip_serializing_if = "Option::is_none"
6294    )]
6295    pub base_instructions: Option<String>,
6296    #[serde(default, skip_serializing_if = "Option::is_none")]
6297    pub config: Option<Value>,
6298    #[serde(default, skip_serializing_if = "Option::is_none")]
6299    pub cwd: Option<String>,
6300    #[serde(
6301        rename = "developerInstructions",
6302        default,
6303        skip_serializing_if = "Option::is_none"
6304    )]
6305    pub developer_instructions: Option<String>,
6306    #[serde(default, skip_serializing_if = "Option::is_none")]
6307    pub ephemeral: Option<bool>,
6308    #[serde(default, skip_serializing_if = "Option::is_none")]
6309    pub model: Option<String>,
6310    #[serde(
6311        rename = "modelProvider",
6312        default,
6313        skip_serializing_if = "Option::is_none"
6314    )]
6315    pub model_provider: Option<String>,
6316    #[serde(default, skip_serializing_if = "Option::is_none")]
6317    pub personality: Option<Personality>,
6318    #[serde(default, skip_serializing_if = "Option::is_none")]
6319    pub sandbox: Option<SandboxMode>,
6320    #[serde(
6321        rename = "serviceName",
6322        default,
6323        skip_serializing_if = "Option::is_none"
6324    )]
6325    pub service_name: Option<String>,
6326    #[serde(
6327        rename = "serviceTier",
6328        default,
6329        skip_serializing_if = "Option::is_none"
6330    )]
6331    pub service_tier: Option<String>,
6332    #[serde(
6333        rename = "sessionStartSource",
6334        default,
6335        skip_serializing_if = "Option::is_none"
6336    )]
6337    pub session_start_source: Option<ThreadStartSource>,
6338    #[serde(
6339        rename = "threadSource",
6340        default,
6341        skip_serializing_if = "Option::is_none"
6342    )]
6343    pub thread_source: Option<ThreadSource>,
6344}
6345
6346#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6347#[serde(rename_all = "camelCase")]
6348pub struct ThreadStartResponse {
6349    #[serde(rename = "approvalPolicy")]
6350    pub approval_policy: AskForApproval,
6351    #[serde(rename = "approvalsReviewer", default)]
6352    pub approvals_reviewer: Value,
6353    #[serde()]
6354    pub cwd: AbsolutePathBuf,
6355    #[serde(
6356        rename = "instructionSources",
6357        default,
6358        skip_serializing_if = "Option::is_none"
6359    )]
6360    pub instruction_sources: Option<Vec<AbsolutePathBuf>>,
6361    #[serde(default)]
6362    pub model: String,
6363    #[serde(rename = "modelProvider", default)]
6364    pub model_provider: String,
6365    #[serde(
6366        rename = "reasoningEffort",
6367        default,
6368        skip_serializing_if = "Option::is_none"
6369    )]
6370    pub reasoning_effort: Option<ReasoningEffort>,
6371    #[serde(default)]
6372    pub sandbox: Value,
6373    #[serde(
6374        rename = "serviceTier",
6375        default,
6376        skip_serializing_if = "Option::is_none"
6377    )]
6378    pub service_tier: Option<String>,
6379    #[serde()]
6380    pub thread: Thread,
6381}
6382
6383#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6384pub enum ThreadStartSource {
6385    #[serde(rename = "startup")]
6386    Startup,
6387    #[serde(rename = "clear")]
6388    Clear,
6389}
6390
6391#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6392#[serde(rename_all = "camelCase")]
6393pub struct ThreadStartedNotification {
6394    #[serde()]
6395    pub thread: Thread,
6396}
6397
6398#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6399#[serde(tag = "type", rename_all = "camelCase")]
6400pub enum ThreadStatus {
6401    #[serde(rename = "notLoaded")]
6402    NotLoaded,
6403    Idle,
6404    #[serde(rename = "systemError")]
6405    SystemError,
6406    Active {
6407        #[serde(rename = "activeFlags")]
6408        active_flags: Vec<ThreadActiveFlag>,
6409    },
6410}
6411
6412#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6413#[serde(rename_all = "camelCase")]
6414pub struct ThreadStatusChangedNotification {
6415    #[serde()]
6416    pub status: ThreadStatus,
6417    #[serde(rename = "threadId", default)]
6418    pub thread_id: String,
6419}
6420
6421#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6422#[serde(rename_all = "camelCase")]
6423pub struct ThreadTokenUsage {
6424    #[serde()]
6425    pub last: TokenUsageBreakdown,
6426    #[serde(
6427        rename = "modelContextWindow",
6428        default,
6429        skip_serializing_if = "Option::is_none"
6430    )]
6431    pub model_context_window: Option<i64>,
6432    #[serde()]
6433    pub total: TokenUsageBreakdown,
6434}
6435
6436#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6437#[serde(rename_all = "camelCase")]
6438pub struct ThreadTokenUsageUpdatedNotification {
6439    #[serde(rename = "threadId", default)]
6440    pub thread_id: String,
6441    #[serde(rename = "tokenUsage")]
6442    pub token_usage: ThreadTokenUsage,
6443    #[serde(rename = "turnId", default)]
6444    pub turn_id: String,
6445}
6446
6447#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6448#[serde(rename_all = "camelCase")]
6449pub struct ThreadUnarchiveParams {
6450    #[serde(rename = "threadId", default)]
6451    pub thread_id: String,
6452}
6453
6454#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6455#[serde(rename_all = "camelCase")]
6456pub struct ThreadUnarchiveResponse {
6457    #[serde()]
6458    pub thread: Thread,
6459}
6460
6461#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6462#[serde(rename_all = "camelCase")]
6463pub struct ThreadUnarchivedNotification {
6464    #[serde(rename = "threadId", default)]
6465    pub thread_id: String,
6466}
6467
6468#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6469#[serde(rename_all = "camelCase")]
6470pub struct ThreadUnsubscribeParams {
6471    #[serde(rename = "threadId", default)]
6472    pub thread_id: String,
6473}
6474
6475#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6476#[serde(rename_all = "camelCase")]
6477pub struct ThreadUnsubscribeResponse {
6478    #[serde()]
6479    pub status: ThreadUnsubscribeStatus,
6480}
6481
6482#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6483pub enum ThreadUnsubscribeStatus {
6484    #[serde(rename = "notLoaded")]
6485    NotLoaded,
6486    #[serde(rename = "notSubscribed")]
6487    NotSubscribed,
6488    #[serde(rename = "unsubscribed")]
6489    Unsubscribed,
6490}
6491
6492#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6493#[serde(rename_all = "camelCase")]
6494pub struct TokenUsageBreakdown {
6495    #[serde(rename = "cachedInputTokens", default)]
6496    pub cached_input_tokens: i64,
6497    #[serde(rename = "inputTokens", default)]
6498    pub input_tokens: i64,
6499    #[serde(rename = "outputTokens", default)]
6500    pub output_tokens: i64,
6501    #[serde(rename = "reasoningOutputTokens", default)]
6502    pub reasoning_output_tokens: i64,
6503    #[serde(rename = "totalTokens", default)]
6504    pub total_tokens: i64,
6505}
6506
6507#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6508#[serde(rename_all = "camelCase")]
6509pub struct Tool {
6510    #[serde(default, skip_serializing_if = "Option::is_none")]
6511    pub _meta: Option<Value>,
6512    #[serde(default, skip_serializing_if = "Option::is_none")]
6513    pub annotations: Option<Value>,
6514    #[serde(default, skip_serializing_if = "Option::is_none")]
6515    pub description: Option<String>,
6516    #[serde(default, skip_serializing_if = "Option::is_none")]
6517    pub icons: Option<Vec<Value>>,
6518    #[serde(rename = "inputSchema", default)]
6519    pub input_schema: Value,
6520    #[serde(default)]
6521    pub name: String,
6522    #[serde(
6523        rename = "outputSchema",
6524        default,
6525        skip_serializing_if = "Option::is_none"
6526    )]
6527    pub output_schema: Option<Value>,
6528    #[serde(default, skip_serializing_if = "Option::is_none")]
6529    pub title: Option<String>,
6530}
6531
6532#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6533#[serde(rename_all = "camelCase")]
6534pub struct ToolRequestUserInputAnswer {
6535    #[serde(default)]
6536    pub answers: Vec<String>,
6537}
6538
6539#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6540#[serde(rename_all = "camelCase")]
6541pub struct ToolRequestUserInputOption {
6542    #[serde(default)]
6543    pub description: String,
6544    #[serde(default)]
6545    pub label: String,
6546}
6547
6548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6549#[serde(rename_all = "camelCase")]
6550pub struct ToolRequestUserInputParams {
6551    #[serde(rename = "itemId", default)]
6552    pub item_id: String,
6553    #[serde(default)]
6554    pub questions: Vec<ToolRequestUserInputQuestion>,
6555    #[serde(rename = "threadId", default)]
6556    pub thread_id: String,
6557    #[serde(rename = "turnId", default)]
6558    pub turn_id: String,
6559}
6560
6561#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6562#[serde(rename_all = "camelCase")]
6563pub struct ToolRequestUserInputQuestion {
6564    #[serde(default)]
6565    pub header: String,
6566    #[serde(default)]
6567    pub id: String,
6568    #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
6569    pub is_other: Option<bool>,
6570    #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
6571    pub is_secret: Option<bool>,
6572    #[serde(default, skip_serializing_if = "Option::is_none")]
6573    pub options: Option<Vec<ToolRequestUserInputOption>>,
6574    #[serde(default)]
6575    pub question: String,
6576}
6577
6578#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6579#[serde(rename_all = "camelCase")]
6580pub struct ToolRequestUserInputResponse {
6581    #[serde(default)]
6582    pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
6583}
6584
6585#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6586#[serde(rename_all = "camelCase")]
6587pub struct ToolsV2 {
6588    #[serde(default, skip_serializing_if = "Option::is_none")]
6589    pub web_search: Option<WebSearchToolConfig>,
6590}
6591
6592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6593#[serde(rename_all = "camelCase")]
6594pub struct Turn {
6595    #[serde(
6596        rename = "completedAt",
6597        default,
6598        skip_serializing_if = "Option::is_none"
6599    )]
6600    pub completed_at: Option<i64>,
6601    #[serde(
6602        rename = "durationMs",
6603        default,
6604        skip_serializing_if = "Option::is_none"
6605    )]
6606    pub duration_ms: Option<i64>,
6607    #[serde(default, skip_serializing_if = "Option::is_none")]
6608    pub error: Option<TurnError>,
6609    #[serde(default)]
6610    pub id: String,
6611    #[serde(default)]
6612    pub items: Vec<ThreadItem>,
6613    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
6614    pub items_view: Option<Value>,
6615    #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
6616    pub started_at: Option<i64>,
6617    #[serde()]
6618    pub status: TurnStatus,
6619}
6620
6621#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6622#[serde(rename_all = "camelCase")]
6623pub struct TurnCompletedNotification {
6624    #[serde(rename = "threadId", default)]
6625    pub thread_id: String,
6626    #[serde()]
6627    pub turn: Turn,
6628}
6629
6630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6631#[serde(rename_all = "camelCase")]
6632pub struct TurnDiffUpdatedNotification {
6633    #[serde(default)]
6634    pub diff: String,
6635    #[serde(rename = "threadId", default)]
6636    pub thread_id: String,
6637    #[serde(rename = "turnId", default)]
6638    pub turn_id: String,
6639}
6640
6641#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6642#[serde(rename_all = "camelCase")]
6643pub struct TurnError {
6644    #[serde(
6645        rename = "additionalDetails",
6646        default,
6647        skip_serializing_if = "Option::is_none"
6648    )]
6649    pub additional_details: Option<String>,
6650    #[serde(
6651        rename = "codexErrorInfo",
6652        default,
6653        skip_serializing_if = "Option::is_none"
6654    )]
6655    pub codex_error_info: Option<CodexErrorInfo>,
6656    #[serde(default)]
6657    pub message: String,
6658}
6659
6660#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6661#[serde(rename_all = "camelCase")]
6662pub struct TurnInterruptParams {
6663    #[serde(rename = "threadId", default)]
6664    pub thread_id: String,
6665    #[serde(rename = "turnId", default)]
6666    pub turn_id: String,
6667}
6668
6669#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6670#[serde(rename_all = "camelCase")]
6671pub struct TurnInterruptResponse {
6672    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6673    pub extra: serde_json::Map<String, Value>,
6674}
6675
6676#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6677pub enum TurnItemsView {
6678    #[serde(rename = "notLoaded")]
6679    NotLoaded,
6680    #[serde(rename = "summary")]
6681    Summary,
6682    #[serde(rename = "full")]
6683    Full,
6684}
6685
6686#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6687#[serde(rename_all = "camelCase")]
6688pub struct TurnModerationMetadataNotification {
6689    #[serde(default)]
6690    pub metadata: Value,
6691    #[serde(rename = "threadId", default)]
6692    pub thread_id: String,
6693    #[serde(rename = "turnId", default)]
6694    pub turn_id: String,
6695}
6696
6697#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6698#[serde(rename_all = "camelCase")]
6699pub struct TurnPlanStep {
6700    #[serde()]
6701    pub status: TurnPlanStepStatus,
6702    #[serde(default)]
6703    pub step: String,
6704}
6705
6706#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6707pub enum TurnPlanStepStatus {
6708    #[serde(rename = "pending")]
6709    Pending,
6710    #[serde(rename = "inProgress")]
6711    InProgress,
6712    #[serde(rename = "completed")]
6713    Completed,
6714}
6715
6716#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6717#[serde(rename_all = "camelCase")]
6718pub struct TurnPlanUpdatedNotification {
6719    #[serde(default, skip_serializing_if = "Option::is_none")]
6720    pub explanation: Option<String>,
6721    #[serde(default)]
6722    pub plan: Vec<TurnPlanStep>,
6723    #[serde(rename = "threadId", default)]
6724    pub thread_id: String,
6725    #[serde(rename = "turnId", default)]
6726    pub turn_id: String,
6727}
6728
6729#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6730#[serde(rename_all = "camelCase")]
6731pub struct TurnStartParams {
6732    #[serde(
6733        rename = "approvalPolicy",
6734        default,
6735        skip_serializing_if = "Option::is_none"
6736    )]
6737    pub approval_policy: Option<AskForApproval>,
6738    #[serde(
6739        rename = "approvalsReviewer",
6740        default,
6741        skip_serializing_if = "Option::is_none"
6742    )]
6743    pub approvals_reviewer: Option<ApprovalsReviewer>,
6744    #[serde(
6745        rename = "clientUserMessageId",
6746        default,
6747        skip_serializing_if = "Option::is_none"
6748    )]
6749    pub client_user_message_id: Option<String>,
6750    #[serde(default, skip_serializing_if = "Option::is_none")]
6751    pub cwd: Option<String>,
6752    #[serde(default, skip_serializing_if = "Option::is_none")]
6753    pub effort: Option<ReasoningEffort>,
6754    #[serde(default)]
6755    pub input: Vec<UserInput>,
6756    #[serde(default, skip_serializing_if = "Option::is_none")]
6757    pub model: Option<String>,
6758    #[serde(
6759        rename = "outputSchema",
6760        default,
6761        skip_serializing_if = "Option::is_none"
6762    )]
6763    pub output_schema: Option<Value>,
6764    #[serde(default, skip_serializing_if = "Option::is_none")]
6765    pub personality: Option<Personality>,
6766    #[serde(
6767        rename = "sandboxPolicy",
6768        default,
6769        skip_serializing_if = "Option::is_none"
6770    )]
6771    pub sandbox_policy: Option<SandboxPolicy>,
6772    #[serde(
6773        rename = "serviceTier",
6774        default,
6775        skip_serializing_if = "Option::is_none"
6776    )]
6777    pub service_tier: Option<String>,
6778    #[serde(default, skip_serializing_if = "Option::is_none")]
6779    pub summary: Option<ReasoningSummary>,
6780    #[serde(rename = "threadId", default)]
6781    pub thread_id: String,
6782}
6783
6784#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6785#[serde(rename_all = "camelCase")]
6786pub struct TurnStartResponse {
6787    #[serde()]
6788    pub turn: Turn,
6789}
6790
6791#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6792#[serde(rename_all = "camelCase")]
6793pub struct TurnStartedNotification {
6794    #[serde(rename = "threadId", default)]
6795    pub thread_id: String,
6796    #[serde()]
6797    pub turn: Turn,
6798}
6799
6800#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6801pub enum TurnStatus {
6802    #[serde(rename = "completed")]
6803    Completed,
6804    #[serde(rename = "interrupted")]
6805    Interrupted,
6806    #[serde(rename = "failed")]
6807    Failed,
6808    #[serde(rename = "inProgress")]
6809    InProgress,
6810}
6811
6812#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6813#[serde(rename_all = "camelCase")]
6814pub struct TurnSteerParams {
6815    #[serde(
6816        rename = "clientUserMessageId",
6817        default,
6818        skip_serializing_if = "Option::is_none"
6819    )]
6820    pub client_user_message_id: Option<String>,
6821    #[serde(rename = "expectedTurnId", default)]
6822    pub expected_turn_id: String,
6823    #[serde(default)]
6824    pub input: Vec<UserInput>,
6825    #[serde(rename = "threadId", default)]
6826    pub thread_id: String,
6827}
6828
6829#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6830#[serde(rename_all = "camelCase")]
6831pub struct TurnSteerResponse {
6832    #[serde(rename = "turnId", default)]
6833    pub turn_id: String,
6834}
6835
6836#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6837#[serde(tag = "type", rename_all = "camelCase")]
6838pub enum UserInput {
6839    Text {
6840        text: String,
6841        #[serde(default, skip_serializing_if = "Option::is_none")]
6842        text_elements: Option<Vec<TextElement>>,
6843    },
6844    Image {
6845        #[serde(default, skip_serializing_if = "Option::is_none")]
6846        detail: Option<ImageDetail>,
6847        url: String,
6848    },
6849    #[serde(rename = "localImage")]
6850    LocalImage {
6851        #[serde(default, skip_serializing_if = "Option::is_none")]
6852        detail: Option<ImageDetail>,
6853        path: String,
6854    },
6855    Skill {
6856        name: String,
6857        path: String,
6858    },
6859    Mention {
6860        name: String,
6861        path: String,
6862    },
6863}
6864
6865#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6866pub enum Verbosity {
6867    #[serde(rename = "low")]
6868    Low,
6869    #[serde(rename = "medium")]
6870    Medium,
6871    #[serde(rename = "high")]
6872    High,
6873}
6874
6875#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6876#[serde(rename_all = "camelCase")]
6877pub struct WarningNotification {
6878    #[serde(default)]
6879    pub message: String,
6880    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
6881    pub thread_id: Option<String>,
6882}
6883
6884#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6885#[serde(tag = "type", rename_all = "camelCase")]
6886pub enum WebSearchAction {
6887    Search {
6888        #[serde(default, skip_serializing_if = "Option::is_none")]
6889        queries: Option<Vec<String>>,
6890        #[serde(default, skip_serializing_if = "Option::is_none")]
6891        query: Option<String>,
6892    },
6893    #[serde(rename = "openPage")]
6894    OpenPage {
6895        #[serde(default, skip_serializing_if = "Option::is_none")]
6896        url: Option<String>,
6897    },
6898    #[serde(rename = "findInPage")]
6899    FindInPage {
6900        #[serde(default, skip_serializing_if = "Option::is_none")]
6901        pattern: Option<String>,
6902        #[serde(default, skip_serializing_if = "Option::is_none")]
6903        url: Option<String>,
6904    },
6905    Other,
6906}
6907
6908#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6909pub enum WebSearchContextSize {
6910    #[serde(rename = "low")]
6911    Low,
6912    #[serde(rename = "medium")]
6913    Medium,
6914    #[serde(rename = "high")]
6915    High,
6916}
6917
6918#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6919#[serde(rename_all = "camelCase")]
6920pub struct WebSearchLocation {
6921    #[serde(default, skip_serializing_if = "Option::is_none")]
6922    pub city: Option<String>,
6923    #[serde(default, skip_serializing_if = "Option::is_none")]
6924    pub country: Option<String>,
6925    #[serde(default, skip_serializing_if = "Option::is_none")]
6926    pub region: Option<String>,
6927    #[serde(default, skip_serializing_if = "Option::is_none")]
6928    pub timezone: Option<String>,
6929}
6930
6931#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6932pub enum WebSearchMode {
6933    #[serde(rename = "disabled")]
6934    Disabled,
6935    #[serde(rename = "cached")]
6936    Cached,
6937    #[serde(rename = "live")]
6938    Live,
6939}
6940
6941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6942#[serde(rename_all = "camelCase")]
6943pub struct WebSearchToolConfig {
6944    #[serde(default, skip_serializing_if = "Option::is_none")]
6945    pub allowed_domains: Option<Vec<String>>,
6946    #[serde(default, skip_serializing_if = "Option::is_none")]
6947    pub context_size: Option<WebSearchContextSize>,
6948    #[serde(default, skip_serializing_if = "Option::is_none")]
6949    pub location: Option<WebSearchLocation>,
6950}
6951
6952#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6953pub enum WindowsSandboxReadiness {
6954    #[serde(rename = "ready")]
6955    Ready,
6956    #[serde(rename = "notConfigured")]
6957    NotConfigured,
6958    #[serde(rename = "updateRequired")]
6959    UpdateRequired,
6960}
6961
6962#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6963#[serde(rename_all = "camelCase")]
6964pub struct WindowsSandboxReadinessResponse {
6965    #[serde()]
6966    pub status: WindowsSandboxReadiness,
6967}
6968
6969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6970#[serde(rename_all = "camelCase")]
6971pub struct WindowsSandboxSetupCompletedNotification {
6972    #[serde(default, skip_serializing_if = "Option::is_none")]
6973    pub error: Option<String>,
6974    #[serde()]
6975    pub mode: WindowsSandboxSetupMode,
6976    #[serde(default)]
6977    pub success: bool,
6978}
6979
6980#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6981pub enum WindowsSandboxSetupMode {
6982    #[serde(rename = "elevated")]
6983    Elevated,
6984    #[serde(rename = "unelevated")]
6985    Unelevated,
6986}
6987
6988#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6989#[serde(rename_all = "camelCase")]
6990pub struct WindowsSandboxSetupStartParams {
6991    #[serde(default, skip_serializing_if = "Option::is_none")]
6992    pub cwd: Option<AbsolutePathBuf>,
6993    #[serde()]
6994    pub mode: WindowsSandboxSetupMode,
6995}
6996
6997#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6998#[serde(rename_all = "camelCase")]
6999pub struct WindowsSandboxSetupStartResponse {
7000    #[serde(default)]
7001    pub started: bool,
7002}
7003
7004#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7005#[serde(rename_all = "camelCase")]
7006pub struct WindowsWorldWritableWarningNotification {
7007    #[serde(rename = "extraCount", default)]
7008    pub extra_count: i64,
7009    #[serde(rename = "failedScan", default)]
7010    pub failed_scan: bool,
7011    #[serde(rename = "samplePaths", default)]
7012    pub sample_paths: Vec<String>,
7013}
7014
7015#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7016pub enum WriteStatus {
7017    #[serde(rename = "ok")]
7018    Ok,
7019    #[serde(rename = "okOverridden")]
7020    OkOverridden,
7021}