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