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