Skip to main content

codex_codes/protocol_generated/
types.rs

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