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

codex_codes/protocol_generated/
types.rs
