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/// Usage-read capabilities of the requesting client, never inferred from its
2684/// experiment arm. Both flags are omitted from the wire when `false`, so the
2685/// default value serializes as `{}`.
2686#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
2687#[serde(rename_all = "camelCase")]
2688pub struct GetAccountRateLimitsParams {
2689    /// Skip the separate reset-credit detail lookup for background usage
2690    /// polls. The usage response still includes the available count;
2691    /// omitted/false preserves detailed reads.
2692    #[serde(
2693        rename = "excludeResetCreditDetails",
2694        default,
2695        skip_serializing_if = "std::ops::Not::not"
2696    )]
2697    pub exclude_reset_credit_details: bool,
2698    /// The client supports automatic Luna Reserve fallback. For eligible
2699    /// ChatGPT CLI users, allow the backend to record experiment exposure
2700    /// after ordinary usage is blocked.
2701    #[serde(
2702        rename = "supportsLunaReserve",
2703        default,
2704        skip_serializing_if = "std::ops::Not::not"
2705    )]
2706    pub supports_luna_reserve: bool,
2707}
2708
2709#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2710#[serde(rename_all = "camelCase")]
2711pub struct GetAccountRateLimitsResponse {
2712    #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
2713    pub account_id: Option<String>,
2714    /// Backend permission for ordinary included usage, validated against the
2715    /// active account. `None` means unavailable; clients must not infer
2716    /// recovery from percentages or reset times.
2717    #[serde(
2718        rename = "ordinaryUsageAllowed",
2719        default,
2720        skip_serializing_if = "Option::is_none"
2721    )]
2722    pub ordinary_usage_allowed: Option<bool>,
2723    #[serde(
2724        rename = "rateLimitResetCredits",
2725        default,
2726        skip_serializing_if = "Option::is_none"
2727    )]
2728    pub rate_limit_reset_credits: Option<RateLimitResetCreditsSummary>,
2729    #[serde(
2730        rename = "rateLimitUpsell",
2731        default,
2732        skip_serializing_if = "Option::is_none"
2733    )]
2734    pub rate_limit_upsell: Option<Value>,
2735    #[serde(rename = "rateLimits", default)]
2736    pub rate_limits: Value,
2737    #[serde(
2738        rename = "rateLimitsByLimitId",
2739        default,
2740        skip_serializing_if = "Option::is_none"
2741    )]
2742    pub rate_limits_by_limit_id: Option<std::collections::BTreeMap<String, RateLimitSnapshot>>,
2743}
2744
2745#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2746#[serde(rename_all = "camelCase")]
2747pub struct GetAccountResponse {
2748    #[serde(default, skip_serializing_if = "Option::is_none")]
2749    pub account: Option<Account>,
2750    #[serde(rename = "requiresOpenaiAuth", default)]
2751    pub requires_openai_auth: bool,
2752}
2753
2754#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2755#[serde(rename_all = "camelCase")]
2756pub struct GetAccountTokenUsageResponse {
2757    #[serde(
2758        rename = "dailyUsageBuckets",
2759        default,
2760        skip_serializing_if = "Option::is_none"
2761    )]
2762    pub daily_usage_buckets: Option<Vec<AccountTokenUsageDailyBucket>>,
2763    #[serde()]
2764    pub summary: AccountTokenUsageSummary,
2765    #[serde(
2766        rename = "threadUsage",
2767        default,
2768        skip_serializing_if = "Option::is_none"
2769    )]
2770    pub thread_usage: Option<ThreadUsage>,
2771}
2772
2773#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2774#[serde(rename_all = "camelCase")]
2775pub struct GetAccountTokenUsageParams {
2776    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
2777    pub thread_id: Option<String>,
2778}
2779
2780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2781#[serde(rename_all = "camelCase")]
2782pub struct ThreadUsage {
2783    #[serde(rename = "estimatedUsageCreditsMicros", default)]
2784    pub estimated_usage_credits_micros: i64,
2785    #[serde(
2786        rename = "estimatedUsageUsdMicros",
2787        default,
2788        skip_serializing_if = "Option::is_none"
2789    )]
2790    pub estimated_usage_usd_micros: Option<i64>,
2791    #[serde(default)]
2792    pub groups: Vec<ThreadUsageBreakdownGroup>,
2793    #[serde(rename = "threadId", default)]
2794    pub thread_id: String,
2795}
2796
2797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2798#[serde(rename_all = "camelCase")]
2799pub struct ThreadUsageBreakdownGroup {
2800    #[serde(
2801        rename = "cachedInputTokens",
2802        default,
2803        skip_serializing_if = "Option::is_none"
2804    )]
2805    pub cached_input_tokens: Option<i64>,
2806    #[serde(rename = "estimatedUsageCreditsMicros", default)]
2807    pub estimated_usage_credits_micros: i64,
2808    #[serde(
2809        rename = "inputTokens",
2810        default,
2811        skip_serializing_if = "Option::is_none"
2812    )]
2813    pub input_tokens: Option<i64>,
2814    #[serde(default, skip_serializing_if = "Option::is_none")]
2815    pub model: Option<String>,
2816    #[serde(
2817        rename = "netNewInputTokens",
2818        default,
2819        skip_serializing_if = "Option::is_none"
2820    )]
2821    pub net_new_input_tokens: Option<i64>,
2822    #[serde(
2823        rename = "outputTokens",
2824        default,
2825        skip_serializing_if = "Option::is_none"
2826    )]
2827    pub output_tokens: Option<i64>,
2828    #[serde(
2829        rename = "reasoningEffort",
2830        default,
2831        skip_serializing_if = "Option::is_none"
2832    )]
2833    pub reasoning_effort: Option<String>,
2834    #[serde(default, skip_serializing_if = "Option::is_none")]
2835    pub speed: Option<String>,
2836    #[serde(
2837        rename = "totalTokens",
2838        default,
2839        skip_serializing_if = "Option::is_none"
2840    )]
2841    pub total_tokens: Option<i64>,
2842}
2843
2844#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2845#[serde(tag = "type", rename_all = "camelCase")]
2846pub enum ImageGenerationFailure {
2847    #[serde(rename = "usageLimitExceeded")]
2848    UsageLimitExceeded {
2849        #[serde(rename = "limitId")]
2850        limit_id: String,
2851        #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
2852        resets_at: Option<i64>,
2853    },
2854}
2855
2856#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2857#[serde(rename_all = "lowercase")]
2858pub enum McpServerOauthClientRegistration {
2859    Auto,
2860    Cimd,
2861    Dcr,
2862}
2863
2864#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2865#[serde(rename_all = "camelCase")]
2866pub struct GetWorkspaceMessagesResponse {
2867    #[serde(rename = "featureEnabled", default)]
2868    pub feature_enabled: bool,
2869    #[serde(default)]
2870    pub messages: Vec<WorkspaceMessage>,
2871}
2872
2873#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2874#[serde(rename_all = "camelCase")]
2875pub struct GitInfo {
2876    #[serde(default, skip_serializing_if = "Option::is_none")]
2877    pub branch: Option<String>,
2878    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
2879    pub origin_url: Option<String>,
2880    #[serde(default, skip_serializing_if = "Option::is_none")]
2881    pub sha: Option<String>,
2882}
2883
2884#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2885#[serde(rename_all = "camelCase")]
2886pub struct GrantedPermissionProfile {
2887    #[serde(
2888        rename = "fileSystem",
2889        default,
2890        skip_serializing_if = "Option::is_none"
2891    )]
2892    pub file_system: Option<AdditionalFileSystemPermissions>,
2893    #[serde(default, skip_serializing_if = "Option::is_none")]
2894    pub network: Option<AdditionalNetworkPermissions>,
2895}
2896
2897#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2898#[serde(rename_all = "camelCase")]
2899pub struct GuardianApprovalReview {
2900    #[serde(default, skip_serializing_if = "Option::is_none")]
2901    pub rationale: Option<String>,
2902    #[serde(rename = "riskLevel", default, skip_serializing_if = "Option::is_none")]
2903    pub risk_level: Option<GuardianRiskLevel>,
2904    #[serde()]
2905    pub status: GuardianApprovalReviewStatus,
2906    #[serde(
2907        rename = "userAuthorization",
2908        default,
2909        skip_serializing_if = "Option::is_none"
2910    )]
2911    pub user_authorization: Option<GuardianUserAuthorization>,
2912}
2913
2914#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2915#[serde(tag = "type", rename_all = "camelCase")]
2916pub enum GuardianApprovalReviewAction {
2917    Command {
2918        command: String,
2919        cwd: AbsolutePathBuf,
2920        source: GuardianCommandSource,
2921    },
2922    Execve {
2923        argv: Vec<String>,
2924        cwd: AbsolutePathBuf,
2925        program: String,
2926        source: GuardianCommandSource,
2927    },
2928    #[serde(rename = "writeStdin")]
2929    WriteStdin {
2930        #[serde(rename = "approvalId")]
2931        approval_id: String,
2932        cwd: LegacyAppPathString,
2933        #[serde(rename = "processId")]
2934        process_id: String,
2935        stdin: String,
2936    },
2937    #[serde(rename = "applyPatch")]
2938    ApplyPatch {
2939        cwd: AbsolutePathBuf,
2940        files: Vec<AbsolutePathBuf>,
2941    },
2942    #[serde(rename = "networkAccess")]
2943    NetworkAccess {
2944        host: String,
2945        port: i64,
2946        protocol: NetworkApprovalProtocol,
2947        target: String,
2948    },
2949    #[serde(rename = "mcpToolCall")]
2950    McpToolCall {
2951        #[serde(
2952            rename = "connectorId",
2953            default,
2954            skip_serializing_if = "Option::is_none"
2955        )]
2956        connector_id: Option<String>,
2957        #[serde(
2958            rename = "connectorName",
2959            default,
2960            skip_serializing_if = "Option::is_none"
2961        )]
2962        connector_name: Option<String>,
2963        server: String,
2964        #[serde(rename = "toolName")]
2965        tool_name: String,
2966        #[serde(rename = "toolTitle", default, skip_serializing_if = "Option::is_none")]
2967        tool_title: Option<String>,
2968    },
2969    #[serde(rename = "requestPermissions")]
2970    RequestPermissions {
2971        permissions: RequestPermissionProfile,
2972        #[serde(default, skip_serializing_if = "Option::is_none")]
2973        reason: Option<String>,
2974    },
2975}
2976
2977#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2978pub enum GuardianApprovalReviewStatus {
2979    #[serde(rename = "inProgress")]
2980    InProgress,
2981    #[serde(rename = "approved")]
2982    Approved,
2983    #[serde(rename = "denied")]
2984    Denied,
2985    #[serde(rename = "timedOut")]
2986    TimedOut,
2987    #[serde(rename = "aborted")]
2988    Aborted,
2989}
2990
2991#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2992pub enum GuardianCommandSource {
2993    #[serde(rename = "shell")]
2994    Shell,
2995    #[serde(rename = "unifiedExec")]
2996    UnifiedExec,
2997}
2998
2999#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3000pub enum GuardianRiskLevel {
3001    #[serde(rename = "low")]
3002    Low,
3003    #[serde(rename = "medium")]
3004    Medium,
3005    #[serde(rename = "high")]
3006    High,
3007    #[serde(rename = "critical")]
3008    Critical,
3009}
3010
3011#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3012pub enum GuardianUserAuthorization {
3013    #[serde(rename = "unknown")]
3014    Unknown,
3015    #[serde(rename = "low")]
3016    Low,
3017    #[serde(rename = "medium")]
3018    Medium,
3019    #[serde(rename = "high")]
3020    High,
3021}
3022
3023#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3024#[serde(rename_all = "camelCase")]
3025pub struct GuardianWarningNotification {
3026    #[serde(default)]
3027    pub message: String,
3028    #[serde(rename = "threadId", default)]
3029    pub thread_id: String,
3030}
3031
3032#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3033#[serde(rename_all = "camelCase")]
3034pub struct HookCompletedNotification {
3035    #[serde()]
3036    pub run: HookRunSummary,
3037    #[serde(rename = "threadId", default)]
3038    pub thread_id: String,
3039    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
3040    pub turn_id: Option<String>,
3041}
3042
3043#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3044#[serde(rename_all = "camelCase")]
3045pub struct HookErrorInfo {
3046    #[serde(default)]
3047    pub message: String,
3048    #[serde(default)]
3049    pub path: String,
3050}
3051
3052#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3053pub enum HookEventName {
3054    #[serde(rename = "preToolUse")]
3055    PreToolUse,
3056    #[serde(rename = "permissionRequest")]
3057    PermissionRequest,
3058    #[serde(rename = "postToolUse")]
3059    PostToolUse,
3060    #[serde(rename = "preCompact")]
3061    PreCompact,
3062    #[serde(rename = "postCompact")]
3063    PostCompact,
3064    #[serde(rename = "sessionStart")]
3065    SessionStart,
3066    #[serde(rename = "sessionEnd")]
3067    SessionEnd,
3068    #[serde(rename = "userPromptSubmit")]
3069    UserPromptSubmit,
3070    #[serde(rename = "subagentStart")]
3071    SubagentStart,
3072    #[serde(rename = "subagentStop")]
3073    SubagentStop,
3074    #[serde(rename = "stop")]
3075    Stop,
3076    #[serde(rename = "interrupt")]
3077    Interrupt,
3078}
3079
3080#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3081pub enum HookExecutionMode {
3082    #[serde(rename = "sync")]
3083    Sync,
3084    #[serde(rename = "async")]
3085    Async,
3086}
3087
3088#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3089pub enum HookHandlerType {
3090    #[serde(rename = "command")]
3091    Command,
3092    #[serde(rename = "mcpTool")]
3093    McpTool,
3094    #[serde(rename = "prompt")]
3095    Prompt,
3096    #[serde(rename = "agent")]
3097    Agent,
3098}
3099
3100#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3101#[serde(rename_all = "camelCase")]
3102pub struct HookMetadata {
3103    #[serde(
3104        rename = "additionalContextLimit",
3105        default,
3106        skip_serializing_if = "Option::is_none"
3107    )]
3108    pub additional_context_limit: Option<i64>,
3109    #[serde(rename = "async", default, skip_serializing_if = "Option::is_none")]
3110    pub is_async: Option<bool>,
3111    #[serde(default, skip_serializing_if = "Option::is_none")]
3112    pub command: Option<String>,
3113    #[serde(rename = "currentHash", default)]
3114    pub current_hash: String,
3115    /// MCP server name (`handlerType: "mcpTool"` hooks).
3116    #[serde(default, skip_serializing_if = "Option::is_none")]
3117    pub server: Option<String>,
3118    /// MCP tool name (`handlerType: "mcpTool"` hooks).
3119    #[serde(default, skip_serializing_if = "Option::is_none")]
3120    pub tool: Option<String>,
3121    #[serde(rename = "displayOrder", default)]
3122    pub display_order: i64,
3123    #[serde(default)]
3124    pub enabled: bool,
3125    #[serde(rename = "eventName")]
3126    pub event_name: HookEventName,
3127    #[serde(
3128        rename = "executionMode",
3129        default,
3130        skip_serializing_if = "Option::is_none"
3131    )]
3132    pub execution_mode: Option<Value>,
3133    #[serde(rename = "handlerType")]
3134    pub handler_type: HookHandlerType,
3135    #[serde(rename = "isManaged", default)]
3136    pub is_managed: bool,
3137    #[serde(default)]
3138    pub key: String,
3139    #[serde(default, skip_serializing_if = "Option::is_none")]
3140    pub matcher: Option<String>,
3141    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
3142    pub plugin_id: Option<String>,
3143    #[serde()]
3144    pub source: HookSource,
3145    #[serde(rename = "sourcePath")]
3146    pub source_path: AbsolutePathBuf,
3147    #[serde(
3148        rename = "statusMessage",
3149        default,
3150        skip_serializing_if = "Option::is_none"
3151    )]
3152    pub status_message: Option<String>,
3153    #[serde(rename = "timeoutSec", default)]
3154    pub timeout_sec: i64,
3155    #[serde(rename = "trustStatus")]
3156    pub trust_status: HookTrustStatus,
3157}
3158
3159#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3160#[serde(rename_all = "camelCase")]
3161pub struct HookMigration {
3162    #[serde(default)]
3163    pub name: String,
3164}
3165
3166#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3167#[serde(rename_all = "camelCase")]
3168pub struct HookOutputEntry {
3169    #[serde()]
3170    pub kind: HookOutputEntryKind,
3171    #[serde(default)]
3172    pub text: String,
3173}
3174
3175#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3176pub enum HookOutputEntryKind {
3177    #[serde(rename = "warning")]
3178    Warning,
3179    #[serde(rename = "stop")]
3180    Stop,
3181    #[serde(rename = "feedback")]
3182    Feedback,
3183    #[serde(rename = "context")]
3184    Context,
3185    #[serde(rename = "error")]
3186    Error,
3187}
3188
3189#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3190#[serde(rename_all = "camelCase")]
3191pub struct HookPromptFragment {
3192    #[serde(rename = "hookRunId", default)]
3193    pub hook_run_id: String,
3194    #[serde(default)]
3195    pub text: String,
3196}
3197
3198#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3199pub enum HookRunStatus {
3200    #[serde(rename = "running")]
3201    Running,
3202    #[serde(rename = "completed")]
3203    Completed,
3204    #[serde(rename = "failed")]
3205    Failed,
3206    #[serde(rename = "blocked")]
3207    Blocked,
3208    #[serde(rename = "stopped")]
3209    Stopped,
3210}
3211
3212#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3213#[serde(rename_all = "camelCase")]
3214pub struct HookRunSummary {
3215    #[serde(
3216        rename = "completedAt",
3217        default,
3218        skip_serializing_if = "Option::is_none"
3219    )]
3220    pub completed_at: Option<i64>,
3221    #[serde(rename = "displayOrder", default)]
3222    pub display_order: i64,
3223    #[serde(
3224        rename = "durationMs",
3225        default,
3226        skip_serializing_if = "Option::is_none"
3227    )]
3228    pub duration_ms: Option<i64>,
3229    #[serde(default)]
3230    pub entries: Vec<HookOutputEntry>,
3231    #[serde(rename = "eventName")]
3232    pub event_name: HookEventName,
3233    #[serde(rename = "executionMode")]
3234    pub execution_mode: HookExecutionMode,
3235    #[serde(rename = "handlerType")]
3236    pub handler_type: HookHandlerType,
3237    #[serde(default)]
3238    pub id: String,
3239    #[serde()]
3240    pub scope: HookScope,
3241    #[serde(default, skip_serializing_if = "Option::is_none")]
3242    pub source: Option<Value>,
3243    #[serde(rename = "sourcePath")]
3244    pub source_path: AbsolutePathBuf,
3245    #[serde(rename = "startedAt", default)]
3246    pub started_at: i64,
3247    #[serde()]
3248    pub status: HookRunStatus,
3249    #[serde(
3250        rename = "statusMessage",
3251        default,
3252        skip_serializing_if = "Option::is_none"
3253    )]
3254    pub status_message: Option<String>,
3255}
3256
3257#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3258pub enum HookScope {
3259    #[serde(rename = "thread")]
3260    Thread,
3261    #[serde(rename = "turn")]
3262    Turn,
3263}
3264
3265#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3266pub enum HookSource {
3267    #[serde(rename = "system")]
3268    System,
3269    #[serde(rename = "user")]
3270    User,
3271    #[serde(rename = "project")]
3272    Project,
3273    #[serde(rename = "mdm")]
3274    Mdm,
3275    #[serde(rename = "sessionFlags")]
3276    SessionFlags,
3277    #[serde(rename = "plugin")]
3278    Plugin,
3279    #[serde(rename = "cloudRequirements")]
3280    CloudRequirements,
3281    #[serde(rename = "cloudManagedConfig")]
3282    CloudManagedConfig,
3283    #[serde(rename = "legacyManagedConfigFile")]
3284    LegacyManagedConfigFile,
3285    #[serde(rename = "legacyManagedConfigMdm")]
3286    LegacyManagedConfigMdm,
3287    #[serde(rename = "unknown")]
3288    Unknown,
3289}
3290
3291#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3292#[serde(rename_all = "camelCase")]
3293pub struct HookStartedNotification {
3294    #[serde()]
3295    pub run: HookRunSummary,
3296    #[serde(rename = "threadId", default)]
3297    pub thread_id: String,
3298    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
3299    pub turn_id: Option<String>,
3300}
3301
3302#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3303pub enum HookTrustStatus {
3304    #[serde(rename = "managed")]
3305    Managed,
3306    #[serde(rename = "untrusted")]
3307    Untrusted,
3308    #[serde(rename = "trusted")]
3309    Trusted,
3310    #[serde(rename = "modified")]
3311    Modified,
3312}
3313
3314#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3315#[serde(rename_all = "camelCase")]
3316pub struct HooksListEntry {
3317    #[serde(default)]
3318    pub cwd: String,
3319    #[serde(default)]
3320    pub errors: Vec<HookErrorInfo>,
3321    #[serde(default)]
3322    pub hooks: Vec<HookMetadata>,
3323    #[serde(default)]
3324    pub warnings: Vec<String>,
3325}
3326
3327#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3328#[serde(rename_all = "camelCase")]
3329pub struct HooksListParams {
3330    #[serde(default, skip_serializing_if = "Option::is_none")]
3331    pub cwds: Option<Vec<String>>,
3332}
3333
3334#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3335#[serde(rename_all = "camelCase")]
3336pub struct HooksListResponse {
3337    #[serde(default)]
3338    pub data: Vec<HooksListEntry>,
3339}
3340
3341#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3342pub enum ImageDetail {
3343    #[serde(rename = "auto")]
3344    Auto,
3345    #[serde(rename = "low")]
3346    Low,
3347    #[serde(rename = "high")]
3348    High,
3349    #[serde(rename = "original")]
3350    Original,
3351}
3352
3353#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3354#[serde(rename_all = "camelCase")]
3355pub struct InitializeCapabilities {
3356    #[serde(
3357        rename = "experimentalApi",
3358        default,
3359        skip_serializing_if = "Option::is_none"
3360    )]
3361    pub experimental_api: Option<bool>,
3362    #[serde(default, skip_serializing_if = "Option::is_none")]
3363    pub extensions: Option<Value>,
3364    #[serde(
3365        rename = "mcpServerOpenaiFormElicitation",
3366        default,
3367        skip_serializing_if = "Option::is_none"
3368    )]
3369    pub mcp_server_openai_form_elicitation: Option<bool>,
3370    #[serde(
3371        rename = "optOutNotificationMethods",
3372        default,
3373        skip_serializing_if = "Option::is_none"
3374    )]
3375    pub opt_out_notification_methods: Option<Vec<String>>,
3376    #[serde(
3377        rename = "requestAttestation",
3378        default,
3379        skip_serializing_if = "Option::is_none"
3380    )]
3381    pub request_attestation: Option<bool>,
3382}
3383
3384#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3385#[serde(rename_all = "camelCase")]
3386pub struct InitializeParams {
3387    #[serde(default, skip_serializing_if = "Option::is_none")]
3388    pub capabilities: Option<InitializeCapabilities>,
3389    #[serde(rename = "clientInfo")]
3390    pub client_info: ClientInfo,
3391}
3392
3393#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3394#[serde(rename_all = "camelCase")]
3395pub struct InitializeResponse {
3396    #[serde(rename = "codexHome", default)]
3397    pub codex_home: Value,
3398    #[serde(rename = "platformFamily", default)]
3399    pub platform_family: String,
3400    #[serde(rename = "platformOs", default)]
3401    pub platform_os: String,
3402    #[serde(rename = "userAgent", default)]
3403    pub user_agent: String,
3404}
3405
3406#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
3407pub enum InputModality {
3408    #[serde(rename = "text")]
3409    Text,
3410    #[serde(rename = "image")]
3411    Image,
3412    #[serde(rename = "audio")]
3413    Audio,
3414}
3415
3416#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3417#[serde(rename_all = "camelCase")]
3418pub struct InstalledApp {
3419    #[serde(default)]
3420    pub callable: bool,
3421    #[serde(default)]
3422    pub enabled: bool,
3423    #[serde(default)]
3424    pub id: String,
3425    #[serde(
3426        rename = "runtimeName",
3427        default,
3428        skip_serializing_if = "Option::is_none"
3429    )]
3430    pub runtime_name: Option<String>,
3431}
3432
3433#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3434#[serde(rename_all = "camelCase")]
3435pub struct ItemCompletedNotification {
3436    #[serde(rename = "completedAtMs", default)]
3437    pub completed_at_ms: i64,
3438    #[serde()]
3439    pub item: ThreadItem,
3440    #[serde(rename = "threadId", default)]
3441    pub thread_id: String,
3442    #[serde(rename = "turnId", default)]
3443    pub turn_id: String,
3444}
3445
3446#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3447#[serde(rename_all = "camelCase")]
3448pub struct ItemGuardianApprovalReviewCompletedNotification {
3449    #[serde()]
3450    pub action: GuardianApprovalReviewAction,
3451    #[serde(rename = "completedAtMs", default)]
3452    pub completed_at_ms: i64,
3453    #[serde(rename = "decisionSource")]
3454    pub decision_source: AutoReviewDecisionSource,
3455    #[serde()]
3456    pub review: GuardianApprovalReview,
3457    #[serde(rename = "reviewId", default)]
3458    pub review_id: String,
3459    #[serde(rename = "startedAtMs", default)]
3460    pub started_at_ms: i64,
3461    #[serde(
3462        rename = "targetItemId",
3463        default,
3464        skip_serializing_if = "Option::is_none"
3465    )]
3466    pub target_item_id: Option<String>,
3467    #[serde(rename = "threadId", default)]
3468    pub thread_id: String,
3469    #[serde(rename = "turnId", default)]
3470    pub turn_id: String,
3471}
3472
3473#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3474#[serde(rename_all = "camelCase")]
3475pub struct ItemGuardianApprovalReviewStartedNotification {
3476    #[serde()]
3477    pub action: GuardianApprovalReviewAction,
3478    #[serde()]
3479    pub review: GuardianApprovalReview,
3480    #[serde(rename = "reviewId", default)]
3481    pub review_id: String,
3482    #[serde(rename = "startedAtMs", default)]
3483    pub started_at_ms: i64,
3484    #[serde(
3485        rename = "targetItemId",
3486        default,
3487        skip_serializing_if = "Option::is_none"
3488    )]
3489    pub target_item_id: Option<String>,
3490    #[serde(rename = "threadId", default)]
3491    pub thread_id: String,
3492    #[serde(rename = "turnId", default)]
3493    pub turn_id: String,
3494}
3495
3496#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3497#[serde(rename_all = "camelCase")]
3498pub struct ItemStartedNotification {
3499    #[serde()]
3500    pub item: ThreadItem,
3501    #[serde(rename = "startedAtMs", default)]
3502    pub started_at_ms: i64,
3503    #[serde(rename = "threadId", default)]
3504    pub thread_id: String,
3505    #[serde(rename = "turnId", default)]
3506    pub turn_id: String,
3507}
3508
3509#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3510#[serde(rename_all = "camelCase")]
3511pub struct JSONRPCResponse {
3512    #[serde()]
3513    pub id: RequestId,
3514    #[serde(default)]
3515    pub result: Value,
3516}
3517
3518#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
3519#[serde(transparent)]
3520pub struct LegacyAppPathString(pub String);
3521
3522#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3523#[serde(rename_all = "camelCase")]
3524pub struct ListMcpServerStatusParams {
3525    #[serde(default, skip_serializing_if = "Option::is_none")]
3526    pub cursor: Option<String>,
3527    #[serde(default, skip_serializing_if = "Option::is_none")]
3528    pub detail: Option<McpServerStatusDetail>,
3529    #[serde(default, skip_serializing_if = "Option::is_none")]
3530    pub limit: Option<i64>,
3531    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3532    pub thread_id: Option<String>,
3533}
3534
3535#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3536#[serde(rename_all = "camelCase")]
3537pub struct ListMcpServerStatusResponse {
3538    #[serde(default)]
3539    pub data: Vec<McpServerStatus>,
3540    #[serde(
3541        rename = "nextCursor",
3542        default,
3543        skip_serializing_if = "Option::is_none"
3544    )]
3545    pub next_cursor: Option<String>,
3546}
3547
3548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3549#[serde(tag = "type", rename_all = "camelCase")]
3550pub enum LoginAccountParams {
3551    #[serde(rename = "apiKey")]
3552    ApiKey {
3553        #[serde(rename = "apiKey")]
3554        api_key: String,
3555    },
3556    Chatgpt {
3557        #[serde(rename = "appBrand", default, skip_serializing_if = "Option::is_none")]
3558        app_brand: Option<LoginAppBrand>,
3559        #[serde(
3560            rename = "codexStreamlinedLogin",
3561            default,
3562            skip_serializing_if = "Option::is_none"
3563        )]
3564        codex_streamlined_login: Option<bool>,
3565        #[serde(
3566            rename = "useHostedLoginSuccessPage",
3567            default,
3568            skip_serializing_if = "Option::is_none"
3569        )]
3570        use_hosted_login_success_page: Option<bool>,
3571    },
3572    #[serde(rename = "chatgptDeviceCode")]
3573    ChatgptDeviceCode,
3574    #[serde(rename = "chatgptAuthTokens")]
3575    ChatgptAuthTokens {
3576        #[serde(rename = "accessToken")]
3577        access_token: String,
3578        #[serde(rename = "chatgptAccountId")]
3579        chatgpt_account_id: String,
3580        #[serde(
3581            rename = "chatgptPlanType",
3582            default,
3583            skip_serializing_if = "Option::is_none"
3584        )]
3585        chatgpt_plan_type: Option<String>,
3586    },
3587    #[serde(rename = "amazonBedrock")]
3588    AmazonBedrock {
3589        #[serde(rename = "apiKey")]
3590        api_key: String,
3591        region: String,
3592    },
3593    #[serde(rename = "amazonBedrockAccessKeys")]
3594    AmazonBedrockAccessKeys {
3595        #[serde(rename = "accessKeyId")]
3596        access_key_id: String,
3597        region: String,
3598        #[serde(rename = "secretAccessKey")]
3599        secret_access_key: String,
3600        #[serde(
3601            rename = "sessionToken",
3602            default,
3603            skip_serializing_if = "Option::is_none"
3604        )]
3605        session_token: Option<String>,
3606    },
3607}
3608
3609#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3610#[serde(tag = "type", rename_all = "camelCase")]
3611pub enum LoginAccountResponse {
3612    #[serde(rename = "apiKey")]
3613    ApiKey,
3614    Chatgpt {
3615        #[serde(rename = "authUrl")]
3616        auth_url: String,
3617        #[serde(rename = "loginId")]
3618        login_id: String,
3619    },
3620    #[serde(rename = "chatgptDeviceCode")]
3621    ChatgptDeviceCode {
3622        #[serde(rename = "loginId")]
3623        login_id: String,
3624        #[serde(rename = "userCode")]
3625        user_code: String,
3626        #[serde(rename = "verificationUrl")]
3627        verification_url: String,
3628    },
3629    #[serde(rename = "chatgptAuthTokens")]
3630    ChatgptAuthTokens,
3631    #[serde(rename = "amazonBedrock")]
3632    AmazonBedrock,
3633}
3634
3635#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3636pub enum LoginAppBrand {
3637    #[serde(rename = "codex")]
3638    Codex,
3639    #[serde(rename = "chatgpt")]
3640    Chatgpt,
3641}
3642
3643#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3644#[serde(rename_all = "camelCase")]
3645pub struct LogoutAccountResponse {
3646    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
3647    pub extra: serde_json::Map<String, Value>,
3648}
3649
3650#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3651#[serde(rename_all = "camelCase")]
3652pub struct MarketplaceAddParams {
3653    #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
3654    pub ref_name: Option<String>,
3655    #[serde(default)]
3656    pub source: String,
3657    #[serde(
3658        rename = "sparsePaths",
3659        default,
3660        skip_serializing_if = "Option::is_none"
3661    )]
3662    pub sparse_paths: Option<Vec<String>>,
3663}
3664
3665#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3666#[serde(rename_all = "camelCase")]
3667pub struct MarketplaceAddResponse {
3668    #[serde(rename = "alreadyAdded", default)]
3669    pub already_added: bool,
3670    #[serde(rename = "installedRoot")]
3671    pub installed_root: AbsolutePathBuf,
3672    #[serde(rename = "marketplaceName", default)]
3673    pub marketplace_name: String,
3674}
3675
3676#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3677#[serde(rename_all = "camelCase")]
3678pub struct MarketplaceInterface {
3679    #[serde(
3680        rename = "displayName",
3681        default,
3682        skip_serializing_if = "Option::is_none"
3683    )]
3684    pub display_name: Option<String>,
3685}
3686
3687#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3688#[serde(rename_all = "camelCase")]
3689pub struct MarketplaceLoadErrorInfo {
3690    #[serde(rename = "marketplacePath")]
3691    pub marketplace_path: AbsolutePathBuf,
3692    #[serde(default)]
3693    pub message: String,
3694}
3695
3696#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3697#[serde(rename_all = "camelCase")]
3698pub struct MarketplaceRemoveParams {
3699    #[serde(rename = "marketplaceName", default)]
3700    pub marketplace_name: String,
3701}
3702
3703#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3704#[serde(rename_all = "camelCase")]
3705pub struct MarketplaceRemoveResponse {
3706    #[serde(
3707        rename = "installedRoot",
3708        default,
3709        skip_serializing_if = "Option::is_none"
3710    )]
3711    pub installed_root: Option<AbsolutePathBuf>,
3712    #[serde(rename = "marketplaceName", default)]
3713    pub marketplace_name: String,
3714}
3715
3716#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3717#[serde(rename_all = "camelCase")]
3718pub struct MarketplaceUpgradeErrorInfo {
3719    #[serde(rename = "marketplaceName", default)]
3720    pub marketplace_name: String,
3721    #[serde(default)]
3722    pub message: String,
3723}
3724
3725#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3726#[serde(rename_all = "camelCase")]
3727pub struct MarketplaceUpgradeParams {
3728    #[serde(
3729        rename = "marketplaceName",
3730        default,
3731        skip_serializing_if = "Option::is_none"
3732    )]
3733    pub marketplace_name: Option<String>,
3734}
3735
3736#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3737#[serde(rename_all = "camelCase")]
3738pub struct MarketplaceUpgradeResponse {
3739    #[serde(default)]
3740    pub errors: Vec<MarketplaceUpgradeErrorInfo>,
3741    #[serde(rename = "selectedMarketplaces", default)]
3742    pub selected_marketplaces: Vec<String>,
3743    #[serde(rename = "upgradedRoots", default)]
3744    pub upgraded_roots: Vec<AbsolutePathBuf>,
3745}
3746
3747#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3748pub enum McpAuthStatus {
3749    #[serde(rename = "unknown")]
3750    Unknown,
3751    #[serde(rename = "unsupported")]
3752    Unsupported,
3753    #[serde(rename = "notLoggedIn")]
3754    NotLoggedIn,
3755    #[serde(rename = "bearerToken")]
3756    BearerToken,
3757    #[serde(rename = "oAuth")]
3758    OAuth,
3759}
3760
3761#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3762pub enum McpElicitationArrayType {
3763    #[serde(rename = "array")]
3764    Array,
3765}
3766
3767#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3768#[serde(rename_all = "camelCase")]
3769pub struct McpElicitationBooleanSchema {
3770    #[serde(default, skip_serializing_if = "Option::is_none")]
3771    pub default: Option<bool>,
3772    #[serde(default, skip_serializing_if = "Option::is_none")]
3773    pub description: Option<String>,
3774    #[serde(default, skip_serializing_if = "Option::is_none")]
3775    pub title: Option<String>,
3776    #[serde(rename = "type")]
3777    pub type_: McpElicitationBooleanType,
3778}
3779
3780#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3781pub enum McpElicitationBooleanType {
3782    #[serde(rename = "boolean")]
3783    Boolean,
3784}
3785
3786#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3787#[serde(rename_all = "camelCase")]
3788pub struct McpElicitationConstOption {
3789    #[serde(rename = "const", default)]
3790    pub const_: String,
3791    #[serde(default)]
3792    pub title: String,
3793}
3794
3795#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3796#[serde(untagged)]
3797pub enum McpElicitationEnumSchema {
3798    McpElicitationSingleSelectEnumSchema(McpElicitationSingleSelectEnumSchema),
3799    McpElicitationMultiSelectEnumSchema(McpElicitationMultiSelectEnumSchema),
3800    McpElicitationLegacyTitledEnumSchema(McpElicitationLegacyTitledEnumSchema),
3801}
3802
3803#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3804#[serde(rename_all = "camelCase")]
3805pub struct McpElicitationLegacyTitledEnumSchema {
3806    #[serde(default, skip_serializing_if = "Option::is_none")]
3807    pub default: Option<String>,
3808    #[serde(default, skip_serializing_if = "Option::is_none")]
3809    pub description: Option<String>,
3810    #[serde(rename = "enum", default)]
3811    pub enum_: Vec<String>,
3812    #[serde(rename = "enumNames", default, skip_serializing_if = "Option::is_none")]
3813    pub enum_names: Option<Vec<String>>,
3814    #[serde(default, skip_serializing_if = "Option::is_none")]
3815    pub title: Option<String>,
3816    #[serde(rename = "type")]
3817    pub type_: McpElicitationStringType,
3818}
3819
3820#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3821#[serde(untagged)]
3822pub enum McpElicitationMultiSelectEnumSchema {
3823    McpElicitationUntitledMultiSelectEnumSchema(McpElicitationUntitledMultiSelectEnumSchema),
3824    McpElicitationTitledMultiSelectEnumSchema(McpElicitationTitledMultiSelectEnumSchema),
3825}
3826
3827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3828#[serde(rename_all = "camelCase")]
3829pub struct McpElicitationNumberSchema {
3830    #[serde(default, skip_serializing_if = "Option::is_none")]
3831    pub default: Option<f64>,
3832    #[serde(default, skip_serializing_if = "Option::is_none")]
3833    pub description: Option<String>,
3834    #[serde(default, skip_serializing_if = "Option::is_none")]
3835    pub maximum: Option<f64>,
3836    #[serde(default, skip_serializing_if = "Option::is_none")]
3837    pub minimum: Option<f64>,
3838    #[serde(default, skip_serializing_if = "Option::is_none")]
3839    pub title: Option<String>,
3840    #[serde(rename = "type")]
3841    pub type_: McpElicitationNumberType,
3842}
3843
3844#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3845pub enum McpElicitationNumberType {
3846    #[serde(rename = "number")]
3847    Number,
3848    #[serde(rename = "integer")]
3849    Integer,
3850}
3851
3852#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3853pub enum McpElicitationObjectType {
3854    #[serde(rename = "object")]
3855    Object,
3856}
3857
3858#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3859#[serde(untagged)]
3860pub enum McpElicitationPrimitiveSchema {
3861    McpElicitationEnumSchema(McpElicitationEnumSchema),
3862    McpElicitationStringSchema(McpElicitationStringSchema),
3863    McpElicitationNumberSchema(McpElicitationNumberSchema),
3864    McpElicitationBooleanSchema(McpElicitationBooleanSchema),
3865}
3866
3867#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3868#[serde(rename_all = "camelCase")]
3869pub struct McpElicitationSchema {
3870    #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
3871    pub schema: Option<String>,
3872    #[serde(default)]
3873    pub properties: std::collections::BTreeMap<String, McpElicitationPrimitiveSchema>,
3874    #[serde(default, skip_serializing_if = "Option::is_none")]
3875    pub required: Option<Vec<String>>,
3876    #[serde(rename = "type")]
3877    pub type_: McpElicitationObjectType,
3878}
3879
3880#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3881#[serde(untagged)]
3882pub enum McpElicitationSingleSelectEnumSchema {
3883    McpElicitationUntitledSingleSelectEnumSchema(McpElicitationUntitledSingleSelectEnumSchema),
3884    McpElicitationTitledSingleSelectEnumSchema(McpElicitationTitledSingleSelectEnumSchema),
3885}
3886
3887#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3888pub enum McpElicitationStringFormat {
3889    #[serde(rename = "email")]
3890    Email,
3891    #[serde(rename = "uri")]
3892    Uri,
3893    #[serde(rename = "date")]
3894    Date,
3895    #[serde(rename = "date-time")]
3896    Date_time,
3897}
3898
3899#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3900#[serde(rename_all = "camelCase")]
3901pub struct McpElicitationStringSchema {
3902    #[serde(default, skip_serializing_if = "Option::is_none")]
3903    pub default: Option<String>,
3904    #[serde(default, skip_serializing_if = "Option::is_none")]
3905    pub description: Option<String>,
3906    #[serde(default, skip_serializing_if = "Option::is_none")]
3907    pub format: Option<McpElicitationStringFormat>,
3908    #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
3909    pub max_length: Option<i64>,
3910    #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
3911    pub min_length: Option<i64>,
3912    #[serde(default, skip_serializing_if = "Option::is_none")]
3913    pub title: Option<String>,
3914    #[serde(rename = "type")]
3915    pub type_: McpElicitationStringType,
3916}
3917
3918#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3919pub enum McpElicitationStringType {
3920    #[serde(rename = "string")]
3921    String,
3922}
3923
3924#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3925#[serde(rename_all = "camelCase")]
3926pub struct McpElicitationTitledEnumItems {
3927    #[serde(rename = "anyOf", default)]
3928    pub any_of: Vec<McpElicitationConstOption>,
3929}
3930
3931#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3932#[serde(rename_all = "camelCase")]
3933pub struct McpElicitationTitledMultiSelectEnumSchema {
3934    #[serde(default, skip_serializing_if = "Option::is_none")]
3935    pub default: Option<Vec<String>>,
3936    #[serde(default, skip_serializing_if = "Option::is_none")]
3937    pub description: Option<String>,
3938    #[serde()]
3939    pub items: McpElicitationTitledEnumItems,
3940    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
3941    pub max_items: Option<i64>,
3942    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
3943    pub min_items: Option<i64>,
3944    #[serde(default, skip_serializing_if = "Option::is_none")]
3945    pub title: Option<String>,
3946    #[serde(rename = "type")]
3947    pub type_: McpElicitationArrayType,
3948}
3949
3950#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3951#[serde(rename_all = "camelCase")]
3952pub struct McpElicitationTitledSingleSelectEnumSchema {
3953    #[serde(default, skip_serializing_if = "Option::is_none")]
3954    pub default: Option<String>,
3955    #[serde(default, skip_serializing_if = "Option::is_none")]
3956    pub description: Option<String>,
3957    #[serde(rename = "oneOf", default)]
3958    pub one_of: Vec<McpElicitationConstOption>,
3959    #[serde(default, skip_serializing_if = "Option::is_none")]
3960    pub title: Option<String>,
3961    #[serde(rename = "type")]
3962    pub type_: McpElicitationStringType,
3963}
3964
3965#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3966#[serde(rename_all = "camelCase")]
3967pub struct McpElicitationUntitledEnumItems {
3968    #[serde(rename = "enum", default)]
3969    pub enum_: Vec<String>,
3970    #[serde(rename = "type")]
3971    pub type_: McpElicitationStringType,
3972}
3973
3974#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3975#[serde(rename_all = "camelCase")]
3976pub struct McpElicitationUntitledMultiSelectEnumSchema {
3977    #[serde(default, skip_serializing_if = "Option::is_none")]
3978    pub default: Option<Vec<String>>,
3979    #[serde(default, skip_serializing_if = "Option::is_none")]
3980    pub description: Option<String>,
3981    #[serde()]
3982    pub items: McpElicitationUntitledEnumItems,
3983    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
3984    pub max_items: Option<i64>,
3985    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
3986    pub min_items: Option<i64>,
3987    #[serde(default, skip_serializing_if = "Option::is_none")]
3988    pub title: Option<String>,
3989    #[serde(rename = "type")]
3990    pub type_: McpElicitationArrayType,
3991}
3992
3993#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3994#[serde(rename_all = "camelCase")]
3995pub struct McpElicitationUntitledSingleSelectEnumSchema {
3996    #[serde(default, skip_serializing_if = "Option::is_none")]
3997    pub default: Option<String>,
3998    #[serde(default, skip_serializing_if = "Option::is_none")]
3999    pub description: Option<String>,
4000    #[serde(rename = "enum", default)]
4001    pub enum_: Vec<String>,
4002    #[serde(default, skip_serializing_if = "Option::is_none")]
4003    pub title: Option<String>,
4004    #[serde(rename = "type")]
4005    pub type_: McpElicitationStringType,
4006}
4007
4008#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4009#[serde(rename_all = "camelCase")]
4010pub struct McpResourceReadParams {
4011    #[serde(
4012        rename = "connectorId",
4013        default,
4014        skip_serializing_if = "Option::is_none"
4015    )]
4016    pub connector_id: Option<String>,
4017    /// Originating MCP tool call used to select the resource's app.
4018    #[serde(
4019        rename = "originCallId",
4020        default,
4021        skip_serializing_if = "Option::is_none"
4022    )]
4023    pub origin_call_id: Option<String>,
4024    #[serde(default)]
4025    pub server: String,
4026    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4027    pub thread_id: Option<String>,
4028    #[serde(default)]
4029    pub uri: String,
4030}
4031
4032#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4033#[serde(rename_all = "camelCase")]
4034pub struct McpResourceReadResponse {
4035    #[serde(default)]
4036    pub contents: Vec<ResourceContent>,
4037    /// Originating call when the server applied app-specific resource
4038    /// scoping.
4039    #[serde(
4040        rename = "originCallId",
4041        default,
4042        skip_serializing_if = "Option::is_none"
4043    )]
4044    pub origin_call_id: Option<String>,
4045}
4046
4047#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4048pub enum McpServerElicitationAction {
4049    #[serde(rename = "accept")]
4050    Accept,
4051    #[serde(rename = "decline")]
4052    Decline,
4053    #[serde(rename = "cancel")]
4054    Cancel,
4055}
4056
4057#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4058#[serde(tag = "mode", rename_all = "camelCase")]
4059pub enum McpServerElicitationRequestParams {
4060    Form {
4061        #[serde(default, skip_serializing_if = "Option::is_none")]
4062        _meta: Option<Value>,
4063        message: String,
4064        #[serde(rename = "requestedSchema")]
4065        requested_schema: McpElicitationSchema,
4066    },
4067    #[serde(rename = "openai/form")]
4068    OpenaiForm {
4069        #[serde(default, skip_serializing_if = "Option::is_none")]
4070        _meta: Option<Value>,
4071        message: String,
4072        #[serde(rename = "requestedSchema")]
4073        requested_schema: Value,
4074    },
4075    #[serde(rename = "openaiForm")]
4076    OpenAiElicitationForm {
4077        #[serde(default, skip_serializing_if = "Option::is_none")]
4078        _meta: Option<Value>,
4079        message: String,
4080        #[serde(rename = "requestedSchema")]
4081        requested_schema: Value,
4082    },
4083    Url {
4084        #[serde(default, skip_serializing_if = "Option::is_none")]
4085        _meta: Option<Value>,
4086        #[serde(rename = "elicitationId")]
4087        elicitation_id: String,
4088        message: String,
4089        url: String,
4090    },
4091}
4092
4093#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4094#[serde(rename_all = "camelCase")]
4095pub struct McpServerElicitationRequestResponse {
4096    #[serde(default, skip_serializing_if = "Option::is_none")]
4097    pub _meta: Option<Value>,
4098    #[serde()]
4099    pub action: McpServerElicitationAction,
4100    #[serde(default, skip_serializing_if = "Option::is_none")]
4101    pub content: Option<Value>,
4102}
4103
4104#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4105#[serde(rename_all = "camelCase")]
4106pub struct McpServerInfo {
4107    #[serde(default, skip_serializing_if = "Option::is_none")]
4108    pub description: Option<String>,
4109    #[serde(default, skip_serializing_if = "Option::is_none")]
4110    pub icons: Option<Vec<Value>>,
4111    #[serde(default)]
4112    pub name: String,
4113    #[serde(default, skip_serializing_if = "Option::is_none")]
4114    pub title: Option<String>,
4115    #[serde(default)]
4116    pub version: String,
4117    #[serde(
4118        rename = "websiteUrl",
4119        default,
4120        skip_serializing_if = "Option::is_none"
4121    )]
4122    pub website_url: Option<String>,
4123}
4124
4125#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4126#[serde(rename_all = "camelCase")]
4127pub struct McpServerMigration {
4128    #[serde(default)]
4129    pub name: String,
4130}
4131
4132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4133#[serde(rename_all = "camelCase")]
4134pub struct McpServerOauthLoginCompletedNotification {
4135    #[serde(default, skip_serializing_if = "Option::is_none")]
4136    pub error: Option<String>,
4137    #[serde(default)]
4138    pub name: String,
4139    #[serde(default)]
4140    pub success: bool,
4141    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4142    pub thread_id: Option<String>,
4143}
4144
4145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4146#[serde(rename_all = "camelCase")]
4147pub struct McpServerOauthLoginParams {
4148    #[serde(
4149        rename = "clientRegistration",
4150        default,
4151        skip_serializing_if = "Option::is_none"
4152    )]
4153    pub client_registration: Option<McpServerOauthClientRegistration>,
4154    #[serde(default)]
4155    pub name: String,
4156    #[serde(default, skip_serializing_if = "Option::is_none")]
4157    pub scopes: Option<Vec<String>>,
4158    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4159    pub thread_id: Option<String>,
4160    #[serde(
4161        rename = "timeoutSecs",
4162        default,
4163        skip_serializing_if = "Option::is_none"
4164    )]
4165    pub timeout_secs: Option<i64>,
4166}
4167
4168#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4169#[serde(rename_all = "camelCase")]
4170pub struct McpServerOauthLoginResponse {
4171    #[serde(rename = "authorizationUrl", default)]
4172    pub authorization_url: String,
4173}
4174
4175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4176#[serde(rename_all = "camelCase")]
4177pub struct McpServerRefreshResponse {
4178    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4179    pub extra: serde_json::Map<String, Value>,
4180}
4181
4182#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4183pub enum McpServerStartupFailureReason {
4184    #[serde(rename = "reauthenticationRequired")]
4185    ReauthenticationRequired,
4186}
4187
4188#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4189pub enum McpServerStartupState {
4190    #[serde(rename = "starting")]
4191    Starting,
4192    #[serde(rename = "ready")]
4193    Ready,
4194    #[serde(rename = "failed")]
4195    Failed,
4196    #[serde(rename = "cancelled")]
4197    Cancelled,
4198}
4199
4200#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4201#[serde(rename_all = "camelCase")]
4202pub struct McpServerStatus {
4203    #[serde(rename = "authStatus")]
4204    pub auth_status: McpAuthStatus,
4205    /// Current thread-runtime connection state; absent when unavailable.
4206    #[serde(
4207        rename = "runtimeStatus",
4208        default,
4209        skip_serializing_if = "Option::is_none"
4210    )]
4211    pub runtime_status: Option<McpServerConnectionStatus>,
4212    #[serde(default)]
4213    pub name: String,
4214    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
4215    pub plugin_id: Option<String>,
4216    #[serde(rename = "resourceTemplates", default)]
4217    pub resource_templates: Vec<ResourceTemplate>,
4218    #[serde(default)]
4219    pub resources: Vec<Resource>,
4220    #[serde(
4221        rename = "serverInfo",
4222        default,
4223        skip_serializing_if = "Option::is_none"
4224    )]
4225    pub server_info: Option<McpServerInfo>,
4226    #[serde(default)]
4227    pub tools: std::collections::BTreeMap<String, Tool>,
4228    /// Tool discovery failed and no catalog was returned. `None` when a
4229    /// catalog is returned, including cached or empty catalogs.
4230    #[serde(
4231        rename = "toolsError",
4232        default,
4233        skip_serializing_if = "Option::is_none"
4234    )]
4235    pub tools_error: Option<String>,
4236}
4237
4238#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4239pub enum McpServerStatusDetail {
4240    #[serde(rename = "full")]
4241    Full,
4242    #[serde(rename = "toolsAndAuthOnly")]
4243    ToolsAndAuthOnly,
4244}
4245
4246#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4247#[serde(rename_all = "camelCase")]
4248pub struct McpServerStatusUpdatedNotification {
4249    #[serde(default, skip_serializing_if = "Option::is_none")]
4250    pub error: Option<String>,
4251    #[serde(
4252        rename = "failureReason",
4253        default,
4254        skip_serializing_if = "Option::is_none"
4255    )]
4256    pub failure_reason: Option<McpServerStartupFailureReason>,
4257    #[serde(default)]
4258    pub name: String,
4259    #[serde()]
4260    pub status: McpServerStartupState,
4261    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4262    pub thread_id: Option<String>,
4263}
4264
4265#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4266#[serde(rename_all = "camelCase")]
4267pub struct McpServerToolCallParams {
4268    #[serde(default, skip_serializing_if = "Option::is_none")]
4269    pub _meta: Option<Value>,
4270    #[serde(default, skip_serializing_if = "Option::is_none")]
4271    pub arguments: Option<Value>,
4272    #[serde(default)]
4273    pub server: String,
4274    #[serde(rename = "threadId", default)]
4275    pub thread_id: String,
4276    #[serde(default)]
4277    pub tool: String,
4278}
4279
4280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4281#[serde(rename_all = "camelCase")]
4282pub struct McpServerToolCallResponse {
4283    #[serde(default, skip_serializing_if = "Option::is_none")]
4284    pub _meta: Option<Value>,
4285    #[serde(default)]
4286    pub content: Vec<Value>,
4287    #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
4288    pub is_error: Option<bool>,
4289    #[serde(
4290        rename = "structuredContent",
4291        default,
4292        skip_serializing_if = "Option::is_none"
4293    )]
4294    pub structured_content: Option<Value>,
4295}
4296
4297#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4298#[serde(rename_all = "camelCase")]
4299pub struct McpToolCallAppContext {
4300    #[serde(
4301        rename = "actionName",
4302        default,
4303        skip_serializing_if = "Option::is_none"
4304    )]
4305    pub action_name: Option<String>,
4306    #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
4307    pub app_name: Option<String>,
4308    #[serde(rename = "connectorId", default)]
4309    pub connector_id: String,
4310    #[serde(rename = "linkId", default, skip_serializing_if = "Option::is_none")]
4311    pub link_id: Option<String>,
4312    #[serde(
4313        rename = "resourceUri",
4314        default,
4315        skip_serializing_if = "Option::is_none"
4316    )]
4317    pub resource_uri: Option<String>,
4318}
4319
4320#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4321#[serde(rename_all = "camelCase")]
4322pub struct McpToolCallError {
4323    #[serde(default)]
4324    pub message: String,
4325}
4326
4327#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4328#[serde(rename_all = "camelCase")]
4329pub struct McpToolCallProgressNotification {
4330    #[serde(rename = "itemId", default)]
4331    pub item_id: String,
4332    #[serde(default)]
4333    pub message: String,
4334    #[serde(rename = "threadId", default)]
4335    pub thread_id: String,
4336    #[serde(rename = "turnId", default)]
4337    pub turn_id: String,
4338}
4339
4340#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4341#[serde(rename_all = "camelCase")]
4342pub struct McpToolCallResult {
4343    #[serde(default, skip_serializing_if = "Option::is_none")]
4344    pub _meta: Option<Value>,
4345    #[serde(default)]
4346    pub content: Vec<Value>,
4347    #[serde(
4348        rename = "structuredContent",
4349        default,
4350        skip_serializing_if = "Option::is_none"
4351    )]
4352    pub structured_content: Option<Value>,
4353}
4354
4355#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4356pub enum McpToolCallStatus {
4357    #[serde(rename = "inProgress")]
4358    InProgress,
4359    #[serde(rename = "completed")]
4360    Completed,
4361    #[serde(rename = "failed")]
4362    Failed,
4363}
4364
4365#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4366#[serde(rename_all = "camelCase")]
4367pub struct MemoryCitation {
4368    #[serde(default)]
4369    pub entries: Vec<MemoryCitationEntry>,
4370    #[serde(rename = "threadIds", default)]
4371    pub thread_ids: Vec<String>,
4372}
4373
4374#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4375#[serde(rename_all = "camelCase")]
4376pub struct MemoryCitationEntry {
4377    #[serde(rename = "lineEnd", default)]
4378    pub line_end: i64,
4379    #[serde(rename = "lineStart", default)]
4380    pub line_start: i64,
4381    #[serde(default)]
4382    pub note: String,
4383    #[serde(default)]
4384    pub path: String,
4385}
4386
4387#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4388pub enum MergeStrategy {
4389    #[serde(rename = "replace")]
4390    Replace,
4391    #[serde(rename = "upsert")]
4392    Upsert,
4393}
4394
4395#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4396pub enum MessagePhase {
4397    #[serde(rename = "commentary")]
4398    Commentary,
4399    #[serde(rename = "final_answer")]
4400    FinalAnswer,
4401}
4402
4403#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4404#[serde(rename_all = "camelCase")]
4405pub struct MigrationDetails {
4406    #[serde(default, skip_serializing_if = "Option::is_none")]
4407    pub commands: Option<Vec<CommandMigration>>,
4408    #[serde(default, skip_serializing_if = "Option::is_none")]
4409    pub hooks: Option<Vec<HookMigration>>,
4410    #[serde(
4411        rename = "mcpServers",
4412        default,
4413        skip_serializing_if = "Option::is_none"
4414    )]
4415    pub mcp_servers: Option<Vec<McpServerMigration>>,
4416    #[serde(default, skip_serializing_if = "Option::is_none")]
4417    pub memory: Option<Vec<String>>,
4418    #[serde(default, skip_serializing_if = "Option::is_none")]
4419    pub plugins: Option<Vec<PluginsMigration>>,
4420    #[serde(default, skip_serializing_if = "Option::is_none")]
4421    pub sessions: Option<Vec<SessionMigration>>,
4422    #[serde(default, skip_serializing_if = "Option::is_none")]
4423    pub skills: Option<Vec<SkillMigration>>,
4424    #[serde(default, skip_serializing_if = "Option::is_none")]
4425    pub subagents: Option<Vec<SubagentMigration>>,
4426}
4427
4428/// Public explanation and continuation instruction attached to a
4429/// misalignment-blocked turn error (0.148 upstream).
4430#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4431#[serde(rename_all = "camelCase")]
4432pub struct MisalignmentErrorDetails {
4433    #[serde(
4434        rename = "detailedExplanation",
4435        default,
4436        skip_serializing_if = "Option::is_none"
4437    )]
4438    pub detailed_explanation: Option<String>,
4439    /// Open-ended classification; accept categories added upstream.
4440    #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
4441    pub error_type: Option<String>,
4442    /// Instruction to submit as the next turn's user input if continuation
4443    /// is confirmed.
4444    #[serde(default, skip_serializing_if = "Option::is_none")]
4445    pub steer: Option<MisalignmentSteer>,
4446}
4447
4448/// The steering instruction inside [`MisalignmentErrorDetails`].
4449#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4450#[serde(rename_all = "camelCase")]
4451pub struct MisalignmentSteer {
4452    #[serde(default)]
4453    pub message: String,
4454}
4455
4456#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4457pub enum ModeKind {
4458    #[serde(rename = "plan")]
4459    Plan,
4460    #[serde(rename = "default")]
4461    Default,
4462}
4463
4464#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4465#[serde(rename_all = "camelCase")]
4466pub struct Model {
4467    #[serde(
4468        rename = "additionalSpeedTiers",
4469        default,
4470        skip_serializing_if = "Option::is_none"
4471    )]
4472    pub additional_speed_tiers: Option<Vec<String>>,
4473    #[serde(
4474        rename = "availabilityNux",
4475        default,
4476        skip_serializing_if = "Option::is_none"
4477    )]
4478    pub availability_nux: Option<ModelAvailabilityNux>,
4479    #[serde(rename = "defaultReasoningEffort")]
4480    pub default_reasoning_effort: ReasoningEffort,
4481    #[serde(
4482        rename = "defaultServiceTier",
4483        default,
4484        skip_serializing_if = "Option::is_none"
4485    )]
4486    pub default_service_tier: Option<String>,
4487    #[serde(default)]
4488    pub description: String,
4489    #[serde(rename = "displayName", default)]
4490    pub display_name: String,
4491    #[serde(default)]
4492    pub hidden: bool,
4493    #[serde(default)]
4494    pub id: String,
4495    #[serde(
4496        rename = "inputModalities",
4497        default,
4498        skip_serializing_if = "Option::is_none"
4499    )]
4500    pub input_modalities: Option<Vec<InputModality>>,
4501    #[serde(rename = "isDefault", default)]
4502    pub is_default: bool,
4503    #[serde(default)]
4504    pub model: String,
4505    #[serde(
4506        rename = "modelSpecialty",
4507        default,
4508        skip_serializing_if = "Option::is_none"
4509    )]
4510    pub model_specialty: Option<String>,
4511    #[serde(
4512        rename = "multiAgentVersion",
4513        default,
4514        skip_serializing_if = "Option::is_none"
4515    )]
4516    pub multi_agent_version: Option<MultiAgentVersion>,
4517    #[serde(
4518        rename = "serviceTiers",
4519        default,
4520        skip_serializing_if = "Option::is_none"
4521    )]
4522    pub service_tiers: Option<Vec<ModelServiceTier>>,
4523    #[serde(rename = "supportedReasoningEfforts", default)]
4524    pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
4525    #[serde(
4526        rename = "supportsPersonality",
4527        default,
4528        skip_serializing_if = "Option::is_none"
4529    )]
4530    pub supports_personality: Option<bool>,
4531    #[serde(default, skip_serializing_if = "Option::is_none")]
4532    pub upgrade: Option<String>,
4533    #[serde(
4534        rename = "upgradeInfo",
4535        default,
4536        skip_serializing_if = "Option::is_none"
4537    )]
4538    pub upgrade_info: Option<ModelUpgradeInfo>,
4539}
4540
4541#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4542#[serde(rename_all = "camelCase")]
4543pub struct ModelAvailabilityNux {
4544    #[serde(default)]
4545    pub message: String,
4546}
4547
4548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4549#[serde(rename_all = "camelCase")]
4550pub struct ModelListParams {
4551    #[serde(default, skip_serializing_if = "Option::is_none")]
4552    pub cursor: Option<String>,
4553    #[serde(
4554        rename = "includeHidden",
4555        default,
4556        skip_serializing_if = "Option::is_none"
4557    )]
4558    pub include_hidden: Option<bool>,
4559    #[serde(default, skip_serializing_if = "Option::is_none")]
4560    pub limit: Option<i64>,
4561}
4562
4563#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4564#[serde(rename_all = "camelCase")]
4565pub struct ModelListResponse {
4566    #[serde(default)]
4567    pub data: Vec<Model>,
4568    #[serde(
4569        rename = "nextCursor",
4570        default,
4571        skip_serializing_if = "Option::is_none"
4572    )]
4573    pub next_cursor: Option<String>,
4574}
4575
4576#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4577#[serde(rename_all = "camelCase")]
4578pub struct ModelProviderCapabilitiesReadParams {
4579    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4580    pub extra: serde_json::Map<String, Value>,
4581}
4582
4583#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4584#[serde(rename_all = "camelCase")]
4585pub struct ModelProviderCapabilitiesReadResponse {
4586    #[serde(rename = "imageGeneration", default)]
4587    pub image_generation: bool,
4588    #[serde(rename = "namespaceTools", default)]
4589    pub namespace_tools: bool,
4590    #[serde(rename = "webSearch", default)]
4591    pub web_search: bool,
4592}
4593
4594#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4595pub enum ModelRerouteReason {
4596    #[serde(rename = "highRiskCyberActivity")]
4597    HighRiskCyberActivity,
4598}
4599
4600#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4601#[serde(rename_all = "camelCase")]
4602pub struct ModelReroutedNotification {
4603    #[serde(rename = "fromModel", default)]
4604    pub from_model: String,
4605    #[serde()]
4606    pub reason: ModelRerouteReason,
4607    #[serde(rename = "threadId", default)]
4608    pub thread_id: String,
4609    #[serde(rename = "toModel", default)]
4610    pub to_model: String,
4611    #[serde(rename = "turnId", default)]
4612    pub turn_id: String,
4613}
4614
4615#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4616#[serde(rename_all = "camelCase")]
4617pub struct ModelSafetyBufferingUpdatedNotification {
4618    #[serde(
4619        rename = "fasterModel",
4620        default,
4621        skip_serializing_if = "Option::is_none"
4622    )]
4623    pub faster_model: Option<String>,
4624    #[serde(default)]
4625    pub model: String,
4626    #[serde(default)]
4627    pub reasons: Vec<String>,
4628    #[serde(rename = "showBufferingUi", default)]
4629    pub show_buffering_ui: bool,
4630    #[serde(rename = "threadId", default)]
4631    pub thread_id: String,
4632    #[serde(rename = "turnId", default)]
4633    pub turn_id: String,
4634    #[serde(rename = "useCases", default)]
4635    pub use_cases: Vec<String>,
4636}
4637
4638#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4639#[serde(rename_all = "camelCase")]
4640pub struct ModelServiceTier {
4641    #[serde(default)]
4642    pub description: String,
4643    #[serde(default)]
4644    pub id: String,
4645    #[serde(default)]
4646    pub name: String,
4647}
4648
4649#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4650#[serde(rename_all = "camelCase")]
4651pub struct ModelUpgradeInfo {
4652    #[serde(
4653        rename = "migrationMarkdown",
4654        default,
4655        skip_serializing_if = "Option::is_none"
4656    )]
4657    pub migration_markdown: Option<String>,
4658    #[serde(default)]
4659    pub model: String,
4660    /// Informational Unix timestamp for this upgrade's scheduled
4661    /// retirement, if known.
4662    #[serde(
4663        rename = "retirementAt",
4664        default,
4665        skip_serializing_if = "Option::is_none"
4666    )]
4667    pub retirement_at: Option<i64>,
4668    #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
4669    pub model_link: Option<String>,
4670    #[serde(
4671        rename = "upgradeCopy",
4672        default,
4673        skip_serializing_if = "Option::is_none"
4674    )]
4675    pub upgrade_copy: Option<String>,
4676}
4677
4678#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4679pub enum ModelVerification {
4680    #[serde(rename = "trustedAccessForCyber")]
4681    TrustedAccessForCyber,
4682}
4683
4684#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4685#[serde(rename_all = "camelCase")]
4686pub struct ModelVerificationNotification {
4687    #[serde(rename = "threadId", default)]
4688    pub thread_id: String,
4689    #[serde(rename = "turnId", default)]
4690    pub turn_id: String,
4691    #[serde(default)]
4692    pub verifications: Vec<ModelVerification>,
4693}
4694
4695#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4696#[serde(rename_all = "camelCase")]
4697pub struct ModelsRequirements {
4698    #[serde(rename = "newThread", default, skip_serializing_if = "Option::is_none")]
4699    pub new_thread: Option<NewThreadModelDefaults>,
4700}
4701
4702#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4703pub enum MultiAgentVersion {
4704    #[serde(rename = "disabled")]
4705    Disabled,
4706    #[serde(rename = "v1")]
4707    V1,
4708    #[serde(rename = "v2")]
4709    V2,
4710}
4711
4712#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4713pub enum NetworkAccess {
4714    #[serde(rename = "restricted")]
4715    Restricted,
4716    #[serde(rename = "enabled")]
4717    Enabled,
4718}
4719
4720#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4721#[serde(rename_all = "camelCase")]
4722pub struct NetworkApprovalContext {
4723    #[serde(default)]
4724    pub host: String,
4725    #[serde()]
4726    pub protocol: NetworkApprovalProtocol,
4727}
4728
4729#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4730pub enum NetworkApprovalProtocol {
4731    #[serde(rename = "http")]
4732    Http,
4733    #[serde(rename = "https")]
4734    Https,
4735    #[serde(rename = "socks5Tcp")]
4736    Socks5Tcp,
4737    #[serde(rename = "socks5Udp")]
4738    Socks5Udp,
4739}
4740
4741#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4742#[serde(rename_all = "camelCase")]
4743pub struct NetworkPolicyAmendment {
4744    #[serde()]
4745    pub action: NetworkPolicyRuleAction,
4746    #[serde(default)]
4747    pub host: String,
4748}
4749
4750#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4751pub enum NetworkPolicyRuleAction {
4752    #[serde(rename = "allow")]
4753    Allow,
4754    #[serde(rename = "deny")]
4755    Deny,
4756}
4757
4758#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4759#[serde(rename_all = "camelCase")]
4760pub struct NewThreadModelDefaults {
4761    #[serde(default, skip_serializing_if = "Option::is_none")]
4762    pub model: Option<String>,
4763    #[serde(
4764        rename = "modelReasoningEffort",
4765        default,
4766        skip_serializing_if = "Option::is_none"
4767    )]
4768    pub model_reasoning_effort: Option<ReasoningEffort>,
4769    #[serde(
4770        rename = "serviceTier",
4771        default,
4772        skip_serializing_if = "Option::is_none"
4773    )]
4774    pub service_tier: Option<String>,
4775}
4776
4777#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4778pub enum NonSteerableTurnKind {
4779    #[serde(rename = "review")]
4780    Review,
4781    #[serde(rename = "compact")]
4782    Compact,
4783}
4784
4785#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4786#[serde(rename_all = "camelCase")]
4787pub struct OverriddenMetadata {
4788    #[serde(rename = "effectiveValue", default)]
4789    pub effective_value: Value,
4790    #[serde(default)]
4791    pub message: String,
4792    #[serde(rename = "overridingLayer")]
4793    pub overriding_layer: ConfigLayerMetadata,
4794}
4795
4796#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4797#[serde(tag = "type", rename_all = "camelCase")]
4798pub enum ParsedCommand {
4799    Read {
4800        cmd: String,
4801        name: String,
4802        path: String,
4803    },
4804    List_files {
4805        cmd: String,
4806        #[serde(default, skip_serializing_if = "Option::is_none")]
4807        path: Option<String>,
4808    },
4809    Search {
4810        cmd: String,
4811        #[serde(default, skip_serializing_if = "Option::is_none")]
4812        path: Option<String>,
4813        #[serde(default, skip_serializing_if = "Option::is_none")]
4814        query: Option<String>,
4815    },
4816    Unknown {
4817        cmd: String,
4818    },
4819}
4820
4821#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4822pub enum PatchApplyStatus {
4823    #[serde(rename = "inProgress")]
4824    InProgress,
4825    #[serde(rename = "completed")]
4826    Completed,
4827    #[serde(rename = "failed")]
4828    Failed,
4829    #[serde(rename = "declined")]
4830    Declined,
4831}
4832
4833#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4834#[serde(tag = "type", rename_all = "camelCase")]
4835pub enum PatchChangeKind {
4836    Add,
4837    Delete,
4838    Update {
4839        #[serde(default, skip_serializing_if = "Option::is_none")]
4840        move_path: Option<String>,
4841    },
4842}
4843
4844#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4845pub enum PermissionGrantScope {
4846    #[serde(rename = "turn")]
4847    Turn,
4848    #[serde(rename = "session")]
4849    Session,
4850}
4851
4852#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4853#[serde(rename_all = "camelCase")]
4854pub struct PermissionProfileListParams {
4855    #[serde(default, skip_serializing_if = "Option::is_none")]
4856    pub cursor: Option<String>,
4857    #[serde(default, skip_serializing_if = "Option::is_none")]
4858    pub cwd: Option<String>,
4859    #[serde(default, skip_serializing_if = "Option::is_none")]
4860    pub limit: Option<i64>,
4861}
4862
4863#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4864#[serde(rename_all = "camelCase")]
4865pub struct PermissionProfileListResponse {
4866    #[serde(default)]
4867    pub data: Vec<PermissionProfileSummary>,
4868    #[serde(
4869        rename = "nextCursor",
4870        default,
4871        skip_serializing_if = "Option::is_none"
4872    )]
4873    pub next_cursor: Option<String>,
4874}
4875
4876#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4877#[serde(rename_all = "camelCase")]
4878pub struct PermissionProfileSummary {
4879    #[serde(default)]
4880    pub allowed: bool,
4881    #[serde(default, skip_serializing_if = "Option::is_none")]
4882    pub description: Option<String>,
4883    #[serde(default)]
4884    pub id: String,
4885}
4886
4887#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4888#[serde(rename_all = "camelCase")]
4889pub struct PermissionsRequestApprovalParams {
4890    #[serde()]
4891    pub cwd: LegacyAppPathString,
4892    #[serde(
4893        rename = "environmentId",
4894        default,
4895        skip_serializing_if = "Option::is_none"
4896    )]
4897    pub environment_id: Option<String>,
4898    #[serde(rename = "itemId", default)]
4899    pub item_id: String,
4900    #[serde()]
4901    pub permissions: RequestPermissionProfile,
4902    #[serde(default, skip_serializing_if = "Option::is_none")]
4903    pub reason: Option<String>,
4904    #[serde(rename = "startedAtMs", default)]
4905    pub started_at_ms: i64,
4906    #[serde(rename = "threadId", default)]
4907    pub thread_id: String,
4908    #[serde(rename = "turnId", default)]
4909    pub turn_id: String,
4910}
4911
4912#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4913#[serde(rename_all = "camelCase")]
4914pub struct PermissionsRequestApprovalResponse {
4915    #[serde()]
4916    pub permissions: GrantedPermissionProfile,
4917    #[serde(default, skip_serializing_if = "Option::is_none")]
4918    pub scope: Option<Value>,
4919    #[serde(
4920        rename = "strictAutoReview",
4921        default,
4922        skip_serializing_if = "Option::is_none"
4923    )]
4924    pub strict_auto_review: Option<bool>,
4925}
4926
4927#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4928pub enum Personality {
4929    #[serde(rename = "none")]
4930    None,
4931    #[serde(rename = "friendly")]
4932    Friendly,
4933    #[serde(rename = "pragmatic")]
4934    Pragmatic,
4935}
4936
4937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4938#[serde(rename_all = "camelCase")]
4939pub struct PlanDeltaNotification {
4940    #[serde(default)]
4941    pub delta: String,
4942    #[serde(rename = "itemId", default)]
4943    pub item_id: String,
4944    #[serde(rename = "threadId", default)]
4945    pub thread_id: String,
4946    #[serde(rename = "turnId", default)]
4947    pub turn_id: String,
4948}
4949
4950#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4951pub enum PlanType {
4952    #[serde(rename = "free")]
4953    Free,
4954    #[serde(rename = "go")]
4955    Go,
4956    #[serde(rename = "plus")]
4957    Plus,
4958    #[serde(rename = "pro")]
4959    Pro,
4960    #[serde(rename = "prolite")]
4961    Prolite,
4962    #[serde(rename = "edu_plus")]
4963    Edu_plus,
4964    #[serde(rename = "edu_pro")]
4965    Edu_pro,
4966    #[serde(rename = "team")]
4967    Team,
4968    #[serde(rename = "self_serve_business_prolite")]
4969    Self_serve_business_prolite,
4970    #[serde(rename = "self_serve_business_usage_based")]
4971    Self_serve_business_usage_based,
4972    #[serde(rename = "business")]
4973    Business,
4974    #[serde(rename = "ent26")]
4975    Ent26,
4976    #[serde(rename = "enterprise_cbp_automation")]
4977    Enterprise_cbp_automation,
4978    #[serde(rename = "enterprise_cbp_usage_based")]
4979    Enterprise_cbp_usage_based,
4980    #[serde(rename = "enterprise")]
4981    Enterprise,
4982    #[serde(rename = "edu")]
4983    Edu,
4984    #[serde(rename = "unknown")]
4985    Unknown,
4986}
4987
4988#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4989pub enum PluginAuthPolicy {
4990    #[serde(rename = "ON_INSTALL")]
4991    ON_INSTALL,
4992    #[serde(rename = "ON_USE")]
4993    ON_USE,
4994}
4995
4996#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4997pub enum PluginAvailability {
4998    #[serde(rename = "DISABLED_BY_ADMIN")]
4999    DISABLEDBYADMIN,
5000    AVAILABLE,
5001}
5002
5003#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5004#[serde(rename_all = "camelCase")]
5005pub struct PluginDetail {
5006    #[serde(rename = "appTemplates", default)]
5007    pub app_templates: Vec<AppTemplateSummary>,
5008    #[serde(default)]
5009    pub apps: Vec<AppSummary>,
5010    #[serde(default, skip_serializing_if = "Option::is_none")]
5011    pub description: Option<String>,
5012    #[serde(default)]
5013    pub hooks: Vec<PluginHookSummary>,
5014    #[serde(rename = "marketplaceName", default)]
5015    pub marketplace_name: String,
5016    #[serde(
5017        rename = "marketplacePath",
5018        default,
5019        skip_serializing_if = "Option::is_none"
5020    )]
5021    pub marketplace_path: Option<AbsolutePathBuf>,
5022    #[serde(rename = "mcpServers", default)]
5023    pub mcp_servers: Vec<String>,
5024    #[serde(
5025        rename = "scheduledTasks",
5026        default,
5027        skip_serializing_if = "Option::is_none"
5028    )]
5029    pub scheduled_tasks: Option<Vec<ScheduledTaskSummary>>,
5030    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5031    pub share_url: Option<String>,
5032    #[serde(default)]
5033    pub skills: Vec<SkillSummary>,
5034    #[serde()]
5035    pub summary: PluginSummary,
5036}
5037
5038#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5039pub enum PluginDisabledReason {
5040    #[serde(rename = "disabled_by_admin")]
5041    Disabled_by_admin,
5042    #[serde(rename = "plan_not_eligible")]
5043    Plan_not_eligible,
5044    #[serde(rename = "required_app_unavailable")]
5045    Required_app_unavailable,
5046    #[serde(rename = "unknown")]
5047    Unknown,
5048}
5049
5050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5051#[serde(rename_all = "camelCase")]
5052pub struct PluginHookSummary {
5053    #[serde(rename = "eventName")]
5054    pub event_name: HookEventName,
5055    #[serde(default)]
5056    pub key: String,
5057}
5058
5059#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5060#[serde(rename_all = "camelCase")]
5061pub struct PluginInstallParams {
5062    #[serde(
5063        rename = "installAttemptId",
5064        default,
5065        skip_serializing_if = "Option::is_none"
5066    )]
5067    pub install_attempt_id: Option<String>,
5068    #[serde(
5069        rename = "marketplacePath",
5070        default,
5071        skip_serializing_if = "Option::is_none"
5072    )]
5073    pub marketplace_path: Option<AbsolutePathBuf>,
5074    #[serde(rename = "pluginName", default)]
5075    pub plugin_name: String,
5076    #[serde(
5077        rename = "remoteMarketplaceName",
5078        default,
5079        skip_serializing_if = "Option::is_none"
5080    )]
5081    pub remote_marketplace_name: Option<String>,
5082}
5083
5084#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5085pub enum PluginInstallPolicy {
5086    #[serde(rename = "NOT_AVAILABLE")]
5087    NOT_AVAILABLE,
5088    #[serde(rename = "AVAILABLE")]
5089    AVAILABLE,
5090    #[serde(rename = "INSTALLED_BY_DEFAULT")]
5091    INSTALLED_BY_DEFAULT,
5092}
5093
5094#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5095pub enum PluginInstallPolicySource {
5096    #[serde(rename = "WORKSPACE_SETTING")]
5097    WORKSPACE_SETTING,
5098    #[serde(rename = "IMPLICIT_CANONICAL_APP")]
5099    IMPLICIT_CANONICAL_APP,
5100}
5101
5102#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5103#[serde(rename_all = "camelCase")]
5104pub struct PluginInstallResponse {
5105    #[serde(rename = "appsNeedingAuth", default)]
5106    pub apps_needing_auth: Vec<AppSummary>,
5107    #[serde(rename = "authPolicy")]
5108    pub auth_policy: PluginAuthPolicy,
5109}
5110
5111#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5112#[serde(rename_all = "camelCase")]
5113pub struct PluginInstalledParams {
5114    #[serde(default, skip_serializing_if = "Option::is_none")]
5115    pub cwds: Option<Vec<AbsolutePathBuf>>,
5116    #[serde(
5117        rename = "installSuggestionPluginNames",
5118        default,
5119        skip_serializing_if = "Option::is_none"
5120    )]
5121    pub install_suggestion_plugin_names: Option<Vec<String>>,
5122}
5123
5124#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5125#[serde(rename_all = "camelCase")]
5126pub struct PluginInstalledResponse {
5127    #[serde(
5128        rename = "marketplaceLoadErrors",
5129        default,
5130        skip_serializing_if = "Option::is_none"
5131    )]
5132    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5133    #[serde(default)]
5134    pub marketplaces: Vec<PluginMarketplaceEntry>,
5135}
5136
5137#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5138#[serde(rename_all = "camelCase")]
5139pub struct PluginInterface {
5140    #[serde(
5141        rename = "brandColor",
5142        default,
5143        skip_serializing_if = "Option::is_none"
5144    )]
5145    pub brand_color: Option<String>,
5146    #[serde(default)]
5147    pub capabilities: Vec<String>,
5148    #[serde(default, skip_serializing_if = "Option::is_none")]
5149    pub category: Option<String>,
5150    #[serde(
5151        rename = "composerIcon",
5152        default,
5153        skip_serializing_if = "Option::is_none"
5154    )]
5155    pub composer_icon: Option<AbsolutePathBuf>,
5156    #[serde(
5157        rename = "composerIconUrl",
5158        default,
5159        skip_serializing_if = "Option::is_none"
5160    )]
5161    pub composer_icon_url: Option<String>,
5162    #[serde(
5163        rename = "defaultPrompt",
5164        default,
5165        skip_serializing_if = "Option::is_none"
5166    )]
5167    pub default_prompt: Option<Vec<String>>,
5168    #[serde(
5169        rename = "developerName",
5170        default,
5171        skip_serializing_if = "Option::is_none"
5172    )]
5173    pub developer_name: Option<String>,
5174    #[serde(
5175        rename = "displayName",
5176        default,
5177        skip_serializing_if = "Option::is_none"
5178    )]
5179    pub display_name: Option<String>,
5180    #[serde(default, skip_serializing_if = "Option::is_none")]
5181    pub logo: Option<AbsolutePathBuf>,
5182    #[serde(rename = "logoDark", default, skip_serializing_if = "Option::is_none")]
5183    pub logo_dark: Option<AbsolutePathBuf>,
5184    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
5185    pub logo_url: Option<String>,
5186    #[serde(
5187        rename = "logoUrlDark",
5188        default,
5189        skip_serializing_if = "Option::is_none"
5190    )]
5191    pub logo_url_dark: Option<String>,
5192    #[serde(
5193        rename = "longDescription",
5194        default,
5195        skip_serializing_if = "Option::is_none"
5196    )]
5197    pub long_description: Option<String>,
5198    #[serde(
5199        rename = "privacyPolicyUrl",
5200        default,
5201        skip_serializing_if = "Option::is_none"
5202    )]
5203    pub privacy_policy_url: Option<String>,
5204    #[serde(rename = "screenshotUrls", default)]
5205    pub screenshot_urls: Vec<String>,
5206    #[serde(default)]
5207    pub screenshots: Vec<AbsolutePathBuf>,
5208    #[serde(
5209        rename = "shortDescription",
5210        default,
5211        skip_serializing_if = "Option::is_none"
5212    )]
5213    pub short_description: Option<String>,
5214    #[serde(
5215        rename = "termsOfServiceUrl",
5216        default,
5217        skip_serializing_if = "Option::is_none"
5218    )]
5219    pub terms_of_service_url: Option<String>,
5220    #[serde(
5221        rename = "websiteUrl",
5222        default,
5223        skip_serializing_if = "Option::is_none"
5224    )]
5225    pub website_url: Option<String>,
5226}
5227
5228#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5229pub enum PluginListMarketplaceKind {
5230    #[serde(rename = "local")]
5231    Local,
5232    #[serde(rename = "vertical")]
5233    Vertical,
5234    #[serde(rename = "workspace-directory")]
5235    Workspace_directory,
5236    #[serde(rename = "shared-with-me")]
5237    Shared_with_me,
5238    #[serde(rename = "created-by-me-remote")]
5239    Created_by_me_remote,
5240}
5241
5242#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5243#[serde(rename_all = "camelCase")]
5244pub struct PluginListParams {
5245    #[serde(default, skip_serializing_if = "Option::is_none")]
5246    pub cwds: Option<Vec<AbsolutePathBuf>>,
5247    #[serde(
5248        rename = "forceRefetch",
5249        default,
5250        skip_serializing_if = "Option::is_none"
5251    )]
5252    pub force_refetch: Option<bool>,
5253    #[serde(
5254        rename = "marketplaceKinds",
5255        default,
5256        skip_serializing_if = "Option::is_none"
5257    )]
5258    pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
5259}
5260
5261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5262#[serde(rename_all = "camelCase")]
5263pub struct PluginListResponse {
5264    #[serde(
5265        rename = "featuredPluginIds",
5266        default,
5267        skip_serializing_if = "Option::is_none"
5268    )]
5269    pub featured_plugin_ids: Option<Vec<String>>,
5270    #[serde(
5271        rename = "marketplaceLoadErrors",
5272        default,
5273        skip_serializing_if = "Option::is_none"
5274    )]
5275    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5276    #[serde(default)]
5277    pub marketplaces: Vec<PluginMarketplaceEntry>,
5278}
5279
5280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5281#[serde(rename_all = "camelCase")]
5282pub struct PluginMarketplaceEntry {
5283    #[serde(default, skip_serializing_if = "Option::is_none")]
5284    pub interface: Option<MarketplaceInterface>,
5285    #[serde(default)]
5286    pub name: String,
5287    #[serde(default, skip_serializing_if = "Option::is_none")]
5288    pub path: Option<AbsolutePathBuf>,
5289    #[serde(default)]
5290    pub plugins: Vec<PluginSummary>,
5291}
5292
5293#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5294#[serde(rename_all = "camelCase")]
5295pub struct PluginReadParams {
5296    #[serde(
5297        rename = "marketplacePath",
5298        default,
5299        skip_serializing_if = "Option::is_none"
5300    )]
5301    pub marketplace_path: Option<AbsolutePathBuf>,
5302    #[serde(rename = "pluginName", default)]
5303    pub plugin_name: String,
5304    #[serde(
5305        rename = "remoteMarketplaceName",
5306        default,
5307        skip_serializing_if = "Option::is_none"
5308    )]
5309    pub remote_marketplace_name: Option<String>,
5310}
5311
5312#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5313#[serde(rename_all = "camelCase")]
5314pub struct PluginReadResponse {
5315    #[serde()]
5316    pub plugin: PluginDetail,
5317}
5318
5319/// Runtime categories affected by this change, not just capabilities
5320/// currently present. Flags describe declarations before runtime policy
5321/// filtering. Updates OR the old and new bundle flags; enablement changes and
5322/// cached reinstalls use the cached bundle; removals retain the old bundle's
5323/// flags.
5324#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5325#[serde(rename_all = "camelCase")]
5326pub struct PluginReconcileChangedPlugin {
5327    #[serde(rename = "hasApps", default)]
5328    pub has_apps: bool,
5329    #[serde(rename = "hasHooks", default)]
5330    pub has_hooks: bool,
5331    #[serde(rename = "hasMcps", default)]
5332    pub has_mcps: bool,
5333    /// Whether either bundle declares skill roots; not a validated inventory
5334    /// of enabled skills.
5335    #[serde(rename = "hasSkills", default)]
5336    pub has_skills: bool,
5337    /// Local plugin ID (`name@marketplace`), matching `PluginSummary.id`.
5338    #[serde(default)]
5339    pub id: String,
5340}
5341
5342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5343#[serde(rename_all = "camelCase")]
5344pub struct PluginReconcileParams {
5345    /// Optional client-provided reason recorded with the reconciliation
5346    /// attempt.
5347    #[serde(default, skip_serializing_if = "Option::is_none")]
5348    pub reason: Option<String>,
5349}
5350
5351/// Bundle and installed-state changes observed by this pass, not a
5352/// runtime-readiness acknowledgement or a cumulative diff since the client's
5353/// last request. Other metadata-only changes are not listed.
5354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5355#[serde(rename_all = "camelCase")]
5356pub struct PluginReconcileResponse {
5357    /// Plugins affected by bundle changes, enablement changes, or removals.
5358    /// Installed-state changes compare against the previous cached snapshot,
5359    /// including cached reinstalls. Removal hints survive cache cleanup
5360    /// failures; unchanged plugins are omitted.
5361    #[serde(rename = "changedPlugins", default)]
5362    pub changed_plugins: Vec<PluginReconcileChangedPlugin>,
5363    /// Subset of failures for which the requested bundle could not be
5364    /// materialized. A previously cached version may still be available.
5365    #[serde(rename = "failedMaterializationRemotePluginIds", default)]
5366    pub failed_materialization_remote_plugin_ids: Vec<String>,
5367    /// Backend remote plugin IDs whose bundle or identity update failed.
5368    #[serde(rename = "failedRemotePluginIds", default)]
5369    pub failed_remote_plugin_ids: Vec<String>,
5370}
5371
5372#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5373#[serde(rename_all = "camelCase")]
5374pub struct PluginShareCheckoutParams {
5375    #[serde(rename = "remotePluginId", default)]
5376    pub remote_plugin_id: String,
5377}
5378
5379#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5380#[serde(rename_all = "camelCase")]
5381pub struct PluginShareCheckoutResponse {
5382    #[serde(rename = "marketplaceName", default)]
5383    pub marketplace_name: String,
5384    #[serde(rename = "marketplacePath")]
5385    pub marketplace_path: AbsolutePathBuf,
5386    #[serde(rename = "pluginId", default)]
5387    pub plugin_id: String,
5388    #[serde(rename = "pluginName", default)]
5389    pub plugin_name: String,
5390    #[serde(rename = "pluginPath")]
5391    pub plugin_path: AbsolutePathBuf,
5392    #[serde(rename = "remotePluginId", default)]
5393    pub remote_plugin_id: String,
5394    #[serde(
5395        rename = "remoteVersion",
5396        default,
5397        skip_serializing_if = "Option::is_none"
5398    )]
5399    pub remote_version: Option<String>,
5400}
5401
5402#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5403#[serde(rename_all = "camelCase")]
5404pub struct PluginShareContext {
5405    #[serde(
5406        rename = "canPublishToWorkspace",
5407        default,
5408        skip_serializing_if = "Option::is_none"
5409    )]
5410    pub can_publish_to_workspace: Option<bool>,
5411    #[serde(
5412        rename = "creatorAccountUserId",
5413        default,
5414        skip_serializing_if = "Option::is_none"
5415    )]
5416    pub creator_account_user_id: Option<String>,
5417    #[serde(
5418        rename = "creatorName",
5419        default,
5420        skip_serializing_if = "Option::is_none"
5421    )]
5422    pub creator_name: Option<String>,
5423    #[serde(default, skip_serializing_if = "Option::is_none")]
5424    pub discoverability: Option<PluginShareDiscoverability>,
5425    #[serde(rename = "remotePluginId", default)]
5426    pub remote_plugin_id: String,
5427    #[serde(
5428        rename = "remoteVersion",
5429        default,
5430        skip_serializing_if = "Option::is_none"
5431    )]
5432    pub remote_version: Option<String>,
5433    #[serde(
5434        rename = "sharePrincipals",
5435        default,
5436        skip_serializing_if = "Option::is_none"
5437    )]
5438    pub share_principals: Option<Vec<PluginSharePrincipal>>,
5439    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5440    pub share_url: Option<String>,
5441}
5442
5443#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5444#[serde(rename_all = "camelCase")]
5445pub struct PluginShareDeleteParams {
5446    #[serde(rename = "remotePluginId", default)]
5447    pub remote_plugin_id: String,
5448}
5449
5450#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5451#[serde(rename_all = "camelCase")]
5452pub struct PluginShareDeleteResponse {
5453    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5454    pub extra: serde_json::Map<String, Value>,
5455}
5456
5457#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5458pub enum PluginShareDiscoverability {
5459    #[serde(rename = "LISTED")]
5460    LISTED,
5461    #[serde(rename = "UNLISTED")]
5462    UNLISTED,
5463    #[serde(rename = "PRIVATE")]
5464    PRIVATE,
5465}
5466
5467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5468#[serde(rename_all = "camelCase")]
5469pub struct PluginShareListItem {
5470    #[serde(
5471        rename = "localPluginPath",
5472        default,
5473        skip_serializing_if = "Option::is_none"
5474    )]
5475    pub local_plugin_path: Option<AbsolutePathBuf>,
5476    #[serde()]
5477    pub plugin: PluginSummary,
5478}
5479
5480#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5481#[serde(rename_all = "camelCase")]
5482pub struct PluginShareListParams {
5483    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5484    pub extra: serde_json::Map<String, Value>,
5485}
5486
5487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5488#[serde(rename_all = "camelCase")]
5489pub struct PluginShareListResponse {
5490    #[serde(default)]
5491    pub data: Vec<PluginShareListItem>,
5492}
5493
5494#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5495#[serde(rename_all = "camelCase")]
5496pub struct PluginSharePrincipal {
5497    #[serde(default)]
5498    pub name: String,
5499    #[serde(rename = "principalId", default)]
5500    pub principal_id: String,
5501    #[serde(rename = "principalType")]
5502    pub principal_type: PluginSharePrincipalType,
5503    #[serde()]
5504    pub role: PluginSharePrincipalRole,
5505}
5506
5507#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5508pub enum PluginSharePrincipalRole {
5509    #[serde(rename = "reader")]
5510    Reader,
5511    #[serde(rename = "editor")]
5512    Editor,
5513    #[serde(rename = "owner")]
5514    Owner,
5515}
5516
5517#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5518pub enum PluginSharePrincipalType {
5519    #[serde(rename = "user")]
5520    User,
5521    #[serde(rename = "group")]
5522    Group,
5523    #[serde(rename = "workspace")]
5524    Workspace,
5525}
5526
5527#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5528#[serde(rename_all = "camelCase")]
5529pub struct PluginShareSaveParams {
5530    #[serde(default, skip_serializing_if = "Option::is_none")]
5531    pub discoverability: Option<PluginShareDiscoverability>,
5532    #[serde(rename = "pluginPath")]
5533    pub plugin_path: AbsolutePathBuf,
5534    #[serde(
5535        rename = "remotePluginId",
5536        default,
5537        skip_serializing_if = "Option::is_none"
5538    )]
5539    pub remote_plugin_id: Option<String>,
5540    #[serde(
5541        rename = "shareTargets",
5542        default,
5543        skip_serializing_if = "Option::is_none"
5544    )]
5545    pub share_targets: Option<Vec<PluginShareTarget>>,
5546}
5547
5548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5549#[serde(rename_all = "camelCase")]
5550pub struct PluginShareSaveResponse {
5551    #[serde(
5552        rename = "canPublishToWorkspace",
5553        default,
5554        skip_serializing_if = "Option::is_none"
5555    )]
5556    pub can_publish_to_workspace: Option<bool>,
5557    #[serde(rename = "remotePluginId", default)]
5558    pub remote_plugin_id: String,
5559    #[serde(rename = "shareUrl", default)]
5560    pub share_url: String,
5561}
5562
5563#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5564#[serde(rename_all = "camelCase")]
5565pub struct PluginShareTarget {
5566    #[serde(rename = "principalId", default)]
5567    pub principal_id: String,
5568    #[serde(rename = "principalType")]
5569    pub principal_type: PluginSharePrincipalType,
5570    #[serde()]
5571    pub role: PluginShareTargetRole,
5572}
5573
5574#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5575pub enum PluginShareTargetRole {
5576    #[serde(rename = "reader")]
5577    Reader,
5578    #[serde(rename = "editor")]
5579    Editor,
5580}
5581
5582#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5583pub enum PluginShareUpdateDiscoverability {
5584    #[serde(rename = "UNLISTED")]
5585    UNLISTED,
5586    #[serde(rename = "PRIVATE")]
5587    PRIVATE,
5588    #[serde(rename = "LISTED")]
5589    LISTED,
5590}
5591
5592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5593#[serde(rename_all = "camelCase")]
5594pub struct PluginShareUpdateTargetsParams {
5595    #[serde()]
5596    pub discoverability: PluginShareUpdateDiscoverability,
5597    #[serde(rename = "remotePluginId", default)]
5598    pub remote_plugin_id: String,
5599    #[serde(rename = "shareTargets", default)]
5600    pub share_targets: Vec<PluginShareTarget>,
5601}
5602
5603#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5604#[serde(rename_all = "camelCase")]
5605pub struct PluginShareUpdateTargetsResponse {
5606    #[serde()]
5607    pub discoverability: PluginShareDiscoverability,
5608    #[serde(default)]
5609    pub principals: Vec<PluginSharePrincipal>,
5610}
5611
5612#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5613#[serde(rename_all = "camelCase")]
5614pub struct PluginSkillReadParams {
5615    #[serde(rename = "remoteMarketplaceName", default)]
5616    pub remote_marketplace_name: String,
5617    #[serde(rename = "remotePluginId", default)]
5618    pub remote_plugin_id: String,
5619    #[serde(rename = "skillName", default)]
5620    pub skill_name: String,
5621}
5622
5623#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5624#[serde(rename_all = "camelCase")]
5625pub struct PluginSkillReadResponse {
5626    #[serde(default, skip_serializing_if = "Option::is_none")]
5627    pub contents: Option<String>,
5628}
5629
5630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5631#[serde(tag = "type", rename_all = "camelCase")]
5632pub enum PluginSource {
5633    Local {
5634        path: AbsolutePathBuf,
5635    },
5636    Git {
5637        #[serde(default, skip_serializing_if = "Option::is_none")]
5638        path: Option<String>,
5639        #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
5640        ref_name: Option<String>,
5641        #[serde(default, skip_serializing_if = "Option::is_none")]
5642        sha: Option<String>,
5643        url: String,
5644    },
5645    Npm {
5646        package: String,
5647        #[serde(default, skip_serializing_if = "Option::is_none")]
5648        registry: Option<String>,
5649        #[serde(default, skip_serializing_if = "Option::is_none")]
5650        version: Option<String>,
5651    },
5652    Remote,
5653}
5654
5655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5656#[serde(rename_all = "camelCase")]
5657pub struct PluginSummary {
5658    #[serde(rename = "authPolicy")]
5659    pub auth_policy: PluginAuthPolicy,
5660    #[serde(default, skip_serializing_if = "Option::is_none")]
5661    pub availability: Option<Value>,
5662    #[serde(
5663        rename = "disabledReason",
5664        default,
5665        skip_serializing_if = "Option::is_none"
5666    )]
5667    pub disabled_reason: Option<PluginDisabledReason>,
5668    #[serde(
5669        rename = "eligiblePlanTypes",
5670        default,
5671        skip_serializing_if = "Option::is_none"
5672    )]
5673    pub eligible_plan_types: Option<Vec<String>>,
5674    #[serde(default)]
5675    pub enabled: bool,
5676    #[serde(default)]
5677    pub id: String,
5678    #[serde(rename = "installPolicy")]
5679    pub install_policy: PluginInstallPolicy,
5680    #[serde(
5681        rename = "installPolicySource",
5682        default,
5683        skip_serializing_if = "Option::is_none"
5684    )]
5685    pub install_policy_source: Option<PluginInstallPolicySource>,
5686    #[serde(default)]
5687    pub installed: bool,
5688    #[serde(
5689        rename = "installedAt",
5690        default,
5691        skip_serializing_if = "Option::is_none"
5692    )]
5693    pub installed_at: Option<i64>,
5694    #[serde(default, skip_serializing_if = "Option::is_none")]
5695    pub interface: Option<PluginInterface>,
5696    #[serde(default, skip_serializing_if = "Option::is_none")]
5697    pub keywords: Option<Vec<String>>,
5698    #[serde(
5699        rename = "localVersion",
5700        default,
5701        skip_serializing_if = "Option::is_none"
5702    )]
5703    pub local_version: Option<String>,
5704    #[serde(
5705        rename = "mustShowInstallationInterstitial",
5706        default,
5707        skip_serializing_if = "Option::is_none"
5708    )]
5709    pub must_show_installation_interstitial: Option<bool>,
5710    #[serde(default)]
5711    pub name: String,
5712    #[serde(
5713        rename = "remotePluginId",
5714        default,
5715        skip_serializing_if = "Option::is_none"
5716    )]
5717    pub remote_plugin_id: Option<String>,
5718    #[serde(
5719        rename = "shareContext",
5720        default,
5721        skip_serializing_if = "Option::is_none"
5722    )]
5723    pub share_context: Option<PluginShareContext>,
5724    #[serde()]
5725    pub source: PluginSource,
5726    #[serde(default, skip_serializing_if = "Option::is_none")]
5727    pub version: Option<String>,
5728}
5729
5730#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5731#[serde(rename_all = "camelCase")]
5732pub struct PluginUninstallParams {
5733    #[serde(rename = "pluginId", default)]
5734    pub plugin_id: String,
5735}
5736
5737#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5738#[serde(rename_all = "camelCase")]
5739pub struct PluginUninstallResponse {
5740    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5741    pub extra: serde_json::Map<String, Value>,
5742}
5743
5744#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5745#[serde(rename_all = "camelCase")]
5746pub struct PluginsMigration {
5747    #[serde(rename = "marketplaceName", default)]
5748    pub marketplace_name: String,
5749    #[serde(rename = "pluginNames", default)]
5750    pub plugin_names: Vec<String>,
5751}
5752
5753#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5754#[serde(rename_all = "camelCase")]
5755pub struct ProcessExitedNotification {
5756    #[serde(rename = "exitCode", default)]
5757    pub exit_code: i64,
5758    #[serde(rename = "processHandle", default)]
5759    pub process_handle: String,
5760    #[serde(default)]
5761    pub stderr: String,
5762    #[serde(rename = "stderrCapReached", default)]
5763    pub stderr_cap_reached: bool,
5764    #[serde(default)]
5765    pub stdout: String,
5766    #[serde(rename = "stdoutCapReached", default)]
5767    pub stdout_cap_reached: bool,
5768}
5769
5770#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5771#[serde(rename_all = "camelCase")]
5772pub struct ProcessOutputDeltaNotification {
5773    #[serde(rename = "capReached", default)]
5774    pub cap_reached: bool,
5775    #[serde(rename = "deltaBase64", default)]
5776    pub delta_base64: String,
5777    #[serde(rename = "processHandle", default)]
5778    pub process_handle: String,
5779    #[serde(default)]
5780    pub stream: Value,
5781}
5782
5783#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5784pub enum ProcessOutputStream {
5785    #[serde(rename = "stdout")]
5786    Stdout,
5787    #[serde(rename = "stderr")]
5788    Stderr,
5789}
5790
5791#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5792pub enum RateLimitReachedType {
5793    #[serde(rename = "rate_limit_reached")]
5794    Rate_limit_reached,
5795    #[serde(rename = "workspace_owner_credits_depleted")]
5796    Workspace_owner_credits_depleted,
5797    #[serde(rename = "workspace_member_credits_depleted")]
5798    Workspace_member_credits_depleted,
5799    #[serde(rename = "workspace_owner_usage_limit_reached")]
5800    Workspace_owner_usage_limit_reached,
5801    #[serde(rename = "workspace_member_usage_limit_reached")]
5802    Workspace_member_usage_limit_reached,
5803}
5804
5805#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5806#[serde(rename_all = "camelCase")]
5807pub struct RateLimitResetCredit {
5808    #[serde(default, skip_serializing_if = "Option::is_none")]
5809    pub description: Option<String>,
5810    #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
5811    pub expires_at: Option<i64>,
5812    #[serde(rename = "grantedAt", default)]
5813    pub granted_at: i64,
5814    #[serde(default)]
5815    pub id: String,
5816    #[serde(rename = "resetType")]
5817    pub reset_type: RateLimitResetType,
5818    #[serde()]
5819    pub status: RateLimitResetCreditStatus,
5820    #[serde(default, skip_serializing_if = "Option::is_none")]
5821    pub title: Option<String>,
5822}
5823
5824#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5825pub enum RateLimitResetCreditStatus {
5826    #[serde(rename = "available")]
5827    Available,
5828    #[serde(rename = "redeeming")]
5829    Redeeming,
5830    #[serde(rename = "redeemed")]
5831    Redeemed,
5832    #[serde(rename = "unknown")]
5833    Unknown,
5834}
5835
5836#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5837#[serde(rename_all = "camelCase")]
5838pub struct RateLimitResetCreditsSummary {
5839    #[serde(rename = "availableCount", default)]
5840    pub available_count: i64,
5841    #[serde(default, skip_serializing_if = "Option::is_none")]
5842    pub credits: Option<Vec<RateLimitResetCredit>>,
5843}
5844
5845#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5846pub enum RateLimitResetType {
5847    #[serde(rename = "codexRateLimits")]
5848    CodexRateLimits,
5849    #[serde(rename = "unknown")]
5850    Unknown,
5851}
5852
5853#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5854#[serde(rename_all = "camelCase")]
5855pub struct RateLimitSnapshot {
5856    #[serde(default, skip_serializing_if = "Option::is_none")]
5857    pub credits: Option<CreditsSnapshot>,
5858    #[serde(
5859        rename = "individualLimit",
5860        default,
5861        skip_serializing_if = "Option::is_none"
5862    )]
5863    pub individual_limit: Option<SpendControlLimitSnapshot>,
5864    #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
5865    pub limit_id: Option<String>,
5866    #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
5867    pub limit_name: Option<String>,
5868    /// Normal model whose display name and reasoning options describe this
5869    /// quota alias.
5870    #[serde(
5871        rename = "normalModelSlug",
5872        default,
5873        skip_serializing_if = "Option::is_none"
5874    )]
5875    pub normal_model_slug: Option<String>,
5876    #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
5877    pub plan_type: Option<PlanType>,
5878    #[serde(default, skip_serializing_if = "Option::is_none")]
5879    pub primary: Option<RateLimitWindow>,
5880    #[serde(
5881        rename = "rateLimitReachedType",
5882        default,
5883        skip_serializing_if = "Option::is_none"
5884    )]
5885    pub rate_limit_reached_type: Option<RateLimitReachedType>,
5886    #[serde(default, skip_serializing_if = "Option::is_none")]
5887    pub secondary: Option<RateLimitWindow>,
5888    #[serde(
5889        rename = "spendControlReached",
5890        default,
5891        skip_serializing_if = "Option::is_none"
5892    )]
5893    pub spend_control_reached: Option<bool>,
5894}
5895
5896#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5897#[serde(rename_all = "camelCase")]
5898pub struct RateLimitWindow {
5899    #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
5900    pub resets_at: Option<i64>,
5901    #[serde(rename = "usedPercent", default)]
5902    pub used_percent: i64,
5903    #[serde(
5904        rename = "windowDurationMins",
5905        default,
5906        skip_serializing_if = "Option::is_none"
5907    )]
5908    pub window_duration_mins: Option<i64>,
5909}
5910
5911#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5912pub enum RealtimeConversationVersion {
5913    #[serde(rename = "v1")]
5914    V1,
5915    #[serde(rename = "v2")]
5916    V2,
5917    #[serde(rename = "v3")]
5918    V3,
5919}
5920
5921/// A non-empty reasoning effort value advertised by the model.
5922#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
5923#[serde(transparent)]
5924pub struct ReasoningEffort(pub String);
5925
5926#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5927#[serde(rename_all = "camelCase")]
5928pub struct ReasoningEffortOption {
5929    #[serde(default)]
5930    pub description: String,
5931    #[serde(rename = "reasoningEffort")]
5932    pub reasoning_effort: ReasoningEffort,
5933}
5934
5935#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5936pub enum ReasoningSummary {
5937    #[serde(rename = "auto")]
5938    Auto,
5939    #[serde(rename = "concise")]
5940    Concise,
5941    #[serde(rename = "detailed")]
5942    Detailed,
5943    #[serde(rename = "none")]
5944    None,
5945}
5946
5947#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5948#[serde(rename_all = "camelCase")]
5949pub struct ReasoningSummaryPartAddedNotification {
5950    #[serde(rename = "itemId", default)]
5951    pub item_id: String,
5952    #[serde(rename = "summaryIndex", default)]
5953    pub summary_index: i64,
5954    #[serde(rename = "threadId", default)]
5955    pub thread_id: String,
5956    #[serde(rename = "turnId", default)]
5957    pub turn_id: String,
5958}
5959
5960#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5961#[serde(rename_all = "camelCase")]
5962pub struct ReasoningSummaryTextDeltaNotification {
5963    #[serde(default)]
5964    pub delta: String,
5965    #[serde(rename = "itemId", default)]
5966    pub item_id: String,
5967    #[serde(rename = "summaryIndex", default)]
5968    pub summary_index: i64,
5969    #[serde(rename = "threadId", default)]
5970    pub thread_id: String,
5971    #[serde(rename = "turnId", default)]
5972    pub turn_id: String,
5973}
5974
5975#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5976#[serde(rename_all = "camelCase")]
5977pub struct ReasoningTextDeltaNotification {
5978    #[serde(rename = "contentIndex", default)]
5979    pub content_index: i64,
5980    #[serde(default)]
5981    pub delta: String,
5982    #[serde(rename = "itemId", default)]
5983    pub item_id: String,
5984    #[serde(rename = "threadId", default)]
5985    pub thread_id: String,
5986    #[serde(rename = "turnId", default)]
5987    pub turn_id: String,
5988}
5989
5990#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5991pub enum RemoteControlConnectionStatus {
5992    #[serde(rename = "disabled")]
5993    Disabled,
5994    #[serde(rename = "connecting")]
5995    Connecting,
5996    #[serde(rename = "connected")]
5997    Connected,
5998    #[serde(rename = "errored")]
5999    Errored,
6000}
6001
6002#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6003#[serde(rename_all = "camelCase")]
6004pub struct RemoteControlStatusChangedNotification {
6005    #[serde(
6006        rename = "environmentId",
6007        default,
6008        skip_serializing_if = "Option::is_none"
6009    )]
6010    pub environment_id: Option<String>,
6011    #[serde(rename = "installationId", default)]
6012    pub installation_id: String,
6013    #[serde(rename = "serverName", default)]
6014    pub server_name: String,
6015    #[serde()]
6016    pub status: RemoteControlConnectionStatus,
6017}
6018
6019#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6020#[serde(untagged)]
6021pub enum RequestId {
6022    Variant0(String),
6023    Variant1(i64),
6024}
6025
6026#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6027#[serde(rename_all = "camelCase")]
6028pub struct RequestPermissionProfile {
6029    #[serde(
6030        rename = "fileSystem",
6031        default,
6032        skip_serializing_if = "Option::is_none"
6033    )]
6034    pub file_system: Option<AdditionalFileSystemPermissions>,
6035    #[serde(default, skip_serializing_if = "Option::is_none")]
6036    pub network: Option<AdditionalNetworkPermissions>,
6037}
6038
6039#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6040pub enum ResidencyRequirement {
6041    #[serde(rename = "us")]
6042    Us,
6043}
6044
6045#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6046#[serde(rename_all = "camelCase")]
6047pub struct Resource {
6048    #[serde(default, skip_serializing_if = "Option::is_none")]
6049    pub _meta: Option<Value>,
6050    #[serde(default, skip_serializing_if = "Option::is_none")]
6051    pub annotations: Option<Value>,
6052    #[serde(default, skip_serializing_if = "Option::is_none")]
6053    pub description: Option<String>,
6054    #[serde(default, skip_serializing_if = "Option::is_none")]
6055    pub icons: Option<Vec<Value>>,
6056    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6057    pub mime_type: Option<String>,
6058    #[serde(default)]
6059    pub name: String,
6060    #[serde(default, skip_serializing_if = "Option::is_none")]
6061    pub size: Option<i64>,
6062    #[serde(default, skip_serializing_if = "Option::is_none")]
6063    pub title: Option<String>,
6064    #[serde(default)]
6065    pub uri: String,
6066}
6067
6068#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6069#[serde(untagged)]
6070pub enum ResourceContent {
6071    Variant0(Value),
6072    Variant1(Value),
6073}
6074
6075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6076#[serde(rename_all = "camelCase")]
6077pub struct ResourceTemplate {
6078    #[serde(default, skip_serializing_if = "Option::is_none")]
6079    pub annotations: Option<Value>,
6080    #[serde(default, skip_serializing_if = "Option::is_none")]
6081    pub description: Option<String>,
6082    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6083    pub mime_type: Option<String>,
6084    #[serde(default)]
6085    pub name: String,
6086    #[serde(default, skip_serializing_if = "Option::is_none")]
6087    pub title: Option<String>,
6088    #[serde(rename = "uriTemplate", default)]
6089    pub uri_template: String,
6090}
6091
6092/// Usage metadata reported for one upstream response (0.148 upstream).
6093#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6094#[serde(rename_all = "camelCase")]
6095pub struct ResponseUsageMetadata {
6096    #[serde(default, skip_serializing_if = "Option::is_none")]
6097    pub amount: Option<String>,
6098    #[serde(default, skip_serializing_if = "Option::is_none")]
6099    pub metadata: Option<Value>,
6100}
6101
6102#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6103pub enum ReviewDecision {
6104    #[serde(rename = "approved")]
6105    Approved,
6106    #[serde(rename = "approved_execpolicy_amendment")]
6107    ApprovedExecpolicyAmendment {
6108        proposed_execpolicy_amendment: Vec<String>,
6109    },
6110    #[serde(rename = "approved_for_session")]
6111    ApprovedForSession,
6112    #[serde(rename = "approved_mcp_policy_amendment")]
6113    ApprovedMcpPolicyAmendment,
6114    #[serde(rename = "network_policy_amendment")]
6115    NetworkPolicyAmendment {
6116        network_policy_amendment: NetworkPolicyAmendment,
6117    },
6118    #[serde(rename = "denied")]
6119    Denied { rejection: String },
6120    #[serde(rename = "timed_out")]
6121    TimedOut,
6122    #[serde(rename = "abort")]
6123    Abort,
6124}
6125
6126#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6127pub enum ReviewDelivery {
6128    #[serde(rename = "inline")]
6129    Inline,
6130    #[serde(rename = "detached")]
6131    Detached,
6132}
6133
6134#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6135#[serde(rename_all = "camelCase")]
6136pub struct ReviewStartParams {
6137    #[serde(default, skip_serializing_if = "Option::is_none")]
6138    pub delivery: Option<ReviewDelivery>,
6139    #[serde()]
6140    pub target: ReviewTarget,
6141    #[serde(rename = "threadId", default)]
6142    pub thread_id: String,
6143}
6144
6145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6146#[serde(rename_all = "camelCase")]
6147pub struct ReviewStartResponse {
6148    #[serde(rename = "reviewThreadId", default)]
6149    pub review_thread_id: String,
6150    #[serde()]
6151    pub turn: Turn,
6152}
6153
6154#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6155#[serde(tag = "type", rename_all = "camelCase")]
6156pub enum ReviewTarget {
6157    #[serde(rename = "uncommittedChanges")]
6158    UncommittedChanges,
6159    #[serde(rename = "baseBranch")]
6160    BaseBranch {
6161        branch: String,
6162    },
6163    Commit {
6164        sha: String,
6165        #[serde(default, skip_serializing_if = "Option::is_none")]
6166        title: Option<String>,
6167    },
6168    Custom {
6169        instructions: String,
6170    },
6171}
6172
6173/// Delivery mode for an agent message item (0.147: currently only `async`).
6174#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6175pub enum AgentMessageDelivery {
6176    #[serde(rename = "async")]
6177    Async,
6178}
6179
6180/// Where the CLI stores auth credentials.
6181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6182pub enum CliAuthCredentialsStoreMode {
6183    #[serde(rename = "file")]
6184    File,
6185    #[serde(rename = "keyring")]
6186    Keyring,
6187    #[serde(rename = "auto")]
6188    Auto,
6189    #[serde(rename = "ephemeral")]
6190    Ephemeral,
6191}
6192
6193/// A project grouping threads, owned by app-server.
6194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6195pub struct Project {
6196    #[serde(rename = "createdAt", default)]
6197    pub created_at: i64,
6198    #[serde(default)]
6199    pub id: String,
6200    #[serde(default)]
6201    pub metadata: std::collections::HashMap<String, String>,
6202    #[serde(default)]
6203    pub name: String,
6204    #[serde(default)]
6205    pub position: i64,
6206    /// Newest non-archived member thread's recency, in Unix seconds;
6207    /// absent/null when none exist (0.148 upstream).
6208    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
6209    pub recency_at: Option<i64>,
6210    #[serde(default)]
6211    pub roots: Vec<ProjectRoot>,
6212    #[serde(rename = "updatedAt", default)]
6213    pub updated_at: i64,
6214}
6215
6216/// Sort order for project listings (0.148 upstream).
6217#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6218pub enum ProjectSortKey {
6219    #[serde(rename = "position")]
6220    Position,
6221    #[serde(rename = "recencyAt")]
6222    RecencyAt,
6223}
6224
6225#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6226pub enum ProjectChangeType {
6227    #[serde(rename = "created")]
6228    Created,
6229    #[serde(rename = "updated")]
6230    Updated,
6231    #[serde(rename = "deleted")]
6232    Deleted,
6233}
6234
6235/// `project/changed` — a project was created, updated, or deleted.
6236#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6237pub struct ProjectChangedNotification {
6238    #[serde(rename = "changeType")]
6239    pub change_type: ProjectChangeType,
6240    #[serde(rename = "projectId", default)]
6241    pub project_id: String,
6242}
6243
6244#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6245pub struct ProjectRoot {
6246    pub path: AbsolutePathBuf,
6247}
6248
6249/// A user submission waiting in a thread's queue.
6250#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6251pub struct QueuedSubmission {
6252    #[serde(rename = "clientUserMessageId", default)]
6253    pub client_user_message_id: String,
6254    #[serde(default)]
6255    pub id: String,
6256    #[serde(default)]
6257    pub input: Vec<UserInput>,
6258}
6259
6260/// `autoApprovalReview/strictReviewRequired` — a strict review gate opened.
6261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6262pub struct StrictReviewRequiredNotification {
6263    /// Unix timestamp (ms) when this review started.
6264    #[serde(rename = "startedAtMs", default)]
6265    pub started_at_ms: i64,
6266    #[serde(rename = "threadId", default)]
6267    pub thread_id: String,
6268    #[serde(rename = "turnId", default)]
6269    pub turn_id: String,
6270}
6271
6272/// `thread/project/updated` — a thread's project assignment changed.
6273#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6274pub struct ThreadProjectUpdatedNotification {
6275    #[serde(rename = "projectId", default)]
6276    pub project_id: Option<String>,
6277    #[serde(rename = "threadId", default)]
6278    pub thread_id: String,
6279}
6280
6281/// `thread/queue/changed` — the thread's queued submissions changed.
6282#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6283pub struct ThreadQueueChangedNotification {
6284    #[serde(rename = "threadId", default)]
6285    pub thread_id: String,
6286}
6287
6288/// `thread/reverted` — the thread was rolled back.
6289#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6290pub struct ThreadRevertedNotification {
6291    #[serde(rename = "threadId", default)]
6292    pub thread_id: String,
6293}
6294
6295/// In-app browser requirements (0.148 upstream).
6296#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6297#[serde(rename_all = "camelCase")]
6298pub struct InAppBrowserRequirements {
6299    #[serde(
6300        rename = "allowExternalBrowserSettingsImport",
6301        default,
6302        skip_serializing_if = "Option::is_none"
6303    )]
6304    pub allow_external_browser_settings_import: Option<bool>,
6305}
6306
6307/// One MCP-server-originated notification, relayed verbatim.
6308#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6309pub struct McpServerEventNotification {
6310    #[serde(default)]
6311    pub method: String,
6312    #[serde(default)]
6313    pub params: Value,
6314}
6315
6316/// `mcpServer/event/stream/notification` — an MCP server's own
6317/// notification stream, forwarded to subscribers.
6318#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6319pub struct McpServerEventStreamNotification {
6320    pub notification: McpServerEventNotification,
6321    #[serde(rename = "subscriptionId", default)]
6322    pub subscription_id: String,
6323}
6324
6325/// Allow/deny switch used across the browser-use / computer-use policy
6326/// surface (0.148 upstream).
6327#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6328pub enum AllowDenyRequirement {
6329    #[serde(rename = "allow")]
6330    Allow,
6331    #[serde(rename = "deny")]
6332    Deny,
6333}
6334
6335/// How long a granted browser-use access approval lasts.
6336#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6337pub enum BrowserUseAccessApprovalLifetime {
6338    #[serde(rename = "turn")]
6339    Turn,
6340    #[serde(rename = "thread")]
6341    Thread,
6342}
6343
6344/// Current thread-runtime MCP server connection state.
6345#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6346pub enum McpServerConnectionStatus {
6347    #[serde(rename = "notStarted")]
6348    NotStarted,
6349    #[serde(rename = "starting")]
6350    Starting,
6351    #[serde(rename = "connected")]
6352    Connected,
6353    #[serde(rename = "authenticationRequired")]
6354    AuthenticationRequired,
6355    #[serde(rename = "failed")]
6356    Failed,
6357    #[serde(rename = "cancelled")]
6358    Cancelled,
6359    #[serde(rename = "disabled")]
6360    Disabled,
6361}
6362
6363/// Per-origin browser-use policy (requirements side, camelCase wire).
6364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6365#[serde(rename_all = "camelCase")]
6366pub struct BrowserUseOriginPolicy {
6367    #[serde(default, skip_serializing_if = "Option::is_none")]
6368    pub access: Option<AllowDenyRequirement>,
6369    #[serde(
6370        rename = "accessApprovalLifetime",
6371        default,
6372        skip_serializing_if = "Option::is_none"
6373    )]
6374    pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
6375    #[serde(
6376        rename = "autoReview",
6377        default,
6378        skip_serializing_if = "Option::is_none"
6379    )]
6380    pub auto_review: Option<AllowDenyRequirement>,
6381    #[serde(default, skip_serializing_if = "Option::is_none")]
6382    pub downloads: Option<AllowDenyRequirement>,
6383    #[serde(
6384        rename = "fullCdpAccess",
6385        default,
6386        skip_serializing_if = "Option::is_none"
6387    )]
6388    pub full_cdp_access: Option<AllowDenyRequirement>,
6389    #[serde(
6390        rename = "persistentApproval",
6391        default,
6392        skip_serializing_if = "Option::is_none"
6393    )]
6394    pub persistent_approval: Option<bool>,
6395    #[serde(default, skip_serializing_if = "Option::is_none")]
6396    pub uploads: Option<AllowDenyRequirement>,
6397}
6398
6399/// Per-origin browser-use policy (config side, snake_case wire).
6400#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6401pub struct BrowserUseOriginPolicyConfig {
6402    #[serde(default, skip_serializing_if = "Option::is_none")]
6403    pub access: Option<AllowDenyRequirement>,
6404    #[serde(default, skip_serializing_if = "Option::is_none")]
6405    pub downloads: Option<AllowDenyRequirement>,
6406    #[serde(default, skip_serializing_if = "Option::is_none")]
6407    pub full_cdp_access: Option<AllowDenyRequirement>,
6408    #[serde(default, skip_serializing_if = "Option::is_none")]
6409    pub uploads: Option<AllowDenyRequirement>,
6410}
6411
6412/// Browser-use configuration (config side, snake_case wire).
6413#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6414pub struct BrowserUseConfig {
6415    #[serde(default, skip_serializing_if = "Option::is_none")]
6416    pub allow_history_access: Option<bool>,
6417    #[serde(default, skip_serializing_if = "Option::is_none")]
6418    pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
6419    #[serde(default, skip_serializing_if = "Option::is_none")]
6420    pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
6421}
6422
6423/// Computer-use configuration (config side, snake_case wire).
6424#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6425pub struct ComputerUseConfig {
6426    #[serde(default, skip_serializing_if = "Option::is_none")]
6427    pub default_app_access: Option<AllowDenyRequirement>,
6428    #[serde(default, skip_serializing_if = "Option::is_none")]
6429    pub macos: Option<ComputerUseMacosConfig>,
6430    #[serde(default, skip_serializing_if = "Option::is_none")]
6431    pub windows: Option<ComputerUseWindowsConfig>,
6432}
6433
6434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6435pub struct ComputerUseMacosConfig {
6436    #[serde(default, skip_serializing_if = "Option::is_none")]
6437    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6438}
6439
6440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6441pub struct ComputerUseWindowsConfig {
6442    #[serde(default, skip_serializing_if = "Option::is_none")]
6443    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6444    #[serde(default, skip_serializing_if = "Option::is_none")]
6445    pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
6446}
6447
6448#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6449pub struct ComputerUseWindowsExeConfig {
6450    pub access: AllowDenyRequirement,
6451    #[serde(default, skip_serializing_if = "Option::is_none")]
6452    pub binary_name: Option<String>,
6453    #[serde(default)]
6454    pub product_name: String,
6455    #[serde(default)]
6456    pub publisher_name: String,
6457}
6458
6459/// Per-platform computer-use requirements (camelCase wire).
6460#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6461#[serde(rename_all = "camelCase")]
6462pub struct ComputerUseMacosRequirements {
6463    #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
6464    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6465}
6466
6467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6468#[serde(rename_all = "camelCase")]
6469pub struct ComputerUseWindowsRequirements {
6470    #[serde(default, skip_serializing_if = "Option::is_none")]
6471    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6472    #[serde(default, skip_serializing_if = "Option::is_none")]
6473    pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
6474}
6475
6476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6477#[serde(rename_all = "camelCase")]
6478pub struct ComputerUseWindowsExeRequirement {
6479    pub access: AllowDenyRequirement,
6480    #[serde(
6481        rename = "binaryName",
6482        default,
6483        skip_serializing_if = "Option::is_none"
6484    )]
6485    pub binary_name: Option<String>,
6486    #[serde(rename = "productName", default)]
6487    pub product_name: String,
6488    #[serde(rename = "publisherName", default)]
6489    pub publisher_name: String,
6490}
6491
6492#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6493pub enum SandboxMode {
6494    #[serde(rename = "read-only")]
6495    Read_only,
6496    #[serde(rename = "workspace-write")]
6497    Workspace_write,
6498    #[serde(rename = "danger-full-access")]
6499    Danger_full_access,
6500}
6501
6502#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6503#[serde(tag = "type", rename_all = "camelCase")]
6504pub enum SandboxPolicy {
6505    #[serde(rename = "dangerFullAccess")]
6506    DangerFullAccess,
6507    #[serde(rename = "readOnly")]
6508    ReadOnly {
6509        #[serde(
6510            rename = "networkAccess",
6511            default,
6512            skip_serializing_if = "Option::is_none"
6513        )]
6514        network_access: Option<bool>,
6515    },
6516    #[serde(rename = "externalSandbox")]
6517    ExternalSandbox {
6518        #[serde(
6519            rename = "networkAccess",
6520            default,
6521            skip_serializing_if = "Option::is_none"
6522        )]
6523        network_access: Option<Value>,
6524    },
6525    #[serde(rename = "workspaceWrite")]
6526    WorkspaceWrite {
6527        #[serde(
6528            rename = "excludeSlashTmp",
6529            default,
6530            skip_serializing_if = "Option::is_none"
6531        )]
6532        exclude_slash_tmp: Option<bool>,
6533        #[serde(
6534            rename = "excludeTmpdirEnvVar",
6535            default,
6536            skip_serializing_if = "Option::is_none"
6537        )]
6538        exclude_tmpdir_env_var: Option<bool>,
6539        #[serde(
6540            rename = "networkAccess",
6541            default,
6542            skip_serializing_if = "Option::is_none"
6543        )]
6544        network_access: Option<bool>,
6545        #[serde(
6546            rename = "writableRoots",
6547            default,
6548            skip_serializing_if = "Option::is_none"
6549        )]
6550        writable_roots: Option<Vec<AbsolutePathBuf>>,
6551    },
6552}
6553
6554#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6555#[serde(rename_all = "snake_case")]
6556pub struct SandboxWorkspaceWrite {
6557    #[serde(default, skip_serializing_if = "Option::is_none")]
6558    pub exclude_slash_tmp: Option<bool>,
6559    #[serde(default, skip_serializing_if = "Option::is_none")]
6560    pub exclude_tmpdir_env_var: Option<bool>,
6561    #[serde(default, skip_serializing_if = "Option::is_none")]
6562    pub network_access: Option<bool>,
6563    #[serde(default, skip_serializing_if = "Option::is_none")]
6564    pub writable_roots: Option<Vec<String>>,
6565}
6566
6567#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6568#[serde(tag = "type", rename_all = "camelCase")]
6569pub enum ScheduledTaskSchedule {
6570    Hourly {
6571        #[serde(default, skip_serializing_if = "Option::is_none")]
6572        days: Option<Vec<ScheduledTaskWeekday>>,
6573        #[serde(rename = "intervalHours")]
6574        interval_hours: i64,
6575    },
6576    Daily {
6577        time: String,
6578    },
6579    Weekdays {
6580        time: String,
6581    },
6582    Weekly {
6583        days: Vec<ScheduledTaskWeekday>,
6584        time: String,
6585    },
6586}
6587
6588#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6589#[serde(rename_all = "camelCase")]
6590pub struct ScheduledTaskSummary {
6591    #[serde(default)]
6592    pub key: String,
6593    #[serde(default)]
6594    pub name: String,
6595    #[serde(default)]
6596    pub prompt: String,
6597    #[serde()]
6598    pub schedule: ScheduledTaskSchedule,
6599}
6600
6601#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6602pub enum ScheduledTaskWeekday {
6603    #[serde(rename = "MO")]
6604    MO,
6605    #[serde(rename = "TU")]
6606    TU,
6607    #[serde(rename = "WE")]
6608    WE,
6609    #[serde(rename = "TH")]
6610    TH,
6611    #[serde(rename = "FR")]
6612    FR,
6613    #[serde(rename = "SA")]
6614    SA,
6615    #[serde(rename = "SU")]
6616    SU,
6617}
6618
6619#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6620#[serde(rename_all = "camelCase")]
6621pub struct SendAddCreditsNudgeEmailParams {
6622    #[serde(rename = "creditType")]
6623    pub credit_type: AddCreditsNudgeCreditType,
6624}
6625
6626#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6627#[serde(rename_all = "camelCase")]
6628pub struct SendAddCreditsNudgeEmailResponse {
6629    #[serde()]
6630    pub status: AddCreditsNudgeEmailStatus,
6631}
6632
6633#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6634#[serde(rename_all = "camelCase")]
6635pub struct ServerRequestResolvedNotification {
6636    #[serde(rename = "requestId")]
6637    pub request_id: RequestId,
6638    #[serde(rename = "threadId", default)]
6639    pub thread_id: String,
6640}
6641
6642#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6643#[serde(rename_all = "camelCase")]
6644pub struct SessionMigration {
6645    #[serde(default)]
6646    pub cwd: String,
6647    #[serde(default)]
6648    pub path: String,
6649    #[serde(default, skip_serializing_if = "Option::is_none")]
6650    pub title: Option<String>,
6651}
6652
6653#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6654pub enum SessionSource {
6655    #[serde(rename = "cli")]
6656    Cli,
6657    #[serde(rename = "vscode")]
6658    Vscode,
6659    #[serde(rename = "exec")]
6660    Exec,
6661    #[serde(rename = "appServer")]
6662    AppServer,
6663    #[serde(rename = "unknown")]
6664    Unknown,
6665    #[serde(rename = "custom")]
6666    Custom(String),
6667    #[serde(rename = "subAgent")]
6668    SubAgent(SubAgentSource),
6669}
6670
6671#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6672#[serde(rename_all = "camelCase")]
6673pub struct Settings {
6674    #[serde(default, skip_serializing_if = "Option::is_none")]
6675    pub developer_instructions: Option<String>,
6676    #[serde(default)]
6677    pub model: String,
6678    #[serde(default, skip_serializing_if = "Option::is_none")]
6679    pub reasoning_effort: Option<ReasoningEffort>,
6680}
6681
6682#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6683#[serde(rename_all = "camelCase")]
6684pub struct SkillDependencies {
6685    #[serde(default)]
6686    pub tools: Vec<SkillToolDependency>,
6687}
6688
6689#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6690#[serde(rename_all = "camelCase")]
6691pub struct SkillErrorInfo {
6692    #[serde(default)]
6693    pub message: String,
6694    #[serde(default)]
6695    pub path: String,
6696}
6697
6698#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6699#[serde(rename_all = "camelCase")]
6700pub struct SkillInterface {
6701    #[serde(
6702        rename = "brandColor",
6703        default,
6704        skip_serializing_if = "Option::is_none"
6705    )]
6706    pub brand_color: Option<String>,
6707    #[serde(
6708        rename = "defaultPrompt",
6709        default,
6710        skip_serializing_if = "Option::is_none"
6711    )]
6712    pub default_prompt: Option<String>,
6713    #[serde(
6714        rename = "displayName",
6715        default,
6716        skip_serializing_if = "Option::is_none"
6717    )]
6718    pub display_name: Option<String>,
6719    #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
6720    pub icon_large: Option<AbsolutePathBuf>,
6721    #[serde(
6722        rename = "iconLargeUrl",
6723        default,
6724        skip_serializing_if = "Option::is_none"
6725    )]
6726    pub icon_large_url: Option<String>,
6727    #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
6728    pub icon_small: Option<AbsolutePathBuf>,
6729    #[serde(
6730        rename = "iconSmallUrl",
6731        default,
6732        skip_serializing_if = "Option::is_none"
6733    )]
6734    pub icon_small_url: Option<String>,
6735    #[serde(
6736        rename = "shortDescription",
6737        default,
6738        skip_serializing_if = "Option::is_none"
6739    )]
6740    pub short_description: Option<String>,
6741}
6742
6743#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6744#[serde(rename_all = "camelCase")]
6745pub struct SkillMetadata {
6746    #[serde(default, skip_serializing_if = "Option::is_none")]
6747    pub dependencies: Option<SkillDependencies>,
6748    #[serde(default)]
6749    pub description: String,
6750    #[serde(default)]
6751    pub enabled: bool,
6752    #[serde(default, skip_serializing_if = "Option::is_none")]
6753    pub interface: Option<SkillInterface>,
6754    #[serde(default)]
6755    pub name: String,
6756    #[serde()]
6757    pub path: AbsolutePathBuf,
6758    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
6759    pub plugin_id: Option<String>,
6760    #[serde()]
6761    pub scope: SkillScope,
6762    #[serde(
6763        rename = "shortDescription",
6764        default,
6765        skip_serializing_if = "Option::is_none"
6766    )]
6767    pub short_description: Option<String>,
6768}
6769
6770#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6771#[serde(rename_all = "camelCase")]
6772pub struct SkillMigration {
6773    #[serde(default)]
6774    pub name: String,
6775}
6776
6777#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6778pub enum SkillScope {
6779    #[serde(rename = "user")]
6780    User,
6781    #[serde(rename = "repo")]
6782    Repo,
6783    #[serde(rename = "system")]
6784    System,
6785    #[serde(rename = "admin")]
6786    Admin,
6787}
6788
6789#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6790#[serde(rename_all = "camelCase")]
6791pub struct SkillSummary {
6792    #[serde(default)]
6793    pub description: String,
6794    #[serde(default)]
6795    pub enabled: bool,
6796    #[serde(default, skip_serializing_if = "Option::is_none")]
6797    pub interface: Option<SkillInterface>,
6798    #[serde(default)]
6799    pub name: String,
6800    #[serde(default, skip_serializing_if = "Option::is_none")]
6801    pub path: Option<AbsolutePathBuf>,
6802    #[serde(
6803        rename = "shortDescription",
6804        default,
6805        skip_serializing_if = "Option::is_none"
6806    )]
6807    pub short_description: Option<String>,
6808}
6809
6810#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6811#[serde(rename_all = "camelCase")]
6812pub struct SkillToolDependency {
6813    #[serde(default, skip_serializing_if = "Option::is_none")]
6814    pub command: Option<String>,
6815    #[serde(default, skip_serializing_if = "Option::is_none")]
6816    pub description: Option<String>,
6817    #[serde(default, skip_serializing_if = "Option::is_none")]
6818    pub transport: Option<String>,
6819    #[serde(rename = "type", default)]
6820    pub type_: String,
6821    #[serde(default, skip_serializing_if = "Option::is_none")]
6822    pub url: Option<String>,
6823    #[serde(default)]
6824    pub value: String,
6825}
6826
6827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6828#[serde(rename_all = "camelCase")]
6829pub struct SkillsChangedNotification {
6830    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6831    pub extra: serde_json::Map<String, Value>,
6832}
6833
6834#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6835#[serde(rename_all = "camelCase")]
6836pub struct SkillsConfigWriteParams {
6837    #[serde(default)]
6838    pub enabled: bool,
6839    #[serde(default, skip_serializing_if = "Option::is_none")]
6840    pub name: Option<String>,
6841    #[serde(default, skip_serializing_if = "Option::is_none")]
6842    pub path: Option<AbsolutePathBuf>,
6843}
6844
6845#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6846#[serde(rename_all = "camelCase")]
6847pub struct SkillsConfigWriteResponse {
6848    #[serde(rename = "effectiveEnabled", default)]
6849    pub effective_enabled: bool,
6850}
6851
6852#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6853#[serde(rename_all = "camelCase")]
6854pub struct SkillsExtraRootsSetParams {
6855    #[serde(rename = "extraRoots", default)]
6856    pub extra_roots: Vec<AbsolutePathBuf>,
6857}
6858
6859#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6860#[serde(rename_all = "camelCase")]
6861pub struct SkillsExtraRootsSetResponse {
6862    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6863    pub extra: serde_json::Map<String, Value>,
6864}
6865
6866#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6867#[serde(rename_all = "camelCase")]
6868pub struct SkillsListEntry {
6869    #[serde(default)]
6870    pub cwd: String,
6871    #[serde(default)]
6872    pub errors: Vec<SkillErrorInfo>,
6873    #[serde(default)]
6874    pub skills: Vec<SkillMetadata>,
6875}
6876
6877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6878#[serde(rename_all = "camelCase")]
6879pub struct SkillsListParams {
6880    #[serde(default, skip_serializing_if = "Option::is_none")]
6881    pub cwds: Option<Vec<String>>,
6882    #[serde(
6883        rename = "forceReload",
6884        default,
6885        skip_serializing_if = "Option::is_none"
6886    )]
6887    pub force_reload: Option<bool>,
6888}
6889
6890#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6891#[serde(rename_all = "camelCase")]
6892pub struct SkillsListResponse {
6893    #[serde(default)]
6894    pub data: Vec<SkillsListEntry>,
6895}
6896
6897#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6898pub enum SortDirection {
6899    #[serde(rename = "asc")]
6900    Asc,
6901    #[serde(rename = "desc")]
6902    Desc,
6903}
6904
6905#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6906#[serde(rename_all = "camelCase")]
6907pub struct SpendControlLimitSnapshot {
6908    #[serde(default)]
6909    pub limit: String,
6910    #[serde(rename = "remainingPercent", default)]
6911    pub remaining_percent: i64,
6912    #[serde(rename = "resetsAt", default)]
6913    pub resets_at: i64,
6914    #[serde(default)]
6915    pub used: String,
6916}
6917
6918#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6919pub enum SubAgentActivityKind {
6920    #[serde(rename = "started")]
6921    Started,
6922    #[serde(rename = "interacted")]
6923    Interacted,
6924    #[serde(rename = "interrupted")]
6925    Interrupted,
6926    #[serde(rename = "completed")]
6927    Completed,
6928}
6929
6930#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6931pub enum SubAgentSource {
6932    #[serde(rename = "review")]
6933    Review,
6934    #[serde(rename = "compact")]
6935    Compact,
6936    #[serde(rename = "memory_consolidation")]
6937    MemoryConsolidation,
6938    #[serde(rename = "thread_spawn")]
6939    ThreadSpawn {
6940        #[serde(default, skip_serializing_if = "Option::is_none")]
6941        agent_nickname: Option<String>,
6942        #[serde(default, skip_serializing_if = "Option::is_none")]
6943        agent_path: Option<AgentPath>,
6944        #[serde(default, skip_serializing_if = "Option::is_none")]
6945        agent_role: Option<String>,
6946        depth: i64,
6947        parent_thread_id: ThreadId,
6948    },
6949    #[serde(rename = "other")]
6950    Other(String),
6951}
6952
6953#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6954#[serde(rename_all = "camelCase")]
6955pub struct SubagentMigration {
6956    #[serde(default)]
6957    pub name: String,
6958}
6959
6960#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6961#[serde(rename_all = "camelCase")]
6962pub struct TerminalInteractionNotification {
6963    #[serde(rename = "itemId", default)]
6964    pub item_id: String,
6965    #[serde(rename = "processId", default)]
6966    pub process_id: String,
6967    #[serde(default)]
6968    pub stdin: String,
6969    #[serde(rename = "threadId", default)]
6970    pub thread_id: String,
6971    #[serde(rename = "turnId", default)]
6972    pub turn_id: String,
6973}
6974
6975#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6976#[serde(rename_all = "camelCase")]
6977pub struct TextElement {
6978    #[serde(rename = "byteRange", default)]
6979    pub byte_range: Value,
6980    #[serde(default, skip_serializing_if = "Option::is_none")]
6981    pub placeholder: Option<String>,
6982}
6983
6984#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6985#[serde(rename_all = "camelCase")]
6986pub struct TextPosition {
6987    #[serde(default)]
6988    pub column: i64,
6989    #[serde(default)]
6990    pub line: i64,
6991}
6992
6993#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6994#[serde(rename_all = "camelCase")]
6995pub struct TextRange {
6996    #[serde()]
6997    pub end: TextPosition,
6998    #[serde()]
6999    pub start: TextPosition,
7000}
7001
7002#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7003#[serde(rename_all = "camelCase")]
7004pub struct Thread {
7005    #[serde(
7006        rename = "agentNickname",
7007        default,
7008        skip_serializing_if = "Option::is_none"
7009    )]
7010    pub agent_nickname: Option<String>,
7011    #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
7012    pub agent_role: Option<String>,
7013    #[serde(rename = "cliVersion", default)]
7014    pub cli_version: String,
7015    #[serde(rename = "createdAt", default)]
7016    pub created_at: i64,
7017    #[serde(default)]
7018    pub cwd: Value,
7019    #[serde(default)]
7020    pub ephemeral: bool,
7021    #[serde(
7022        rename = "forkedFromId",
7023        default,
7024        skip_serializing_if = "Option::is_none"
7025    )]
7026    pub forked_from_id: Option<String>,
7027    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
7028    pub git_info: Option<GitInfo>,
7029    /// Persisted history contract chosen at thread creation (0.148 upstream);
7030    /// absent on older servers, which are always `legacy`.
7031    #[serde(
7032        rename = "historyMode",
7033        default,
7034        skip_serializing_if = "Option::is_none"
7035    )]
7036    pub history_mode: Option<ThreadHistoryMode>,
7037    /// Canonical project assignment owned by app-server, if any. Required
7038    /// upstream from 0.147 but kept tolerant for pre-project servers.
7039    #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
7040    pub project_id: Option<String>,
7041    #[serde(default)]
7042    pub id: String,
7043    /// Current configured model when loaded, otherwise the latest persisted
7044    /// model. Null when unavailable. Not per-turn execution telemetry.
7045    #[serde(default, skip_serializing_if = "Option::is_none")]
7046    pub model: Option<String>,
7047    #[serde(rename = "modelProvider", default)]
7048    pub model_provider: String,
7049    #[serde(default, skip_serializing_if = "Option::is_none")]
7050    pub name: Option<String>,
7051    /// Originator recorded when the thread was created, independent of its
7052    /// current client or executor. `None` when the recorded originator is
7053    /// unavailable.
7054    #[serde(default, skip_serializing_if = "Option::is_none")]
7055    pub originator: Option<String>,
7056    #[serde(
7057        rename = "parentThreadId",
7058        default,
7059        skip_serializing_if = "Option::is_none"
7060    )]
7061    pub parent_thread_id: Option<String>,
7062    #[serde(default, skip_serializing_if = "Option::is_none")]
7063    pub path: Option<String>,
7064    #[serde(default)]
7065    pub preview: String,
7066    /// Current configured reasoning effort when loaded, otherwise the latest
7067    /// persisted effort. Null when unset or unavailable. Not per-turn
7068    /// execution telemetry.
7069    #[serde(
7070        rename = "reasoningEffort",
7071        default,
7072        skip_serializing_if = "Option::is_none"
7073    )]
7074    pub reasoning_effort: Option<ReasoningEffort>,
7075    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7076    pub recency_at: Option<i64>,
7077    #[serde(default, skip_serializing_if = "Option::is_none")]
7078    pub section: Option<ThreadSection>,
7079    #[serde(
7080        rename = "sectionEnteredAt",
7081        default,
7082        skip_serializing_if = "Option::is_none"
7083    )]
7084    pub section_entered_at: Option<i64>,
7085    #[serde(rename = "sessionId", default)]
7086    pub session_id: String,
7087    #[serde(default)]
7088    pub source: Value,
7089    #[serde(default)]
7090    pub status: Value,
7091    #[serde(
7092        rename = "threadSource",
7093        default,
7094        skip_serializing_if = "Option::is_none"
7095    )]
7096    pub thread_source: Option<ThreadSource>,
7097    #[serde(default)]
7098    pub turns: Vec<Turn>,
7099    #[serde(rename = "updatedAt", default)]
7100    pub updated_at: i64,
7101}
7102
7103#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7104pub enum ThreadActiveFlag {
7105    #[serde(rename = "waitingOnApproval")]
7106    WaitingOnApproval,
7107    #[serde(rename = "waitingOnUserInput")]
7108    WaitingOnUserInput,
7109}
7110
7111#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7112#[serde(rename_all = "camelCase")]
7113pub struct ThreadApproveGuardianDeniedActionParams {
7114    #[serde(default)]
7115    pub event: Value,
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 ThreadApproveGuardianDeniedActionResponse {
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 ThreadArchiveParams {
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 ThreadArchiveResponse {
7137    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7138    pub extra: serde_json::Map<String, Value>,
7139}
7140
7141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7142#[serde(rename_all = "camelCase")]
7143pub struct ThreadArchivedNotification {
7144    #[serde(rename = "threadId", default)]
7145    pub thread_id: String,
7146}
7147
7148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7149#[serde(rename_all = "camelCase")]
7150pub struct ThreadClosedNotification {
7151    #[serde(rename = "threadId", default)]
7152    pub thread_id: String,
7153}
7154
7155#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7156#[serde(rename_all = "camelCase")]
7157pub struct ThreadCompactStartParams {
7158    #[serde(rename = "threadId", default)]
7159    pub thread_id: String,
7160}
7161
7162#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7163#[serde(rename_all = "camelCase")]
7164pub struct ThreadCompactStartResponse {
7165    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7166    pub extra: serde_json::Map<String, Value>,
7167}
7168
7169#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7170#[serde(rename_all = "camelCase")]
7171pub struct ThreadDeleteParams {
7172    #[serde(rename = "threadId", default)]
7173    pub thread_id: String,
7174}
7175
7176#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7177#[serde(rename_all = "camelCase")]
7178pub struct ThreadDeleteResponse {
7179    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7180    pub extra: serde_json::Map<String, Value>,
7181}
7182
7183#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7184#[serde(rename_all = "camelCase")]
7185pub struct ThreadDeletedNotification {
7186    #[serde(rename = "threadId", default)]
7187    pub thread_id: String,
7188}
7189
7190#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7191#[serde(rename_all = "camelCase")]
7192pub struct ThreadForkParams {
7193    #[serde(
7194        rename = "approvalPolicy",
7195        default,
7196        skip_serializing_if = "Option::is_none"
7197    )]
7198    pub approval_policy: Option<AskForApproval>,
7199    #[serde(
7200        rename = "approvalsReviewer",
7201        default,
7202        skip_serializing_if = "Option::is_none"
7203    )]
7204    pub approvals_reviewer: Option<ApprovalsReviewer>,
7205    #[serde(
7206        rename = "baseInstructions",
7207        default,
7208        skip_serializing_if = "Option::is_none"
7209    )]
7210    pub base_instructions: Option<String>,
7211    #[serde(default, skip_serializing_if = "Option::is_none")]
7212    pub config: Option<Value>,
7213    #[serde(default, skip_serializing_if = "Option::is_none")]
7214    pub cwd: Option<String>,
7215    #[serde(
7216        rename = "developerInstructions",
7217        default,
7218        skip_serializing_if = "Option::is_none"
7219    )]
7220    pub developer_instructions: Option<String>,
7221    #[serde(default, skip_serializing_if = "Option::is_none")]
7222    pub ephemeral: Option<bool>,
7223    #[serde(
7224        rename = "excludeTurns",
7225        default,
7226        skip_serializing_if = "Option::is_none"
7227    )]
7228    pub exclude_turns: Option<bool>,
7229    #[serde(
7230        rename = "lastTurnId",
7231        default,
7232        skip_serializing_if = "Option::is_none"
7233    )]
7234    pub last_turn_id: Option<String>,
7235    #[serde(default, skip_serializing_if = "Option::is_none")]
7236    pub model: Option<String>,
7237    #[serde(
7238        rename = "modelProvider",
7239        default,
7240        skip_serializing_if = "Option::is_none"
7241    )]
7242    pub model_provider: Option<String>,
7243    #[serde(default, skip_serializing_if = "Option::is_none")]
7244    pub sandbox: Option<SandboxMode>,
7245    #[serde(
7246        rename = "serviceTier",
7247        default,
7248        skip_serializing_if = "Option::is_none"
7249    )]
7250    pub service_tier: Option<String>,
7251    #[serde(rename = "threadId", default)]
7252    pub thread_id: String,
7253    #[serde(
7254        rename = "threadSource",
7255        default,
7256        skip_serializing_if = "Option::is_none"
7257    )]
7258    pub thread_source: Option<ThreadSource>,
7259}
7260
7261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7262#[serde(rename_all = "camelCase")]
7263pub struct ThreadForkResponse {
7264    #[serde(rename = "approvalPolicy")]
7265    pub approval_policy: AskForApproval,
7266    #[serde(rename = "approvalsReviewer", default)]
7267    pub approvals_reviewer: Value,
7268    #[serde()]
7269    pub cwd: AbsolutePathBuf,
7270    #[serde(
7271        rename = "instructionSources",
7272        default,
7273        skip_serializing_if = "Option::is_none"
7274    )]
7275    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
7276    #[serde(default)]
7277    pub model: String,
7278    #[serde(rename = "modelProvider", default)]
7279    pub model_provider: String,
7280    #[serde(
7281        rename = "reasoningEffort",
7282        default,
7283        skip_serializing_if = "Option::is_none"
7284    )]
7285    pub reasoning_effort: Option<ReasoningEffort>,
7286    #[serde(default)]
7287    pub sandbox: Value,
7288    #[serde(
7289        rename = "serviceTier",
7290        default,
7291        skip_serializing_if = "Option::is_none"
7292    )]
7293    pub service_tier: Option<String>,
7294    #[serde()]
7295    pub thread: Thread,
7296}
7297
7298#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7299#[serde(rename_all = "camelCase")]
7300pub struct ThreadGoal {
7301    #[serde(rename = "createdAt", default)]
7302    pub created_at: i64,
7303    #[serde(default)]
7304    pub objective: String,
7305    #[serde()]
7306    pub status: ThreadGoalStatus,
7307    #[serde(rename = "threadId", default)]
7308    pub thread_id: String,
7309    #[serde(rename = "timeUsedSeconds", default)]
7310    pub time_used_seconds: i64,
7311    #[serde(
7312        rename = "tokenBudget",
7313        default,
7314        skip_serializing_if = "Option::is_none"
7315    )]
7316    pub token_budget: Option<i64>,
7317    #[serde(rename = "tokensUsed", default)]
7318    pub tokens_used: i64,
7319    #[serde(rename = "updatedAt", default)]
7320    pub updated_at: i64,
7321}
7322
7323#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7324#[serde(rename_all = "camelCase")]
7325pub struct ThreadGoalClearParams {
7326    #[serde(rename = "threadId", default)]
7327    pub thread_id: String,
7328}
7329
7330#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7331#[serde(rename_all = "camelCase")]
7332pub struct ThreadGoalClearResponse {
7333    #[serde(default)]
7334    pub cleared: bool,
7335}
7336
7337#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7338#[serde(rename_all = "camelCase")]
7339pub struct ThreadGoalClearedNotification {
7340    #[serde(rename = "threadId", default)]
7341    pub thread_id: String,
7342}
7343
7344#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7345#[serde(rename_all = "camelCase")]
7346pub struct ThreadGoalGetParams {
7347    #[serde(rename = "threadId", default)]
7348    pub thread_id: String,
7349}
7350
7351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7352#[serde(rename_all = "camelCase")]
7353pub struct ThreadGoalGetResponse {
7354    #[serde(default, skip_serializing_if = "Option::is_none")]
7355    pub goal: Option<ThreadGoal>,
7356}
7357
7358#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7359#[serde(rename_all = "camelCase")]
7360pub struct ThreadGoalSetParams {
7361    #[serde(default, skip_serializing_if = "Option::is_none")]
7362    pub objective: Option<String>,
7363    #[serde(default, skip_serializing_if = "Option::is_none")]
7364    pub status: Option<ThreadGoalStatus>,
7365    #[serde(rename = "threadId", default)]
7366    pub thread_id: String,
7367    #[serde(
7368        rename = "tokenBudget",
7369        default,
7370        skip_serializing_if = "Option::is_none"
7371    )]
7372    pub token_budget: Option<i64>,
7373}
7374
7375#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7376#[serde(rename_all = "camelCase")]
7377pub struct ThreadGoalSetResponse {
7378    #[serde()]
7379    pub goal: ThreadGoal,
7380}
7381
7382#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7383pub enum ThreadGoalStatus {
7384    #[serde(rename = "active")]
7385    Active,
7386    #[serde(rename = "paused")]
7387    Paused,
7388    #[serde(rename = "blocked")]
7389    Blocked,
7390    #[serde(rename = "usageLimited")]
7391    UsageLimited,
7392    #[serde(rename = "budgetLimited")]
7393    BudgetLimited,
7394    #[serde(rename = "complete")]
7395    Complete,
7396}
7397
7398#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7399#[serde(rename_all = "camelCase")]
7400pub struct ThreadGoalUpdatedNotification {
7401    #[serde()]
7402    pub goal: ThreadGoal,
7403    #[serde(rename = "threadId", default)]
7404    pub thread_id: String,
7405    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
7406    pub turn_id: Option<String>,
7407}
7408
7409#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
7410#[serde(transparent)]
7411pub struct ThreadId(pub String);
7412
7413#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7414#[serde(rename_all = "camelCase")]
7415pub struct ThreadInjectItemsParams {
7416    #[serde(default)]
7417    pub items: Vec<Value>,
7418    #[serde(rename = "threadId", default)]
7419    pub thread_id: String,
7420}
7421
7422#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7423#[serde(rename_all = "camelCase")]
7424pub struct ThreadInjectItemsResponse {
7425    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7426    pub extra: serde_json::Map<String, Value>,
7427}
7428
7429#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7430#[serde(tag = "type", rename_all = "camelCase")]
7431pub enum ThreadItem {
7432    #[serde(rename = "userMessage")]
7433    UserMessage {
7434        #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
7435        client_id: Option<String>,
7436        content: Vec<UserInput>,
7437        id: String,
7438    },
7439    #[serde(rename = "hookPrompt")]
7440    HookPrompt {
7441        fragments: Vec<HookPromptFragment>,
7442        id: String,
7443    },
7444    #[serde(rename = "agentMessage")]
7445    AgentMessage {
7446        #[serde(default, skip_serializing_if = "Option::is_none")]
7447        delivery: Option<AgentMessageDelivery>,
7448        id: String,
7449        #[serde(
7450            rename = "memoryCitation",
7451            default,
7452            skip_serializing_if = "Option::is_none"
7453        )]
7454        memory_citation: Option<MemoryCitation>,
7455        #[serde(default, skip_serializing_if = "Option::is_none")]
7456        phase: Option<MessagePhase>,
7457        #[serde(default, skip_serializing_if = "Option::is_none")]
7458        questions: Option<Vec<AsyncUserInputQuestion>>,
7459        text: String,
7460    },
7461    Plan {
7462        id: String,
7463        text: String,
7464    },
7465    Reasoning {
7466        #[serde(default, skip_serializing_if = "Option::is_none")]
7467        content: Option<Vec<String>>,
7468        id: String,
7469        #[serde(default, skip_serializing_if = "Option::is_none")]
7470        summary: Option<Vec<String>>,
7471    },
7472    #[serde(rename = "commandExecution")]
7473    CommandExecution {
7474        #[serde(
7475            rename = "aggregatedOutput",
7476            default,
7477            skip_serializing_if = "Option::is_none"
7478        )]
7479        aggregated_output: Option<String>,
7480        command: String,
7481        #[serde(rename = "commandActions")]
7482        command_actions: Vec<CommandAction>,
7483        cwd: Value,
7484        #[serde(
7485            rename = "durationMs",
7486            default,
7487            skip_serializing_if = "Option::is_none"
7488        )]
7489        duration_ms: Option<i64>,
7490        #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
7491        exit_code: Option<i64>,
7492        id: String,
7493        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7494        plugin_id: Option<String>,
7495        #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
7496        process_id: Option<String>,
7497        #[serde(
7498            rename = "scriptPath",
7499            default,
7500            skip_serializing_if = "Option::is_none"
7501        )]
7502        script_path: Option<String>,
7503        #[serde(default, skip_serializing_if = "Option::is_none")]
7504        source: Option<Value>,
7505        status: CommandExecutionStatus,
7506    },
7507    #[serde(rename = "fileChange")]
7508    FileChange {
7509        changes: Vec<FileUpdateChange>,
7510        id: String,
7511        status: PatchApplyStatus,
7512    },
7513    #[serde(rename = "mcpToolCall")]
7514    McpToolCall {
7515        #[serde(
7516            rename = "appContext",
7517            default,
7518            skip_serializing_if = "Option::is_none"
7519        )]
7520        app_context: Option<McpToolCallAppContext>,
7521        arguments: Value,
7522        #[serde(
7523            rename = "durationMs",
7524            default,
7525            skip_serializing_if = "Option::is_none"
7526        )]
7527        duration_ms: Option<i64>,
7528        #[serde(default, skip_serializing_if = "Option::is_none")]
7529        error: Option<McpToolCallError>,
7530        id: String,
7531        #[serde(
7532            rename = "mcpAppResourceUri",
7533            default,
7534            skip_serializing_if = "Option::is_none"
7535        )]
7536        mcp_app_resource_uri: Option<String>,
7537        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7538        plugin_id: Option<String>,
7539        #[serde(
7540            rename = "readOnlyHint",
7541            default,
7542            skip_serializing_if = "Option::is_none"
7543        )]
7544        read_only_hint: Option<bool>,
7545        #[serde(default, skip_serializing_if = "Option::is_none")]
7546        result: Option<McpToolCallResult>,
7547        server: String,
7548        status: McpToolCallStatus,
7549        tool: String,
7550    },
7551    #[serde(rename = "dynamicToolCall")]
7552    DynamicToolCall {
7553        arguments: Value,
7554        #[serde(
7555            rename = "contentItems",
7556            default,
7557            skip_serializing_if = "Option::is_none"
7558        )]
7559        content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
7560        #[serde(
7561            rename = "durationMs",
7562            default,
7563            skip_serializing_if = "Option::is_none"
7564        )]
7565        duration_ms: Option<i64>,
7566        id: String,
7567        #[serde(default, skip_serializing_if = "Option::is_none")]
7568        namespace: Option<String>,
7569        status: DynamicToolCallStatus,
7570        #[serde(default, skip_serializing_if = "Option::is_none")]
7571        success: Option<bool>,
7572        tool: String,
7573    },
7574    #[serde(rename = "collabAgentToolCall")]
7575    CollabAgentToolCall {
7576        #[serde(rename = "agentsStates")]
7577        agents_states: std::collections::BTreeMap<String, CollabAgentState>,
7578        id: String,
7579        #[serde(default, skip_serializing_if = "Option::is_none")]
7580        model: Option<String>,
7581        #[serde(default, skip_serializing_if = "Option::is_none")]
7582        prompt: Option<String>,
7583        #[serde(
7584            rename = "reasoningEffort",
7585            default,
7586            skip_serializing_if = "Option::is_none"
7587        )]
7588        reasoning_effort: Option<ReasoningEffort>,
7589        #[serde(rename = "receiverThreadIds")]
7590        receiver_thread_ids: Vec<String>,
7591        #[serde(rename = "senderThreadId")]
7592        sender_thread_id: String,
7593        status: Value,
7594        tool: Value,
7595    },
7596    #[serde(rename = "subAgentActivity")]
7597    SubAgentActivity {
7598        #[serde(rename = "agentPath")]
7599        agent_path: String,
7600        #[serde(rename = "agentThreadId")]
7601        agent_thread_id: String,
7602        id: String,
7603        kind: SubAgentActivityKind,
7604    },
7605    #[serde(rename = "webSearch")]
7606    WebSearch {
7607        #[serde(default, skip_serializing_if = "Option::is_none")]
7608        action: Option<WebSearchAction>,
7609        id: String,
7610        query: String,
7611        #[serde(default, skip_serializing_if = "Option::is_none")]
7612        results: Option<Vec<Value>>,
7613    },
7614    #[serde(rename = "imageView")]
7615    ImageView {
7616        id: String,
7617        path: LegacyAppPathString,
7618    },
7619    Sleep {
7620        #[serde(rename = "durationMs")]
7621        duration_ms: i64,
7622        id: String,
7623    },
7624    #[serde(rename = "imageGeneration")]
7625    ImageGeneration {
7626        #[serde(default, skip_serializing_if = "Option::is_none")]
7627        failure: Option<ImageGenerationFailure>,
7628        id: String,
7629        result: String,
7630        #[serde(
7631            rename = "revisedPrompt",
7632            default,
7633            skip_serializing_if = "Option::is_none"
7634        )]
7635        revised_prompt: Option<String>,
7636        #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
7637        saved_path: Option<AbsolutePathBuf>,
7638        status: String,
7639        #[serde(
7640            rename = "transparentBackground",
7641            default,
7642            skip_serializing_if = "Option::is_none"
7643        )]
7644        transparent_background: Option<bool>,
7645    },
7646    #[serde(rename = "enteredReviewMode")]
7647    EnteredReviewMode {
7648        id: String,
7649        review: String,
7650    },
7651    #[serde(rename = "exitedReviewMode")]
7652    ExitedReviewMode {
7653        id: String,
7654        review: String,
7655    },
7656    #[serde(rename = "contextCompaction")]
7657    ContextCompaction {
7658        id: String,
7659    },
7660    #[serde(rename = "functionCallOutput")]
7661    FunctionCallOutput {
7662        id: String,
7663        name: String,
7664        #[serde(default, skip_serializing_if = "Option::is_none")]
7665        namespace: Option<String>,
7666        output: FunctionCallOutputBody,
7667    },
7668}
7669
7670#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7671#[serde(untagged)]
7672pub enum ThreadListCwdFilter {
7673    Variant0(String),
7674    Variant1(Vec<String>),
7675}
7676
7677#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7678#[serde(rename_all = "camelCase")]
7679pub struct ThreadListParams {
7680    #[serde(default, skip_serializing_if = "Option::is_none")]
7681    pub archived: Option<bool>,
7682    #[serde(default, skip_serializing_if = "Option::is_none")]
7683    pub cursor: Option<String>,
7684    #[serde(default, skip_serializing_if = "Option::is_none")]
7685    pub cwd: Option<ThreadListCwdFilter>,
7686    #[serde(default, skip_serializing_if = "Option::is_none")]
7687    pub limit: Option<i64>,
7688    #[serde(
7689        rename = "modelProviders",
7690        default,
7691        skip_serializing_if = "Option::is_none"
7692    )]
7693    pub model_providers: Option<Vec<String>>,
7694    /// Optional originator allowlist, matching any supplied value exactly.
7695    /// Supported by hosted backends only; the local app-server rejects a
7696    /// nonempty list. Omitted or empty lists leave originators unrestricted.
7697    #[serde(default, skip_serializing_if = "Option::is_none")]
7698    pub originators: Option<Vec<String>>,
7699    #[serde(
7700        rename = "searchTerm",
7701        default,
7702        skip_serializing_if = "Option::is_none"
7703    )]
7704    pub search_term: Option<String>,
7705    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
7706    pub section_id: Option<String>,
7707    #[serde(
7708        rename = "sortDirection",
7709        default,
7710        skip_serializing_if = "Option::is_none"
7711    )]
7712    pub sort_direction: Option<SortDirection>,
7713    #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
7714    pub sort_key: Option<ThreadSortKey>,
7715    #[serde(
7716        rename = "sourceKinds",
7717        default,
7718        skip_serializing_if = "Option::is_none"
7719    )]
7720    pub source_kinds: Option<Vec<ThreadSourceKind>>,
7721    #[serde(
7722        rename = "useStateDbOnly",
7723        default,
7724        skip_serializing_if = "Option::is_none"
7725    )]
7726    pub use_state_db_only: Option<bool>,
7727}
7728
7729#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7730#[serde(rename_all = "camelCase")]
7731pub struct ThreadListResponse {
7732    #[serde(
7733        rename = "backwardsCursor",
7734        default,
7735        skip_serializing_if = "Option::is_none"
7736    )]
7737    pub backwards_cursor: Option<String>,
7738    #[serde(default)]
7739    pub data: Vec<Thread>,
7740    #[serde(
7741        rename = "nextCursor",
7742        default,
7743        skip_serializing_if = "Option::is_none"
7744    )]
7745    pub next_cursor: Option<String>,
7746}
7747
7748#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7749#[serde(rename_all = "camelCase")]
7750pub struct ThreadLoadedListParams {
7751    #[serde(default, skip_serializing_if = "Option::is_none")]
7752    pub cursor: Option<String>,
7753    #[serde(default, skip_serializing_if = "Option::is_none")]
7754    pub limit: Option<i64>,
7755}
7756
7757#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7758#[serde(rename_all = "camelCase")]
7759pub struct ThreadLoadedListResponse {
7760    #[serde(default)]
7761    pub data: Vec<String>,
7762    #[serde(
7763        rename = "nextCursor",
7764        default,
7765        skip_serializing_if = "Option::is_none"
7766    )]
7767    pub next_cursor: Option<String>,
7768}
7769
7770#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7771#[serde(rename_all = "camelCase")]
7772pub struct ThreadMetadataGitInfoUpdateParams {
7773    #[serde(default, skip_serializing_if = "Option::is_none")]
7774    pub branch: Option<String>,
7775    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
7776    pub origin_url: Option<String>,
7777    #[serde(default, skip_serializing_if = "Option::is_none")]
7778    pub sha: Option<String>,
7779}
7780
7781#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7782#[serde(rename_all = "camelCase")]
7783pub struct ThreadMetadataUpdateParams {
7784    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
7785    pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
7786    #[serde(rename = "threadId", default)]
7787    pub thread_id: String,
7788}
7789
7790#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7791#[serde(rename_all = "camelCase")]
7792pub struct ThreadMetadataUpdateResponse {
7793    #[serde()]
7794    pub thread: Thread,
7795}
7796
7797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7798#[serde(rename_all = "camelCase")]
7799pub struct ThreadNameUpdatedNotification {
7800    #[serde(rename = "threadId", default)]
7801    pub thread_id: String,
7802    #[serde(
7803        rename = "threadName",
7804        default,
7805        skip_serializing_if = "Option::is_none"
7806    )]
7807    pub thread_name: Option<String>,
7808}
7809
7810#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7811#[serde(rename_all = "camelCase")]
7812pub struct ThreadReadParams {
7813    #[serde(
7814        rename = "includeTurns",
7815        default,
7816        skip_serializing_if = "Option::is_none"
7817    )]
7818    pub include_turns: Option<bool>,
7819    #[serde(rename = "threadId", default)]
7820    pub thread_id: String,
7821}
7822
7823#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7824#[serde(rename_all = "camelCase")]
7825pub struct ThreadReadResponse {
7826    #[serde()]
7827    pub thread: Thread,
7828}
7829
7830#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7831#[serde(rename_all = "camelCase")]
7832pub struct ThreadRealtimeAudioChunk {
7833    #[serde(default)]
7834    pub data: String,
7835    #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
7836    pub item_id: Option<String>,
7837    #[serde(rename = "numChannels", default)]
7838    pub num_channels: i64,
7839    #[serde(rename = "sampleRate", default)]
7840    pub sample_rate: i64,
7841    #[serde(
7842        rename = "samplesPerChannel",
7843        default,
7844        skip_serializing_if = "Option::is_none"
7845    )]
7846    pub samples_per_channel: Option<i64>,
7847}
7848
7849#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7850#[serde(rename_all = "camelCase")]
7851pub struct ThreadRealtimeClosedNotification {
7852    #[serde(default, skip_serializing_if = "Option::is_none")]
7853    pub reason: Option<String>,
7854    #[serde(rename = "threadId", default)]
7855    pub thread_id: String,
7856}
7857
7858#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7859#[serde(rename_all = "camelCase")]
7860pub struct ThreadRealtimeErrorNotification {
7861    #[serde(default)]
7862    pub message: String,
7863    #[serde(rename = "threadId", default)]
7864    pub thread_id: String,
7865}
7866
7867#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7868#[serde(rename_all = "camelCase")]
7869pub struct ThreadRealtimeItemAddedNotification {
7870    #[serde(default)]
7871    pub item: Value,
7872    #[serde(rename = "threadId", default)]
7873    pub thread_id: String,
7874}
7875
7876#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7877#[serde(rename_all = "camelCase")]
7878pub struct ThreadRealtimeOutputAudioDeltaNotification {
7879    #[serde()]
7880    pub audio: ThreadRealtimeAudioChunk,
7881    #[serde(rename = "threadId", default)]
7882    pub thread_id: String,
7883}
7884
7885#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7886#[serde(rename_all = "camelCase")]
7887pub struct ThreadRealtimeSdpNotification {
7888    #[serde(default)]
7889    pub sdp: String,
7890    #[serde(rename = "threadId", default)]
7891    pub thread_id: String,
7892}
7893
7894#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7895#[serde(rename_all = "camelCase")]
7896pub struct ThreadRealtimeStartedNotification {
7897    #[serde(
7898        rename = "realtimeSessionId",
7899        default,
7900        skip_serializing_if = "Option::is_none"
7901    )]
7902    pub realtime_session_id: Option<String>,
7903    #[serde(rename = "threadId", default)]
7904    pub thread_id: String,
7905    #[serde()]
7906    pub version: RealtimeConversationVersion,
7907}
7908
7909#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7910#[serde(rename_all = "camelCase")]
7911pub struct ThreadRealtimeTranscriptDeltaNotification {
7912    #[serde(default)]
7913    pub delta: String,
7914    #[serde(default)]
7915    pub role: String,
7916    #[serde(rename = "threadId", default)]
7917    pub thread_id: String,
7918}
7919
7920#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7921#[serde(rename_all = "camelCase")]
7922pub struct ThreadRealtimeTranscriptDoneNotification {
7923    #[serde(default)]
7924    pub role: String,
7925    #[serde(default)]
7926    pub text: String,
7927    #[serde(rename = "threadId", default)]
7928    pub thread_id: String,
7929}
7930
7931#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7932#[serde(rename_all = "camelCase")]
7933pub struct ThreadResumeParams {
7934    #[serde(
7935        rename = "approvalPolicy",
7936        default,
7937        skip_serializing_if = "Option::is_none"
7938    )]
7939    pub approval_policy: Option<AskForApproval>,
7940    #[serde(
7941        rename = "approvalsReviewer",
7942        default,
7943        skip_serializing_if = "Option::is_none"
7944    )]
7945    pub approvals_reviewer: Option<ApprovalsReviewer>,
7946    #[serde(
7947        rename = "baseInstructions",
7948        default,
7949        skip_serializing_if = "Option::is_none"
7950    )]
7951    pub base_instructions: Option<String>,
7952    #[serde(default, skip_serializing_if = "Option::is_none")]
7953    pub config: Option<Value>,
7954    #[serde(default, skip_serializing_if = "Option::is_none")]
7955    pub cwd: Option<String>,
7956    #[serde(
7957        rename = "developerInstructions",
7958        default,
7959        skip_serializing_if = "Option::is_none"
7960    )]
7961    pub developer_instructions: Option<String>,
7962    #[serde(default, skip_serializing_if = "Option::is_none")]
7963    pub model: Option<String>,
7964    #[serde(
7965        rename = "modelProvider",
7966        default,
7967        skip_serializing_if = "Option::is_none"
7968    )]
7969    pub model_provider: Option<String>,
7970    #[serde(default, skip_serializing_if = "Option::is_none")]
7971    pub personality: Option<Personality>,
7972    #[serde(default, skip_serializing_if = "Option::is_none")]
7973    pub sandbox: Option<SandboxMode>,
7974    #[serde(
7975        rename = "serviceTier",
7976        default,
7977        skip_serializing_if = "Option::is_none"
7978    )]
7979    pub service_tier: Option<String>,
7980    #[serde(rename = "threadId", default)]
7981    pub thread_id: String,
7982    #[serde(
7983        rename = "excludeTurns",
7984        default,
7985        skip_serializing_if = "Option::is_none"
7986    )]
7987    pub exclude_turns: Option<bool>,
7988}
7989
7990#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7991#[serde(rename_all = "camelCase")]
7992pub struct ThreadResumeResponse {
7993    #[serde(rename = "approvalPolicy")]
7994    pub approval_policy: AskForApproval,
7995    #[serde(rename = "approvalsReviewer", default)]
7996    pub approvals_reviewer: Value,
7997    #[serde()]
7998    pub cwd: AbsolutePathBuf,
7999    #[serde(
8000        rename = "instructionSources",
8001        default,
8002        skip_serializing_if = "Option::is_none"
8003    )]
8004    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8005    /// Cursor for hydrating paginated items backwards via `thread/items/list`
8006    /// with `sortDirection: "desc"` (0.148 upstream).
8007    #[serde(
8008        rename = "itemsBackwardsCursor",
8009        default,
8010        skip_serializing_if = "Option::is_none"
8011    )]
8012    pub items_backwards_cursor: Option<String>,
8013    #[serde(default)]
8014    pub model: String,
8015    #[serde(rename = "modelProvider", default)]
8016    pub model_provider: String,
8017    #[serde(
8018        rename = "reasoningEffort",
8019        default,
8020        skip_serializing_if = "Option::is_none"
8021    )]
8022    pub reasoning_effort: Option<ReasoningEffort>,
8023    #[serde(default)]
8024    pub sandbox: Value,
8025    #[serde(
8026        rename = "serviceTier",
8027        default,
8028        skip_serializing_if = "Option::is_none"
8029    )]
8030    pub service_tier: Option<String>,
8031    #[serde()]
8032    pub thread: Thread,
8033    /// Cursor for hydrating paginated turns backwards via `thread/turns/list`
8034    /// with `sortDirection: "desc"` (0.148 upstream).
8035    #[serde(
8036        rename = "turnsBackwardsCursor",
8037        default,
8038        skip_serializing_if = "Option::is_none"
8039    )]
8040    pub turns_backwards_cursor: Option<String>,
8041}
8042
8043/// Persisted thread history contract (0.148 upstream).
8044#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8045pub enum ThreadHistoryMode {
8046    #[serde(rename = "legacy")]
8047    Legacy,
8048    #[serde(rename = "paginated")]
8049    Paginated,
8050}
8051
8052/// One item plus the turn that contains it, as returned by
8053/// `thread/items/list` (0.148 upstream).
8054#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8055#[serde(rename_all = "camelCase")]
8056pub struct ThreadItemEntry {
8057    #[serde()]
8058    pub item: ThreadItem,
8059    #[serde(rename = "turnId", default)]
8060    pub turn_id: String,
8061}
8062
8063/// Params for `thread/items/list` — paginated item hydration (0.148 upstream).
8064#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8065#[serde(rename_all = "camelCase")]
8066pub struct ThreadItemsListParams {
8067    #[serde(default, skip_serializing_if = "Option::is_none")]
8068    pub cursor: Option<String>,
8069    #[serde(default, skip_serializing_if = "Option::is_none")]
8070    pub limit: Option<u32>,
8071    #[serde(
8072        rename = "sortDirection",
8073        default,
8074        skip_serializing_if = "Option::is_none"
8075    )]
8076    pub sort_direction: Option<SortDirection>,
8077    #[serde(rename = "threadId", default)]
8078    pub thread_id: String,
8079    /// Optional turn id filter; omitted returns items across the thread.
8080    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8081    pub turn_id: Option<String>,
8082}
8083
8084/// Response to `thread/items/list` (0.148 upstream).
8085#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8086#[serde(rename_all = "camelCase")]
8087pub struct ThreadItemsListResponse {
8088    #[serde(
8089        rename = "backwardsCursor",
8090        default,
8091        skip_serializing_if = "Option::is_none"
8092    )]
8093    pub backwards_cursor: Option<String>,
8094    #[serde(default)]
8095    pub data: Vec<ThreadItemEntry>,
8096    #[serde(
8097        rename = "nextCursor",
8098        default,
8099        skip_serializing_if = "Option::is_none"
8100    )]
8101    pub next_cursor: Option<String>,
8102}
8103
8104/// EXPERIMENTAL upstream — a thread-scoped realtime item in the canonical
8105/// timeline (0.148). Top-level identity fields are camelCase on the wire
8106/// while variant payload fields are snake_case; mirrored exactly.
8107#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8108pub struct ThreadRealtimeItem {
8109    #[serde(default)]
8110    pub id: String,
8111    #[serde(rename = "realtimeSessionId", default)]
8112    pub realtime_session_id: String,
8113    #[serde(flatten)]
8114    pub detail: ThreadRealtimeItemDetail,
8115}
8116
8117/// The `type`-tagged payload of a [`ThreadRealtimeItem`].
8118#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8119#[serde(tag = "type", rename_all = "camelCase")]
8120pub enum ThreadRealtimeItemDetail {
8121    #[serde(rename = "realtimeSessionStarted")]
8122    RealtimeSessionStarted,
8123    #[serde(rename = "transcriptSegment")]
8124    TranscriptSegment {
8125        role: ThreadRealtimeTranscriptRole,
8126        text: String,
8127    },
8128    #[serde(rename = "bemItemPromoted")]
8129    BemItemPromoted {
8130        item_id: String,
8131        presentation: ThreadRealtimeBemItemPresentation,
8132        turn_id: String,
8133    },
8134    #[serde(rename = "realtimeSessionClosed")]
8135    RealtimeSessionClosed {
8136        outcome: ThreadRealtimeSessionOutcome,
8137    },
8138}
8139
8140/// EXPERIMENTAL upstream — how an existing agent item appears in a realtime
8141/// conversation (0.148).
8142#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8143#[serde(tag = "type", rename_all = "camelCase")]
8144pub enum ThreadRealtimeBemItemPresentation {
8145    #[serde(rename = "wholeItem")]
8146    WholeItem,
8147    #[serde(rename = "inlineMarkdown")]
8148    InlineMarkdown,
8149    #[serde(rename = "inlineVisualization")]
8150    InlineVisualization { index: u32 },
8151}
8152
8153/// EXPERIMENTAL upstream — `thread/realtime/item/started` params (0.148).
8154#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8155#[serde(rename_all = "camelCase")]
8156pub struct ThreadRealtimeItemStartedNotification {
8157    #[serde()]
8158    pub item: ThreadRealtimeItem,
8159    #[serde(rename = "threadId", default)]
8160    pub thread_id: String,
8161}
8162
8163/// EXPERIMENTAL upstream — `thread/realtime/item/completed` params (0.148).
8164#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8165#[serde(rename_all = "camelCase")]
8166pub struct ThreadRealtimeItemCompletedNotification {
8167    #[serde()]
8168    pub item: ThreadRealtimeItem,
8169    #[serde(rename = "threadId", default)]
8170    pub thread_id: String,
8171}
8172
8173/// EXPERIMENTAL upstream — `thread/realtime/item/transcript/delta` params:
8174/// text appended to an active realtime transcript item (0.148).
8175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8176#[serde(rename_all = "camelCase")]
8177pub struct ThreadRealtimeItemTranscriptDeltaNotification {
8178    #[serde(default)]
8179    pub delta: String,
8180    #[serde(rename = "itemId", default)]
8181    pub item_id: String,
8182    #[serde(rename = "threadId", default)]
8183    pub thread_id: String,
8184}
8185
8186/// EXPERIMENTAL upstream — outcome of a closed realtime session (0.148).
8187#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8188pub enum ThreadRealtimeSessionOutcome {
8189    #[serde(rename = "ended")]
8190    Ended,
8191    #[serde(rename = "failed")]
8192    Failed,
8193}
8194
8195/// EXPERIMENTAL upstream — speaker role in a realtime transcript (0.148).
8196#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8197pub enum ThreadRealtimeTranscriptRole {
8198    #[serde(rename = "user")]
8199    User,
8200    #[serde(rename = "assistant")]
8201    Assistant,
8202}
8203
8204/// Params for `thread/revert` — replace a paginated thread's durable history
8205/// with the prefix before one turn; local file changes are untouched
8206/// (0.148 upstream).
8207#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8208#[serde(rename_all = "camelCase")]
8209pub struct ThreadRevertParams {
8210    /// Turn excluded from the replacement history, with every later turn.
8211    #[serde(rename = "beforeTurnId", default)]
8212    pub before_turn_id: String,
8213    #[serde(rename = "threadId", default)]
8214    pub thread_id: String,
8215}
8216
8217/// Response to `thread/revert` (0.148 upstream). `thread.turns` is always
8218/// empty; retained history hydrates through `thread/turns/list`.
8219#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8220#[serde(rename_all = "camelCase")]
8221pub struct ThreadRevertResponse {
8222    #[serde(
8223        rename = "itemsBackwardsCursor",
8224        default,
8225        skip_serializing_if = "Option::is_none"
8226    )]
8227    pub items_backwards_cursor: Option<String>,
8228    #[serde()]
8229    pub thread: Thread,
8230    #[serde(
8231        rename = "turnsBackwardsCursor",
8232        default,
8233        skip_serializing_if = "Option::is_none"
8234    )]
8235    pub turns_backwards_cursor: Option<String>,
8236}
8237
8238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8239#[serde(rename_all = "camelCase")]
8240pub struct ThreadRollbackParams {
8241    #[serde(rename = "numTurns", default)]
8242    pub num_turns: i64,
8243    #[serde(rename = "threadId", default)]
8244    pub thread_id: String,
8245}
8246
8247#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8248#[serde(rename_all = "camelCase")]
8249pub struct ThreadRollbackResponse {
8250    #[serde(default)]
8251    pub thread: Value,
8252}
8253
8254#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8255#[serde(rename_all = "camelCase")]
8256pub struct ThreadSection {
8257    #[serde(default, skip_serializing_if = "Option::is_none")]
8258    pub appearance: Option<ThreadSectionAppearance>,
8259    #[serde(default)]
8260    pub id: String,
8261    #[serde(default)]
8262    pub name: String,
8263}
8264
8265#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8266#[serde(rename_all = "camelCase")]
8267pub struct ThreadSectionAppearance {
8268    #[serde(default, skip_serializing_if = "Option::is_none")]
8269    pub color: Option<String>,
8270    #[serde(default, skip_serializing_if = "Option::is_none")]
8271    pub icon: Option<String>,
8272}
8273
8274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8275#[serde(rename_all = "camelCase")]
8276pub struct ThreadSectionCreateParams {
8277    #[serde(default, skip_serializing_if = "Option::is_none")]
8278    pub appearance: Option<ThreadSectionAppearance>,
8279    #[serde(default)]
8280    pub name: String,
8281}
8282
8283#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8284#[serde(rename_all = "camelCase")]
8285pub struct ThreadSectionCreateResponse {
8286    #[serde()]
8287    pub section: ThreadSection,
8288}
8289
8290#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8291#[serde(rename_all = "camelCase")]
8292pub struct ThreadSectionDeleteParams {
8293    #[serde(rename = "sectionId", default)]
8294    pub section_id: String,
8295}
8296
8297#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8298#[serde(rename_all = "camelCase")]
8299pub struct ThreadSectionDeleteResponse {
8300    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8301    pub extra: serde_json::Map<String, Value>,
8302}
8303
8304#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8305#[serde(rename_all = "camelCase")]
8306pub struct ThreadSectionListParams {
8307    #[serde(default, skip_serializing_if = "Option::is_none")]
8308    pub cursor: Option<String>,
8309    #[serde(default, skip_serializing_if = "Option::is_none")]
8310    pub limit: Option<i64>,
8311}
8312
8313#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8314#[serde(rename_all = "camelCase")]
8315pub struct ThreadSectionListResponse {
8316    #[serde(default)]
8317    pub data: Vec<ThreadSection>,
8318    #[serde(
8319        rename = "nextCursor",
8320        default,
8321        skip_serializing_if = "Option::is_none"
8322    )]
8323    pub next_cursor: Option<String>,
8324}
8325
8326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8327#[serde(rename_all = "camelCase")]
8328pub struct ThreadSectionMoveParams {
8329    #[serde(
8330        rename = "beforeThreadId",
8331        default,
8332        skip_serializing_if = "Option::is_none"
8333    )]
8334    pub before_thread_id: Option<String>,
8335    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8336    pub section_id: Option<String>,
8337    #[serde(rename = "threadId", default)]
8338    pub thread_id: String,
8339}
8340
8341#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8342#[serde(rename_all = "camelCase")]
8343pub struct ThreadSectionMoveResponse {
8344    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8345    pub extra: serde_json::Map<String, Value>,
8346}
8347
8348#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8349#[serde(rename_all = "camelCase")]
8350pub struct ThreadSectionUpdateParams {
8351    #[serde(default, skip_serializing_if = "Option::is_none")]
8352    pub appearance: Option<ThreadSectionAppearance>,
8353    #[serde(default)]
8354    pub name: String,
8355    #[serde(rename = "sectionId", default)]
8356    pub section_id: String,
8357}
8358
8359#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8360#[serde(rename_all = "camelCase")]
8361pub struct ThreadSectionUpdateResponse {
8362    #[serde()]
8363    pub section: ThreadSection,
8364}
8365
8366#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8367#[serde(rename_all = "camelCase")]
8368pub struct ThreadSetNameParams {
8369    #[serde(default)]
8370    pub name: String,
8371    #[serde(rename = "threadId", default)]
8372    pub thread_id: String,
8373}
8374
8375#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8376#[serde(rename_all = "camelCase")]
8377pub struct ThreadSetNameResponse {
8378    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8379    pub extra: serde_json::Map<String, Value>,
8380}
8381
8382#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8383#[serde(rename_all = "camelCase")]
8384pub struct ThreadSettings {
8385    #[serde(
8386        rename = "activePermissionProfile",
8387        default,
8388        skip_serializing_if = "Option::is_none"
8389    )]
8390    pub active_permission_profile: Option<ActivePermissionProfile>,
8391    #[serde(rename = "approvalPolicy")]
8392    pub approval_policy: AskForApproval,
8393    #[serde(rename = "approvalsReviewer")]
8394    pub approvals_reviewer: ApprovalsReviewer,
8395    #[serde(rename = "collaborationMode")]
8396    pub collaboration_mode: CollaborationMode,
8397    #[serde()]
8398    pub cwd: AbsolutePathBuf,
8399    #[serde(default, skip_serializing_if = "Option::is_none")]
8400    pub effort: Option<ReasoningEffort>,
8401    #[serde(default)]
8402    pub model: String,
8403    #[serde(rename = "modelProvider", default)]
8404    pub model_provider: String,
8405    #[serde(default, skip_serializing_if = "Option::is_none")]
8406    pub personality: Option<Personality>,
8407    #[serde(rename = "sandboxPolicy")]
8408    pub sandbox_policy: SandboxPolicy,
8409    #[serde(
8410        rename = "serviceTier",
8411        default,
8412        skip_serializing_if = "Option::is_none"
8413    )]
8414    pub service_tier: Option<String>,
8415    #[serde(default, skip_serializing_if = "Option::is_none")]
8416    pub summary: Option<ReasoningSummary>,
8417}
8418
8419#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8420#[serde(rename_all = "camelCase")]
8421pub struct ThreadSettingsUpdatedNotification {
8422    #[serde(rename = "threadId", default)]
8423    pub thread_id: String,
8424    #[serde(rename = "threadSettings")]
8425    pub thread_settings: ThreadSettings,
8426}
8427
8428#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8429#[serde(rename_all = "camelCase")]
8430pub struct ThreadShellCommandParams {
8431    #[serde(default)]
8432    pub command: String,
8433    #[serde(rename = "threadId", default)]
8434    pub thread_id: String,
8435    /// Maximum execution time in ms; defaults to one hour when omitted.
8436    /// Zero requests an immediate timeout, not unlimited (0.148 upstream).
8437    #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
8438    pub timeout_ms: Option<i64>,
8439}
8440
8441#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8442#[serde(rename_all = "camelCase")]
8443pub struct ThreadShellCommandResponse {
8444    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8445    pub extra: serde_json::Map<String, Value>,
8446}
8447
8448#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8449pub enum ThreadSortKey {
8450    #[serde(rename = "created_at")]
8451    Created_at,
8452    #[serde(rename = "updated_at")]
8453    Updated_at,
8454    #[serde(rename = "recency_at")]
8455    Recency_at,
8456    #[serde(rename = "section_position")]
8457    Section_position,
8458}
8459
8460#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
8461#[serde(transparent)]
8462pub struct ThreadSource(pub String);
8463
8464#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8465pub enum ThreadSourceKind {
8466    #[serde(rename = "cli")]
8467    Cli,
8468    #[serde(rename = "vscode")]
8469    Vscode,
8470    #[serde(rename = "exec")]
8471    Exec,
8472    #[serde(rename = "appServer")]
8473    AppServer,
8474    #[serde(rename = "subAgent")]
8475    SubAgent,
8476    #[serde(rename = "subAgentReview")]
8477    SubAgentReview,
8478    #[serde(rename = "subAgentCompact")]
8479    SubAgentCompact,
8480    #[serde(rename = "subAgentThreadSpawn")]
8481    SubAgentThreadSpawn,
8482    #[serde(rename = "subAgentOther")]
8483    SubAgentOther,
8484    #[serde(rename = "unknown")]
8485    Unknown,
8486}
8487
8488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8489#[serde(rename_all = "camelCase")]
8490pub struct ThreadStartParams {
8491    #[serde(
8492        rename = "approvalPolicy",
8493        default,
8494        skip_serializing_if = "Option::is_none"
8495    )]
8496    pub approval_policy: Option<AskForApproval>,
8497    #[serde(
8498        rename = "approvalsReviewer",
8499        default,
8500        skip_serializing_if = "Option::is_none"
8501    )]
8502    pub approvals_reviewer: Option<ApprovalsReviewer>,
8503    #[serde(
8504        rename = "baseInstructions",
8505        default,
8506        skip_serializing_if = "Option::is_none"
8507    )]
8508    pub base_instructions: Option<String>,
8509    #[serde(default, skip_serializing_if = "Option::is_none")]
8510    pub config: Option<Value>,
8511    #[serde(default, skip_serializing_if = "Option::is_none")]
8512    pub cwd: Option<String>,
8513    #[serde(
8514        rename = "developerInstructions",
8515        default,
8516        skip_serializing_if = "Option::is_none"
8517    )]
8518    pub developer_instructions: Option<String>,
8519    #[serde(default, skip_serializing_if = "Option::is_none")]
8520    pub ephemeral: Option<bool>,
8521    #[serde(default, skip_serializing_if = "Option::is_none")]
8522    pub model: Option<String>,
8523    #[serde(
8524        rename = "modelProvider",
8525        default,
8526        skip_serializing_if = "Option::is_none"
8527    )]
8528    pub model_provider: Option<String>,
8529    #[serde(default, skip_serializing_if = "Option::is_none")]
8530    pub personality: Option<Personality>,
8531    #[serde(default, skip_serializing_if = "Option::is_none")]
8532    pub sandbox: Option<SandboxMode>,
8533    #[serde(
8534        rename = "serviceName",
8535        default,
8536        skip_serializing_if = "Option::is_none"
8537    )]
8538    pub service_name: Option<String>,
8539    #[serde(
8540        rename = "serviceTier",
8541        default,
8542        skip_serializing_if = "Option::is_none"
8543    )]
8544    pub service_tier: Option<String>,
8545    #[serde(
8546        rename = "sessionStartSource",
8547        default,
8548        skip_serializing_if = "Option::is_none"
8549    )]
8550    pub session_start_source: Option<ThreadStartSource>,
8551    #[serde(
8552        rename = "threadSource",
8553        default,
8554        skip_serializing_if = "Option::is_none"
8555    )]
8556    pub thread_source: Option<ThreadSource>,
8557}
8558
8559#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8560#[serde(rename_all = "camelCase")]
8561pub struct ThreadStartResponse {
8562    #[serde(rename = "approvalPolicy")]
8563    pub approval_policy: AskForApproval,
8564    #[serde(rename = "approvalsReviewer", default)]
8565    pub approvals_reviewer: Value,
8566    #[serde()]
8567    pub cwd: AbsolutePathBuf,
8568    #[serde(
8569        rename = "instructionSources",
8570        default,
8571        skip_serializing_if = "Option::is_none"
8572    )]
8573    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8574    #[serde(default)]
8575    pub model: String,
8576    #[serde(rename = "modelProvider", default)]
8577    pub model_provider: String,
8578    #[serde(
8579        rename = "reasoningEffort",
8580        default,
8581        skip_serializing_if = "Option::is_none"
8582    )]
8583    pub reasoning_effort: Option<ReasoningEffort>,
8584    #[serde(default)]
8585    pub sandbox: Value,
8586    #[serde(
8587        rename = "serviceTier",
8588        default,
8589        skip_serializing_if = "Option::is_none"
8590    )]
8591    pub service_tier: Option<String>,
8592    #[serde()]
8593    pub thread: Thread,
8594}
8595
8596#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8597pub enum ThreadStartSource {
8598    #[serde(rename = "startup")]
8599    Startup,
8600    #[serde(rename = "clear")]
8601    Clear,
8602}
8603
8604#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8605#[serde(rename_all = "camelCase")]
8606pub struct ThreadStartedNotification {
8607    #[serde()]
8608    pub thread: Thread,
8609}
8610
8611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8612#[serde(tag = "type", rename_all = "camelCase")]
8613pub enum ThreadStatus {
8614    #[serde(rename = "notLoaded")]
8615    NotLoaded,
8616    Idle,
8617    #[serde(rename = "systemError")]
8618    SystemError,
8619    Active {
8620        #[serde(rename = "activeFlags")]
8621        active_flags: Vec<ThreadActiveFlag>,
8622    },
8623}
8624
8625#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8626#[serde(rename_all = "camelCase")]
8627pub struct ThreadStatusChangedNotification {
8628    #[serde()]
8629    pub status: ThreadStatus,
8630    #[serde(rename = "threadId", default)]
8631    pub thread_id: String,
8632}
8633
8634#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8635#[serde(rename_all = "camelCase")]
8636pub struct ThreadTokenUsage {
8637    #[serde()]
8638    pub last: TokenUsageBreakdown,
8639    #[serde(
8640        rename = "modelContextWindow",
8641        default,
8642        skip_serializing_if = "Option::is_none"
8643    )]
8644    pub model_context_window: Option<i64>,
8645    #[serde()]
8646    pub total: TokenUsageBreakdown,
8647}
8648
8649#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8650#[serde(rename_all = "camelCase")]
8651pub struct ThreadTokenUsageUpdatedNotification {
8652    #[serde(rename = "threadId", default)]
8653    pub thread_id: String,
8654    #[serde(rename = "tokenUsage")]
8655    pub token_usage: ThreadTokenUsage,
8656    #[serde(rename = "turnId", default)]
8657    pub turn_id: String,
8658}
8659
8660#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8661#[serde(rename_all = "camelCase")]
8662pub struct ThreadUnarchiveParams {
8663    #[serde(rename = "threadId", default)]
8664    pub thread_id: String,
8665}
8666
8667#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8668#[serde(rename_all = "camelCase")]
8669pub struct ThreadUnarchiveResponse {
8670    #[serde()]
8671    pub thread: Thread,
8672}
8673
8674#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8675#[serde(rename_all = "camelCase")]
8676pub struct ThreadUnarchivedNotification {
8677    #[serde(rename = "threadId", default)]
8678    pub thread_id: String,
8679}
8680
8681/// EXPERIMENTAL upstream — one item or turn boundary in canonical rollout
8682/// order (0.148). Wire quirk mirrored exactly: the `item` variant uses
8683/// camelCase `turnId` while the turn-boundary variants use snake_case
8684/// `turn_id`/`started_at`/`completed_at`/`duration_ms`.
8685#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8686#[serde(tag = "type", rename_all = "camelCase")]
8687#[allow(clippy::large_enum_variant)] // transient per-entry wire value, not stored in bulk
8688pub enum ThreadTimelineEntry {
8689    Item {
8690        item: ThreadItem,
8691        position: u64,
8692        #[serde(rename = "turnId")]
8693        turn_id: String,
8694    },
8695    Realtime {
8696        item: ThreadRealtimeItem,
8697        position: u64,
8698    },
8699    TurnStarted {
8700        position: u64,
8701        #[serde(default, skip_serializing_if = "Option::is_none")]
8702        started_at: Option<i64>,
8703        turn_id: String,
8704    },
8705    TurnCompleted {
8706        #[serde(default, skip_serializing_if = "Option::is_none")]
8707        completed_at: Option<i64>,
8708        #[serde(default, skip_serializing_if = "Option::is_none")]
8709        duration_ms: Option<i64>,
8710        #[serde(default, skip_serializing_if = "Option::is_none")]
8711        error: Option<TurnError>,
8712        position: u64,
8713        #[serde(default, skip_serializing_if = "Option::is_none")]
8714        started_at: Option<i64>,
8715        status: TurnStatus,
8716        turn_id: String,
8717    },
8718}
8719
8720/// Params for `thread/turns/list` — paginated turn hydration (0.148 upstream).
8721#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8722#[serde(rename_all = "camelCase")]
8723pub struct ThreadTurnsListParams {
8724    #[serde(default, skip_serializing_if = "Option::is_none")]
8725    pub cursor: Option<String>,
8726    /// How much item detail to include per turn; defaults to summary.
8727    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
8728    pub items_view: Option<TurnItemsView>,
8729    #[serde(default, skip_serializing_if = "Option::is_none")]
8730    pub limit: Option<u32>,
8731    #[serde(
8732        rename = "sortDirection",
8733        default,
8734        skip_serializing_if = "Option::is_none"
8735    )]
8736    pub sort_direction: Option<SortDirection>,
8737    #[serde(rename = "threadId", default)]
8738    pub thread_id: String,
8739}
8740
8741/// Response to `thread/turns/list` (0.148 upstream).
8742#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8743#[serde(rename_all = "camelCase")]
8744pub struct ThreadTurnsListResponse {
8745    #[serde(
8746        rename = "backwardsCursor",
8747        default,
8748        skip_serializing_if = "Option::is_none"
8749    )]
8750    pub backwards_cursor: Option<String>,
8751    #[serde(default)]
8752    pub data: Vec<Turn>,
8753    #[serde(
8754        rename = "nextCursor",
8755        default,
8756        skip_serializing_if = "Option::is_none"
8757    )]
8758    pub next_cursor: Option<String>,
8759}
8760
8761#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8762#[serde(rename_all = "camelCase")]
8763pub struct ThreadUnsubscribeParams {
8764    #[serde(rename = "threadId", default)]
8765    pub thread_id: String,
8766}
8767
8768#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8769#[serde(rename_all = "camelCase")]
8770pub struct ThreadUnsubscribeResponse {
8771    #[serde()]
8772    pub status: ThreadUnsubscribeStatus,
8773}
8774
8775#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8776pub enum ThreadUnsubscribeStatus {
8777    #[serde(rename = "notLoaded")]
8778    NotLoaded,
8779    #[serde(rename = "notSubscribed")]
8780    NotSubscribed,
8781    #[serde(rename = "unsubscribed")]
8782    Unsubscribed,
8783}
8784
8785#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8786#[serde(rename_all = "camelCase")]
8787pub struct TokenUsageBreakdown {
8788    #[serde(
8789        rename = "cacheWriteInputTokens",
8790        default,
8791        skip_serializing_if = "Option::is_none"
8792    )]
8793    pub cache_write_input_tokens: Option<i64>,
8794    #[serde(rename = "cachedInputTokens", default)]
8795    pub cached_input_tokens: i64,
8796    #[serde(rename = "inputTokens", default)]
8797    pub input_tokens: i64,
8798    #[serde(rename = "outputTokens", default)]
8799    pub output_tokens: i64,
8800    #[serde(rename = "reasoningOutputTokens", default)]
8801    pub reasoning_output_tokens: i64,
8802    #[serde(rename = "totalTokens", default)]
8803    pub total_tokens: i64,
8804}
8805
8806#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8807#[serde(rename_all = "camelCase")]
8808pub struct Tool {
8809    #[serde(default, skip_serializing_if = "Option::is_none")]
8810    pub _meta: Option<Value>,
8811    #[serde(default, skip_serializing_if = "Option::is_none")]
8812    pub annotations: Option<Value>,
8813    #[serde(default, skip_serializing_if = "Option::is_none")]
8814    pub description: Option<String>,
8815    #[serde(default, skip_serializing_if = "Option::is_none")]
8816    pub icons: Option<Vec<Value>>,
8817    #[serde(rename = "inputSchema", default)]
8818    pub input_schema: Value,
8819    #[serde(default)]
8820    pub name: String,
8821    #[serde(
8822        rename = "outputSchema",
8823        default,
8824        skip_serializing_if = "Option::is_none"
8825    )]
8826    pub output_schema: Option<Value>,
8827    #[serde(default, skip_serializing_if = "Option::is_none")]
8828    pub title: Option<String>,
8829}
8830
8831#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8832#[serde(rename_all = "camelCase")]
8833pub struct ToolRequestUserInputAnswer {
8834    #[serde(default)]
8835    pub answers: Vec<String>,
8836}
8837
8838#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8839#[serde(rename_all = "camelCase")]
8840pub struct ToolRequestUserInputOption {
8841    #[serde(default)]
8842    pub description: String,
8843    #[serde(default)]
8844    pub label: String,
8845}
8846
8847#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8848#[serde(rename_all = "camelCase")]
8849pub struct ToolRequestUserInputParams {
8850    #[serde(
8851        rename = "autoResolutionMs",
8852        default,
8853        skip_serializing_if = "Option::is_none"
8854    )]
8855    pub auto_resolution_ms: Option<i64>,
8856    #[serde(rename = "isBlocking", default)]
8857    pub is_blocking: bool,
8858    #[serde(rename = "itemId", default)]
8859    pub item_id: String,
8860    #[serde(default)]
8861    pub questions: Vec<ToolRequestUserInputQuestion>,
8862    #[serde(rename = "threadId", default)]
8863    pub thread_id: String,
8864    #[serde(rename = "turnId", default)]
8865    pub turn_id: String,
8866}
8867
8868#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8869#[serde(rename_all = "camelCase")]
8870pub struct ToolRequestUserInputQuestion {
8871    #[serde(default)]
8872    pub header: String,
8873    #[serde(default)]
8874    pub id: String,
8875    #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
8876    pub is_other: Option<bool>,
8877    #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
8878    pub is_secret: Option<bool>,
8879    #[serde(default, skip_serializing_if = "Option::is_none")]
8880    pub options: Option<Vec<ToolRequestUserInputOption>>,
8881    #[serde(default)]
8882    pub question: String,
8883}
8884
8885#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8886#[serde(rename_all = "camelCase")]
8887pub struct ToolRequestUserInputResponse {
8888    #[serde(default)]
8889    pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
8890}
8891
8892#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8893#[serde(rename_all = "camelCase")]
8894pub struct ToolsV2 {
8895    #[serde(default, skip_serializing_if = "Option::is_none")]
8896    pub web_search: Option<WebSearchToolConfig>,
8897}
8898
8899#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8900#[serde(rename_all = "camelCase")]
8901pub struct Turn {
8902    #[serde(
8903        rename = "completedAt",
8904        default,
8905        skip_serializing_if = "Option::is_none"
8906    )]
8907    pub completed_at: Option<i64>,
8908    #[serde(
8909        rename = "durationMs",
8910        default,
8911        skip_serializing_if = "Option::is_none"
8912    )]
8913    pub duration_ms: Option<i64>,
8914    #[serde(default, skip_serializing_if = "Option::is_none")]
8915    pub error: Option<TurnError>,
8916    #[serde(default)]
8917    pub id: String,
8918    #[serde(default)]
8919    pub items: Vec<ThreadItem>,
8920    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
8921    pub items_view: Option<Value>,
8922    #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
8923    pub started_at: Option<i64>,
8924    #[serde()]
8925    pub status: TurnStatus,
8926}
8927
8928#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8929#[serde(rename_all = "camelCase")]
8930pub struct TurnCompletedNotification {
8931    #[serde(rename = "threadId", default)]
8932    pub thread_id: String,
8933    #[serde()]
8934    pub turn: Turn,
8935}
8936
8937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8938#[serde(rename_all = "camelCase")]
8939pub struct TurnDiffUpdatedNotification {
8940    #[serde(default)]
8941    pub diff: String,
8942    #[serde(rename = "threadId", default)]
8943    pub thread_id: String,
8944    #[serde(rename = "turnId", default)]
8945    pub turn_id: String,
8946}
8947
8948#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8949#[serde(rename_all = "camelCase")]
8950pub struct TurnError {
8951    #[serde(
8952        rename = "additionalDetails",
8953        default,
8954        skip_serializing_if = "Option::is_none"
8955    )]
8956    pub additional_details: Option<String>,
8957    #[serde(
8958        rename = "codexErrorInfo",
8959        default,
8960        skip_serializing_if = "Option::is_none"
8961    )]
8962    pub codex_error_info: Option<CodexErrorInfo>,
8963    #[serde(default)]
8964    pub message: String,
8965    /// Public explanation and continuation instruction for a misalignment
8966    /// block (0.148 upstream).
8967    #[serde(default, skip_serializing_if = "Option::is_none")]
8968    pub misalignment: Option<MisalignmentErrorDetails>,
8969}
8970
8971#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8972#[serde(rename_all = "camelCase")]
8973pub struct TurnInterruptParams {
8974    #[serde(rename = "threadId", default)]
8975    pub thread_id: String,
8976    #[serde(rename = "turnId", default)]
8977    pub turn_id: String,
8978}
8979
8980#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8981#[serde(rename_all = "camelCase")]
8982pub struct TurnInterruptResponse {
8983    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8984    pub extra: serde_json::Map<String, Value>,
8985}
8986
8987#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
8988pub enum TurnItemsView {
8989    #[serde(rename = "notLoaded")]
8990    NotLoaded,
8991    #[serde(rename = "summary")]
8992    Summary,
8993    #[serde(rename = "full")]
8994    Full,
8995}
8996
8997#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8998#[serde(rename_all = "camelCase")]
8999pub struct TurnModerationMetadataNotification {
9000    #[serde(default)]
9001    pub metadata: Value,
9002    #[serde(rename = "threadId", default)]
9003    pub thread_id: String,
9004    #[serde(rename = "turnId", default)]
9005    pub turn_id: String,
9006}
9007
9008#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9009#[serde(rename_all = "camelCase")]
9010pub struct TurnPlanStep {
9011    #[serde()]
9012    pub status: TurnPlanStepStatus,
9013    #[serde(default)]
9014    pub step: String,
9015}
9016
9017#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9018pub enum TurnPlanStepStatus {
9019    #[serde(rename = "pending")]
9020    Pending,
9021    #[serde(rename = "inProgress")]
9022    InProgress,
9023    #[serde(rename = "completed")]
9024    Completed,
9025}
9026
9027#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9028#[serde(rename_all = "camelCase")]
9029pub struct TurnPlanUpdatedNotification {
9030    #[serde(default, skip_serializing_if = "Option::is_none")]
9031    pub explanation: Option<String>,
9032    #[serde(default)]
9033    pub plan: Vec<TurnPlanStep>,
9034    #[serde(rename = "threadId", default)]
9035    pub thread_id: String,
9036    #[serde(rename = "turnId", default)]
9037    pub turn_id: String,
9038}
9039
9040#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9041#[serde(rename_all = "camelCase")]
9042pub struct TurnStartParams {
9043    #[serde(
9044        rename = "approvalPolicy",
9045        default,
9046        skip_serializing_if = "Option::is_none"
9047    )]
9048    pub approval_policy: Option<AskForApproval>,
9049    #[serde(
9050        rename = "approvalsReviewer",
9051        default,
9052        skip_serializing_if = "Option::is_none"
9053    )]
9054    pub approvals_reviewer: Option<ApprovalsReviewer>,
9055    #[serde(
9056        rename = "clientUserMessageId",
9057        default,
9058        skip_serializing_if = "Option::is_none"
9059    )]
9060    pub client_user_message_id: Option<String>,
9061    #[serde(default, skip_serializing_if = "Option::is_none")]
9062    pub cwd: Option<String>,
9063    #[serde(default, skip_serializing_if = "Option::is_none")]
9064    pub effort: Option<ReasoningEffort>,
9065    #[serde(default)]
9066    pub input: Vec<UserInput>,
9067    #[serde(default, skip_serializing_if = "Option::is_none")]
9068    pub model: Option<String>,
9069    #[serde(
9070        rename = "outputSchema",
9071        default,
9072        skip_serializing_if = "Option::is_none"
9073    )]
9074    pub output_schema: Option<Value>,
9075    #[serde(default, skip_serializing_if = "Option::is_none")]
9076    pub personality: Option<Personality>,
9077    #[serde(
9078        rename = "sandboxPolicy",
9079        default,
9080        skip_serializing_if = "Option::is_none"
9081    )]
9082    pub sandbox_policy: Option<SandboxPolicy>,
9083    #[serde(
9084        rename = "serviceTier",
9085        default,
9086        skip_serializing_if = "Option::is_none"
9087    )]
9088    pub service_tier: Option<String>,
9089    /// One-turn service-tier override; `"default"` for standard speed.
9090    /// Omitted or null inherits the thread's tier (0.148 upstream).
9091    #[serde(
9092        rename = "serviceTierForTurn",
9093        default,
9094        skip_serializing_if = "Option::is_none"
9095    )]
9096    pub service_tier_for_turn: Option<String>,
9097    #[serde(default, skip_serializing_if = "Option::is_none")]
9098    pub summary: Option<ReasoningSummary>,
9099    #[serde(rename = "threadId", default)]
9100    pub thread_id: String,
9101    /// Pre-computed tool output to inject when starting the turn
9102    /// (0.148 upstream).
9103    #[serde(
9104        rename = "toolOutput",
9105        default,
9106        skip_serializing_if = "Option::is_none"
9107    )]
9108    pub tool_output: Option<TurnToolOutput>,
9109    /// Optional source classification for the caller starting this turn;
9110    /// ignored when steering an already-active turn (0.148 upstream).
9111    #[serde(
9112        rename = "turnTrigger",
9113        default,
9114        skip_serializing_if = "Option::is_none"
9115    )]
9116    pub turn_trigger: Option<String>,
9117}
9118
9119#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9120#[serde(rename_all = "camelCase")]
9121pub struct TurnStartResponse {
9122    #[serde()]
9123    pub turn: Turn,
9124}
9125
9126#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9127#[serde(rename_all = "camelCase")]
9128pub struct TurnStartedNotification {
9129    #[serde(rename = "threadId", default)]
9130    pub thread_id: String,
9131    #[serde()]
9132    pub turn: Turn,
9133}
9134
9135#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9136pub enum TurnStatus {
9137    #[serde(rename = "completed")]
9138    Completed,
9139    #[serde(rename = "interrupted")]
9140    Interrupted,
9141    #[serde(rename = "failed")]
9142    Failed,
9143    #[serde(rename = "inProgress")]
9144    InProgress,
9145}
9146
9147/// A pre-computed tool output supplied when starting a turn
9148/// (`TurnStartParams.toolOutput`, 0.148 upstream).
9149#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9150#[serde(rename_all = "camelCase")]
9151pub struct TurnToolOutput {
9152    #[serde(default)]
9153    pub name: String,
9154    #[serde(default, skip_serializing_if = "Option::is_none")]
9155    pub namespace: Option<String>,
9156    #[serde()]
9157    pub output: FunctionCallOutputBody,
9158}
9159
9160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9161#[serde(rename_all = "camelCase")]
9162pub struct TurnSteerParams {
9163    #[serde(
9164        rename = "clientUserMessageId",
9165        default,
9166        skip_serializing_if = "Option::is_none"
9167    )]
9168    pub client_user_message_id: Option<String>,
9169    #[serde(rename = "expectedTurnId", default)]
9170    pub expected_turn_id: String,
9171    #[serde(default)]
9172    pub input: Vec<UserInput>,
9173    #[serde(rename = "threadId", default)]
9174    pub thread_id: String,
9175}
9176
9177#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9178#[serde(rename_all = "camelCase")]
9179pub struct TurnSteerResponse {
9180    #[serde(rename = "turnId", default)]
9181    pub turn_id: String,
9182}
9183
9184#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9185#[serde(tag = "type", rename_all = "camelCase")]
9186pub enum UserInput {
9187    Text {
9188        text: String,
9189        #[serde(default, skip_serializing_if = "Option::is_none")]
9190        text_elements: Option<Vec<TextElement>>,
9191    },
9192    Image {
9193        #[serde(default, skip_serializing_if = "Option::is_none")]
9194        detail: Option<ImageDetail>,
9195        url: String,
9196    },
9197    #[serde(rename = "localImage")]
9198    LocalImage {
9199        #[serde(default, skip_serializing_if = "Option::is_none")]
9200        detail: Option<ImageDetail>,
9201        path: String,
9202    },
9203    Audio {
9204        url: String,
9205    },
9206    #[serde(rename = "localAudio")]
9207    LocalAudio {
9208        path: String,
9209    },
9210    Skill {
9211        name: String,
9212        path: String,
9213    },
9214    Mention {
9215        name: String,
9216        path: String,
9217    },
9218}
9219
9220#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9221pub enum Verbosity {
9222    #[serde(rename = "low")]
9223    Low,
9224    #[serde(rename = "medium")]
9225    Medium,
9226    #[serde(rename = "high")]
9227    High,
9228}
9229
9230#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9231#[serde(rename_all = "camelCase")]
9232pub struct WarningNotification {
9233    #[serde(default)]
9234    pub message: String,
9235    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
9236    pub thread_id: Option<String>,
9237}
9238
9239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9240#[serde(tag = "type", rename_all = "camelCase")]
9241pub enum WebSearchAction {
9242    Search {
9243        #[serde(default, skip_serializing_if = "Option::is_none")]
9244        queries: Option<Vec<String>>,
9245        #[serde(default, skip_serializing_if = "Option::is_none")]
9246        query: Option<String>,
9247    },
9248    #[serde(rename = "openPage")]
9249    OpenPage {
9250        #[serde(default, skip_serializing_if = "Option::is_none")]
9251        url: Option<String>,
9252    },
9253    #[serde(rename = "findInPage")]
9254    FindInPage {
9255        #[serde(default, skip_serializing_if = "Option::is_none")]
9256        pattern: Option<String>,
9257        #[serde(default, skip_serializing_if = "Option::is_none")]
9258        url: Option<String>,
9259    },
9260    Other,
9261}
9262
9263#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9264pub enum WebSearchContextSize {
9265    #[serde(rename = "low")]
9266    Low,
9267    #[serde(rename = "medium")]
9268    Medium,
9269    #[serde(rename = "high")]
9270    High,
9271}
9272
9273#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9274#[serde(rename_all = "camelCase")]
9275pub struct WebSearchLocation {
9276    #[serde(default, skip_serializing_if = "Option::is_none")]
9277    pub city: Option<String>,
9278    #[serde(default, skip_serializing_if = "Option::is_none")]
9279    pub country: Option<String>,
9280    #[serde(default, skip_serializing_if = "Option::is_none")]
9281    pub region: Option<String>,
9282    #[serde(default, skip_serializing_if = "Option::is_none")]
9283    pub timezone: Option<String>,
9284}
9285
9286#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9287pub enum WebSearchMode {
9288    #[serde(rename = "disabled")]
9289    Disabled,
9290    #[serde(rename = "cached")]
9291    Cached,
9292    #[serde(rename = "indexed")]
9293    Indexed,
9294    #[serde(rename = "live")]
9295    Live,
9296}
9297
9298#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9299#[serde(rename_all = "camelCase")]
9300pub struct WebSearchToolConfig {
9301    #[serde(default, skip_serializing_if = "Option::is_none")]
9302    pub allowed_domains: Option<Vec<String>>,
9303    #[serde(default, skip_serializing_if = "Option::is_none")]
9304    pub context_size: Option<WebSearchContextSize>,
9305    #[serde(default, skip_serializing_if = "Option::is_none")]
9306    pub location: Option<WebSearchLocation>,
9307}
9308
9309#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9310pub enum WindowsSandboxReadiness {
9311    #[serde(rename = "ready")]
9312    Ready,
9313    #[serde(rename = "notConfigured")]
9314    NotConfigured,
9315    #[serde(rename = "updateRequired")]
9316    UpdateRequired,
9317}
9318
9319#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9320#[serde(rename_all = "camelCase")]
9321pub struct WindowsSandboxReadinessResponse {
9322    #[serde()]
9323    pub status: WindowsSandboxReadiness,
9324}
9325
9326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9327#[serde(rename_all = "camelCase")]
9328pub struct WindowsSandboxSetupCompletedNotification {
9329    #[serde(default, skip_serializing_if = "Option::is_none")]
9330    pub error: Option<String>,
9331    #[serde()]
9332    pub mode: WindowsSandboxSetupMode,
9333    #[serde(default)]
9334    pub success: bool,
9335}
9336
9337#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9338pub enum WindowsSandboxSetupMode {
9339    #[serde(rename = "elevated")]
9340    Elevated,
9341    #[serde(rename = "unelevated")]
9342    Unelevated,
9343}
9344
9345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9346#[serde(rename_all = "camelCase")]
9347pub struct WindowsSandboxSetupStartParams {
9348    #[serde(default, skip_serializing_if = "Option::is_none")]
9349    pub cwd: Option<AbsolutePathBuf>,
9350    #[serde()]
9351    pub mode: WindowsSandboxSetupMode,
9352}
9353
9354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9355#[serde(rename_all = "camelCase")]
9356pub struct WindowsSandboxSetupStartResponse {
9357    #[serde(default)]
9358    pub started: bool,
9359}
9360
9361#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9362#[serde(rename_all = "camelCase")]
9363pub struct WindowsWorldWritableWarningNotification {
9364    #[serde(rename = "extraCount", default)]
9365    pub extra_count: i64,
9366    #[serde(rename = "failedScan", default)]
9367    pub failed_scan: bool,
9368    #[serde(rename = "samplePaths", default)]
9369    pub sample_paths: Vec<String>,
9370}
9371
9372#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9373#[serde(rename_all = "camelCase")]
9374pub struct WorkspaceMessage {
9375    #[serde(
9376        rename = "archivedAt",
9377        default,
9378        skip_serializing_if = "Option::is_none"
9379    )]
9380    pub archived_at: Option<i64>,
9381    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
9382    pub created_at: Option<i64>,
9383    #[serde(rename = "messageBody", default)]
9384    pub message_body: String,
9385    #[serde(rename = "messageId", default)]
9386    pub message_id: String,
9387    #[serde(rename = "messageType")]
9388    pub message_type: WorkspaceMessageType,
9389}
9390
9391#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9392pub enum WorkspaceMessageType {
9393    #[serde(rename = "headline")]
9394    Headline,
9395    #[serde(rename = "announcement")]
9396    Announcement,
9397    #[serde(rename = "unknown")]
9398    Unknown,
9399}
9400
9401#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9402pub enum WriteStatus {
9403    #[serde(rename = "ok")]
9404    Ok,
9405    #[serde(rename = "okOverridden")]
9406    OkOverridden,
9407}
codex_codes/protocol_generated/types.rs

codex_codes/protocol_generated/
types.rs
