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