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