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