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