Skip to main content

codex_codes/protocol_generated/
types.rs

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