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

codex_codes/protocol_generated/
types.rs
