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