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