Skip to main content

codex_codes/protocol_generated/
types.rs

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