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, PartialEq, Eq, Serialize, Deserialize)]
7005pub struct AgentMessageModeration {
7006 pub moderated: bool,
7007 #[serde(default, skip_serializing_if = "Option::is_none")]
7008 pub display: Option<AgentMessageDisplay>,
7009}
7010
7011#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
7013#[serde(rename_all = "camelCase")]
7014pub struct AgentMessageDisplay {
7015 pub action: String,
7017 #[serde(default, skip_serializing_if = "Option::is_none")]
7018 pub block_type: Option<String>,
7019 #[serde(default, skip_serializing_if = "Option::is_none")]
7020 pub cyber_trusted_access: Option<bool>,
7021 #[serde(default, skip_serializing_if = "Option::is_none")]
7022 pub check_trusted_contacts: Option<bool>,
7023}
7024
7025#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7027pub enum CliAuthCredentialsStoreMode {
7028 #[serde(rename = "file")]
7029 File,
7030 #[serde(rename = "keyring")]
7031 Keyring,
7032 #[serde(rename = "auto")]
7033 Auto,
7034 #[serde(rename = "ephemeral")]
7035 Ephemeral,
7036}
7037
7038#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7040pub struct Project {
7041 #[serde(rename = "createdAt", default)]
7042 pub created_at: i64,
7043 #[serde(default)]
7044 pub id: String,
7045 #[serde(default)]
7046 pub metadata: std::collections::HashMap<String, String>,
7047 #[serde(default)]
7048 pub name: String,
7049 #[serde(default)]
7050 pub position: i64,
7051 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7054 pub recency_at: Option<i64>,
7055 #[serde(default)]
7056 pub roots: Vec<ProjectRoot>,
7057 #[serde(rename = "updatedAt", default)]
7058 pub updated_at: i64,
7059}
7060
7061#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7063pub enum ProjectSortKey {
7064 #[serde(rename = "position")]
7065 Position,
7066 #[serde(rename = "recencyAt")]
7067 RecencyAt,
7068}
7069
7070#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7071pub enum ProjectChangeType {
7072 #[serde(rename = "created")]
7073 Created,
7074 #[serde(rename = "updated")]
7075 Updated,
7076 #[serde(rename = "deleted")]
7077 Deleted,
7078}
7079
7080#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7082pub struct ProjectChangedNotification {
7083 #[serde(rename = "changeType")]
7084 pub change_type: ProjectChangeType,
7085 #[serde(rename = "projectId", default)]
7086 pub project_id: String,
7087}
7088
7089#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7090pub struct ProjectRoot {
7091 pub path: AbsolutePathBuf,
7092}
7093
7094#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7096pub struct QueuedSubmission {
7097 #[serde(rename = "clientUserMessageId", default)]
7098 pub client_user_message_id: String,
7099 #[serde(default)]
7100 pub id: String,
7101 #[serde(default)]
7102 pub input: Vec<UserInput>,
7103 #[serde(
7105 rename = "responsesapiClientMetadata",
7106 default,
7107 skip_serializing_if = "Option::is_none"
7108 )]
7109 pub responsesapi_client_metadata: Option<std::collections::HashMap<String, String>>,
7110}
7111
7112#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7114pub struct StrictReviewRequiredNotification {
7115 #[serde(rename = "startedAtMs", default)]
7117 pub started_at_ms: i64,
7118 #[serde(rename = "threadId", default)]
7119 pub thread_id: String,
7120 #[serde(rename = "turnId", default)]
7121 pub turn_id: String,
7122}
7123
7124#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7126pub struct ThreadProjectUpdatedNotification {
7127 #[serde(rename = "projectId", default)]
7128 pub project_id: Option<String>,
7129 #[serde(rename = "threadId", default)]
7130 pub thread_id: String,
7131}
7132
7133#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7135pub struct ThreadQueueChangedNotification {
7136 #[serde(rename = "threadId", default)]
7137 pub thread_id: String,
7138}
7139
7140#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7142pub struct ThreadRevertedNotification {
7143 #[serde(rename = "threadId", default)]
7144 pub thread_id: String,
7145}
7146
7147#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7150#[serde(rename_all = "camelCase")]
7151pub struct ThreadPredictionUpdatedNotification {
7152 pub result: ThreadPredictionResult,
7153 #[serde(rename = "sourceTurnId", default)]
7154 pub source_turn_id: String,
7155 #[serde(rename = "threadId", default)]
7156 pub thread_id: String,
7157}
7158
7159#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7161#[serde(tag = "type", rename_all = "camelCase")]
7162pub enum ThreadPredictionResult {
7163 Completed {
7164 #[serde(default, skip_serializing_if = "Option::is_none")]
7165 text: Option<String>,
7166 },
7167 Failed,
7168}
7169
7170#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7172#[serde(rename_all = "camelCase")]
7173pub struct InAppBrowserRequirements {
7174 #[serde(
7175 rename = "allowExternalBrowserSettingsImport",
7176 default,
7177 skip_serializing_if = "Option::is_none"
7178 )]
7179 pub allow_external_browser_settings_import: Option<bool>,
7180}
7181
7182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7184pub struct McpServerEventNotification {
7185 #[serde(default)]
7186 pub method: String,
7187 #[serde(default)]
7188 pub params: Value,
7189}
7190
7191#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7194pub struct McpServerEventStreamNotification {
7195 pub notification: McpServerEventNotification,
7196 #[serde(rename = "subscriptionId", default)]
7197 pub subscription_id: String,
7198}
7199
7200#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7203pub enum AllowDenyRequirement {
7204 #[serde(rename = "allow")]
7205 Allow,
7206 #[serde(rename = "deny")]
7207 Deny,
7208}
7209
7210#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7212pub enum BrowserUseAccessApprovalLifetime {
7213 #[serde(rename = "turn")]
7214 Turn,
7215 #[serde(rename = "thread")]
7216 Thread,
7217}
7218
7219#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7221pub enum McpServerConnectionStatus {
7222 #[serde(rename = "notStarted")]
7223 NotStarted,
7224 #[serde(rename = "starting")]
7225 Starting,
7226 #[serde(rename = "connected")]
7227 Connected,
7228 #[serde(rename = "authenticationRequired")]
7229 AuthenticationRequired,
7230 #[serde(rename = "failed")]
7231 Failed,
7232 #[serde(rename = "cancelled")]
7233 Cancelled,
7234 #[serde(rename = "disabled")]
7235 Disabled,
7236}
7237
7238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7240#[serde(rename_all = "camelCase")]
7241pub struct BrowserUseOriginPolicy {
7242 #[serde(default, skip_serializing_if = "Option::is_none")]
7243 pub access: Option<AllowDenyRequirement>,
7244 #[serde(
7245 rename = "accessApprovalLifetime",
7246 default,
7247 skip_serializing_if = "Option::is_none"
7248 )]
7249 pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
7250 #[serde(
7251 rename = "autoReview",
7252 default,
7253 skip_serializing_if = "Option::is_none"
7254 )]
7255 pub auto_review: Option<AllowDenyRequirement>,
7256 #[serde(default, skip_serializing_if = "Option::is_none")]
7257 pub downloads: Option<AllowDenyRequirement>,
7258 #[serde(
7259 rename = "fullCdpAccess",
7260 default,
7261 skip_serializing_if = "Option::is_none"
7262 )]
7263 pub full_cdp_access: Option<AllowDenyRequirement>,
7264 #[serde(
7265 rename = "persistentApproval",
7266 default,
7267 skip_serializing_if = "Option::is_none"
7268 )]
7269 pub persistent_approval: Option<bool>,
7270 #[serde(default, skip_serializing_if = "Option::is_none")]
7271 pub uploads: Option<AllowDenyRequirement>,
7272}
7273
7274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7276pub struct BrowserUseOriginPolicyConfig {
7277 #[serde(default, skip_serializing_if = "Option::is_none")]
7278 pub access: Option<AllowDenyRequirement>,
7279 #[serde(default, skip_serializing_if = "Option::is_none")]
7280 pub downloads: Option<AllowDenyRequirement>,
7281 #[serde(default, skip_serializing_if = "Option::is_none")]
7282 pub full_cdp_access: Option<AllowDenyRequirement>,
7283 #[serde(default, skip_serializing_if = "Option::is_none")]
7284 pub uploads: Option<AllowDenyRequirement>,
7285}
7286
7287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7289pub struct BrowserUseConfig {
7290 #[serde(default, skip_serializing_if = "Option::is_none")]
7291 pub allow_history_access: Option<bool>,
7292 #[serde(default, skip_serializing_if = "Option::is_none")]
7293 pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
7294 #[serde(default, skip_serializing_if = "Option::is_none")]
7295 pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
7296}
7297
7298#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7300pub struct ComputerUseConfig {
7301 #[serde(default, skip_serializing_if = "Option::is_none")]
7302 pub default_app_access: Option<AllowDenyRequirement>,
7303 #[serde(default, skip_serializing_if = "Option::is_none")]
7304 pub macos: Option<ComputerUseMacosConfig>,
7305 #[serde(default, skip_serializing_if = "Option::is_none")]
7306 pub windows: Option<ComputerUseWindowsConfig>,
7307}
7308
7309#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7310pub struct ComputerUseMacosConfig {
7311 #[serde(default, skip_serializing_if = "Option::is_none")]
7312 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7313}
7314
7315#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7316pub struct ComputerUseWindowsConfig {
7317 #[serde(default, skip_serializing_if = "Option::is_none")]
7318 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7319 #[serde(default, skip_serializing_if = "Option::is_none")]
7320 pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
7321}
7322
7323#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7324pub struct ComputerUseWindowsExeConfig {
7325 pub access: AllowDenyRequirement,
7326 #[serde(default, skip_serializing_if = "Option::is_none")]
7327 pub binary_name: Option<String>,
7328 #[serde(default)]
7329 pub product_name: String,
7330 #[serde(default)]
7331 pub publisher_name: String,
7332}
7333
7334#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7336#[serde(rename_all = "camelCase")]
7337pub struct ComputerUseMacosRequirements {
7338 #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
7339 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7340}
7341
7342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7343#[serde(rename_all = "camelCase")]
7344pub struct ComputerUseWindowsRequirements {
7345 #[serde(default, skip_serializing_if = "Option::is_none")]
7346 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7347 #[serde(default, skip_serializing_if = "Option::is_none")]
7348 pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
7349}
7350
7351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7352#[serde(rename_all = "camelCase")]
7353pub struct ComputerUseWindowsExeRequirement {
7354 pub access: AllowDenyRequirement,
7355 #[serde(
7356 rename = "binaryName",
7357 default,
7358 skip_serializing_if = "Option::is_none"
7359 )]
7360 pub binary_name: Option<String>,
7361 #[serde(rename = "productName", default)]
7362 pub product_name: String,
7363 #[serde(rename = "publisherName", default)]
7364 pub publisher_name: String,
7365}
7366
7367#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7368pub enum SandboxMode {
7369 #[serde(rename = "read-only")]
7370 Read_only,
7371 #[serde(rename = "workspace-write")]
7372 Workspace_write,
7373 #[serde(rename = "danger-full-access")]
7374 Danger_full_access,
7375}
7376
7377#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7378#[serde(tag = "type", rename_all = "camelCase")]
7379pub enum SandboxPolicy {
7380 #[serde(rename = "dangerFullAccess")]
7381 DangerFullAccess,
7382 #[serde(rename = "readOnly")]
7383 ReadOnly {
7384 #[serde(
7385 rename = "networkAccess",
7386 default,
7387 skip_serializing_if = "Option::is_none"
7388 )]
7389 network_access: Option<bool>,
7390 },
7391 #[serde(rename = "externalSandbox")]
7392 ExternalSandbox {
7393 #[serde(
7394 rename = "networkAccess",
7395 default,
7396 skip_serializing_if = "Option::is_none"
7397 )]
7398 network_access: Option<Value>,
7399 },
7400 #[serde(rename = "workspaceWrite")]
7401 WorkspaceWrite {
7402 #[serde(
7403 rename = "excludeSlashTmp",
7404 default,
7405 skip_serializing_if = "Option::is_none"
7406 )]
7407 exclude_slash_tmp: Option<bool>,
7408 #[serde(
7409 rename = "excludeTmpdirEnvVar",
7410 default,
7411 skip_serializing_if = "Option::is_none"
7412 )]
7413 exclude_tmpdir_env_var: Option<bool>,
7414 #[serde(
7415 rename = "networkAccess",
7416 default,
7417 skip_serializing_if = "Option::is_none"
7418 )]
7419 network_access: Option<bool>,
7420 #[serde(
7421 rename = "writableRoots",
7422 default,
7423 skip_serializing_if = "Option::is_none"
7424 )]
7425 writable_roots: Option<Vec<AbsolutePathBuf>>,
7426 },
7427}
7428
7429#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7430#[serde(rename_all = "snake_case")]
7431pub struct SandboxWorkspaceWrite {
7432 #[serde(default, skip_serializing_if = "Option::is_none")]
7433 pub exclude_slash_tmp: Option<bool>,
7434 #[serde(default, skip_serializing_if = "Option::is_none")]
7435 pub exclude_tmpdir_env_var: Option<bool>,
7436 #[serde(default, skip_serializing_if = "Option::is_none")]
7437 pub network_access: Option<bool>,
7438 #[serde(default, skip_serializing_if = "Option::is_none")]
7439 pub writable_roots: Option<Vec<String>>,
7440}
7441
7442#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7443#[serde(tag = "type", rename_all = "camelCase")]
7444pub enum ScheduledTaskSchedule {
7445 Hourly {
7446 #[serde(default, skip_serializing_if = "Option::is_none")]
7447 days: Option<Vec<ScheduledTaskWeekday>>,
7448 #[serde(rename = "intervalHours")]
7449 interval_hours: i64,
7450 },
7451 Daily {
7452 time: String,
7453 },
7454 Weekdays {
7455 time: String,
7456 },
7457 Weekly {
7458 days: Vec<ScheduledTaskWeekday>,
7459 time: String,
7460 },
7461}
7462
7463#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7464#[serde(rename_all = "camelCase")]
7465pub struct ScheduledTaskSummary {
7466 #[serde(default)]
7467 pub key: String,
7468 #[serde(default)]
7469 pub name: String,
7470 #[serde(default)]
7471 pub prompt: String,
7472 #[serde()]
7473 pub schedule: ScheduledTaskSchedule,
7474}
7475
7476#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7477pub enum ScheduledTaskWeekday {
7478 #[serde(rename = "MO")]
7479 MO,
7480 #[serde(rename = "TU")]
7481 TU,
7482 #[serde(rename = "WE")]
7483 WE,
7484 #[serde(rename = "TH")]
7485 TH,
7486 #[serde(rename = "FR")]
7487 FR,
7488 #[serde(rename = "SA")]
7489 SA,
7490 #[serde(rename = "SU")]
7491 SU,
7492}
7493
7494#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7495#[serde(rename_all = "camelCase")]
7496pub struct SendAddCreditsNudgeEmailParams {
7497 #[serde(rename = "creditType")]
7498 pub credit_type: AddCreditsNudgeCreditType,
7499}
7500
7501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7502#[serde(rename_all = "camelCase")]
7503pub struct SendAddCreditsNudgeEmailResponse {
7504 #[serde()]
7505 pub status: AddCreditsNudgeEmailStatus,
7506}
7507
7508#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7509#[serde(rename_all = "camelCase")]
7510pub struct ServerRequestResolvedNotification {
7511 #[serde(rename = "requestId")]
7512 pub request_id: RequestId,
7513 #[serde(rename = "threadId", default)]
7514 pub thread_id: String,
7515}
7516
7517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7518#[serde(rename_all = "camelCase")]
7519pub struct SessionMigration {
7520 #[serde(default)]
7521 pub cwd: String,
7522 #[serde(default)]
7523 pub path: String,
7524 #[serde(default, skip_serializing_if = "Option::is_none")]
7525 pub title: Option<String>,
7526}
7527
7528#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7529pub enum SessionSource {
7530 #[serde(rename = "cli")]
7531 Cli,
7532 #[serde(rename = "vscode")]
7533 Vscode,
7534 #[serde(rename = "exec")]
7535 Exec,
7536 #[serde(rename = "appServer")]
7537 AppServer,
7538 #[serde(rename = "unknown")]
7539 Unknown,
7540 #[serde(rename = "custom")]
7541 Custom(String),
7542 #[serde(rename = "subAgent")]
7543 SubAgent(SubAgentSource),
7544}
7545
7546#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7547#[serde(rename_all = "camelCase")]
7548pub struct Settings {
7549 #[serde(default, skip_serializing_if = "Option::is_none")]
7550 pub developer_instructions: Option<String>,
7551 #[serde(default)]
7552 pub model: String,
7553 #[serde(default, skip_serializing_if = "Option::is_none")]
7554 pub reasoning_effort: Option<ReasoningEffort>,
7555}
7556
7557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7558#[serde(rename_all = "camelCase")]
7559pub struct SkillDependencies {
7560 #[serde(default)]
7561 pub tools: Vec<SkillToolDependency>,
7562}
7563
7564#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7565#[serde(rename_all = "camelCase")]
7566pub struct SkillErrorInfo {
7567 #[serde(default)]
7568 pub message: String,
7569 #[serde(default)]
7570 pub path: String,
7571}
7572
7573#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7574#[serde(rename_all = "camelCase")]
7575pub struct SkillInterface {
7576 #[serde(
7577 rename = "brandColor",
7578 default,
7579 skip_serializing_if = "Option::is_none"
7580 )]
7581 pub brand_color: Option<String>,
7582 #[serde(
7583 rename = "defaultPrompt",
7584 default,
7585 skip_serializing_if = "Option::is_none"
7586 )]
7587 pub default_prompt: Option<String>,
7588 #[serde(
7589 rename = "displayName",
7590 default,
7591 skip_serializing_if = "Option::is_none"
7592 )]
7593 pub display_name: Option<String>,
7594 #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
7595 pub icon_large: Option<AbsolutePathBuf>,
7596 #[serde(
7597 rename = "iconLargeUrl",
7598 default,
7599 skip_serializing_if = "Option::is_none"
7600 )]
7601 pub icon_large_url: Option<String>,
7602 #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
7603 pub icon_small: Option<AbsolutePathBuf>,
7604 #[serde(
7605 rename = "iconSmallUrl",
7606 default,
7607 skip_serializing_if = "Option::is_none"
7608 )]
7609 pub icon_small_url: Option<String>,
7610 #[serde(
7611 rename = "shortDescription",
7612 default,
7613 skip_serializing_if = "Option::is_none"
7614 )]
7615 pub short_description: Option<String>,
7616}
7617
7618#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7619#[serde(rename_all = "camelCase")]
7620pub struct SkillMetadata {
7621 #[serde(default, skip_serializing_if = "Option::is_none")]
7622 pub dependencies: Option<SkillDependencies>,
7623 #[serde(default)]
7624 pub description: String,
7625 #[serde(default)]
7626 pub enabled: bool,
7627 #[serde(default, skip_serializing_if = "Option::is_none")]
7628 pub interface: Option<SkillInterface>,
7629 #[serde(default)]
7630 pub name: String,
7631 #[serde()]
7632 pub path: LegacyAppPathString,
7633 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7634 pub plugin_id: Option<String>,
7635 #[serde()]
7636 pub scope: SkillScope,
7637 #[serde(
7638 rename = "shortDescription",
7639 default,
7640 skip_serializing_if = "Option::is_none"
7641 )]
7642 pub short_description: Option<String>,
7643}
7644
7645#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7646#[serde(rename_all = "camelCase")]
7647pub struct SkillMigration {
7648 #[serde(default)]
7649 pub name: String,
7650}
7651
7652#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7653pub enum SkillScope {
7654 #[serde(rename = "user")]
7655 User,
7656 #[serde(rename = "repo")]
7657 Repo,
7658 #[serde(rename = "system")]
7659 System,
7660 #[serde(rename = "admin")]
7661 Admin,
7662}
7663
7664#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7665#[serde(rename_all = "camelCase")]
7666pub struct SkillSummary {
7667 #[serde(default)]
7668 pub description: String,
7669 #[serde(default)]
7670 pub enabled: bool,
7671 #[serde(default, skip_serializing_if = "Option::is_none")]
7672 pub interface: Option<SkillInterface>,
7673 #[serde(default)]
7674 pub name: String,
7675 #[serde(default, skip_serializing_if = "Option::is_none")]
7676 pub path: Option<LegacyAppPathString>,
7677 #[serde(
7678 rename = "shortDescription",
7679 default,
7680 skip_serializing_if = "Option::is_none"
7681 )]
7682 pub short_description: Option<String>,
7683}
7684
7685#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7686#[serde(rename_all = "camelCase")]
7687pub struct SkillToolDependency {
7688 #[serde(default, skip_serializing_if = "Option::is_none")]
7689 pub command: Option<String>,
7690 #[serde(default, skip_serializing_if = "Option::is_none")]
7691 pub description: Option<String>,
7692 #[serde(default, skip_serializing_if = "Option::is_none")]
7693 pub transport: Option<String>,
7694 #[serde(rename = "type", default)]
7695 pub type_: String,
7696 #[serde(default, skip_serializing_if = "Option::is_none")]
7697 pub url: Option<String>,
7698 #[serde(default)]
7699 pub value: String,
7700}
7701
7702#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7703#[serde(rename_all = "camelCase")]
7704pub struct SkillsChangedNotification {
7705 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7706 pub extra: serde_json::Map<String, Value>,
7707}
7708
7709#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7710#[serde(rename_all = "camelCase")]
7711pub struct SkillsConfigWriteParams {
7712 #[serde(default)]
7713 pub enabled: bool,
7714 #[serde(default, skip_serializing_if = "Option::is_none")]
7715 pub name: Option<String>,
7716 #[serde(default, skip_serializing_if = "Option::is_none")]
7717 pub path: Option<AbsolutePathBuf>,
7718}
7719
7720#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7721#[serde(rename_all = "camelCase")]
7722pub struct SkillsConfigWriteResponse {
7723 #[serde(rename = "effectiveEnabled", default)]
7724 pub effective_enabled: bool,
7725}
7726
7727#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7728#[serde(rename_all = "camelCase")]
7729pub struct SkillsExtraRootsSetParams {
7730 #[serde(rename = "extraRoots", default)]
7731 pub extra_roots: Vec<AbsolutePathBuf>,
7732}
7733
7734#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7735#[serde(rename_all = "camelCase")]
7736pub struct SkillsExtraRootsSetResponse {
7737 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7738 pub extra: serde_json::Map<String, Value>,
7739}
7740
7741#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7742#[serde(rename_all = "camelCase")]
7743pub struct SkillsListEntry {
7744 #[serde(default)]
7745 pub cwd: String,
7746 #[serde(default)]
7747 pub errors: Vec<SkillErrorInfo>,
7748 #[serde(default)]
7749 pub skills: Vec<SkillMetadata>,
7750}
7751
7752#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7753#[serde(rename_all = "camelCase")]
7754pub struct SkillsListParams {
7755 #[serde(default, skip_serializing_if = "Option::is_none")]
7756 pub cwds: Option<Vec<String>>,
7757 #[serde(
7758 rename = "forceReload",
7759 default,
7760 skip_serializing_if = "Option::is_none"
7761 )]
7762 pub force_reload: Option<bool>,
7763}
7764
7765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7766#[serde(rename_all = "camelCase")]
7767pub struct SkillsListResponse {
7768 #[serde(default)]
7769 pub data: Vec<SkillsListEntry>,
7770}
7771
7772#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7773pub enum SortDirection {
7774 #[serde(rename = "asc")]
7775 Asc,
7776 #[serde(rename = "desc")]
7777 Desc,
7778}
7779
7780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7781#[serde(rename_all = "camelCase")]
7782pub struct SpendControlLimitSnapshot {
7783 #[serde(default)]
7784 pub limit: String,
7785 #[serde(rename = "remainingPercent", default)]
7786 pub remaining_percent: i64,
7787 #[serde(rename = "resetsAt", default)]
7788 pub resets_at: i64,
7789 #[serde(default)]
7790 pub used: String,
7791}
7792
7793#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7794pub enum SubAgentActivityKind {
7795 #[serde(rename = "started")]
7796 Started,
7797 #[serde(rename = "interacted")]
7798 Interacted,
7799 #[serde(rename = "interrupted")]
7800 Interrupted,
7801 #[serde(rename = "completed")]
7802 Completed,
7803}
7804
7805#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7806pub enum SubAgentSource {
7807 #[serde(rename = "review")]
7808 Review,
7809 #[serde(rename = "compact")]
7810 Compact,
7811 #[serde(rename = "memory_consolidation")]
7812 MemoryConsolidation,
7813 #[serde(rename = "thread_spawn")]
7814 ThreadSpawn {
7815 #[serde(default, skip_serializing_if = "Option::is_none")]
7816 agent_nickname: Option<String>,
7817 #[serde(default, skip_serializing_if = "Option::is_none")]
7818 agent_path: Option<AgentPath>,
7819 #[serde(default, skip_serializing_if = "Option::is_none")]
7820 agent_role: Option<String>,
7821 depth: i64,
7822 parent_thread_id: ThreadId,
7823 },
7824 #[serde(rename = "other")]
7825 Other(String),
7826}
7827
7828#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7829#[serde(rename_all = "camelCase")]
7830pub struct SubagentMigration {
7831 #[serde(default)]
7832 pub name: String,
7833}
7834
7835#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7836#[serde(rename_all = "camelCase")]
7837pub struct TerminalInteractionNotification {
7838 #[serde(rename = "itemId", default)]
7839 pub item_id: String,
7840 #[serde(rename = "processId", default)]
7841 pub process_id: String,
7842 #[serde(default)]
7843 pub stdin: String,
7844 #[serde(rename = "threadId", default)]
7845 pub thread_id: String,
7846 #[serde(rename = "turnId", default)]
7847 pub turn_id: String,
7848}
7849
7850#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7851#[serde(rename_all = "camelCase")]
7852pub struct TextElement {
7853 #[serde(rename = "byteRange", default)]
7854 pub byte_range: Value,
7855 #[serde(default, skip_serializing_if = "Option::is_none")]
7856 pub placeholder: Option<String>,
7857}
7858
7859#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7860#[serde(rename_all = "camelCase")]
7861pub struct TextPosition {
7862 #[serde(default)]
7863 pub column: i64,
7864 #[serde(default)]
7865 pub line: i64,
7866}
7867
7868#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7869#[serde(rename_all = "camelCase")]
7870pub struct TextRange {
7871 #[serde()]
7872 pub end: TextPosition,
7873 #[serde()]
7874 pub start: TextPosition,
7875}
7876
7877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7878#[serde(rename_all = "camelCase")]
7879pub struct Thread {
7880 #[serde(
7881 rename = "agentNickname",
7882 default,
7883 skip_serializing_if = "Option::is_none"
7884 )]
7885 pub agent_nickname: Option<String>,
7886 #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
7887 pub agent_role: Option<String>,
7888 #[serde(rename = "cliVersion", default)]
7889 pub cli_version: String,
7890 #[serde(rename = "createdAt", default)]
7891 pub created_at: i64,
7892 #[serde(default)]
7893 pub cwd: Value,
7894 #[serde(default)]
7895 pub ephemeral: bool,
7896 #[serde(
7897 rename = "forkedFromId",
7898 default,
7899 skip_serializing_if = "Option::is_none"
7900 )]
7901 pub forked_from_id: Option<String>,
7902 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
7903 pub git_info: Option<GitInfo>,
7904 #[serde(
7907 rename = "historyMode",
7908 default,
7909 skip_serializing_if = "Option::is_none"
7910 )]
7911 pub history_mode: Option<ThreadHistoryMode>,
7912 #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
7915 pub project_id: Option<String>,
7916 #[serde(default)]
7917 pub id: String,
7918 #[serde(default, skip_serializing_if = "Option::is_none")]
7921 pub model: Option<String>,
7922 #[serde(rename = "modelProvider", default)]
7923 pub model_provider: String,
7924 #[serde(default, skip_serializing_if = "Option::is_none")]
7925 pub name: Option<String>,
7926 #[serde(default, skip_serializing_if = "Option::is_none")]
7930 pub originator: Option<String>,
7931 #[serde(
7932 rename = "parentThreadId",
7933 default,
7934 skip_serializing_if = "Option::is_none"
7935 )]
7936 pub parent_thread_id: Option<String>,
7937 #[serde(default, skip_serializing_if = "Option::is_none")]
7938 pub path: Option<String>,
7939 #[serde(default)]
7940 pub preview: String,
7941 #[serde(
7945 rename = "reasoningEffort",
7946 default,
7947 skip_serializing_if = "Option::is_none"
7948 )]
7949 pub reasoning_effort: Option<ReasoningEffort>,
7950 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7951 pub recency_at: Option<i64>,
7952 #[serde(default, skip_serializing_if = "Option::is_none")]
7953 pub section: Option<ThreadSection>,
7954 #[serde(
7955 rename = "sectionEnteredAt",
7956 default,
7957 skip_serializing_if = "Option::is_none"
7958 )]
7959 pub section_entered_at: Option<i64>,
7960 #[serde(rename = "sessionId", default)]
7961 pub session_id: String,
7962 #[serde(default)]
7963 pub source: Value,
7964 #[serde(default)]
7965 pub status: Value,
7966 #[serde(
7967 rename = "threadSource",
7968 default,
7969 skip_serializing_if = "Option::is_none"
7970 )]
7971 pub thread_source: Option<ThreadSource>,
7972 #[serde(default)]
7973 pub turns: Vec<Turn>,
7974 #[serde(rename = "updatedAt", default)]
7975 pub updated_at: i64,
7976}
7977
7978#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7979pub enum ThreadActiveFlag {
7980 #[serde(rename = "waitingOnApproval")]
7981 WaitingOnApproval,
7982 #[serde(rename = "waitingOnUserInput")]
7983 WaitingOnUserInput,
7984}
7985
7986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7987#[serde(rename_all = "camelCase")]
7988pub struct ThreadApproveGuardianDeniedActionParams {
7989 #[serde(default)]
7990 pub event: Value,
7991 #[serde(rename = "threadId", default)]
7992 pub thread_id: String,
7993}
7994
7995#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7996#[serde(rename_all = "camelCase")]
7997pub struct ThreadApproveGuardianDeniedActionResponse {
7998 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7999 pub extra: serde_json::Map<String, Value>,
8000}
8001
8002#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8003#[serde(rename_all = "camelCase")]
8004pub struct ThreadArchiveParams {
8005 #[serde(rename = "threadId", default)]
8006 pub thread_id: String,
8007}
8008
8009#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8010#[serde(rename_all = "camelCase")]
8011pub struct ThreadArchiveResponse {
8012 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8013 pub extra: serde_json::Map<String, Value>,
8014}
8015
8016#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8017#[serde(rename_all = "camelCase")]
8018pub struct ThreadArchivedNotification {
8019 #[serde(rename = "threadId", default)]
8020 pub thread_id: String,
8021}
8022
8023#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8025#[serde(rename_all = "camelCase")]
8026pub struct ThreadAttachment {
8027 #[serde(rename = "attachmentType", default)]
8028 pub attachment_type: String,
8029 #[serde(rename = "createdAt", default)]
8030 pub created_at: i64,
8031 #[serde(default)]
8032 pub id: String,
8033 #[serde(rename = "identityKey", default)]
8034 pub identity_key: String,
8035 #[serde(default)]
8036 pub payload: Value,
8037}
8038
8039#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8041pub enum ThreadAttachmentAddOutcome {
8042 #[serde(rename = "created")]
8043 Created,
8044 #[serde(rename = "existing")]
8045 Existing,
8046}
8047
8048#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8050#[serde(rename_all = "camelCase")]
8051pub struct ThreadAttachmentAddParams {
8052 #[serde(rename = "attachmentType", default)]
8053 pub attachment_type: String,
8054 #[serde(rename = "identityKey", default)]
8055 pub identity_key: String,
8056 #[serde(default)]
8057 pub payload: Value,
8058 #[serde(rename = "threadId", default)]
8059 pub thread_id: String,
8060}
8061
8062#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8064#[serde(rename_all = "camelCase")]
8065pub struct ThreadAttachmentAddResponse {
8066 pub attachment: ThreadAttachment,
8067 pub outcome: ThreadAttachmentAddOutcome,
8068}
8069
8070#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8072#[serde(rename_all = "camelCase")]
8073pub struct ThreadAttachmentListParams {
8074 #[serde(default, skip_serializing_if = "Option::is_none")]
8075 pub cursor: Option<String>,
8076 #[serde(default, skip_serializing_if = "Option::is_none")]
8077 pub limit: Option<i64>,
8078 #[serde(rename = "threadId", default)]
8079 pub thread_id: String,
8080}
8081
8082#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8084#[serde(rename_all = "camelCase")]
8085pub struct ThreadAttachmentListResponse {
8086 #[serde(default)]
8087 pub data: Vec<ThreadAttachment>,
8088 #[serde(
8089 rename = "nextCursor",
8090 default,
8091 skip_serializing_if = "Option::is_none"
8092 )]
8093 pub next_cursor: Option<String>,
8094}
8095
8096#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8098pub enum ThreadAttachmentOperation {
8099 #[serde(rename = "created")]
8100 Created,
8101 #[serde(rename = "deleted")]
8102 Deleted,
8103}
8104
8105#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8107#[serde(rename_all = "camelCase")]
8108pub struct ThreadAttachmentOwner {
8109 #[serde(default)]
8111 pub archived: bool,
8112 #[serde(rename = "threadId", default)]
8113 pub thread_id: String,
8114}
8115
8116#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8118#[serde(rename_all = "camelCase")]
8119pub struct ThreadAttachmentOwnerListParams {
8120 #[serde(default, skip_serializing_if = "Option::is_none")]
8122 pub archived: Option<bool>,
8123 #[serde(rename = "attachmentType", default)]
8124 pub attachment_type: String,
8125 #[serde(default, skip_serializing_if = "Option::is_none")]
8126 pub cursor: Option<String>,
8127 #[serde(rename = "identityKey", default)]
8128 pub identity_key: String,
8129 #[serde(default, skip_serializing_if = "Option::is_none")]
8130 pub limit: Option<i64>,
8131}
8132
8133#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8135#[serde(rename_all = "camelCase")]
8136pub struct ThreadAttachmentOwnerListResponse {
8137 #[serde(default)]
8138 pub data: Vec<ThreadAttachmentOwner>,
8139 #[serde(
8140 rename = "nextCursor",
8141 default,
8142 skip_serializing_if = "Option::is_none"
8143 )]
8144 pub next_cursor: Option<String>,
8145}
8146
8147#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8149#[serde(rename_all = "camelCase")]
8150pub struct ThreadAttachmentRemoveParams {
8151 #[serde(rename = "attachmentType", default)]
8152 pub attachment_type: String,
8153 #[serde(rename = "identityKey", default)]
8154 pub identity_key: String,
8155 #[serde(rename = "threadId", default)]
8156 pub thread_id: String,
8157}
8158
8159#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8161#[serde(rename_all = "camelCase")]
8162pub struct ThreadAttachmentRemoveResponse {
8163 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8164 pub extra: serde_json::Map<String, Value>,
8165}
8166
8167#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8169#[serde(rename_all = "camelCase")]
8170pub struct ThreadAttachmentUpdatedNotification {
8171 #[serde(rename = "attachmentId", default)]
8172 pub attachment_id: String,
8173 #[serde(rename = "attachmentType", default)]
8174 pub attachment_type: String,
8175 #[serde(rename = "identityKey", default)]
8176 pub identity_key: String,
8177 pub operation: ThreadAttachmentOperation,
8178 #[serde(rename = "threadId", default)]
8179 pub thread_id: String,
8180}
8181
8182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8183#[serde(rename_all = "camelCase")]
8184pub struct ThreadClosedNotification {
8185 #[serde(rename = "threadId", default)]
8186 pub thread_id: String,
8187}
8188
8189#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8190#[serde(rename_all = "camelCase")]
8191pub struct ThreadCompactStartParams {
8192 #[serde(rename = "threadId", default)]
8193 pub thread_id: String,
8194}
8195
8196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8197#[serde(rename_all = "camelCase")]
8198pub struct ThreadCompactStartResponse {
8199 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8200 pub extra: serde_json::Map<String, Value>,
8201}
8202
8203#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8204#[serde(rename_all = "camelCase")]
8205pub struct ThreadDeleteParams {
8206 #[serde(rename = "threadId", default)]
8207 pub thread_id: String,
8208}
8209
8210#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8211#[serde(rename_all = "camelCase")]
8212pub struct ThreadDeleteResponse {
8213 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8214 pub extra: serde_json::Map<String, Value>,
8215}
8216
8217#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8218#[serde(rename_all = "camelCase")]
8219pub struct ThreadDeletedNotification {
8220 #[serde(rename = "threadId", default)]
8221 pub thread_id: String,
8222}
8223
8224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8225#[serde(rename_all = "camelCase")]
8226pub struct ThreadForkParams {
8227 #[serde(
8228 rename = "approvalPolicy",
8229 default,
8230 skip_serializing_if = "Option::is_none"
8231 )]
8232 pub approval_policy: Option<AskForApproval>,
8233 #[serde(
8234 rename = "approvalsReviewer",
8235 default,
8236 skip_serializing_if = "Option::is_none"
8237 )]
8238 pub approvals_reviewer: Option<ApprovalsReviewer>,
8239 #[serde(
8240 rename = "baseInstructions",
8241 default,
8242 skip_serializing_if = "Option::is_none"
8243 )]
8244 pub base_instructions: Option<String>,
8245 #[serde(default, skip_serializing_if = "Option::is_none")]
8246 pub config: Option<Value>,
8247 #[serde(default, skip_serializing_if = "Option::is_none")]
8248 pub cwd: Option<String>,
8249 #[serde(
8250 rename = "developerInstructions",
8251 default,
8252 skip_serializing_if = "Option::is_none"
8253 )]
8254 pub developer_instructions: Option<String>,
8255 #[serde(default, skip_serializing_if = "Option::is_none")]
8256 pub ephemeral: Option<bool>,
8257 #[serde(
8258 rename = "excludeTurns",
8259 default,
8260 skip_serializing_if = "Option::is_none"
8261 )]
8262 pub exclude_turns: Option<bool>,
8263 #[serde(
8264 rename = "lastTurnId",
8265 default,
8266 skip_serializing_if = "Option::is_none"
8267 )]
8268 pub last_turn_id: Option<String>,
8269 #[serde(default, skip_serializing_if = "Option::is_none")]
8270 pub model: Option<String>,
8271 #[serde(
8272 rename = "modelProvider",
8273 default,
8274 skip_serializing_if = "Option::is_none"
8275 )]
8276 pub model_provider: Option<String>,
8277 #[serde(default, skip_serializing_if = "Option::is_none")]
8278 pub sandbox: Option<SandboxMode>,
8279 #[serde(
8280 rename = "serviceTier",
8281 default,
8282 skip_serializing_if = "Option::is_none"
8283 )]
8284 pub service_tier: Option<String>,
8285 #[serde(rename = "threadId", default)]
8286 pub thread_id: String,
8287 #[serde(
8288 rename = "threadSource",
8289 default,
8290 skip_serializing_if = "Option::is_none"
8291 )]
8292 pub thread_source: Option<ThreadSource>,
8293}
8294
8295#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8296#[serde(rename_all = "camelCase")]
8297pub struct ThreadForkResponse {
8298 #[serde(rename = "approvalPolicy")]
8299 pub approval_policy: AskForApproval,
8300 #[serde(rename = "approvalsReviewer", default)]
8301 pub approvals_reviewer: Value,
8302 #[serde()]
8303 pub cwd: AbsolutePathBuf,
8304 #[serde(rename = "disabledPluginIds", default)]
8307 pub disabled_plugin_ids: Vec<String>,
8308 #[serde(
8309 rename = "instructionSources",
8310 default,
8311 skip_serializing_if = "Option::is_none"
8312 )]
8313 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8314 #[serde(default)]
8315 pub model: String,
8316 #[serde(rename = "modelProvider", default)]
8317 pub model_provider: String,
8318 #[serde(
8319 rename = "reasoningEffort",
8320 default,
8321 skip_serializing_if = "Option::is_none"
8322 )]
8323 pub reasoning_effort: Option<ReasoningEffort>,
8324 #[serde(default)]
8325 pub sandbox: Value,
8326 #[serde(
8327 rename = "serviceTier",
8328 default,
8329 skip_serializing_if = "Option::is_none"
8330 )]
8331 pub service_tier: Option<String>,
8332 #[serde()]
8333 pub thread: Thread,
8334}
8335
8336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8337#[serde(rename_all = "camelCase")]
8338pub struct ThreadGoal {
8339 #[serde(rename = "createdAt", default)]
8340 pub created_at: i64,
8341 #[serde(default)]
8342 pub objective: String,
8343 #[serde()]
8344 pub status: ThreadGoalStatus,
8345 #[serde(rename = "threadId", default)]
8346 pub thread_id: String,
8347 #[serde(rename = "timeUsedSeconds", default)]
8348 pub time_used_seconds: i64,
8349 #[serde(
8350 rename = "tokenBudget",
8351 default,
8352 skip_serializing_if = "Option::is_none"
8353 )]
8354 pub token_budget: Option<i64>,
8355 #[serde(rename = "tokensUsed", default)]
8356 pub tokens_used: i64,
8357 #[serde(rename = "updatedAt", default)]
8358 pub updated_at: i64,
8359}
8360
8361#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8362#[serde(rename_all = "camelCase")]
8363pub struct ThreadGoalClearParams {
8364 #[serde(default, skip_serializing_if = "Option::is_none")]
8366 pub origin: Option<ThreadGoalMutationOrigin>,
8367 #[serde(rename = "threadId", default)]
8368 pub thread_id: String,
8369}
8370
8371#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8372#[serde(rename_all = "camelCase")]
8373pub struct ThreadGoalClearResponse {
8374 #[serde(default)]
8375 pub cleared: bool,
8376}
8377
8378#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8379#[serde(rename_all = "camelCase")]
8380pub struct ThreadGoalClearedNotification {
8381 #[serde(rename = "threadId", default)]
8382 pub thread_id: String,
8383}
8384
8385#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8386#[serde(rename_all = "camelCase")]
8387pub struct ThreadGoalGetParams {
8388 #[serde(rename = "threadId", default)]
8389 pub thread_id: String,
8390}
8391
8392#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8393#[serde(rename_all = "camelCase")]
8394pub struct ThreadGoalGetResponse {
8395 #[serde(default, skip_serializing_if = "Option::is_none")]
8396 pub goal: Option<ThreadGoal>,
8397}
8398
8399#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8401pub enum ThreadGoalMutationOrigin {
8402 #[serde(rename = "user")]
8403 User,
8404 #[serde(rename = "automatic")]
8405 Automatic,
8406}
8407
8408#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8409#[serde(rename_all = "camelCase")]
8410pub struct ThreadGoalSetParams {
8411 #[serde(default, skip_serializing_if = "Option::is_none")]
8412 pub objective: Option<String>,
8413 #[serde(default, skip_serializing_if = "Option::is_none")]
8415 pub origin: Option<ThreadGoalMutationOrigin>,
8416 #[serde(default, skip_serializing_if = "Option::is_none")]
8417 pub status: Option<ThreadGoalStatus>,
8418 #[serde(rename = "threadId", default)]
8419 pub thread_id: String,
8420 #[serde(
8421 rename = "tokenBudget",
8422 default,
8423 skip_serializing_if = "Option::is_none"
8424 )]
8425 pub token_budget: Option<i64>,
8426}
8427
8428#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8429#[serde(rename_all = "camelCase")]
8430pub struct ThreadGoalSetResponse {
8431 #[serde()]
8432 pub goal: ThreadGoal,
8433}
8434
8435#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8436pub enum ThreadGoalStatus {
8437 #[serde(rename = "active")]
8438 Active,
8439 #[serde(rename = "paused")]
8440 Paused,
8441 #[serde(rename = "blocked")]
8442 Blocked,
8443 #[serde(rename = "usageLimited")]
8444 UsageLimited,
8445 #[serde(rename = "budgetLimited")]
8446 BudgetLimited,
8447 #[serde(rename = "complete")]
8448 Complete,
8449}
8450
8451#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8452#[serde(rename_all = "camelCase")]
8453pub struct ThreadGoalUpdatedNotification {
8454 #[serde()]
8455 pub goal: ThreadGoal,
8456 #[serde(rename = "threadId", default)]
8457 pub thread_id: String,
8458 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8459 pub turn_id: Option<String>,
8460}
8461
8462#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
8463#[serde(transparent)]
8464pub struct ThreadId(pub String);
8465
8466#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8467#[serde(rename_all = "camelCase")]
8468pub struct ThreadInjectItemsParams {
8469 #[serde(default)]
8470 pub items: Vec<Value>,
8471 #[serde(rename = "threadId", default)]
8472 pub thread_id: String,
8473}
8474
8475#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8476#[serde(rename_all = "camelCase")]
8477pub struct ThreadInjectItemsResponse {
8478 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8479 pub extra: serde_json::Map<String, Value>,
8480}
8481
8482#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8484#[serde(rename_all = "camelCase")]
8485pub struct ThreadItem {
8486 #[serde(flatten)]
8487 pub payload: ThreadItemPayload,
8488 #[serde(
8490 rename = "startedAtMs",
8491 default,
8492 skip_serializing_if = "Option::is_none"
8493 )]
8494 pub started_at_ms: Option<i64>,
8495 #[serde(
8497 rename = "completedAtMs",
8498 default,
8499 skip_serializing_if = "Option::is_none"
8500 )]
8501 pub completed_at_ms: Option<i64>,
8502}
8503
8504impl ThreadItem {
8505 pub fn untimed(payload: ThreadItemPayload) -> Self {
8507 Self {
8508 payload,
8509 started_at_ms: None,
8510 completed_at_ms: None,
8511 }
8512 }
8513}
8514
8515impl From<ThreadItemPayload> for ThreadItem {
8516 fn from(payload: ThreadItemPayload) -> Self {
8517 Self::untimed(payload)
8518 }
8519}
8520
8521#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8523#[serde(tag = "type", rename_all = "camelCase")]
8524pub enum ThreadItemPayload {
8525 #[serde(rename = "userMessage")]
8526 UserMessage {
8527 #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
8528 client_id: Option<String>,
8529 content: Vec<UserInput>,
8530 id: String,
8531 },
8532 #[serde(rename = "hookPrompt")]
8533 HookPrompt {
8534 fragments: Vec<HookPromptFragment>,
8535 id: String,
8536 },
8537 #[serde(rename = "agentMessage")]
8538 AgentMessage {
8539 #[serde(default, skip_serializing_if = "Option::is_none")]
8540 delivery: Option<AgentMessageDelivery>,
8541 id: String,
8542 #[serde(
8543 rename = "memoryCitation",
8544 default,
8545 skip_serializing_if = "Option::is_none"
8546 )]
8547 memory_citation: Option<MemoryCitation>,
8548 #[serde(default, skip_serializing_if = "Option::is_none")]
8549 moderation: Option<AgentMessageModeration>,
8550 #[serde(default, skip_serializing_if = "Option::is_none")]
8551 phase: Option<MessagePhase>,
8552 #[serde(default, skip_serializing_if = "Option::is_none")]
8553 questions: Option<Vec<AsyncUserInputQuestion>>,
8554 text: String,
8555 },
8556 Plan {
8557 id: String,
8558 text: String,
8559 },
8560 Reasoning {
8561 #[serde(default, skip_serializing_if = "Option::is_none")]
8562 content: Option<Vec<String>>,
8563 id: String,
8564 #[serde(default, skip_serializing_if = "Option::is_none")]
8565 summary: Option<Vec<String>>,
8566 },
8567 #[serde(rename = "commandExecution")]
8568 CommandExecution {
8569 #[serde(
8570 rename = "aggregatedOutput",
8571 default,
8572 skip_serializing_if = "Option::is_none"
8573 )]
8574 aggregated_output: Option<String>,
8575 command: String,
8576 #[serde(rename = "commandActions")]
8577 command_actions: Vec<CommandAction>,
8578 cwd: Value,
8579 #[serde(
8580 rename = "durationMs",
8581 default,
8582 skip_serializing_if = "Option::is_none"
8583 )]
8584 duration_ms: Option<i64>,
8585 #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
8586 exit_code: Option<i64>,
8587 id: String,
8588 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8589 plugin_id: Option<String>,
8590 #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
8591 process_id: Option<String>,
8592 #[serde(
8593 rename = "scriptPath",
8594 default,
8595 skip_serializing_if = "Option::is_none"
8596 )]
8597 script_path: Option<String>,
8598 #[serde(default, skip_serializing_if = "Option::is_none")]
8599 source: Option<Value>,
8600 status: CommandExecutionStatus,
8601 },
8602 #[serde(rename = "fileChange")]
8603 FileChange {
8604 changes: Vec<FileUpdateChange>,
8605 id: String,
8606 status: PatchApplyStatus,
8607 },
8608 #[serde(rename = "mcpToolCall")]
8609 McpToolCall {
8610 #[serde(
8611 rename = "appContext",
8612 default,
8613 skip_serializing_if = "Option::is_none"
8614 )]
8615 app_context: Option<McpToolCallAppContext>,
8616 arguments: Value,
8617 #[serde(
8618 rename = "durationMs",
8619 default,
8620 skip_serializing_if = "Option::is_none"
8621 )]
8622 duration_ms: Option<i64>,
8623 #[serde(default, skip_serializing_if = "Option::is_none")]
8624 error: Option<McpToolCallError>,
8625 id: String,
8626 #[serde(
8629 rename = "mcpAppResourceUri",
8630 default,
8631 skip_serializing_if = "Option::is_none"
8632 )]
8633 mcp_app_resource_uri: Option<String>,
8634 #[serde(rename = "mcpAppUi", default, skip_serializing_if = "Option::is_none")]
8637 mcp_app_ui: Option<McpAppUi>,
8638 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8639 plugin_id: Option<String>,
8640 #[serde(
8641 rename = "readOnlyHint",
8642 default,
8643 skip_serializing_if = "Option::is_none"
8644 )]
8645 read_only_hint: Option<bool>,
8646 #[serde(default, skip_serializing_if = "Option::is_none")]
8647 result: Option<McpToolCallResult>,
8648 server: String,
8649 status: McpToolCallStatus,
8650 tool: String,
8651 },
8652 #[serde(rename = "dynamicToolCall")]
8653 DynamicToolCall {
8654 arguments: Value,
8655 #[serde(
8656 rename = "contentItems",
8657 default,
8658 skip_serializing_if = "Option::is_none"
8659 )]
8660 content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
8661 #[serde(
8662 rename = "durationMs",
8663 default,
8664 skip_serializing_if = "Option::is_none"
8665 )]
8666 duration_ms: Option<i64>,
8667 id: String,
8668 #[serde(default, skip_serializing_if = "Option::is_none")]
8669 namespace: Option<String>,
8670 status: DynamicToolCallStatus,
8671 #[serde(default, skip_serializing_if = "Option::is_none")]
8672 success: Option<bool>,
8673 tool: String,
8674 },
8675 #[serde(rename = "collabAgentToolCall")]
8676 CollabAgentToolCall {
8677 #[serde(rename = "agentsStates")]
8678 agents_states: std::collections::BTreeMap<String, CollabAgentState>,
8679 id: String,
8680 #[serde(default, skip_serializing_if = "Option::is_none")]
8681 model: Option<String>,
8682 #[serde(default, skip_serializing_if = "Option::is_none")]
8683 prompt: Option<String>,
8684 #[serde(
8685 rename = "reasoningEffort",
8686 default,
8687 skip_serializing_if = "Option::is_none"
8688 )]
8689 reasoning_effort: Option<ReasoningEffort>,
8690 #[serde(rename = "receiverThreadIds")]
8691 receiver_thread_ids: Vec<String>,
8692 #[serde(rename = "senderThreadId")]
8693 sender_thread_id: String,
8694 status: Value,
8695 tool: Value,
8696 },
8697 #[serde(rename = "subAgentActivity")]
8698 SubAgentActivity {
8699 #[serde(rename = "agentPath")]
8700 agent_path: String,
8701 #[serde(rename = "agentThreadId")]
8702 agent_thread_id: String,
8703 id: String,
8704 kind: SubAgentActivityKind,
8705 #[serde(default, skip_serializing_if = "Option::is_none")]
8708 model: Option<String>,
8709 #[serde(
8711 rename = "reasoningEffort",
8712 default,
8713 skip_serializing_if = "Option::is_none"
8714 )]
8715 reasoning_effort: Option<ReasoningEffort>,
8716 },
8717 #[serde(rename = "webSearch")]
8718 WebSearch {
8719 #[serde(default, skip_serializing_if = "Option::is_none")]
8720 action: Option<WebSearchAction>,
8721 id: String,
8722 query: String,
8723 #[serde(default, skip_serializing_if = "Option::is_none")]
8724 results: Option<Vec<Value>>,
8725 },
8726 #[serde(rename = "imageView")]
8727 ImageView {
8728 id: String,
8729 path: LegacyAppPathString,
8730 },
8731 Sleep {
8732 #[serde(rename = "durationMs")]
8733 duration_ms: i64,
8734 id: String,
8735 },
8736 #[serde(rename = "imageGeneration")]
8737 ImageGeneration {
8738 #[serde(default, skip_serializing_if = "Option::is_none")]
8739 failure: Option<ImageGenerationFailure>,
8740 #[serde(
8742 rename = "generationId",
8743 default,
8744 skip_serializing_if = "Option::is_none"
8745 )]
8746 generation_id: Option<String>,
8747 id: String,
8748 #[serde(flatten)]
8749 image: GeneratedImageRef,
8750 #[serde(
8752 rename = "inputImages",
8753 default,
8754 skip_serializing_if = "Option::is_none"
8755 )]
8756 input_images: Option<Vec<ImageGenerationInputImage>>,
8757 #[serde(
8758 rename = "revisedPrompt",
8759 default,
8760 skip_serializing_if = "Option::is_none"
8761 )]
8762 revised_prompt: Option<String>,
8763 #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
8764 saved_path: Option<AbsolutePathBuf>,
8765 status: String,
8766 #[serde(
8767 rename = "transparentBackground",
8768 default,
8769 skip_serializing_if = "Option::is_none"
8770 )]
8771 transparent_background: Option<bool>,
8772 },
8773 #[serde(rename = "enteredReviewMode")]
8774 EnteredReviewMode {
8775 id: String,
8776 review: String,
8777 },
8778 #[serde(rename = "exitedReviewMode")]
8779 ExitedReviewMode {
8780 id: String,
8781 review: String,
8782 },
8783 #[serde(rename = "contextCompaction")]
8784 ContextCompaction {
8785 id: String,
8786 },
8787 #[serde(rename = "functionCallOutput")]
8788 FunctionCallOutput {
8789 id: String,
8790 name: String,
8791 #[serde(default, skip_serializing_if = "Option::is_none")]
8792 namespace: Option<String>,
8793 output: FunctionCallOutputBody,
8794 },
8795}
8796
8797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8798#[serde(untagged)]
8799pub enum ThreadListCwdFilter {
8800 Variant0(String),
8801 Variant1(Vec<String>),
8802}
8803
8804#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8805#[serde(rename_all = "camelCase")]
8806pub struct ThreadListParams {
8807 #[serde(default, skip_serializing_if = "Option::is_none")]
8808 pub archived: Option<bool>,
8809 #[serde(
8812 rename = "currentAccountOnly",
8813 default,
8814 skip_serializing_if = "Option::is_none"
8815 )]
8816 pub current_account_only: Option<bool>,
8817 #[serde(default, skip_serializing_if = "Option::is_none")]
8818 pub cursor: Option<String>,
8819 #[serde(default, skip_serializing_if = "Option::is_none")]
8820 pub cwd: Option<ThreadListCwdFilter>,
8821 #[serde(
8826 rename = "excludedThreadIds",
8827 default,
8828 skip_serializing_if = "Option::is_none"
8829 )]
8830 pub excluded_thread_ids: Option<Vec<String>>,
8831 #[serde(default, skip_serializing_if = "Option::is_none")]
8832 pub limit: Option<i64>,
8833 #[serde(
8834 rename = "modelProviders",
8835 default,
8836 skip_serializing_if = "Option::is_none"
8837 )]
8838 pub model_providers: Option<Vec<String>>,
8839 #[serde(default, skip_serializing_if = "Option::is_none")]
8843 pub originators: Option<Vec<String>>,
8844 #[serde(
8845 rename = "searchTerm",
8846 default,
8847 skip_serializing_if = "Option::is_none"
8848 )]
8849 pub search_term: Option<String>,
8850 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8851 pub section_id: Option<String>,
8852 #[serde(
8853 rename = "sortDirection",
8854 default,
8855 skip_serializing_if = "Option::is_none"
8856 )]
8857 pub sort_direction: Option<SortDirection>,
8858 #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
8859 pub sort_key: Option<ThreadSortKey>,
8860 #[serde(
8861 rename = "sourceKinds",
8862 default,
8863 skip_serializing_if = "Option::is_none"
8864 )]
8865 pub source_kinds: Option<Vec<ThreadSourceKind>>,
8866 #[serde(
8867 rename = "useStateDbOnly",
8868 default,
8869 skip_serializing_if = "Option::is_none"
8870 )]
8871 pub use_state_db_only: Option<bool>,
8872}
8873
8874#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8875#[serde(rename_all = "camelCase")]
8876pub struct ThreadListResponse {
8877 #[serde(
8878 rename = "backwardsCursor",
8879 default,
8880 skip_serializing_if = "Option::is_none"
8881 )]
8882 pub backwards_cursor: Option<String>,
8883 #[serde(default)]
8884 pub data: Vec<Thread>,
8885 #[serde(
8886 rename = "nextCursor",
8887 default,
8888 skip_serializing_if = "Option::is_none"
8889 )]
8890 pub next_cursor: Option<String>,
8891}
8892
8893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8894#[serde(rename_all = "camelCase")]
8895pub struct ThreadLoadedListParams {
8896 #[serde(default, skip_serializing_if = "Option::is_none")]
8897 pub cursor: Option<String>,
8898 #[serde(default, skip_serializing_if = "Option::is_none")]
8899 pub limit: Option<i64>,
8900}
8901
8902#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8903#[serde(rename_all = "camelCase")]
8904pub struct ThreadLoadedListResponse {
8905 #[serde(default)]
8906 pub data: Vec<String>,
8907 #[serde(
8908 rename = "nextCursor",
8909 default,
8910 skip_serializing_if = "Option::is_none"
8911 )]
8912 pub next_cursor: Option<String>,
8913}
8914
8915#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8916#[serde(rename_all = "camelCase")]
8917pub struct ThreadMetadataGitInfoUpdateParams {
8918 #[serde(default, skip_serializing_if = "Option::is_none")]
8919 pub branch: Option<String>,
8920 #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
8921 pub origin_url: Option<String>,
8922 #[serde(default, skip_serializing_if = "Option::is_none")]
8923 pub sha: Option<String>,
8924}
8925
8926#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8927#[serde(rename_all = "camelCase")]
8928pub struct ThreadMetadataUpdateParams {
8929 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
8930 pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
8931 #[serde(rename = "threadId", default)]
8932 pub thread_id: String,
8933}
8934
8935#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8936#[serde(rename_all = "camelCase")]
8937pub struct ThreadMetadataUpdateResponse {
8938 #[serde()]
8939 pub thread: Thread,
8940}
8941
8942#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8943#[serde(rename_all = "camelCase")]
8944pub struct ThreadNameUpdatedNotification {
8945 #[serde(rename = "threadId", default)]
8946 pub thread_id: String,
8947 #[serde(
8948 rename = "threadName",
8949 default,
8950 skip_serializing_if = "Option::is_none"
8951 )]
8952 pub thread_name: Option<String>,
8953}
8954
8955#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8956#[serde(rename_all = "camelCase")]
8957pub struct ThreadReadParams {
8958 #[serde(
8959 rename = "includeTurns",
8960 default,
8961 skip_serializing_if = "Option::is_none"
8962 )]
8963 pub include_turns: Option<bool>,
8964 #[serde(rename = "threadId", default)]
8965 pub thread_id: String,
8966}
8967
8968#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8969#[serde(rename_all = "camelCase")]
8970pub struct ThreadReadResponse {
8971 #[serde()]
8972 pub thread: Thread,
8973}
8974
8975#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8978#[serde(rename_all = "camelCase")]
8979pub struct ThreadReadState {
8980 #[serde(
8981 rename = "firstUnread",
8982 default,
8983 skip_serializing_if = "Option::is_none"
8984 )]
8985 pub first_unread: Option<ThreadUnreadPosition>,
8986 #[serde(default)]
8987 pub revision: String,
8988}
8989
8990#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8991#[serde(rename_all = "camelCase")]
8992pub struct ThreadReadStateChangedNotification {
8993 #[serde(rename = "readState")]
8994 pub read_state: ThreadReadState,
8995 #[serde(rename = "threadId", default)]
8996 pub thread_id: String,
8997}
8998
8999#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
9001#[serde(rename_all = "camelCase")]
9002pub struct ThreadSectionChangedNotification {
9003 #[serde(rename = "threadId")]
9004 pub thread_id: String,
9005 #[serde(rename = "sectionId")]
9008 pub section_id: Option<String>,
9009}
9010
9011#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9012#[serde(rename_all = "camelCase")]
9013pub struct ThreadRealtimeAudioChunk {
9014 #[serde(default)]
9015 pub data: String,
9016 #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
9017 pub item_id: Option<String>,
9018 #[serde(rename = "numChannels", default)]
9019 pub num_channels: i64,
9020 #[serde(rename = "sampleRate", default)]
9021 pub sample_rate: i64,
9022 #[serde(
9023 rename = "samplesPerChannel",
9024 default,
9025 skip_serializing_if = "Option::is_none"
9026 )]
9027 pub samples_per_channel: Option<i64>,
9028}
9029
9030#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9031#[serde(rename_all = "camelCase")]
9032pub struct ThreadRealtimeClosedNotification {
9033 #[serde(default, skip_serializing_if = "Option::is_none")]
9034 pub reason: Option<String>,
9035 #[serde(rename = "threadId", default)]
9036 pub thread_id: String,
9037}
9038
9039#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9040#[serde(rename_all = "camelCase")]
9041pub struct ThreadRealtimeErrorNotification {
9042 #[serde(default)]
9043 pub message: String,
9044 #[serde(rename = "threadId", default)]
9045 pub thread_id: String,
9046}
9047
9048#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9049#[serde(rename_all = "camelCase")]
9050pub struct ThreadRealtimeItemAddedNotification {
9051 #[serde(default)]
9052 pub item: Value,
9053 #[serde(rename = "threadId", default)]
9054 pub thread_id: String,
9055}
9056
9057#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9058#[serde(rename_all = "camelCase")]
9059pub struct ThreadRealtimeOutputAudioDeltaNotification {
9060 #[serde()]
9061 pub audio: ThreadRealtimeAudioChunk,
9062 #[serde(rename = "threadId", default)]
9063 pub thread_id: String,
9064}
9065
9066#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9067#[serde(rename_all = "camelCase")]
9068pub struct ThreadRealtimeSdpNotification {
9069 #[serde(default)]
9070 pub sdp: String,
9071 #[serde(rename = "threadId", default)]
9072 pub thread_id: String,
9073}
9074
9075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9076#[serde(rename_all = "camelCase")]
9077pub struct ThreadRealtimeStartedNotification {
9078 #[serde(
9079 rename = "realtimeSessionId",
9080 default,
9081 skip_serializing_if = "Option::is_none"
9082 )]
9083 pub realtime_session_id: Option<String>,
9084 #[serde(rename = "threadId", default)]
9085 pub thread_id: String,
9086 #[serde()]
9087 pub version: RealtimeConversationVersion,
9088}
9089
9090#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9091#[serde(rename_all = "camelCase")]
9092pub struct ThreadRealtimeTranscriptDeltaNotification {
9093 #[serde(default)]
9094 pub delta: String,
9095 #[serde(default)]
9096 pub role: String,
9097 #[serde(rename = "threadId", default)]
9098 pub thread_id: String,
9099}
9100
9101#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9102#[serde(rename_all = "camelCase")]
9103pub struct ThreadRealtimeTranscriptDoneNotification {
9104 #[serde(default)]
9105 pub role: String,
9106 #[serde(default)]
9107 pub text: String,
9108 #[serde(rename = "threadId", default)]
9109 pub thread_id: String,
9110}
9111
9112#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9113#[serde(rename_all = "camelCase")]
9114pub struct ThreadResumeParams {
9115 #[serde(
9116 rename = "approvalPolicy",
9117 default,
9118 skip_serializing_if = "Option::is_none"
9119 )]
9120 pub approval_policy: Option<AskForApproval>,
9121 #[serde(
9122 rename = "approvalsReviewer",
9123 default,
9124 skip_serializing_if = "Option::is_none"
9125 )]
9126 pub approvals_reviewer: Option<ApprovalsReviewer>,
9127 #[serde(
9128 rename = "baseInstructions",
9129 default,
9130 skip_serializing_if = "Option::is_none"
9131 )]
9132 pub base_instructions: Option<String>,
9133 #[serde(default, skip_serializing_if = "Option::is_none")]
9134 pub config: Option<Value>,
9135 #[serde(default, skip_serializing_if = "Option::is_none")]
9136 pub cwd: Option<String>,
9137 #[serde(
9138 rename = "developerInstructions",
9139 default,
9140 skip_serializing_if = "Option::is_none"
9141 )]
9142 pub developer_instructions: Option<String>,
9143 #[serde(default, skip_serializing_if = "Option::is_none")]
9144 pub model: Option<String>,
9145 #[serde(
9146 rename = "modelProvider",
9147 default,
9148 skip_serializing_if = "Option::is_none"
9149 )]
9150 pub model_provider: Option<String>,
9151 #[serde(default, skip_serializing_if = "Option::is_none")]
9152 pub personality: Option<Personality>,
9153 #[serde(default, skip_serializing_if = "Option::is_none")]
9154 pub sandbox: Option<SandboxMode>,
9155 #[serde(
9156 rename = "serviceTier",
9157 default,
9158 skip_serializing_if = "Option::is_none"
9159 )]
9160 pub service_tier: Option<String>,
9161 #[serde(rename = "threadId", default)]
9162 pub thread_id: String,
9163 #[serde(
9164 rename = "excludeTurns",
9165 default,
9166 skip_serializing_if = "Option::is_none"
9167 )]
9168 pub exclude_turns: Option<bool>,
9169}
9170
9171#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9172#[serde(rename_all = "camelCase")]
9173pub struct ThreadResumeResponse {
9174 #[serde(rename = "approvalPolicy")]
9175 pub approval_policy: AskForApproval,
9176 #[serde(rename = "approvalsReviewer", default)]
9177 pub approvals_reviewer: Value,
9178 #[serde(
9181 rename = "collaborationMode",
9182 default,
9183 skip_serializing_if = "Option::is_none"
9184 )]
9185 pub collaboration_mode: Option<CollaborationMode>,
9186 #[serde()]
9187 pub cwd: AbsolutePathBuf,
9188 #[serde(rename = "disabledPluginIds", default)]
9191 pub disabled_plugin_ids: Vec<String>,
9192 #[serde(
9193 rename = "instructionSources",
9194 default,
9195 skip_serializing_if = "Option::is_none"
9196 )]
9197 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9198 #[serde(
9201 rename = "itemsBackwardsCursor",
9202 default,
9203 skip_serializing_if = "Option::is_none"
9204 )]
9205 pub items_backwards_cursor: Option<String>,
9206 #[serde(default)]
9207 pub model: String,
9208 #[serde(rename = "modelProvider", default)]
9209 pub model_provider: String,
9210 #[serde(
9211 rename = "reasoningEffort",
9212 default,
9213 skip_serializing_if = "Option::is_none"
9214 )]
9215 pub reasoning_effort: Option<ReasoningEffort>,
9216 #[serde(default)]
9217 pub sandbox: Value,
9218 #[serde(
9219 rename = "serviceTier",
9220 default,
9221 skip_serializing_if = "Option::is_none"
9222 )]
9223 pub service_tier: Option<String>,
9224 #[serde()]
9225 pub thread: Thread,
9226 #[serde(
9229 rename = "turnsBackwardsCursor",
9230 default,
9231 skip_serializing_if = "Option::is_none"
9232 )]
9233 pub turns_backwards_cursor: Option<String>,
9234}
9235
9236#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9238pub enum ThreadHistoryMode {
9239 #[serde(rename = "legacy")]
9240 Legacy,
9241 #[serde(rename = "paginated")]
9242 Paginated,
9243}
9244
9245#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9248#[serde(rename_all = "camelCase")]
9249pub struct ThreadItemEntry {
9250 #[serde(
9253 rename = "completedAtMs",
9254 default,
9255 skip_serializing_if = "Option::is_none"
9256 )]
9257 pub completed_at_ms: Option<i64>,
9258 #[serde()]
9259 pub item: ThreadItem,
9260 #[serde(
9265 rename = "outputDeferred",
9266 default,
9267 skip_serializing_if = "std::ops::Not::not"
9268 )]
9269 pub output_deferred: bool,
9270 #[serde(
9273 rename = "startedAtMs",
9274 default,
9275 skip_serializing_if = "Option::is_none"
9276 )]
9277 pub started_at_ms: Option<i64>,
9278 #[serde(rename = "turnId", default)]
9279 pub turn_id: String,
9280}
9281
9282#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9284#[serde(rename_all = "camelCase")]
9285pub struct ThreadItemsListParams {
9286 #[serde(default, skip_serializing_if = "Option::is_none")]
9292 pub cursor: Option<ThreadItemsListCursor>,
9293 #[serde(
9296 rename = "deferOutput",
9297 default,
9298 skip_serializing_if = "Option::is_none"
9299 )]
9300 pub defer_output: Option<ThreadItemOutputDeferral>,
9301 #[serde(default, skip_serializing_if = "Option::is_none")]
9302 pub limit: Option<u32>,
9303 #[serde(
9304 rename = "sortDirection",
9305 default,
9306 skip_serializing_if = "Option::is_none"
9307 )]
9308 pub sort_direction: Option<SortDirection>,
9309 #[serde(rename = "threadId", default)]
9310 pub thread_id: String,
9311 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
9313 pub turn_id: Option<String>,
9314}
9315
9316#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
9321#[serde(rename_all = "camelCase")]
9322pub struct ThreadItemOutputDeferral {
9323 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9326 pub command_execution: bool,
9327}
9328
9329#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9334#[serde(untagged)]
9335pub enum ThreadItemsListCursor {
9336 Opaque(String),
9337 Anchor(ThreadItemsListAnchor),
9338}
9339
9340#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9343#[serde(tag = "type", rename_all = "camelCase")]
9344pub enum ThreadItemsListAnchor {
9345 Item {
9346 #[serde(rename = "itemId")]
9347 item_id: String,
9348 },
9349}
9350
9351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9353#[serde(rename_all = "camelCase")]
9354pub struct ThreadItemsListResponse {
9355 #[serde(
9356 rename = "backwardsCursor",
9357 default,
9358 skip_serializing_if = "Option::is_none"
9359 )]
9360 pub backwards_cursor: Option<String>,
9361 #[serde(default)]
9362 pub data: Vec<ThreadItemEntry>,
9363 #[serde(
9364 rename = "nextCursor",
9365 default,
9366 skip_serializing_if = "Option::is_none"
9367 )]
9368 pub next_cursor: Option<String>,
9369}
9370
9371#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9375pub struct ThreadRealtimeItem {
9376 #[serde(default)]
9377 pub id: String,
9378 #[serde(rename = "realtimeSessionId", default)]
9379 pub realtime_session_id: String,
9380 #[serde(flatten)]
9381 pub detail: ThreadRealtimeItemDetail,
9382}
9383
9384#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9386#[serde(tag = "type", rename_all = "camelCase")]
9387pub enum ThreadRealtimeItemDetail {
9388 #[serde(rename = "realtimeSessionStarted")]
9389 RealtimeSessionStarted,
9390 #[serde(rename = "transcriptSegment")]
9391 TranscriptSegment {
9392 role: ThreadRealtimeTranscriptRole,
9393 text: String,
9394 },
9395 #[serde(rename = "bemItemPromoted")]
9396 BemItemPromoted {
9397 item_id: String,
9398 presentation: ThreadRealtimeBemItemPresentation,
9399 turn_id: String,
9400 },
9401 #[serde(rename = "realtimeSessionClosed")]
9402 RealtimeSessionClosed {
9403 outcome: ThreadRealtimeSessionOutcome,
9404 },
9405}
9406
9407#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9410#[serde(tag = "type", rename_all = "camelCase")]
9411pub enum ThreadRealtimeBemItemPresentation {
9412 #[serde(rename = "wholeItem")]
9413 WholeItem,
9414 #[serde(rename = "inlineMarkdown")]
9415 InlineMarkdown,
9416 #[serde(rename = "inlineVisualization")]
9417 InlineVisualization { index: u32 },
9418}
9419
9420#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9422#[serde(rename_all = "camelCase")]
9423pub struct ThreadRealtimeItemStartedNotification {
9424 #[serde()]
9425 pub item: ThreadRealtimeItem,
9426 #[serde(rename = "threadId", default)]
9427 pub thread_id: String,
9428}
9429
9430#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9432#[serde(rename_all = "camelCase")]
9433pub struct ThreadRealtimeItemCompletedNotification {
9434 #[serde()]
9435 pub item: ThreadRealtimeItem,
9436 #[serde(rename = "threadId", default)]
9437 pub thread_id: String,
9438}
9439
9440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9443#[serde(rename_all = "camelCase")]
9444pub struct ThreadRealtimeItemTranscriptDeltaNotification {
9445 #[serde(default)]
9446 pub delta: String,
9447 #[serde(rename = "itemId", default)]
9448 pub item_id: String,
9449 #[serde(rename = "threadId", default)]
9450 pub thread_id: String,
9451}
9452
9453#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9455pub enum ThreadRealtimeSessionOutcome {
9456 #[serde(rename = "ended")]
9457 Ended,
9458 #[serde(rename = "failed")]
9459 Failed,
9460}
9461
9462#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9464pub enum ThreadRealtimeTranscriptRole {
9465 #[serde(rename = "user")]
9466 User,
9467 #[serde(rename = "assistant")]
9468 Assistant,
9469}
9470
9471#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9475#[serde(rename_all = "camelCase")]
9476pub struct ThreadRevertParams {
9477 #[serde(rename = "beforeTurnId", default)]
9479 pub before_turn_id: String,
9480 #[serde(rename = "threadId", default)]
9481 pub thread_id: String,
9482}
9483
9484#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9487#[serde(rename_all = "camelCase")]
9488pub struct ThreadRevertResponse {
9489 #[serde(
9490 rename = "itemsBackwardsCursor",
9491 default,
9492 skip_serializing_if = "Option::is_none"
9493 )]
9494 pub items_backwards_cursor: Option<String>,
9495 #[serde()]
9496 pub thread: Thread,
9497 #[serde(
9498 rename = "turnsBackwardsCursor",
9499 default,
9500 skip_serializing_if = "Option::is_none"
9501 )]
9502 pub turns_backwards_cursor: Option<String>,
9503}
9504
9505#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9506#[serde(rename_all = "camelCase")]
9507pub struct ThreadSection {
9508 #[serde(default, skip_serializing_if = "Option::is_none")]
9509 pub appearance: Option<ThreadSectionAppearance>,
9510 #[serde(default)]
9511 pub id: String,
9512 #[serde(default)]
9513 pub name: String,
9514}
9515
9516#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9517#[serde(rename_all = "camelCase")]
9518pub struct ThreadSectionAppearance {
9519 #[serde(default, skip_serializing_if = "Option::is_none")]
9520 pub color: Option<String>,
9521 #[serde(default, skip_serializing_if = "Option::is_none")]
9522 pub icon: Option<String>,
9523}
9524
9525#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9526#[serde(rename_all = "camelCase")]
9527pub struct ThreadSectionCreateParams {
9528 #[serde(default, skip_serializing_if = "Option::is_none")]
9529 pub appearance: Option<ThreadSectionAppearance>,
9530 #[serde(default)]
9531 pub name: String,
9532}
9533
9534#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9535#[serde(rename_all = "camelCase")]
9536pub struct ThreadSectionCreateResponse {
9537 #[serde()]
9538 pub section: ThreadSection,
9539}
9540
9541#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9542#[serde(rename_all = "camelCase")]
9543pub struct ThreadSectionDeleteParams {
9544 #[serde(rename = "sectionId", default)]
9545 pub section_id: String,
9546}
9547
9548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9549#[serde(rename_all = "camelCase")]
9550pub struct ThreadSectionDeleteResponse {
9551 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9552 pub extra: serde_json::Map<String, Value>,
9553}
9554
9555#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9556#[serde(rename_all = "camelCase")]
9557pub struct ThreadSectionListParams {
9558 #[serde(default, skip_serializing_if = "Option::is_none")]
9559 pub cursor: Option<String>,
9560 #[serde(default, skip_serializing_if = "Option::is_none")]
9561 pub limit: Option<i64>,
9562}
9563
9564#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9565#[serde(rename_all = "camelCase")]
9566pub struct ThreadSectionListResponse {
9567 #[serde(default)]
9568 pub data: Vec<ThreadSection>,
9569 #[serde(
9570 rename = "nextCursor",
9571 default,
9572 skip_serializing_if = "Option::is_none"
9573 )]
9574 pub next_cursor: Option<String>,
9575}
9576
9577#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9578#[serde(rename_all = "camelCase")]
9579pub struct ThreadSectionMoveParams {
9580 #[serde(
9581 rename = "beforeThreadId",
9582 default,
9583 skip_serializing_if = "Option::is_none"
9584 )]
9585 pub before_thread_id: Option<String>,
9586 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
9587 pub section_id: Option<String>,
9588 #[serde(rename = "threadId", default)]
9589 pub thread_id: String,
9590}
9591
9592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9593#[serde(rename_all = "camelCase")]
9594pub struct ThreadSectionMoveResponse {
9595 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9596 pub extra: serde_json::Map<String, Value>,
9597}
9598
9599#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9600#[serde(rename_all = "camelCase")]
9601pub struct ThreadSectionUpdateParams {
9602 #[serde(default, skip_serializing_if = "Option::is_none")]
9603 pub appearance: Option<ThreadSectionAppearance>,
9604 #[serde(default)]
9605 pub name: String,
9606 #[serde(rename = "sectionId", default)]
9607 pub section_id: String,
9608}
9609
9610#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9611#[serde(rename_all = "camelCase")]
9612pub struct ThreadSectionUpdateResponse {
9613 #[serde()]
9614 pub section: ThreadSection,
9615}
9616
9617#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9618#[serde(rename_all = "camelCase")]
9619pub struct ThreadSetNameParams {
9620 #[serde(default)]
9621 pub name: String,
9622 #[serde(rename = "threadId", default)]
9623 pub thread_id: String,
9624}
9625
9626#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9627#[serde(rename_all = "camelCase")]
9628pub struct ThreadSetNameResponse {
9629 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9630 pub extra: serde_json::Map<String, Value>,
9631}
9632
9633#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9634#[serde(rename_all = "camelCase")]
9635pub struct ThreadSettings {
9636 #[serde(
9637 rename = "activePermissionProfile",
9638 default,
9639 skip_serializing_if = "Option::is_none"
9640 )]
9641 pub active_permission_profile: Option<ActivePermissionProfile>,
9642 #[serde(rename = "approvalPolicy")]
9643 pub approval_policy: AskForApproval,
9644 #[serde(rename = "approvalsReviewer")]
9645 pub approvals_reviewer: ApprovalsReviewer,
9646 #[serde(rename = "collaborationMode")]
9647 pub collaboration_mode: CollaborationMode,
9648 #[serde()]
9649 pub cwd: AbsolutePathBuf,
9650 #[serde(rename = "disabledPluginIds", default)]
9653 pub disabled_plugin_ids: Vec<String>,
9654 #[serde(default, skip_serializing_if = "Option::is_none")]
9655 pub effort: Option<ReasoningEffort>,
9656 #[serde(default)]
9657 pub model: String,
9658 #[serde(rename = "modelProvider", default)]
9659 pub model_provider: String,
9660 #[serde(default, skip_serializing_if = "Option::is_none")]
9661 pub personality: Option<Personality>,
9662 #[serde(rename = "sandboxPolicy")]
9663 pub sandbox_policy: SandboxPolicy,
9664 #[serde(
9665 rename = "serviceTier",
9666 default,
9667 skip_serializing_if = "Option::is_none"
9668 )]
9669 pub service_tier: Option<String>,
9670 #[serde(default, skip_serializing_if = "Option::is_none")]
9671 pub summary: Option<ReasoningSummary>,
9672}
9673
9674#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9675#[serde(rename_all = "camelCase")]
9676pub struct ThreadSettingsUpdatedNotification {
9677 #[serde(rename = "threadId", default)]
9678 pub thread_id: String,
9679 #[serde(rename = "threadSettings")]
9680 pub thread_settings: ThreadSettings,
9681}
9682
9683#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9684#[serde(rename_all = "camelCase")]
9685pub struct ThreadShellCommandParams {
9686 #[serde(default)]
9687 pub command: String,
9688 #[serde(rename = "threadId", default)]
9689 pub thread_id: String,
9690 #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
9693 pub timeout_ms: Option<i64>,
9694}
9695
9696#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9697#[serde(rename_all = "camelCase")]
9698pub struct ThreadShellCommandResponse {
9699 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9700 pub extra: serde_json::Map<String, Value>,
9701}
9702
9703#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9704pub enum ThreadSortKey {
9705 #[serde(rename = "created_at")]
9706 Created_at,
9707 #[serde(rename = "updated_at")]
9708 Updated_at,
9709 #[serde(rename = "recency_at")]
9710 Recency_at,
9711 #[serde(rename = "section_position")]
9712 Section_position,
9713}
9714
9715#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
9716#[serde(transparent)]
9717pub struct ThreadSource(pub String);
9718
9719#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9720pub enum ThreadSourceKind {
9721 #[serde(rename = "cli")]
9722 Cli,
9723 #[serde(rename = "vscode")]
9724 Vscode,
9725 #[serde(rename = "exec")]
9726 Exec,
9727 #[serde(rename = "appServer")]
9728 AppServer,
9729 #[serde(rename = "subAgent")]
9730 SubAgent,
9731 #[serde(rename = "subAgentReview")]
9732 SubAgentReview,
9733 #[serde(rename = "subAgentCompact")]
9734 SubAgentCompact,
9735 #[serde(rename = "subAgentThreadSpawn")]
9736 SubAgentThreadSpawn,
9737 #[serde(rename = "subAgentOther")]
9738 SubAgentOther,
9739 #[serde(rename = "unknown")]
9740 Unknown,
9741}
9742
9743#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9744#[serde(rename_all = "camelCase")]
9745pub struct ThreadStartParams {
9746 #[serde(
9747 rename = "approvalPolicy",
9748 default,
9749 skip_serializing_if = "Option::is_none"
9750 )]
9751 pub approval_policy: Option<AskForApproval>,
9752 #[serde(
9753 rename = "approvalsReviewer",
9754 default,
9755 skip_serializing_if = "Option::is_none"
9756 )]
9757 pub approvals_reviewer: Option<ApprovalsReviewer>,
9758 #[serde(
9759 rename = "baseInstructions",
9760 default,
9761 skip_serializing_if = "Option::is_none"
9762 )]
9763 pub base_instructions: Option<String>,
9764 #[serde(default, skip_serializing_if = "Option::is_none")]
9765 pub config: Option<Value>,
9766 #[serde(default, skip_serializing_if = "Option::is_none")]
9767 pub cwd: Option<String>,
9768 #[serde(
9769 rename = "developerInstructions",
9770 default,
9771 skip_serializing_if = "Option::is_none"
9772 )]
9773 pub developer_instructions: Option<String>,
9774 #[serde(default, skip_serializing_if = "Option::is_none")]
9775 pub ephemeral: Option<bool>,
9776 #[serde(default, skip_serializing_if = "Option::is_none")]
9777 pub model: Option<String>,
9778 #[serde(
9779 rename = "modelProvider",
9780 default,
9781 skip_serializing_if = "Option::is_none"
9782 )]
9783 pub model_provider: Option<String>,
9784 #[serde(default, skip_serializing_if = "Option::is_none")]
9785 pub personality: Option<Personality>,
9786 #[serde(default, skip_serializing_if = "Option::is_none")]
9787 pub sandbox: Option<SandboxMode>,
9788 #[serde(
9789 rename = "serviceName",
9790 default,
9791 skip_serializing_if = "Option::is_none"
9792 )]
9793 pub service_name: Option<String>,
9794 #[serde(
9795 rename = "serviceTier",
9796 default,
9797 skip_serializing_if = "Option::is_none"
9798 )]
9799 pub service_tier: Option<String>,
9800 #[serde(
9801 rename = "sessionStartSource",
9802 default,
9803 skip_serializing_if = "Option::is_none"
9804 )]
9805 pub session_start_source: Option<ThreadStartSource>,
9806 #[serde(
9807 rename = "threadSource",
9808 default,
9809 skip_serializing_if = "Option::is_none"
9810 )]
9811 pub thread_source: Option<ThreadSource>,
9812}
9813
9814#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9815#[serde(rename_all = "camelCase")]
9816pub struct ThreadStartResponse {
9817 #[serde(rename = "approvalPolicy")]
9818 pub approval_policy: AskForApproval,
9819 #[serde(rename = "approvalsReviewer", default)]
9820 pub approvals_reviewer: Value,
9821 #[serde()]
9822 pub cwd: AbsolutePathBuf,
9823 #[serde(rename = "disabledPluginIds", default)]
9826 pub disabled_plugin_ids: Vec<String>,
9827 #[serde(
9828 rename = "instructionSources",
9829 default,
9830 skip_serializing_if = "Option::is_none"
9831 )]
9832 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9833 #[serde(default)]
9834 pub model: String,
9835 #[serde(rename = "modelProvider", default)]
9836 pub model_provider: String,
9837 #[serde(
9838 rename = "reasoningEffort",
9839 default,
9840 skip_serializing_if = "Option::is_none"
9841 )]
9842 pub reasoning_effort: Option<ReasoningEffort>,
9843 #[serde(default)]
9844 pub sandbox: Value,
9845 #[serde(
9846 rename = "serviceTier",
9847 default,
9848 skip_serializing_if = "Option::is_none"
9849 )]
9850 pub service_tier: Option<String>,
9851 #[serde()]
9852 pub thread: Thread,
9853}
9854
9855#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9856pub enum ThreadStartSource {
9857 #[serde(rename = "startup")]
9858 Startup,
9859 #[serde(rename = "clear")]
9860 Clear,
9861}
9862
9863#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9864#[serde(rename_all = "camelCase")]
9865pub struct ThreadStartedNotification {
9866 #[serde()]
9867 pub thread: Thread,
9868}
9869
9870#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9871#[serde(tag = "type", rename_all = "camelCase")]
9872pub enum ThreadStatus {
9873 #[serde(rename = "notLoaded")]
9874 NotLoaded,
9875 Idle,
9876 #[serde(rename = "systemError")]
9877 SystemError,
9878 Active {
9879 #[serde(rename = "activeFlags")]
9880 active_flags: Vec<ThreadActiveFlag>,
9881 },
9882}
9883
9884#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9885#[serde(rename_all = "camelCase")]
9886pub struct ThreadStatusChangedNotification {
9887 #[serde()]
9888 pub status: ThreadStatus,
9889 #[serde(rename = "threadId", default)]
9890 pub thread_id: String,
9891}
9892
9893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9894#[serde(rename_all = "camelCase")]
9895pub struct ThreadTokenUsage {
9896 #[serde()]
9897 pub last: TokenUsageBreakdown,
9898 #[serde(
9899 rename = "modelContextWindow",
9900 default,
9901 skip_serializing_if = "Option::is_none"
9902 )]
9903 pub model_context_window: Option<i64>,
9904 #[serde()]
9905 pub total: TokenUsageBreakdown,
9906}
9907
9908#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9909#[serde(rename_all = "camelCase")]
9910pub struct ThreadTokenUsageUpdatedNotification {
9911 #[serde(rename = "threadId", default)]
9912 pub thread_id: String,
9913 #[serde(rename = "tokenUsage")]
9914 pub token_usage: ThreadTokenUsage,
9915 #[serde(rename = "turnId", default)]
9916 pub turn_id: String,
9917}
9918
9919#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9920#[serde(rename_all = "camelCase")]
9921pub struct ThreadUnarchiveParams {
9922 #[serde(rename = "threadId", default)]
9923 pub thread_id: String,
9924}
9925
9926#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9927#[serde(rename_all = "camelCase")]
9928pub struct ThreadUnarchiveResponse {
9929 #[serde()]
9930 pub thread: Thread,
9931}
9932
9933#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9934#[serde(rename_all = "camelCase")]
9935pub struct ThreadUnarchivedNotification {
9936 #[serde(rename = "threadId", default)]
9937 pub thread_id: String,
9938}
9939
9940#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9941#[serde(tag = "type", rename_all = "camelCase")]
9942pub enum ThreadUnreadPosition {
9943 #[serde(rename = "threadStart")]
9945 ThreadStart,
9946 Turn {
9948 #[serde(rename = "turnId")]
9949 turn_id: String,
9950 },
9951}
9952
9953#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9958#[serde(tag = "type", rename_all = "camelCase")]
9959#[allow(clippy::large_enum_variant)] pub enum ThreadTimelineEntry {
9961 Item {
9962 item: ThreadItem,
9963 position: u64,
9964 #[serde(rename = "turnId")]
9965 turn_id: String,
9966 },
9967 Realtime {
9968 item: ThreadRealtimeItem,
9969 position: u64,
9970 },
9971 TurnStarted {
9972 position: u64,
9973 #[serde(default, skip_serializing_if = "Option::is_none")]
9974 started_at: Option<i64>,
9975 turn_id: String,
9976 },
9977 TurnCompleted {
9978 #[serde(default, skip_serializing_if = "Option::is_none")]
9979 completed_at: Option<i64>,
9980 #[serde(default, skip_serializing_if = "Option::is_none")]
9981 duration_ms: Option<i64>,
9982 #[serde(default, skip_serializing_if = "Option::is_none")]
9983 error: Option<TurnError>,
9984 position: u64,
9985 #[serde(default, skip_serializing_if = "Option::is_none")]
9986 started_at: Option<i64>,
9987 status: TurnStatus,
9988 turn_id: String,
9989 },
9990}
9991
9992#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9994#[serde(rename_all = "camelCase")]
9995pub struct ThreadTurnsListParams {
9996 #[serde(default, skip_serializing_if = "Option::is_none")]
9997 pub cursor: Option<String>,
9998 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
10000 pub items_view: Option<TurnItemsView>,
10001 #[serde(default, skip_serializing_if = "Option::is_none")]
10002 pub limit: Option<u32>,
10003 #[serde(
10004 rename = "sortDirection",
10005 default,
10006 skip_serializing_if = "Option::is_none"
10007 )]
10008 pub sort_direction: Option<SortDirection>,
10009 #[serde(rename = "threadId", default)]
10010 pub thread_id: String,
10011}
10012
10013#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10015#[serde(rename_all = "camelCase")]
10016pub struct ThreadTurnsListResponse {
10017 #[serde(
10018 rename = "backwardsCursor",
10019 default,
10020 skip_serializing_if = "Option::is_none"
10021 )]
10022 pub backwards_cursor: Option<String>,
10023 #[serde(default)]
10024 pub data: Vec<Turn>,
10025 #[serde(
10026 rename = "nextCursor",
10027 default,
10028 skip_serializing_if = "Option::is_none"
10029 )]
10030 pub next_cursor: Option<String>,
10031}
10032
10033#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10034#[serde(rename_all = "camelCase")]
10035pub struct ThreadUnsubscribeParams {
10036 #[serde(rename = "threadId", default)]
10037 pub thread_id: String,
10038}
10039
10040#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10041#[serde(rename_all = "camelCase")]
10042pub struct ThreadUnsubscribeResponse {
10043 #[serde()]
10044 pub status: ThreadUnsubscribeStatus,
10045}
10046
10047#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10048pub enum ThreadUnsubscribeStatus {
10049 #[serde(rename = "notLoaded")]
10050 NotLoaded,
10051 #[serde(rename = "notSubscribed")]
10052 NotSubscribed,
10053 #[serde(rename = "unsubscribed")]
10054 Unsubscribed,
10055}
10056
10057#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10058#[serde(rename_all = "camelCase")]
10059pub struct TokenUsageBreakdown {
10060 #[serde(
10061 rename = "cacheWriteInputTokens",
10062 default,
10063 skip_serializing_if = "Option::is_none"
10064 )]
10065 pub cache_write_input_tokens: Option<i64>,
10066 #[serde(rename = "cachedInputTokens", default)]
10067 pub cached_input_tokens: i64,
10068 #[serde(rename = "inputTokens", default)]
10069 pub input_tokens: i64,
10070 #[serde(rename = "outputTokens", default)]
10071 pub output_tokens: i64,
10072 #[serde(rename = "reasoningOutputTokens", default)]
10073 pub reasoning_output_tokens: i64,
10074 #[serde(rename = "totalTokens", default)]
10075 pub total_tokens: i64,
10076}
10077
10078#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10079#[serde(rename_all = "camelCase")]
10080pub struct Tool {
10081 #[serde(default, skip_serializing_if = "Option::is_none")]
10082 pub _meta: Option<Value>,
10083 #[serde(default, skip_serializing_if = "Option::is_none")]
10084 pub annotations: Option<Value>,
10085 #[serde(default, skip_serializing_if = "Option::is_none")]
10086 pub description: Option<String>,
10087 #[serde(default, skip_serializing_if = "Option::is_none")]
10088 pub icons: Option<Vec<Value>>,
10089 #[serde(rename = "inputSchema", default)]
10090 pub input_schema: Value,
10091 #[serde(default)]
10092 pub name: String,
10093 #[serde(
10094 rename = "outputSchema",
10095 default,
10096 skip_serializing_if = "Option::is_none"
10097 )]
10098 pub output_schema: Option<Value>,
10099 #[serde(default, skip_serializing_if = "Option::is_none")]
10100 pub title: Option<String>,
10101}
10102
10103#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10104#[serde(rename_all = "camelCase")]
10105pub struct ToolRequestUserInputAnswer {
10106 #[serde(default)]
10107 pub answers: Vec<String>,
10108}
10109
10110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10111#[serde(rename_all = "camelCase")]
10112pub struct ToolRequestUserInputOption {
10113 #[serde(default)]
10114 pub description: String,
10115 #[serde(default)]
10116 pub label: String,
10117}
10118
10119#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10120#[serde(rename_all = "camelCase")]
10121pub struct ToolRequestUserInputParams {
10122 #[serde(
10123 rename = "autoResolutionMs",
10124 default,
10125 skip_serializing_if = "Option::is_none"
10126 )]
10127 pub auto_resolution_ms: Option<i64>,
10128 #[serde(rename = "isBlocking", default)]
10129 pub is_blocking: bool,
10130 #[serde(rename = "itemId", default)]
10131 pub item_id: String,
10132 #[serde(default)]
10133 pub questions: Vec<ToolRequestUserInputQuestion>,
10134 #[serde(rename = "threadId", default)]
10135 pub thread_id: String,
10136 #[serde(rename = "turnId", default)]
10137 pub turn_id: String,
10138}
10139
10140#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10141#[serde(rename_all = "camelCase")]
10142pub struct ToolRequestUserInputQuestion {
10143 #[serde(default)]
10144 pub header: String,
10145 #[serde(default)]
10146 pub id: String,
10147 #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
10148 pub is_other: Option<bool>,
10149 #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
10150 pub is_secret: Option<bool>,
10151 #[serde(default, skip_serializing_if = "Option::is_none")]
10152 pub options: Option<Vec<ToolRequestUserInputOption>>,
10153 #[serde(default)]
10154 pub question: String,
10155}
10156
10157#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10158#[serde(rename_all = "camelCase")]
10159pub struct ToolRequestUserInputResponse {
10160 #[serde(default)]
10161 pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
10162}
10163
10164#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10165#[serde(rename_all = "camelCase")]
10166pub struct ToolsV2 {
10167 #[serde(default, skip_serializing_if = "Option::is_none")]
10168 pub web_search: Option<WebSearchToolConfig>,
10169}
10170
10171#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10172#[serde(rename_all = "camelCase")]
10173pub struct Turn {
10174 #[serde(
10175 rename = "completedAt",
10176 default,
10177 skip_serializing_if = "Option::is_none"
10178 )]
10179 pub completed_at: Option<i64>,
10180 #[serde(
10181 rename = "durationMs",
10182 default,
10183 skip_serializing_if = "Option::is_none"
10184 )]
10185 pub duration_ms: Option<i64>,
10186 #[serde(default, skip_serializing_if = "Option::is_none")]
10187 pub error: Option<TurnError>,
10188 #[serde(default)]
10189 pub id: String,
10190 #[serde(default)]
10191 pub items: Vec<ThreadItem>,
10192 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
10193 pub items_view: Option<Value>,
10194 #[serde(
10198 rename = "rootTurnId",
10199 default,
10200 skip_serializing_if = "Option::is_none"
10201 )]
10202 pub root_turn_id: Option<String>,
10203 #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
10204 pub started_at: Option<i64>,
10205 #[serde()]
10206 pub status: TurnStatus,
10207}
10208
10209#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10210#[serde(rename_all = "camelCase")]
10211pub struct TurnCompletedNotification {
10212 #[serde(rename = "threadId", default)]
10213 pub thread_id: String,
10214 #[serde()]
10215 pub turn: Turn,
10216}
10217
10218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10219#[serde(rename_all = "camelCase")]
10220pub struct TurnDiffUpdatedNotification {
10221 #[serde(default)]
10222 pub diff: String,
10223 #[serde(rename = "threadId", default)]
10224 pub thread_id: String,
10225 #[serde(rename = "turnId", default)]
10226 pub turn_id: String,
10227}
10228
10229#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10230#[serde(rename_all = "camelCase")]
10231pub struct TurnError {
10232 #[serde(
10233 rename = "additionalDetails",
10234 default,
10235 skip_serializing_if = "Option::is_none"
10236 )]
10237 pub additional_details: Option<String>,
10238 #[serde(
10239 rename = "codexErrorInfo",
10240 default,
10241 skip_serializing_if = "Option::is_none"
10242 )]
10243 pub codex_error_info: Option<CodexErrorInfo>,
10244 #[serde(default)]
10245 pub message: String,
10246 #[serde(default, skip_serializing_if = "Option::is_none")]
10249 pub misalignment: Option<MisalignmentErrorDetails>,
10250}
10251
10252#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10253#[serde(rename_all = "camelCase")]
10254pub struct TurnInterruptParams {
10255 #[serde(rename = "threadId", default)]
10256 pub thread_id: String,
10257 #[serde(rename = "turnId", default)]
10258 pub turn_id: String,
10259}
10260
10261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10262#[serde(rename_all = "camelCase")]
10263pub struct TurnInterruptResponse {
10264 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
10265 pub extra: serde_json::Map<String, Value>,
10266}
10267
10268#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
10269pub enum TurnItemsView {
10270 #[serde(rename = "notLoaded")]
10271 NotLoaded,
10272 #[serde(rename = "summary")]
10273 Summary,
10274 #[serde(rename = "full")]
10275 Full,
10276}
10277
10278#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10279#[serde(rename_all = "camelCase")]
10280pub struct TurnModerationMetadataNotification {
10281 #[serde(default)]
10282 pub metadata: Value,
10283 #[serde(rename = "threadId", default)]
10284 pub thread_id: String,
10285 #[serde(rename = "turnId", default)]
10286 pub turn_id: String,
10287}
10288
10289#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10290#[serde(rename_all = "camelCase")]
10291pub struct TurnPlanStep {
10292 #[serde()]
10293 pub status: TurnPlanStepStatus,
10294 #[serde(default)]
10295 pub step: String,
10296}
10297
10298#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10299pub enum TurnPlanStepStatus {
10300 #[serde(rename = "pending")]
10301 Pending,
10302 #[serde(rename = "inProgress")]
10303 InProgress,
10304 #[serde(rename = "completed")]
10305 Completed,
10306}
10307
10308#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10309#[serde(rename_all = "camelCase")]
10310pub struct TurnPlanUpdatedNotification {
10311 #[serde(default, skip_serializing_if = "Option::is_none")]
10312 pub explanation: Option<String>,
10313 #[serde(default)]
10314 pub plan: Vec<TurnPlanStep>,
10315 #[serde(rename = "threadId", default)]
10316 pub thread_id: String,
10317 #[serde(rename = "turnId", default)]
10318 pub turn_id: String,
10319}
10320
10321#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10322#[serde(rename_all = "camelCase")]
10323pub struct TurnStartParams {
10324 #[serde(
10325 rename = "approvalPolicy",
10326 default,
10327 skip_serializing_if = "Option::is_none"
10328 )]
10329 pub approval_policy: Option<AskForApproval>,
10330 #[serde(
10331 rename = "approvalsReviewer",
10332 default,
10333 skip_serializing_if = "Option::is_none"
10334 )]
10335 pub approvals_reviewer: Option<ApprovalsReviewer>,
10336 #[serde(
10337 rename = "clientUserMessageId",
10338 default,
10339 skip_serializing_if = "Option::is_none"
10340 )]
10341 pub client_user_message_id: Option<String>,
10342 #[serde(default, skip_serializing_if = "Option::is_none")]
10343 pub cwd: Option<String>,
10344 #[serde(
10347 rename = "disabledPluginIds",
10348 default,
10349 skip_serializing_if = "Option::is_none"
10350 )]
10351 pub disabled_plugin_ids: Option<Vec<String>>,
10352 #[serde(default, skip_serializing_if = "Option::is_none")]
10353 pub effort: Option<ReasoningEffort>,
10354 #[serde(default)]
10355 pub input: Vec<UserInput>,
10356 #[serde(default, skip_serializing_if = "Option::is_none")]
10357 pub model: Option<String>,
10358 #[serde(
10359 rename = "outputSchema",
10360 default,
10361 skip_serializing_if = "Option::is_none"
10362 )]
10363 pub output_schema: Option<Value>,
10364 #[serde(
10368 rename = "parentTurnId",
10369 default,
10370 skip_serializing_if = "Option::is_none"
10371 )]
10372 pub parent_turn_id: Option<String>,
10373 #[serde(default, skip_serializing_if = "Option::is_none")]
10374 pub personality: Option<Personality>,
10375 #[serde(
10380 rename = "rootTurnId",
10381 default,
10382 skip_serializing_if = "Option::is_none"
10383 )]
10384 pub root_turn_id: Option<String>,
10385 #[serde(
10386 rename = "sandboxPolicy",
10387 default,
10388 skip_serializing_if = "Option::is_none"
10389 )]
10390 pub sandbox_policy: Option<SandboxPolicy>,
10391 #[serde(
10392 rename = "serviceTier",
10393 default,
10394 skip_serializing_if = "Option::is_none"
10395 )]
10396 pub service_tier: Option<String>,
10397 #[serde(
10400 rename = "serviceTierForTurn",
10401 default,
10402 skip_serializing_if = "Option::is_none"
10403 )]
10404 pub service_tier_for_turn: Option<String>,
10405 #[serde(default, skip_serializing_if = "Option::is_none")]
10406 pub summary: Option<ReasoningSummary>,
10407 #[serde(rename = "threadId", default)]
10408 pub thread_id: String,
10409 #[serde(
10412 rename = "toolOutput",
10413 default,
10414 skip_serializing_if = "Option::is_none"
10415 )]
10416 pub tool_output: Option<TurnToolOutput>,
10417 #[serde(
10420 rename = "turnTrigger",
10421 default,
10422 skip_serializing_if = "Option::is_none"
10423 )]
10424 pub turn_trigger: Option<String>,
10425}
10426
10427#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10428#[serde(rename_all = "camelCase")]
10429pub struct TurnStartResponse {
10430 #[serde()]
10431 pub turn: Turn,
10432}
10433
10434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10435#[serde(rename_all = "camelCase")]
10436pub struct TurnStartedNotification {
10437 #[serde(rename = "threadId", default)]
10438 pub thread_id: String,
10439 #[serde()]
10440 pub turn: Turn,
10441}
10442
10443#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10444pub enum TurnStatus {
10445 #[serde(rename = "completed")]
10446 Completed,
10447 #[serde(rename = "interrupted")]
10448 Interrupted,
10449 #[serde(rename = "failed")]
10450 Failed,
10451 #[serde(rename = "inProgress")]
10452 InProgress,
10453}
10454
10455#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10458#[serde(rename_all = "camelCase")]
10459pub struct TurnToolOutput {
10460 #[serde(default)]
10461 pub name: String,
10462 #[serde(default, skip_serializing_if = "Option::is_none")]
10463 pub namespace: Option<String>,
10464 #[serde()]
10465 pub output: FunctionCallOutputBody,
10466 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
10469 pub retain: bool,
10470}
10471
10472#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10473#[serde(rename_all = "camelCase")]
10474pub struct TurnSteerParams {
10475 #[serde(
10476 rename = "clientUserMessageId",
10477 default,
10478 skip_serializing_if = "Option::is_none"
10479 )]
10480 pub client_user_message_id: Option<String>,
10481 #[serde(rename = "expectedTurnId", default)]
10482 pub expected_turn_id: String,
10483 #[serde(default)]
10484 pub input: Vec<UserInput>,
10485 #[serde(rename = "threadId", default)]
10486 pub thread_id: String,
10487}
10488
10489#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10490#[serde(rename_all = "camelCase")]
10491pub struct TurnSteerResponse {
10492 #[serde(rename = "turnId", default)]
10493 pub turn_id: String,
10494}
10495
10496#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10497#[serde(tag = "type", rename_all = "camelCase")]
10498pub enum UserInput {
10499 Text {
10500 text: String,
10501 #[serde(default, skip_serializing_if = "Option::is_none")]
10502 text_elements: Option<Vec<TextElement>>,
10503 },
10504 Image {
10505 #[serde(default, skip_serializing_if = "Option::is_none")]
10506 detail: Option<ImageDetail>,
10507 #[serde(flatten)]
10508 image: UserInputImageReference,
10509 },
10510 #[serde(rename = "localImage")]
10511 LocalImage {
10512 #[serde(default, skip_serializing_if = "Option::is_none")]
10513 detail: Option<ImageDetail>,
10514 path: String,
10515 },
10516 Audio {
10517 #[serde(flatten)]
10518 audio: UserInputAudioReference,
10519 },
10520 #[serde(rename = "localAudio")]
10521 LocalAudio {
10522 path: String,
10523 },
10524 Skill {
10525 name: String,
10526 path: String,
10527 },
10528 Mention {
10529 name: String,
10530 path: String,
10531 },
10532}
10533
10534#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10540#[serde(untagged)]
10541pub enum UserInputImageReference {
10542 Inline {
10543 url: String,
10544 },
10545 File {
10546 #[serde(rename = "fileId")]
10547 file_id: String,
10548 },
10549}
10550
10551#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10556#[serde(untagged)]
10557pub enum UserInputAudioReference {
10558 Inline {
10559 url: String,
10560 },
10561 File {
10562 #[serde(rename = "fileId")]
10563 file_id: String,
10564 },
10565}
10566
10567#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10568pub enum Verbosity {
10569 #[serde(rename = "low")]
10570 Low,
10571 #[serde(rename = "medium")]
10572 Medium,
10573 #[serde(rename = "high")]
10574 High,
10575}
10576
10577#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10578#[serde(rename_all = "camelCase")]
10579pub struct WarningNotification {
10580 #[serde(default)]
10581 pub message: String,
10582 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
10583 pub thread_id: Option<String>,
10584}
10585
10586#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10587#[serde(tag = "type", rename_all = "camelCase")]
10588pub enum WebSearchAction {
10589 Search {
10590 #[serde(default, skip_serializing_if = "Option::is_none")]
10591 queries: Option<Vec<String>>,
10592 #[serde(default, skip_serializing_if = "Option::is_none")]
10593 query: Option<String>,
10594 },
10595 #[serde(rename = "openPage")]
10596 OpenPage {
10597 #[serde(default, skip_serializing_if = "Option::is_none")]
10598 url: Option<String>,
10599 },
10600 #[serde(rename = "findInPage")]
10601 FindInPage {
10602 #[serde(default, skip_serializing_if = "Option::is_none")]
10603 pattern: Option<String>,
10604 #[serde(default, skip_serializing_if = "Option::is_none")]
10605 url: Option<String>,
10606 },
10607 Other,
10608}
10609
10610#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10611pub enum WebSearchContextSize {
10612 #[serde(rename = "low")]
10613 Low,
10614 #[serde(rename = "medium")]
10615 Medium,
10616 #[serde(rename = "high")]
10617 High,
10618}
10619
10620#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10621#[serde(rename_all = "camelCase")]
10622pub struct WebSearchLocation {
10623 #[serde(default, skip_serializing_if = "Option::is_none")]
10624 pub city: Option<String>,
10625 #[serde(default, skip_serializing_if = "Option::is_none")]
10626 pub country: Option<String>,
10627 #[serde(default, skip_serializing_if = "Option::is_none")]
10628 pub region: Option<String>,
10629 #[serde(default, skip_serializing_if = "Option::is_none")]
10630 pub timezone: Option<String>,
10631}
10632
10633#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10634pub enum WebSearchMode {
10635 #[serde(rename = "disabled")]
10636 Disabled,
10637 #[serde(rename = "cached")]
10638 Cached,
10639 #[serde(rename = "indexed")]
10640 Indexed,
10641 #[serde(rename = "live")]
10642 Live,
10643}
10644
10645#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10648pub enum WebSearchProvider {
10649 #[serde(rename = "standalone")]
10650 Standalone,
10651 #[serde(rename = "search_mcp")]
10652 SearchMcp,
10653}
10654
10655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10656#[serde(rename_all = "camelCase")]
10657pub struct WebSearchToolConfig {
10658 #[serde(default, skip_serializing_if = "Option::is_none")]
10659 pub allowed_domains: Option<Vec<String>>,
10660 #[serde(default, skip_serializing_if = "Option::is_none")]
10661 pub context_size: Option<WebSearchContextSize>,
10662 #[serde(default, skip_serializing_if = "Option::is_none")]
10663 pub location: Option<WebSearchLocation>,
10664}
10665
10666#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10667pub enum WindowsSandboxReadiness {
10668 #[serde(rename = "ready")]
10669 Ready,
10670 #[serde(rename = "notConfigured")]
10671 NotConfigured,
10672 #[serde(rename = "updateRequired")]
10673 UpdateRequired,
10674}
10675
10676#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10677#[serde(rename_all = "camelCase")]
10678pub struct WindowsSandboxReadinessResponse {
10679 #[serde()]
10680 pub status: WindowsSandboxReadiness,
10681}
10682
10683#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10684#[serde(rename_all = "camelCase")]
10685pub struct WindowsSandboxSetupCompletedNotification {
10686 #[serde(default, skip_serializing_if = "Option::is_none")]
10687 pub error: Option<String>,
10688 #[serde()]
10689 pub mode: WindowsSandboxSetupMode,
10690 #[serde(default)]
10691 pub success: bool,
10692}
10693
10694#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10695pub enum WindowsSandboxSetupMode {
10696 #[serde(rename = "elevated")]
10697 Elevated,
10698 #[serde(rename = "unelevated")]
10699 Unelevated,
10700}
10701
10702#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10706pub enum WindowsSandboxImplementation {
10707 #[serde(rename = "elevated")]
10708 Elevated,
10709 #[serde(rename = "unelevated")]
10710 Unelevated,
10711 #[serde(rename = "mxc")]
10712 Mxc,
10713}
10714
10715#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10716#[serde(rename_all = "camelCase")]
10717pub struct WindowsSandboxSetupStartParams {
10718 #[serde(default, skip_serializing_if = "Option::is_none")]
10719 pub cwd: Option<AbsolutePathBuf>,
10720 #[serde()]
10721 pub mode: WindowsSandboxSetupMode,
10722}
10723
10724#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10725#[serde(rename_all = "camelCase")]
10726pub struct WindowsSandboxSetupStartResponse {
10727 #[serde(default)]
10728 pub started: bool,
10729}
10730
10731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10732#[serde(rename_all = "camelCase")]
10733pub struct WindowsWorldWritableWarningNotification {
10734 #[serde(rename = "extraCount", default)]
10735 pub extra_count: i64,
10736 #[serde(rename = "failedScan", default)]
10737 pub failed_scan: bool,
10738 #[serde(rename = "samplePaths", default)]
10739 pub sample_paths: Vec<String>,
10740}
10741
10742#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10743#[serde(rename_all = "camelCase")]
10744pub struct WorkspaceMessage {
10745 #[serde(
10746 rename = "archivedAt",
10747 default,
10748 skip_serializing_if = "Option::is_none"
10749 )]
10750 pub archived_at: Option<i64>,
10751 #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
10752 pub created_at: Option<i64>,
10753 #[serde(rename = "messageBody", default)]
10754 pub message_body: String,
10755 #[serde(rename = "messageId", default)]
10756 pub message_id: String,
10757 #[serde(rename = "messageType")]
10758 pub message_type: WorkspaceMessageType,
10759}
10760
10761#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10762pub enum WorkspaceMessageType {
10763 #[serde(rename = "headline")]
10764 Headline,
10765 #[serde(rename = "announcement")]
10766 Announcement,
10767 #[serde(rename = "unknown")]
10768 Unknown,
10769}
10770
10771#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10772pub enum WriteStatus {
10773 #[serde(rename = "ok")]
10774 Ok,
10775 #[serde(rename = "okOverridden")]
10776 OkOverridden,
10777}