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