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