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

codex_codes/protocol_generated/
types.rs
