Skip to main content

codex_codes/protocol_generated/
types.rs

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