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    /// Explicit hosted app/account. Omit to retain legacy resource discovery.
4138    #[serde(default, skip_serializing_if = "Option::is_none")]
4139    pub target: Option<McpResourceReadTarget>,
4140    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4141    pub thread_id: Option<String>,
4142    #[serde(default)]
4143    pub uri: String,
4144}
4145
4146/// Explicit hosted app/account selector for `mcpServer/resource/read`.
4147#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4148#[serde(rename_all = "camelCase")]
4149pub struct McpResourceReadTarget {
4150    #[serde(rename = "connectorId", default)]
4151    pub connector_id: String,
4152    /// Null explicitly requests no-auth access, subject to the app's resource
4153    /// policy. Always serialized (the wire field is required but nullable).
4154    #[serde(rename = "linkId", default)]
4155    pub link_id: Option<String>,
4156}
4157
4158#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4159#[serde(rename_all = "camelCase")]
4160pub struct McpResourceReadResponse {
4161    #[serde(default)]
4162    pub contents: Vec<ResourceContent>,
4163    /// Originating call when the server applied app-specific resource
4164    /// scoping.
4165    #[serde(
4166        rename = "originCallId",
4167        default,
4168        skip_serializing_if = "Option::is_none"
4169    )]
4170    pub origin_call_id: Option<String>,
4171}
4172
4173#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4174pub enum McpServerElicitationAction {
4175    #[serde(rename = "accept")]
4176    Accept,
4177    #[serde(rename = "decline")]
4178    Decline,
4179    #[serde(rename = "cancel")]
4180    Cancel,
4181}
4182
4183#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4184#[serde(tag = "mode", rename_all = "camelCase")]
4185pub enum McpServerElicitationRequestParams {
4186    Form {
4187        #[serde(default, skip_serializing_if = "Option::is_none")]
4188        _meta: Option<Value>,
4189        message: String,
4190        #[serde(rename = "requestedSchema")]
4191        requested_schema: McpElicitationSchema,
4192    },
4193    #[serde(rename = "openai/form")]
4194    OpenaiForm {
4195        #[serde(default, skip_serializing_if = "Option::is_none")]
4196        _meta: Option<Value>,
4197        message: String,
4198        #[serde(rename = "requestedSchema")]
4199        requested_schema: Value,
4200    },
4201    #[serde(rename = "openaiForm")]
4202    OpenAiElicitationForm {
4203        #[serde(default, skip_serializing_if = "Option::is_none")]
4204        _meta: Option<Value>,
4205        message: String,
4206        #[serde(rename = "requestedSchema")]
4207        requested_schema: Value,
4208    },
4209    Url {
4210        #[serde(default, skip_serializing_if = "Option::is_none")]
4211        _meta: Option<Value>,
4212        #[serde(rename = "elicitationId")]
4213        elicitation_id: String,
4214        message: String,
4215        url: String,
4216    },
4217}
4218
4219#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4220#[serde(rename_all = "camelCase")]
4221pub struct McpServerElicitationRequestResponse {
4222    #[serde(default, skip_serializing_if = "Option::is_none")]
4223    pub _meta: Option<Value>,
4224    #[serde()]
4225    pub action: McpServerElicitationAction,
4226    #[serde(default, skip_serializing_if = "Option::is_none")]
4227    pub content: Option<Value>,
4228}
4229
4230#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4231#[serde(rename_all = "camelCase")]
4232pub struct McpServerInfo {
4233    #[serde(default, skip_serializing_if = "Option::is_none")]
4234    pub description: Option<String>,
4235    #[serde(default, skip_serializing_if = "Option::is_none")]
4236    pub icons: Option<Vec<Value>>,
4237    #[serde(default)]
4238    pub name: String,
4239    #[serde(default, skip_serializing_if = "Option::is_none")]
4240    pub title: Option<String>,
4241    #[serde(default)]
4242    pub version: String,
4243    #[serde(
4244        rename = "websiteUrl",
4245        default,
4246        skip_serializing_if = "Option::is_none"
4247    )]
4248    pub website_url: Option<String>,
4249}
4250
4251#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4252#[serde(rename_all = "camelCase")]
4253pub struct McpServerMigration {
4254    #[serde(default)]
4255    pub name: String,
4256}
4257
4258#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4259#[serde(rename_all = "camelCase")]
4260pub struct McpServerOauthLoginCompletedNotification {
4261    #[serde(default, skip_serializing_if = "Option::is_none")]
4262    pub error: Option<String>,
4263    #[serde(default)]
4264    pub name: String,
4265    #[serde(default)]
4266    pub success: bool,
4267    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4268    pub thread_id: Option<String>,
4269}
4270
4271#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4272#[serde(rename_all = "camelCase")]
4273pub struct McpServerOauthLoginParams {
4274    #[serde(
4275        rename = "clientRegistration",
4276        default,
4277        skip_serializing_if = "Option::is_none"
4278    )]
4279    pub client_registration: Option<McpServerOauthClientRegistration>,
4280    #[serde(default)]
4281    pub name: String,
4282    #[serde(default, skip_serializing_if = "Option::is_none")]
4283    pub scopes: Option<Vec<String>>,
4284    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4285    pub thread_id: Option<String>,
4286    #[serde(
4287        rename = "timeoutSecs",
4288        default,
4289        skip_serializing_if = "Option::is_none"
4290    )]
4291    pub timeout_secs: Option<i64>,
4292}
4293
4294#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4295#[serde(rename_all = "camelCase")]
4296pub struct McpServerOauthLoginResponse {
4297    #[serde(rename = "authorizationUrl", default)]
4298    pub authorization_url: String,
4299}
4300
4301#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4302#[serde(rename_all = "camelCase")]
4303pub struct McpServerRefreshResponse {
4304    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4305    pub extra: serde_json::Map<String, Value>,
4306}
4307
4308#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4309pub enum McpServerStartupFailureReason {
4310    #[serde(rename = "reauthenticationRequired")]
4311    ReauthenticationRequired,
4312}
4313
4314#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4315pub enum McpServerStartupState {
4316    #[serde(rename = "starting")]
4317    Starting,
4318    #[serde(rename = "ready")]
4319    Ready,
4320    #[serde(rename = "failed")]
4321    Failed,
4322    #[serde(rename = "cancelled")]
4323    Cancelled,
4324}
4325
4326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4327#[serde(rename_all = "camelCase")]
4328pub struct McpServerStatus {
4329    #[serde(rename = "authStatus")]
4330    pub auth_status: McpAuthStatus,
4331    /// HTTP origin of the effective configured endpoint, including plugin
4332    /// servers. Excludes credentials, path, query, and fragment; `None` for
4333    /// non-HTTP transports.
4334    #[serde(
4335        rename = "httpOrigin",
4336        default,
4337        skip_serializing_if = "Option::is_none"
4338    )]
4339    pub http_origin: Option<String>,
4340    /// Current thread-runtime connection state; absent when unavailable.
4341    #[serde(
4342        rename = "runtimeStatus",
4343        default,
4344        skip_serializing_if = "Option::is_none"
4345    )]
4346    pub runtime_status: Option<McpServerConnectionStatus>,
4347    #[serde(default)]
4348    pub name: String,
4349    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
4350    pub plugin_id: Option<String>,
4351    #[serde(rename = "resourceTemplates", default)]
4352    pub resource_templates: Vec<ResourceTemplate>,
4353    #[serde(default)]
4354    pub resources: Vec<Resource>,
4355    /// Capabilities advertised by the initialized MCP server; `None` when
4356    /// unavailable.
4357    #[serde(
4358        rename = "serverCapabilities",
4359        default,
4360        skip_serializing_if = "Option::is_none"
4361    )]
4362    pub server_capabilities: Option<Value>,
4363    #[serde(
4364        rename = "serverInfo",
4365        default,
4366        skip_serializing_if = "Option::is_none"
4367    )]
4368    pub server_info: Option<McpServerInfo>,
4369    #[serde(default)]
4370    pub tools: std::collections::BTreeMap<String, Tool>,
4371    /// Tool discovery failed and no catalog was returned. `None` when a
4372    /// catalog is returned, including cached or empty catalogs.
4373    #[serde(
4374        rename = "toolsError",
4375        default,
4376        skip_serializing_if = "Option::is_none"
4377    )]
4378    pub tools_error: Option<String>,
4379}
4380
4381#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4382pub enum McpServerStatusDetail {
4383    #[serde(rename = "full")]
4384    Full,
4385    #[serde(rename = "toolsAndAuthOnly")]
4386    ToolsAndAuthOnly,
4387}
4388
4389#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4390#[serde(rename_all = "camelCase")]
4391pub struct McpServerStatusUpdatedNotification {
4392    #[serde(default, skip_serializing_if = "Option::is_none")]
4393    pub error: Option<String>,
4394    #[serde(
4395        rename = "failureReason",
4396        default,
4397        skip_serializing_if = "Option::is_none"
4398    )]
4399    pub failure_reason: Option<McpServerStartupFailureReason>,
4400    #[serde(default)]
4401    pub name: String,
4402    #[serde()]
4403    pub status: McpServerStartupState,
4404    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4405    pub thread_id: Option<String>,
4406}
4407
4408#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4409#[serde(rename_all = "camelCase")]
4410pub struct McpServerToolCallParams {
4411    #[serde(default, skip_serializing_if = "Option::is_none")]
4412    pub _meta: Option<Value>,
4413    #[serde(default, skip_serializing_if = "Option::is_none")]
4414    pub arguments: Option<Value>,
4415    #[serde(default)]
4416    pub server: String,
4417    #[serde(rename = "threadId", default)]
4418    pub thread_id: String,
4419    #[serde(default)]
4420    pub tool: String,
4421}
4422
4423#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4424#[serde(rename_all = "camelCase")]
4425pub struct McpServerToolCallResponse {
4426    #[serde(default, skip_serializing_if = "Option::is_none")]
4427    pub _meta: Option<Value>,
4428    #[serde(default)]
4429    pub content: Vec<Value>,
4430    #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
4431    pub is_error: Option<bool>,
4432    #[serde(
4433        rename = "structuredContent",
4434        default,
4435        skip_serializing_if = "Option::is_none"
4436    )]
4437    pub structured_content: Option<Value>,
4438}
4439
4440/// UI resource and display preference for model invocations, captured from
4441/// the tool descriptor (`ThreadItem::McpToolCall::mcp_app_ui`).
4442#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
4443#[serde(rename_all = "camelCase")]
4444pub struct McpAppUi {
4445    #[serde(rename = "resourceUri")]
4446    pub resource_uri: String,
4447    #[serde(rename = "preferredModelDisplayMode")]
4448    pub preferred_model_display_mode: McpAppDisplayMode,
4449}
4450
4451#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4452pub enum McpAppDisplayMode {
4453    #[serde(rename = "inline")]
4454    Inline,
4455    #[serde(rename = "fullscreen")]
4456    Fullscreen,
4457}
4458
4459#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4460#[serde(rename_all = "camelCase")]
4461pub struct McpToolCallAppContext {
4462    #[serde(
4463        rename = "actionName",
4464        default,
4465        skip_serializing_if = "Option::is_none"
4466    )]
4467    pub action_name: Option<String>,
4468    #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
4469    pub app_name: Option<String>,
4470    #[serde(rename = "connectorId", default)]
4471    pub connector_id: String,
4472    #[serde(rename = "linkId", default, skip_serializing_if = "Option::is_none")]
4473    pub link_id: Option<String>,
4474    #[serde(
4475        rename = "resourceUri",
4476        default,
4477        skip_serializing_if = "Option::is_none"
4478    )]
4479    pub resource_uri: Option<String>,
4480}
4481
4482#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4483#[serde(rename_all = "camelCase")]
4484pub struct McpToolCallError {
4485    #[serde(default)]
4486    pub message: String,
4487}
4488
4489#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4490#[serde(rename_all = "camelCase")]
4491pub struct McpToolCallProgressNotification {
4492    #[serde(rename = "itemId", default)]
4493    pub item_id: String,
4494    #[serde(default)]
4495    pub message: String,
4496    #[serde(rename = "threadId", default)]
4497    pub thread_id: String,
4498    #[serde(rename = "turnId", default)]
4499    pub turn_id: String,
4500}
4501
4502#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4503#[serde(rename_all = "camelCase")]
4504pub struct McpToolCallResult {
4505    #[serde(default, skip_serializing_if = "Option::is_none")]
4506    pub _meta: Option<Value>,
4507    #[serde(default)]
4508    pub content: Vec<Value>,
4509    #[serde(
4510        rename = "structuredContent",
4511        default,
4512        skip_serializing_if = "Option::is_none"
4513    )]
4514    pub structured_content: Option<Value>,
4515}
4516
4517#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4518pub enum McpToolCallStatus {
4519    #[serde(rename = "inProgress")]
4520    InProgress,
4521    #[serde(rename = "completed")]
4522    Completed,
4523    #[serde(rename = "failed")]
4524    Failed,
4525}
4526
4527#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4528#[serde(rename_all = "camelCase")]
4529pub struct MemoryCitation {
4530    #[serde(default)]
4531    pub entries: Vec<MemoryCitationEntry>,
4532    #[serde(rename = "threadIds", default)]
4533    pub thread_ids: Vec<String>,
4534}
4535
4536#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4537#[serde(rename_all = "camelCase")]
4538pub struct MemoryCitationEntry {
4539    #[serde(rename = "lineEnd", default)]
4540    pub line_end: i64,
4541    #[serde(rename = "lineStart", default)]
4542    pub line_start: i64,
4543    #[serde(default)]
4544    pub note: String,
4545    #[serde(default)]
4546    pub path: String,
4547}
4548
4549#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4550pub enum MergeStrategy {
4551    #[serde(rename = "replace")]
4552    Replace,
4553    #[serde(rename = "upsert")]
4554    Upsert,
4555}
4556
4557#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4558pub enum MessagePhase {
4559    #[serde(rename = "commentary")]
4560    Commentary,
4561    #[serde(rename = "final_answer")]
4562    FinalAnswer,
4563}
4564
4565#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4566#[serde(rename_all = "camelCase")]
4567pub struct MigrationDetails {
4568    #[serde(default, skip_serializing_if = "Option::is_none")]
4569    pub commands: Option<Vec<CommandMigration>>,
4570    #[serde(default, skip_serializing_if = "Option::is_none")]
4571    pub hooks: Option<Vec<HookMigration>>,
4572    #[serde(
4573        rename = "mcpServers",
4574        default,
4575        skip_serializing_if = "Option::is_none"
4576    )]
4577    pub mcp_servers: Option<Vec<McpServerMigration>>,
4578    #[serde(default, skip_serializing_if = "Option::is_none")]
4579    pub memory: Option<Vec<String>>,
4580    #[serde(default, skip_serializing_if = "Option::is_none")]
4581    pub plugins: Option<Vec<PluginsMigration>>,
4582    #[serde(default, skip_serializing_if = "Option::is_none")]
4583    pub sessions: Option<Vec<SessionMigration>>,
4584    #[serde(default, skip_serializing_if = "Option::is_none")]
4585    pub skills: Option<Vec<SkillMigration>>,
4586    #[serde(default, skip_serializing_if = "Option::is_none")]
4587    pub subagents: Option<Vec<SubagentMigration>>,
4588}
4589
4590/// Public explanation and continuation instruction attached to a
4591/// misalignment-blocked turn error (0.148 upstream).
4592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4593#[serde(rename_all = "camelCase")]
4594pub struct MisalignmentErrorDetails {
4595    #[serde(
4596        rename = "detailedExplanation",
4597        default,
4598        skip_serializing_if = "Option::is_none"
4599    )]
4600    pub detailed_explanation: Option<String>,
4601    /// Open-ended classification; accept categories added upstream.
4602    #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
4603    pub error_type: Option<String>,
4604    /// Instruction to submit as the next turn's user input if continuation
4605    /// is confirmed.
4606    #[serde(default, skip_serializing_if = "Option::is_none")]
4607    pub steer: Option<MisalignmentSteer>,
4608}
4609
4610/// The steering instruction inside [`MisalignmentErrorDetails`].
4611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4612#[serde(rename_all = "camelCase")]
4613pub struct MisalignmentSteer {
4614    #[serde(default)]
4615    pub message: String,
4616}
4617
4618#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4619pub enum ModeKind {
4620    #[serde(rename = "plan")]
4621    Plan,
4622    #[serde(rename = "default")]
4623    Default,
4624}
4625
4626#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4627#[serde(rename_all = "camelCase")]
4628pub struct Model {
4629    #[serde(
4630        rename = "additionalSpeedTiers",
4631        default,
4632        skip_serializing_if = "Option::is_none"
4633    )]
4634    pub additional_speed_tiers: Option<Vec<String>>,
4635    #[serde(
4636        rename = "availabilityNux",
4637        default,
4638        skip_serializing_if = "Option::is_none"
4639    )]
4640    pub availability_nux: Option<ModelAvailabilityNux>,
4641    /// `None` when the catalog does not provide access-program metadata.
4642    #[serde(
4643        rename = "availableAccessPrograms",
4644        default,
4645        skip_serializing_if = "Option::is_none"
4646    )]
4647    pub available_access_programs: Option<ModelAccessPrograms>,
4648    #[serde(rename = "defaultReasoningEffort")]
4649    pub default_reasoning_effort: ReasoningEffort,
4650    #[serde(
4651        rename = "defaultServiceTier",
4652        default,
4653        skip_serializing_if = "Option::is_none"
4654    )]
4655    pub default_service_tier: Option<String>,
4656    #[serde(default)]
4657    pub description: String,
4658    #[serde(rename = "displayName", default)]
4659    pub display_name: String,
4660    #[serde(default)]
4661    pub hidden: bool,
4662    #[serde(default)]
4663    pub id: String,
4664    #[serde(
4665        rename = "inputModalities",
4666        default,
4667        skip_serializing_if = "Option::is_none"
4668    )]
4669    pub input_modalities: Option<Vec<InputModality>>,
4670    #[serde(rename = "isDefault", default)]
4671    pub is_default: bool,
4672    #[serde(default)]
4673    pub model: String,
4674    #[serde(
4675        rename = "modelSpecialty",
4676        default,
4677        skip_serializing_if = "Option::is_none"
4678    )]
4679    pub model_specialty: Option<String>,
4680    #[serde(
4681        rename = "multiAgentVersion",
4682        default,
4683        skip_serializing_if = "Option::is_none"
4684    )]
4685    pub multi_agent_version: Option<MultiAgentVersion>,
4686    #[serde(
4687        rename = "serviceTiers",
4688        default,
4689        skip_serializing_if = "Option::is_none"
4690    )]
4691    pub service_tiers: Option<Vec<ModelServiceTier>>,
4692    #[serde(rename = "supportedReasoningEfforts", default)]
4693    pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
4694    /// Deprecated upstream: always `false`; models no longer support
4695    /// personality selection.
4696    #[serde(
4697        rename = "supportsPersonality",
4698        default,
4699        skip_serializing_if = "Option::is_none"
4700    )]
4701    pub supports_personality: Option<bool>,
4702    #[serde(default, skip_serializing_if = "Option::is_none")]
4703    pub upgrade: Option<String>,
4704    #[serde(
4705        rename = "upgradeInfo",
4706        default,
4707        skip_serializing_if = "Option::is_none"
4708    )]
4709    pub upgrade_info: Option<ModelUpgradeInfo>,
4710}
4711
4712/// Caller-specific explicit access programs advertised by model discovery.
4713#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4714#[serde(rename_all = "camelCase")]
4715pub struct ModelAccessPrograms {
4716    /// Accepted explicit selections.
4717    #[serde(default)]
4718    pub cyber: Vec<CyberAccessProgram>,
4719}
4720
4721#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4722#[serde(rename_all = "camelCase")]
4723pub struct ModelAvailabilityNux {
4724    #[serde(default)]
4725    pub message: String,
4726}
4727
4728#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4729#[serde(rename_all = "camelCase")]
4730pub struct ModelListParams {
4731    #[serde(default, skip_serializing_if = "Option::is_none")]
4732    pub cursor: Option<String>,
4733    #[serde(
4734        rename = "includeHidden",
4735        default,
4736        skip_serializing_if = "Option::is_none"
4737    )]
4738    pub include_hidden: Option<bool>,
4739    #[serde(default, skip_serializing_if = "Option::is_none")]
4740    pub limit: Option<i64>,
4741}
4742
4743#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4744#[serde(rename_all = "camelCase")]
4745pub struct ModelListResponse {
4746    #[serde(default)]
4747    pub data: Vec<Model>,
4748    #[serde(
4749        rename = "nextCursor",
4750        default,
4751        skip_serializing_if = "Option::is_none"
4752    )]
4753    pub next_cursor: Option<String>,
4754}
4755
4756#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4757#[serde(rename_all = "camelCase")]
4758pub struct ModelProviderCapabilitiesReadParams {
4759    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4760    pub extra: serde_json::Map<String, Value>,
4761}
4762
4763#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4764#[serde(rename_all = "camelCase")]
4765pub struct ModelProviderCapabilitiesReadResponse {
4766    #[serde(rename = "imageGeneration", default)]
4767    pub image_generation: bool,
4768    #[serde(rename = "namespaceTools", default)]
4769    pub namespace_tools: bool,
4770    #[serde(rename = "webSearch", default)]
4771    pub web_search: bool,
4772}
4773
4774#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4775pub enum ModelRerouteReason {
4776    #[serde(rename = "highRiskCyberActivity")]
4777    HighRiskCyberActivity,
4778}
4779
4780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4781#[serde(rename_all = "camelCase")]
4782pub struct ModelReroutedNotification {
4783    #[serde(rename = "fromModel", default)]
4784    pub from_model: String,
4785    #[serde()]
4786    pub reason: ModelRerouteReason,
4787    #[serde(rename = "threadId", default)]
4788    pub thread_id: String,
4789    #[serde(rename = "toModel", default)]
4790    pub to_model: String,
4791    #[serde(rename = "turnId", default)]
4792    pub turn_id: String,
4793}
4794
4795#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4796#[serde(rename_all = "camelCase")]
4797pub struct ModelSafetyBufferingUpdatedNotification {
4798    #[serde(
4799        rename = "fasterModel",
4800        default,
4801        skip_serializing_if = "Option::is_none"
4802    )]
4803    pub faster_model: Option<String>,
4804    #[serde(default)]
4805    pub model: String,
4806    #[serde(default)]
4807    pub reasons: Vec<String>,
4808    #[serde(rename = "showBufferingUi", default)]
4809    pub show_buffering_ui: bool,
4810    #[serde(rename = "threadId", default)]
4811    pub thread_id: String,
4812    #[serde(rename = "turnId", default)]
4813    pub turn_id: String,
4814    #[serde(rename = "useCases", default)]
4815    pub use_cases: Vec<String>,
4816}
4817
4818#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4819#[serde(rename_all = "camelCase")]
4820pub struct ModelServiceTier {
4821    #[serde(default)]
4822    pub description: String,
4823    #[serde(default)]
4824    pub id: String,
4825    #[serde(default)]
4826    pub name: String,
4827}
4828
4829#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4830#[serde(rename_all = "camelCase")]
4831pub struct ModelUpgradeInfo {
4832    #[serde(
4833        rename = "migrationMarkdown",
4834        default,
4835        skip_serializing_if = "Option::is_none"
4836    )]
4837    pub migration_markdown: Option<String>,
4838    #[serde(default)]
4839    pub model: String,
4840    /// Informational Unix timestamp for this upgrade's scheduled
4841    /// retirement, if known.
4842    #[serde(
4843        rename = "retirementAt",
4844        default,
4845        skip_serializing_if = "Option::is_none"
4846    )]
4847    pub retirement_at: Option<i64>,
4848    #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
4849    pub model_link: Option<String>,
4850    #[serde(
4851        rename = "upgradeCopy",
4852        default,
4853        skip_serializing_if = "Option::is_none"
4854    )]
4855    pub upgrade_copy: Option<String>,
4856}
4857
4858#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4859pub enum ModelVerification {
4860    #[serde(rename = "trustedAccessForCyber")]
4861    TrustedAccessForCyber,
4862}
4863
4864#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4865#[serde(rename_all = "camelCase")]
4866pub struct ModelVerificationNotification {
4867    #[serde(rename = "threadId", default)]
4868    pub thread_id: String,
4869    #[serde(rename = "turnId", default)]
4870    pub turn_id: String,
4871    #[serde(default)]
4872    pub verifications: Vec<ModelVerification>,
4873}
4874
4875#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4876#[serde(rename_all = "camelCase")]
4877pub struct ModelsRequirements {
4878    #[serde(rename = "newThread", default, skip_serializing_if = "Option::is_none")]
4879    pub new_thread: Option<NewThreadModelDefaults>,
4880}
4881
4882#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4883pub enum MultiAgentVersion {
4884    #[serde(rename = "disabled")]
4885    Disabled,
4886    #[serde(rename = "v1")]
4887    V1,
4888    #[serde(rename = "v2")]
4889    V2,
4890}
4891
4892#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4893pub enum NetworkAccess {
4894    #[serde(rename = "restricted")]
4895    Restricted,
4896    #[serde(rename = "enabled")]
4897    Enabled,
4898}
4899
4900#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4901#[serde(rename_all = "camelCase")]
4902pub struct NetworkApprovalContext {
4903    #[serde(default)]
4904    pub host: String,
4905    #[serde()]
4906    pub protocol: NetworkApprovalProtocol,
4907}
4908
4909#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4910pub enum NetworkApprovalProtocol {
4911    #[serde(rename = "http")]
4912    Http,
4913    #[serde(rename = "https")]
4914    Https,
4915    #[serde(rename = "socks5Tcp")]
4916    Socks5Tcp,
4917    #[serde(rename = "socks5Udp")]
4918    Socks5Udp,
4919}
4920
4921#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4922#[serde(rename_all = "camelCase")]
4923pub struct NetworkPolicyAmendment {
4924    #[serde()]
4925    pub action: NetworkPolicyRuleAction,
4926    #[serde(default)]
4927    pub host: String,
4928}
4929
4930#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4931pub enum NetworkPolicyRuleAction {
4932    #[serde(rename = "allow")]
4933    Allow,
4934    #[serde(rename = "deny")]
4935    Deny,
4936}
4937
4938#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4939#[serde(rename_all = "camelCase")]
4940pub struct NewThreadModelDefaults {
4941    #[serde(default, skip_serializing_if = "Option::is_none")]
4942    pub model: Option<String>,
4943    #[serde(
4944        rename = "modelReasoningEffort",
4945        default,
4946        skip_serializing_if = "Option::is_none"
4947    )]
4948    pub model_reasoning_effort: Option<ReasoningEffort>,
4949    #[serde(
4950        rename = "serviceTier",
4951        default,
4952        skip_serializing_if = "Option::is_none"
4953    )]
4954    pub service_tier: Option<String>,
4955}
4956
4957#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4958pub enum NonSteerableTurnKind {
4959    #[serde(rename = "review")]
4960    Review,
4961    #[serde(rename = "compact")]
4962    Compact,
4963}
4964
4965#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4966#[serde(rename_all = "camelCase")]
4967pub struct OverriddenMetadata {
4968    #[serde(rename = "effectiveValue", default)]
4969    pub effective_value: Value,
4970    #[serde(default)]
4971    pub message: String,
4972    #[serde(rename = "overridingLayer")]
4973    pub overriding_layer: ConfigLayerMetadata,
4974}
4975
4976#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4977#[serde(tag = "type", rename_all = "camelCase")]
4978pub enum ParsedCommand {
4979    Read {
4980        cmd: String,
4981        name: String,
4982        path: String,
4983    },
4984    List_files {
4985        cmd: String,
4986        #[serde(default, skip_serializing_if = "Option::is_none")]
4987        path: Option<String>,
4988    },
4989    Search {
4990        cmd: String,
4991        #[serde(default, skip_serializing_if = "Option::is_none")]
4992        path: Option<String>,
4993        #[serde(default, skip_serializing_if = "Option::is_none")]
4994        query: Option<String>,
4995    },
4996    Unknown {
4997        cmd: String,
4998    },
4999}
5000
5001#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5002pub enum PatchApplyStatus {
5003    #[serde(rename = "inProgress")]
5004    InProgress,
5005    #[serde(rename = "completed")]
5006    Completed,
5007    #[serde(rename = "failed")]
5008    Failed,
5009    #[serde(rename = "declined")]
5010    Declined,
5011}
5012
5013#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5014#[serde(tag = "type", rename_all = "camelCase")]
5015pub enum PatchChangeKind {
5016    Add,
5017    Delete,
5018    Update {
5019        #[serde(default, skip_serializing_if = "Option::is_none")]
5020        move_path: Option<String>,
5021    },
5022}
5023
5024#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5025pub enum PermissionGrantScope {
5026    #[serde(rename = "turn")]
5027    Turn,
5028    #[serde(rename = "session")]
5029    Session,
5030}
5031
5032#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5033#[serde(rename_all = "camelCase")]
5034pub struct PermissionProfileListParams {
5035    #[serde(default, skip_serializing_if = "Option::is_none")]
5036    pub cursor: Option<String>,
5037    #[serde(default, skip_serializing_if = "Option::is_none")]
5038    pub cwd: Option<String>,
5039    #[serde(default, skip_serializing_if = "Option::is_none")]
5040    pub limit: Option<i64>,
5041}
5042
5043#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5044#[serde(rename_all = "camelCase")]
5045pub struct PermissionProfileListResponse {
5046    #[serde(default)]
5047    pub data: Vec<PermissionProfileSummary>,
5048    #[serde(
5049        rename = "nextCursor",
5050        default,
5051        skip_serializing_if = "Option::is_none"
5052    )]
5053    pub next_cursor: Option<String>,
5054}
5055
5056#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5057#[serde(rename_all = "camelCase")]
5058pub struct PermissionProfileSummary {
5059    #[serde(default)]
5060    pub allowed: bool,
5061    #[serde(default, skip_serializing_if = "Option::is_none")]
5062    pub description: Option<String>,
5063    #[serde(default)]
5064    pub id: String,
5065}
5066
5067#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5068#[serde(rename_all = "camelCase")]
5069pub struct PermissionsRequestApprovalParams {
5070    #[serde()]
5071    pub cwd: LegacyAppPathString,
5072    #[serde(
5073        rename = "environmentId",
5074        default,
5075        skip_serializing_if = "Option::is_none"
5076    )]
5077    pub environment_id: Option<String>,
5078    #[serde(rename = "itemId", default)]
5079    pub item_id: String,
5080    #[serde()]
5081    pub permissions: RequestPermissionProfile,
5082    #[serde(default, skip_serializing_if = "Option::is_none")]
5083    pub reason: Option<String>,
5084    #[serde(rename = "startedAtMs", default)]
5085    pub started_at_ms: i64,
5086    #[serde(rename = "threadId", default)]
5087    pub thread_id: String,
5088    #[serde(rename = "turnId", default)]
5089    pub turn_id: String,
5090}
5091
5092#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5093#[serde(rename_all = "camelCase")]
5094pub struct PermissionsRequestApprovalResponse {
5095    #[serde()]
5096    pub permissions: GrantedPermissionProfile,
5097    #[serde(default, skip_serializing_if = "Option::is_none")]
5098    pub scope: Option<Value>,
5099    #[serde(
5100        rename = "strictAutoReview",
5101        default,
5102        skip_serializing_if = "Option::is_none"
5103    )]
5104    pub strict_auto_review: Option<bool>,
5105}
5106
5107/// Deprecated upstream: `friendly` and `pragmatic` no longer select a style,
5108/// and `Model::supports_personality` is now always `false`. The setting is
5109/// still reported and accepted on the wire; changing it on a turn does not
5110/// rewrite the thread's existing instructions.
5111#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5112pub enum Personality {
5113    #[serde(rename = "none")]
5114    None,
5115    #[serde(rename = "friendly")]
5116    Friendly,
5117    #[serde(rename = "pragmatic")]
5118    Pragmatic,
5119}
5120
5121#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5122#[serde(rename_all = "camelCase")]
5123pub struct PlanDeltaNotification {
5124    #[serde(default)]
5125    pub delta: String,
5126    #[serde(rename = "itemId", default)]
5127    pub item_id: String,
5128    #[serde(rename = "threadId", default)]
5129    pub thread_id: String,
5130    #[serde(rename = "turnId", default)]
5131    pub turn_id: String,
5132}
5133
5134#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5135pub enum PlanType {
5136    #[serde(rename = "free")]
5137    Free,
5138    #[serde(rename = "go")]
5139    Go,
5140    #[serde(rename = "plus")]
5141    Plus,
5142    #[serde(rename = "pro")]
5143    Pro,
5144    #[serde(rename = "prolite")]
5145    Prolite,
5146    #[serde(rename = "edu_plus")]
5147    Edu_plus,
5148    #[serde(rename = "edu_pro")]
5149    Edu_pro,
5150    #[serde(rename = "team")]
5151    Team,
5152    #[serde(rename = "self_serve_business_prolite")]
5153    Self_serve_business_prolite,
5154    #[serde(rename = "self_serve_business_usage_based")]
5155    Self_serve_business_usage_based,
5156    #[serde(rename = "business")]
5157    Business,
5158    #[serde(rename = "ent26")]
5159    Ent26,
5160    #[serde(rename = "enterprise_cbp_automation")]
5161    Enterprise_cbp_automation,
5162    #[serde(rename = "enterprise_cbp_usage_based")]
5163    Enterprise_cbp_usage_based,
5164    #[serde(rename = "enterprise")]
5165    Enterprise,
5166    #[serde(rename = "edu")]
5167    Edu,
5168    #[serde(rename = "unknown")]
5169    Unknown,
5170}
5171
5172#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5173pub enum PluginAuthPolicy {
5174    #[serde(rename = "ON_INSTALL")]
5175    ON_INSTALL,
5176    #[serde(rename = "ON_USE")]
5177    ON_USE,
5178}
5179
5180#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5181pub enum PluginAvailability {
5182    #[serde(rename = "DISABLED_BY_ADMIN")]
5183    DISABLEDBYADMIN,
5184    AVAILABLE,
5185}
5186
5187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5188#[serde(rename_all = "camelCase")]
5189pub struct PluginDetail {
5190    #[serde(rename = "appTemplates", default)]
5191    pub app_templates: Vec<AppTemplateSummary>,
5192    #[serde(default)]
5193    pub apps: Vec<AppSummary>,
5194    #[serde(default, skip_serializing_if = "Option::is_none")]
5195    pub description: Option<String>,
5196    #[serde(default)]
5197    pub hooks: Vec<PluginHookSummary>,
5198    #[serde(rename = "marketplaceName", default)]
5199    pub marketplace_name: String,
5200    #[serde(
5201        rename = "marketplacePath",
5202        default,
5203        skip_serializing_if = "Option::is_none"
5204    )]
5205    pub marketplace_path: Option<AbsolutePathBuf>,
5206    #[serde(rename = "mcpServers", default)]
5207    pub mcp_servers: Vec<String>,
5208    /// The declared onboarding skill, when the plugin and visible skill are enabled.
5209    #[serde(
5210        rename = "onboardingSkill",
5211        default,
5212        skip_serializing_if = "Option::is_none"
5213    )]
5214    pub onboarding_skill: Option<SkillSummary>,
5215    #[serde(
5216        rename = "scheduledTasks",
5217        default,
5218        skip_serializing_if = "Option::is_none"
5219    )]
5220    pub scheduled_tasks: Option<Vec<ScheduledTaskSummary>>,
5221    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5222    pub share_url: Option<String>,
5223    #[serde(default)]
5224    pub skills: Vec<SkillSummary>,
5225    #[serde()]
5226    pub summary: PluginSummary,
5227}
5228
5229#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5230pub enum PluginDisabledReason {
5231    #[serde(rename = "disabled_by_admin")]
5232    Disabled_by_admin,
5233    #[serde(rename = "plan_not_eligible")]
5234    Plan_not_eligible,
5235    #[serde(rename = "required_app_unavailable")]
5236    Required_app_unavailable,
5237    #[serde(rename = "unknown")]
5238    Unknown,
5239}
5240
5241/// A UI entrypoint contributed by a plugin's bundled MCP app. Every variant
5242/// shares the presentation fields (`app_id`, `tool_name`, `title`,
5243/// `resource_uri`, `icons`); the `type` tag says where the host surfaces it.
5244#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5245#[serde(tag = "type", rename_all = "camelCase")]
5246pub enum PluginEntrypoint {
5247    Global {
5248        #[serde(rename = "appId")]
5249        app_id: String,
5250        icons: Vec<PluginIcon>,
5251        #[serde(
5252            rename = "quickAction",
5253            default,
5254            skip_serializing_if = "Option::is_none"
5255        )]
5256        quick_action: Option<PluginQuickAction>,
5257        #[serde(rename = "resourceUri")]
5258        resource_uri: String,
5259        title: String,
5260        #[serde(rename = "toolName")]
5261        tool_name: String,
5262    },
5263    Settings {
5264        #[serde(rename = "appId")]
5265        app_id: String,
5266        icons: Vec<PluginIcon>,
5267        #[serde(rename = "resourceUri")]
5268        resource_uri: String,
5269        #[serde(rename = "searchTerms", default)]
5270        search_terms: Vec<String>,
5271        title: String,
5272        #[serde(rename = "toolName")]
5273        tool_name: String,
5274    },
5275    Thread {
5276        #[serde(rename = "appId")]
5277        app_id: String,
5278        icons: Vec<PluginIcon>,
5279        #[serde(rename = "resourceUri")]
5280        resource_uri: String,
5281        title: String,
5282        #[serde(rename = "toolName")]
5283        tool_name: String,
5284    },
5285    File {
5286        #[serde(rename = "appId")]
5287        app_id: String,
5288        extensions: Vec<String>,
5289        icons: Vec<PluginIcon>,
5290        #[serde(rename = "resourceUri")]
5291        resource_uri: String,
5292        title: String,
5293        #[serde(rename = "toolName")]
5294        tool_name: String,
5295    },
5296}
5297
5298/// Host-integration surface a plugin exposes (`PluginSummary.extensions`).
5299/// The per-surface lists default to empty; `entrypoints` is the legacy
5300/// undifferentiated list and is absent when the plugin uses the typed lists.
5301#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5302#[serde(rename_all = "camelCase")]
5303pub struct PluginExtensions {
5304    #[serde(default, skip_serializing_if = "Option::is_none")]
5305    pub entrypoints: Option<Vec<PluginEntrypoint>>,
5306    #[serde(rename = "fileHandlers", default)]
5307    pub file_handlers: Vec<PluginEntrypoint>,
5308    #[serde(rename = "searchMentionProviders", default)]
5309    pub search_mention_providers: Vec<PluginSearchProvider>,
5310    #[serde(default)]
5311    pub settings: Vec<PluginSettings>,
5312    #[serde(rename = "settingsEntrypoints", default)]
5313    pub settings_entrypoints: Vec<PluginEntrypoint>,
5314    #[serde(rename = "threadEntrypoints", default)]
5315    pub thread_entrypoints: Vec<PluginEntrypoint>,
5316}
5317
5318#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5319#[serde(rename_all = "camelCase")]
5320pub struct PluginHookSummary {
5321    #[serde(rename = "eventName")]
5322    pub event_name: HookEventName,
5323    #[serde(default)]
5324    pub key: String,
5325}
5326
5327/// Icon asset for a plugin entrypoint or quick action.
5328#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5329#[serde(rename_all = "camelCase")]
5330pub struct PluginIcon {
5331    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
5332    pub mime_type: Option<String>,
5333    #[serde(default, skip_serializing_if = "Option::is_none")]
5334    pub sizes: Option<Vec<String>>,
5335    #[serde(default)]
5336    pub src: String,
5337    #[serde(default, skip_serializing_if = "Option::is_none")]
5338    pub theme: Option<String>,
5339}
5340
5341#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5342#[serde(rename_all = "camelCase")]
5343pub struct PluginInstallParams {
5344    #[serde(
5345        rename = "installAttemptId",
5346        default,
5347        skip_serializing_if = "Option::is_none"
5348    )]
5349    pub install_attempt_id: Option<String>,
5350    #[serde(
5351        rename = "marketplacePath",
5352        default,
5353        skip_serializing_if = "Option::is_none"
5354    )]
5355    pub marketplace_path: Option<AbsolutePathBuf>,
5356    #[serde(rename = "pluginName", default)]
5357    pub plugin_name: String,
5358    #[serde(
5359        rename = "remoteMarketplaceName",
5360        default,
5361        skip_serializing_if = "Option::is_none"
5362    )]
5363    pub remote_marketplace_name: Option<String>,
5364}
5365
5366#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5367pub enum PluginInstallPolicy {
5368    #[serde(rename = "NOT_AVAILABLE")]
5369    NOT_AVAILABLE,
5370    #[serde(rename = "AVAILABLE")]
5371    AVAILABLE,
5372    #[serde(rename = "INSTALLED_BY_DEFAULT")]
5373    INSTALLED_BY_DEFAULT,
5374}
5375
5376#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5377pub enum PluginInstallPolicySource {
5378    #[serde(rename = "WORKSPACE_SETTING")]
5379    WORKSPACE_SETTING,
5380    #[serde(rename = "IMPLICIT_CANONICAL_APP")]
5381    IMPLICIT_CANONICAL_APP,
5382}
5383
5384#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5385#[serde(rename_all = "camelCase")]
5386pub struct PluginInstallResponse {
5387    #[serde(rename = "appsNeedingAuth", default)]
5388    pub apps_needing_auth: Vec<AppSummary>,
5389    #[serde(rename = "authPolicy")]
5390    pub auth_policy: PluginAuthPolicy,
5391}
5392
5393#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5394#[serde(rename_all = "camelCase")]
5395pub struct PluginInstalledParams {
5396    #[serde(default, skip_serializing_if = "Option::is_none")]
5397    pub cwds: Option<Vec<AbsolutePathBuf>>,
5398    #[serde(
5399        rename = "installSuggestionPluginNames",
5400        default,
5401        skip_serializing_if = "Option::is_none"
5402    )]
5403    pub install_suggestion_plugin_names: Option<Vec<String>>,
5404}
5405
5406#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5407#[serde(rename_all = "camelCase")]
5408pub struct PluginInstalledResponse {
5409    #[serde(
5410        rename = "marketplaceLoadErrors",
5411        default,
5412        skip_serializing_if = "Option::is_none"
5413    )]
5414    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5415    #[serde(default)]
5416    pub marketplaces: Vec<PluginMarketplaceEntry>,
5417}
5418
5419#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5420#[serde(rename_all = "camelCase")]
5421pub struct PluginInterface {
5422    #[serde(
5423        rename = "brandColor",
5424        default,
5425        skip_serializing_if = "Option::is_none"
5426    )]
5427    pub brand_color: Option<String>,
5428    #[serde(default)]
5429    pub capabilities: Vec<String>,
5430    #[serde(default, skip_serializing_if = "Option::is_none")]
5431    pub category: Option<String>,
5432    #[serde(
5433        rename = "composerIcon",
5434        default,
5435        skip_serializing_if = "Option::is_none"
5436    )]
5437    pub composer_icon: Option<AbsolutePathBuf>,
5438    #[serde(
5439        rename = "composerIconUrl",
5440        default,
5441        skip_serializing_if = "Option::is_none"
5442    )]
5443    pub composer_icon_url: Option<String>,
5444    #[serde(
5445        rename = "defaultPrompt",
5446        default,
5447        skip_serializing_if = "Option::is_none"
5448    )]
5449    pub default_prompt: Option<Vec<String>>,
5450    #[serde(
5451        rename = "developerName",
5452        default,
5453        skip_serializing_if = "Option::is_none"
5454    )]
5455    pub developer_name: Option<String>,
5456    #[serde(
5457        rename = "displayName",
5458        default,
5459        skip_serializing_if = "Option::is_none"
5460    )]
5461    pub display_name: Option<String>,
5462    #[serde(default, skip_serializing_if = "Option::is_none")]
5463    pub logo: Option<AbsolutePathBuf>,
5464    #[serde(rename = "logoDark", default, skip_serializing_if = "Option::is_none")]
5465    pub logo_dark: Option<AbsolutePathBuf>,
5466    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
5467    pub logo_url: Option<String>,
5468    #[serde(
5469        rename = "logoUrlDark",
5470        default,
5471        skip_serializing_if = "Option::is_none"
5472    )]
5473    pub logo_url_dark: Option<String>,
5474    #[serde(
5475        rename = "longDescription",
5476        default,
5477        skip_serializing_if = "Option::is_none"
5478    )]
5479    pub long_description: Option<String>,
5480    #[serde(
5481        rename = "privacyPolicyUrl",
5482        default,
5483        skip_serializing_if = "Option::is_none"
5484    )]
5485    pub privacy_policy_url: Option<String>,
5486    #[serde(rename = "screenshotUrls", default)]
5487    pub screenshot_urls: Vec<String>,
5488    #[serde(default)]
5489    pub screenshots: Vec<AbsolutePathBuf>,
5490    #[serde(
5491        rename = "shortDescription",
5492        default,
5493        skip_serializing_if = "Option::is_none"
5494    )]
5495    pub short_description: Option<String>,
5496    #[serde(
5497        rename = "termsOfServiceUrl",
5498        default,
5499        skip_serializing_if = "Option::is_none"
5500    )]
5501    pub terms_of_service_url: Option<String>,
5502    #[serde(
5503        rename = "websiteUrl",
5504        default,
5505        skip_serializing_if = "Option::is_none"
5506    )]
5507    pub website_url: Option<String>,
5508}
5509
5510#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5511pub enum PluginListMarketplaceKind {
5512    #[serde(rename = "local")]
5513    Local,
5514    #[serde(rename = "vertical")]
5515    Vertical,
5516    #[serde(rename = "workspace-directory")]
5517    Workspace_directory,
5518    #[serde(rename = "shared-with-me")]
5519    Shared_with_me,
5520    #[serde(rename = "created-by-me-remote")]
5521    Created_by_me_remote,
5522}
5523
5524#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5525#[serde(rename_all = "camelCase")]
5526pub struct PluginListParams {
5527    #[serde(default, skip_serializing_if = "Option::is_none")]
5528    pub cwds: Option<Vec<AbsolutePathBuf>>,
5529    #[serde(
5530        rename = "forceRefetch",
5531        default,
5532        skip_serializing_if = "Option::is_none"
5533    )]
5534    pub force_refetch: Option<bool>,
5535    #[serde(
5536        rename = "marketplaceKinds",
5537        default,
5538        skip_serializing_if = "Option::is_none"
5539    )]
5540    pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
5541}
5542
5543#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5544#[serde(rename_all = "camelCase")]
5545pub struct PluginListResponse {
5546    #[serde(
5547        rename = "featuredPluginIds",
5548        default,
5549        skip_serializing_if = "Option::is_none"
5550    )]
5551    pub featured_plugin_ids: Option<Vec<String>>,
5552    #[serde(
5553        rename = "marketplaceLoadErrors",
5554        default,
5555        skip_serializing_if = "Option::is_none"
5556    )]
5557    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5558    #[serde(default)]
5559    pub marketplaces: Vec<PluginMarketplaceEntry>,
5560}
5561
5562#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5563#[serde(rename_all = "camelCase")]
5564pub struct PluginMarketplaceEntry {
5565    #[serde(default, skip_serializing_if = "Option::is_none")]
5566    pub interface: Option<MarketplaceInterface>,
5567    #[serde(default)]
5568    pub name: String,
5569    #[serde(default, skip_serializing_if = "Option::is_none")]
5570    pub path: Option<AbsolutePathBuf>,
5571    #[serde(default)]
5572    pub plugins: Vec<PluginSummary>,
5573}
5574
5575/// One-click action attached to a global plugin entrypoint.
5576#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5577#[serde(rename_all = "camelCase")]
5578pub struct PluginQuickAction {
5579    #[serde(default)]
5580    pub icons: Vec<PluginIcon>,
5581    pub target: PluginQuickActionTarget,
5582    #[serde(default)]
5583    pub title: String,
5584}
5585
5586/// What a `PluginQuickAction` invokes when triggered.
5587#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5588#[serde(tag = "type", rename_all = "camelCase")]
5589pub enum PluginQuickActionTarget {
5590    Tool {
5591        #[serde(default, skip_serializing_if = "Option::is_none")]
5592        arguments: Option<Value>,
5593        name: String,
5594    },
5595}
5596
5597#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5598#[serde(rename_all = "camelCase")]
5599pub struct PluginReadParams {
5600    #[serde(
5601        rename = "marketplacePath",
5602        default,
5603        skip_serializing_if = "Option::is_none"
5604    )]
5605    pub marketplace_path: Option<AbsolutePathBuf>,
5606    #[serde(rename = "pluginName", default)]
5607    pub plugin_name: String,
5608    #[serde(
5609        rename = "remoteMarketplaceName",
5610        default,
5611        skip_serializing_if = "Option::is_none"
5612    )]
5613    pub remote_marketplace_name: Option<String>,
5614}
5615
5616#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5617#[serde(rename_all = "camelCase")]
5618pub struct PluginReadResponse {
5619    #[serde()]
5620    pub plugin: PluginDetail,
5621}
5622
5623/// Runtime categories affected by this change, not just capabilities
5624/// currently present. Flags describe declarations before runtime policy
5625/// filtering. Updates OR the old and new bundle flags; enablement changes and
5626/// cached reinstalls use the cached bundle; removals retain the old bundle's
5627/// flags.
5628#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5629#[serde(rename_all = "camelCase")]
5630pub struct PluginReconcileChangedPlugin {
5631    #[serde(rename = "hasApps", default)]
5632    pub has_apps: bool,
5633    #[serde(rename = "hasHooks", default)]
5634    pub has_hooks: bool,
5635    #[serde(rename = "hasMcps", default)]
5636    pub has_mcps: bool,
5637    /// Whether either bundle declares skill roots; not a validated inventory
5638    /// of enabled skills.
5639    #[serde(rename = "hasSkills", default)]
5640    pub has_skills: bool,
5641    /// Local plugin ID (`name@marketplace`), matching `PluginSummary.id`.
5642    #[serde(default)]
5643    pub id: String,
5644}
5645
5646#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5647#[serde(rename_all = "camelCase")]
5648pub struct PluginReconcileParams {
5649    /// Optional client-provided reason recorded with the reconciliation
5650    /// attempt.
5651    #[serde(default, skip_serializing_if = "Option::is_none")]
5652    pub reason: Option<String>,
5653}
5654
5655/// Bundle and installed-state changes observed by this pass, not a
5656/// runtime-readiness acknowledgement or a cumulative diff since the client's
5657/// last request. Other metadata-only changes are not listed.
5658#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5659#[serde(rename_all = "camelCase")]
5660pub struct PluginReconcileResponse {
5661    /// Plugins affected by bundle changes, enablement changes, or removals.
5662    /// Installed-state changes compare against the previous cached snapshot,
5663    /// including cached reinstalls. Removal hints survive cache cleanup
5664    /// failures; unchanged plugins are omitted.
5665    #[serde(rename = "changedPlugins", default)]
5666    pub changed_plugins: Vec<PluginReconcileChangedPlugin>,
5667    /// Subset of failures for which the requested bundle could not be
5668    /// materialized. A previously cached version may still be available.
5669    #[serde(rename = "failedMaterializationRemotePluginIds", default)]
5670    pub failed_materialization_remote_plugin_ids: Vec<String>,
5671    /// Backend remote plugin IDs whose bundle or identity update failed.
5672    #[serde(rename = "failedRemotePluginIds", default)]
5673    pub failed_remote_plugin_ids: Vec<String>,
5674}
5675
5676/// A plugin-provided search/mention provider backed by an MCP tool.
5677#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5678#[serde(rename_all = "camelCase")]
5679pub struct PluginSearchProvider {
5680    #[serde(rename = "appId", default)]
5681    pub app_id: String,
5682    #[serde(default, skip_serializing_if = "Option::is_none")]
5683    pub call: Option<PluginSearchProviderCall>,
5684    #[serde(rename = "linkId", default)]
5685    pub link_id: String,
5686    #[serde(default)]
5687    pub title: String,
5688    #[serde(rename = "toolName", default)]
5689    pub tool_name: String,
5690}
5691
5692/// Pre-bound MCP tool call a `PluginSearchProvider` issues.
5693#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5694#[serde(rename_all = "camelCase")]
5695pub struct PluginSearchProviderCall {
5696    #[serde(rename = "_meta", default)]
5697    pub meta: Value,
5698    #[serde(default)]
5699    pub arguments: Value,
5700    #[serde(default)]
5701    pub name: String,
5702}
5703
5704/// Read/update tool pair backing a plugin's settings surface.
5705#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5706#[serde(rename_all = "camelCase")]
5707pub struct PluginSettings {
5708    #[serde(rename = "appId", default)]
5709    pub app_id: String,
5710    #[serde(rename = "readToolName", default)]
5711    pub read_tool_name: String,
5712    #[serde(rename = "updateToolName", default)]
5713    pub update_tool_name: String,
5714}
5715
5716#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5717#[serde(rename_all = "camelCase")]
5718pub struct PluginShareCheckoutParams {
5719    #[serde(rename = "remotePluginId", default)]
5720    pub remote_plugin_id: String,
5721}
5722
5723#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5724#[serde(rename_all = "camelCase")]
5725pub struct PluginShareCheckoutResponse {
5726    #[serde(rename = "marketplaceName", default)]
5727    pub marketplace_name: String,
5728    #[serde(rename = "marketplacePath")]
5729    pub marketplace_path: AbsolutePathBuf,
5730    #[serde(rename = "pluginId", default)]
5731    pub plugin_id: String,
5732    #[serde(rename = "pluginName", default)]
5733    pub plugin_name: String,
5734    #[serde(rename = "pluginPath")]
5735    pub plugin_path: AbsolutePathBuf,
5736    #[serde(rename = "remotePluginId", default)]
5737    pub remote_plugin_id: String,
5738    #[serde(
5739        rename = "remoteVersion",
5740        default,
5741        skip_serializing_if = "Option::is_none"
5742    )]
5743    pub remote_version: Option<String>,
5744}
5745
5746#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5747#[serde(rename_all = "camelCase")]
5748pub struct PluginShareContext {
5749    #[serde(
5750        rename = "canPublishToWorkspace",
5751        default,
5752        skip_serializing_if = "Option::is_none"
5753    )]
5754    pub can_publish_to_workspace: Option<bool>,
5755    #[serde(
5756        rename = "creatorAccountUserId",
5757        default,
5758        skip_serializing_if = "Option::is_none"
5759    )]
5760    pub creator_account_user_id: Option<String>,
5761    #[serde(
5762        rename = "creatorName",
5763        default,
5764        skip_serializing_if = "Option::is_none"
5765    )]
5766    pub creator_name: Option<String>,
5767    #[serde(default, skip_serializing_if = "Option::is_none")]
5768    pub discoverability: Option<PluginShareDiscoverability>,
5769    #[serde(rename = "remotePluginId", default)]
5770    pub remote_plugin_id: String,
5771    #[serde(
5772        rename = "remoteVersion",
5773        default,
5774        skip_serializing_if = "Option::is_none"
5775    )]
5776    pub remote_version: Option<String>,
5777    #[serde(
5778        rename = "sharePrincipals",
5779        default,
5780        skip_serializing_if = "Option::is_none"
5781    )]
5782    pub share_principals: Option<Vec<PluginSharePrincipal>>,
5783    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5784    pub share_url: Option<String>,
5785}
5786
5787#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5788#[serde(rename_all = "camelCase")]
5789pub struct PluginShareDeleteParams {
5790    #[serde(rename = "remotePluginId", default)]
5791    pub remote_plugin_id: String,
5792}
5793
5794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5795#[serde(rename_all = "camelCase")]
5796pub struct PluginShareDeleteResponse {
5797    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5798    pub extra: serde_json::Map<String, Value>,
5799}
5800
5801#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5802pub enum PluginShareDiscoverability {
5803    #[serde(rename = "LISTED")]
5804    LISTED,
5805    #[serde(rename = "UNLISTED")]
5806    UNLISTED,
5807    #[serde(rename = "PRIVATE")]
5808    PRIVATE,
5809}
5810
5811#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5812#[serde(rename_all = "camelCase")]
5813pub struct PluginShareListItem {
5814    #[serde(
5815        rename = "localPluginPath",
5816        default,
5817        skip_serializing_if = "Option::is_none"
5818    )]
5819    pub local_plugin_path: Option<AbsolutePathBuf>,
5820    #[serde()]
5821    pub plugin: PluginSummary,
5822}
5823
5824#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5825#[serde(rename_all = "camelCase")]
5826pub struct PluginShareListParams {
5827    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5828    pub extra: serde_json::Map<String, Value>,
5829}
5830
5831#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5832#[serde(rename_all = "camelCase")]
5833pub struct PluginShareListResponse {
5834    #[serde(default)]
5835    pub data: Vec<PluginShareListItem>,
5836}
5837
5838#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5839#[serde(rename_all = "camelCase")]
5840pub struct PluginSharePrincipal {
5841    #[serde(default)]
5842    pub name: String,
5843    #[serde(rename = "principalId", default)]
5844    pub principal_id: String,
5845    #[serde(rename = "principalType")]
5846    pub principal_type: PluginSharePrincipalType,
5847    #[serde()]
5848    pub role: PluginSharePrincipalRole,
5849}
5850
5851#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5852pub enum PluginSharePrincipalRole {
5853    #[serde(rename = "reader")]
5854    Reader,
5855    #[serde(rename = "editor")]
5856    Editor,
5857    #[serde(rename = "owner")]
5858    Owner,
5859}
5860
5861#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5862pub enum PluginSharePrincipalType {
5863    #[serde(rename = "user")]
5864    User,
5865    #[serde(rename = "group")]
5866    Group,
5867    #[serde(rename = "workspace")]
5868    Workspace,
5869}
5870
5871#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5872#[serde(rename_all = "camelCase")]
5873pub struct PluginShareSaveParams {
5874    #[serde(default, skip_serializing_if = "Option::is_none")]
5875    pub discoverability: Option<PluginShareDiscoverability>,
5876    #[serde(rename = "pluginPath")]
5877    pub plugin_path: AbsolutePathBuf,
5878    #[serde(
5879        rename = "remotePluginId",
5880        default,
5881        skip_serializing_if = "Option::is_none"
5882    )]
5883    pub remote_plugin_id: Option<String>,
5884    #[serde(
5885        rename = "shareTargets",
5886        default,
5887        skip_serializing_if = "Option::is_none"
5888    )]
5889    pub share_targets: Option<Vec<PluginShareTarget>>,
5890}
5891
5892#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5893#[serde(rename_all = "camelCase")]
5894pub struct PluginShareSaveResponse {
5895    #[serde(
5896        rename = "canPublishToWorkspace",
5897        default,
5898        skip_serializing_if = "Option::is_none"
5899    )]
5900    pub can_publish_to_workspace: Option<bool>,
5901    #[serde(rename = "remotePluginId", default)]
5902    pub remote_plugin_id: String,
5903    #[serde(rename = "shareUrl", default)]
5904    pub share_url: String,
5905}
5906
5907#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5908#[serde(rename_all = "camelCase")]
5909pub struct PluginShareTarget {
5910    #[serde(rename = "principalId", default)]
5911    pub principal_id: String,
5912    #[serde(rename = "principalType")]
5913    pub principal_type: PluginSharePrincipalType,
5914    #[serde()]
5915    pub role: PluginShareTargetRole,
5916}
5917
5918#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5919pub enum PluginShareTargetRole {
5920    #[serde(rename = "reader")]
5921    Reader,
5922    #[serde(rename = "editor")]
5923    Editor,
5924}
5925
5926#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5927pub enum PluginShareUpdateDiscoverability {
5928    #[serde(rename = "UNLISTED")]
5929    UNLISTED,
5930    #[serde(rename = "PRIVATE")]
5931    PRIVATE,
5932    #[serde(rename = "LISTED")]
5933    LISTED,
5934}
5935
5936#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5937#[serde(rename_all = "camelCase")]
5938pub struct PluginShareUpdateTargetsParams {
5939    #[serde()]
5940    pub discoverability: PluginShareUpdateDiscoverability,
5941    #[serde(rename = "remotePluginId", default)]
5942    pub remote_plugin_id: String,
5943    #[serde(rename = "shareTargets", default)]
5944    pub share_targets: Vec<PluginShareTarget>,
5945}
5946
5947#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5948#[serde(rename_all = "camelCase")]
5949pub struct PluginShareUpdateTargetsResponse {
5950    #[serde()]
5951    pub discoverability: PluginShareDiscoverability,
5952    #[serde(default)]
5953    pub principals: Vec<PluginSharePrincipal>,
5954}
5955
5956#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5957#[serde(rename_all = "camelCase")]
5958pub struct PluginSkillReadParams {
5959    #[serde(rename = "remoteMarketplaceName", default)]
5960    pub remote_marketplace_name: String,
5961    #[serde(rename = "remotePluginId", default)]
5962    pub remote_plugin_id: String,
5963    #[serde(rename = "skillName", default)]
5964    pub skill_name: String,
5965}
5966
5967#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5968#[serde(rename_all = "camelCase")]
5969pub struct PluginSkillReadResponse {
5970    #[serde(default, skip_serializing_if = "Option::is_none")]
5971    pub contents: Option<String>,
5972}
5973
5974#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5975#[serde(tag = "type", rename_all = "camelCase")]
5976pub enum PluginSource {
5977    Local {
5978        path: AbsolutePathBuf,
5979    },
5980    Git {
5981        #[serde(default, skip_serializing_if = "Option::is_none")]
5982        path: Option<String>,
5983        #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
5984        ref_name: Option<String>,
5985        #[serde(default, skip_serializing_if = "Option::is_none")]
5986        sha: Option<String>,
5987        url: String,
5988    },
5989    Npm {
5990        package: String,
5991        #[serde(default, skip_serializing_if = "Option::is_none")]
5992        registry: Option<String>,
5993        #[serde(default, skip_serializing_if = "Option::is_none")]
5994        version: Option<String>,
5995    },
5996    Remote,
5997}
5998
5999#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6000#[serde(rename_all = "camelCase")]
6001pub struct PluginSummary {
6002    #[serde(rename = "authPolicy")]
6003    pub auth_policy: PluginAuthPolicy,
6004    #[serde(default, skip_serializing_if = "Option::is_none")]
6005    pub availability: Option<Value>,
6006    #[serde(
6007        rename = "disabledReason",
6008        default,
6009        skip_serializing_if = "Option::is_none"
6010    )]
6011    pub disabled_reason: Option<PluginDisabledReason>,
6012    #[serde(
6013        rename = "eligiblePlanTypes",
6014        default,
6015        skip_serializing_if = "Option::is_none"
6016    )]
6017    pub eligible_plan_types: Option<Vec<String>>,
6018    #[serde(default)]
6019    pub enabled: bool,
6020    /// Host-integration surface (entrypoints, settings, search providers)
6021    /// contributed by the plugin's bundled MCP app, when it has one.
6022    #[serde(default, skip_serializing_if = "Option::is_none")]
6023    pub extensions: Option<PluginExtensions>,
6024    #[serde(default)]
6025    pub id: String,
6026    #[serde(rename = "installPolicy")]
6027    pub install_policy: PluginInstallPolicy,
6028    #[serde(
6029        rename = "installPolicySource",
6030        default,
6031        skip_serializing_if = "Option::is_none"
6032    )]
6033    pub install_policy_source: Option<PluginInstallPolicySource>,
6034    #[serde(default)]
6035    pub installed: bool,
6036    #[serde(
6037        rename = "installedAt",
6038        default,
6039        skip_serializing_if = "Option::is_none"
6040    )]
6041    pub installed_at: Option<i64>,
6042    #[serde(default, skip_serializing_if = "Option::is_none")]
6043    pub interface: Option<PluginInterface>,
6044    #[serde(default, skip_serializing_if = "Option::is_none")]
6045    pub keywords: Option<Vec<String>>,
6046    #[serde(
6047        rename = "localVersion",
6048        default,
6049        skip_serializing_if = "Option::is_none"
6050    )]
6051    pub local_version: Option<String>,
6052    #[serde(
6053        rename = "mustShowInstallationInterstitial",
6054        default,
6055        skip_serializing_if = "Option::is_none"
6056    )]
6057    pub must_show_installation_interstitial: Option<bool>,
6058    #[serde(default)]
6059    pub name: String,
6060    #[serde(
6061        rename = "remotePluginId",
6062        default,
6063        skip_serializing_if = "Option::is_none"
6064    )]
6065    pub remote_plugin_id: Option<String>,
6066    #[serde(
6067        rename = "shareContext",
6068        default,
6069        skip_serializing_if = "Option::is_none"
6070    )]
6071    pub share_context: Option<PluginShareContext>,
6072    #[serde()]
6073    pub source: PluginSource,
6074    #[serde(default, skip_serializing_if = "Option::is_none")]
6075    pub version: Option<String>,
6076}
6077
6078#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6079#[serde(rename_all = "camelCase")]
6080pub struct PluginUninstallParams {
6081    #[serde(rename = "pluginId", default)]
6082    pub plugin_id: String,
6083}
6084
6085#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6086#[serde(rename_all = "camelCase")]
6087pub struct PluginUninstallResponse {
6088    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6089    pub extra: serde_json::Map<String, Value>,
6090}
6091
6092#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6093#[serde(rename_all = "camelCase")]
6094pub struct PluginsMigration {
6095    #[serde(rename = "marketplaceName", default)]
6096    pub marketplace_name: String,
6097    #[serde(rename = "pluginNames", default)]
6098    pub plugin_names: Vec<String>,
6099}
6100
6101#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6102#[serde(rename_all = "camelCase")]
6103pub struct ProcessExitedNotification {
6104    #[serde(rename = "exitCode", default)]
6105    pub exit_code: i64,
6106    #[serde(rename = "processHandle", default)]
6107    pub process_handle: String,
6108    #[serde(default)]
6109    pub stderr: String,
6110    #[serde(rename = "stderrCapReached", default)]
6111    pub stderr_cap_reached: bool,
6112    #[serde(default)]
6113    pub stdout: String,
6114    #[serde(rename = "stdoutCapReached", default)]
6115    pub stdout_cap_reached: bool,
6116}
6117
6118#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6119#[serde(rename_all = "camelCase")]
6120pub struct ProcessOutputDeltaNotification {
6121    #[serde(rename = "capReached", default)]
6122    pub cap_reached: bool,
6123    #[serde(rename = "deltaBase64", default)]
6124    pub delta_base64: String,
6125    #[serde(rename = "processHandle", default)]
6126    pub process_handle: String,
6127    #[serde(default)]
6128    pub stream: Value,
6129}
6130
6131#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6132pub enum ProcessOutputStream {
6133    #[serde(rename = "stdout")]
6134    Stdout,
6135    #[serde(rename = "stderr")]
6136    Stderr,
6137}
6138
6139#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6140pub enum RateLimitReachedType {
6141    #[serde(rename = "rate_limit_reached")]
6142    Rate_limit_reached,
6143    #[serde(rename = "workspace_owner_credits_depleted")]
6144    Workspace_owner_credits_depleted,
6145    #[serde(rename = "workspace_member_credits_depleted")]
6146    Workspace_member_credits_depleted,
6147    #[serde(rename = "workspace_owner_usage_limit_reached")]
6148    Workspace_owner_usage_limit_reached,
6149    #[serde(rename = "workspace_member_usage_limit_reached")]
6150    Workspace_member_usage_limit_reached,
6151}
6152
6153#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6154#[serde(rename_all = "camelCase")]
6155pub struct RateLimitResetCredit {
6156    #[serde(default, skip_serializing_if = "Option::is_none")]
6157    pub description: Option<String>,
6158    #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
6159    pub expires_at: Option<i64>,
6160    #[serde(rename = "grantedAt", default)]
6161    pub granted_at: i64,
6162    #[serde(default)]
6163    pub id: String,
6164    #[serde(rename = "resetType")]
6165    pub reset_type: RateLimitResetType,
6166    #[serde()]
6167    pub status: RateLimitResetCreditStatus,
6168    #[serde(default, skip_serializing_if = "Option::is_none")]
6169    pub title: Option<String>,
6170}
6171
6172#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6173pub enum RateLimitResetCreditStatus {
6174    #[serde(rename = "available")]
6175    Available,
6176    #[serde(rename = "redeeming")]
6177    Redeeming,
6178    #[serde(rename = "redeemed")]
6179    Redeemed,
6180    #[serde(rename = "unknown")]
6181    Unknown,
6182}
6183
6184#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6185#[serde(rename_all = "camelCase")]
6186pub struct RateLimitResetCreditsSummary {
6187    #[serde(rename = "availableCount", default)]
6188    pub available_count: i64,
6189    #[serde(default, skip_serializing_if = "Option::is_none")]
6190    pub credits: Option<Vec<RateLimitResetCredit>>,
6191}
6192
6193#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6194pub enum RateLimitResetType {
6195    #[serde(rename = "codexRateLimits")]
6196    CodexRateLimits,
6197    #[serde(rename = "unknown")]
6198    Unknown,
6199}
6200
6201#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6202#[serde(rename_all = "camelCase")]
6203pub struct RateLimitSnapshot {
6204    #[serde(default, skip_serializing_if = "Option::is_none")]
6205    pub credits: Option<CreditsSnapshot>,
6206    #[serde(
6207        rename = "individualLimit",
6208        default,
6209        skip_serializing_if = "Option::is_none"
6210    )]
6211    pub individual_limit: Option<SpendControlLimitSnapshot>,
6212    #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
6213    pub limit_id: Option<String>,
6214    #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
6215    pub limit_name: Option<String>,
6216    /// Normal model whose display name and reasoning options describe this
6217    /// quota alias.
6218    #[serde(
6219        rename = "normalModelSlug",
6220        default,
6221        skip_serializing_if = "Option::is_none"
6222    )]
6223    pub normal_model_slug: Option<String>,
6224    #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
6225    pub plan_type: Option<PlanType>,
6226    #[serde(default, skip_serializing_if = "Option::is_none")]
6227    pub primary: Option<RateLimitWindow>,
6228    #[serde(
6229        rename = "rateLimitReachedType",
6230        default,
6231        skip_serializing_if = "Option::is_none"
6232    )]
6233    pub rate_limit_reached_type: Option<RateLimitReachedType>,
6234    #[serde(default, skip_serializing_if = "Option::is_none")]
6235    pub secondary: Option<RateLimitWindow>,
6236    #[serde(
6237        rename = "spendControlReached",
6238        default,
6239        skip_serializing_if = "Option::is_none"
6240    )]
6241    pub spend_control_reached: Option<bool>,
6242}
6243
6244#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6245#[serde(rename_all = "camelCase")]
6246pub struct RateLimitWindow {
6247    #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
6248    pub resets_at: Option<i64>,
6249    #[serde(rename = "usedPercent", default)]
6250    pub used_percent: i64,
6251    #[serde(
6252        rename = "windowDurationMins",
6253        default,
6254        skip_serializing_if = "Option::is_none"
6255    )]
6256    pub window_duration_mins: Option<i64>,
6257}
6258
6259#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6260pub enum RealtimeConversationVersion {
6261    #[serde(rename = "v1")]
6262    V1,
6263    #[serde(rename = "v2")]
6264    V2,
6265    #[serde(rename = "v3")]
6266    V3,
6267}
6268
6269/// A non-empty reasoning effort value advertised by the model.
6270#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
6271#[serde(transparent)]
6272pub struct ReasoningEffort(pub String);
6273
6274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6275#[serde(rename_all = "camelCase")]
6276pub struct ReasoningEffortOption {
6277    #[serde(default)]
6278    pub description: String,
6279    #[serde(rename = "reasoningEffort")]
6280    pub reasoning_effort: ReasoningEffort,
6281}
6282
6283#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6284pub enum ReasoningSummary {
6285    #[serde(rename = "auto")]
6286    Auto,
6287    #[serde(rename = "concise")]
6288    Concise,
6289    #[serde(rename = "detailed")]
6290    Detailed,
6291    #[serde(rename = "none")]
6292    None,
6293}
6294
6295#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6296#[serde(rename_all = "camelCase")]
6297pub struct ReasoningSummaryPartAddedNotification {
6298    #[serde(rename = "itemId", default)]
6299    pub item_id: String,
6300    #[serde(rename = "summaryIndex", default)]
6301    pub summary_index: i64,
6302    #[serde(rename = "threadId", default)]
6303    pub thread_id: String,
6304    #[serde(rename = "turnId", default)]
6305    pub turn_id: String,
6306}
6307
6308#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6309#[serde(rename_all = "camelCase")]
6310pub struct ReasoningSummaryTextDeltaNotification {
6311    #[serde(default)]
6312    pub delta: String,
6313    #[serde(rename = "itemId", default)]
6314    pub item_id: String,
6315    #[serde(rename = "summaryIndex", default)]
6316    pub summary_index: i64,
6317    #[serde(rename = "threadId", default)]
6318    pub thread_id: String,
6319    #[serde(rename = "turnId", default)]
6320    pub turn_id: String,
6321}
6322
6323#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6324#[serde(rename_all = "camelCase")]
6325pub struct ReasoningTextDeltaNotification {
6326    #[serde(rename = "contentIndex", default)]
6327    pub content_index: i64,
6328    #[serde(default)]
6329    pub delta: String,
6330    #[serde(rename = "itemId", default)]
6331    pub item_id: String,
6332    #[serde(rename = "threadId", default)]
6333    pub thread_id: String,
6334    #[serde(rename = "turnId", default)]
6335    pub turn_id: String,
6336}
6337
6338#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6339pub enum RemoteControlConnectionStatus {
6340    #[serde(rename = "disabled")]
6341    Disabled,
6342    #[serde(rename = "connecting")]
6343    Connecting,
6344    #[serde(rename = "connected")]
6345    Connected,
6346    #[serde(rename = "errored")]
6347    Errored,
6348}
6349
6350#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6351#[serde(rename_all = "camelCase")]
6352pub struct RemoteControlStatusChangedNotification {
6353    #[serde(
6354        rename = "environmentId",
6355        default,
6356        skip_serializing_if = "Option::is_none"
6357    )]
6358    pub environment_id: Option<String>,
6359    #[serde(rename = "installationId", default)]
6360    pub installation_id: String,
6361    #[serde(rename = "serverName", default)]
6362    pub server_name: String,
6363    #[serde()]
6364    pub status: RemoteControlConnectionStatus,
6365}
6366
6367#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6368#[serde(untagged)]
6369pub enum RequestId {
6370    Variant0(String),
6371    Variant1(i64),
6372}
6373
6374#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6375#[serde(rename_all = "camelCase")]
6376pub struct RequestPermissionProfile {
6377    #[serde(
6378        rename = "fileSystem",
6379        default,
6380        skip_serializing_if = "Option::is_none"
6381    )]
6382    pub file_system: Option<AdditionalFileSystemPermissions>,
6383    #[serde(default, skip_serializing_if = "Option::is_none")]
6384    pub network: Option<AdditionalNetworkPermissions>,
6385}
6386
6387#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6388pub enum ResidencyRequirement {
6389    #[serde(rename = "us")]
6390    Us,
6391}
6392
6393#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6394#[serde(rename_all = "camelCase")]
6395pub struct Resource {
6396    #[serde(default, skip_serializing_if = "Option::is_none")]
6397    pub _meta: Option<Value>,
6398    #[serde(default, skip_serializing_if = "Option::is_none")]
6399    pub annotations: Option<Value>,
6400    #[serde(default, skip_serializing_if = "Option::is_none")]
6401    pub description: Option<String>,
6402    #[serde(default, skip_serializing_if = "Option::is_none")]
6403    pub icons: Option<Vec<Value>>,
6404    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6405    pub mime_type: Option<String>,
6406    #[serde(default)]
6407    pub name: String,
6408    #[serde(default, skip_serializing_if = "Option::is_none")]
6409    pub size: Option<i64>,
6410    #[serde(default, skip_serializing_if = "Option::is_none")]
6411    pub title: Option<String>,
6412    #[serde(default)]
6413    pub uri: String,
6414}
6415
6416#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6417#[serde(untagged)]
6418pub enum ResourceContent {
6419    Variant0(Value),
6420    Variant1(Value),
6421}
6422
6423#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6424#[serde(rename_all = "camelCase")]
6425pub struct ResourceTemplate {
6426    #[serde(default, skip_serializing_if = "Option::is_none")]
6427    pub annotations: Option<Value>,
6428    #[serde(default, skip_serializing_if = "Option::is_none")]
6429    pub description: Option<String>,
6430    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6431    pub mime_type: Option<String>,
6432    #[serde(default)]
6433    pub name: String,
6434    #[serde(default, skip_serializing_if = "Option::is_none")]
6435    pub title: Option<String>,
6436    #[serde(rename = "uriTemplate", default)]
6437    pub uri_template: String,
6438}
6439
6440/// Usage metadata reported for one upstream response (0.148 upstream).
6441#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6442#[serde(rename_all = "camelCase")]
6443pub struct ResponseUsageMetadata {
6444    #[serde(default, skip_serializing_if = "Option::is_none")]
6445    pub amount: Option<String>,
6446    #[serde(default, skip_serializing_if = "Option::is_none")]
6447    pub metadata: Option<Value>,
6448}
6449
6450#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6451pub enum ReviewDecision {
6452    #[serde(rename = "approved")]
6453    Approved,
6454    #[serde(rename = "approved_execpolicy_amendment")]
6455    ApprovedExecpolicyAmendment {
6456        proposed_execpolicy_amendment: Vec<String>,
6457    },
6458    #[serde(rename = "approved_for_session")]
6459    ApprovedForSession,
6460    #[serde(rename = "approved_mcp_policy_amendment")]
6461    ApprovedMcpPolicyAmendment,
6462    #[serde(rename = "network_policy_amendment")]
6463    NetworkPolicyAmendment {
6464        network_policy_amendment: NetworkPolicyAmendment,
6465    },
6466    #[serde(rename = "denied")]
6467    Denied { rejection: String },
6468    #[serde(rename = "timed_out")]
6469    TimedOut,
6470    #[serde(rename = "abort")]
6471    Abort,
6472}
6473
6474#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6475pub enum ReviewDelivery {
6476    #[serde(rename = "inline")]
6477    Inline,
6478    #[serde(rename = "detached")]
6479    Detached,
6480}
6481
6482#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6483#[serde(rename_all = "camelCase")]
6484pub struct ReviewStartParams {
6485    #[serde(default, skip_serializing_if = "Option::is_none")]
6486    pub delivery: Option<ReviewDelivery>,
6487    #[serde()]
6488    pub target: ReviewTarget,
6489    #[serde(rename = "threadId", default)]
6490    pub thread_id: String,
6491}
6492
6493#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6494#[serde(rename_all = "camelCase")]
6495pub struct ReviewStartResponse {
6496    #[serde(rename = "reviewThreadId", default)]
6497    pub review_thread_id: String,
6498    #[serde()]
6499    pub turn: Turn,
6500}
6501
6502#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6503#[serde(tag = "type", rename_all = "camelCase")]
6504pub enum ReviewTarget {
6505    #[serde(rename = "uncommittedChanges")]
6506    UncommittedChanges,
6507    #[serde(rename = "baseBranch")]
6508    BaseBranch {
6509        branch: String,
6510    },
6511    Commit {
6512        sha: String,
6513        #[serde(default, skip_serializing_if = "Option::is_none")]
6514        title: Option<String>,
6515    },
6516    Custom {
6517        instructions: String,
6518    },
6519}
6520
6521/// Delivery mode for an agent message item (0.147: currently only `async`).
6522#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6523pub enum AgentMessageDelivery {
6524    #[serde(rename = "async")]
6525    Async,
6526}
6527
6528/// Where the CLI stores auth credentials.
6529#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6530pub enum CliAuthCredentialsStoreMode {
6531    #[serde(rename = "file")]
6532    File,
6533    #[serde(rename = "keyring")]
6534    Keyring,
6535    #[serde(rename = "auto")]
6536    Auto,
6537    #[serde(rename = "ephemeral")]
6538    Ephemeral,
6539}
6540
6541/// A project grouping threads, owned by app-server.
6542#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6543pub struct Project {
6544    #[serde(rename = "createdAt", default)]
6545    pub created_at: i64,
6546    #[serde(default)]
6547    pub id: String,
6548    #[serde(default)]
6549    pub metadata: std::collections::HashMap<String, String>,
6550    #[serde(default)]
6551    pub name: String,
6552    #[serde(default)]
6553    pub position: i64,
6554    /// Newest non-archived member thread's recency, in Unix seconds;
6555    /// absent/null when none exist (0.148 upstream).
6556    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
6557    pub recency_at: Option<i64>,
6558    #[serde(default)]
6559    pub roots: Vec<ProjectRoot>,
6560    #[serde(rename = "updatedAt", default)]
6561    pub updated_at: i64,
6562}
6563
6564/// Sort order for project listings (0.148 upstream).
6565#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6566pub enum ProjectSortKey {
6567    #[serde(rename = "position")]
6568    Position,
6569    #[serde(rename = "recencyAt")]
6570    RecencyAt,
6571}
6572
6573#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6574pub enum ProjectChangeType {
6575    #[serde(rename = "created")]
6576    Created,
6577    #[serde(rename = "updated")]
6578    Updated,
6579    #[serde(rename = "deleted")]
6580    Deleted,
6581}
6582
6583/// `project/changed` — a project was created, updated, or deleted.
6584#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6585pub struct ProjectChangedNotification {
6586    #[serde(rename = "changeType")]
6587    pub change_type: ProjectChangeType,
6588    #[serde(rename = "projectId", default)]
6589    pub project_id: String,
6590}
6591
6592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6593pub struct ProjectRoot {
6594    pub path: AbsolutePathBuf,
6595}
6596
6597/// A user submission waiting in a thread's queue.
6598#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6599pub struct QueuedSubmission {
6600    #[serde(rename = "clientUserMessageId", default)]
6601    pub client_user_message_id: String,
6602    #[serde(default)]
6603    pub id: String,
6604    #[serde(default)]
6605    pub input: Vec<UserInput>,
6606}
6607
6608/// `autoApprovalReview/strictReviewRequired` — a strict review gate opened.
6609#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6610pub struct StrictReviewRequiredNotification {
6611    /// Unix timestamp (ms) when this review started.
6612    #[serde(rename = "startedAtMs", default)]
6613    pub started_at_ms: i64,
6614    #[serde(rename = "threadId", default)]
6615    pub thread_id: String,
6616    #[serde(rename = "turnId", default)]
6617    pub turn_id: String,
6618}
6619
6620/// `thread/project/updated` — a thread's project assignment changed.
6621#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6622pub struct ThreadProjectUpdatedNotification {
6623    #[serde(rename = "projectId", default)]
6624    pub project_id: Option<String>,
6625    #[serde(rename = "threadId", default)]
6626    pub thread_id: String,
6627}
6628
6629/// `thread/queue/changed` — the thread's queued submissions changed.
6630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6631pub struct ThreadQueueChangedNotification {
6632    #[serde(rename = "threadId", default)]
6633    pub thread_id: String,
6634}
6635
6636/// `thread/reverted` — the thread was rolled back.
6637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6638pub struct ThreadRevertedNotification {
6639    #[serde(rename = "threadId", default)]
6640    pub thread_id: String,
6641}
6642
6643/// In-app browser requirements (0.148 upstream).
6644#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6645#[serde(rename_all = "camelCase")]
6646pub struct InAppBrowserRequirements {
6647    #[serde(
6648        rename = "allowExternalBrowserSettingsImport",
6649        default,
6650        skip_serializing_if = "Option::is_none"
6651    )]
6652    pub allow_external_browser_settings_import: Option<bool>,
6653}
6654
6655/// One MCP-server-originated notification, relayed verbatim.
6656#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6657pub struct McpServerEventNotification {
6658    #[serde(default)]
6659    pub method: String,
6660    #[serde(default)]
6661    pub params: Value,
6662}
6663
6664/// `mcpServer/event/stream/notification` — an MCP server's own
6665/// notification stream, forwarded to subscribers.
6666#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6667pub struct McpServerEventStreamNotification {
6668    pub notification: McpServerEventNotification,
6669    #[serde(rename = "subscriptionId", default)]
6670    pub subscription_id: String,
6671}
6672
6673/// Allow/deny switch used across the browser-use / computer-use policy
6674/// surface (0.148 upstream).
6675#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6676pub enum AllowDenyRequirement {
6677    #[serde(rename = "allow")]
6678    Allow,
6679    #[serde(rename = "deny")]
6680    Deny,
6681}
6682
6683/// How long a granted browser-use access approval lasts.
6684#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6685pub enum BrowserUseAccessApprovalLifetime {
6686    #[serde(rename = "turn")]
6687    Turn,
6688    #[serde(rename = "thread")]
6689    Thread,
6690}
6691
6692/// Current thread-runtime MCP server connection state.
6693#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6694pub enum McpServerConnectionStatus {
6695    #[serde(rename = "notStarted")]
6696    NotStarted,
6697    #[serde(rename = "starting")]
6698    Starting,
6699    #[serde(rename = "connected")]
6700    Connected,
6701    #[serde(rename = "authenticationRequired")]
6702    AuthenticationRequired,
6703    #[serde(rename = "failed")]
6704    Failed,
6705    #[serde(rename = "cancelled")]
6706    Cancelled,
6707    #[serde(rename = "disabled")]
6708    Disabled,
6709}
6710
6711/// Per-origin browser-use policy (requirements side, camelCase wire).
6712#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6713#[serde(rename_all = "camelCase")]
6714pub struct BrowserUseOriginPolicy {
6715    #[serde(default, skip_serializing_if = "Option::is_none")]
6716    pub access: Option<AllowDenyRequirement>,
6717    #[serde(
6718        rename = "accessApprovalLifetime",
6719        default,
6720        skip_serializing_if = "Option::is_none"
6721    )]
6722    pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
6723    #[serde(
6724        rename = "autoReview",
6725        default,
6726        skip_serializing_if = "Option::is_none"
6727    )]
6728    pub auto_review: Option<AllowDenyRequirement>,
6729    #[serde(default, skip_serializing_if = "Option::is_none")]
6730    pub downloads: Option<AllowDenyRequirement>,
6731    #[serde(
6732        rename = "fullCdpAccess",
6733        default,
6734        skip_serializing_if = "Option::is_none"
6735    )]
6736    pub full_cdp_access: Option<AllowDenyRequirement>,
6737    #[serde(
6738        rename = "persistentApproval",
6739        default,
6740        skip_serializing_if = "Option::is_none"
6741    )]
6742    pub persistent_approval: Option<bool>,
6743    #[serde(default, skip_serializing_if = "Option::is_none")]
6744    pub uploads: Option<AllowDenyRequirement>,
6745}
6746
6747/// Per-origin browser-use policy (config side, snake_case wire).
6748#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6749pub struct BrowserUseOriginPolicyConfig {
6750    #[serde(default, skip_serializing_if = "Option::is_none")]
6751    pub access: Option<AllowDenyRequirement>,
6752    #[serde(default, skip_serializing_if = "Option::is_none")]
6753    pub downloads: Option<AllowDenyRequirement>,
6754    #[serde(default, skip_serializing_if = "Option::is_none")]
6755    pub full_cdp_access: Option<AllowDenyRequirement>,
6756    #[serde(default, skip_serializing_if = "Option::is_none")]
6757    pub uploads: Option<AllowDenyRequirement>,
6758}
6759
6760/// Browser-use configuration (config side, snake_case wire).
6761#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6762pub struct BrowserUseConfig {
6763    #[serde(default, skip_serializing_if = "Option::is_none")]
6764    pub allow_history_access: Option<bool>,
6765    #[serde(default, skip_serializing_if = "Option::is_none")]
6766    pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
6767    #[serde(default, skip_serializing_if = "Option::is_none")]
6768    pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
6769}
6770
6771/// Computer-use configuration (config side, snake_case wire).
6772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6773pub struct ComputerUseConfig {
6774    #[serde(default, skip_serializing_if = "Option::is_none")]
6775    pub default_app_access: Option<AllowDenyRequirement>,
6776    #[serde(default, skip_serializing_if = "Option::is_none")]
6777    pub macos: Option<ComputerUseMacosConfig>,
6778    #[serde(default, skip_serializing_if = "Option::is_none")]
6779    pub windows: Option<ComputerUseWindowsConfig>,
6780}
6781
6782#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6783pub struct ComputerUseMacosConfig {
6784    #[serde(default, skip_serializing_if = "Option::is_none")]
6785    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6786}
6787
6788#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6789pub struct ComputerUseWindowsConfig {
6790    #[serde(default, skip_serializing_if = "Option::is_none")]
6791    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6792    #[serde(default, skip_serializing_if = "Option::is_none")]
6793    pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
6794}
6795
6796#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6797pub struct ComputerUseWindowsExeConfig {
6798    pub access: AllowDenyRequirement,
6799    #[serde(default, skip_serializing_if = "Option::is_none")]
6800    pub binary_name: Option<String>,
6801    #[serde(default)]
6802    pub product_name: String,
6803    #[serde(default)]
6804    pub publisher_name: String,
6805}
6806
6807/// Per-platform computer-use requirements (camelCase wire).
6808#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6809#[serde(rename_all = "camelCase")]
6810pub struct ComputerUseMacosRequirements {
6811    #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
6812    pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6813}
6814
6815#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6816#[serde(rename_all = "camelCase")]
6817pub struct ComputerUseWindowsRequirements {
6818    #[serde(default, skip_serializing_if = "Option::is_none")]
6819    pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6820    #[serde(default, skip_serializing_if = "Option::is_none")]
6821    pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
6822}
6823
6824#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6825#[serde(rename_all = "camelCase")]
6826pub struct ComputerUseWindowsExeRequirement {
6827    pub access: AllowDenyRequirement,
6828    #[serde(
6829        rename = "binaryName",
6830        default,
6831        skip_serializing_if = "Option::is_none"
6832    )]
6833    pub binary_name: Option<String>,
6834    #[serde(rename = "productName", default)]
6835    pub product_name: String,
6836    #[serde(rename = "publisherName", default)]
6837    pub publisher_name: String,
6838}
6839
6840#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6841pub enum SandboxMode {
6842    #[serde(rename = "read-only")]
6843    Read_only,
6844    #[serde(rename = "workspace-write")]
6845    Workspace_write,
6846    #[serde(rename = "danger-full-access")]
6847    Danger_full_access,
6848}
6849
6850#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6851#[serde(tag = "type", rename_all = "camelCase")]
6852pub enum SandboxPolicy {
6853    #[serde(rename = "dangerFullAccess")]
6854    DangerFullAccess,
6855    #[serde(rename = "readOnly")]
6856    ReadOnly {
6857        #[serde(
6858            rename = "networkAccess",
6859            default,
6860            skip_serializing_if = "Option::is_none"
6861        )]
6862        network_access: Option<bool>,
6863    },
6864    #[serde(rename = "externalSandbox")]
6865    ExternalSandbox {
6866        #[serde(
6867            rename = "networkAccess",
6868            default,
6869            skip_serializing_if = "Option::is_none"
6870        )]
6871        network_access: Option<Value>,
6872    },
6873    #[serde(rename = "workspaceWrite")]
6874    WorkspaceWrite {
6875        #[serde(
6876            rename = "excludeSlashTmp",
6877            default,
6878            skip_serializing_if = "Option::is_none"
6879        )]
6880        exclude_slash_tmp: Option<bool>,
6881        #[serde(
6882            rename = "excludeTmpdirEnvVar",
6883            default,
6884            skip_serializing_if = "Option::is_none"
6885        )]
6886        exclude_tmpdir_env_var: Option<bool>,
6887        #[serde(
6888            rename = "networkAccess",
6889            default,
6890            skip_serializing_if = "Option::is_none"
6891        )]
6892        network_access: Option<bool>,
6893        #[serde(
6894            rename = "writableRoots",
6895            default,
6896            skip_serializing_if = "Option::is_none"
6897        )]
6898        writable_roots: Option<Vec<AbsolutePathBuf>>,
6899    },
6900}
6901
6902#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6903#[serde(rename_all = "snake_case")]
6904pub struct SandboxWorkspaceWrite {
6905    #[serde(default, skip_serializing_if = "Option::is_none")]
6906    pub exclude_slash_tmp: Option<bool>,
6907    #[serde(default, skip_serializing_if = "Option::is_none")]
6908    pub exclude_tmpdir_env_var: Option<bool>,
6909    #[serde(default, skip_serializing_if = "Option::is_none")]
6910    pub network_access: Option<bool>,
6911    #[serde(default, skip_serializing_if = "Option::is_none")]
6912    pub writable_roots: Option<Vec<String>>,
6913}
6914
6915#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6916#[serde(tag = "type", rename_all = "camelCase")]
6917pub enum ScheduledTaskSchedule {
6918    Hourly {
6919        #[serde(default, skip_serializing_if = "Option::is_none")]
6920        days: Option<Vec<ScheduledTaskWeekday>>,
6921        #[serde(rename = "intervalHours")]
6922        interval_hours: i64,
6923    },
6924    Daily {
6925        time: String,
6926    },
6927    Weekdays {
6928        time: String,
6929    },
6930    Weekly {
6931        days: Vec<ScheduledTaskWeekday>,
6932        time: String,
6933    },
6934}
6935
6936#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6937#[serde(rename_all = "camelCase")]
6938pub struct ScheduledTaskSummary {
6939    #[serde(default)]
6940    pub key: String,
6941    #[serde(default)]
6942    pub name: String,
6943    #[serde(default)]
6944    pub prompt: String,
6945    #[serde()]
6946    pub schedule: ScheduledTaskSchedule,
6947}
6948
6949#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6950pub enum ScheduledTaskWeekday {
6951    #[serde(rename = "MO")]
6952    MO,
6953    #[serde(rename = "TU")]
6954    TU,
6955    #[serde(rename = "WE")]
6956    WE,
6957    #[serde(rename = "TH")]
6958    TH,
6959    #[serde(rename = "FR")]
6960    FR,
6961    #[serde(rename = "SA")]
6962    SA,
6963    #[serde(rename = "SU")]
6964    SU,
6965}
6966
6967#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6968#[serde(rename_all = "camelCase")]
6969pub struct SendAddCreditsNudgeEmailParams {
6970    #[serde(rename = "creditType")]
6971    pub credit_type: AddCreditsNudgeCreditType,
6972}
6973
6974#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6975#[serde(rename_all = "camelCase")]
6976pub struct SendAddCreditsNudgeEmailResponse {
6977    #[serde()]
6978    pub status: AddCreditsNudgeEmailStatus,
6979}
6980
6981#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6982#[serde(rename_all = "camelCase")]
6983pub struct ServerRequestResolvedNotification {
6984    #[serde(rename = "requestId")]
6985    pub request_id: RequestId,
6986    #[serde(rename = "threadId", default)]
6987    pub thread_id: String,
6988}
6989
6990#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6991#[serde(rename_all = "camelCase")]
6992pub struct SessionMigration {
6993    #[serde(default)]
6994    pub cwd: String,
6995    #[serde(default)]
6996    pub path: String,
6997    #[serde(default, skip_serializing_if = "Option::is_none")]
6998    pub title: Option<String>,
6999}
7000
7001#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7002pub enum SessionSource {
7003    #[serde(rename = "cli")]
7004    Cli,
7005    #[serde(rename = "vscode")]
7006    Vscode,
7007    #[serde(rename = "exec")]
7008    Exec,
7009    #[serde(rename = "appServer")]
7010    AppServer,
7011    #[serde(rename = "unknown")]
7012    Unknown,
7013    #[serde(rename = "custom")]
7014    Custom(String),
7015    #[serde(rename = "subAgent")]
7016    SubAgent(SubAgentSource),
7017}
7018
7019#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7020#[serde(rename_all = "camelCase")]
7021pub struct Settings {
7022    #[serde(default, skip_serializing_if = "Option::is_none")]
7023    pub developer_instructions: Option<String>,
7024    #[serde(default)]
7025    pub model: String,
7026    #[serde(default, skip_serializing_if = "Option::is_none")]
7027    pub reasoning_effort: Option<ReasoningEffort>,
7028}
7029
7030#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7031#[serde(rename_all = "camelCase")]
7032pub struct SkillDependencies {
7033    #[serde(default)]
7034    pub tools: Vec<SkillToolDependency>,
7035}
7036
7037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7038#[serde(rename_all = "camelCase")]
7039pub struct SkillErrorInfo {
7040    #[serde(default)]
7041    pub message: String,
7042    #[serde(default)]
7043    pub path: String,
7044}
7045
7046#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7047#[serde(rename_all = "camelCase")]
7048pub struct SkillInterface {
7049    #[serde(
7050        rename = "brandColor",
7051        default,
7052        skip_serializing_if = "Option::is_none"
7053    )]
7054    pub brand_color: Option<String>,
7055    #[serde(
7056        rename = "defaultPrompt",
7057        default,
7058        skip_serializing_if = "Option::is_none"
7059    )]
7060    pub default_prompt: Option<String>,
7061    #[serde(
7062        rename = "displayName",
7063        default,
7064        skip_serializing_if = "Option::is_none"
7065    )]
7066    pub display_name: Option<String>,
7067    #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
7068    pub icon_large: Option<AbsolutePathBuf>,
7069    #[serde(
7070        rename = "iconLargeUrl",
7071        default,
7072        skip_serializing_if = "Option::is_none"
7073    )]
7074    pub icon_large_url: Option<String>,
7075    #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
7076    pub icon_small: Option<AbsolutePathBuf>,
7077    #[serde(
7078        rename = "iconSmallUrl",
7079        default,
7080        skip_serializing_if = "Option::is_none"
7081    )]
7082    pub icon_small_url: Option<String>,
7083    #[serde(
7084        rename = "shortDescription",
7085        default,
7086        skip_serializing_if = "Option::is_none"
7087    )]
7088    pub short_description: Option<String>,
7089}
7090
7091#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7092#[serde(rename_all = "camelCase")]
7093pub struct SkillMetadata {
7094    #[serde(default, skip_serializing_if = "Option::is_none")]
7095    pub dependencies: Option<SkillDependencies>,
7096    #[serde(default)]
7097    pub description: String,
7098    #[serde(default)]
7099    pub enabled: bool,
7100    #[serde(default, skip_serializing_if = "Option::is_none")]
7101    pub interface: Option<SkillInterface>,
7102    #[serde(default)]
7103    pub name: String,
7104    #[serde()]
7105    pub path: AbsolutePathBuf,
7106    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7107    pub plugin_id: Option<String>,
7108    #[serde()]
7109    pub scope: SkillScope,
7110    #[serde(
7111        rename = "shortDescription",
7112        default,
7113        skip_serializing_if = "Option::is_none"
7114    )]
7115    pub short_description: Option<String>,
7116}
7117
7118#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7119#[serde(rename_all = "camelCase")]
7120pub struct SkillMigration {
7121    #[serde(default)]
7122    pub name: String,
7123}
7124
7125#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7126pub enum SkillScope {
7127    #[serde(rename = "user")]
7128    User,
7129    #[serde(rename = "repo")]
7130    Repo,
7131    #[serde(rename = "system")]
7132    System,
7133    #[serde(rename = "admin")]
7134    Admin,
7135}
7136
7137#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7138#[serde(rename_all = "camelCase")]
7139pub struct SkillSummary {
7140    #[serde(default)]
7141    pub description: String,
7142    #[serde(default)]
7143    pub enabled: bool,
7144    #[serde(default, skip_serializing_if = "Option::is_none")]
7145    pub interface: Option<SkillInterface>,
7146    #[serde(default)]
7147    pub name: String,
7148    #[serde(default, skip_serializing_if = "Option::is_none")]
7149    pub path: Option<AbsolutePathBuf>,
7150    #[serde(
7151        rename = "shortDescription",
7152        default,
7153        skip_serializing_if = "Option::is_none"
7154    )]
7155    pub short_description: Option<String>,
7156}
7157
7158#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7159#[serde(rename_all = "camelCase")]
7160pub struct SkillToolDependency {
7161    #[serde(default, skip_serializing_if = "Option::is_none")]
7162    pub command: Option<String>,
7163    #[serde(default, skip_serializing_if = "Option::is_none")]
7164    pub description: Option<String>,
7165    #[serde(default, skip_serializing_if = "Option::is_none")]
7166    pub transport: Option<String>,
7167    #[serde(rename = "type", default)]
7168    pub type_: String,
7169    #[serde(default, skip_serializing_if = "Option::is_none")]
7170    pub url: Option<String>,
7171    #[serde(default)]
7172    pub value: String,
7173}
7174
7175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7176#[serde(rename_all = "camelCase")]
7177pub struct SkillsChangedNotification {
7178    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7179    pub extra: serde_json::Map<String, Value>,
7180}
7181
7182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7183#[serde(rename_all = "camelCase")]
7184pub struct SkillsConfigWriteParams {
7185    #[serde(default)]
7186    pub enabled: bool,
7187    #[serde(default, skip_serializing_if = "Option::is_none")]
7188    pub name: Option<String>,
7189    #[serde(default, skip_serializing_if = "Option::is_none")]
7190    pub path: Option<AbsolutePathBuf>,
7191}
7192
7193#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7194#[serde(rename_all = "camelCase")]
7195pub struct SkillsConfigWriteResponse {
7196    #[serde(rename = "effectiveEnabled", default)]
7197    pub effective_enabled: bool,
7198}
7199
7200#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7201#[serde(rename_all = "camelCase")]
7202pub struct SkillsExtraRootsSetParams {
7203    #[serde(rename = "extraRoots", default)]
7204    pub extra_roots: Vec<AbsolutePathBuf>,
7205}
7206
7207#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7208#[serde(rename_all = "camelCase")]
7209pub struct SkillsExtraRootsSetResponse {
7210    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7211    pub extra: serde_json::Map<String, Value>,
7212}
7213
7214#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7215#[serde(rename_all = "camelCase")]
7216pub struct SkillsListEntry {
7217    #[serde(default)]
7218    pub cwd: String,
7219    #[serde(default)]
7220    pub errors: Vec<SkillErrorInfo>,
7221    #[serde(default)]
7222    pub skills: Vec<SkillMetadata>,
7223}
7224
7225#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7226#[serde(rename_all = "camelCase")]
7227pub struct SkillsListParams {
7228    #[serde(default, skip_serializing_if = "Option::is_none")]
7229    pub cwds: Option<Vec<String>>,
7230    #[serde(
7231        rename = "forceReload",
7232        default,
7233        skip_serializing_if = "Option::is_none"
7234    )]
7235    pub force_reload: Option<bool>,
7236}
7237
7238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7239#[serde(rename_all = "camelCase")]
7240pub struct SkillsListResponse {
7241    #[serde(default)]
7242    pub data: Vec<SkillsListEntry>,
7243}
7244
7245#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7246pub enum SortDirection {
7247    #[serde(rename = "asc")]
7248    Asc,
7249    #[serde(rename = "desc")]
7250    Desc,
7251}
7252
7253#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7254#[serde(rename_all = "camelCase")]
7255pub struct SpendControlLimitSnapshot {
7256    #[serde(default)]
7257    pub limit: String,
7258    #[serde(rename = "remainingPercent", default)]
7259    pub remaining_percent: i64,
7260    #[serde(rename = "resetsAt", default)]
7261    pub resets_at: i64,
7262    #[serde(default)]
7263    pub used: String,
7264}
7265
7266#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7267pub enum SubAgentActivityKind {
7268    #[serde(rename = "started")]
7269    Started,
7270    #[serde(rename = "interacted")]
7271    Interacted,
7272    #[serde(rename = "interrupted")]
7273    Interrupted,
7274    #[serde(rename = "completed")]
7275    Completed,
7276}
7277
7278#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7279pub enum SubAgentSource {
7280    #[serde(rename = "review")]
7281    Review,
7282    #[serde(rename = "compact")]
7283    Compact,
7284    #[serde(rename = "memory_consolidation")]
7285    MemoryConsolidation,
7286    #[serde(rename = "thread_spawn")]
7287    ThreadSpawn {
7288        #[serde(default, skip_serializing_if = "Option::is_none")]
7289        agent_nickname: Option<String>,
7290        #[serde(default, skip_serializing_if = "Option::is_none")]
7291        agent_path: Option<AgentPath>,
7292        #[serde(default, skip_serializing_if = "Option::is_none")]
7293        agent_role: Option<String>,
7294        depth: i64,
7295        parent_thread_id: ThreadId,
7296    },
7297    #[serde(rename = "other")]
7298    Other(String),
7299}
7300
7301#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7302#[serde(rename_all = "camelCase")]
7303pub struct SubagentMigration {
7304    #[serde(default)]
7305    pub name: String,
7306}
7307
7308#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7309#[serde(rename_all = "camelCase")]
7310pub struct TerminalInteractionNotification {
7311    #[serde(rename = "itemId", default)]
7312    pub item_id: String,
7313    #[serde(rename = "processId", default)]
7314    pub process_id: String,
7315    #[serde(default)]
7316    pub stdin: String,
7317    #[serde(rename = "threadId", default)]
7318    pub thread_id: String,
7319    #[serde(rename = "turnId", default)]
7320    pub turn_id: String,
7321}
7322
7323#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7324#[serde(rename_all = "camelCase")]
7325pub struct TextElement {
7326    #[serde(rename = "byteRange", default)]
7327    pub byte_range: Value,
7328    #[serde(default, skip_serializing_if = "Option::is_none")]
7329    pub placeholder: Option<String>,
7330}
7331
7332#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7333#[serde(rename_all = "camelCase")]
7334pub struct TextPosition {
7335    #[serde(default)]
7336    pub column: i64,
7337    #[serde(default)]
7338    pub line: i64,
7339}
7340
7341#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7342#[serde(rename_all = "camelCase")]
7343pub struct TextRange {
7344    #[serde()]
7345    pub end: TextPosition,
7346    #[serde()]
7347    pub start: TextPosition,
7348}
7349
7350#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7351#[serde(rename_all = "camelCase")]
7352pub struct Thread {
7353    #[serde(
7354        rename = "agentNickname",
7355        default,
7356        skip_serializing_if = "Option::is_none"
7357    )]
7358    pub agent_nickname: Option<String>,
7359    #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
7360    pub agent_role: Option<String>,
7361    #[serde(rename = "cliVersion", default)]
7362    pub cli_version: String,
7363    #[serde(rename = "createdAt", default)]
7364    pub created_at: i64,
7365    #[serde(default)]
7366    pub cwd: Value,
7367    #[serde(default)]
7368    pub ephemeral: bool,
7369    #[serde(
7370        rename = "forkedFromId",
7371        default,
7372        skip_serializing_if = "Option::is_none"
7373    )]
7374    pub forked_from_id: Option<String>,
7375    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
7376    pub git_info: Option<GitInfo>,
7377    /// Persisted history contract chosen at thread creation (0.148 upstream);
7378    /// absent on older servers, which are always `legacy`.
7379    #[serde(
7380        rename = "historyMode",
7381        default,
7382        skip_serializing_if = "Option::is_none"
7383    )]
7384    pub history_mode: Option<ThreadHistoryMode>,
7385    /// Canonical project assignment owned by app-server, if any. Required
7386    /// upstream from 0.147 but kept tolerant for pre-project servers.
7387    #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
7388    pub project_id: Option<String>,
7389    #[serde(default)]
7390    pub id: String,
7391    /// Current configured model when loaded, otherwise the latest persisted
7392    /// model. Null when unavailable. Not per-turn execution telemetry.
7393    #[serde(default, skip_serializing_if = "Option::is_none")]
7394    pub model: Option<String>,
7395    #[serde(rename = "modelProvider", default)]
7396    pub model_provider: String,
7397    #[serde(default, skip_serializing_if = "Option::is_none")]
7398    pub name: Option<String>,
7399    /// Originator recorded when the thread was created, independent of its
7400    /// current client or executor. `None` when the recorded originator is
7401    /// unavailable.
7402    #[serde(default, skip_serializing_if = "Option::is_none")]
7403    pub originator: Option<String>,
7404    #[serde(
7405        rename = "parentThreadId",
7406        default,
7407        skip_serializing_if = "Option::is_none"
7408    )]
7409    pub parent_thread_id: Option<String>,
7410    #[serde(default, skip_serializing_if = "Option::is_none")]
7411    pub path: Option<String>,
7412    #[serde(default)]
7413    pub preview: String,
7414    /// Current configured reasoning effort when loaded, otherwise the latest
7415    /// persisted effort. Null when unset or unavailable. Not per-turn
7416    /// execution telemetry.
7417    #[serde(
7418        rename = "reasoningEffort",
7419        default,
7420        skip_serializing_if = "Option::is_none"
7421    )]
7422    pub reasoning_effort: Option<ReasoningEffort>,
7423    #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7424    pub recency_at: Option<i64>,
7425    #[serde(default, skip_serializing_if = "Option::is_none")]
7426    pub section: Option<ThreadSection>,
7427    #[serde(
7428        rename = "sectionEnteredAt",
7429        default,
7430        skip_serializing_if = "Option::is_none"
7431    )]
7432    pub section_entered_at: Option<i64>,
7433    #[serde(rename = "sessionId", default)]
7434    pub session_id: String,
7435    #[serde(default)]
7436    pub source: Value,
7437    #[serde(default)]
7438    pub status: Value,
7439    #[serde(
7440        rename = "threadSource",
7441        default,
7442        skip_serializing_if = "Option::is_none"
7443    )]
7444    pub thread_source: Option<ThreadSource>,
7445    #[serde(default)]
7446    pub turns: Vec<Turn>,
7447    #[serde(rename = "updatedAt", default)]
7448    pub updated_at: i64,
7449}
7450
7451#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7452pub enum ThreadActiveFlag {
7453    #[serde(rename = "waitingOnApproval")]
7454    WaitingOnApproval,
7455    #[serde(rename = "waitingOnUserInput")]
7456    WaitingOnUserInput,
7457}
7458
7459#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7460#[serde(rename_all = "camelCase")]
7461pub struct ThreadApproveGuardianDeniedActionParams {
7462    #[serde(default)]
7463    pub event: Value,
7464    #[serde(rename = "threadId", default)]
7465    pub thread_id: String,
7466}
7467
7468#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7469#[serde(rename_all = "camelCase")]
7470pub struct ThreadApproveGuardianDeniedActionResponse {
7471    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7472    pub extra: serde_json::Map<String, Value>,
7473}
7474
7475#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7476#[serde(rename_all = "camelCase")]
7477pub struct ThreadArchiveParams {
7478    #[serde(rename = "threadId", default)]
7479    pub thread_id: String,
7480}
7481
7482#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7483#[serde(rename_all = "camelCase")]
7484pub struct ThreadArchiveResponse {
7485    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7486    pub extra: serde_json::Map<String, Value>,
7487}
7488
7489#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7490#[serde(rename_all = "camelCase")]
7491pub struct ThreadArchivedNotification {
7492    #[serde(rename = "threadId", default)]
7493    pub thread_id: String,
7494}
7495
7496/// An independently persisted attachment associated with a thread.
7497#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7498#[serde(rename_all = "camelCase")]
7499pub struct ThreadAttachment {
7500    #[serde(rename = "attachmentType", default)]
7501    pub attachment_type: String,
7502    #[serde(rename = "createdAt", default)]
7503    pub created_at: i64,
7504    #[serde(default)]
7505    pub id: String,
7506    #[serde(rename = "identityKey", default)]
7507    pub identity_key: String,
7508    #[serde(default)]
7509    pub payload: Value,
7510}
7511
7512/// Result of attempting to associate an attachment with a thread.
7513#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7514pub enum ThreadAttachmentAddOutcome {
7515    #[serde(rename = "created")]
7516    Created,
7517    #[serde(rename = "existing")]
7518    Existing,
7519}
7520
7521/// Parameters for creating or locating an attachment on its owning thread.
7522#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7523#[serde(rename_all = "camelCase")]
7524pub struct ThreadAttachmentAddParams {
7525    #[serde(rename = "attachmentType", default)]
7526    pub attachment_type: String,
7527    #[serde(rename = "identityKey", default)]
7528    pub identity_key: String,
7529    #[serde(default)]
7530    pub payload: Value,
7531    #[serde(rename = "threadId", default)]
7532    pub thread_id: String,
7533}
7534
7535/// The created or existing attachment.
7536#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7537#[serde(rename_all = "camelCase")]
7538pub struct ThreadAttachmentAddResponse {
7539    pub attachment: ThreadAttachment,
7540    pub outcome: ThreadAttachmentAddOutcome,
7541}
7542
7543/// Parameters for listing attachments from one thread.
7544#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7545#[serde(rename_all = "camelCase")]
7546pub struct ThreadAttachmentListParams {
7547    #[serde(default, skip_serializing_if = "Option::is_none")]
7548    pub cursor: Option<String>,
7549    #[serde(default, skip_serializing_if = "Option::is_none")]
7550    pub limit: Option<i64>,
7551    #[serde(rename = "threadId", default)]
7552    pub thread_id: String,
7553}
7554
7555/// One page of attachments associated with the requested thread.
7556#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7557#[serde(rename_all = "camelCase")]
7558pub struct ThreadAttachmentListResponse {
7559    #[serde(default)]
7560    pub data: Vec<ThreadAttachment>,
7561    #[serde(
7562        rename = "nextCursor",
7563        default,
7564        skip_serializing_if = "Option::is_none"
7565    )]
7566    pub next_cursor: Option<String>,
7567}
7568
7569/// The persisted attachment change represented by a notification.
7570#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7571pub enum ThreadAttachmentOperation {
7572    #[serde(rename = "created")]
7573    Created,
7574    #[serde(rename = "deleted")]
7575    Deleted,
7576}
7577
7578/// Parameters for deleting an attachment by its stable thread-local identity.
7579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7580#[serde(rename_all = "camelCase")]
7581pub struct ThreadAttachmentRemoveParams {
7582    #[serde(rename = "attachmentType", default)]
7583    pub attachment_type: String,
7584    #[serde(rename = "identityKey", default)]
7585    pub identity_key: String,
7586    #[serde(rename = "threadId", default)]
7587    pub thread_id: String,
7588}
7589
7590/// Successful deletion does not return additional attachment data.
7591#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7592#[serde(rename_all = "camelCase")]
7593pub struct ThreadAttachmentRemoveResponse {
7594    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7595    pub extra: serde_json::Map<String, Value>,
7596}
7597
7598/// Notification published after a thread attachment is created or deleted.
7599#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7600#[serde(rename_all = "camelCase")]
7601pub struct ThreadAttachmentUpdatedNotification {
7602    #[serde(rename = "attachmentId", default)]
7603    pub attachment_id: String,
7604    #[serde(rename = "attachmentType", default)]
7605    pub attachment_type: String,
7606    #[serde(rename = "identityKey", default)]
7607    pub identity_key: String,
7608    pub operation: ThreadAttachmentOperation,
7609    #[serde(rename = "threadId", default)]
7610    pub thread_id: String,
7611}
7612
7613#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7614#[serde(rename_all = "camelCase")]
7615pub struct ThreadClosedNotification {
7616    #[serde(rename = "threadId", default)]
7617    pub thread_id: String,
7618}
7619
7620#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7621#[serde(rename_all = "camelCase")]
7622pub struct ThreadCompactStartParams {
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 ThreadCompactStartResponse {
7630    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7631    pub extra: serde_json::Map<String, Value>,
7632}
7633
7634#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7635#[serde(rename_all = "camelCase")]
7636pub struct ThreadDeleteParams {
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 ThreadDeleteResponse {
7644    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7645    pub extra: serde_json::Map<String, Value>,
7646}
7647
7648#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7649#[serde(rename_all = "camelCase")]
7650pub struct ThreadDeletedNotification {
7651    #[serde(rename = "threadId", default)]
7652    pub thread_id: String,
7653}
7654
7655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7656#[serde(rename_all = "camelCase")]
7657pub struct ThreadForkParams {
7658    #[serde(
7659        rename = "approvalPolicy",
7660        default,
7661        skip_serializing_if = "Option::is_none"
7662    )]
7663    pub approval_policy: Option<AskForApproval>,
7664    #[serde(
7665        rename = "approvalsReviewer",
7666        default,
7667        skip_serializing_if = "Option::is_none"
7668    )]
7669    pub approvals_reviewer: Option<ApprovalsReviewer>,
7670    #[serde(
7671        rename = "baseInstructions",
7672        default,
7673        skip_serializing_if = "Option::is_none"
7674    )]
7675    pub base_instructions: Option<String>,
7676    #[serde(default, skip_serializing_if = "Option::is_none")]
7677    pub config: Option<Value>,
7678    #[serde(default, skip_serializing_if = "Option::is_none")]
7679    pub cwd: Option<String>,
7680    #[serde(
7681        rename = "developerInstructions",
7682        default,
7683        skip_serializing_if = "Option::is_none"
7684    )]
7685    pub developer_instructions: Option<String>,
7686    #[serde(default, skip_serializing_if = "Option::is_none")]
7687    pub ephemeral: Option<bool>,
7688    #[serde(
7689        rename = "excludeTurns",
7690        default,
7691        skip_serializing_if = "Option::is_none"
7692    )]
7693    pub exclude_turns: Option<bool>,
7694    #[serde(
7695        rename = "lastTurnId",
7696        default,
7697        skip_serializing_if = "Option::is_none"
7698    )]
7699    pub last_turn_id: Option<String>,
7700    #[serde(default, skip_serializing_if = "Option::is_none")]
7701    pub model: Option<String>,
7702    #[serde(
7703        rename = "modelProvider",
7704        default,
7705        skip_serializing_if = "Option::is_none"
7706    )]
7707    pub model_provider: Option<String>,
7708    #[serde(default, skip_serializing_if = "Option::is_none")]
7709    pub sandbox: Option<SandboxMode>,
7710    #[serde(
7711        rename = "serviceTier",
7712        default,
7713        skip_serializing_if = "Option::is_none"
7714    )]
7715    pub service_tier: Option<String>,
7716    #[serde(rename = "threadId", default)]
7717    pub thread_id: String,
7718    #[serde(
7719        rename = "threadSource",
7720        default,
7721        skip_serializing_if = "Option::is_none"
7722    )]
7723    pub thread_source: Option<ThreadSource>,
7724}
7725
7726#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7727#[serde(rename_all = "camelCase")]
7728pub struct ThreadForkResponse {
7729    #[serde(rename = "approvalPolicy")]
7730    pub approval_policy: AskForApproval,
7731    #[serde(rename = "approvalsReviewer", default)]
7732    pub approvals_reviewer: Value,
7733    #[serde()]
7734    pub cwd: AbsolutePathBuf,
7735    /// Saved list of disabled plugin IDs. Does not yet filter plugin
7736    /// capabilities.
7737    #[serde(rename = "disabledPluginIds", default)]
7738    pub disabled_plugin_ids: Vec<String>,
7739    #[serde(
7740        rename = "instructionSources",
7741        default,
7742        skip_serializing_if = "Option::is_none"
7743    )]
7744    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
7745    #[serde(default)]
7746    pub model: String,
7747    #[serde(rename = "modelProvider", default)]
7748    pub model_provider: String,
7749    #[serde(
7750        rename = "reasoningEffort",
7751        default,
7752        skip_serializing_if = "Option::is_none"
7753    )]
7754    pub reasoning_effort: Option<ReasoningEffort>,
7755    #[serde(default)]
7756    pub sandbox: Value,
7757    #[serde(
7758        rename = "serviceTier",
7759        default,
7760        skip_serializing_if = "Option::is_none"
7761    )]
7762    pub service_tier: Option<String>,
7763    #[serde()]
7764    pub thread: Thread,
7765}
7766
7767#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7768#[serde(rename_all = "camelCase")]
7769pub struct ThreadGoal {
7770    #[serde(rename = "createdAt", default)]
7771    pub created_at: i64,
7772    #[serde(default)]
7773    pub objective: String,
7774    #[serde()]
7775    pub status: ThreadGoalStatus,
7776    #[serde(rename = "threadId", default)]
7777    pub thread_id: String,
7778    #[serde(rename = "timeUsedSeconds", default)]
7779    pub time_used_seconds: i64,
7780    #[serde(
7781        rename = "tokenBudget",
7782        default,
7783        skip_serializing_if = "Option::is_none"
7784    )]
7785    pub token_budget: Option<i64>,
7786    #[serde(rename = "tokensUsed", default)]
7787    pub tokens_used: i64,
7788    #[serde(rename = "updatedAt", default)]
7789    pub updated_at: i64,
7790}
7791
7792#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7793#[serde(rename_all = "camelCase")]
7794pub struct ThreadGoalClearParams {
7795    #[serde(rename = "threadId", default)]
7796    pub thread_id: String,
7797}
7798
7799#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7800#[serde(rename_all = "camelCase")]
7801pub struct ThreadGoalClearResponse {
7802    #[serde(default)]
7803    pub cleared: bool,
7804}
7805
7806#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7807#[serde(rename_all = "camelCase")]
7808pub struct ThreadGoalClearedNotification {
7809    #[serde(rename = "threadId", default)]
7810    pub thread_id: String,
7811}
7812
7813#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7814#[serde(rename_all = "camelCase")]
7815pub struct ThreadGoalGetParams {
7816    #[serde(rename = "threadId", default)]
7817    pub thread_id: String,
7818}
7819
7820#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7821#[serde(rename_all = "camelCase")]
7822pub struct ThreadGoalGetResponse {
7823    #[serde(default, skip_serializing_if = "Option::is_none")]
7824    pub goal: Option<ThreadGoal>,
7825}
7826
7827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7828#[serde(rename_all = "camelCase")]
7829pub struct ThreadGoalSetParams {
7830    #[serde(default, skip_serializing_if = "Option::is_none")]
7831    pub objective: Option<String>,
7832    #[serde(default, skip_serializing_if = "Option::is_none")]
7833    pub status: Option<ThreadGoalStatus>,
7834    #[serde(rename = "threadId", default)]
7835    pub thread_id: String,
7836    #[serde(
7837        rename = "tokenBudget",
7838        default,
7839        skip_serializing_if = "Option::is_none"
7840    )]
7841    pub token_budget: Option<i64>,
7842}
7843
7844#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7845#[serde(rename_all = "camelCase")]
7846pub struct ThreadGoalSetResponse {
7847    #[serde()]
7848    pub goal: ThreadGoal,
7849}
7850
7851#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7852pub enum ThreadGoalStatus {
7853    #[serde(rename = "active")]
7854    Active,
7855    #[serde(rename = "paused")]
7856    Paused,
7857    #[serde(rename = "blocked")]
7858    Blocked,
7859    #[serde(rename = "usageLimited")]
7860    UsageLimited,
7861    #[serde(rename = "budgetLimited")]
7862    BudgetLimited,
7863    #[serde(rename = "complete")]
7864    Complete,
7865}
7866
7867#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7868#[serde(rename_all = "camelCase")]
7869pub struct ThreadGoalUpdatedNotification {
7870    #[serde()]
7871    pub goal: ThreadGoal,
7872    #[serde(rename = "threadId", default)]
7873    pub thread_id: String,
7874    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
7875    pub turn_id: Option<String>,
7876}
7877
7878#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
7879#[serde(transparent)]
7880pub struct ThreadId(pub String);
7881
7882#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7883#[serde(rename_all = "camelCase")]
7884pub struct ThreadInjectItemsParams {
7885    #[serde(default)]
7886    pub items: Vec<Value>,
7887    #[serde(rename = "threadId", default)]
7888    pub thread_id: String,
7889}
7890
7891#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7892#[serde(rename_all = "camelCase")]
7893pub struct ThreadInjectItemsResponse {
7894    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7895    pub extra: serde_json::Map<String, Value>,
7896}
7897
7898#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7899#[serde(tag = "type", rename_all = "camelCase")]
7900pub enum ThreadItem {
7901    #[serde(rename = "userMessage")]
7902    UserMessage {
7903        #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
7904        client_id: Option<String>,
7905        content: Vec<UserInput>,
7906        id: String,
7907    },
7908    #[serde(rename = "hookPrompt")]
7909    HookPrompt {
7910        fragments: Vec<HookPromptFragment>,
7911        id: String,
7912    },
7913    #[serde(rename = "agentMessage")]
7914    AgentMessage {
7915        #[serde(default, skip_serializing_if = "Option::is_none")]
7916        delivery: Option<AgentMessageDelivery>,
7917        id: String,
7918        #[serde(
7919            rename = "memoryCitation",
7920            default,
7921            skip_serializing_if = "Option::is_none"
7922        )]
7923        memory_citation: Option<MemoryCitation>,
7924        #[serde(default, skip_serializing_if = "Option::is_none")]
7925        phase: Option<MessagePhase>,
7926        #[serde(default, skip_serializing_if = "Option::is_none")]
7927        questions: Option<Vec<AsyncUserInputQuestion>>,
7928        text: String,
7929    },
7930    Plan {
7931        id: String,
7932        text: String,
7933    },
7934    Reasoning {
7935        #[serde(default, skip_serializing_if = "Option::is_none")]
7936        content: Option<Vec<String>>,
7937        id: String,
7938        #[serde(default, skip_serializing_if = "Option::is_none")]
7939        summary: Option<Vec<String>>,
7940    },
7941    #[serde(rename = "commandExecution")]
7942    CommandExecution {
7943        #[serde(
7944            rename = "aggregatedOutput",
7945            default,
7946            skip_serializing_if = "Option::is_none"
7947        )]
7948        aggregated_output: Option<String>,
7949        command: String,
7950        #[serde(rename = "commandActions")]
7951        command_actions: Vec<CommandAction>,
7952        cwd: Value,
7953        #[serde(
7954            rename = "durationMs",
7955            default,
7956            skip_serializing_if = "Option::is_none"
7957        )]
7958        duration_ms: Option<i64>,
7959        #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
7960        exit_code: Option<i64>,
7961        id: String,
7962        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7963        plugin_id: Option<String>,
7964        #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
7965        process_id: Option<String>,
7966        #[serde(
7967            rename = "scriptPath",
7968            default,
7969            skip_serializing_if = "Option::is_none"
7970        )]
7971        script_path: Option<String>,
7972        #[serde(default, skip_serializing_if = "Option::is_none")]
7973        source: Option<Value>,
7974        status: CommandExecutionStatus,
7975    },
7976    #[serde(rename = "fileChange")]
7977    FileChange {
7978        changes: Vec<FileUpdateChange>,
7979        id: String,
7980        status: PatchApplyStatus,
7981    },
7982    #[serde(rename = "mcpToolCall")]
7983    McpToolCall {
7984        #[serde(
7985            rename = "appContext",
7986            default,
7987            skip_serializing_if = "Option::is_none"
7988        )]
7989        app_context: Option<McpToolCallAppContext>,
7990        arguments: Value,
7991        #[serde(
7992            rename = "durationMs",
7993            default,
7994            skip_serializing_if = "Option::is_none"
7995        )]
7996        duration_ms: Option<i64>,
7997        #[serde(default, skip_serializing_if = "Option::is_none")]
7998        error: Option<McpToolCallError>,
7999        id: String,
8000        /// Legacy compatibility field; prefer `mcp_app_ui.resource_uri` when
8001        /// available.
8002        #[serde(
8003            rename = "mcpAppResourceUri",
8004            default,
8005            skip_serializing_if = "Option::is_none"
8006        )]
8007        mcp_app_resource_uri: Option<String>,
8008        /// Presentation captured from the invoked descriptor; absent in
8009        /// older history.
8010        #[serde(rename = "mcpAppUi", default, skip_serializing_if = "Option::is_none")]
8011        mcp_app_ui: Option<McpAppUi>,
8012        #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8013        plugin_id: Option<String>,
8014        #[serde(
8015            rename = "readOnlyHint",
8016            default,
8017            skip_serializing_if = "Option::is_none"
8018        )]
8019        read_only_hint: Option<bool>,
8020        #[serde(default, skip_serializing_if = "Option::is_none")]
8021        result: Option<McpToolCallResult>,
8022        server: String,
8023        status: McpToolCallStatus,
8024        tool: String,
8025    },
8026    #[serde(rename = "dynamicToolCall")]
8027    DynamicToolCall {
8028        arguments: Value,
8029        #[serde(
8030            rename = "contentItems",
8031            default,
8032            skip_serializing_if = "Option::is_none"
8033        )]
8034        content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
8035        #[serde(
8036            rename = "durationMs",
8037            default,
8038            skip_serializing_if = "Option::is_none"
8039        )]
8040        duration_ms: Option<i64>,
8041        id: String,
8042        #[serde(default, skip_serializing_if = "Option::is_none")]
8043        namespace: Option<String>,
8044        status: DynamicToolCallStatus,
8045        #[serde(default, skip_serializing_if = "Option::is_none")]
8046        success: Option<bool>,
8047        tool: String,
8048    },
8049    #[serde(rename = "collabAgentToolCall")]
8050    CollabAgentToolCall {
8051        #[serde(rename = "agentsStates")]
8052        agents_states: std::collections::BTreeMap<String, CollabAgentState>,
8053        id: String,
8054        #[serde(default, skip_serializing_if = "Option::is_none")]
8055        model: Option<String>,
8056        #[serde(default, skip_serializing_if = "Option::is_none")]
8057        prompt: Option<String>,
8058        #[serde(
8059            rename = "reasoningEffort",
8060            default,
8061            skip_serializing_if = "Option::is_none"
8062        )]
8063        reasoning_effort: Option<ReasoningEffort>,
8064        #[serde(rename = "receiverThreadIds")]
8065        receiver_thread_ids: Vec<String>,
8066        #[serde(rename = "senderThreadId")]
8067        sender_thread_id: String,
8068        status: Value,
8069        tool: Value,
8070    },
8071    #[serde(rename = "subAgentActivity")]
8072    SubAgentActivity {
8073        #[serde(rename = "agentPath")]
8074        agent_path: String,
8075        #[serde(rename = "agentThreadId")]
8076        agent_thread_id: String,
8077        id: String,
8078        kind: SubAgentActivityKind,
8079    },
8080    #[serde(rename = "webSearch")]
8081    WebSearch {
8082        #[serde(default, skip_serializing_if = "Option::is_none")]
8083        action: Option<WebSearchAction>,
8084        id: String,
8085        query: String,
8086        #[serde(default, skip_serializing_if = "Option::is_none")]
8087        results: Option<Vec<Value>>,
8088    },
8089    #[serde(rename = "imageView")]
8090    ImageView {
8091        id: String,
8092        path: LegacyAppPathString,
8093    },
8094    Sleep {
8095        #[serde(rename = "durationMs")]
8096        duration_ms: i64,
8097        id: String,
8098    },
8099    #[serde(rename = "imageGeneration")]
8100    ImageGeneration {
8101        #[serde(default, skip_serializing_if = "Option::is_none")]
8102        failure: Option<ImageGenerationFailure>,
8103        id: String,
8104        result: String,
8105        #[serde(
8106            rename = "revisedPrompt",
8107            default,
8108            skip_serializing_if = "Option::is_none"
8109        )]
8110        revised_prompt: Option<String>,
8111        #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
8112        saved_path: Option<AbsolutePathBuf>,
8113        status: String,
8114        #[serde(
8115            rename = "transparentBackground",
8116            default,
8117            skip_serializing_if = "Option::is_none"
8118        )]
8119        transparent_background: Option<bool>,
8120    },
8121    #[serde(rename = "enteredReviewMode")]
8122    EnteredReviewMode {
8123        id: String,
8124        review: String,
8125    },
8126    #[serde(rename = "exitedReviewMode")]
8127    ExitedReviewMode {
8128        id: String,
8129        review: String,
8130    },
8131    #[serde(rename = "contextCompaction")]
8132    ContextCompaction {
8133        id: String,
8134    },
8135    #[serde(rename = "functionCallOutput")]
8136    FunctionCallOutput {
8137        id: String,
8138        name: String,
8139        #[serde(default, skip_serializing_if = "Option::is_none")]
8140        namespace: Option<String>,
8141        output: FunctionCallOutputBody,
8142    },
8143}
8144
8145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8146#[serde(untagged)]
8147pub enum ThreadListCwdFilter {
8148    Variant0(String),
8149    Variant1(Vec<String>),
8150}
8151
8152#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8153#[serde(rename_all = "camelCase")]
8154pub struct ThreadListParams {
8155    #[serde(default, skip_serializing_if = "Option::is_none")]
8156    pub archived: Option<bool>,
8157    #[serde(default, skip_serializing_if = "Option::is_none")]
8158    pub cursor: Option<String>,
8159    #[serde(default, skip_serializing_if = "Option::is_none")]
8160    pub cwd: Option<ThreadListCwdFilter>,
8161    #[serde(default, skip_serializing_if = "Option::is_none")]
8162    pub limit: Option<i64>,
8163    #[serde(
8164        rename = "modelProviders",
8165        default,
8166        skip_serializing_if = "Option::is_none"
8167    )]
8168    pub model_providers: Option<Vec<String>>,
8169    /// Optional originator allowlist, matching any supplied value exactly.
8170    /// Supported by hosted backends only; the local app-server rejects a
8171    /// nonempty list. Omitted or empty lists leave originators unrestricted.
8172    #[serde(default, skip_serializing_if = "Option::is_none")]
8173    pub originators: Option<Vec<String>>,
8174    #[serde(
8175        rename = "searchTerm",
8176        default,
8177        skip_serializing_if = "Option::is_none"
8178    )]
8179    pub search_term: Option<String>,
8180    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8181    pub section_id: Option<String>,
8182    #[serde(
8183        rename = "sortDirection",
8184        default,
8185        skip_serializing_if = "Option::is_none"
8186    )]
8187    pub sort_direction: Option<SortDirection>,
8188    #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
8189    pub sort_key: Option<ThreadSortKey>,
8190    #[serde(
8191        rename = "sourceKinds",
8192        default,
8193        skip_serializing_if = "Option::is_none"
8194    )]
8195    pub source_kinds: Option<Vec<ThreadSourceKind>>,
8196    #[serde(
8197        rename = "useStateDbOnly",
8198        default,
8199        skip_serializing_if = "Option::is_none"
8200    )]
8201    pub use_state_db_only: Option<bool>,
8202}
8203
8204#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8205#[serde(rename_all = "camelCase")]
8206pub struct ThreadListResponse {
8207    #[serde(
8208        rename = "backwardsCursor",
8209        default,
8210        skip_serializing_if = "Option::is_none"
8211    )]
8212    pub backwards_cursor: Option<String>,
8213    #[serde(default)]
8214    pub data: Vec<Thread>,
8215    #[serde(
8216        rename = "nextCursor",
8217        default,
8218        skip_serializing_if = "Option::is_none"
8219    )]
8220    pub next_cursor: Option<String>,
8221}
8222
8223#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8224#[serde(rename_all = "camelCase")]
8225pub struct ThreadLoadedListParams {
8226    #[serde(default, skip_serializing_if = "Option::is_none")]
8227    pub cursor: Option<String>,
8228    #[serde(default, skip_serializing_if = "Option::is_none")]
8229    pub limit: Option<i64>,
8230}
8231
8232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8233#[serde(rename_all = "camelCase")]
8234pub struct ThreadLoadedListResponse {
8235    #[serde(default)]
8236    pub data: Vec<String>,
8237    #[serde(
8238        rename = "nextCursor",
8239        default,
8240        skip_serializing_if = "Option::is_none"
8241    )]
8242    pub next_cursor: Option<String>,
8243}
8244
8245#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8246#[serde(rename_all = "camelCase")]
8247pub struct ThreadMetadataGitInfoUpdateParams {
8248    #[serde(default, skip_serializing_if = "Option::is_none")]
8249    pub branch: Option<String>,
8250    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
8251    pub origin_url: Option<String>,
8252    #[serde(default, skip_serializing_if = "Option::is_none")]
8253    pub sha: Option<String>,
8254}
8255
8256#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8257#[serde(rename_all = "camelCase")]
8258pub struct ThreadMetadataUpdateParams {
8259    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
8260    pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
8261    #[serde(rename = "threadId", default)]
8262    pub thread_id: String,
8263}
8264
8265#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8266#[serde(rename_all = "camelCase")]
8267pub struct ThreadMetadataUpdateResponse {
8268    #[serde()]
8269    pub thread: Thread,
8270}
8271
8272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8273#[serde(rename_all = "camelCase")]
8274pub struct ThreadNameUpdatedNotification {
8275    #[serde(rename = "threadId", default)]
8276    pub thread_id: String,
8277    #[serde(
8278        rename = "threadName",
8279        default,
8280        skip_serializing_if = "Option::is_none"
8281    )]
8282    pub thread_name: Option<String>,
8283}
8284
8285#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8286#[serde(rename_all = "camelCase")]
8287pub struct ThreadReadParams {
8288    #[serde(
8289        rename = "includeTurns",
8290        default,
8291        skip_serializing_if = "Option::is_none"
8292    )]
8293    pub include_turns: Option<bool>,
8294    #[serde(rename = "threadId", default)]
8295    pub thread_id: String,
8296}
8297
8298#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8299#[serde(rename_all = "camelCase")]
8300pub struct ThreadReadResponse {
8301    #[serde()]
8302    pub thread: Thread,
8303}
8304
8305#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8306#[serde(rename_all = "camelCase")]
8307pub struct ThreadRealtimeAudioChunk {
8308    #[serde(default)]
8309    pub data: String,
8310    #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
8311    pub item_id: Option<String>,
8312    #[serde(rename = "numChannels", default)]
8313    pub num_channels: i64,
8314    #[serde(rename = "sampleRate", default)]
8315    pub sample_rate: i64,
8316    #[serde(
8317        rename = "samplesPerChannel",
8318        default,
8319        skip_serializing_if = "Option::is_none"
8320    )]
8321    pub samples_per_channel: Option<i64>,
8322}
8323
8324#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8325#[serde(rename_all = "camelCase")]
8326pub struct ThreadRealtimeClosedNotification {
8327    #[serde(default, skip_serializing_if = "Option::is_none")]
8328    pub reason: Option<String>,
8329    #[serde(rename = "threadId", default)]
8330    pub thread_id: String,
8331}
8332
8333#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8334#[serde(rename_all = "camelCase")]
8335pub struct ThreadRealtimeErrorNotification {
8336    #[serde(default)]
8337    pub message: String,
8338    #[serde(rename = "threadId", default)]
8339    pub thread_id: String,
8340}
8341
8342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8343#[serde(rename_all = "camelCase")]
8344pub struct ThreadRealtimeItemAddedNotification {
8345    #[serde(default)]
8346    pub item: Value,
8347    #[serde(rename = "threadId", default)]
8348    pub thread_id: String,
8349}
8350
8351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8352#[serde(rename_all = "camelCase")]
8353pub struct ThreadRealtimeOutputAudioDeltaNotification {
8354    #[serde()]
8355    pub audio: ThreadRealtimeAudioChunk,
8356    #[serde(rename = "threadId", default)]
8357    pub thread_id: String,
8358}
8359
8360#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8361#[serde(rename_all = "camelCase")]
8362pub struct ThreadRealtimeSdpNotification {
8363    #[serde(default)]
8364    pub sdp: String,
8365    #[serde(rename = "threadId", default)]
8366    pub thread_id: String,
8367}
8368
8369#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8370#[serde(rename_all = "camelCase")]
8371pub struct ThreadRealtimeStartedNotification {
8372    #[serde(
8373        rename = "realtimeSessionId",
8374        default,
8375        skip_serializing_if = "Option::is_none"
8376    )]
8377    pub realtime_session_id: Option<String>,
8378    #[serde(rename = "threadId", default)]
8379    pub thread_id: String,
8380    #[serde()]
8381    pub version: RealtimeConversationVersion,
8382}
8383
8384#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8385#[serde(rename_all = "camelCase")]
8386pub struct ThreadRealtimeTranscriptDeltaNotification {
8387    #[serde(default)]
8388    pub delta: String,
8389    #[serde(default)]
8390    pub role: String,
8391    #[serde(rename = "threadId", default)]
8392    pub thread_id: String,
8393}
8394
8395#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8396#[serde(rename_all = "camelCase")]
8397pub struct ThreadRealtimeTranscriptDoneNotification {
8398    #[serde(default)]
8399    pub role: String,
8400    #[serde(default)]
8401    pub text: String,
8402    #[serde(rename = "threadId", default)]
8403    pub thread_id: String,
8404}
8405
8406#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8407#[serde(rename_all = "camelCase")]
8408pub struct ThreadResumeParams {
8409    #[serde(
8410        rename = "approvalPolicy",
8411        default,
8412        skip_serializing_if = "Option::is_none"
8413    )]
8414    pub approval_policy: Option<AskForApproval>,
8415    #[serde(
8416        rename = "approvalsReviewer",
8417        default,
8418        skip_serializing_if = "Option::is_none"
8419    )]
8420    pub approvals_reviewer: Option<ApprovalsReviewer>,
8421    #[serde(
8422        rename = "baseInstructions",
8423        default,
8424        skip_serializing_if = "Option::is_none"
8425    )]
8426    pub base_instructions: Option<String>,
8427    #[serde(default, skip_serializing_if = "Option::is_none")]
8428    pub config: Option<Value>,
8429    #[serde(default, skip_serializing_if = "Option::is_none")]
8430    pub cwd: Option<String>,
8431    #[serde(
8432        rename = "developerInstructions",
8433        default,
8434        skip_serializing_if = "Option::is_none"
8435    )]
8436    pub developer_instructions: Option<String>,
8437    #[serde(default, skip_serializing_if = "Option::is_none")]
8438    pub model: Option<String>,
8439    #[serde(
8440        rename = "modelProvider",
8441        default,
8442        skip_serializing_if = "Option::is_none"
8443    )]
8444    pub model_provider: Option<String>,
8445    #[serde(default, skip_serializing_if = "Option::is_none")]
8446    pub personality: Option<Personality>,
8447    #[serde(default, skip_serializing_if = "Option::is_none")]
8448    pub sandbox: Option<SandboxMode>,
8449    #[serde(
8450        rename = "serviceTier",
8451        default,
8452        skip_serializing_if = "Option::is_none"
8453    )]
8454    pub service_tier: Option<String>,
8455    #[serde(rename = "threadId", default)]
8456    pub thread_id: String,
8457    #[serde(
8458        rename = "excludeTurns",
8459        default,
8460        skip_serializing_if = "Option::is_none"
8461    )]
8462    pub exclude_turns: Option<bool>,
8463}
8464
8465#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8466#[serde(rename_all = "camelCase")]
8467pub struct ThreadResumeResponse {
8468    #[serde(rename = "approvalPolicy")]
8469    pub approval_policy: AskForApproval,
8470    #[serde(rename = "approvalsReviewer", default)]
8471    pub approvals_reviewer: Value,
8472    /// Effective collaboration mode. Absent when resuming from an older
8473    /// server.
8474    #[serde(
8475        rename = "collaborationMode",
8476        default,
8477        skip_serializing_if = "Option::is_none"
8478    )]
8479    pub collaboration_mode: Option<CollaborationMode>,
8480    #[serde()]
8481    pub cwd: AbsolutePathBuf,
8482    /// Saved list of disabled plugin IDs. Does not yet filter plugin
8483    /// capabilities.
8484    #[serde(rename = "disabledPluginIds", default)]
8485    pub disabled_plugin_ids: Vec<String>,
8486    #[serde(
8487        rename = "instructionSources",
8488        default,
8489        skip_serializing_if = "Option::is_none"
8490    )]
8491    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8492    /// Cursor for hydrating paginated items backwards via `thread/items/list`
8493    /// with `sortDirection: "desc"` (0.148 upstream).
8494    #[serde(
8495        rename = "itemsBackwardsCursor",
8496        default,
8497        skip_serializing_if = "Option::is_none"
8498    )]
8499    pub items_backwards_cursor: Option<String>,
8500    #[serde(default)]
8501    pub model: String,
8502    #[serde(rename = "modelProvider", default)]
8503    pub model_provider: String,
8504    #[serde(
8505        rename = "reasoningEffort",
8506        default,
8507        skip_serializing_if = "Option::is_none"
8508    )]
8509    pub reasoning_effort: Option<ReasoningEffort>,
8510    #[serde(default)]
8511    pub sandbox: Value,
8512    #[serde(
8513        rename = "serviceTier",
8514        default,
8515        skip_serializing_if = "Option::is_none"
8516    )]
8517    pub service_tier: Option<String>,
8518    #[serde()]
8519    pub thread: Thread,
8520    /// Cursor for hydrating paginated turns backwards via `thread/turns/list`
8521    /// with `sortDirection: "desc"` (0.148 upstream).
8522    #[serde(
8523        rename = "turnsBackwardsCursor",
8524        default,
8525        skip_serializing_if = "Option::is_none"
8526    )]
8527    pub turns_backwards_cursor: Option<String>,
8528}
8529
8530/// Persisted thread history contract (0.148 upstream).
8531#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8532pub enum ThreadHistoryMode {
8533    #[serde(rename = "legacy")]
8534    Legacy,
8535    #[serde(rename = "paginated")]
8536    Paginated,
8537}
8538
8539/// One item plus the turn that contains it, as returned by
8540/// `thread/items/list` (0.148 upstream).
8541#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8542#[serde(rename_all = "camelCase")]
8543pub struct ThreadItemEntry {
8544    /// Unix timestamp (milliseconds) when the item completed, if recorded by
8545    /// the producer.
8546    #[serde(
8547        rename = "completedAtMs",
8548        default,
8549        skip_serializing_if = "Option::is_none"
8550    )]
8551    pub completed_at_ms: Option<i64>,
8552    #[serde()]
8553    pub item: ThreadItem,
8554    /// Unix timestamp (milliseconds) when the item started, if recorded by
8555    /// the producer.
8556    #[serde(
8557        rename = "startedAtMs",
8558        default,
8559        skip_serializing_if = "Option::is_none"
8560    )]
8561    pub started_at_ms: Option<i64>,
8562    #[serde(rename = "turnId", default)]
8563    pub turn_id: String,
8564}
8565
8566/// Params for `thread/items/list` — paginated item hydration (0.148 upstream).
8567#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8568#[serde(rename_all = "camelCase")]
8569pub struct ThreadItemsListParams {
8570    #[serde(default, skip_serializing_if = "Option::is_none")]
8571    pub cursor: Option<String>,
8572    #[serde(default, skip_serializing_if = "Option::is_none")]
8573    pub limit: Option<u32>,
8574    #[serde(
8575        rename = "sortDirection",
8576        default,
8577        skip_serializing_if = "Option::is_none"
8578    )]
8579    pub sort_direction: Option<SortDirection>,
8580    #[serde(rename = "threadId", default)]
8581    pub thread_id: String,
8582    /// Optional turn id filter; omitted returns items across the thread.
8583    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8584    pub turn_id: Option<String>,
8585}
8586
8587/// Response to `thread/items/list` (0.148 upstream).
8588#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8589#[serde(rename_all = "camelCase")]
8590pub struct ThreadItemsListResponse {
8591    #[serde(
8592        rename = "backwardsCursor",
8593        default,
8594        skip_serializing_if = "Option::is_none"
8595    )]
8596    pub backwards_cursor: Option<String>,
8597    #[serde(default)]
8598    pub data: Vec<ThreadItemEntry>,
8599    #[serde(
8600        rename = "nextCursor",
8601        default,
8602        skip_serializing_if = "Option::is_none"
8603    )]
8604    pub next_cursor: Option<String>,
8605}
8606
8607/// EXPERIMENTAL upstream — a thread-scoped realtime item in the canonical
8608/// timeline (0.148). Top-level identity fields are camelCase on the wire
8609/// while variant payload fields are snake_case; mirrored exactly.
8610#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8611pub struct ThreadRealtimeItem {
8612    #[serde(default)]
8613    pub id: String,
8614    #[serde(rename = "realtimeSessionId", default)]
8615    pub realtime_session_id: String,
8616    #[serde(flatten)]
8617    pub detail: ThreadRealtimeItemDetail,
8618}
8619
8620/// The `type`-tagged payload of a [`ThreadRealtimeItem`].
8621#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8622#[serde(tag = "type", rename_all = "camelCase")]
8623pub enum ThreadRealtimeItemDetail {
8624    #[serde(rename = "realtimeSessionStarted")]
8625    RealtimeSessionStarted,
8626    #[serde(rename = "transcriptSegment")]
8627    TranscriptSegment {
8628        role: ThreadRealtimeTranscriptRole,
8629        text: String,
8630    },
8631    #[serde(rename = "bemItemPromoted")]
8632    BemItemPromoted {
8633        item_id: String,
8634        presentation: ThreadRealtimeBemItemPresentation,
8635        turn_id: String,
8636    },
8637    #[serde(rename = "realtimeSessionClosed")]
8638    RealtimeSessionClosed {
8639        outcome: ThreadRealtimeSessionOutcome,
8640    },
8641}
8642
8643/// EXPERIMENTAL upstream — how an existing agent item appears in a realtime
8644/// conversation (0.148).
8645#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8646#[serde(tag = "type", rename_all = "camelCase")]
8647pub enum ThreadRealtimeBemItemPresentation {
8648    #[serde(rename = "wholeItem")]
8649    WholeItem,
8650    #[serde(rename = "inlineMarkdown")]
8651    InlineMarkdown,
8652    #[serde(rename = "inlineVisualization")]
8653    InlineVisualization { index: u32 },
8654}
8655
8656/// EXPERIMENTAL upstream — `thread/realtime/item/started` params (0.148).
8657#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8658#[serde(rename_all = "camelCase")]
8659pub struct ThreadRealtimeItemStartedNotification {
8660    #[serde()]
8661    pub item: ThreadRealtimeItem,
8662    #[serde(rename = "threadId", default)]
8663    pub thread_id: String,
8664}
8665
8666/// EXPERIMENTAL upstream — `thread/realtime/item/completed` params (0.148).
8667#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8668#[serde(rename_all = "camelCase")]
8669pub struct ThreadRealtimeItemCompletedNotification {
8670    #[serde()]
8671    pub item: ThreadRealtimeItem,
8672    #[serde(rename = "threadId", default)]
8673    pub thread_id: String,
8674}
8675
8676/// EXPERIMENTAL upstream — `thread/realtime/item/transcript/delta` params:
8677/// text appended to an active realtime transcript item (0.148).
8678#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8679#[serde(rename_all = "camelCase")]
8680pub struct ThreadRealtimeItemTranscriptDeltaNotification {
8681    #[serde(default)]
8682    pub delta: String,
8683    #[serde(rename = "itemId", default)]
8684    pub item_id: String,
8685    #[serde(rename = "threadId", default)]
8686    pub thread_id: String,
8687}
8688
8689/// EXPERIMENTAL upstream — outcome of a closed realtime session (0.148).
8690#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8691pub enum ThreadRealtimeSessionOutcome {
8692    #[serde(rename = "ended")]
8693    Ended,
8694    #[serde(rename = "failed")]
8695    Failed,
8696}
8697
8698/// EXPERIMENTAL upstream — speaker role in a realtime transcript (0.148).
8699#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8700pub enum ThreadRealtimeTranscriptRole {
8701    #[serde(rename = "user")]
8702    User,
8703    #[serde(rename = "assistant")]
8704    Assistant,
8705}
8706
8707/// Params for `thread/revert` — replace a paginated thread's durable history
8708/// with the prefix before one turn; local file changes are untouched
8709/// (0.148 upstream).
8710#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8711#[serde(rename_all = "camelCase")]
8712pub struct ThreadRevertParams {
8713    /// Turn excluded from the replacement history, with every later turn.
8714    #[serde(rename = "beforeTurnId", default)]
8715    pub before_turn_id: String,
8716    #[serde(rename = "threadId", default)]
8717    pub thread_id: String,
8718}
8719
8720/// Response to `thread/revert` (0.148 upstream). `thread.turns` is always
8721/// empty; retained history hydrates through `thread/turns/list`.
8722#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8723#[serde(rename_all = "camelCase")]
8724pub struct ThreadRevertResponse {
8725    #[serde(
8726        rename = "itemsBackwardsCursor",
8727        default,
8728        skip_serializing_if = "Option::is_none"
8729    )]
8730    pub items_backwards_cursor: Option<String>,
8731    #[serde()]
8732    pub thread: Thread,
8733    #[serde(
8734        rename = "turnsBackwardsCursor",
8735        default,
8736        skip_serializing_if = "Option::is_none"
8737    )]
8738    pub turns_backwards_cursor: Option<String>,
8739}
8740
8741#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8742#[serde(rename_all = "camelCase")]
8743pub struct ThreadSection {
8744    #[serde(default, skip_serializing_if = "Option::is_none")]
8745    pub appearance: Option<ThreadSectionAppearance>,
8746    #[serde(default)]
8747    pub id: String,
8748    #[serde(default)]
8749    pub name: String,
8750}
8751
8752#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8753#[serde(rename_all = "camelCase")]
8754pub struct ThreadSectionAppearance {
8755    #[serde(default, skip_serializing_if = "Option::is_none")]
8756    pub color: Option<String>,
8757    #[serde(default, skip_serializing_if = "Option::is_none")]
8758    pub icon: Option<String>,
8759}
8760
8761#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8762#[serde(rename_all = "camelCase")]
8763pub struct ThreadSectionCreateParams {
8764    #[serde(default, skip_serializing_if = "Option::is_none")]
8765    pub appearance: Option<ThreadSectionAppearance>,
8766    #[serde(default)]
8767    pub name: String,
8768}
8769
8770#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8771#[serde(rename_all = "camelCase")]
8772pub struct ThreadSectionCreateResponse {
8773    #[serde()]
8774    pub section: ThreadSection,
8775}
8776
8777#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8778#[serde(rename_all = "camelCase")]
8779pub struct ThreadSectionDeleteParams {
8780    #[serde(rename = "sectionId", default)]
8781    pub section_id: String,
8782}
8783
8784#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8785#[serde(rename_all = "camelCase")]
8786pub struct ThreadSectionDeleteResponse {
8787    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8788    pub extra: serde_json::Map<String, Value>,
8789}
8790
8791#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8792#[serde(rename_all = "camelCase")]
8793pub struct ThreadSectionListParams {
8794    #[serde(default, skip_serializing_if = "Option::is_none")]
8795    pub cursor: Option<String>,
8796    #[serde(default, skip_serializing_if = "Option::is_none")]
8797    pub limit: Option<i64>,
8798}
8799
8800#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8801#[serde(rename_all = "camelCase")]
8802pub struct ThreadSectionListResponse {
8803    #[serde(default)]
8804    pub data: Vec<ThreadSection>,
8805    #[serde(
8806        rename = "nextCursor",
8807        default,
8808        skip_serializing_if = "Option::is_none"
8809    )]
8810    pub next_cursor: Option<String>,
8811}
8812
8813#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8814#[serde(rename_all = "camelCase")]
8815pub struct ThreadSectionMoveParams {
8816    #[serde(
8817        rename = "beforeThreadId",
8818        default,
8819        skip_serializing_if = "Option::is_none"
8820    )]
8821    pub before_thread_id: Option<String>,
8822    #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8823    pub section_id: Option<String>,
8824    #[serde(rename = "threadId", default)]
8825    pub thread_id: String,
8826}
8827
8828#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8829#[serde(rename_all = "camelCase")]
8830pub struct ThreadSectionMoveResponse {
8831    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8832    pub extra: serde_json::Map<String, Value>,
8833}
8834
8835#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8836#[serde(rename_all = "camelCase")]
8837pub struct ThreadSectionUpdateParams {
8838    #[serde(default, skip_serializing_if = "Option::is_none")]
8839    pub appearance: Option<ThreadSectionAppearance>,
8840    #[serde(default)]
8841    pub name: String,
8842    #[serde(rename = "sectionId", default)]
8843    pub section_id: String,
8844}
8845
8846#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8847#[serde(rename_all = "camelCase")]
8848pub struct ThreadSectionUpdateResponse {
8849    #[serde()]
8850    pub section: ThreadSection,
8851}
8852
8853#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8854#[serde(rename_all = "camelCase")]
8855pub struct ThreadSetNameParams {
8856    #[serde(default)]
8857    pub name: String,
8858    #[serde(rename = "threadId", default)]
8859    pub thread_id: String,
8860}
8861
8862#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8863#[serde(rename_all = "camelCase")]
8864pub struct ThreadSetNameResponse {
8865    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8866    pub extra: serde_json::Map<String, Value>,
8867}
8868
8869#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8870#[serde(rename_all = "camelCase")]
8871pub struct ThreadSettings {
8872    #[serde(
8873        rename = "activePermissionProfile",
8874        default,
8875        skip_serializing_if = "Option::is_none"
8876    )]
8877    pub active_permission_profile: Option<ActivePermissionProfile>,
8878    #[serde(rename = "approvalPolicy")]
8879    pub approval_policy: AskForApproval,
8880    #[serde(rename = "approvalsReviewer")]
8881    pub approvals_reviewer: ApprovalsReviewer,
8882    #[serde(rename = "collaborationMode")]
8883    pub collaboration_mode: CollaborationMode,
8884    #[serde()]
8885    pub cwd: AbsolutePathBuf,
8886    /// Saved list of disabled plugin IDs. Does not yet filter plugin
8887    /// capabilities.
8888    #[serde(rename = "disabledPluginIds", default)]
8889    pub disabled_plugin_ids: Vec<String>,
8890    #[serde(default, skip_serializing_if = "Option::is_none")]
8891    pub effort: Option<ReasoningEffort>,
8892    #[serde(default)]
8893    pub model: String,
8894    #[serde(rename = "modelProvider", default)]
8895    pub model_provider: String,
8896    #[serde(default, skip_serializing_if = "Option::is_none")]
8897    pub personality: Option<Personality>,
8898    #[serde(rename = "sandboxPolicy")]
8899    pub sandbox_policy: SandboxPolicy,
8900    #[serde(
8901        rename = "serviceTier",
8902        default,
8903        skip_serializing_if = "Option::is_none"
8904    )]
8905    pub service_tier: Option<String>,
8906    #[serde(default, skip_serializing_if = "Option::is_none")]
8907    pub summary: Option<ReasoningSummary>,
8908}
8909
8910#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8911#[serde(rename_all = "camelCase")]
8912pub struct ThreadSettingsUpdatedNotification {
8913    #[serde(rename = "threadId", default)]
8914    pub thread_id: String,
8915    #[serde(rename = "threadSettings")]
8916    pub thread_settings: ThreadSettings,
8917}
8918
8919#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8920#[serde(rename_all = "camelCase")]
8921pub struct ThreadShellCommandParams {
8922    #[serde(default)]
8923    pub command: String,
8924    #[serde(rename = "threadId", default)]
8925    pub thread_id: String,
8926    /// Maximum execution time in ms; defaults to one hour when omitted.
8927    /// Zero requests an immediate timeout, not unlimited (0.148 upstream).
8928    #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
8929    pub timeout_ms: Option<i64>,
8930}
8931
8932#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8933#[serde(rename_all = "camelCase")]
8934pub struct ThreadShellCommandResponse {
8935    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8936    pub extra: serde_json::Map<String, Value>,
8937}
8938
8939#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8940pub enum ThreadSortKey {
8941    #[serde(rename = "created_at")]
8942    Created_at,
8943    #[serde(rename = "updated_at")]
8944    Updated_at,
8945    #[serde(rename = "recency_at")]
8946    Recency_at,
8947    #[serde(rename = "section_position")]
8948    Section_position,
8949}
8950
8951#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
8952#[serde(transparent)]
8953pub struct ThreadSource(pub String);
8954
8955#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8956pub enum ThreadSourceKind {
8957    #[serde(rename = "cli")]
8958    Cli,
8959    #[serde(rename = "vscode")]
8960    Vscode,
8961    #[serde(rename = "exec")]
8962    Exec,
8963    #[serde(rename = "appServer")]
8964    AppServer,
8965    #[serde(rename = "subAgent")]
8966    SubAgent,
8967    #[serde(rename = "subAgentReview")]
8968    SubAgentReview,
8969    #[serde(rename = "subAgentCompact")]
8970    SubAgentCompact,
8971    #[serde(rename = "subAgentThreadSpawn")]
8972    SubAgentThreadSpawn,
8973    #[serde(rename = "subAgentOther")]
8974    SubAgentOther,
8975    #[serde(rename = "unknown")]
8976    Unknown,
8977}
8978
8979#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8980#[serde(rename_all = "camelCase")]
8981pub struct ThreadStartParams {
8982    #[serde(
8983        rename = "approvalPolicy",
8984        default,
8985        skip_serializing_if = "Option::is_none"
8986    )]
8987    pub approval_policy: Option<AskForApproval>,
8988    #[serde(
8989        rename = "approvalsReviewer",
8990        default,
8991        skip_serializing_if = "Option::is_none"
8992    )]
8993    pub approvals_reviewer: Option<ApprovalsReviewer>,
8994    #[serde(
8995        rename = "baseInstructions",
8996        default,
8997        skip_serializing_if = "Option::is_none"
8998    )]
8999    pub base_instructions: Option<String>,
9000    #[serde(default, skip_serializing_if = "Option::is_none")]
9001    pub config: Option<Value>,
9002    #[serde(default, skip_serializing_if = "Option::is_none")]
9003    pub cwd: Option<String>,
9004    #[serde(
9005        rename = "developerInstructions",
9006        default,
9007        skip_serializing_if = "Option::is_none"
9008    )]
9009    pub developer_instructions: Option<String>,
9010    #[serde(default, skip_serializing_if = "Option::is_none")]
9011    pub ephemeral: Option<bool>,
9012    #[serde(default, skip_serializing_if = "Option::is_none")]
9013    pub model: Option<String>,
9014    #[serde(
9015        rename = "modelProvider",
9016        default,
9017        skip_serializing_if = "Option::is_none"
9018    )]
9019    pub model_provider: Option<String>,
9020    #[serde(default, skip_serializing_if = "Option::is_none")]
9021    pub personality: Option<Personality>,
9022    #[serde(default, skip_serializing_if = "Option::is_none")]
9023    pub sandbox: Option<SandboxMode>,
9024    #[serde(
9025        rename = "serviceName",
9026        default,
9027        skip_serializing_if = "Option::is_none"
9028    )]
9029    pub service_name: Option<String>,
9030    #[serde(
9031        rename = "serviceTier",
9032        default,
9033        skip_serializing_if = "Option::is_none"
9034    )]
9035    pub service_tier: Option<String>,
9036    #[serde(
9037        rename = "sessionStartSource",
9038        default,
9039        skip_serializing_if = "Option::is_none"
9040    )]
9041    pub session_start_source: Option<ThreadStartSource>,
9042    #[serde(
9043        rename = "threadSource",
9044        default,
9045        skip_serializing_if = "Option::is_none"
9046    )]
9047    pub thread_source: Option<ThreadSource>,
9048}
9049
9050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9051#[serde(rename_all = "camelCase")]
9052pub struct ThreadStartResponse {
9053    #[serde(rename = "approvalPolicy")]
9054    pub approval_policy: AskForApproval,
9055    #[serde(rename = "approvalsReviewer", default)]
9056    pub approvals_reviewer: Value,
9057    #[serde()]
9058    pub cwd: AbsolutePathBuf,
9059    /// Saved list of disabled plugin IDs. Does not yet filter plugin
9060    /// capabilities.
9061    #[serde(rename = "disabledPluginIds", default)]
9062    pub disabled_plugin_ids: Vec<String>,
9063    #[serde(
9064        rename = "instructionSources",
9065        default,
9066        skip_serializing_if = "Option::is_none"
9067    )]
9068    pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9069    #[serde(default)]
9070    pub model: String,
9071    #[serde(rename = "modelProvider", default)]
9072    pub model_provider: String,
9073    #[serde(
9074        rename = "reasoningEffort",
9075        default,
9076        skip_serializing_if = "Option::is_none"
9077    )]
9078    pub reasoning_effort: Option<ReasoningEffort>,
9079    #[serde(default)]
9080    pub sandbox: Value,
9081    #[serde(
9082        rename = "serviceTier",
9083        default,
9084        skip_serializing_if = "Option::is_none"
9085    )]
9086    pub service_tier: Option<String>,
9087    #[serde()]
9088    pub thread: Thread,
9089}
9090
9091#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9092pub enum ThreadStartSource {
9093    #[serde(rename = "startup")]
9094    Startup,
9095    #[serde(rename = "clear")]
9096    Clear,
9097}
9098
9099#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9100#[serde(rename_all = "camelCase")]
9101pub struct ThreadStartedNotification {
9102    #[serde()]
9103    pub thread: Thread,
9104}
9105
9106#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9107#[serde(tag = "type", rename_all = "camelCase")]
9108pub enum ThreadStatus {
9109    #[serde(rename = "notLoaded")]
9110    NotLoaded,
9111    Idle,
9112    #[serde(rename = "systemError")]
9113    SystemError,
9114    Active {
9115        #[serde(rename = "activeFlags")]
9116        active_flags: Vec<ThreadActiveFlag>,
9117    },
9118}
9119
9120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9121#[serde(rename_all = "camelCase")]
9122pub struct ThreadStatusChangedNotification {
9123    #[serde()]
9124    pub status: ThreadStatus,
9125    #[serde(rename = "threadId", default)]
9126    pub thread_id: String,
9127}
9128
9129#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9130#[serde(rename_all = "camelCase")]
9131pub struct ThreadTokenUsage {
9132    #[serde()]
9133    pub last: TokenUsageBreakdown,
9134    #[serde(
9135        rename = "modelContextWindow",
9136        default,
9137        skip_serializing_if = "Option::is_none"
9138    )]
9139    pub model_context_window: Option<i64>,
9140    #[serde()]
9141    pub total: TokenUsageBreakdown,
9142}
9143
9144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9145#[serde(rename_all = "camelCase")]
9146pub struct ThreadTokenUsageUpdatedNotification {
9147    #[serde(rename = "threadId", default)]
9148    pub thread_id: String,
9149    #[serde(rename = "tokenUsage")]
9150    pub token_usage: ThreadTokenUsage,
9151    #[serde(rename = "turnId", default)]
9152    pub turn_id: String,
9153}
9154
9155#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9156#[serde(rename_all = "camelCase")]
9157pub struct ThreadUnarchiveParams {
9158    #[serde(rename = "threadId", default)]
9159    pub thread_id: String,
9160}
9161
9162#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9163#[serde(rename_all = "camelCase")]
9164pub struct ThreadUnarchiveResponse {
9165    #[serde()]
9166    pub thread: Thread,
9167}
9168
9169#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9170#[serde(rename_all = "camelCase")]
9171pub struct ThreadUnarchivedNotification {
9172    #[serde(rename = "threadId", default)]
9173    pub thread_id: String,
9174}
9175
9176/// EXPERIMENTAL upstream — one item or turn boundary in canonical rollout
9177/// order (0.148). Wire quirk mirrored exactly: the `item` variant uses
9178/// camelCase `turnId` while the turn-boundary variants use snake_case
9179/// `turn_id`/`started_at`/`completed_at`/`duration_ms`.
9180#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9181#[serde(tag = "type", rename_all = "camelCase")]
9182#[allow(clippy::large_enum_variant)] // transient per-entry wire value, not stored in bulk
9183pub enum ThreadTimelineEntry {
9184    Item {
9185        item: ThreadItem,
9186        position: u64,
9187        #[serde(rename = "turnId")]
9188        turn_id: String,
9189    },
9190    Realtime {
9191        item: ThreadRealtimeItem,
9192        position: u64,
9193    },
9194    TurnStarted {
9195        position: u64,
9196        #[serde(default, skip_serializing_if = "Option::is_none")]
9197        started_at: Option<i64>,
9198        turn_id: String,
9199    },
9200    TurnCompleted {
9201        #[serde(default, skip_serializing_if = "Option::is_none")]
9202        completed_at: Option<i64>,
9203        #[serde(default, skip_serializing_if = "Option::is_none")]
9204        duration_ms: Option<i64>,
9205        #[serde(default, skip_serializing_if = "Option::is_none")]
9206        error: Option<TurnError>,
9207        position: u64,
9208        #[serde(default, skip_serializing_if = "Option::is_none")]
9209        started_at: Option<i64>,
9210        status: TurnStatus,
9211        turn_id: String,
9212    },
9213}
9214
9215/// Params for `thread/turns/list` — paginated turn hydration (0.148 upstream).
9216#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9217#[serde(rename_all = "camelCase")]
9218pub struct ThreadTurnsListParams {
9219    #[serde(default, skip_serializing_if = "Option::is_none")]
9220    pub cursor: Option<String>,
9221    /// How much item detail to include per turn; defaults to summary.
9222    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9223    pub items_view: Option<TurnItemsView>,
9224    #[serde(default, skip_serializing_if = "Option::is_none")]
9225    pub limit: Option<u32>,
9226    #[serde(
9227        rename = "sortDirection",
9228        default,
9229        skip_serializing_if = "Option::is_none"
9230    )]
9231    pub sort_direction: Option<SortDirection>,
9232    #[serde(rename = "threadId", default)]
9233    pub thread_id: String,
9234}
9235
9236/// Response to `thread/turns/list` (0.148 upstream).
9237#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9238#[serde(rename_all = "camelCase")]
9239pub struct ThreadTurnsListResponse {
9240    #[serde(
9241        rename = "backwardsCursor",
9242        default,
9243        skip_serializing_if = "Option::is_none"
9244    )]
9245    pub backwards_cursor: Option<String>,
9246    #[serde(default)]
9247    pub data: Vec<Turn>,
9248    #[serde(
9249        rename = "nextCursor",
9250        default,
9251        skip_serializing_if = "Option::is_none"
9252    )]
9253    pub next_cursor: Option<String>,
9254}
9255
9256#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9257#[serde(rename_all = "camelCase")]
9258pub struct ThreadUnsubscribeParams {
9259    #[serde(rename = "threadId", default)]
9260    pub thread_id: String,
9261}
9262
9263#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9264#[serde(rename_all = "camelCase")]
9265pub struct ThreadUnsubscribeResponse {
9266    #[serde()]
9267    pub status: ThreadUnsubscribeStatus,
9268}
9269
9270#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9271pub enum ThreadUnsubscribeStatus {
9272    #[serde(rename = "notLoaded")]
9273    NotLoaded,
9274    #[serde(rename = "notSubscribed")]
9275    NotSubscribed,
9276    #[serde(rename = "unsubscribed")]
9277    Unsubscribed,
9278}
9279
9280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9281#[serde(rename_all = "camelCase")]
9282pub struct TokenUsageBreakdown {
9283    #[serde(
9284        rename = "cacheWriteInputTokens",
9285        default,
9286        skip_serializing_if = "Option::is_none"
9287    )]
9288    pub cache_write_input_tokens: Option<i64>,
9289    #[serde(rename = "cachedInputTokens", default)]
9290    pub cached_input_tokens: i64,
9291    #[serde(rename = "inputTokens", default)]
9292    pub input_tokens: i64,
9293    #[serde(rename = "outputTokens", default)]
9294    pub output_tokens: i64,
9295    #[serde(rename = "reasoningOutputTokens", default)]
9296    pub reasoning_output_tokens: i64,
9297    #[serde(rename = "totalTokens", default)]
9298    pub total_tokens: i64,
9299}
9300
9301#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9302#[serde(rename_all = "camelCase")]
9303pub struct Tool {
9304    #[serde(default, skip_serializing_if = "Option::is_none")]
9305    pub _meta: Option<Value>,
9306    #[serde(default, skip_serializing_if = "Option::is_none")]
9307    pub annotations: Option<Value>,
9308    #[serde(default, skip_serializing_if = "Option::is_none")]
9309    pub description: Option<String>,
9310    #[serde(default, skip_serializing_if = "Option::is_none")]
9311    pub icons: Option<Vec<Value>>,
9312    #[serde(rename = "inputSchema", default)]
9313    pub input_schema: Value,
9314    #[serde(default)]
9315    pub name: String,
9316    #[serde(
9317        rename = "outputSchema",
9318        default,
9319        skip_serializing_if = "Option::is_none"
9320    )]
9321    pub output_schema: Option<Value>,
9322    #[serde(default, skip_serializing_if = "Option::is_none")]
9323    pub title: Option<String>,
9324}
9325
9326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9327#[serde(rename_all = "camelCase")]
9328pub struct ToolRequestUserInputAnswer {
9329    #[serde(default)]
9330    pub answers: Vec<String>,
9331}
9332
9333#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9334#[serde(rename_all = "camelCase")]
9335pub struct ToolRequestUserInputOption {
9336    #[serde(default)]
9337    pub description: String,
9338    #[serde(default)]
9339    pub label: String,
9340}
9341
9342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9343#[serde(rename_all = "camelCase")]
9344pub struct ToolRequestUserInputParams {
9345    #[serde(
9346        rename = "autoResolutionMs",
9347        default,
9348        skip_serializing_if = "Option::is_none"
9349    )]
9350    pub auto_resolution_ms: Option<i64>,
9351    #[serde(rename = "isBlocking", default)]
9352    pub is_blocking: bool,
9353    #[serde(rename = "itemId", default)]
9354    pub item_id: String,
9355    #[serde(default)]
9356    pub questions: Vec<ToolRequestUserInputQuestion>,
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 ToolRequestUserInputQuestion {
9366    #[serde(default)]
9367    pub header: String,
9368    #[serde(default)]
9369    pub id: String,
9370    #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
9371    pub is_other: Option<bool>,
9372    #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
9373    pub is_secret: Option<bool>,
9374    #[serde(default, skip_serializing_if = "Option::is_none")]
9375    pub options: Option<Vec<ToolRequestUserInputOption>>,
9376    #[serde(default)]
9377    pub question: String,
9378}
9379
9380#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9381#[serde(rename_all = "camelCase")]
9382pub struct ToolRequestUserInputResponse {
9383    #[serde(default)]
9384    pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
9385}
9386
9387#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9388#[serde(rename_all = "camelCase")]
9389pub struct ToolsV2 {
9390    #[serde(default, skip_serializing_if = "Option::is_none")]
9391    pub web_search: Option<WebSearchToolConfig>,
9392}
9393
9394#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9395#[serde(rename_all = "camelCase")]
9396pub struct Turn {
9397    #[serde(
9398        rename = "completedAt",
9399        default,
9400        skip_serializing_if = "Option::is_none"
9401    )]
9402    pub completed_at: Option<i64>,
9403    #[serde(
9404        rename = "durationMs",
9405        default,
9406        skip_serializing_if = "Option::is_none"
9407    )]
9408    pub duration_ms: Option<i64>,
9409    #[serde(default, skip_serializing_if = "Option::is_none")]
9410    pub error: Option<TurnError>,
9411    #[serde(default)]
9412    pub id: String,
9413    #[serde(default)]
9414    pub items: Vec<ThreadItem>,
9415    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9416    pub items_view: Option<Value>,
9417    #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
9418    pub started_at: Option<i64>,
9419    #[serde()]
9420    pub status: TurnStatus,
9421}
9422
9423#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9424#[serde(rename_all = "camelCase")]
9425pub struct TurnCompletedNotification {
9426    #[serde(rename = "threadId", default)]
9427    pub thread_id: String,
9428    #[serde()]
9429    pub turn: Turn,
9430}
9431
9432#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9433#[serde(rename_all = "camelCase")]
9434pub struct TurnDiffUpdatedNotification {
9435    #[serde(default)]
9436    pub diff: String,
9437    #[serde(rename = "threadId", default)]
9438    pub thread_id: String,
9439    #[serde(rename = "turnId", default)]
9440    pub turn_id: String,
9441}
9442
9443#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9444#[serde(rename_all = "camelCase")]
9445pub struct TurnError {
9446    #[serde(
9447        rename = "additionalDetails",
9448        default,
9449        skip_serializing_if = "Option::is_none"
9450    )]
9451    pub additional_details: Option<String>,
9452    #[serde(
9453        rename = "codexErrorInfo",
9454        default,
9455        skip_serializing_if = "Option::is_none"
9456    )]
9457    pub codex_error_info: Option<CodexErrorInfo>,
9458    #[serde(default)]
9459    pub message: String,
9460    /// Public explanation and continuation instruction for a misalignment
9461    /// block (0.148 upstream).
9462    #[serde(default, skip_serializing_if = "Option::is_none")]
9463    pub misalignment: Option<MisalignmentErrorDetails>,
9464}
9465
9466#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9467#[serde(rename_all = "camelCase")]
9468pub struct TurnInterruptParams {
9469    #[serde(rename = "threadId", default)]
9470    pub thread_id: String,
9471    #[serde(rename = "turnId", default)]
9472    pub turn_id: String,
9473}
9474
9475#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9476#[serde(rename_all = "camelCase")]
9477pub struct TurnInterruptResponse {
9478    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9479    pub extra: serde_json::Map<String, Value>,
9480}
9481
9482#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
9483pub enum TurnItemsView {
9484    #[serde(rename = "notLoaded")]
9485    NotLoaded,
9486    #[serde(rename = "summary")]
9487    Summary,
9488    #[serde(rename = "full")]
9489    Full,
9490}
9491
9492#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9493#[serde(rename_all = "camelCase")]
9494pub struct TurnModerationMetadataNotification {
9495    #[serde(default)]
9496    pub metadata: Value,
9497    #[serde(rename = "threadId", default)]
9498    pub thread_id: String,
9499    #[serde(rename = "turnId", default)]
9500    pub turn_id: String,
9501}
9502
9503#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9504#[serde(rename_all = "camelCase")]
9505pub struct TurnPlanStep {
9506    #[serde()]
9507    pub status: TurnPlanStepStatus,
9508    #[serde(default)]
9509    pub step: String,
9510}
9511
9512#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9513pub enum TurnPlanStepStatus {
9514    #[serde(rename = "pending")]
9515    Pending,
9516    #[serde(rename = "inProgress")]
9517    InProgress,
9518    #[serde(rename = "completed")]
9519    Completed,
9520}
9521
9522#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9523#[serde(rename_all = "camelCase")]
9524pub struct TurnPlanUpdatedNotification {
9525    #[serde(default, skip_serializing_if = "Option::is_none")]
9526    pub explanation: Option<String>,
9527    #[serde(default)]
9528    pub plan: Vec<TurnPlanStep>,
9529    #[serde(rename = "threadId", default)]
9530    pub thread_id: String,
9531    #[serde(rename = "turnId", default)]
9532    pub turn_id: String,
9533}
9534
9535#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9536#[serde(rename_all = "camelCase")]
9537pub struct TurnStartParams {
9538    #[serde(
9539        rename = "approvalPolicy",
9540        default,
9541        skip_serializing_if = "Option::is_none"
9542    )]
9543    pub approval_policy: Option<AskForApproval>,
9544    #[serde(
9545        rename = "approvalsReviewer",
9546        default,
9547        skip_serializing_if = "Option::is_none"
9548    )]
9549    pub approvals_reviewer: Option<ApprovalsReviewer>,
9550    #[serde(
9551        rename = "clientUserMessageId",
9552        default,
9553        skip_serializing_if = "Option::is_none"
9554    )]
9555    pub client_user_message_id: Option<String>,
9556    #[serde(default, skip_serializing_if = "Option::is_none")]
9557    pub cwd: Option<String>,
9558    /// Replace this thread's disabled plugin IDs. Omitted/null preserves the
9559    /// list; `[]` clears it.
9560    #[serde(
9561        rename = "disabledPluginIds",
9562        default,
9563        skip_serializing_if = "Option::is_none"
9564    )]
9565    pub disabled_plugin_ids: Option<Vec<String>>,
9566    #[serde(default, skip_serializing_if = "Option::is_none")]
9567    pub effort: Option<ReasoningEffort>,
9568    #[serde(default)]
9569    pub input: Vec<UserInput>,
9570    #[serde(default, skip_serializing_if = "Option::is_none")]
9571    pub model: Option<String>,
9572    #[serde(
9573        rename = "outputSchema",
9574        default,
9575        skip_serializing_if = "Option::is_none"
9576    )]
9577    pub output_schema: Option<Value>,
9578    #[serde(default, skip_serializing_if = "Option::is_none")]
9579    pub personality: Option<Personality>,
9580    #[serde(
9581        rename = "sandboxPolicy",
9582        default,
9583        skip_serializing_if = "Option::is_none"
9584    )]
9585    pub sandbox_policy: Option<SandboxPolicy>,
9586    #[serde(
9587        rename = "serviceTier",
9588        default,
9589        skip_serializing_if = "Option::is_none"
9590    )]
9591    pub service_tier: Option<String>,
9592    /// One-turn service-tier override; `"default"` for standard speed.
9593    /// Omitted or null inherits the thread's tier (0.148 upstream).
9594    #[serde(
9595        rename = "serviceTierForTurn",
9596        default,
9597        skip_serializing_if = "Option::is_none"
9598    )]
9599    pub service_tier_for_turn: Option<String>,
9600    #[serde(default, skip_serializing_if = "Option::is_none")]
9601    pub summary: Option<ReasoningSummary>,
9602    #[serde(rename = "threadId", default)]
9603    pub thread_id: String,
9604    /// Pre-computed tool output to inject when starting the turn
9605    /// (0.148 upstream).
9606    #[serde(
9607        rename = "toolOutput",
9608        default,
9609        skip_serializing_if = "Option::is_none"
9610    )]
9611    pub tool_output: Option<TurnToolOutput>,
9612    /// Optional source classification for the caller starting this turn;
9613    /// ignored when steering an already-active turn (0.148 upstream).
9614    #[serde(
9615        rename = "turnTrigger",
9616        default,
9617        skip_serializing_if = "Option::is_none"
9618    )]
9619    pub turn_trigger: Option<String>,
9620}
9621
9622#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9623#[serde(rename_all = "camelCase")]
9624pub struct TurnStartResponse {
9625    #[serde()]
9626    pub turn: Turn,
9627}
9628
9629#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9630#[serde(rename_all = "camelCase")]
9631pub struct TurnStartedNotification {
9632    #[serde(rename = "threadId", default)]
9633    pub thread_id: String,
9634    #[serde()]
9635    pub turn: Turn,
9636}
9637
9638#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9639pub enum TurnStatus {
9640    #[serde(rename = "completed")]
9641    Completed,
9642    #[serde(rename = "interrupted")]
9643    Interrupted,
9644    #[serde(rename = "failed")]
9645    Failed,
9646    #[serde(rename = "inProgress")]
9647    InProgress,
9648}
9649
9650/// A pre-computed tool output supplied when starting a turn
9651/// (`TurnStartParams.toolOutput`, 0.148 upstream).
9652#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9653#[serde(rename_all = "camelCase")]
9654pub struct TurnToolOutput {
9655    #[serde(default)]
9656    pub name: String,
9657    #[serde(default, skip_serializing_if = "Option::is_none")]
9658    pub namespace: Option<String>,
9659    #[serde()]
9660    pub output: FunctionCallOutputBody,
9661}
9662
9663#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9664#[serde(rename_all = "camelCase")]
9665pub struct TurnSteerParams {
9666    #[serde(
9667        rename = "clientUserMessageId",
9668        default,
9669        skip_serializing_if = "Option::is_none"
9670    )]
9671    pub client_user_message_id: Option<String>,
9672    #[serde(rename = "expectedTurnId", default)]
9673    pub expected_turn_id: String,
9674    #[serde(default)]
9675    pub input: Vec<UserInput>,
9676    #[serde(rename = "threadId", default)]
9677    pub thread_id: String,
9678}
9679
9680#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9681#[serde(rename_all = "camelCase")]
9682pub struct TurnSteerResponse {
9683    #[serde(rename = "turnId", default)]
9684    pub turn_id: String,
9685}
9686
9687#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9688#[serde(tag = "type", rename_all = "camelCase")]
9689pub enum UserInput {
9690    Text {
9691        text: String,
9692        #[serde(default, skip_serializing_if = "Option::is_none")]
9693        text_elements: Option<Vec<TextElement>>,
9694    },
9695    Image {
9696        #[serde(default, skip_serializing_if = "Option::is_none")]
9697        detail: Option<ImageDetail>,
9698        #[serde(flatten)]
9699        image: UserInputImageReference,
9700    },
9701    #[serde(rename = "localImage")]
9702    LocalImage {
9703        #[serde(default, skip_serializing_if = "Option::is_none")]
9704        detail: Option<ImageDetail>,
9705        path: String,
9706    },
9707    Audio {
9708        url: String,
9709    },
9710    #[serde(rename = "localAudio")]
9711    LocalAudio {
9712        path: String,
9713    },
9714    Skill {
9715        name: String,
9716        path: String,
9717    },
9718    Mention {
9719        name: String,
9720        path: String,
9721    },
9722}
9723
9724/// How a [`UserInput::Image`] names its image: an inline `url` (data URL or
9725/// remote URL) or a previously uploaded `fileId`. Flattened into the variant;
9726/// untagged, so exactly one of the two keys is on the wire. Mirrors the v2
9727/// `ImageReference` upstream; the Responses-API twin used by tool outputs is
9728/// [`ImageReference`].
9729#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9730#[serde(untagged)]
9731pub enum UserInputImageReference {
9732    Inline {
9733        url: String,
9734    },
9735    File {
9736        #[serde(rename = "fileId")]
9737        file_id: String,
9738    },
9739}
9740
9741#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9742pub enum Verbosity {
9743    #[serde(rename = "low")]
9744    Low,
9745    #[serde(rename = "medium")]
9746    Medium,
9747    #[serde(rename = "high")]
9748    High,
9749}
9750
9751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9752#[serde(rename_all = "camelCase")]
9753pub struct WarningNotification {
9754    #[serde(default)]
9755    pub message: String,
9756    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
9757    pub thread_id: Option<String>,
9758}
9759
9760#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9761#[serde(tag = "type", rename_all = "camelCase")]
9762pub enum WebSearchAction {
9763    Search {
9764        #[serde(default, skip_serializing_if = "Option::is_none")]
9765        queries: Option<Vec<String>>,
9766        #[serde(default, skip_serializing_if = "Option::is_none")]
9767        query: Option<String>,
9768    },
9769    #[serde(rename = "openPage")]
9770    OpenPage {
9771        #[serde(default, skip_serializing_if = "Option::is_none")]
9772        url: Option<String>,
9773    },
9774    #[serde(rename = "findInPage")]
9775    FindInPage {
9776        #[serde(default, skip_serializing_if = "Option::is_none")]
9777        pattern: Option<String>,
9778        #[serde(default, skip_serializing_if = "Option::is_none")]
9779        url: Option<String>,
9780    },
9781    Other,
9782}
9783
9784#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9785pub enum WebSearchContextSize {
9786    #[serde(rename = "low")]
9787    Low,
9788    #[serde(rename = "medium")]
9789    Medium,
9790    #[serde(rename = "high")]
9791    High,
9792}
9793
9794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9795#[serde(rename_all = "camelCase")]
9796pub struct WebSearchLocation {
9797    #[serde(default, skip_serializing_if = "Option::is_none")]
9798    pub city: Option<String>,
9799    #[serde(default, skip_serializing_if = "Option::is_none")]
9800    pub country: Option<String>,
9801    #[serde(default, skip_serializing_if = "Option::is_none")]
9802    pub region: Option<String>,
9803    #[serde(default, skip_serializing_if = "Option::is_none")]
9804    pub timezone: Option<String>,
9805}
9806
9807#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9808pub enum WebSearchMode {
9809    #[serde(rename = "disabled")]
9810    Disabled,
9811    #[serde(rename = "cached")]
9812    Cached,
9813    #[serde(rename = "indexed")]
9814    Indexed,
9815    #[serde(rename = "live")]
9816    Live,
9817}
9818
9819#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9820#[serde(rename_all = "camelCase")]
9821pub struct WebSearchToolConfig {
9822    #[serde(default, skip_serializing_if = "Option::is_none")]
9823    pub allowed_domains: Option<Vec<String>>,
9824    #[serde(default, skip_serializing_if = "Option::is_none")]
9825    pub context_size: Option<WebSearchContextSize>,
9826    #[serde(default, skip_serializing_if = "Option::is_none")]
9827    pub location: Option<WebSearchLocation>,
9828}
9829
9830#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9831pub enum WindowsSandboxReadiness {
9832    #[serde(rename = "ready")]
9833    Ready,
9834    #[serde(rename = "notConfigured")]
9835    NotConfigured,
9836    #[serde(rename = "updateRequired")]
9837    UpdateRequired,
9838}
9839
9840#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9841#[serde(rename_all = "camelCase")]
9842pub struct WindowsSandboxReadinessResponse {
9843    #[serde()]
9844    pub status: WindowsSandboxReadiness,
9845}
9846
9847#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9848#[serde(rename_all = "camelCase")]
9849pub struct WindowsSandboxSetupCompletedNotification {
9850    #[serde(default, skip_serializing_if = "Option::is_none")]
9851    pub error: Option<String>,
9852    #[serde()]
9853    pub mode: WindowsSandboxSetupMode,
9854    #[serde(default)]
9855    pub success: bool,
9856}
9857
9858#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9859pub enum WindowsSandboxSetupMode {
9860    #[serde(rename = "elevated")]
9861    Elevated,
9862    #[serde(rename = "unelevated")]
9863    Unelevated,
9864}
9865
9866/// A Windows sandbox implementation a managed policy may allow
9867/// ([`ConfigRequirements::allowed_windows_sandbox_implementations`]). Grows
9868/// `mxc` beyond the two [`WindowsSandboxSetupMode`] values.
9869#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9870pub enum WindowsSandboxImplementation {
9871    #[serde(rename = "elevated")]
9872    Elevated,
9873    #[serde(rename = "unelevated")]
9874    Unelevated,
9875    #[serde(rename = "mxc")]
9876    Mxc,
9877}
9878
9879#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9880#[serde(rename_all = "camelCase")]
9881pub struct WindowsSandboxSetupStartParams {
9882    #[serde(default, skip_serializing_if = "Option::is_none")]
9883    pub cwd: Option<AbsolutePathBuf>,
9884    #[serde()]
9885    pub mode: WindowsSandboxSetupMode,
9886}
9887
9888#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9889#[serde(rename_all = "camelCase")]
9890pub struct WindowsSandboxSetupStartResponse {
9891    #[serde(default)]
9892    pub started: bool,
9893}
9894
9895#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9896#[serde(rename_all = "camelCase")]
9897pub struct WindowsWorldWritableWarningNotification {
9898    #[serde(rename = "extraCount", default)]
9899    pub extra_count: i64,
9900    #[serde(rename = "failedScan", default)]
9901    pub failed_scan: bool,
9902    #[serde(rename = "samplePaths", default)]
9903    pub sample_paths: Vec<String>,
9904}
9905
9906#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9907#[serde(rename_all = "camelCase")]
9908pub struct WorkspaceMessage {
9909    #[serde(
9910        rename = "archivedAt",
9911        default,
9912        skip_serializing_if = "Option::is_none"
9913    )]
9914    pub archived_at: Option<i64>,
9915    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
9916    pub created_at: Option<i64>,
9917    #[serde(rename = "messageBody", default)]
9918    pub message_body: String,
9919    #[serde(rename = "messageId", default)]
9920    pub message_id: String,
9921    #[serde(rename = "messageType")]
9922    pub message_type: WorkspaceMessageType,
9923}
9924
9925#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9926pub enum WorkspaceMessageType {
9927    #[serde(rename = "headline")]
9928    Headline,
9929    #[serde(rename = "announcement")]
9930    Announcement,
9931    #[serde(rename = "unknown")]
9932    Unknown,
9933}
9934
9935#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9936pub enum WriteStatus {
9937    #[serde(rename = "ok")]
9938    Ok,
9939    #[serde(rename = "okOverridden")]
9940    OkOverridden,
9941}