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

codex_codes/protocol_generated/
types.rs
