Skip to main content

codex_codes/protocol_generated/
types.rs

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