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