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

codex_codes/protocol_generated/
types.rs
