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)]
2869#[serde(rename_all = "camelCase")]
2870pub struct GatewayOAuthLoginResponse {}
2871
2872#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2875#[serde(rename_all = "camelCase")]
2876pub struct GatewayOAuthReadResponse {
2877 #[serde(default, skip_serializing_if = "Option::is_none")]
2878 pub error: Option<String>,
2879 #[serde(rename = "providerId", default)]
2880 pub provider_id: String,
2881 #[serde(rename = "providerName", default)]
2882 pub provider_name: String,
2883 #[serde(default)]
2886 pub required: bool,
2887 #[serde(default, skip_serializing_if = "Option::is_none")]
2889 pub status: Option<GatewayOAuthStatus>,
2890}
2891
2892#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
2893pub enum GatewayOAuthStatus {
2894 #[serde(rename = "notReady")]
2895 NotReady,
2896 #[serde(rename = "started")]
2897 Started,
2898 #[serde(rename = "succeeded")]
2899 Succeeded,
2900 #[serde(rename = "failed")]
2901 Failed,
2902}
2903
2904#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2905#[serde(rename_all = "camelCase")]
2906pub struct GetAccountParams {
2907 #[serde(
2908 rename = "refreshToken",
2909 default,
2910 skip_serializing_if = "Option::is_none"
2911 )]
2912 pub refresh_token: Option<bool>,
2913}
2914
2915#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
2919#[serde(rename_all = "camelCase")]
2920pub struct GetAccountRateLimitsParams {
2921 #[serde(
2925 rename = "excludeResetCreditDetails",
2926 default,
2927 skip_serializing_if = "std::ops::Not::not"
2928 )]
2929 pub exclude_reset_credit_details: bool,
2930 #[serde(
2934 rename = "supportsLunaReserve",
2935 default,
2936 skip_serializing_if = "std::ops::Not::not"
2937 )]
2938 pub supports_luna_reserve: bool,
2939}
2940
2941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2942#[serde(rename_all = "camelCase")]
2943pub struct GetAccountRateLimitsResponse {
2944 #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
2945 pub account_id: Option<String>,
2946 #[serde(
2950 rename = "ordinaryUsageAllowed",
2951 default,
2952 skip_serializing_if = "Option::is_none"
2953 )]
2954 pub ordinary_usage_allowed: Option<bool>,
2955 #[serde(
2956 rename = "rateLimitResetCredits",
2957 default,
2958 skip_serializing_if = "Option::is_none"
2959 )]
2960 pub rate_limit_reset_credits: Option<RateLimitResetCreditsSummary>,
2961 #[serde(
2962 rename = "rateLimitUpsell",
2963 default,
2964 skip_serializing_if = "Option::is_none"
2965 )]
2966 pub rate_limit_upsell: Option<Value>,
2967 #[serde(rename = "rateLimits", default)]
2968 pub rate_limits: Value,
2969 #[serde(
2970 rename = "rateLimitsByLimitId",
2971 default,
2972 skip_serializing_if = "Option::is_none"
2973 )]
2974 pub rate_limits_by_limit_id: Option<std::collections::BTreeMap<String, RateLimitSnapshot>>,
2975}
2976
2977#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2978#[serde(rename_all = "camelCase")]
2979pub struct GetAccountResponse {
2980 #[serde(default, skip_serializing_if = "Option::is_none")]
2981 pub account: Option<Account>,
2982 #[serde(rename = "requiresOpenaiAuth", default)]
2983 pub requires_openai_auth: bool,
2984}
2985
2986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2987#[serde(rename_all = "camelCase")]
2988pub struct GetAccountTokenUsageResponse {
2989 #[serde(
2990 rename = "dailyUsageBuckets",
2991 default,
2992 skip_serializing_if = "Option::is_none"
2993 )]
2994 pub daily_usage_buckets: Option<Vec<AccountTokenUsageDailyBucket>>,
2995 #[serde()]
2996 pub summary: AccountTokenUsageSummary,
2997 #[serde(
2998 rename = "threadUsage",
2999 default,
3000 skip_serializing_if = "Option::is_none"
3001 )]
3002 pub thread_usage: Option<ThreadUsage>,
3003}
3004
3005#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3006#[serde(rename_all = "camelCase")]
3007pub struct GetAccountTokenUsageParams {
3008 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3009 pub thread_id: Option<String>,
3010}
3011
3012#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3013#[serde(rename_all = "camelCase")]
3014pub struct ThreadUsage {
3015 #[serde(rename = "estimatedUsageCreditsMicros", default)]
3016 pub estimated_usage_credits_micros: i64,
3017 #[serde(
3018 rename = "estimatedUsageUsdMicros",
3019 default,
3020 skip_serializing_if = "Option::is_none"
3021 )]
3022 pub estimated_usage_usd_micros: Option<i64>,
3023 #[serde(
3026 rename = "nativeUsageUsdMicros",
3027 default,
3028 skip_serializing_if = "Option::is_none"
3029 )]
3030 pub native_usage_usd_micros: Option<i64>,
3031 #[serde(default)]
3032 pub groups: Vec<ThreadUsageBreakdownGroup>,
3033 #[serde(rename = "threadId", default)]
3034 pub thread_id: String,
3035}
3036
3037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3038#[serde(rename_all = "camelCase")]
3039pub struct ThreadUsageBreakdownGroup {
3040 #[serde(
3041 rename = "cachedInputTokens",
3042 default,
3043 skip_serializing_if = "Option::is_none"
3044 )]
3045 pub cached_input_tokens: Option<i64>,
3046 #[serde(rename = "estimatedUsageCreditsMicros", default)]
3047 pub estimated_usage_credits_micros: i64,
3048 #[serde(
3049 rename = "inputTokens",
3050 default,
3051 skip_serializing_if = "Option::is_none"
3052 )]
3053 pub input_tokens: Option<i64>,
3054 #[serde(default, skip_serializing_if = "Option::is_none")]
3055 pub model: Option<String>,
3056 #[serde(
3057 rename = "netNewInputTokens",
3058 default,
3059 skip_serializing_if = "Option::is_none"
3060 )]
3061 pub net_new_input_tokens: Option<i64>,
3062 #[serde(
3063 rename = "outputTokens",
3064 default,
3065 skip_serializing_if = "Option::is_none"
3066 )]
3067 pub output_tokens: Option<i64>,
3068 #[serde(
3069 rename = "reasoningEffort",
3070 default,
3071 skip_serializing_if = "Option::is_none"
3072 )]
3073 pub reasoning_effort: Option<String>,
3074 #[serde(default, skip_serializing_if = "Option::is_none")]
3075 pub speed: Option<String>,
3076 #[serde(
3077 rename = "totalTokens",
3078 default,
3079 skip_serializing_if = "Option::is_none"
3080 )]
3081 pub total_tokens: Option<i64>,
3082}
3083
3084#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3089#[serde(untagged)]
3090pub enum GeneratedImageRef {
3091 File {
3092 #[serde(rename = "fileId")]
3093 file_id: String,
3094 },
3095 Inline {
3096 result: String,
3097 },
3098}
3099
3100#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3102pub struct ImageGenerationInputImage {
3103 pub path: AbsolutePathBuf,
3104 pub sha256: String,
3106}
3107
3108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3109#[serde(tag = "type", rename_all = "camelCase")]
3110pub enum ImageGenerationFailure {
3111 #[serde(rename = "usageLimitExceeded")]
3112 UsageLimitExceeded {
3113 #[serde(rename = "limitId")]
3114 limit_id: String,
3115 #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
3116 resets_at: Option<i64>,
3117 },
3118}
3119
3120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3121#[serde(rename_all = "lowercase")]
3122pub enum McpServerOauthClientRegistration {
3123 Auto,
3124 Cimd,
3125 Dcr,
3126}
3127
3128#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3129#[serde(rename_all = "camelCase")]
3130pub struct GetWorkspaceMessagesResponse {
3131 #[serde(rename = "featureEnabled", default)]
3132 pub feature_enabled: bool,
3133 #[serde(default)]
3134 pub messages: Vec<WorkspaceMessage>,
3135}
3136
3137#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3138#[serde(rename_all = "camelCase")]
3139pub struct GitInfo {
3140 #[serde(default, skip_serializing_if = "Option::is_none")]
3141 pub branch: Option<String>,
3142 #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
3143 pub origin_url: Option<String>,
3144 #[serde(default, skip_serializing_if = "Option::is_none")]
3145 pub sha: Option<String>,
3146}
3147
3148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3149#[serde(rename_all = "camelCase")]
3150pub struct GrantedPermissionProfile {
3151 #[serde(
3152 rename = "fileSystem",
3153 default,
3154 skip_serializing_if = "Option::is_none"
3155 )]
3156 pub file_system: Option<AdditionalFileSystemPermissions>,
3157 #[serde(default, skip_serializing_if = "Option::is_none")]
3158 pub network: Option<AdditionalNetworkPermissions>,
3159}
3160
3161#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3162#[serde(rename_all = "camelCase")]
3163pub struct GuardianApprovalReview {
3164 #[serde(default, skip_serializing_if = "Option::is_none")]
3165 pub rationale: Option<String>,
3166 #[serde(rename = "riskLevel", default, skip_serializing_if = "Option::is_none")]
3167 pub risk_level: Option<GuardianRiskLevel>,
3168 #[serde()]
3169 pub status: GuardianApprovalReviewStatus,
3170 #[serde(
3171 rename = "userAuthorization",
3172 default,
3173 skip_serializing_if = "Option::is_none"
3174 )]
3175 pub user_authorization: Option<GuardianUserAuthorization>,
3176}
3177
3178#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3179#[serde(tag = "type", rename_all = "camelCase")]
3180pub enum GuardianApprovalReviewAction {
3181 Command {
3182 command: String,
3183 cwd: LegacyAppPathString,
3184 source: GuardianCommandSource,
3185 },
3186 Execve {
3187 argv: Vec<String>,
3188 cwd: AbsolutePathBuf,
3189 program: String,
3190 source: GuardianCommandSource,
3191 },
3192 #[serde(rename = "writeStdin")]
3193 WriteStdin {
3194 #[serde(rename = "approvalId")]
3195 approval_id: String,
3196 cwd: LegacyAppPathString,
3197 #[serde(rename = "processId")]
3198 process_id: String,
3199 stdin: String,
3200 },
3201 #[serde(rename = "applyPatch")]
3202 ApplyPatch {
3203 cwd: LegacyAppPathString,
3204 files: Vec<LegacyAppPathString>,
3205 },
3206 #[serde(rename = "networkAccess")]
3207 NetworkAccess {
3208 host: String,
3209 port: i64,
3210 protocol: NetworkApprovalProtocol,
3211 target: String,
3212 },
3213 #[serde(rename = "mcpToolCall")]
3214 McpToolCall {
3215 #[serde(
3216 rename = "connectorId",
3217 default,
3218 skip_serializing_if = "Option::is_none"
3219 )]
3220 connector_id: Option<String>,
3221 #[serde(
3222 rename = "connectorName",
3223 default,
3224 skip_serializing_if = "Option::is_none"
3225 )]
3226 connector_name: Option<String>,
3227 server: String,
3228 #[serde(rename = "toolName")]
3229 tool_name: String,
3230 #[serde(rename = "toolTitle", default, skip_serializing_if = "Option::is_none")]
3231 tool_title: Option<String>,
3232 },
3233 #[serde(rename = "requestPermissions")]
3234 RequestPermissions {
3235 permissions: RequestPermissionProfile,
3236 #[serde(default, skip_serializing_if = "Option::is_none")]
3237 reason: Option<String>,
3238 },
3239}
3240
3241#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3242pub enum GuardianApprovalReviewStatus {
3243 #[serde(rename = "inProgress")]
3244 InProgress,
3245 #[serde(rename = "approved")]
3246 Approved,
3247 #[serde(rename = "denied")]
3248 Denied,
3249 #[serde(rename = "timedOut")]
3250 TimedOut,
3251 #[serde(rename = "aborted")]
3252 Aborted,
3253}
3254
3255#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3256pub enum GuardianCommandSource {
3257 #[serde(rename = "shell")]
3258 Shell,
3259 #[serde(rename = "unifiedExec")]
3260 UnifiedExec,
3261}
3262
3263#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3264pub enum GuardianRiskLevel {
3265 #[serde(rename = "low")]
3266 Low,
3267 #[serde(rename = "medium")]
3268 Medium,
3269 #[serde(rename = "high")]
3270 High,
3271 #[serde(rename = "critical")]
3272 Critical,
3273}
3274
3275#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3276pub enum GuardianUserAuthorization {
3277 #[serde(rename = "unknown")]
3278 Unknown,
3279 #[serde(rename = "low")]
3280 Low,
3281 #[serde(rename = "medium")]
3282 Medium,
3283 #[serde(rename = "high")]
3284 High,
3285}
3286
3287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3288#[serde(rename_all = "camelCase")]
3289pub struct GuardianWarningNotification {
3290 #[serde(default)]
3291 pub message: String,
3292 #[serde(rename = "threadId", default)]
3293 pub thread_id: String,
3294}
3295
3296#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3297#[serde(rename_all = "camelCase")]
3298pub struct HookCompletedNotification {
3299 #[serde()]
3300 pub run: HookRunSummary,
3301 #[serde(rename = "threadId", default)]
3302 pub thread_id: String,
3303 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
3304 pub turn_id: Option<String>,
3305}
3306
3307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3308#[serde(rename_all = "camelCase")]
3309pub struct HookErrorInfo {
3310 #[serde(default)]
3311 pub message: String,
3312 #[serde(default)]
3313 pub path: String,
3314}
3315
3316#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3317pub enum HookEventName {
3318 #[serde(rename = "preModelRequest")]
3319 PreModelRequest,
3320 #[serde(rename = "postModelRequest")]
3321 PostModelRequest,
3322 #[serde(rename = "preToolUse")]
3323 PreToolUse,
3324 #[serde(rename = "permissionRequest")]
3325 PermissionRequest,
3326 #[serde(rename = "postToolUse")]
3327 PostToolUse,
3328 #[serde(rename = "preCompact")]
3329 PreCompact,
3330 #[serde(rename = "postCompact")]
3331 PostCompact,
3332 #[serde(rename = "sessionStart")]
3333 SessionStart,
3334 #[serde(rename = "sessionEnd")]
3335 SessionEnd,
3336 #[serde(rename = "userPromptSubmit")]
3337 UserPromptSubmit,
3338 #[serde(rename = "subagentStart")]
3339 SubagentStart,
3340 #[serde(rename = "subagentStop")]
3341 SubagentStop,
3342 #[serde(rename = "stop")]
3343 Stop,
3344 #[serde(rename = "interrupt")]
3345 Interrupt,
3346}
3347
3348#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3349pub enum HookExecutionMode {
3350 #[serde(rename = "sync")]
3351 Sync,
3352 #[serde(rename = "async")]
3353 Async,
3354}
3355
3356#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3357pub enum HookHandlerType {
3358 #[serde(rename = "command")]
3359 Command,
3360 #[serde(rename = "mcpTool")]
3361 McpTool,
3362 #[serde(rename = "prompt")]
3363 Prompt,
3364 #[serde(rename = "agent")]
3365 Agent,
3366}
3367
3368#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3369#[serde(rename_all = "camelCase")]
3370pub struct HookMetadata {
3371 #[serde(
3372 rename = "additionalContextLimit",
3373 default,
3374 skip_serializing_if = "Option::is_none"
3375 )]
3376 pub additional_context_limit: Option<i64>,
3377 #[serde(rename = "async", default, skip_serializing_if = "Option::is_none")]
3378 pub is_async: Option<bool>,
3379 #[serde(default, skip_serializing_if = "Option::is_none")]
3380 pub command: Option<String>,
3381 #[serde(rename = "currentHash", default)]
3382 pub current_hash: String,
3383 #[serde(default, skip_serializing_if = "Option::is_none")]
3385 pub server: Option<String>,
3386 #[serde(default, skip_serializing_if = "Option::is_none")]
3388 pub tool: Option<String>,
3389 #[serde(rename = "displayOrder", default)]
3390 pub display_order: i64,
3391 #[serde(default)]
3392 pub enabled: bool,
3393 #[serde(
3395 rename = "environmentId",
3396 default,
3397 skip_serializing_if = "Option::is_none"
3398 )]
3399 pub environment_id: Option<String>,
3400 #[serde(rename = "eventName")]
3401 pub event_name: HookEventName,
3402 #[serde(
3403 rename = "executionMode",
3404 default,
3405 skip_serializing_if = "Option::is_none"
3406 )]
3407 pub execution_mode: Option<Value>,
3408 #[serde(rename = "handlerType")]
3409 pub handler_type: HookHandlerType,
3410 #[serde(rename = "isManaged", default)]
3411 pub is_managed: bool,
3412 #[serde(default)]
3413 pub key: String,
3414 #[serde(default, skip_serializing_if = "Option::is_none")]
3415 pub matcher: Option<String>,
3416 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
3417 pub plugin_id: Option<String>,
3418 #[serde()]
3419 pub source: HookSource,
3420 #[serde(rename = "sourcePath")]
3421 pub source_path: AbsolutePathBuf,
3422 #[serde(
3423 rename = "statusMessage",
3424 default,
3425 skip_serializing_if = "Option::is_none"
3426 )]
3427 pub status_message: Option<String>,
3428 #[serde(rename = "timeoutSec", default)]
3429 pub timeout_sec: i64,
3430 #[serde(rename = "trustStatus")]
3431 pub trust_status: HookTrustStatus,
3432}
3433
3434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3435#[serde(rename_all = "camelCase")]
3436pub struct HookMigration {
3437 #[serde(default)]
3438 pub name: String,
3439}
3440
3441#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3442#[serde(rename_all = "camelCase")]
3443pub struct HookOutputEntry {
3444 #[serde()]
3445 pub kind: HookOutputEntryKind,
3446 #[serde(default)]
3447 pub text: String,
3448}
3449
3450#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3451pub enum HookOutputEntryKind {
3452 #[serde(rename = "warning")]
3453 Warning,
3454 #[serde(rename = "stop")]
3455 Stop,
3456 #[serde(rename = "feedback")]
3457 Feedback,
3458 #[serde(rename = "context")]
3459 Context,
3460 #[serde(rename = "error")]
3461 Error,
3462}
3463
3464#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3465#[serde(rename_all = "camelCase")]
3466pub struct HookPromptFragment {
3467 #[serde(rename = "hookRunId", default)]
3468 pub hook_run_id: String,
3469 #[serde(default)]
3470 pub text: String,
3471}
3472
3473#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3474pub enum HookRunStatus {
3475 #[serde(rename = "running")]
3476 Running,
3477 #[serde(rename = "completed")]
3478 Completed,
3479 #[serde(rename = "failed")]
3480 Failed,
3481 #[serde(rename = "blocked")]
3482 Blocked,
3483 #[serde(rename = "stopped")]
3484 Stopped,
3485}
3486
3487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3488#[serde(rename_all = "camelCase")]
3489pub struct HookRunSummary {
3490 #[serde(
3491 rename = "completedAt",
3492 default,
3493 skip_serializing_if = "Option::is_none"
3494 )]
3495 pub completed_at: Option<i64>,
3496 #[serde(rename = "displayOrder", default)]
3497 pub display_order: i64,
3498 #[serde(
3499 rename = "durationMs",
3500 default,
3501 skip_serializing_if = "Option::is_none"
3502 )]
3503 pub duration_ms: Option<i64>,
3504 #[serde(default)]
3505 pub entries: Vec<HookOutputEntry>,
3506 #[serde(rename = "eventName")]
3507 pub event_name: HookEventName,
3508 #[serde(rename = "executionMode")]
3509 pub execution_mode: HookExecutionMode,
3510 #[serde(rename = "handlerType")]
3511 pub handler_type: HookHandlerType,
3512 #[serde(default)]
3513 pub id: String,
3514 #[serde()]
3515 pub scope: HookScope,
3516 #[serde(default, skip_serializing_if = "Option::is_none")]
3517 pub source: Option<Value>,
3518 #[serde(rename = "sourcePath")]
3519 pub source_path: LegacyAppPathString,
3520 #[serde(rename = "startedAt", default)]
3521 pub started_at: i64,
3522 #[serde()]
3523 pub status: HookRunStatus,
3524 #[serde(
3525 rename = "statusMessage",
3526 default,
3527 skip_serializing_if = "Option::is_none"
3528 )]
3529 pub status_message: Option<String>,
3530}
3531
3532#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3533pub enum HookScope {
3534 #[serde(rename = "thread")]
3535 Thread,
3536 #[serde(rename = "turn")]
3537 Turn,
3538}
3539
3540#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3541pub enum HookSource {
3542 #[serde(rename = "system")]
3543 System,
3544 #[serde(rename = "user")]
3545 User,
3546 #[serde(rename = "project")]
3547 Project,
3548 #[serde(rename = "mdm")]
3549 Mdm,
3550 #[serde(rename = "sessionFlags")]
3551 SessionFlags,
3552 #[serde(rename = "plugin")]
3553 Plugin,
3554 #[serde(rename = "cloudRequirements")]
3555 CloudRequirements,
3556 #[serde(rename = "cloudManagedConfig")]
3557 CloudManagedConfig,
3558 #[serde(rename = "legacyManagedConfigFile")]
3559 LegacyManagedConfigFile,
3560 #[serde(rename = "legacyManagedConfigMdm")]
3561 LegacyManagedConfigMdm,
3562 #[serde(rename = "unknown")]
3563 Unknown,
3564}
3565
3566#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3567#[serde(rename_all = "camelCase")]
3568pub struct HookStartedNotification {
3569 #[serde()]
3570 pub run: HookRunSummary,
3571 #[serde(rename = "threadId", default)]
3572 pub thread_id: String,
3573 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
3574 pub turn_id: Option<String>,
3575}
3576
3577#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3578pub enum HookTrustStatus {
3579 #[serde(rename = "managed")]
3580 Managed,
3581 #[serde(rename = "untrusted")]
3582 Untrusted,
3583 #[serde(rename = "trusted")]
3584 Trusted,
3585 #[serde(rename = "modified")]
3586 Modified,
3587}
3588
3589#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3590#[serde(rename_all = "camelCase")]
3591pub struct HooksListEntry {
3592 #[serde(default)]
3593 pub cwd: String,
3594 #[serde(default)]
3595 pub errors: Vec<HookErrorInfo>,
3596 #[serde(default)]
3597 pub hooks: Vec<HookMetadata>,
3598 #[serde(default)]
3599 pub warnings: Vec<String>,
3600}
3601
3602#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3603#[serde(rename_all = "camelCase")]
3604pub struct HooksListParams {
3605 #[serde(default, skip_serializing_if = "Option::is_none")]
3607 pub cwds: Option<Vec<String>>,
3608 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3610 pub thread_id: Option<String>,
3611}
3612
3613#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3614#[serde(rename_all = "camelCase")]
3615pub struct HooksListResponse {
3616 #[serde(default)]
3617 pub data: Vec<HooksListEntry>,
3618}
3619
3620#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3621pub enum ImageDetail {
3622 #[serde(rename = "auto")]
3623 Auto,
3624 #[serde(rename = "low")]
3625 Low,
3626 #[serde(rename = "high")]
3627 High,
3628 #[serde(rename = "original")]
3629 Original,
3630}
3631
3632#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3633#[serde(rename_all = "camelCase")]
3634pub struct InitializeCapabilities {
3635 #[serde(
3636 rename = "experimentalApi",
3637 default,
3638 skip_serializing_if = "Option::is_none"
3639 )]
3640 pub experimental_api: Option<bool>,
3641 #[serde(
3645 rename = "explicitGatewayOauth",
3646 default,
3647 skip_serializing_if = "Option::is_none"
3648 )]
3649 pub explicit_gateway_oauth: Option<bool>,
3650 #[serde(default, skip_serializing_if = "Option::is_none")]
3651 pub extensions: Option<Value>,
3652 #[serde(
3653 rename = "mcpServerOpenaiFormElicitation",
3654 default,
3655 skip_serializing_if = "Option::is_none"
3656 )]
3657 pub mcp_server_openai_form_elicitation: Option<bool>,
3658 #[serde(
3659 rename = "optOutNotificationMethods",
3660 default,
3661 skip_serializing_if = "Option::is_none"
3662 )]
3663 pub opt_out_notification_methods: Option<Vec<String>>,
3664 #[serde(
3665 rename = "requestAttestation",
3666 default,
3667 skip_serializing_if = "Option::is_none"
3668 )]
3669 pub request_attestation: Option<bool>,
3670 #[serde(
3674 rename = "requiredHumanApproval",
3675 default,
3676 skip_serializing_if = "Option::is_none"
3677 )]
3678 pub required_human_approval: Option<bool>,
3679}
3680
3681#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3682#[serde(rename_all = "camelCase")]
3683pub struct InitializeParams {
3684 #[serde(default, skip_serializing_if = "Option::is_none")]
3685 pub capabilities: Option<InitializeCapabilities>,
3686 #[serde(rename = "clientInfo")]
3687 pub client_info: ClientInfo,
3688}
3689
3690#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3691#[serde(rename_all = "camelCase")]
3692pub struct InitializeResponse {
3693 #[serde(rename = "codexHome", default)]
3694 pub codex_home: Value,
3695 #[serde(rename = "platformFamily", default)]
3696 pub platform_family: String,
3697 #[serde(rename = "platformOs", default)]
3698 pub platform_os: String,
3699 #[serde(rename = "userAgent", default)]
3700 pub user_agent: String,
3701}
3702
3703#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
3704pub enum InputModality {
3705 #[serde(rename = "text")]
3706 Text,
3707 #[serde(rename = "image")]
3708 Image,
3709 #[serde(rename = "audio")]
3710 Audio,
3711}
3712
3713#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3714#[serde(rename_all = "camelCase")]
3715pub struct InstalledApp {
3716 #[serde(default)]
3717 pub callable: bool,
3718 #[serde(default)]
3719 pub enabled: bool,
3720 #[serde(default)]
3721 pub id: String,
3722 #[serde(
3723 rename = "runtimeName",
3724 default,
3725 skip_serializing_if = "Option::is_none"
3726 )]
3727 pub runtime_name: Option<String>,
3728}
3729
3730#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3731#[serde(rename_all = "camelCase")]
3732pub struct ItemCompletedNotification {
3733 #[serde(rename = "completedAtMs", default)]
3734 pub completed_at_ms: i64,
3735 #[serde(
3739 rename = "contentTokenCount",
3740 default,
3741 skip_serializing_if = "Option::is_none"
3742 )]
3743 pub content_token_count: Option<i64>,
3744 #[serde()]
3745 pub item: ThreadItem,
3746 #[serde(rename = "threadId", default)]
3747 pub thread_id: String,
3748 #[serde(rename = "turnId", default)]
3749 pub turn_id: String,
3750}
3751
3752#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3753#[serde(rename_all = "camelCase")]
3754pub struct ItemGuardianApprovalReviewCompletedNotification {
3755 #[serde()]
3756 pub action: GuardianApprovalReviewAction,
3757 #[serde(rename = "completedAtMs", default)]
3758 pub completed_at_ms: i64,
3759 #[serde(rename = "decisionSource")]
3760 pub decision_source: AutoReviewDecisionSource,
3761 #[serde()]
3762 pub review: GuardianApprovalReview,
3763 #[serde(rename = "reviewId", default)]
3764 pub review_id: String,
3765 #[serde(rename = "startedAtMs", default)]
3766 pub started_at_ms: i64,
3767 #[serde(
3768 rename = "targetItemId",
3769 default,
3770 skip_serializing_if = "Option::is_none"
3771 )]
3772 pub target_item_id: Option<String>,
3773 #[serde(rename = "threadId", default)]
3774 pub thread_id: String,
3775 #[serde(rename = "turnId", default)]
3776 pub turn_id: String,
3777}
3778
3779#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3780#[serde(rename_all = "camelCase")]
3781pub struct ItemGuardianApprovalReviewStartedNotification {
3782 #[serde()]
3783 pub action: GuardianApprovalReviewAction,
3784 #[serde()]
3785 pub review: GuardianApprovalReview,
3786 #[serde(rename = "reviewId", default)]
3787 pub review_id: String,
3788 #[serde(rename = "startedAtMs", default)]
3789 pub started_at_ms: i64,
3790 #[serde(
3791 rename = "targetItemId",
3792 default,
3793 skip_serializing_if = "Option::is_none"
3794 )]
3795 pub target_item_id: Option<String>,
3796 #[serde(rename = "threadId", default)]
3797 pub thread_id: String,
3798 #[serde(rename = "turnId", default)]
3799 pub turn_id: String,
3800}
3801
3802#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3803#[serde(rename_all = "camelCase")]
3804pub struct ItemStartedNotification {
3805 #[serde()]
3806 pub item: ThreadItem,
3807 #[serde(rename = "startedAtMs", default)]
3808 pub started_at_ms: i64,
3809 #[serde(rename = "threadId", default)]
3810 pub thread_id: String,
3811 #[serde(rename = "turnId", default)]
3812 pub turn_id: String,
3813}
3814
3815#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3816#[serde(rename_all = "camelCase")]
3817pub struct JSONRPCResponse {
3818 #[serde()]
3819 pub id: RequestId,
3820 #[serde(default)]
3821 pub result: Value,
3822}
3823
3824#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
3825#[serde(transparent)]
3826pub struct LegacyAppPathString(pub String);
3827
3828#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3829#[serde(rename_all = "camelCase")]
3830pub struct ListMcpServerStatusParams {
3831 #[serde(default, skip_serializing_if = "Option::is_none")]
3832 pub cursor: Option<String>,
3833 #[serde(default, skip_serializing_if = "Option::is_none")]
3834 pub detail: Option<McpServerStatusDetail>,
3835 #[serde(default, skip_serializing_if = "Option::is_none")]
3836 pub limit: Option<i64>,
3837 #[serde(
3840 rename = "serverName",
3841 default,
3842 skip_serializing_if = "Option::is_none"
3843 )]
3844 pub server_name: Option<String>,
3845 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3846 pub thread_id: Option<String>,
3847}
3848
3849#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3850#[serde(rename_all = "camelCase")]
3851pub struct ListMcpServerStatusResponse {
3852 #[serde(default)]
3853 pub data: Vec<McpServerStatus>,
3854 #[serde(
3855 rename = "nextCursor",
3856 default,
3857 skip_serializing_if = "Option::is_none"
3858 )]
3859 pub next_cursor: Option<String>,
3860}
3861
3862#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3863#[serde(tag = "type", rename_all = "camelCase")]
3864pub enum LoginAccountParams {
3865 #[serde(rename = "apiKey")]
3866 ApiKey {
3867 #[serde(rename = "apiKey")]
3868 api_key: String,
3869 },
3870 Chatgpt {
3871 #[serde(rename = "appBrand", default, skip_serializing_if = "Option::is_none")]
3872 app_brand: Option<LoginAppBrand>,
3873 #[serde(
3874 rename = "codexStreamlinedLogin",
3875 default,
3876 skip_serializing_if = "Option::is_none"
3877 )]
3878 codex_streamlined_login: Option<bool>,
3879 #[serde(
3880 rename = "useHostedLoginSuccessPage",
3881 default,
3882 skip_serializing_if = "Option::is_none"
3883 )]
3884 use_hosted_login_success_page: Option<bool>,
3885 },
3886 #[serde(rename = "chatgptDeviceCode")]
3887 ChatgptDeviceCode,
3888 #[serde(rename = "chatgptAuthTokens")]
3889 ChatgptAuthTokens {
3890 #[serde(rename = "accessToken")]
3891 access_token: String,
3892 #[serde(rename = "chatgptAccountId")]
3893 chatgpt_account_id: String,
3894 #[serde(
3895 rename = "chatgptPlanType",
3896 default,
3897 skip_serializing_if = "Option::is_none"
3898 )]
3899 chatgpt_plan_type: Option<String>,
3900 },
3901 #[serde(rename = "amazonBedrock")]
3902 AmazonBedrock {
3903 #[serde(rename = "apiKey")]
3904 api_key: String,
3905 region: String,
3906 },
3907 #[serde(rename = "amazonBedrockAccessKeys")]
3908 AmazonBedrockAccessKeys {
3909 #[serde(rename = "accessKeyId")]
3910 access_key_id: String,
3911 region: String,
3912 #[serde(rename = "secretAccessKey")]
3913 secret_access_key: String,
3914 #[serde(
3915 rename = "sessionToken",
3916 default,
3917 skip_serializing_if = "Option::is_none"
3918 )]
3919 session_token: Option<String>,
3920 },
3921}
3922
3923#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3924#[serde(tag = "type", rename_all = "camelCase")]
3925pub enum LoginAccountResponse {
3926 #[serde(rename = "apiKey")]
3927 ApiKey,
3928 Chatgpt {
3929 #[serde(rename = "authUrl")]
3930 auth_url: String,
3931 #[serde(rename = "loginId")]
3932 login_id: String,
3933 },
3934 #[serde(rename = "chatgptDeviceCode")]
3935 ChatgptDeviceCode {
3936 #[serde(rename = "loginId")]
3937 login_id: String,
3938 #[serde(rename = "userCode")]
3939 user_code: String,
3940 #[serde(rename = "verificationUrl")]
3941 verification_url: String,
3942 },
3943 #[serde(rename = "chatgptAuthTokens")]
3944 ChatgptAuthTokens,
3945 #[serde(rename = "amazonBedrock")]
3946 AmazonBedrock,
3947}
3948
3949#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3950pub enum LoginAppBrand {
3951 #[serde(rename = "codex")]
3952 Codex,
3953 #[serde(rename = "chatgpt")]
3954 Chatgpt,
3955}
3956
3957#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3958#[serde(rename_all = "camelCase")]
3959pub struct LogoutAccountResponse {
3960 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
3961 pub extra: serde_json::Map<String, Value>,
3962}
3963
3964#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3965#[serde(rename_all = "camelCase")]
3966pub struct MarketplaceAddParams {
3967 #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
3968 pub ref_name: Option<String>,
3969 #[serde(default)]
3970 pub source: String,
3971 #[serde(
3972 rename = "sparsePaths",
3973 default,
3974 skip_serializing_if = "Option::is_none"
3975 )]
3976 pub sparse_paths: Option<Vec<String>>,
3977}
3978
3979#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3980#[serde(rename_all = "camelCase")]
3981pub struct MarketplaceAddResponse {
3982 #[serde(rename = "alreadyAdded", default)]
3983 pub already_added: bool,
3984 #[serde(rename = "installedRoot")]
3985 pub installed_root: AbsolutePathBuf,
3986 #[serde(rename = "marketplaceName", default)]
3987 pub marketplace_name: String,
3988}
3989
3990#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3991#[serde(rename_all = "camelCase")]
3992pub struct MarketplaceInterface {
3993 #[serde(
3994 rename = "displayName",
3995 default,
3996 skip_serializing_if = "Option::is_none"
3997 )]
3998 pub display_name: Option<String>,
3999}
4000
4001#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4002#[serde(rename_all = "camelCase")]
4003pub struct MarketplaceLoadErrorInfo {
4004 #[serde(rename = "marketplacePath")]
4005 pub marketplace_path: AbsolutePathBuf,
4006 #[serde(default)]
4007 pub message: String,
4008}
4009
4010#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4011#[serde(rename_all = "camelCase")]
4012pub struct MarketplaceRemoveParams {
4013 #[serde(rename = "marketplaceName", default)]
4014 pub marketplace_name: String,
4015}
4016
4017#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4018#[serde(rename_all = "camelCase")]
4019pub struct MarketplaceRemoveResponse {
4020 #[serde(
4021 rename = "installedRoot",
4022 default,
4023 skip_serializing_if = "Option::is_none"
4024 )]
4025 pub installed_root: Option<AbsolutePathBuf>,
4026 #[serde(rename = "marketplaceName", default)]
4027 pub marketplace_name: String,
4028}
4029
4030#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4031#[serde(rename_all = "camelCase")]
4032pub struct MarketplaceUpgradeErrorInfo {
4033 #[serde(rename = "marketplaceName", default)]
4034 pub marketplace_name: String,
4035 #[serde(default)]
4036 pub message: String,
4037}
4038
4039#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4040#[serde(rename_all = "camelCase")]
4041pub struct MarketplaceUpgradeParams {
4042 #[serde(
4043 rename = "marketplaceName",
4044 default,
4045 skip_serializing_if = "Option::is_none"
4046 )]
4047 pub marketplace_name: Option<String>,
4048}
4049
4050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4051#[serde(rename_all = "camelCase")]
4052pub struct MarketplaceUpgradeResponse {
4053 #[serde(default)]
4054 pub errors: Vec<MarketplaceUpgradeErrorInfo>,
4055 #[serde(rename = "selectedMarketplaces", default)]
4056 pub selected_marketplaces: Vec<String>,
4057 #[serde(rename = "upgradedRoots", default)]
4058 pub upgraded_roots: Vec<AbsolutePathBuf>,
4059}
4060
4061#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4062pub enum McpAuthStatus {
4063 #[serde(rename = "unknown")]
4064 Unknown,
4065 #[serde(rename = "unsupported")]
4066 Unsupported,
4067 #[serde(rename = "notLoggedIn")]
4068 NotLoggedIn,
4069 #[serde(rename = "bearerToken")]
4070 BearerToken,
4071 #[serde(rename = "oAuth")]
4072 OAuth,
4073}
4074
4075#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4076pub enum McpElicitationArrayType {
4077 #[serde(rename = "array")]
4078 Array,
4079}
4080
4081#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4082#[serde(rename_all = "camelCase")]
4083pub struct McpElicitationBooleanSchema {
4084 #[serde(default, skip_serializing_if = "Option::is_none")]
4085 pub default: Option<bool>,
4086 #[serde(default, skip_serializing_if = "Option::is_none")]
4087 pub description: Option<String>,
4088 #[serde(default, skip_serializing_if = "Option::is_none")]
4089 pub title: Option<String>,
4090 #[serde(rename = "type")]
4091 pub type_: McpElicitationBooleanType,
4092}
4093
4094#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4095pub enum McpElicitationBooleanType {
4096 #[serde(rename = "boolean")]
4097 Boolean,
4098}
4099
4100#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4101#[serde(rename_all = "camelCase")]
4102pub struct McpElicitationConstOption {
4103 #[serde(rename = "const", default)]
4104 pub const_: String,
4105 #[serde(default)]
4106 pub title: String,
4107}
4108
4109#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4110#[serde(untagged)]
4111pub enum McpElicitationEnumSchema {
4112 McpElicitationSingleSelectEnumSchema(McpElicitationSingleSelectEnumSchema),
4113 McpElicitationMultiSelectEnumSchema(McpElicitationMultiSelectEnumSchema),
4114 McpElicitationLegacyTitledEnumSchema(McpElicitationLegacyTitledEnumSchema),
4115}
4116
4117#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4118#[serde(rename_all = "camelCase")]
4119pub struct McpElicitationLegacyTitledEnumSchema {
4120 #[serde(default, skip_serializing_if = "Option::is_none")]
4121 pub default: Option<String>,
4122 #[serde(default, skip_serializing_if = "Option::is_none")]
4123 pub description: Option<String>,
4124 #[serde(rename = "enum", default)]
4125 pub enum_: Vec<String>,
4126 #[serde(rename = "enumNames", default, skip_serializing_if = "Option::is_none")]
4127 pub enum_names: Option<Vec<String>>,
4128 #[serde(default, skip_serializing_if = "Option::is_none")]
4129 pub title: Option<String>,
4130 #[serde(rename = "type")]
4131 pub type_: McpElicitationStringType,
4132}
4133
4134#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4135#[serde(untagged)]
4136pub enum McpElicitationMultiSelectEnumSchema {
4137 McpElicitationUntitledMultiSelectEnumSchema(McpElicitationUntitledMultiSelectEnumSchema),
4138 McpElicitationTitledMultiSelectEnumSchema(McpElicitationTitledMultiSelectEnumSchema),
4139}
4140
4141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4142#[serde(rename_all = "camelCase")]
4143pub struct McpElicitationNumberSchema {
4144 #[serde(default, skip_serializing_if = "Option::is_none")]
4145 pub default: Option<f64>,
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 maximum: Option<f64>,
4150 #[serde(default, skip_serializing_if = "Option::is_none")]
4151 pub minimum: Option<f64>,
4152 #[serde(default, skip_serializing_if = "Option::is_none")]
4153 pub title: Option<String>,
4154 #[serde(rename = "type")]
4155 pub type_: McpElicitationNumberType,
4156}
4157
4158#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4159pub enum McpElicitationNumberType {
4160 #[serde(rename = "number")]
4161 Number,
4162 #[serde(rename = "integer")]
4163 Integer,
4164}
4165
4166#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4167pub enum McpElicitationObjectType {
4168 #[serde(rename = "object")]
4169 Object,
4170}
4171
4172#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4173#[serde(untagged)]
4174pub enum McpElicitationPrimitiveSchema {
4175 McpElicitationEnumSchema(McpElicitationEnumSchema),
4176 McpElicitationStringSchema(McpElicitationStringSchema),
4177 McpElicitationNumberSchema(McpElicitationNumberSchema),
4178 McpElicitationBooleanSchema(McpElicitationBooleanSchema),
4179}
4180
4181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4182#[serde(rename_all = "camelCase")]
4183pub struct McpElicitationSchema {
4184 #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
4185 pub schema: Option<String>,
4186 #[serde(default)]
4187 pub properties: std::collections::BTreeMap<String, McpElicitationPrimitiveSchema>,
4188 #[serde(default, skip_serializing_if = "Option::is_none")]
4189 pub required: Option<Vec<String>>,
4190 #[serde(rename = "type")]
4191 pub type_: McpElicitationObjectType,
4192}
4193
4194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4195#[serde(untagged)]
4196pub enum McpElicitationSingleSelectEnumSchema {
4197 McpElicitationUntitledSingleSelectEnumSchema(McpElicitationUntitledSingleSelectEnumSchema),
4198 McpElicitationTitledSingleSelectEnumSchema(McpElicitationTitledSingleSelectEnumSchema),
4199}
4200
4201#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4202pub enum McpElicitationStringFormat {
4203 #[serde(rename = "email")]
4204 Email,
4205 #[serde(rename = "uri")]
4206 Uri,
4207 #[serde(rename = "date")]
4208 Date,
4209 #[serde(rename = "date-time")]
4210 Date_time,
4211}
4212
4213#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4214#[serde(rename_all = "camelCase")]
4215pub struct McpElicitationStringSchema {
4216 #[serde(default, skip_serializing_if = "Option::is_none")]
4217 pub default: Option<String>,
4218 #[serde(default, skip_serializing_if = "Option::is_none")]
4219 pub description: Option<String>,
4220 #[serde(default, skip_serializing_if = "Option::is_none")]
4221 pub format: Option<McpElicitationStringFormat>,
4222 #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
4223 pub max_length: Option<i64>,
4224 #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
4225 pub min_length: Option<i64>,
4226 #[serde(default, skip_serializing_if = "Option::is_none")]
4227 pub title: Option<String>,
4228 #[serde(rename = "type")]
4229 pub type_: McpElicitationStringType,
4230}
4231
4232#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4233pub enum McpElicitationStringType {
4234 #[serde(rename = "string")]
4235 String,
4236}
4237
4238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4239#[serde(rename_all = "camelCase")]
4240pub struct McpElicitationTitledEnumItems {
4241 #[serde(rename = "anyOf", default)]
4242 pub any_of: Vec<McpElicitationConstOption>,
4243}
4244
4245#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4246#[serde(rename_all = "camelCase")]
4247pub struct McpElicitationTitledMultiSelectEnumSchema {
4248 #[serde(default, skip_serializing_if = "Option::is_none")]
4249 pub default: Option<Vec<String>>,
4250 #[serde(default, skip_serializing_if = "Option::is_none")]
4251 pub description: Option<String>,
4252 #[serde()]
4253 pub items: McpElicitationTitledEnumItems,
4254 #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4255 pub max_items: Option<i64>,
4256 #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4257 pub min_items: Option<i64>,
4258 #[serde(default, skip_serializing_if = "Option::is_none")]
4259 pub title: Option<String>,
4260 #[serde(rename = "type")]
4261 pub type_: McpElicitationArrayType,
4262}
4263
4264#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4265#[serde(rename_all = "camelCase")]
4266pub struct McpElicitationTitledSingleSelectEnumSchema {
4267 #[serde(default, skip_serializing_if = "Option::is_none")]
4268 pub default: Option<String>,
4269 #[serde(default, skip_serializing_if = "Option::is_none")]
4270 pub description: Option<String>,
4271 #[serde(rename = "oneOf", default)]
4272 pub one_of: Vec<McpElicitationConstOption>,
4273 #[serde(default, skip_serializing_if = "Option::is_none")]
4274 pub title: Option<String>,
4275 #[serde(rename = "type")]
4276 pub type_: McpElicitationStringType,
4277}
4278
4279#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4280#[serde(rename_all = "camelCase")]
4281pub struct McpElicitationUntitledEnumItems {
4282 #[serde(rename = "enum", default)]
4283 pub enum_: Vec<String>,
4284 #[serde(rename = "type")]
4285 pub type_: McpElicitationStringType,
4286}
4287
4288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4289#[serde(rename_all = "camelCase")]
4290pub struct McpElicitationUntitledMultiSelectEnumSchema {
4291 #[serde(default, skip_serializing_if = "Option::is_none")]
4292 pub default: Option<Vec<String>>,
4293 #[serde(default, skip_serializing_if = "Option::is_none")]
4294 pub description: Option<String>,
4295 #[serde()]
4296 pub items: McpElicitationUntitledEnumItems,
4297 #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4298 pub max_items: Option<i64>,
4299 #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4300 pub min_items: Option<i64>,
4301 #[serde(default, skip_serializing_if = "Option::is_none")]
4302 pub title: Option<String>,
4303 #[serde(rename = "type")]
4304 pub type_: McpElicitationArrayType,
4305}
4306
4307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4308#[serde(rename_all = "camelCase")]
4309pub struct McpElicitationUntitledSingleSelectEnumSchema {
4310 #[serde(default, skip_serializing_if = "Option::is_none")]
4311 pub default: Option<String>,
4312 #[serde(default, skip_serializing_if = "Option::is_none")]
4313 pub description: Option<String>,
4314 #[serde(rename = "enum", default)]
4315 pub enum_: Vec<String>,
4316 #[serde(default, skip_serializing_if = "Option::is_none")]
4317 pub title: Option<String>,
4318 #[serde(rename = "type")]
4319 pub type_: McpElicitationStringType,
4320}
4321
4322#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4323#[serde(rename_all = "camelCase")]
4324pub struct McpResourceReadParams {
4325 #[serde(
4326 rename = "connectorId",
4327 default,
4328 skip_serializing_if = "Option::is_none"
4329 )]
4330 pub connector_id: Option<String>,
4331 #[serde(
4333 rename = "originCallId",
4334 default,
4335 skip_serializing_if = "Option::is_none"
4336 )]
4337 pub origin_call_id: Option<String>,
4338 #[serde(default)]
4339 pub server: String,
4340 #[serde(default, skip_serializing_if = "Option::is_none")]
4342 pub target: Option<McpResourceReadTarget>,
4343 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4344 pub thread_id: Option<String>,
4345 #[serde(default)]
4346 pub uri: String,
4347}
4348
4349#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4351#[serde(rename_all = "camelCase")]
4352pub struct McpResourceReadTarget {
4353 #[serde(rename = "connectorId", default)]
4354 pub connector_id: String,
4355 #[serde(rename = "linkId", default)]
4358 pub link_id: Option<String>,
4359}
4360
4361#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4362#[serde(rename_all = "camelCase")]
4363pub struct McpResourceReadResponse {
4364 #[serde(default)]
4365 pub contents: Vec<ResourceContent>,
4366 #[serde(
4369 rename = "originCallId",
4370 default,
4371 skip_serializing_if = "Option::is_none"
4372 )]
4373 pub origin_call_id: Option<String>,
4374}
4375
4376#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4377pub enum McpServerElicitationAction {
4378 #[serde(rename = "accept")]
4379 Accept,
4380 #[serde(rename = "decline")]
4381 Decline,
4382 #[serde(rename = "cancel")]
4383 Cancel,
4384}
4385
4386#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4387#[serde(tag = "mode", rename_all = "camelCase")]
4388pub enum McpServerElicitationRequestParams {
4389 Form {
4390 #[serde(default, skip_serializing_if = "Option::is_none")]
4391 _meta: Option<Value>,
4392 message: String,
4393 #[serde(rename = "requestedSchema")]
4394 requested_schema: McpElicitationSchema,
4395 },
4396 #[serde(rename = "openai/form")]
4397 OpenaiForm {
4398 #[serde(default, skip_serializing_if = "Option::is_none")]
4399 _meta: Option<Value>,
4400 message: String,
4401 #[serde(rename = "requestedSchema")]
4402 requested_schema: Value,
4403 },
4404 #[serde(rename = "openaiForm")]
4405 OpenAiElicitationForm {
4406 #[serde(default, skip_serializing_if = "Option::is_none")]
4407 _meta: Option<Value>,
4408 message: String,
4409 #[serde(rename = "requestedSchema")]
4410 requested_schema: Value,
4411 },
4412 Url {
4413 #[serde(default, skip_serializing_if = "Option::is_none")]
4414 _meta: Option<Value>,
4415 #[serde(rename = "elicitationId")]
4416 elicitation_id: String,
4417 message: String,
4418 url: String,
4419 },
4420}
4421
4422#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4423#[serde(rename_all = "camelCase")]
4424pub struct McpServerElicitationRequestResponse {
4425 #[serde(default, skip_serializing_if = "Option::is_none")]
4426 pub _meta: Option<Value>,
4427 #[serde()]
4428 pub action: McpServerElicitationAction,
4429 #[serde(default, skip_serializing_if = "Option::is_none")]
4430 pub content: Option<Value>,
4431}
4432
4433#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4434#[serde(rename_all = "camelCase")]
4435pub struct McpServerInfo {
4436 #[serde(default, skip_serializing_if = "Option::is_none")]
4437 pub description: Option<String>,
4438 #[serde(default, skip_serializing_if = "Option::is_none")]
4439 pub icons: Option<Vec<Value>>,
4440 #[serde(default)]
4441 pub name: String,
4442 #[serde(default, skip_serializing_if = "Option::is_none")]
4443 pub title: Option<String>,
4444 #[serde(default)]
4445 pub version: String,
4446 #[serde(
4447 rename = "websiteUrl",
4448 default,
4449 skip_serializing_if = "Option::is_none"
4450 )]
4451 pub website_url: Option<String>,
4452}
4453
4454#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4455#[serde(rename_all = "camelCase")]
4456pub struct McpServerMigration {
4457 #[serde(default)]
4458 pub name: String,
4459}
4460
4461#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4462#[serde(rename_all = "camelCase")]
4463pub struct McpServerOauthLoginCompletedNotification {
4464 #[serde(default, skip_serializing_if = "Option::is_none")]
4465 pub error: Option<String>,
4466 #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4468 pub login_id: Option<String>,
4469 #[serde(default)]
4470 pub name: String,
4471 #[serde(default)]
4472 pub success: bool,
4473 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4474 pub thread_id: Option<String>,
4475}
4476
4477#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4478#[serde(rename_all = "camelCase")]
4479pub struct McpServerOauthLoginParams {
4480 #[serde(
4481 rename = "clientRegistration",
4482 default,
4483 skip_serializing_if = "Option::is_none"
4484 )]
4485 pub client_registration: Option<McpServerOauthClientRegistration>,
4486 #[serde(default)]
4487 pub name: String,
4488 #[serde(default, skip_serializing_if = "Option::is_none")]
4489 pub scopes: Option<Vec<String>>,
4490 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4491 pub thread_id: Option<String>,
4492 #[serde(
4493 rename = "timeoutSecs",
4494 default,
4495 skip_serializing_if = "Option::is_none"
4496 )]
4497 pub timeout_secs: Option<i64>,
4498}
4499
4500#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4501#[serde(rename_all = "camelCase")]
4502pub struct McpServerOauthLoginResponse {
4503 #[serde(rename = "authorizationUrl", default)]
4504 pub authorization_url: String,
4505 #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4509 pub login_id: Option<String>,
4510}
4511
4512#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4513#[serde(rename_all = "camelCase")]
4514pub struct McpServerRefreshResponse {
4515 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4516 pub extra: serde_json::Map<String, Value>,
4517}
4518
4519#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4520pub enum McpServerStartupFailureReason {
4521 #[serde(rename = "reauthenticationRequired")]
4522 ReauthenticationRequired,
4523}
4524
4525#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4526pub enum McpServerStartupState {
4527 #[serde(rename = "starting")]
4528 Starting,
4529 #[serde(rename = "ready")]
4530 Ready,
4531 #[serde(rename = "failed")]
4532 Failed,
4533 #[serde(rename = "cancelled")]
4534 Cancelled,
4535}
4536
4537#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4538#[serde(rename_all = "camelCase")]
4539pub struct McpServerStatus {
4540 #[serde(rename = "authStatus")]
4541 pub auth_status: McpAuthStatus,
4542 #[serde(
4546 rename = "httpOrigin",
4547 default,
4548 skip_serializing_if = "Option::is_none"
4549 )]
4550 pub http_origin: Option<String>,
4551 #[serde(
4553 rename = "runtimeStatus",
4554 default,
4555 skip_serializing_if = "Option::is_none"
4556 )]
4557 pub runtime_status: Option<McpServerConnectionStatus>,
4558 #[serde(default)]
4559 pub name: String,
4560 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
4561 pub plugin_id: Option<String>,
4562 #[serde(rename = "resourceTemplates", default)]
4563 pub resource_templates: Vec<ResourceTemplate>,
4564 #[serde(default)]
4565 pub resources: Vec<Resource>,
4566 #[serde(
4569 rename = "serverCapabilities",
4570 default,
4571 skip_serializing_if = "Option::is_none"
4572 )]
4573 pub server_capabilities: Option<Value>,
4574 #[serde(
4575 rename = "serverInfo",
4576 default,
4577 skip_serializing_if = "Option::is_none"
4578 )]
4579 pub server_info: Option<McpServerInfo>,
4580 #[serde(
4583 rename = "toolListMeta",
4584 default,
4585 skip_serializing_if = "Option::is_none"
4586 )]
4587 pub tool_list_meta: Option<Value>,
4588 #[serde(default)]
4589 pub tools: std::collections::BTreeMap<String, Tool>,
4590 #[serde(
4593 rename = "toolsError",
4594 default,
4595 skip_serializing_if = "Option::is_none"
4596 )]
4597 pub tools_error: Option<String>,
4598}
4599
4600#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4601pub enum McpServerStatusDetail {
4602 #[serde(rename = "full")]
4603 Full,
4604 #[serde(rename = "toolsAndAuthOnly")]
4605 ToolsAndAuthOnly,
4606}
4607
4608#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4609#[serde(rename_all = "camelCase")]
4610pub struct McpServerStatusUpdatedNotification {
4611 #[serde(default, skip_serializing_if = "Option::is_none")]
4612 pub error: Option<String>,
4613 #[serde(
4614 rename = "failureReason",
4615 default,
4616 skip_serializing_if = "Option::is_none"
4617 )]
4618 pub failure_reason: Option<McpServerStartupFailureReason>,
4619 #[serde(default)]
4620 pub name: String,
4621 #[serde()]
4622 pub status: McpServerStartupState,
4623 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4624 pub thread_id: Option<String>,
4625}
4626
4627#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4628#[serde(rename_all = "camelCase")]
4629pub struct McpServerToolCallParams {
4630 #[serde(default, skip_serializing_if = "Option::is_none")]
4631 pub _meta: Option<Value>,
4632 #[serde(default, skip_serializing_if = "Option::is_none")]
4633 pub arguments: Option<Value>,
4634 #[serde(default)]
4635 pub server: String,
4636 #[serde(rename = "threadId", default)]
4637 pub thread_id: String,
4638 #[serde(default)]
4639 pub tool: String,
4640}
4641
4642#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4643#[serde(rename_all = "camelCase")]
4644pub struct McpServerToolCallResponse {
4645 #[serde(default, skip_serializing_if = "Option::is_none")]
4646 pub _meta: Option<Value>,
4647 #[serde(default)]
4648 pub content: Vec<Value>,
4649 #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
4650 pub is_error: Option<bool>,
4651 #[serde(
4652 rename = "structuredContent",
4653 default,
4654 skip_serializing_if = "Option::is_none"
4655 )]
4656 pub structured_content: Option<Value>,
4657}
4658
4659#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
4662#[serde(rename_all = "camelCase")]
4663pub struct McpAppUi {
4664 #[serde(rename = "resourceUri")]
4665 pub resource_uri: String,
4666 #[serde(rename = "preferredModelDisplayMode")]
4667 pub preferred_model_display_mode: McpAppDisplayMode,
4668}
4669
4670#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4671pub enum McpAppDisplayMode {
4672 #[serde(rename = "inline")]
4673 Inline,
4674 #[serde(rename = "fullscreen")]
4675 Fullscreen,
4676}
4677
4678#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4679#[serde(rename_all = "camelCase")]
4680pub struct McpToolCallAppContext {
4681 #[serde(
4682 rename = "actionName",
4683 default,
4684 skip_serializing_if = "Option::is_none"
4685 )]
4686 pub action_name: Option<String>,
4687 #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
4688 pub app_name: Option<String>,
4689 #[serde(rename = "connectorId", default)]
4690 pub connector_id: String,
4691 #[serde(rename = "linkId", default, skip_serializing_if = "Option::is_none")]
4692 pub link_id: Option<String>,
4693 #[serde(
4694 rename = "resourceUri",
4695 default,
4696 skip_serializing_if = "Option::is_none"
4697 )]
4698 pub resource_uri: Option<String>,
4699}
4700
4701#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4702#[serde(rename_all = "camelCase")]
4703pub struct McpToolCallError {
4704 #[serde(default)]
4705 pub message: String,
4706}
4707
4708#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4709#[serde(rename_all = "camelCase")]
4710pub struct McpToolCallProgressNotification {
4711 #[serde(rename = "itemId", default)]
4712 pub item_id: String,
4713 #[serde(default)]
4714 pub message: String,
4715 #[serde(rename = "threadId", default)]
4716 pub thread_id: String,
4717 #[serde(rename = "turnId", default)]
4718 pub turn_id: String,
4719}
4720
4721#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4722#[serde(rename_all = "camelCase")]
4723pub struct McpToolCallResult {
4724 #[serde(default, skip_serializing_if = "Option::is_none")]
4725 pub _meta: Option<Value>,
4726 #[serde(default)]
4727 pub content: Vec<Value>,
4728 #[serde(
4729 rename = "structuredContent",
4730 default,
4731 skip_serializing_if = "Option::is_none"
4732 )]
4733 pub structured_content: Option<Value>,
4734}
4735
4736#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4737pub enum McpToolCallStatus {
4738 #[serde(rename = "inProgress")]
4739 InProgress,
4740 #[serde(rename = "completed")]
4741 Completed,
4742 #[serde(rename = "failed")]
4743 Failed,
4744}
4745
4746#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4747#[serde(rename_all = "camelCase")]
4748pub struct MemoryCitation {
4749 #[serde(default)]
4750 pub entries: Vec<MemoryCitationEntry>,
4751 #[serde(rename = "threadIds", default)]
4752 pub thread_ids: Vec<String>,
4753}
4754
4755#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4756#[serde(rename_all = "camelCase")]
4757pub struct MemoryCitationEntry {
4758 #[serde(rename = "lineEnd", default)]
4759 pub line_end: i64,
4760 #[serde(rename = "lineStart", default)]
4761 pub line_start: i64,
4762 #[serde(default)]
4763 pub note: String,
4764 #[serde(default)]
4765 pub path: String,
4766}
4767
4768#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4769pub enum MergeStrategy {
4770 #[serde(rename = "replace")]
4771 Replace,
4772 #[serde(rename = "upsert")]
4773 Upsert,
4774}
4775
4776#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4777pub enum MessagePhase {
4778 #[serde(rename = "commentary")]
4779 Commentary,
4780 #[serde(rename = "partial_answer")]
4783 PartialAnswer,
4784 #[serde(rename = "final_answer")]
4785 FinalAnswer,
4786}
4787
4788#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4789#[serde(rename_all = "camelCase")]
4790pub struct MigrationDetails {
4791 #[serde(default, skip_serializing_if = "Option::is_none")]
4792 pub commands: Option<Vec<CommandMigration>>,
4793 #[serde(default, skip_serializing_if = "Option::is_none")]
4794 pub hooks: Option<Vec<HookMigration>>,
4795 #[serde(
4796 rename = "mcpServers",
4797 default,
4798 skip_serializing_if = "Option::is_none"
4799 )]
4800 pub mcp_servers: Option<Vec<McpServerMigration>>,
4801 #[serde(default, skip_serializing_if = "Option::is_none")]
4802 pub memory: Option<Vec<String>>,
4803 #[serde(default, skip_serializing_if = "Option::is_none")]
4804 pub plugins: Option<Vec<PluginsMigration>>,
4805 #[serde(default, skip_serializing_if = "Option::is_none")]
4806 pub sessions: Option<Vec<SessionMigration>>,
4807 #[serde(default, skip_serializing_if = "Option::is_none")]
4808 pub skills: Option<Vec<SkillMigration>>,
4809 #[serde(default, skip_serializing_if = "Option::is_none")]
4810 pub subagents: Option<Vec<SubagentMigration>>,
4811}
4812
4813#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4816#[serde(rename_all = "camelCase")]
4817pub struct MisalignmentErrorDetails {
4818 #[serde(
4819 rename = "detailedExplanation",
4820 default,
4821 skip_serializing_if = "Option::is_none"
4822 )]
4823 pub detailed_explanation: Option<String>,
4824 #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
4826 pub error_type: Option<String>,
4827 #[serde(
4830 rename = "reviewTarget",
4831 default,
4832 skip_serializing_if = "Option::is_none"
4833 )]
4834 pub review_target: Option<String>,
4835 #[serde(default, skip_serializing_if = "Option::is_none")]
4838 pub steer: Option<MisalignmentSteer>,
4839}
4840
4841#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4843#[serde(rename_all = "camelCase")]
4844pub struct MisalignmentSteer {
4845 #[serde(default)]
4846 pub message: String,
4847}
4848
4849#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4850pub enum ModeKind {
4851 #[serde(rename = "plan")]
4852 Plan,
4853 #[serde(rename = "default")]
4854 Default,
4855}
4856
4857#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4858#[serde(rename_all = "camelCase")]
4859pub struct Model {
4860 #[serde(
4861 rename = "additionalSpeedTiers",
4862 default,
4863 skip_serializing_if = "Option::is_none"
4864 )]
4865 pub additional_speed_tiers: Option<Vec<String>>,
4866 #[serde(
4867 rename = "availabilityNux",
4868 default,
4869 skip_serializing_if = "Option::is_none"
4870 )]
4871 pub availability_nux: Option<ModelAvailabilityNux>,
4872 #[serde(
4874 rename = "availableAccessPrograms",
4875 default,
4876 skip_serializing_if = "Option::is_none"
4877 )]
4878 pub available_access_programs: Option<ModelAccessPrograms>,
4879 #[serde(rename = "defaultReasoningEffort")]
4880 pub default_reasoning_effort: ReasoningEffort,
4881 #[serde(
4882 rename = "defaultServiceTier",
4883 default,
4884 skip_serializing_if = "Option::is_none"
4885 )]
4886 pub default_service_tier: Option<String>,
4887 #[serde(default)]
4888 pub description: String,
4889 #[serde(rename = "displayName", default)]
4890 pub display_name: String,
4891 #[serde(default)]
4892 pub hidden: bool,
4893 #[serde(default)]
4894 pub id: String,
4895 #[serde(
4896 rename = "inputModalities",
4897 default,
4898 skip_serializing_if = "Option::is_none"
4899 )]
4900 pub input_modalities: Option<Vec<InputModality>>,
4901 #[serde(rename = "isDefault", default)]
4902 pub is_default: bool,
4903 #[serde(default)]
4904 pub model: String,
4905 #[serde(
4906 rename = "modelSpecialty",
4907 default,
4908 skip_serializing_if = "Option::is_none"
4909 )]
4910 pub model_specialty: Option<String>,
4911 #[serde(
4912 rename = "multiAgentVersion",
4913 default,
4914 skip_serializing_if = "Option::is_none"
4915 )]
4916 pub multi_agent_version: Option<MultiAgentVersion>,
4917 #[serde(
4918 rename = "serviceTiers",
4919 default,
4920 skip_serializing_if = "Option::is_none"
4921 )]
4922 pub service_tiers: Option<Vec<ModelServiceTier>>,
4923 #[serde(rename = "supportedReasoningEfforts", default)]
4924 pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
4925 #[serde(
4928 rename = "supportsPersonality",
4929 default,
4930 skip_serializing_if = "Option::is_none"
4931 )]
4932 pub supports_personality: Option<bool>,
4933 #[serde(default, skip_serializing_if = "Option::is_none")]
4934 pub upgrade: Option<String>,
4935 #[serde(
4936 rename = "upgradeInfo",
4937 default,
4938 skip_serializing_if = "Option::is_none"
4939 )]
4940 pub upgrade_info: Option<ModelUpgradeInfo>,
4941}
4942
4943#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4945#[serde(rename_all = "camelCase")]
4946pub struct ModelAccessPrograms {
4947 #[serde(default)]
4949 pub cyber: Vec<CyberAccessProgram>,
4950}
4951
4952#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4953#[serde(rename_all = "camelCase")]
4954pub struct ModelAvailabilityNux {
4955 #[serde(default)]
4956 pub message: String,
4957}
4958
4959#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4960#[serde(rename_all = "camelCase")]
4961pub struct ModelListParams {
4962 #[serde(default, skip_serializing_if = "Option::is_none")]
4963 pub cursor: Option<String>,
4964 #[serde(
4965 rename = "includeHidden",
4966 default,
4967 skip_serializing_if = "Option::is_none"
4968 )]
4969 pub include_hidden: Option<bool>,
4970 #[serde(default, skip_serializing_if = "Option::is_none")]
4971 pub limit: Option<i64>,
4972}
4973
4974#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4975#[serde(rename_all = "camelCase")]
4976pub struct ModelListResponse {
4977 #[serde(default)]
4978 pub data: Vec<Model>,
4979 #[serde(
4980 rename = "nextCursor",
4981 default,
4982 skip_serializing_if = "Option::is_none"
4983 )]
4984 pub next_cursor: Option<String>,
4985}
4986
4987#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4988#[serde(rename_all = "camelCase")]
4989pub struct ModelProviderCapabilitiesReadParams {
4990 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4991 pub extra: serde_json::Map<String, Value>,
4992}
4993
4994#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4995#[serde(rename_all = "camelCase")]
4996pub struct ModelProviderCapabilitiesReadResponse {
4997 #[serde(rename = "imageGeneration", default)]
4998 pub image_generation: bool,
4999 #[serde(rename = "webSearch", default)]
5000 pub web_search: bool,
5001}
5002
5003#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5005#[serde(rename_all = "camelCase")]
5006pub struct ModelProviderListParams {
5007 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5008 pub extra: serde_json::Map<String, Value>,
5009}
5010
5011#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5013#[serde(rename_all = "camelCase")]
5014pub struct ModelProviderListResponse {
5015 pub data: Vec<ModelProviderSummary>,
5016 #[serde(rename = "defaultProviderId")]
5017 pub default_provider_id: String,
5018 #[serde(rename = "canChangeDefault")]
5019 pub can_change_default: bool,
5020}
5021
5022#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5024#[serde(rename_all = "camelCase")]
5025pub struct ModelProviderSummary {
5026 pub id: String,
5027 pub name: String,
5028 #[serde(rename = "canEdit")]
5030 pub can_edit: bool,
5031 #[serde(rename = "baseUrl", default)]
5033 pub base_url: Option<String>,
5034 pub settings: ProviderSettings,
5035}
5036
5037#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5039#[serde(tag = "type", rename_all = "camelCase")]
5040pub enum ProviderSettings {
5041 #[serde(rename = "openai")]
5042 OpenAi,
5043 #[serde(rename = "customGateway")]
5044 CustomGateway { auth: GatewayAuth },
5045 #[serde(rename = "bedrock")]
5046 Bedrock {
5047 #[serde(default)]
5048 profile: Option<String>,
5049 #[serde(default)]
5050 region: Option<String>,
5051 },
5052 #[serde(rename = "gcp")]
5053 Gcp {
5054 #[serde(rename = "projectId", default)]
5055 project_id: Option<String>,
5056 #[serde(default)]
5057 location: Option<String>,
5058 #[serde(rename = "credentialFile", default)]
5060 credential_file: Option<String>,
5061 },
5062}
5063
5064#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5066#[serde(tag = "mode", rename_all = "camelCase")]
5067pub enum GatewayAuth {
5068 #[serde(rename = "none")]
5069 None,
5070 #[serde(rename = "environmentVariable")]
5071 EnvironmentVariable {
5072 #[serde(rename = "envKey")]
5073 env_key: String,
5074 },
5075 #[serde(rename = "externallyConfigured")]
5077 ExternallyConfigured {
5078 #[serde(rename = "envKey", default)]
5079 env_key: Option<String>,
5080 },
5081}
5082
5083#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5085#[serde(rename_all = "camelCase")]
5086pub struct ModelProviderConfigWriteParams {
5087 pub settings: ProviderSettingsPatch,
5088}
5089
5090#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5092#[serde(rename_all = "camelCase")]
5093pub struct ModelProviderConfigWriteResponse {
5094 pub provider: ModelProviderSummary,
5095}
5096
5097#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5102#[serde(tag = "type", rename_all = "camelCase")]
5103pub enum ProviderSettingsPatch {
5104 #[serde(rename = "customGateway")]
5105 CustomGateway {
5106 #[serde(
5108 rename = "providerId",
5109 default,
5110 skip_serializing_if = "Option::is_none"
5111 )]
5112 provider_id: Option<String>,
5113 #[serde(
5115 default,
5116 deserialize_with = "deserialize_patch_name",
5117 skip_serializing_if = "Option::is_none"
5118 )]
5119 name: Option<String>,
5120 #[serde(
5121 rename = "baseUrl",
5122 default,
5123 deserialize_with = "deserialize_patch_field",
5124 skip_serializing_if = "Option::is_none"
5125 )]
5126 base_url: Option<Option<String>>,
5127 #[serde(
5128 rename = "envKey",
5129 default,
5130 deserialize_with = "deserialize_patch_field",
5131 skip_serializing_if = "Option::is_none"
5132 )]
5133 env_key: Option<Option<String>>,
5134 },
5135 #[serde(rename = "bedrock")]
5137 Bedrock {
5138 #[serde(rename = "providerId")]
5139 provider_id: BedrockProviderId,
5140 #[serde(
5141 default,
5142 deserialize_with = "deserialize_patch_field",
5143 skip_serializing_if = "Option::is_none"
5144 )]
5145 profile: Option<Option<String>>,
5146 #[serde(
5147 default,
5148 deserialize_with = "deserialize_patch_field",
5149 skip_serializing_if = "Option::is_none"
5150 )]
5151 region: Option<Option<String>>,
5152 },
5153 #[serde(rename = "gcp")]
5155 Gcp {
5156 #[serde(rename = "providerId")]
5157 provider_id: GcpProviderId,
5158 #[serde(
5159 rename = "projectId",
5160 default,
5161 deserialize_with = "deserialize_patch_field",
5162 skip_serializing_if = "Option::is_none"
5163 )]
5164 project_id: Option<Option<String>>,
5165 #[serde(
5166 default,
5167 deserialize_with = "deserialize_patch_field",
5168 skip_serializing_if = "Option::is_none"
5169 )]
5170 location: Option<Option<String>>,
5171 #[serde(
5172 rename = "credentialFile",
5173 default,
5174 deserialize_with = "deserialize_patch_field",
5175 skip_serializing_if = "Option::is_none"
5176 )]
5177 credential_file: Option<Option<String>>,
5178 },
5179}
5180
5181fn deserialize_patch_field<'de, D>(deserializer: D) -> Result<Option<Option<String>>, D::Error>
5183where
5184 D: serde::Deserializer<'de>,
5185{
5186 Option::<String>::deserialize(deserializer).map(Some)
5187}
5188
5189fn deserialize_patch_name<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
5191where
5192 D: serde::Deserializer<'de>,
5193{
5194 String::deserialize(deserializer).map(Some)
5195}
5196
5197#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
5199pub enum BedrockProviderId {
5200 #[serde(rename = "amazon-bedrock")]
5201 AmazonBedrock,
5202 #[serde(rename = "amazon-bedrock-runtime")]
5203 AmazonBedrockRuntime,
5204}
5205
5206#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
5208pub enum GcpProviderId {
5209 #[serde(rename = "gcp")]
5210 Gcp,
5211}
5212
5213#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5218#[serde(tag = "type", rename_all = "camelCase")]
5219pub enum ModelProviderError {
5220 #[serde(rename = "modelProviderMismatch")]
5221 ModelProviderMismatch {
5222 #[serde(rename = "modelProvider")]
5223 model_provider: String,
5224 #[serde(rename = "currentModelProvider")]
5225 current_model_provider: String,
5226 },
5227 #[serde(rename = "modelProviderNotConfigured")]
5228 ModelProviderNotConfigured {
5229 #[serde(rename = "modelProvider")]
5230 model_provider: String,
5231 },
5232 #[serde(rename = "modelProviderPolicyConflict")]
5233 ModelProviderPolicyConflict {
5234 #[serde(rename = "modelProvider")]
5235 model_provider: String,
5236 #[serde(rename = "requiredModelProvider")]
5237 required_model_provider: String,
5238 },
5239}
5240
5241#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5242pub enum ModelRerouteReason {
5243 #[serde(rename = "highRiskCyberActivity")]
5244 HighRiskCyberActivity,
5245}
5246
5247#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5248#[serde(rename_all = "camelCase")]
5249pub struct ModelReroutedNotification {
5250 #[serde(rename = "fromModel", default)]
5251 pub from_model: String,
5252 #[serde()]
5253 pub reason: ModelRerouteReason,
5254 #[serde(rename = "threadId", default)]
5255 pub thread_id: String,
5256 #[serde(rename = "toModel", default)]
5257 pub to_model: String,
5258 #[serde(rename = "turnId", default)]
5259 pub turn_id: String,
5260}
5261
5262#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5263#[serde(rename_all = "camelCase")]
5264pub struct ModelSafetyBufferingUpdatedNotification {
5265 #[serde(
5266 rename = "fasterModel",
5267 default,
5268 skip_serializing_if = "Option::is_none"
5269 )]
5270 pub faster_model: Option<String>,
5271 #[serde(default)]
5272 pub model: String,
5273 #[serde(default)]
5274 pub reasons: Vec<String>,
5275 #[serde(rename = "showBufferingUi", default)]
5276 pub show_buffering_ui: bool,
5277 #[serde(rename = "threadId", default)]
5278 pub thread_id: String,
5279 #[serde(rename = "turnId", default)]
5280 pub turn_id: String,
5281 #[serde(rename = "useCases", default)]
5282 pub use_cases: Vec<String>,
5283}
5284
5285#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5286#[serde(rename_all = "camelCase")]
5287pub struct ModelServiceTier {
5288 #[serde(default)]
5289 pub description: String,
5290 #[serde(default)]
5291 pub id: String,
5292 #[serde(default)]
5293 pub name: String,
5294}
5295
5296#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5297#[serde(rename_all = "camelCase")]
5298pub struct ModelUpgradeInfo {
5299 #[serde(
5300 rename = "migrationMarkdown",
5301 default,
5302 skip_serializing_if = "Option::is_none"
5303 )]
5304 pub migration_markdown: Option<String>,
5305 #[serde(default)]
5306 pub model: String,
5307 #[serde(
5310 rename = "retirementAt",
5311 default,
5312 skip_serializing_if = "Option::is_none"
5313 )]
5314 pub retirement_at: Option<i64>,
5315 #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
5316 pub model_link: Option<String>,
5317 #[serde(
5318 rename = "upgradeCopy",
5319 default,
5320 skip_serializing_if = "Option::is_none"
5321 )]
5322 pub upgrade_copy: Option<String>,
5323}
5324
5325#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5326pub enum ModelVerification {
5327 #[serde(rename = "trustedAccessForCyber")]
5328 TrustedAccessForCyber,
5329}
5330
5331#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5332#[serde(rename_all = "camelCase")]
5333pub struct ModelVerificationNotification {
5334 #[serde(rename = "threadId", default)]
5335 pub thread_id: String,
5336 #[serde(rename = "turnId", default)]
5337 pub turn_id: String,
5338 #[serde(default)]
5339 pub verifications: Vec<ModelVerification>,
5340}
5341
5342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5343#[serde(rename_all = "camelCase")]
5344pub struct ModelsRequirements {
5345 #[serde(rename = "newThread", default, skip_serializing_if = "Option::is_none")]
5346 pub new_thread: Option<NewThreadModelDefaults>,
5347}
5348
5349#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5350pub enum MultiAgentVersion {
5351 #[serde(rename = "disabled")]
5352 Disabled,
5353 #[serde(rename = "v1")]
5354 V1,
5355 #[serde(rename = "v2")]
5356 V2,
5357}
5358
5359#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5360pub enum NetworkAccess {
5361 #[serde(rename = "restricted")]
5362 Restricted,
5363 #[serde(rename = "enabled")]
5364 Enabled,
5365}
5366
5367#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5368#[serde(rename_all = "camelCase")]
5369pub struct NetworkApprovalContext {
5370 #[serde(default)]
5371 pub host: String,
5372 #[serde()]
5373 pub protocol: NetworkApprovalProtocol,
5374}
5375
5376#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5377pub enum NetworkApprovalProtocol {
5378 #[serde(rename = "http")]
5379 Http,
5380 #[serde(rename = "https")]
5381 Https,
5382 #[serde(rename = "socks5Tcp")]
5383 Socks5Tcp,
5384 #[serde(rename = "socks5Udp")]
5385 Socks5Udp,
5386}
5387
5388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5389#[serde(rename_all = "camelCase")]
5390pub struct NetworkPolicyAmendment {
5391 #[serde()]
5392 pub action: NetworkPolicyRuleAction,
5393 #[serde(default)]
5394 pub host: String,
5395}
5396
5397#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5398pub enum NetworkPolicyRuleAction {
5399 #[serde(rename = "allow")]
5400 Allow,
5401 #[serde(rename = "deny")]
5402 Deny,
5403}
5404
5405#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5406#[serde(rename_all = "camelCase")]
5407pub struct NewThreadModelDefaults {
5408 #[serde(default, skip_serializing_if = "Option::is_none")]
5409 pub model: Option<String>,
5410 #[serde(
5411 rename = "modelReasoningEffort",
5412 default,
5413 skip_serializing_if = "Option::is_none"
5414 )]
5415 pub model_reasoning_effort: Option<ReasoningEffort>,
5416 #[serde(
5417 rename = "serviceTier",
5418 default,
5419 skip_serializing_if = "Option::is_none"
5420 )]
5421 pub service_tier: Option<String>,
5422}
5423
5424#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5425pub enum NonSteerableTurnKind {
5426 #[serde(rename = "review")]
5427 Review,
5428 #[serde(rename = "compact")]
5429 Compact,
5430}
5431
5432#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5434#[serde(rename_all = "kebab-case")]
5435pub enum OtelExporter {
5436 None,
5437 Statsig,
5438 OtlpHttp {
5439 endpoint: String,
5440 headers: std::collections::BTreeMap<String, String>,
5442 protocol: OtelHttpProtocol,
5443 #[serde(default, skip_serializing_if = "Option::is_none")]
5444 tls: Option<OtelTlsConfig>,
5445 },
5446 OtlpGrpc {
5447 endpoint: String,
5448 headers: std::collections::BTreeMap<String, String>,
5450 #[serde(default, skip_serializing_if = "Option::is_none")]
5451 tls: Option<OtelTlsConfig>,
5452 },
5453}
5454
5455#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5456#[serde(rename_all = "kebab-case")]
5457pub enum OtelHttpProtocol {
5458 Binary,
5459 Json,
5460}
5461
5462#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5465#[serde(rename_all = "snake_case")]
5466pub struct OtelRequirements {
5467 #[serde(default, skip_serializing_if = "Option::is_none")]
5468 pub tool_result: Option<OtelToolResultLogConfig>,
5469 #[serde(default, skip_serializing_if = "Option::is_none")]
5470 pub log_sse_deltas: Option<bool>,
5471 #[serde(default, skip_serializing_if = "Option::is_none")]
5472 pub log_user_prompt: Option<bool>,
5473 #[serde(default, skip_serializing_if = "Option::is_none")]
5474 pub log_agent_responses: Option<bool>,
5475 #[serde(default, skip_serializing_if = "Option::is_none")]
5476 pub log_guardian_assessments: Option<bool>,
5477 #[serde(default, skip_serializing_if = "Option::is_none")]
5478 pub environment: Option<String>,
5479 #[serde(default, skip_serializing_if = "Option::is_none")]
5480 pub exporter: Option<OtelExporter>,
5481 #[serde(default, skip_serializing_if = "Option::is_none")]
5482 pub trace_exporter: Option<OtelExporter>,
5483 #[serde(default, skip_serializing_if = "Option::is_none")]
5484 pub metrics_exporter: Option<OtelExporter>,
5485 #[serde(default, skip_serializing_if = "Option::is_none")]
5486 pub span_attributes: Option<std::collections::BTreeMap<String, String>>,
5487 #[serde(default, skip_serializing_if = "Option::is_none")]
5488 pub tracestate:
5489 Option<std::collections::BTreeMap<String, std::collections::BTreeMap<String, String>>>,
5490}
5491
5492#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
5493#[serde(rename_all = "kebab-case")]
5494pub struct OtelTlsConfig {
5495 #[serde(default, skip_serializing_if = "Option::is_none")]
5496 pub ca_certificate: Option<String>,
5497 #[serde(default, skip_serializing_if = "Option::is_none")]
5498 pub client_certificate: Option<String>,
5499 #[serde(default, skip_serializing_if = "Option::is_none")]
5500 pub client_private_key: Option<String>,
5501}
5502
5503#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
5504#[serde(rename_all = "snake_case")]
5505pub struct OtelToolResultLogConfig {
5506 pub max_bytes: u64,
5507}
5508
5509#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5510#[serde(rename_all = "camelCase")]
5511pub struct OverriddenMetadata {
5512 #[serde(rename = "effectiveValue", default)]
5513 pub effective_value: Value,
5514 #[serde(default)]
5515 pub message: String,
5516 #[serde(rename = "overridingLayer")]
5517 pub overriding_layer: ConfigLayerMetadata,
5518}
5519
5520#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5521#[serde(tag = "type", rename_all = "camelCase")]
5522pub enum ParsedCommand {
5523 Read {
5524 cmd: String,
5525 name: String,
5526 path: String,
5527 },
5528 List_files {
5529 cmd: String,
5530 #[serde(default, skip_serializing_if = "Option::is_none")]
5531 path: Option<String>,
5532 },
5533 Search {
5534 cmd: String,
5535 #[serde(default, skip_serializing_if = "Option::is_none")]
5536 path: Option<String>,
5537 #[serde(default, skip_serializing_if = "Option::is_none")]
5538 query: Option<String>,
5539 },
5540 Unknown {
5541 cmd: String,
5542 },
5543}
5544
5545#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5546pub enum PatchApplyStatus {
5547 #[serde(rename = "inProgress")]
5548 InProgress,
5549 #[serde(rename = "completed")]
5550 Completed,
5551 #[serde(rename = "failed")]
5552 Failed,
5553 #[serde(rename = "declined")]
5554 Declined,
5555}
5556
5557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5558#[serde(tag = "type", rename_all = "camelCase")]
5559pub enum PatchChangeKind {
5560 Add,
5561 Delete,
5562 Update {
5563 #[serde(default, skip_serializing_if = "Option::is_none")]
5564 move_path: Option<String>,
5565 },
5566}
5567
5568#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5569pub enum PermissionGrantScope {
5570 #[serde(rename = "turn")]
5571 Turn,
5572 #[serde(rename = "session")]
5573 Session,
5574}
5575
5576#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5577#[serde(rename_all = "camelCase")]
5578pub struct PermissionProfileListParams {
5579 #[serde(default, skip_serializing_if = "Option::is_none")]
5580 pub cursor: Option<String>,
5581 #[serde(default, skip_serializing_if = "Option::is_none")]
5582 pub cwd: Option<String>,
5583 #[serde(default, skip_serializing_if = "Option::is_none")]
5584 pub limit: Option<i64>,
5585}
5586
5587#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5588#[serde(rename_all = "camelCase")]
5589pub struct PermissionProfileListResponse {
5590 #[serde(default)]
5591 pub data: Vec<PermissionProfileSummary>,
5592 #[serde(
5593 rename = "nextCursor",
5594 default,
5595 skip_serializing_if = "Option::is_none"
5596 )]
5597 pub next_cursor: Option<String>,
5598}
5599
5600#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5601#[serde(rename_all = "camelCase")]
5602pub struct PermissionProfileSummary {
5603 #[serde(default)]
5604 pub allowed: bool,
5605 #[serde(default, skip_serializing_if = "Option::is_none")]
5606 pub description: Option<String>,
5607 #[serde(default)]
5608 pub id: String,
5609}
5610
5611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5612#[serde(rename_all = "camelCase")]
5613pub struct PermissionsRequestApprovalParams {
5614 #[serde()]
5615 pub cwd: LegacyAppPathString,
5616 #[serde(
5617 rename = "environmentId",
5618 default,
5619 skip_serializing_if = "Option::is_none"
5620 )]
5621 pub environment_id: Option<String>,
5622 #[serde(rename = "itemId", default)]
5623 pub item_id: String,
5624 #[serde()]
5625 pub permissions: RequestPermissionProfile,
5626 #[serde(default, skip_serializing_if = "Option::is_none")]
5627 pub reason: Option<String>,
5628 #[serde(rename = "startedAtMs", default)]
5629 pub started_at_ms: i64,
5630 #[serde(rename = "threadId", default)]
5631 pub thread_id: String,
5632 #[serde(rename = "turnId", default)]
5633 pub turn_id: String,
5634}
5635
5636#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5637#[serde(rename_all = "camelCase")]
5638pub struct PermissionsRequestApprovalResponse {
5639 #[serde()]
5640 pub permissions: GrantedPermissionProfile,
5641 #[serde(default, skip_serializing_if = "Option::is_none")]
5642 pub scope: Option<Value>,
5643 #[serde(
5644 rename = "strictAutoReview",
5645 default,
5646 skip_serializing_if = "Option::is_none"
5647 )]
5648 pub strict_auto_review: Option<bool>,
5649}
5650
5651#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5656pub enum Personality {
5657 #[serde(rename = "none")]
5658 None,
5659 #[serde(rename = "friendly")]
5660 Friendly,
5661 #[serde(rename = "pragmatic")]
5662 Pragmatic,
5663}
5664
5665#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5666#[serde(rename_all = "camelCase")]
5667pub struct PlanDeltaNotification {
5668 #[serde(default)]
5669 pub delta: String,
5670 #[serde(rename = "itemId", default)]
5671 pub item_id: String,
5672 #[serde(rename = "threadId", default)]
5673 pub thread_id: String,
5674 #[serde(rename = "turnId", default)]
5675 pub turn_id: String,
5676}
5677
5678#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5679pub enum PlanType {
5680 #[serde(rename = "free")]
5681 Free,
5682 #[serde(rename = "go")]
5683 Go,
5684 #[serde(rename = "plus")]
5685 Plus,
5686 #[serde(rename = "pro")]
5687 Pro,
5688 #[serde(rename = "prolite")]
5689 Prolite,
5690 #[serde(rename = "promax")]
5691 Promax,
5692 #[serde(rename = "edu_plus")]
5693 Edu_plus,
5694 #[serde(rename = "edu_pro")]
5695 Edu_pro,
5696 #[serde(rename = "team")]
5697 Team,
5698 #[serde(rename = "self_serve_business_prolite")]
5699 Self_serve_business_prolite,
5700 #[serde(rename = "self_serve_business_usage_based")]
5701 Self_serve_business_usage_based,
5702 #[serde(rename = "business")]
5703 Business,
5704 #[serde(rename = "ent26")]
5705 Ent26,
5706 #[serde(rename = "enterprise_cbp_automation")]
5707 Enterprise_cbp_automation,
5708 #[serde(rename = "enterprise_cbp_usage_based")]
5709 Enterprise_cbp_usage_based,
5710 #[serde(rename = "enterprise")]
5711 Enterprise,
5712 #[serde(rename = "edu")]
5713 Edu,
5714 #[serde(rename = "sci")]
5715 Sci,
5716 #[serde(rename = "sci_plus")]
5717 Sci_plus,
5718 #[serde(rename = "unknown")]
5719 Unknown,
5720}
5721
5722#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5723pub enum PluginAuthPolicy {
5724 #[serde(rename = "ON_INSTALL")]
5725 ON_INSTALL,
5726 #[serde(rename = "ON_USE")]
5727 ON_USE,
5728}
5729
5730#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5731pub enum PluginAvailability {
5732 #[serde(rename = "DISABLED_BY_ADMIN")]
5733 DISABLEDBYADMIN,
5734 AVAILABLE,
5735}
5736
5737#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5738#[serde(rename_all = "camelCase")]
5739pub struct PluginDetail {
5740 #[serde(rename = "appTemplates", default)]
5741 pub app_templates: Vec<AppTemplateSummary>,
5742 #[serde(default)]
5743 pub apps: Vec<AppSummary>,
5744 #[serde(default, skip_serializing_if = "Option::is_none")]
5745 pub description: Option<String>,
5746 #[serde(default)]
5747 pub hooks: Vec<PluginHookSummary>,
5748 #[serde(rename = "marketplaceName", default)]
5749 pub marketplace_name: String,
5750 #[serde(
5751 rename = "marketplacePath",
5752 default,
5753 skip_serializing_if = "Option::is_none"
5754 )]
5755 pub marketplace_path: Option<AbsolutePathBuf>,
5756 #[serde(rename = "mcpServers", default)]
5757 pub mcp_servers: Vec<String>,
5758 #[serde(
5760 rename = "onboardingSkill",
5761 default,
5762 skip_serializing_if = "Option::is_none"
5763 )]
5764 pub onboarding_skill: Option<SkillSummary>,
5765 #[serde(
5766 rename = "scheduledTasks",
5767 default,
5768 skip_serializing_if = "Option::is_none"
5769 )]
5770 pub scheduled_tasks: Option<Vec<ScheduledTaskSummary>>,
5771 #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5772 pub share_url: Option<String>,
5773 #[serde(default)]
5774 pub skills: Vec<SkillSummary>,
5775 #[serde()]
5776 pub summary: PluginSummary,
5777}
5778
5779#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5780pub enum PluginDisabledReason {
5781 #[serde(rename = "disabled_by_admin")]
5782 Disabled_by_admin,
5783 #[serde(rename = "plan_not_eligible")]
5784 Plan_not_eligible,
5785 #[serde(rename = "required_app_unavailable")]
5786 Required_app_unavailable,
5787 #[serde(rename = "unknown")]
5788 Unknown,
5789}
5790
5791#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5792#[serde(rename_all = "camelCase")]
5793pub struct PluginHookSummary {
5794 #[serde(rename = "eventName")]
5795 pub event_name: HookEventName,
5796 #[serde(default)]
5797 pub key: String,
5798}
5799
5800#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5801#[serde(rename_all = "camelCase")]
5802pub struct PluginInstallParams {
5803 #[serde(
5804 rename = "installAttemptId",
5805 default,
5806 skip_serializing_if = "Option::is_none"
5807 )]
5808 pub install_attempt_id: Option<String>,
5809 #[serde(
5810 rename = "marketplacePath",
5811 default,
5812 skip_serializing_if = "Option::is_none"
5813 )]
5814 pub marketplace_path: Option<AbsolutePathBuf>,
5815 #[serde(rename = "pluginName", default)]
5816 pub plugin_name: String,
5817 #[serde(
5818 rename = "remoteMarketplaceName",
5819 default,
5820 skip_serializing_if = "Option::is_none"
5821 )]
5822 pub remote_marketplace_name: Option<String>,
5823}
5824
5825#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5826pub enum PluginInstallPolicy {
5827 #[serde(rename = "NOT_AVAILABLE")]
5828 NOT_AVAILABLE,
5829 #[serde(rename = "AVAILABLE")]
5830 AVAILABLE,
5831 #[serde(rename = "INSTALLED_BY_DEFAULT")]
5832 INSTALLED_BY_DEFAULT,
5833}
5834
5835#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5836pub enum PluginInstallPolicySource {
5837 #[serde(rename = "WORKSPACE_SETTING")]
5838 WORKSPACE_SETTING,
5839 #[serde(rename = "IMPLICIT_CANONICAL_APP")]
5840 IMPLICIT_CANONICAL_APP,
5841}
5842
5843#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5844#[serde(rename_all = "camelCase")]
5845pub struct PluginInstallResponse {
5846 #[serde(rename = "appsNeedingAuth", default)]
5847 pub apps_needing_auth: Vec<AppSummary>,
5848 #[serde(rename = "authPolicy")]
5849 pub auth_policy: PluginAuthPolicy,
5850}
5851
5852#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5853#[serde(rename_all = "camelCase")]
5854pub struct PluginInstalledParams {
5855 #[serde(default, skip_serializing_if = "Option::is_none")]
5856 pub cwds: Option<Vec<AbsolutePathBuf>>,
5857 #[serde(
5858 rename = "installSuggestionPluginNames",
5859 default,
5860 skip_serializing_if = "Option::is_none"
5861 )]
5862 pub install_suggestion_plugin_names: Option<Vec<String>>,
5863}
5864
5865#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5866#[serde(rename_all = "camelCase")]
5867pub struct PluginInstalledResponse {
5868 #[serde(
5869 rename = "marketplaceLoadErrors",
5870 default,
5871 skip_serializing_if = "Option::is_none"
5872 )]
5873 pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5874 #[serde(default)]
5875 pub marketplaces: Vec<PluginMarketplaceEntry>,
5876}
5877
5878#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5879#[serde(rename_all = "camelCase")]
5880pub struct PluginInterface {
5881 #[serde(
5882 rename = "brandColor",
5883 default,
5884 skip_serializing_if = "Option::is_none"
5885 )]
5886 pub brand_color: Option<String>,
5887 #[serde(default)]
5888 pub capabilities: Vec<String>,
5889 #[serde(default, skip_serializing_if = "Option::is_none")]
5890 pub category: Option<String>,
5891 #[serde(
5892 rename = "composerIcon",
5893 default,
5894 skip_serializing_if = "Option::is_none"
5895 )]
5896 pub composer_icon: Option<AbsolutePathBuf>,
5897 #[serde(
5898 rename = "composerIconUrl",
5899 default,
5900 skip_serializing_if = "Option::is_none"
5901 )]
5902 pub composer_icon_url: Option<String>,
5903 #[serde(
5904 rename = "defaultPrompt",
5905 default,
5906 skip_serializing_if = "Option::is_none"
5907 )]
5908 pub default_prompt: Option<Vec<String>>,
5909 #[serde(
5910 rename = "developerName",
5911 default,
5912 skip_serializing_if = "Option::is_none"
5913 )]
5914 pub developer_name: Option<String>,
5915 #[serde(
5916 rename = "displayName",
5917 default,
5918 skip_serializing_if = "Option::is_none"
5919 )]
5920 pub display_name: Option<String>,
5921 #[serde(default, skip_serializing_if = "Option::is_none")]
5922 pub logo: Option<AbsolutePathBuf>,
5923 #[serde(rename = "logoDark", default, skip_serializing_if = "Option::is_none")]
5924 pub logo_dark: Option<AbsolutePathBuf>,
5925 #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
5926 pub logo_url: Option<String>,
5927 #[serde(
5928 rename = "logoUrlDark",
5929 default,
5930 skip_serializing_if = "Option::is_none"
5931 )]
5932 pub logo_url_dark: Option<String>,
5933 #[serde(
5934 rename = "longDescription",
5935 default,
5936 skip_serializing_if = "Option::is_none"
5937 )]
5938 pub long_description: Option<String>,
5939 #[serde(
5940 rename = "privacyPolicyUrl",
5941 default,
5942 skip_serializing_if = "Option::is_none"
5943 )]
5944 pub privacy_policy_url: Option<String>,
5945 #[serde(rename = "screenshotUrls", default)]
5946 pub screenshot_urls: Vec<String>,
5947 #[serde(default)]
5948 pub screenshots: Vec<AbsolutePathBuf>,
5949 #[serde(
5950 rename = "shortDescription",
5951 default,
5952 skip_serializing_if = "Option::is_none"
5953 )]
5954 pub short_description: Option<String>,
5955 #[serde(
5956 rename = "termsOfServiceUrl",
5957 default,
5958 skip_serializing_if = "Option::is_none"
5959 )]
5960 pub terms_of_service_url: Option<String>,
5961 #[serde(
5962 rename = "websiteUrl",
5963 default,
5964 skip_serializing_if = "Option::is_none"
5965 )]
5966 pub website_url: Option<String>,
5967}
5968
5969#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5970pub enum PluginListMarketplaceKind {
5971 #[serde(rename = "local")]
5972 Local,
5973 #[serde(rename = "vertical")]
5974 Vertical,
5975 #[serde(rename = "workspace-directory")]
5976 Workspace_directory,
5977 #[serde(rename = "shared-with-me")]
5978 Shared_with_me,
5979 #[serde(rename = "created-by-me-remote")]
5980 Created_by_me_remote,
5981}
5982
5983#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5984#[serde(rename_all = "camelCase")]
5985pub struct PluginListParams {
5986 #[serde(default, skip_serializing_if = "Option::is_none")]
5987 pub cwds: Option<Vec<AbsolutePathBuf>>,
5988 #[serde(
5989 rename = "forceRefetch",
5990 default,
5991 skip_serializing_if = "Option::is_none"
5992 )]
5993 pub force_refetch: Option<bool>,
5994 #[serde(
5995 rename = "marketplaceKinds",
5996 default,
5997 skip_serializing_if = "Option::is_none"
5998 )]
5999 pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
6000}
6001
6002#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6003#[serde(rename_all = "camelCase")]
6004pub struct PluginListResponse {
6005 #[serde(
6006 rename = "featuredPluginIds",
6007 default,
6008 skip_serializing_if = "Option::is_none"
6009 )]
6010 pub featured_plugin_ids: Option<Vec<String>>,
6011 #[serde(
6012 rename = "marketplaceLoadErrors",
6013 default,
6014 skip_serializing_if = "Option::is_none"
6015 )]
6016 pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
6017 #[serde(default)]
6018 pub marketplaces: Vec<PluginMarketplaceEntry>,
6019}
6020
6021#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6022#[serde(rename_all = "camelCase")]
6023pub struct PluginMarketplaceEntry {
6024 #[serde(default, skip_serializing_if = "Option::is_none")]
6025 pub interface: Option<MarketplaceInterface>,
6026 #[serde(default)]
6027 pub name: String,
6028 #[serde(default, skip_serializing_if = "Option::is_none")]
6029 pub path: Option<AbsolutePathBuf>,
6030 #[serde(default)]
6031 pub plugins: Vec<PluginSummary>,
6032}
6033
6034#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6035#[serde(rename_all = "camelCase")]
6036pub struct PluginReadParams {
6037 #[serde(
6038 rename = "marketplacePath",
6039 default,
6040 skip_serializing_if = "Option::is_none"
6041 )]
6042 pub marketplace_path: Option<AbsolutePathBuf>,
6043 #[serde(rename = "pluginName", default)]
6044 pub plugin_name: String,
6045 #[serde(
6046 rename = "remoteMarketplaceName",
6047 default,
6048 skip_serializing_if = "Option::is_none"
6049 )]
6050 pub remote_marketplace_name: Option<String>,
6051}
6052
6053#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6054#[serde(rename_all = "camelCase")]
6055pub struct PluginReadResponse {
6056 #[serde()]
6057 pub plugin: PluginDetail,
6058}
6059
6060#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6066#[serde(rename_all = "camelCase")]
6067pub struct PluginReconcileChangedPlugin {
6068 #[serde(rename = "hasApps", default)]
6069 pub has_apps: bool,
6070 #[serde(rename = "hasHooks", default)]
6071 pub has_hooks: bool,
6072 #[serde(rename = "hasMcps", default)]
6073 pub has_mcps: bool,
6074 #[serde(rename = "hasSkills", default)]
6077 pub has_skills: bool,
6078 #[serde(default)]
6080 pub id: String,
6081}
6082
6083#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6084#[serde(rename_all = "camelCase")]
6085pub struct PluginReconcileParams {
6086 #[serde(default, skip_serializing_if = "Option::is_none")]
6089 pub reason: Option<String>,
6090}
6091
6092#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6096#[serde(rename_all = "camelCase")]
6097pub struct PluginReconcileResponse {
6098 #[serde(rename = "changedPlugins", default)]
6103 pub changed_plugins: Vec<PluginReconcileChangedPlugin>,
6104 #[serde(rename = "failedMaterializationRemotePluginIds", default)]
6107 pub failed_materialization_remote_plugin_ids: Vec<String>,
6108 #[serde(rename = "failedRemotePluginIds", default)]
6110 pub failed_remote_plugin_ids: Vec<String>,
6111}
6112
6113#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6114#[serde(rename_all = "camelCase")]
6115pub struct PluginShareCheckoutParams {
6116 #[serde(rename = "remotePluginId", default)]
6117 pub remote_plugin_id: String,
6118}
6119
6120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6121#[serde(rename_all = "camelCase")]
6122pub struct PluginShareCheckoutResponse {
6123 #[serde(rename = "marketplaceName", default)]
6124 pub marketplace_name: String,
6125 #[serde(rename = "marketplacePath")]
6126 pub marketplace_path: AbsolutePathBuf,
6127 #[serde(rename = "pluginId", default)]
6128 pub plugin_id: String,
6129 #[serde(rename = "pluginName", default)]
6130 pub plugin_name: String,
6131 #[serde(rename = "pluginPath")]
6132 pub plugin_path: AbsolutePathBuf,
6133 #[serde(rename = "remotePluginId", default)]
6134 pub remote_plugin_id: String,
6135 #[serde(
6136 rename = "remoteVersion",
6137 default,
6138 skip_serializing_if = "Option::is_none"
6139 )]
6140 pub remote_version: Option<String>,
6141}
6142
6143#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6144#[serde(rename_all = "camelCase")]
6145pub struct PluginShareContext {
6146 #[serde(
6147 rename = "canPublishToWorkspace",
6148 default,
6149 skip_serializing_if = "Option::is_none"
6150 )]
6151 pub can_publish_to_workspace: Option<bool>,
6152 #[serde(
6153 rename = "creatorAccountUserId",
6154 default,
6155 skip_serializing_if = "Option::is_none"
6156 )]
6157 pub creator_account_user_id: Option<String>,
6158 #[serde(
6159 rename = "creatorName",
6160 default,
6161 skip_serializing_if = "Option::is_none"
6162 )]
6163 pub creator_name: Option<String>,
6164 #[serde(default, skip_serializing_if = "Option::is_none")]
6165 pub discoverability: Option<PluginShareDiscoverability>,
6166 #[serde(rename = "remotePluginId", default)]
6167 pub remote_plugin_id: String,
6168 #[serde(
6169 rename = "remoteVersion",
6170 default,
6171 skip_serializing_if = "Option::is_none"
6172 )]
6173 pub remote_version: Option<String>,
6174 #[serde(
6175 rename = "sharePrincipals",
6176 default,
6177 skip_serializing_if = "Option::is_none"
6178 )]
6179 pub share_principals: Option<Vec<PluginSharePrincipal>>,
6180 #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
6181 pub share_url: Option<String>,
6182}
6183
6184#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6185#[serde(rename_all = "camelCase")]
6186pub struct PluginShareDeleteParams {
6187 #[serde(rename = "remotePluginId", default)]
6188 pub remote_plugin_id: String,
6189}
6190
6191#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6192#[serde(rename_all = "camelCase")]
6193pub struct PluginShareDeleteResponse {
6194 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6195 pub extra: serde_json::Map<String, Value>,
6196}
6197
6198#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6199pub enum PluginShareDiscoverability {
6200 #[serde(rename = "LISTED")]
6201 LISTED,
6202 #[serde(rename = "UNLISTED")]
6203 UNLISTED,
6204 #[serde(rename = "PRIVATE")]
6205 PRIVATE,
6206}
6207
6208#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6209#[serde(rename_all = "camelCase")]
6210pub struct PluginShareListItem {
6211 #[serde(
6212 rename = "localPluginPath",
6213 default,
6214 skip_serializing_if = "Option::is_none"
6215 )]
6216 pub local_plugin_path: Option<AbsolutePathBuf>,
6217 #[serde()]
6218 pub plugin: PluginSummary,
6219}
6220
6221#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6222#[serde(rename_all = "camelCase")]
6223pub struct PluginShareListParams {
6224 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6225 pub extra: serde_json::Map<String, Value>,
6226}
6227
6228#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6229#[serde(rename_all = "camelCase")]
6230pub struct PluginShareListResponse {
6231 #[serde(default)]
6232 pub data: Vec<PluginShareListItem>,
6233}
6234
6235#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6236#[serde(rename_all = "camelCase")]
6237pub struct PluginSharePrincipal {
6238 #[serde(default)]
6239 pub name: String,
6240 #[serde(rename = "principalId", default)]
6241 pub principal_id: String,
6242 #[serde(rename = "principalType")]
6243 pub principal_type: PluginSharePrincipalType,
6244 #[serde()]
6245 pub role: PluginSharePrincipalRole,
6246}
6247
6248#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6249pub enum PluginSharePrincipalRole {
6250 #[serde(rename = "reader")]
6251 Reader,
6252 #[serde(rename = "editor")]
6253 Editor,
6254 #[serde(rename = "owner")]
6255 Owner,
6256}
6257
6258#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6259pub enum PluginSharePrincipalType {
6260 #[serde(rename = "user")]
6261 User,
6262 #[serde(rename = "group")]
6263 Group,
6264 #[serde(rename = "workspace")]
6265 Workspace,
6266}
6267
6268#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6269#[serde(rename_all = "camelCase")]
6270pub struct PluginShareSaveParams {
6271 #[serde(default, skip_serializing_if = "Option::is_none")]
6272 pub discoverability: Option<PluginShareDiscoverability>,
6273 #[serde(rename = "pluginPath")]
6274 pub plugin_path: AbsolutePathBuf,
6275 #[serde(
6276 rename = "remotePluginId",
6277 default,
6278 skip_serializing_if = "Option::is_none"
6279 )]
6280 pub remote_plugin_id: Option<String>,
6281 #[serde(
6282 rename = "shareTargets",
6283 default,
6284 skip_serializing_if = "Option::is_none"
6285 )]
6286 pub share_targets: Option<Vec<PluginShareTarget>>,
6287}
6288
6289#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6290#[serde(rename_all = "camelCase")]
6291pub struct PluginShareSaveResponse {
6292 #[serde(
6293 rename = "canPublishToWorkspace",
6294 default,
6295 skip_serializing_if = "Option::is_none"
6296 )]
6297 pub can_publish_to_workspace: Option<bool>,
6298 #[serde(rename = "remotePluginId", default)]
6299 pub remote_plugin_id: String,
6300 #[serde(rename = "shareUrl", default)]
6301 pub share_url: String,
6302}
6303
6304#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6305#[serde(rename_all = "camelCase")]
6306pub struct PluginShareTarget {
6307 #[serde(rename = "principalId", default)]
6308 pub principal_id: String,
6309 #[serde(rename = "principalType")]
6310 pub principal_type: PluginSharePrincipalType,
6311 #[serde()]
6312 pub role: PluginShareTargetRole,
6313}
6314
6315#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6316pub enum PluginShareTargetRole {
6317 #[serde(rename = "reader")]
6318 Reader,
6319 #[serde(rename = "editor")]
6320 Editor,
6321}
6322
6323#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6324pub enum PluginShareUpdateDiscoverability {
6325 #[serde(rename = "UNLISTED")]
6326 UNLISTED,
6327 #[serde(rename = "PRIVATE")]
6328 PRIVATE,
6329 #[serde(rename = "LISTED")]
6330 LISTED,
6331}
6332
6333#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6334#[serde(rename_all = "camelCase")]
6335pub struct PluginShareUpdateTargetsParams {
6336 #[serde()]
6337 pub discoverability: PluginShareUpdateDiscoverability,
6338 #[serde(rename = "remotePluginId", default)]
6339 pub remote_plugin_id: String,
6340 #[serde(rename = "shareTargets", default)]
6341 pub share_targets: Vec<PluginShareTarget>,
6342}
6343
6344#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6345#[serde(rename_all = "camelCase")]
6346pub struct PluginShareUpdateTargetsResponse {
6347 #[serde()]
6348 pub discoverability: PluginShareDiscoverability,
6349 #[serde(default)]
6350 pub principals: Vec<PluginSharePrincipal>,
6351}
6352
6353#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6354#[serde(rename_all = "camelCase")]
6355pub struct PluginSkillReadParams {
6356 #[serde(rename = "remoteMarketplaceName", default)]
6357 pub remote_marketplace_name: String,
6358 #[serde(rename = "remotePluginId", default)]
6359 pub remote_plugin_id: String,
6360 #[serde(rename = "skillName", default)]
6361 pub skill_name: String,
6362}
6363
6364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6365#[serde(rename_all = "camelCase")]
6366pub struct PluginSkillReadResponse {
6367 #[serde(default, skip_serializing_if = "Option::is_none")]
6368 pub contents: Option<String>,
6369}
6370
6371#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6372#[serde(tag = "type", rename_all = "camelCase")]
6373pub enum PluginSource {
6374 Local {
6375 path: AbsolutePathBuf,
6376 },
6377 Git {
6378 #[serde(default, skip_serializing_if = "Option::is_none")]
6379 path: Option<String>,
6380 #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
6381 ref_name: Option<String>,
6382 #[serde(default, skip_serializing_if = "Option::is_none")]
6383 sha: Option<String>,
6384 url: String,
6385 },
6386 Npm {
6387 package: String,
6388 #[serde(default, skip_serializing_if = "Option::is_none")]
6389 registry: Option<String>,
6390 #[serde(default, skip_serializing_if = "Option::is_none")]
6391 version: Option<String>,
6392 },
6393 Remote,
6394}
6395
6396#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6397#[serde(rename_all = "camelCase")]
6398pub struct PluginSummary {
6399 #[serde(rename = "authPolicy")]
6400 pub auth_policy: PluginAuthPolicy,
6401 #[serde(default, skip_serializing_if = "Option::is_none")]
6402 pub availability: Option<Value>,
6403 #[serde(
6404 rename = "disabledReason",
6405 default,
6406 skip_serializing_if = "Option::is_none"
6407 )]
6408 pub disabled_reason: Option<PluginDisabledReason>,
6409 #[serde(
6410 rename = "eligiblePlanTypes",
6411 default,
6412 skip_serializing_if = "Option::is_none"
6413 )]
6414 pub eligible_plan_types: Option<Vec<String>>,
6415 #[serde(default)]
6416 pub enabled: bool,
6417 #[serde(default)]
6418 pub id: String,
6419 #[serde(rename = "installPolicy")]
6420 pub install_policy: PluginInstallPolicy,
6421 #[serde(
6422 rename = "installPolicySource",
6423 default,
6424 skip_serializing_if = "Option::is_none"
6425 )]
6426 pub install_policy_source: Option<PluginInstallPolicySource>,
6427 #[serde(default)]
6428 pub installed: bool,
6429 #[serde(
6430 rename = "installedAt",
6431 default,
6432 skip_serializing_if = "Option::is_none"
6433 )]
6434 pub installed_at: Option<i64>,
6435 #[serde(default, skip_serializing_if = "Option::is_none")]
6436 pub interface: Option<PluginInterface>,
6437 #[serde(default, skip_serializing_if = "Option::is_none")]
6438 pub keywords: Option<Vec<String>>,
6439 #[serde(
6440 rename = "localVersion",
6441 default,
6442 skip_serializing_if = "Option::is_none"
6443 )]
6444 pub local_version: Option<String>,
6445 #[serde(
6446 rename = "mustShowInstallationInterstitial",
6447 default,
6448 skip_serializing_if = "Option::is_none"
6449 )]
6450 pub must_show_installation_interstitial: Option<bool>,
6451 #[serde(default)]
6452 pub name: String,
6453 #[serde(
6454 rename = "remotePluginId",
6455 default,
6456 skip_serializing_if = "Option::is_none"
6457 )]
6458 pub remote_plugin_id: Option<String>,
6459 #[serde(
6460 rename = "shareContext",
6461 default,
6462 skip_serializing_if = "Option::is_none"
6463 )]
6464 pub share_context: Option<PluginShareContext>,
6465 #[serde()]
6466 pub source: PluginSource,
6467 #[serde(default, skip_serializing_if = "Option::is_none")]
6468 pub version: Option<String>,
6469}
6470
6471#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6472#[serde(rename_all = "camelCase")]
6473pub struct PluginUninstallParams {
6474 #[serde(rename = "pluginId", default)]
6475 pub plugin_id: String,
6476}
6477
6478#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6479#[serde(rename_all = "camelCase")]
6480pub struct PluginUninstallResponse {
6481 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6482 pub extra: serde_json::Map<String, Value>,
6483}
6484
6485#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6486#[serde(rename_all = "camelCase")]
6487pub struct PluginsMigration {
6488 #[serde(rename = "marketplaceName", default)]
6489 pub marketplace_name: String,
6490 #[serde(rename = "pluginNames", default)]
6491 pub plugin_names: Vec<String>,
6492}
6493
6494#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6495#[serde(rename_all = "camelCase")]
6496pub struct ProcessExitedNotification {
6497 #[serde(rename = "exitCode", default)]
6498 pub exit_code: i64,
6499 #[serde(
6503 rename = "outputDrainTimedOut",
6504 default,
6505 skip_serializing_if = "Option::is_none"
6506 )]
6507 pub output_drain_timed_out: Option<bool>,
6508 #[serde(rename = "processHandle", default)]
6509 pub process_handle: String,
6510 #[serde(default)]
6511 pub stderr: String,
6512 #[serde(rename = "stderrCapReached", default)]
6513 pub stderr_cap_reached: bool,
6514 #[serde(default)]
6515 pub stdout: String,
6516 #[serde(rename = "stdoutCapReached", default)]
6517 pub stdout_cap_reached: bool,
6518}
6519
6520#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6521#[serde(rename_all = "camelCase")]
6522pub struct ProcessOutputDeltaNotification {
6523 #[serde(rename = "capReached", default)]
6524 pub cap_reached: bool,
6525 #[serde(rename = "deltaBase64", default)]
6526 pub delta_base64: String,
6527 #[serde(rename = "processHandle", default)]
6528 pub process_handle: String,
6529 #[serde(default)]
6530 pub stream: Value,
6531}
6532
6533#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6534pub enum ProcessOutputStream {
6535 #[serde(rename = "stdout")]
6536 Stdout,
6537 #[serde(rename = "stderr")]
6538 Stderr,
6539}
6540
6541#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6542pub enum RateLimitReachedType {
6543 #[serde(rename = "rate_limit_reached")]
6544 Rate_limit_reached,
6545 #[serde(rename = "workspace_owner_credits_depleted")]
6546 Workspace_owner_credits_depleted,
6547 #[serde(rename = "workspace_member_credits_depleted")]
6548 Workspace_member_credits_depleted,
6549 #[serde(rename = "workspace_owner_usage_limit_reached")]
6550 Workspace_owner_usage_limit_reached,
6551 #[serde(rename = "workspace_member_usage_limit_reached")]
6552 Workspace_member_usage_limit_reached,
6553}
6554
6555#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6556#[serde(rename_all = "camelCase")]
6557pub struct RateLimitResetCredit {
6558 #[serde(default, skip_serializing_if = "Option::is_none")]
6559 pub description: Option<String>,
6560 #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
6561 pub expires_at: Option<i64>,
6562 #[serde(rename = "grantedAt", default)]
6563 pub granted_at: i64,
6564 #[serde(default)]
6565 pub id: String,
6566 #[serde(rename = "resetType")]
6567 pub reset_type: RateLimitResetType,
6568 #[serde()]
6569 pub status: RateLimitResetCreditStatus,
6570 #[serde(default, skip_serializing_if = "Option::is_none")]
6571 pub title: Option<String>,
6572}
6573
6574#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6575pub enum RateLimitResetCreditStatus {
6576 #[serde(rename = "available")]
6577 Available,
6578 #[serde(rename = "redeeming")]
6579 Redeeming,
6580 #[serde(rename = "redeemed")]
6581 Redeemed,
6582 #[serde(rename = "unknown")]
6583 Unknown,
6584}
6585
6586#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6587#[serde(rename_all = "camelCase")]
6588pub struct RateLimitResetCreditsSummary {
6589 #[serde(rename = "availableCount", default)]
6590 pub available_count: i64,
6591 #[serde(default, skip_serializing_if = "Option::is_none")]
6592 pub credits: Option<Vec<RateLimitResetCredit>>,
6593}
6594
6595#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6596pub enum RateLimitResetType {
6597 #[serde(rename = "codexRateLimits")]
6598 CodexRateLimits,
6599 #[serde(rename = "unknown")]
6600 Unknown,
6601}
6602
6603#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6604#[serde(rename_all = "camelCase")]
6605pub struct RateLimitSnapshot {
6606 #[serde(default, skip_serializing_if = "Option::is_none")]
6607 pub credits: Option<CreditsSnapshot>,
6608 #[serde(
6609 rename = "individualLimit",
6610 default,
6611 skip_serializing_if = "Option::is_none"
6612 )]
6613 pub individual_limit: Option<SpendControlLimitSnapshot>,
6614 #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
6615 pub limit_id: Option<String>,
6616 #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
6617 pub limit_name: Option<String>,
6618 #[serde(
6621 rename = "normalModelSlug",
6622 default,
6623 skip_serializing_if = "Option::is_none"
6624 )]
6625 pub normal_model_slug: Option<String>,
6626 #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
6627 pub plan_type: Option<PlanType>,
6628 #[serde(default, skip_serializing_if = "Option::is_none")]
6629 pub primary: Option<RateLimitWindow>,
6630 #[serde(
6631 rename = "rateLimitReachedType",
6632 default,
6633 skip_serializing_if = "Option::is_none"
6634 )]
6635 pub rate_limit_reached_type: Option<RateLimitReachedType>,
6636 #[serde(default, skip_serializing_if = "Option::is_none")]
6637 pub secondary: Option<RateLimitWindow>,
6638 #[serde(
6639 rename = "spendControlReached",
6640 default,
6641 skip_serializing_if = "Option::is_none"
6642 )]
6643 pub spend_control_reached: Option<bool>,
6644}
6645
6646#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6647#[serde(rename_all = "camelCase")]
6648pub struct RateLimitWindow {
6649 #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
6650 pub resets_at: Option<i64>,
6651 #[serde(rename = "usedPercent", default)]
6652 pub used_percent: i64,
6653 #[serde(
6654 rename = "windowDurationMins",
6655 default,
6656 skip_serializing_if = "Option::is_none"
6657 )]
6658 pub window_duration_mins: Option<i64>,
6659}
6660
6661#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6662pub enum RealtimeConversationVersion {
6663 #[serde(rename = "v1")]
6664 V1,
6665 #[serde(rename = "v2")]
6666 V2,
6667 #[serde(rename = "v3")]
6668 V3,
6669}
6670
6671#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
6673#[serde(transparent)]
6674pub struct ReasoningEffort(pub String);
6675
6676#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6677#[serde(rename_all = "camelCase")]
6678pub struct ReasoningEffortOption {
6679 #[serde(default)]
6680 pub description: String,
6681 #[serde(rename = "reasoningEffort")]
6682 pub reasoning_effort: ReasoningEffort,
6683}
6684
6685#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6686pub enum ReasoningSummary {
6687 #[serde(rename = "auto")]
6688 Auto,
6689 #[serde(rename = "concise")]
6690 Concise,
6691 #[serde(rename = "detailed")]
6692 Detailed,
6693 #[serde(rename = "none")]
6694 None,
6695}
6696
6697#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6698#[serde(rename_all = "camelCase")]
6699pub struct ReasoningSummaryPartAddedNotification {
6700 #[serde(rename = "itemId", default)]
6701 pub item_id: String,
6702 #[serde(rename = "summaryIndex", default)]
6703 pub summary_index: i64,
6704 #[serde(rename = "threadId", default)]
6705 pub thread_id: String,
6706 #[serde(rename = "turnId", default)]
6707 pub turn_id: String,
6708}
6709
6710#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6711#[serde(rename_all = "camelCase")]
6712pub struct ReasoningSummaryTextDeltaNotification {
6713 #[serde(default)]
6714 pub delta: String,
6715 #[serde(rename = "itemId", default)]
6716 pub item_id: String,
6717 #[serde(rename = "summaryIndex", default)]
6718 pub summary_index: i64,
6719 #[serde(rename = "threadId", default)]
6720 pub thread_id: String,
6721 #[serde(rename = "turnId", default)]
6722 pub turn_id: String,
6723}
6724
6725#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6726#[serde(rename_all = "camelCase")]
6727pub struct ReasoningTextDeltaNotification {
6728 #[serde(rename = "contentIndex", default)]
6729 pub content_index: i64,
6730 #[serde(default)]
6731 pub delta: String,
6732 #[serde(rename = "itemId", default)]
6733 pub item_id: String,
6734 #[serde(rename = "threadId", default)]
6735 pub thread_id: String,
6736 #[serde(rename = "turnId", default)]
6737 pub turn_id: String,
6738}
6739
6740#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6741pub enum RemoteControlConnectionStatus {
6742 #[serde(rename = "disabled")]
6743 Disabled,
6744 #[serde(rename = "connecting")]
6745 Connecting,
6746 #[serde(rename = "connected")]
6747 Connected,
6748 #[serde(rename = "errored")]
6749 Errored,
6750}
6751
6752#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6753#[serde(rename_all = "camelCase")]
6754pub struct RemoteControlStatusChangedNotification {
6755 #[serde(
6756 rename = "environmentId",
6757 default,
6758 skip_serializing_if = "Option::is_none"
6759 )]
6760 pub environment_id: Option<String>,
6761 #[serde(rename = "installationId", default)]
6762 pub installation_id: String,
6763 #[serde(rename = "serverName", default)]
6764 pub server_name: String,
6765 #[serde()]
6766 pub status: RemoteControlConnectionStatus,
6767}
6768
6769#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6770#[serde(untagged)]
6771pub enum RequestId {
6772 Variant0(String),
6773 Variant1(i64),
6774}
6775
6776#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6777#[serde(rename_all = "camelCase")]
6778pub struct RequestPermissionProfile {
6779 #[serde(
6780 rename = "fileSystem",
6781 default,
6782 skip_serializing_if = "Option::is_none"
6783 )]
6784 pub file_system: Option<AdditionalFileSystemPermissions>,
6785 #[serde(default, skip_serializing_if = "Option::is_none")]
6786 pub network: Option<AdditionalNetworkPermissions>,
6787}
6788
6789#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6790pub enum ResidencyRequirement {
6791 #[serde(rename = "us")]
6792 Us,
6793}
6794
6795#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6796#[serde(rename_all = "camelCase")]
6797pub struct Resource {
6798 #[serde(default, skip_serializing_if = "Option::is_none")]
6799 pub _meta: Option<Value>,
6800 #[serde(default, skip_serializing_if = "Option::is_none")]
6801 pub annotations: Option<Value>,
6802 #[serde(default, skip_serializing_if = "Option::is_none")]
6803 pub description: Option<String>,
6804 #[serde(default, skip_serializing_if = "Option::is_none")]
6805 pub icons: Option<Vec<Value>>,
6806 #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6807 pub mime_type: Option<String>,
6808 #[serde(default)]
6809 pub name: String,
6810 #[serde(default, skip_serializing_if = "Option::is_none")]
6811 pub size: Option<i64>,
6812 #[serde(default, skip_serializing_if = "Option::is_none")]
6813 pub title: Option<String>,
6814 #[serde(default)]
6815 pub uri: String,
6816}
6817
6818#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6819#[serde(untagged)]
6820pub enum ResourceContent {
6821 Variant0(Value),
6822 Variant1(Value),
6823}
6824
6825#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6826#[serde(rename_all = "camelCase")]
6827pub struct ResourceTemplate {
6828 #[serde(default, skip_serializing_if = "Option::is_none")]
6829 pub annotations: Option<Value>,
6830 #[serde(default, skip_serializing_if = "Option::is_none")]
6831 pub description: Option<String>,
6832 #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6833 pub mime_type: Option<String>,
6834 #[serde(default)]
6835 pub name: String,
6836 #[serde(default, skip_serializing_if = "Option::is_none")]
6837 pub title: Option<String>,
6838 #[serde(rename = "uriTemplate", default)]
6839 pub uri_template: String,
6840}
6841
6842#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6844#[serde(rename_all = "camelCase")]
6845pub struct ResponseUsageMetadata {
6846 #[serde(default, skip_serializing_if = "Option::is_none")]
6847 pub amount: Option<String>,
6848 #[serde(default, skip_serializing_if = "Option::is_none")]
6849 pub metadata: Option<Value>,
6850}
6851
6852#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6853pub enum ReviewDecision {
6854 #[serde(rename = "approved")]
6855 Approved,
6856 #[serde(rename = "approved_execpolicy_amendment")]
6857 ApprovedExecpolicyAmendment {
6858 proposed_execpolicy_amendment: Vec<String>,
6859 },
6860 #[serde(rename = "approved_for_session")]
6861 ApprovedForSession,
6862 #[serde(rename = "approved_mcp_policy_amendment")]
6863 ApprovedMcpPolicyAmendment,
6864 #[serde(rename = "network_policy_amendment")]
6865 NetworkPolicyAmendment {
6866 network_policy_amendment: NetworkPolicyAmendment,
6867 },
6868 #[serde(rename = "denied")]
6869 Denied { rejection: String },
6870 #[serde(rename = "timed_out")]
6871 TimedOut,
6872 #[serde(rename = "abort")]
6873 Abort,
6874}
6875
6876#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6877pub enum ReviewDelivery {
6878 #[serde(rename = "inline")]
6879 Inline,
6880}
6881
6882#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6883#[serde(rename_all = "camelCase")]
6884pub struct ReviewStartParams {
6885 #[serde(default, skip_serializing_if = "Option::is_none")]
6889 pub delivery: Option<ReviewDelivery>,
6890 #[serde()]
6891 pub target: ReviewTarget,
6892 #[serde(rename = "threadId", default)]
6893 pub thread_id: String,
6894}
6895
6896#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6897#[serde(rename_all = "camelCase")]
6898pub struct ReviewStartResponse {
6899 #[serde(rename = "reviewThreadId", default)]
6901 pub review_thread_id: String,
6902 #[serde()]
6903 pub turn: Turn,
6904}
6905
6906#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6907#[serde(tag = "type", rename_all = "camelCase")]
6908pub enum ReviewTarget {
6909 #[serde(rename = "uncommittedChanges")]
6910 UncommittedChanges,
6911 #[serde(rename = "baseBranch")]
6912 BaseBranch {
6913 branch: String,
6914 },
6915 Commit {
6916 sha: String,
6917 #[serde(default, skip_serializing_if = "Option::is_none")]
6918 title: Option<String>,
6919 },
6920 Custom {
6921 instructions: String,
6922 },
6923}
6924
6925#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6927pub enum AgentMessageDelivery {
6928 #[serde(rename = "async")]
6929 Async,
6930}
6931
6932#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6934pub enum CliAuthCredentialsStoreMode {
6935 #[serde(rename = "file")]
6936 File,
6937 #[serde(rename = "keyring")]
6938 Keyring,
6939 #[serde(rename = "auto")]
6940 Auto,
6941 #[serde(rename = "ephemeral")]
6942 Ephemeral,
6943}
6944
6945#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6947pub struct Project {
6948 #[serde(rename = "createdAt", default)]
6949 pub created_at: i64,
6950 #[serde(default)]
6951 pub id: String,
6952 #[serde(default)]
6953 pub metadata: std::collections::HashMap<String, String>,
6954 #[serde(default)]
6955 pub name: String,
6956 #[serde(default)]
6957 pub position: i64,
6958 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
6961 pub recency_at: Option<i64>,
6962 #[serde(default)]
6963 pub roots: Vec<ProjectRoot>,
6964 #[serde(rename = "updatedAt", default)]
6965 pub updated_at: i64,
6966}
6967
6968#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6970pub enum ProjectSortKey {
6971 #[serde(rename = "position")]
6972 Position,
6973 #[serde(rename = "recencyAt")]
6974 RecencyAt,
6975}
6976
6977#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6978pub enum ProjectChangeType {
6979 #[serde(rename = "created")]
6980 Created,
6981 #[serde(rename = "updated")]
6982 Updated,
6983 #[serde(rename = "deleted")]
6984 Deleted,
6985}
6986
6987#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6989pub struct ProjectChangedNotification {
6990 #[serde(rename = "changeType")]
6991 pub change_type: ProjectChangeType,
6992 #[serde(rename = "projectId", default)]
6993 pub project_id: String,
6994}
6995
6996#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6997pub struct ProjectRoot {
6998 pub path: AbsolutePathBuf,
6999}
7000
7001#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7003pub struct QueuedSubmission {
7004 #[serde(rename = "clientUserMessageId", default)]
7005 pub client_user_message_id: String,
7006 #[serde(default)]
7007 pub id: String,
7008 #[serde(default)]
7009 pub input: Vec<UserInput>,
7010}
7011
7012#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7014pub struct StrictReviewRequiredNotification {
7015 #[serde(rename = "startedAtMs", default)]
7017 pub started_at_ms: i64,
7018 #[serde(rename = "threadId", default)]
7019 pub thread_id: String,
7020 #[serde(rename = "turnId", default)]
7021 pub turn_id: String,
7022}
7023
7024#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7026pub struct ThreadProjectUpdatedNotification {
7027 #[serde(rename = "projectId", default)]
7028 pub project_id: Option<String>,
7029 #[serde(rename = "threadId", default)]
7030 pub thread_id: String,
7031}
7032
7033#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7035pub struct ThreadQueueChangedNotification {
7036 #[serde(rename = "threadId", default)]
7037 pub thread_id: String,
7038}
7039
7040#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7042pub struct ThreadRevertedNotification {
7043 #[serde(rename = "threadId", default)]
7044 pub thread_id: String,
7045}
7046
7047#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7050#[serde(rename_all = "camelCase")]
7051pub struct ThreadPredictionUpdatedNotification {
7052 pub result: ThreadPredictionResult,
7053 #[serde(rename = "sourceTurnId", default)]
7054 pub source_turn_id: String,
7055 #[serde(rename = "threadId", default)]
7056 pub thread_id: String,
7057}
7058
7059#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7061#[serde(tag = "type", rename_all = "camelCase")]
7062pub enum ThreadPredictionResult {
7063 Completed {
7064 #[serde(default, skip_serializing_if = "Option::is_none")]
7065 text: Option<String>,
7066 },
7067 Failed,
7068}
7069
7070#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7072#[serde(rename_all = "camelCase")]
7073pub struct InAppBrowserRequirements {
7074 #[serde(
7075 rename = "allowExternalBrowserSettingsImport",
7076 default,
7077 skip_serializing_if = "Option::is_none"
7078 )]
7079 pub allow_external_browser_settings_import: Option<bool>,
7080}
7081
7082#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7084pub struct McpServerEventNotification {
7085 #[serde(default)]
7086 pub method: String,
7087 #[serde(default)]
7088 pub params: Value,
7089}
7090
7091#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7094pub struct McpServerEventStreamNotification {
7095 pub notification: McpServerEventNotification,
7096 #[serde(rename = "subscriptionId", default)]
7097 pub subscription_id: String,
7098}
7099
7100#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7103pub enum AllowDenyRequirement {
7104 #[serde(rename = "allow")]
7105 Allow,
7106 #[serde(rename = "deny")]
7107 Deny,
7108}
7109
7110#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7112pub enum BrowserUseAccessApprovalLifetime {
7113 #[serde(rename = "turn")]
7114 Turn,
7115 #[serde(rename = "thread")]
7116 Thread,
7117}
7118
7119#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7121pub enum McpServerConnectionStatus {
7122 #[serde(rename = "notStarted")]
7123 NotStarted,
7124 #[serde(rename = "starting")]
7125 Starting,
7126 #[serde(rename = "connected")]
7127 Connected,
7128 #[serde(rename = "authenticationRequired")]
7129 AuthenticationRequired,
7130 #[serde(rename = "failed")]
7131 Failed,
7132 #[serde(rename = "cancelled")]
7133 Cancelled,
7134 #[serde(rename = "disabled")]
7135 Disabled,
7136}
7137
7138#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7140#[serde(rename_all = "camelCase")]
7141pub struct BrowserUseOriginPolicy {
7142 #[serde(default, skip_serializing_if = "Option::is_none")]
7143 pub access: Option<AllowDenyRequirement>,
7144 #[serde(
7145 rename = "accessApprovalLifetime",
7146 default,
7147 skip_serializing_if = "Option::is_none"
7148 )]
7149 pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
7150 #[serde(
7151 rename = "autoReview",
7152 default,
7153 skip_serializing_if = "Option::is_none"
7154 )]
7155 pub auto_review: Option<AllowDenyRequirement>,
7156 #[serde(default, skip_serializing_if = "Option::is_none")]
7157 pub downloads: Option<AllowDenyRequirement>,
7158 #[serde(
7159 rename = "fullCdpAccess",
7160 default,
7161 skip_serializing_if = "Option::is_none"
7162 )]
7163 pub full_cdp_access: Option<AllowDenyRequirement>,
7164 #[serde(
7165 rename = "persistentApproval",
7166 default,
7167 skip_serializing_if = "Option::is_none"
7168 )]
7169 pub persistent_approval: Option<bool>,
7170 #[serde(default, skip_serializing_if = "Option::is_none")]
7171 pub uploads: Option<AllowDenyRequirement>,
7172}
7173
7174#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7176pub struct BrowserUseOriginPolicyConfig {
7177 #[serde(default, skip_serializing_if = "Option::is_none")]
7178 pub access: Option<AllowDenyRequirement>,
7179 #[serde(default, skip_serializing_if = "Option::is_none")]
7180 pub downloads: Option<AllowDenyRequirement>,
7181 #[serde(default, skip_serializing_if = "Option::is_none")]
7182 pub full_cdp_access: Option<AllowDenyRequirement>,
7183 #[serde(default, skip_serializing_if = "Option::is_none")]
7184 pub uploads: Option<AllowDenyRequirement>,
7185}
7186
7187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7189pub struct BrowserUseConfig {
7190 #[serde(default, skip_serializing_if = "Option::is_none")]
7191 pub allow_history_access: Option<bool>,
7192 #[serde(default, skip_serializing_if = "Option::is_none")]
7193 pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
7194 #[serde(default, skip_serializing_if = "Option::is_none")]
7195 pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
7196}
7197
7198#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7200pub struct ComputerUseConfig {
7201 #[serde(default, skip_serializing_if = "Option::is_none")]
7202 pub default_app_access: Option<AllowDenyRequirement>,
7203 #[serde(default, skip_serializing_if = "Option::is_none")]
7204 pub macos: Option<ComputerUseMacosConfig>,
7205 #[serde(default, skip_serializing_if = "Option::is_none")]
7206 pub windows: Option<ComputerUseWindowsConfig>,
7207}
7208
7209#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7210pub struct ComputerUseMacosConfig {
7211 #[serde(default, skip_serializing_if = "Option::is_none")]
7212 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7213}
7214
7215#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7216pub struct ComputerUseWindowsConfig {
7217 #[serde(default, skip_serializing_if = "Option::is_none")]
7218 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7219 #[serde(default, skip_serializing_if = "Option::is_none")]
7220 pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
7221}
7222
7223#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7224pub struct ComputerUseWindowsExeConfig {
7225 pub access: AllowDenyRequirement,
7226 #[serde(default, skip_serializing_if = "Option::is_none")]
7227 pub binary_name: Option<String>,
7228 #[serde(default)]
7229 pub product_name: String,
7230 #[serde(default)]
7231 pub publisher_name: String,
7232}
7233
7234#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7236#[serde(rename_all = "camelCase")]
7237pub struct ComputerUseMacosRequirements {
7238 #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
7239 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7240}
7241
7242#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7243#[serde(rename_all = "camelCase")]
7244pub struct ComputerUseWindowsRequirements {
7245 #[serde(default, skip_serializing_if = "Option::is_none")]
7246 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7247 #[serde(default, skip_serializing_if = "Option::is_none")]
7248 pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
7249}
7250
7251#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7252#[serde(rename_all = "camelCase")]
7253pub struct ComputerUseWindowsExeRequirement {
7254 pub access: AllowDenyRequirement,
7255 #[serde(
7256 rename = "binaryName",
7257 default,
7258 skip_serializing_if = "Option::is_none"
7259 )]
7260 pub binary_name: Option<String>,
7261 #[serde(rename = "productName", default)]
7262 pub product_name: String,
7263 #[serde(rename = "publisherName", default)]
7264 pub publisher_name: String,
7265}
7266
7267#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7268pub enum SandboxMode {
7269 #[serde(rename = "read-only")]
7270 Read_only,
7271 #[serde(rename = "workspace-write")]
7272 Workspace_write,
7273 #[serde(rename = "danger-full-access")]
7274 Danger_full_access,
7275}
7276
7277#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7278#[serde(tag = "type", rename_all = "camelCase")]
7279pub enum SandboxPolicy {
7280 #[serde(rename = "dangerFullAccess")]
7281 DangerFullAccess,
7282 #[serde(rename = "readOnly")]
7283 ReadOnly {
7284 #[serde(
7285 rename = "networkAccess",
7286 default,
7287 skip_serializing_if = "Option::is_none"
7288 )]
7289 network_access: Option<bool>,
7290 },
7291 #[serde(rename = "externalSandbox")]
7292 ExternalSandbox {
7293 #[serde(
7294 rename = "networkAccess",
7295 default,
7296 skip_serializing_if = "Option::is_none"
7297 )]
7298 network_access: Option<Value>,
7299 },
7300 #[serde(rename = "workspaceWrite")]
7301 WorkspaceWrite {
7302 #[serde(
7303 rename = "excludeSlashTmp",
7304 default,
7305 skip_serializing_if = "Option::is_none"
7306 )]
7307 exclude_slash_tmp: Option<bool>,
7308 #[serde(
7309 rename = "excludeTmpdirEnvVar",
7310 default,
7311 skip_serializing_if = "Option::is_none"
7312 )]
7313 exclude_tmpdir_env_var: Option<bool>,
7314 #[serde(
7315 rename = "networkAccess",
7316 default,
7317 skip_serializing_if = "Option::is_none"
7318 )]
7319 network_access: Option<bool>,
7320 #[serde(
7321 rename = "writableRoots",
7322 default,
7323 skip_serializing_if = "Option::is_none"
7324 )]
7325 writable_roots: Option<Vec<AbsolutePathBuf>>,
7326 },
7327}
7328
7329#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7330#[serde(rename_all = "snake_case")]
7331pub struct SandboxWorkspaceWrite {
7332 #[serde(default, skip_serializing_if = "Option::is_none")]
7333 pub exclude_slash_tmp: Option<bool>,
7334 #[serde(default, skip_serializing_if = "Option::is_none")]
7335 pub exclude_tmpdir_env_var: Option<bool>,
7336 #[serde(default, skip_serializing_if = "Option::is_none")]
7337 pub network_access: Option<bool>,
7338 #[serde(default, skip_serializing_if = "Option::is_none")]
7339 pub writable_roots: Option<Vec<String>>,
7340}
7341
7342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7343#[serde(tag = "type", rename_all = "camelCase")]
7344pub enum ScheduledTaskSchedule {
7345 Hourly {
7346 #[serde(default, skip_serializing_if = "Option::is_none")]
7347 days: Option<Vec<ScheduledTaskWeekday>>,
7348 #[serde(rename = "intervalHours")]
7349 interval_hours: i64,
7350 },
7351 Daily {
7352 time: String,
7353 },
7354 Weekdays {
7355 time: String,
7356 },
7357 Weekly {
7358 days: Vec<ScheduledTaskWeekday>,
7359 time: String,
7360 },
7361}
7362
7363#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7364#[serde(rename_all = "camelCase")]
7365pub struct ScheduledTaskSummary {
7366 #[serde(default)]
7367 pub key: String,
7368 #[serde(default)]
7369 pub name: String,
7370 #[serde(default)]
7371 pub prompt: String,
7372 #[serde()]
7373 pub schedule: ScheduledTaskSchedule,
7374}
7375
7376#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7377pub enum ScheduledTaskWeekday {
7378 #[serde(rename = "MO")]
7379 MO,
7380 #[serde(rename = "TU")]
7381 TU,
7382 #[serde(rename = "WE")]
7383 WE,
7384 #[serde(rename = "TH")]
7385 TH,
7386 #[serde(rename = "FR")]
7387 FR,
7388 #[serde(rename = "SA")]
7389 SA,
7390 #[serde(rename = "SU")]
7391 SU,
7392}
7393
7394#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7395#[serde(rename_all = "camelCase")]
7396pub struct SendAddCreditsNudgeEmailParams {
7397 #[serde(rename = "creditType")]
7398 pub credit_type: AddCreditsNudgeCreditType,
7399}
7400
7401#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7402#[serde(rename_all = "camelCase")]
7403pub struct SendAddCreditsNudgeEmailResponse {
7404 #[serde()]
7405 pub status: AddCreditsNudgeEmailStatus,
7406}
7407
7408#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7409#[serde(rename_all = "camelCase")]
7410pub struct ServerRequestResolvedNotification {
7411 #[serde(rename = "requestId")]
7412 pub request_id: RequestId,
7413 #[serde(rename = "threadId", default)]
7414 pub thread_id: String,
7415}
7416
7417#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7418#[serde(rename_all = "camelCase")]
7419pub struct SessionMigration {
7420 #[serde(default)]
7421 pub cwd: String,
7422 #[serde(default)]
7423 pub path: String,
7424 #[serde(default, skip_serializing_if = "Option::is_none")]
7425 pub title: Option<String>,
7426}
7427
7428#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7429pub enum SessionSource {
7430 #[serde(rename = "cli")]
7431 Cli,
7432 #[serde(rename = "vscode")]
7433 Vscode,
7434 #[serde(rename = "exec")]
7435 Exec,
7436 #[serde(rename = "appServer")]
7437 AppServer,
7438 #[serde(rename = "unknown")]
7439 Unknown,
7440 #[serde(rename = "custom")]
7441 Custom(String),
7442 #[serde(rename = "subAgent")]
7443 SubAgent(SubAgentSource),
7444}
7445
7446#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7447#[serde(rename_all = "camelCase")]
7448pub struct Settings {
7449 #[serde(default, skip_serializing_if = "Option::is_none")]
7450 pub developer_instructions: Option<String>,
7451 #[serde(default)]
7452 pub model: String,
7453 #[serde(default, skip_serializing_if = "Option::is_none")]
7454 pub reasoning_effort: Option<ReasoningEffort>,
7455}
7456
7457#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7458#[serde(rename_all = "camelCase")]
7459pub struct SkillDependencies {
7460 #[serde(default)]
7461 pub tools: Vec<SkillToolDependency>,
7462}
7463
7464#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7465#[serde(rename_all = "camelCase")]
7466pub struct SkillErrorInfo {
7467 #[serde(default)]
7468 pub message: String,
7469 #[serde(default)]
7470 pub path: String,
7471}
7472
7473#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7474#[serde(rename_all = "camelCase")]
7475pub struct SkillInterface {
7476 #[serde(
7477 rename = "brandColor",
7478 default,
7479 skip_serializing_if = "Option::is_none"
7480 )]
7481 pub brand_color: Option<String>,
7482 #[serde(
7483 rename = "defaultPrompt",
7484 default,
7485 skip_serializing_if = "Option::is_none"
7486 )]
7487 pub default_prompt: Option<String>,
7488 #[serde(
7489 rename = "displayName",
7490 default,
7491 skip_serializing_if = "Option::is_none"
7492 )]
7493 pub display_name: Option<String>,
7494 #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
7495 pub icon_large: Option<AbsolutePathBuf>,
7496 #[serde(
7497 rename = "iconLargeUrl",
7498 default,
7499 skip_serializing_if = "Option::is_none"
7500 )]
7501 pub icon_large_url: Option<String>,
7502 #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
7503 pub icon_small: Option<AbsolutePathBuf>,
7504 #[serde(
7505 rename = "iconSmallUrl",
7506 default,
7507 skip_serializing_if = "Option::is_none"
7508 )]
7509 pub icon_small_url: Option<String>,
7510 #[serde(
7511 rename = "shortDescription",
7512 default,
7513 skip_serializing_if = "Option::is_none"
7514 )]
7515 pub short_description: Option<String>,
7516}
7517
7518#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7519#[serde(rename_all = "camelCase")]
7520pub struct SkillMetadata {
7521 #[serde(default, skip_serializing_if = "Option::is_none")]
7522 pub dependencies: Option<SkillDependencies>,
7523 #[serde(default)]
7524 pub description: String,
7525 #[serde(default)]
7526 pub enabled: bool,
7527 #[serde(default, skip_serializing_if = "Option::is_none")]
7528 pub interface: Option<SkillInterface>,
7529 #[serde(default)]
7530 pub name: String,
7531 #[serde()]
7532 pub path: LegacyAppPathString,
7533 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7534 pub plugin_id: Option<String>,
7535 #[serde()]
7536 pub scope: SkillScope,
7537 #[serde(
7538 rename = "shortDescription",
7539 default,
7540 skip_serializing_if = "Option::is_none"
7541 )]
7542 pub short_description: Option<String>,
7543}
7544
7545#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7546#[serde(rename_all = "camelCase")]
7547pub struct SkillMigration {
7548 #[serde(default)]
7549 pub name: String,
7550}
7551
7552#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7553pub enum SkillScope {
7554 #[serde(rename = "user")]
7555 User,
7556 #[serde(rename = "repo")]
7557 Repo,
7558 #[serde(rename = "system")]
7559 System,
7560 #[serde(rename = "admin")]
7561 Admin,
7562}
7563
7564#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7565#[serde(rename_all = "camelCase")]
7566pub struct SkillSummary {
7567 #[serde(default)]
7568 pub description: String,
7569 #[serde(default)]
7570 pub enabled: bool,
7571 #[serde(default, skip_serializing_if = "Option::is_none")]
7572 pub interface: Option<SkillInterface>,
7573 #[serde(default)]
7574 pub name: String,
7575 #[serde(default, skip_serializing_if = "Option::is_none")]
7576 pub path: Option<LegacyAppPathString>,
7577 #[serde(
7578 rename = "shortDescription",
7579 default,
7580 skip_serializing_if = "Option::is_none"
7581 )]
7582 pub short_description: Option<String>,
7583}
7584
7585#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7586#[serde(rename_all = "camelCase")]
7587pub struct SkillToolDependency {
7588 #[serde(default, skip_serializing_if = "Option::is_none")]
7589 pub command: Option<String>,
7590 #[serde(default, skip_serializing_if = "Option::is_none")]
7591 pub description: Option<String>,
7592 #[serde(default, skip_serializing_if = "Option::is_none")]
7593 pub transport: Option<String>,
7594 #[serde(rename = "type", default)]
7595 pub type_: String,
7596 #[serde(default, skip_serializing_if = "Option::is_none")]
7597 pub url: Option<String>,
7598 #[serde(default)]
7599 pub value: String,
7600}
7601
7602#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7603#[serde(rename_all = "camelCase")]
7604pub struct SkillsChangedNotification {
7605 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7606 pub extra: serde_json::Map<String, Value>,
7607}
7608
7609#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7610#[serde(rename_all = "camelCase")]
7611pub struct SkillsConfigWriteParams {
7612 #[serde(default)]
7613 pub enabled: bool,
7614 #[serde(default, skip_serializing_if = "Option::is_none")]
7615 pub name: Option<String>,
7616 #[serde(default, skip_serializing_if = "Option::is_none")]
7617 pub path: Option<AbsolutePathBuf>,
7618}
7619
7620#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7621#[serde(rename_all = "camelCase")]
7622pub struct SkillsConfigWriteResponse {
7623 #[serde(rename = "effectiveEnabled", default)]
7624 pub effective_enabled: bool,
7625}
7626
7627#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7628#[serde(rename_all = "camelCase")]
7629pub struct SkillsExtraRootsSetParams {
7630 #[serde(rename = "extraRoots", default)]
7631 pub extra_roots: Vec<AbsolutePathBuf>,
7632}
7633
7634#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7635#[serde(rename_all = "camelCase")]
7636pub struct SkillsExtraRootsSetResponse {
7637 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7638 pub extra: serde_json::Map<String, Value>,
7639}
7640
7641#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7642#[serde(rename_all = "camelCase")]
7643pub struct SkillsListEntry {
7644 #[serde(default)]
7645 pub cwd: String,
7646 #[serde(default)]
7647 pub errors: Vec<SkillErrorInfo>,
7648 #[serde(default)]
7649 pub skills: Vec<SkillMetadata>,
7650}
7651
7652#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7653#[serde(rename_all = "camelCase")]
7654pub struct SkillsListParams {
7655 #[serde(default, skip_serializing_if = "Option::is_none")]
7656 pub cwds: Option<Vec<String>>,
7657 #[serde(
7658 rename = "forceReload",
7659 default,
7660 skip_serializing_if = "Option::is_none"
7661 )]
7662 pub force_reload: Option<bool>,
7663}
7664
7665#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7666#[serde(rename_all = "camelCase")]
7667pub struct SkillsListResponse {
7668 #[serde(default)]
7669 pub data: Vec<SkillsListEntry>,
7670}
7671
7672#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7673pub enum SortDirection {
7674 #[serde(rename = "asc")]
7675 Asc,
7676 #[serde(rename = "desc")]
7677 Desc,
7678}
7679
7680#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7681#[serde(rename_all = "camelCase")]
7682pub struct SpendControlLimitSnapshot {
7683 #[serde(default)]
7684 pub limit: String,
7685 #[serde(rename = "remainingPercent", default)]
7686 pub remaining_percent: i64,
7687 #[serde(rename = "resetsAt", default)]
7688 pub resets_at: i64,
7689 #[serde(default)]
7690 pub used: String,
7691}
7692
7693#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7694pub enum SubAgentActivityKind {
7695 #[serde(rename = "started")]
7696 Started,
7697 #[serde(rename = "interacted")]
7698 Interacted,
7699 #[serde(rename = "interrupted")]
7700 Interrupted,
7701 #[serde(rename = "completed")]
7702 Completed,
7703}
7704
7705#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7706pub enum SubAgentSource {
7707 #[serde(rename = "review")]
7708 Review,
7709 #[serde(rename = "compact")]
7710 Compact,
7711 #[serde(rename = "memory_consolidation")]
7712 MemoryConsolidation,
7713 #[serde(rename = "thread_spawn")]
7714 ThreadSpawn {
7715 #[serde(default, skip_serializing_if = "Option::is_none")]
7716 agent_nickname: Option<String>,
7717 #[serde(default, skip_serializing_if = "Option::is_none")]
7718 agent_path: Option<AgentPath>,
7719 #[serde(default, skip_serializing_if = "Option::is_none")]
7720 agent_role: Option<String>,
7721 depth: i64,
7722 parent_thread_id: ThreadId,
7723 },
7724 #[serde(rename = "other")]
7725 Other(String),
7726}
7727
7728#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7729#[serde(rename_all = "camelCase")]
7730pub struct SubagentMigration {
7731 #[serde(default)]
7732 pub name: String,
7733}
7734
7735#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7736#[serde(rename_all = "camelCase")]
7737pub struct TerminalInteractionNotification {
7738 #[serde(rename = "itemId", default)]
7739 pub item_id: String,
7740 #[serde(rename = "processId", default)]
7741 pub process_id: String,
7742 #[serde(default)]
7743 pub stdin: String,
7744 #[serde(rename = "threadId", default)]
7745 pub thread_id: String,
7746 #[serde(rename = "turnId", default)]
7747 pub turn_id: String,
7748}
7749
7750#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7751#[serde(rename_all = "camelCase")]
7752pub struct TextElement {
7753 #[serde(rename = "byteRange", default)]
7754 pub byte_range: Value,
7755 #[serde(default, skip_serializing_if = "Option::is_none")]
7756 pub placeholder: Option<String>,
7757}
7758
7759#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7760#[serde(rename_all = "camelCase")]
7761pub struct TextPosition {
7762 #[serde(default)]
7763 pub column: i64,
7764 #[serde(default)]
7765 pub line: i64,
7766}
7767
7768#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7769#[serde(rename_all = "camelCase")]
7770pub struct TextRange {
7771 #[serde()]
7772 pub end: TextPosition,
7773 #[serde()]
7774 pub start: TextPosition,
7775}
7776
7777#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7778#[serde(rename_all = "camelCase")]
7779pub struct Thread {
7780 #[serde(
7781 rename = "agentNickname",
7782 default,
7783 skip_serializing_if = "Option::is_none"
7784 )]
7785 pub agent_nickname: Option<String>,
7786 #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
7787 pub agent_role: Option<String>,
7788 #[serde(rename = "cliVersion", default)]
7789 pub cli_version: String,
7790 #[serde(rename = "createdAt", default)]
7791 pub created_at: i64,
7792 #[serde(default)]
7793 pub cwd: Value,
7794 #[serde(default)]
7795 pub ephemeral: bool,
7796 #[serde(
7797 rename = "forkedFromId",
7798 default,
7799 skip_serializing_if = "Option::is_none"
7800 )]
7801 pub forked_from_id: Option<String>,
7802 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
7803 pub git_info: Option<GitInfo>,
7804 #[serde(
7807 rename = "historyMode",
7808 default,
7809 skip_serializing_if = "Option::is_none"
7810 )]
7811 pub history_mode: Option<ThreadHistoryMode>,
7812 #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
7815 pub project_id: Option<String>,
7816 #[serde(default)]
7817 pub id: String,
7818 #[serde(default, skip_serializing_if = "Option::is_none")]
7821 pub model: Option<String>,
7822 #[serde(rename = "modelProvider", default)]
7823 pub model_provider: String,
7824 #[serde(default, skip_serializing_if = "Option::is_none")]
7825 pub name: Option<String>,
7826 #[serde(default, skip_serializing_if = "Option::is_none")]
7830 pub originator: Option<String>,
7831 #[serde(
7832 rename = "parentThreadId",
7833 default,
7834 skip_serializing_if = "Option::is_none"
7835 )]
7836 pub parent_thread_id: Option<String>,
7837 #[serde(default, skip_serializing_if = "Option::is_none")]
7838 pub path: Option<String>,
7839 #[serde(default)]
7840 pub preview: String,
7841 #[serde(
7845 rename = "reasoningEffort",
7846 default,
7847 skip_serializing_if = "Option::is_none"
7848 )]
7849 pub reasoning_effort: Option<ReasoningEffort>,
7850 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7851 pub recency_at: Option<i64>,
7852 #[serde(default, skip_serializing_if = "Option::is_none")]
7853 pub section: Option<ThreadSection>,
7854 #[serde(
7855 rename = "sectionEnteredAt",
7856 default,
7857 skip_serializing_if = "Option::is_none"
7858 )]
7859 pub section_entered_at: Option<i64>,
7860 #[serde(rename = "sessionId", default)]
7861 pub session_id: String,
7862 #[serde(default)]
7863 pub source: Value,
7864 #[serde(default)]
7865 pub status: Value,
7866 #[serde(
7867 rename = "threadSource",
7868 default,
7869 skip_serializing_if = "Option::is_none"
7870 )]
7871 pub thread_source: Option<ThreadSource>,
7872 #[serde(default)]
7873 pub turns: Vec<Turn>,
7874 #[serde(rename = "updatedAt", default)]
7875 pub updated_at: i64,
7876}
7877
7878#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7879pub enum ThreadActiveFlag {
7880 #[serde(rename = "waitingOnApproval")]
7881 WaitingOnApproval,
7882 #[serde(rename = "waitingOnUserInput")]
7883 WaitingOnUserInput,
7884}
7885
7886#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7887#[serde(rename_all = "camelCase")]
7888pub struct ThreadApproveGuardianDeniedActionParams {
7889 #[serde(default)]
7890 pub event: Value,
7891 #[serde(rename = "threadId", default)]
7892 pub thread_id: String,
7893}
7894
7895#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7896#[serde(rename_all = "camelCase")]
7897pub struct ThreadApproveGuardianDeniedActionResponse {
7898 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7899 pub extra: serde_json::Map<String, Value>,
7900}
7901
7902#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7903#[serde(rename_all = "camelCase")]
7904pub struct ThreadArchiveParams {
7905 #[serde(rename = "threadId", default)]
7906 pub thread_id: String,
7907}
7908
7909#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7910#[serde(rename_all = "camelCase")]
7911pub struct ThreadArchiveResponse {
7912 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7913 pub extra: serde_json::Map<String, Value>,
7914}
7915
7916#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7917#[serde(rename_all = "camelCase")]
7918pub struct ThreadArchivedNotification {
7919 #[serde(rename = "threadId", default)]
7920 pub thread_id: String,
7921}
7922
7923#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7925#[serde(rename_all = "camelCase")]
7926pub struct ThreadAttachment {
7927 #[serde(rename = "attachmentType", default)]
7928 pub attachment_type: String,
7929 #[serde(rename = "createdAt", default)]
7930 pub created_at: i64,
7931 #[serde(default)]
7932 pub id: String,
7933 #[serde(rename = "identityKey", default)]
7934 pub identity_key: String,
7935 #[serde(default)]
7936 pub payload: Value,
7937}
7938
7939#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7941pub enum ThreadAttachmentAddOutcome {
7942 #[serde(rename = "created")]
7943 Created,
7944 #[serde(rename = "existing")]
7945 Existing,
7946}
7947
7948#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7950#[serde(rename_all = "camelCase")]
7951pub struct ThreadAttachmentAddParams {
7952 #[serde(rename = "attachmentType", default)]
7953 pub attachment_type: String,
7954 #[serde(rename = "identityKey", default)]
7955 pub identity_key: String,
7956 #[serde(default)]
7957 pub payload: Value,
7958 #[serde(rename = "threadId", default)]
7959 pub thread_id: String,
7960}
7961
7962#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7964#[serde(rename_all = "camelCase")]
7965pub struct ThreadAttachmentAddResponse {
7966 pub attachment: ThreadAttachment,
7967 pub outcome: ThreadAttachmentAddOutcome,
7968}
7969
7970#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7972#[serde(rename_all = "camelCase")]
7973pub struct ThreadAttachmentListParams {
7974 #[serde(default, skip_serializing_if = "Option::is_none")]
7975 pub cursor: Option<String>,
7976 #[serde(default, skip_serializing_if = "Option::is_none")]
7977 pub limit: Option<i64>,
7978 #[serde(rename = "threadId", default)]
7979 pub thread_id: String,
7980}
7981
7982#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7984#[serde(rename_all = "camelCase")]
7985pub struct ThreadAttachmentListResponse {
7986 #[serde(default)]
7987 pub data: Vec<ThreadAttachment>,
7988 #[serde(
7989 rename = "nextCursor",
7990 default,
7991 skip_serializing_if = "Option::is_none"
7992 )]
7993 pub next_cursor: Option<String>,
7994}
7995
7996#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7998pub enum ThreadAttachmentOperation {
7999 #[serde(rename = "created")]
8000 Created,
8001 #[serde(rename = "deleted")]
8002 Deleted,
8003}
8004
8005#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8007#[serde(rename_all = "camelCase")]
8008pub struct ThreadAttachmentOwner {
8009 #[serde(default)]
8011 pub archived: bool,
8012 #[serde(rename = "threadId", default)]
8013 pub thread_id: String,
8014}
8015
8016#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8018#[serde(rename_all = "camelCase")]
8019pub struct ThreadAttachmentOwnerListParams {
8020 #[serde(default, skip_serializing_if = "Option::is_none")]
8022 pub archived: Option<bool>,
8023 #[serde(rename = "attachmentType", default)]
8024 pub attachment_type: String,
8025 #[serde(default, skip_serializing_if = "Option::is_none")]
8026 pub cursor: Option<String>,
8027 #[serde(rename = "identityKey", default)]
8028 pub identity_key: String,
8029 #[serde(default, skip_serializing_if = "Option::is_none")]
8030 pub limit: Option<i64>,
8031}
8032
8033#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8035#[serde(rename_all = "camelCase")]
8036pub struct ThreadAttachmentOwnerListResponse {
8037 #[serde(default)]
8038 pub data: Vec<ThreadAttachmentOwner>,
8039 #[serde(
8040 rename = "nextCursor",
8041 default,
8042 skip_serializing_if = "Option::is_none"
8043 )]
8044 pub next_cursor: Option<String>,
8045}
8046
8047#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8049#[serde(rename_all = "camelCase")]
8050pub struct ThreadAttachmentRemoveParams {
8051 #[serde(rename = "attachmentType", default)]
8052 pub attachment_type: String,
8053 #[serde(rename = "identityKey", default)]
8054 pub identity_key: String,
8055 #[serde(rename = "threadId", default)]
8056 pub thread_id: String,
8057}
8058
8059#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8061#[serde(rename_all = "camelCase")]
8062pub struct ThreadAttachmentRemoveResponse {
8063 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8064 pub extra: serde_json::Map<String, Value>,
8065}
8066
8067#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8069#[serde(rename_all = "camelCase")]
8070pub struct ThreadAttachmentUpdatedNotification {
8071 #[serde(rename = "attachmentId", default)]
8072 pub attachment_id: String,
8073 #[serde(rename = "attachmentType", default)]
8074 pub attachment_type: String,
8075 #[serde(rename = "identityKey", default)]
8076 pub identity_key: String,
8077 pub operation: ThreadAttachmentOperation,
8078 #[serde(rename = "threadId", default)]
8079 pub thread_id: String,
8080}
8081
8082#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8083#[serde(rename_all = "camelCase")]
8084pub struct ThreadClosedNotification {
8085 #[serde(rename = "threadId", default)]
8086 pub thread_id: String,
8087}
8088
8089#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8090#[serde(rename_all = "camelCase")]
8091pub struct ThreadCompactStartParams {
8092 #[serde(rename = "threadId", default)]
8093 pub thread_id: String,
8094}
8095
8096#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8097#[serde(rename_all = "camelCase")]
8098pub struct ThreadCompactStartResponse {
8099 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8100 pub extra: serde_json::Map<String, Value>,
8101}
8102
8103#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8104#[serde(rename_all = "camelCase")]
8105pub struct ThreadDeleteParams {
8106 #[serde(rename = "threadId", default)]
8107 pub thread_id: String,
8108}
8109
8110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8111#[serde(rename_all = "camelCase")]
8112pub struct ThreadDeleteResponse {
8113 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8114 pub extra: serde_json::Map<String, Value>,
8115}
8116
8117#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8118#[serde(rename_all = "camelCase")]
8119pub struct ThreadDeletedNotification {
8120 #[serde(rename = "threadId", default)]
8121 pub thread_id: String,
8122}
8123
8124#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8125#[serde(rename_all = "camelCase")]
8126pub struct ThreadForkParams {
8127 #[serde(
8128 rename = "approvalPolicy",
8129 default,
8130 skip_serializing_if = "Option::is_none"
8131 )]
8132 pub approval_policy: Option<AskForApproval>,
8133 #[serde(
8134 rename = "approvalsReviewer",
8135 default,
8136 skip_serializing_if = "Option::is_none"
8137 )]
8138 pub approvals_reviewer: Option<ApprovalsReviewer>,
8139 #[serde(
8140 rename = "baseInstructions",
8141 default,
8142 skip_serializing_if = "Option::is_none"
8143 )]
8144 pub base_instructions: Option<String>,
8145 #[serde(default, skip_serializing_if = "Option::is_none")]
8146 pub config: Option<Value>,
8147 #[serde(default, skip_serializing_if = "Option::is_none")]
8148 pub cwd: Option<String>,
8149 #[serde(
8150 rename = "developerInstructions",
8151 default,
8152 skip_serializing_if = "Option::is_none"
8153 )]
8154 pub developer_instructions: Option<String>,
8155 #[serde(default, skip_serializing_if = "Option::is_none")]
8156 pub ephemeral: Option<bool>,
8157 #[serde(
8158 rename = "excludeTurns",
8159 default,
8160 skip_serializing_if = "Option::is_none"
8161 )]
8162 pub exclude_turns: Option<bool>,
8163 #[serde(
8164 rename = "lastTurnId",
8165 default,
8166 skip_serializing_if = "Option::is_none"
8167 )]
8168 pub last_turn_id: Option<String>,
8169 #[serde(default, skip_serializing_if = "Option::is_none")]
8170 pub model: Option<String>,
8171 #[serde(
8172 rename = "modelProvider",
8173 default,
8174 skip_serializing_if = "Option::is_none"
8175 )]
8176 pub model_provider: Option<String>,
8177 #[serde(default, skip_serializing_if = "Option::is_none")]
8178 pub sandbox: Option<SandboxMode>,
8179 #[serde(
8180 rename = "serviceTier",
8181 default,
8182 skip_serializing_if = "Option::is_none"
8183 )]
8184 pub service_tier: Option<String>,
8185 #[serde(rename = "threadId", default)]
8186 pub thread_id: String,
8187 #[serde(
8188 rename = "threadSource",
8189 default,
8190 skip_serializing_if = "Option::is_none"
8191 )]
8192 pub thread_source: Option<ThreadSource>,
8193}
8194
8195#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8196#[serde(rename_all = "camelCase")]
8197pub struct ThreadForkResponse {
8198 #[serde(rename = "approvalPolicy")]
8199 pub approval_policy: AskForApproval,
8200 #[serde(rename = "approvalsReviewer", default)]
8201 pub approvals_reviewer: Value,
8202 #[serde()]
8203 pub cwd: AbsolutePathBuf,
8204 #[serde(rename = "disabledPluginIds", default)]
8207 pub disabled_plugin_ids: Vec<String>,
8208 #[serde(
8209 rename = "instructionSources",
8210 default,
8211 skip_serializing_if = "Option::is_none"
8212 )]
8213 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8214 #[serde(default)]
8215 pub model: String,
8216 #[serde(rename = "modelProvider", default)]
8217 pub model_provider: String,
8218 #[serde(
8219 rename = "reasoningEffort",
8220 default,
8221 skip_serializing_if = "Option::is_none"
8222 )]
8223 pub reasoning_effort: Option<ReasoningEffort>,
8224 #[serde(default)]
8225 pub sandbox: Value,
8226 #[serde(
8227 rename = "serviceTier",
8228 default,
8229 skip_serializing_if = "Option::is_none"
8230 )]
8231 pub service_tier: Option<String>,
8232 #[serde()]
8233 pub thread: Thread,
8234}
8235
8236#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8237#[serde(rename_all = "camelCase")]
8238pub struct ThreadGoal {
8239 #[serde(rename = "createdAt", default)]
8240 pub created_at: i64,
8241 #[serde(default)]
8242 pub objective: String,
8243 #[serde()]
8244 pub status: ThreadGoalStatus,
8245 #[serde(rename = "threadId", default)]
8246 pub thread_id: String,
8247 #[serde(rename = "timeUsedSeconds", default)]
8248 pub time_used_seconds: i64,
8249 #[serde(
8250 rename = "tokenBudget",
8251 default,
8252 skip_serializing_if = "Option::is_none"
8253 )]
8254 pub token_budget: Option<i64>,
8255 #[serde(rename = "tokensUsed", default)]
8256 pub tokens_used: i64,
8257 #[serde(rename = "updatedAt", default)]
8258 pub updated_at: i64,
8259}
8260
8261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8262#[serde(rename_all = "camelCase")]
8263pub struct ThreadGoalClearParams {
8264 #[serde(default, skip_serializing_if = "Option::is_none")]
8266 pub origin: Option<ThreadGoalMutationOrigin>,
8267 #[serde(rename = "threadId", default)]
8268 pub thread_id: String,
8269}
8270
8271#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8272#[serde(rename_all = "camelCase")]
8273pub struct ThreadGoalClearResponse {
8274 #[serde(default)]
8275 pub cleared: bool,
8276}
8277
8278#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8279#[serde(rename_all = "camelCase")]
8280pub struct ThreadGoalClearedNotification {
8281 #[serde(rename = "threadId", default)]
8282 pub thread_id: String,
8283}
8284
8285#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8286#[serde(rename_all = "camelCase")]
8287pub struct ThreadGoalGetParams {
8288 #[serde(rename = "threadId", default)]
8289 pub thread_id: String,
8290}
8291
8292#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8293#[serde(rename_all = "camelCase")]
8294pub struct ThreadGoalGetResponse {
8295 #[serde(default, skip_serializing_if = "Option::is_none")]
8296 pub goal: Option<ThreadGoal>,
8297}
8298
8299#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8301pub enum ThreadGoalMutationOrigin {
8302 #[serde(rename = "user")]
8303 User,
8304 #[serde(rename = "automatic")]
8305 Automatic,
8306}
8307
8308#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8309#[serde(rename_all = "camelCase")]
8310pub struct ThreadGoalSetParams {
8311 #[serde(default, skip_serializing_if = "Option::is_none")]
8312 pub objective: Option<String>,
8313 #[serde(default, skip_serializing_if = "Option::is_none")]
8315 pub origin: Option<ThreadGoalMutationOrigin>,
8316 #[serde(default, skip_serializing_if = "Option::is_none")]
8317 pub status: Option<ThreadGoalStatus>,
8318 #[serde(rename = "threadId", default)]
8319 pub thread_id: String,
8320 #[serde(
8321 rename = "tokenBudget",
8322 default,
8323 skip_serializing_if = "Option::is_none"
8324 )]
8325 pub token_budget: Option<i64>,
8326}
8327
8328#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8329#[serde(rename_all = "camelCase")]
8330pub struct ThreadGoalSetResponse {
8331 #[serde()]
8332 pub goal: ThreadGoal,
8333}
8334
8335#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8336pub enum ThreadGoalStatus {
8337 #[serde(rename = "active")]
8338 Active,
8339 #[serde(rename = "paused")]
8340 Paused,
8341 #[serde(rename = "blocked")]
8342 Blocked,
8343 #[serde(rename = "usageLimited")]
8344 UsageLimited,
8345 #[serde(rename = "budgetLimited")]
8346 BudgetLimited,
8347 #[serde(rename = "complete")]
8348 Complete,
8349}
8350
8351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8352#[serde(rename_all = "camelCase")]
8353pub struct ThreadGoalUpdatedNotification {
8354 #[serde()]
8355 pub goal: ThreadGoal,
8356 #[serde(rename = "threadId", default)]
8357 pub thread_id: String,
8358 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8359 pub turn_id: Option<String>,
8360}
8361
8362#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
8363#[serde(transparent)]
8364pub struct ThreadId(pub String);
8365
8366#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8367#[serde(rename_all = "camelCase")]
8368pub struct ThreadInjectItemsParams {
8369 #[serde(default)]
8370 pub items: Vec<Value>,
8371 #[serde(rename = "threadId", default)]
8372 pub thread_id: String,
8373}
8374
8375#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8376#[serde(rename_all = "camelCase")]
8377pub struct ThreadInjectItemsResponse {
8378 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8379 pub extra: serde_json::Map<String, Value>,
8380}
8381
8382#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8384#[serde(rename_all = "camelCase")]
8385pub struct ThreadItem {
8386 #[serde(flatten)]
8387 pub payload: ThreadItemPayload,
8388 #[serde(
8390 rename = "startedAtMs",
8391 default,
8392 skip_serializing_if = "Option::is_none"
8393 )]
8394 pub started_at_ms: Option<i64>,
8395 #[serde(
8397 rename = "completedAtMs",
8398 default,
8399 skip_serializing_if = "Option::is_none"
8400 )]
8401 pub completed_at_ms: Option<i64>,
8402}
8403
8404impl ThreadItem {
8405 pub fn untimed(payload: ThreadItemPayload) -> Self {
8407 Self {
8408 payload,
8409 started_at_ms: None,
8410 completed_at_ms: None,
8411 }
8412 }
8413}
8414
8415impl From<ThreadItemPayload> for ThreadItem {
8416 fn from(payload: ThreadItemPayload) -> Self {
8417 Self::untimed(payload)
8418 }
8419}
8420
8421#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8423#[serde(tag = "type", rename_all = "camelCase")]
8424pub enum ThreadItemPayload {
8425 #[serde(rename = "userMessage")]
8426 UserMessage {
8427 #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
8428 client_id: Option<String>,
8429 content: Vec<UserInput>,
8430 id: String,
8431 },
8432 #[serde(rename = "hookPrompt")]
8433 HookPrompt {
8434 fragments: Vec<HookPromptFragment>,
8435 id: String,
8436 },
8437 #[serde(rename = "agentMessage")]
8438 AgentMessage {
8439 #[serde(default, skip_serializing_if = "Option::is_none")]
8440 delivery: Option<AgentMessageDelivery>,
8441 id: String,
8442 #[serde(
8443 rename = "memoryCitation",
8444 default,
8445 skip_serializing_if = "Option::is_none"
8446 )]
8447 memory_citation: Option<MemoryCitation>,
8448 #[serde(default, skip_serializing_if = "Option::is_none")]
8449 phase: Option<MessagePhase>,
8450 #[serde(default, skip_serializing_if = "Option::is_none")]
8451 questions: Option<Vec<AsyncUserInputQuestion>>,
8452 text: String,
8453 },
8454 Plan {
8455 id: String,
8456 text: String,
8457 },
8458 Reasoning {
8459 #[serde(default, skip_serializing_if = "Option::is_none")]
8460 content: Option<Vec<String>>,
8461 id: String,
8462 #[serde(default, skip_serializing_if = "Option::is_none")]
8463 summary: Option<Vec<String>>,
8464 },
8465 #[serde(rename = "commandExecution")]
8466 CommandExecution {
8467 #[serde(
8468 rename = "aggregatedOutput",
8469 default,
8470 skip_serializing_if = "Option::is_none"
8471 )]
8472 aggregated_output: Option<String>,
8473 command: String,
8474 #[serde(rename = "commandActions")]
8475 command_actions: Vec<CommandAction>,
8476 cwd: Value,
8477 #[serde(
8478 rename = "durationMs",
8479 default,
8480 skip_serializing_if = "Option::is_none"
8481 )]
8482 duration_ms: Option<i64>,
8483 #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
8484 exit_code: Option<i64>,
8485 id: String,
8486 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8487 plugin_id: Option<String>,
8488 #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
8489 process_id: Option<String>,
8490 #[serde(
8491 rename = "scriptPath",
8492 default,
8493 skip_serializing_if = "Option::is_none"
8494 )]
8495 script_path: Option<String>,
8496 #[serde(default, skip_serializing_if = "Option::is_none")]
8497 source: Option<Value>,
8498 status: CommandExecutionStatus,
8499 },
8500 #[serde(rename = "fileChange")]
8501 FileChange {
8502 changes: Vec<FileUpdateChange>,
8503 id: String,
8504 status: PatchApplyStatus,
8505 },
8506 #[serde(rename = "mcpToolCall")]
8507 McpToolCall {
8508 #[serde(
8509 rename = "appContext",
8510 default,
8511 skip_serializing_if = "Option::is_none"
8512 )]
8513 app_context: Option<McpToolCallAppContext>,
8514 arguments: Value,
8515 #[serde(
8516 rename = "durationMs",
8517 default,
8518 skip_serializing_if = "Option::is_none"
8519 )]
8520 duration_ms: Option<i64>,
8521 #[serde(default, skip_serializing_if = "Option::is_none")]
8522 error: Option<McpToolCallError>,
8523 id: String,
8524 #[serde(
8527 rename = "mcpAppResourceUri",
8528 default,
8529 skip_serializing_if = "Option::is_none"
8530 )]
8531 mcp_app_resource_uri: Option<String>,
8532 #[serde(rename = "mcpAppUi", default, skip_serializing_if = "Option::is_none")]
8535 mcp_app_ui: Option<McpAppUi>,
8536 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8537 plugin_id: Option<String>,
8538 #[serde(
8539 rename = "readOnlyHint",
8540 default,
8541 skip_serializing_if = "Option::is_none"
8542 )]
8543 read_only_hint: Option<bool>,
8544 #[serde(default, skip_serializing_if = "Option::is_none")]
8545 result: Option<McpToolCallResult>,
8546 server: String,
8547 status: McpToolCallStatus,
8548 tool: String,
8549 },
8550 #[serde(rename = "dynamicToolCall")]
8551 DynamicToolCall {
8552 arguments: Value,
8553 #[serde(
8554 rename = "contentItems",
8555 default,
8556 skip_serializing_if = "Option::is_none"
8557 )]
8558 content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
8559 #[serde(
8560 rename = "durationMs",
8561 default,
8562 skip_serializing_if = "Option::is_none"
8563 )]
8564 duration_ms: Option<i64>,
8565 id: String,
8566 #[serde(default, skip_serializing_if = "Option::is_none")]
8567 namespace: Option<String>,
8568 status: DynamicToolCallStatus,
8569 #[serde(default, skip_serializing_if = "Option::is_none")]
8570 success: Option<bool>,
8571 tool: String,
8572 },
8573 #[serde(rename = "collabAgentToolCall")]
8574 CollabAgentToolCall {
8575 #[serde(rename = "agentsStates")]
8576 agents_states: std::collections::BTreeMap<String, CollabAgentState>,
8577 id: String,
8578 #[serde(default, skip_serializing_if = "Option::is_none")]
8579 model: Option<String>,
8580 #[serde(default, skip_serializing_if = "Option::is_none")]
8581 prompt: Option<String>,
8582 #[serde(
8583 rename = "reasoningEffort",
8584 default,
8585 skip_serializing_if = "Option::is_none"
8586 )]
8587 reasoning_effort: Option<ReasoningEffort>,
8588 #[serde(rename = "receiverThreadIds")]
8589 receiver_thread_ids: Vec<String>,
8590 #[serde(rename = "senderThreadId")]
8591 sender_thread_id: String,
8592 status: Value,
8593 tool: Value,
8594 },
8595 #[serde(rename = "subAgentActivity")]
8596 SubAgentActivity {
8597 #[serde(rename = "agentPath")]
8598 agent_path: String,
8599 #[serde(rename = "agentThreadId")]
8600 agent_thread_id: String,
8601 id: String,
8602 kind: SubAgentActivityKind,
8603 #[serde(default, skip_serializing_if = "Option::is_none")]
8606 model: Option<String>,
8607 #[serde(
8609 rename = "reasoningEffort",
8610 default,
8611 skip_serializing_if = "Option::is_none"
8612 )]
8613 reasoning_effort: Option<ReasoningEffort>,
8614 },
8615 #[serde(rename = "webSearch")]
8616 WebSearch {
8617 #[serde(default, skip_serializing_if = "Option::is_none")]
8618 action: Option<WebSearchAction>,
8619 id: String,
8620 query: String,
8621 #[serde(default, skip_serializing_if = "Option::is_none")]
8622 results: Option<Vec<Value>>,
8623 },
8624 #[serde(rename = "imageView")]
8625 ImageView {
8626 id: String,
8627 path: LegacyAppPathString,
8628 },
8629 Sleep {
8630 #[serde(rename = "durationMs")]
8631 duration_ms: i64,
8632 id: String,
8633 },
8634 #[serde(rename = "imageGeneration")]
8635 ImageGeneration {
8636 #[serde(default, skip_serializing_if = "Option::is_none")]
8637 failure: Option<ImageGenerationFailure>,
8638 #[serde(
8640 rename = "generationId",
8641 default,
8642 skip_serializing_if = "Option::is_none"
8643 )]
8644 generation_id: Option<String>,
8645 id: String,
8646 #[serde(flatten)]
8647 image: GeneratedImageRef,
8648 #[serde(
8650 rename = "inputImages",
8651 default,
8652 skip_serializing_if = "Option::is_none"
8653 )]
8654 input_images: Option<Vec<ImageGenerationInputImage>>,
8655 #[serde(
8656 rename = "revisedPrompt",
8657 default,
8658 skip_serializing_if = "Option::is_none"
8659 )]
8660 revised_prompt: Option<String>,
8661 #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
8662 saved_path: Option<AbsolutePathBuf>,
8663 status: String,
8664 #[serde(
8665 rename = "transparentBackground",
8666 default,
8667 skip_serializing_if = "Option::is_none"
8668 )]
8669 transparent_background: Option<bool>,
8670 },
8671 #[serde(rename = "enteredReviewMode")]
8672 EnteredReviewMode {
8673 id: String,
8674 review: String,
8675 },
8676 #[serde(rename = "exitedReviewMode")]
8677 ExitedReviewMode {
8678 id: String,
8679 review: String,
8680 },
8681 #[serde(rename = "contextCompaction")]
8682 ContextCompaction {
8683 id: String,
8684 },
8685 #[serde(rename = "functionCallOutput")]
8686 FunctionCallOutput {
8687 id: String,
8688 name: String,
8689 #[serde(default, skip_serializing_if = "Option::is_none")]
8690 namespace: Option<String>,
8691 output: FunctionCallOutputBody,
8692 },
8693}
8694
8695#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8696#[serde(untagged)]
8697pub enum ThreadListCwdFilter {
8698 Variant0(String),
8699 Variant1(Vec<String>),
8700}
8701
8702#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8703#[serde(rename_all = "camelCase")]
8704pub struct ThreadListParams {
8705 #[serde(default, skip_serializing_if = "Option::is_none")]
8706 pub archived: Option<bool>,
8707 #[serde(
8710 rename = "currentAccountOnly",
8711 default,
8712 skip_serializing_if = "Option::is_none"
8713 )]
8714 pub current_account_only: Option<bool>,
8715 #[serde(default, skip_serializing_if = "Option::is_none")]
8716 pub cursor: Option<String>,
8717 #[serde(default, skip_serializing_if = "Option::is_none")]
8718 pub cwd: Option<ThreadListCwdFilter>,
8719 #[serde(
8724 rename = "excludedThreadIds",
8725 default,
8726 skip_serializing_if = "Option::is_none"
8727 )]
8728 pub excluded_thread_ids: Option<Vec<String>>,
8729 #[serde(default, skip_serializing_if = "Option::is_none")]
8730 pub limit: Option<i64>,
8731 #[serde(
8732 rename = "modelProviders",
8733 default,
8734 skip_serializing_if = "Option::is_none"
8735 )]
8736 pub model_providers: Option<Vec<String>>,
8737 #[serde(default, skip_serializing_if = "Option::is_none")]
8741 pub originators: Option<Vec<String>>,
8742 #[serde(
8743 rename = "searchTerm",
8744 default,
8745 skip_serializing_if = "Option::is_none"
8746 )]
8747 pub search_term: Option<String>,
8748 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8749 pub section_id: Option<String>,
8750 #[serde(
8751 rename = "sortDirection",
8752 default,
8753 skip_serializing_if = "Option::is_none"
8754 )]
8755 pub sort_direction: Option<SortDirection>,
8756 #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
8757 pub sort_key: Option<ThreadSortKey>,
8758 #[serde(
8759 rename = "sourceKinds",
8760 default,
8761 skip_serializing_if = "Option::is_none"
8762 )]
8763 pub source_kinds: Option<Vec<ThreadSourceKind>>,
8764 #[serde(
8765 rename = "useStateDbOnly",
8766 default,
8767 skip_serializing_if = "Option::is_none"
8768 )]
8769 pub use_state_db_only: Option<bool>,
8770}
8771
8772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8773#[serde(rename_all = "camelCase")]
8774pub struct ThreadListResponse {
8775 #[serde(
8776 rename = "backwardsCursor",
8777 default,
8778 skip_serializing_if = "Option::is_none"
8779 )]
8780 pub backwards_cursor: Option<String>,
8781 #[serde(default)]
8782 pub data: Vec<Thread>,
8783 #[serde(
8784 rename = "nextCursor",
8785 default,
8786 skip_serializing_if = "Option::is_none"
8787 )]
8788 pub next_cursor: Option<String>,
8789}
8790
8791#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8792#[serde(rename_all = "camelCase")]
8793pub struct ThreadLoadedListParams {
8794 #[serde(default, skip_serializing_if = "Option::is_none")]
8795 pub cursor: Option<String>,
8796 #[serde(default, skip_serializing_if = "Option::is_none")]
8797 pub limit: Option<i64>,
8798}
8799
8800#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8801#[serde(rename_all = "camelCase")]
8802pub struct ThreadLoadedListResponse {
8803 #[serde(default)]
8804 pub data: Vec<String>,
8805 #[serde(
8806 rename = "nextCursor",
8807 default,
8808 skip_serializing_if = "Option::is_none"
8809 )]
8810 pub next_cursor: Option<String>,
8811}
8812
8813#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8814#[serde(rename_all = "camelCase")]
8815pub struct ThreadMetadataGitInfoUpdateParams {
8816 #[serde(default, skip_serializing_if = "Option::is_none")]
8817 pub branch: Option<String>,
8818 #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
8819 pub origin_url: Option<String>,
8820 #[serde(default, skip_serializing_if = "Option::is_none")]
8821 pub sha: Option<String>,
8822}
8823
8824#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8825#[serde(rename_all = "camelCase")]
8826pub struct ThreadMetadataUpdateParams {
8827 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
8828 pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
8829 #[serde(rename = "threadId", default)]
8830 pub thread_id: String,
8831}
8832
8833#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8834#[serde(rename_all = "camelCase")]
8835pub struct ThreadMetadataUpdateResponse {
8836 #[serde()]
8837 pub thread: Thread,
8838}
8839
8840#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8841#[serde(rename_all = "camelCase")]
8842pub struct ThreadNameUpdatedNotification {
8843 #[serde(rename = "threadId", default)]
8844 pub thread_id: String,
8845 #[serde(
8846 rename = "threadName",
8847 default,
8848 skip_serializing_if = "Option::is_none"
8849 )]
8850 pub thread_name: Option<String>,
8851}
8852
8853#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8854#[serde(rename_all = "camelCase")]
8855pub struct ThreadReadParams {
8856 #[serde(
8857 rename = "includeTurns",
8858 default,
8859 skip_serializing_if = "Option::is_none"
8860 )]
8861 pub include_turns: Option<bool>,
8862 #[serde(rename = "threadId", default)]
8863 pub thread_id: String,
8864}
8865
8866#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8867#[serde(rename_all = "camelCase")]
8868pub struct ThreadReadResponse {
8869 #[serde()]
8870 pub thread: Thread,
8871}
8872
8873#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8876#[serde(rename_all = "camelCase")]
8877pub struct ThreadReadState {
8878 #[serde(
8879 rename = "firstUnread",
8880 default,
8881 skip_serializing_if = "Option::is_none"
8882 )]
8883 pub first_unread: Option<ThreadUnreadPosition>,
8884 #[serde(default)]
8885 pub revision: String,
8886}
8887
8888#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8889#[serde(rename_all = "camelCase")]
8890pub struct ThreadReadStateChangedNotification {
8891 #[serde(rename = "readState")]
8892 pub read_state: ThreadReadState,
8893 #[serde(rename = "threadId", default)]
8894 pub thread_id: String,
8895}
8896
8897#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
8899#[serde(rename_all = "camelCase")]
8900pub struct ThreadSectionChangedNotification {
8901 #[serde(rename = "threadId")]
8902 pub thread_id: String,
8903 #[serde(rename = "sectionId")]
8906 pub section_id: Option<String>,
8907}
8908
8909#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8910#[serde(rename_all = "camelCase")]
8911pub struct ThreadRealtimeAudioChunk {
8912 #[serde(default)]
8913 pub data: String,
8914 #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
8915 pub item_id: Option<String>,
8916 #[serde(rename = "numChannels", default)]
8917 pub num_channels: i64,
8918 #[serde(rename = "sampleRate", default)]
8919 pub sample_rate: i64,
8920 #[serde(
8921 rename = "samplesPerChannel",
8922 default,
8923 skip_serializing_if = "Option::is_none"
8924 )]
8925 pub samples_per_channel: Option<i64>,
8926}
8927
8928#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8929#[serde(rename_all = "camelCase")]
8930pub struct ThreadRealtimeClosedNotification {
8931 #[serde(default, skip_serializing_if = "Option::is_none")]
8932 pub reason: Option<String>,
8933 #[serde(rename = "threadId", default)]
8934 pub thread_id: String,
8935}
8936
8937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8938#[serde(rename_all = "camelCase")]
8939pub struct ThreadRealtimeErrorNotification {
8940 #[serde(default)]
8941 pub message: String,
8942 #[serde(rename = "threadId", default)]
8943 pub thread_id: String,
8944}
8945
8946#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8947#[serde(rename_all = "camelCase")]
8948pub struct ThreadRealtimeItemAddedNotification {
8949 #[serde(default)]
8950 pub item: Value,
8951 #[serde(rename = "threadId", default)]
8952 pub thread_id: String,
8953}
8954
8955#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8956#[serde(rename_all = "camelCase")]
8957pub struct ThreadRealtimeOutputAudioDeltaNotification {
8958 #[serde()]
8959 pub audio: ThreadRealtimeAudioChunk,
8960 #[serde(rename = "threadId", default)]
8961 pub thread_id: String,
8962}
8963
8964#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8965#[serde(rename_all = "camelCase")]
8966pub struct ThreadRealtimeSdpNotification {
8967 #[serde(default)]
8968 pub sdp: String,
8969 #[serde(rename = "threadId", default)]
8970 pub thread_id: String,
8971}
8972
8973#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8974#[serde(rename_all = "camelCase")]
8975pub struct ThreadRealtimeStartedNotification {
8976 #[serde(
8977 rename = "realtimeSessionId",
8978 default,
8979 skip_serializing_if = "Option::is_none"
8980 )]
8981 pub realtime_session_id: Option<String>,
8982 #[serde(rename = "threadId", default)]
8983 pub thread_id: String,
8984 #[serde()]
8985 pub version: RealtimeConversationVersion,
8986}
8987
8988#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8989#[serde(rename_all = "camelCase")]
8990pub struct ThreadRealtimeTranscriptDeltaNotification {
8991 #[serde(default)]
8992 pub delta: String,
8993 #[serde(default)]
8994 pub role: String,
8995 #[serde(rename = "threadId", default)]
8996 pub thread_id: String,
8997}
8998
8999#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9000#[serde(rename_all = "camelCase")]
9001pub struct ThreadRealtimeTranscriptDoneNotification {
9002 #[serde(default)]
9003 pub role: String,
9004 #[serde(default)]
9005 pub text: String,
9006 #[serde(rename = "threadId", default)]
9007 pub thread_id: String,
9008}
9009
9010#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9011#[serde(rename_all = "camelCase")]
9012pub struct ThreadResumeParams {
9013 #[serde(
9014 rename = "approvalPolicy",
9015 default,
9016 skip_serializing_if = "Option::is_none"
9017 )]
9018 pub approval_policy: Option<AskForApproval>,
9019 #[serde(
9020 rename = "approvalsReviewer",
9021 default,
9022 skip_serializing_if = "Option::is_none"
9023 )]
9024 pub approvals_reviewer: Option<ApprovalsReviewer>,
9025 #[serde(
9026 rename = "baseInstructions",
9027 default,
9028 skip_serializing_if = "Option::is_none"
9029 )]
9030 pub base_instructions: Option<String>,
9031 #[serde(default, skip_serializing_if = "Option::is_none")]
9032 pub config: Option<Value>,
9033 #[serde(default, skip_serializing_if = "Option::is_none")]
9034 pub cwd: Option<String>,
9035 #[serde(
9036 rename = "developerInstructions",
9037 default,
9038 skip_serializing_if = "Option::is_none"
9039 )]
9040 pub developer_instructions: Option<String>,
9041 #[serde(default, skip_serializing_if = "Option::is_none")]
9042 pub model: Option<String>,
9043 #[serde(
9044 rename = "modelProvider",
9045 default,
9046 skip_serializing_if = "Option::is_none"
9047 )]
9048 pub model_provider: Option<String>,
9049 #[serde(default, skip_serializing_if = "Option::is_none")]
9050 pub personality: Option<Personality>,
9051 #[serde(default, skip_serializing_if = "Option::is_none")]
9052 pub sandbox: Option<SandboxMode>,
9053 #[serde(
9054 rename = "serviceTier",
9055 default,
9056 skip_serializing_if = "Option::is_none"
9057 )]
9058 pub service_tier: Option<String>,
9059 #[serde(rename = "threadId", default)]
9060 pub thread_id: String,
9061 #[serde(
9062 rename = "excludeTurns",
9063 default,
9064 skip_serializing_if = "Option::is_none"
9065 )]
9066 pub exclude_turns: Option<bool>,
9067}
9068
9069#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9070#[serde(rename_all = "camelCase")]
9071pub struct ThreadResumeResponse {
9072 #[serde(rename = "approvalPolicy")]
9073 pub approval_policy: AskForApproval,
9074 #[serde(rename = "approvalsReviewer", default)]
9075 pub approvals_reviewer: Value,
9076 #[serde(
9079 rename = "collaborationMode",
9080 default,
9081 skip_serializing_if = "Option::is_none"
9082 )]
9083 pub collaboration_mode: Option<CollaborationMode>,
9084 #[serde()]
9085 pub cwd: AbsolutePathBuf,
9086 #[serde(rename = "disabledPluginIds", default)]
9089 pub disabled_plugin_ids: Vec<String>,
9090 #[serde(
9091 rename = "instructionSources",
9092 default,
9093 skip_serializing_if = "Option::is_none"
9094 )]
9095 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9096 #[serde(
9099 rename = "itemsBackwardsCursor",
9100 default,
9101 skip_serializing_if = "Option::is_none"
9102 )]
9103 pub items_backwards_cursor: Option<String>,
9104 #[serde(default)]
9105 pub model: String,
9106 #[serde(rename = "modelProvider", default)]
9107 pub model_provider: String,
9108 #[serde(
9109 rename = "reasoningEffort",
9110 default,
9111 skip_serializing_if = "Option::is_none"
9112 )]
9113 pub reasoning_effort: Option<ReasoningEffort>,
9114 #[serde(default)]
9115 pub sandbox: Value,
9116 #[serde(
9117 rename = "serviceTier",
9118 default,
9119 skip_serializing_if = "Option::is_none"
9120 )]
9121 pub service_tier: Option<String>,
9122 #[serde()]
9123 pub thread: Thread,
9124 #[serde(
9127 rename = "turnsBackwardsCursor",
9128 default,
9129 skip_serializing_if = "Option::is_none"
9130 )]
9131 pub turns_backwards_cursor: Option<String>,
9132}
9133
9134#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9136pub enum ThreadHistoryMode {
9137 #[serde(rename = "legacy")]
9138 Legacy,
9139 #[serde(rename = "paginated")]
9140 Paginated,
9141}
9142
9143#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9146#[serde(rename_all = "camelCase")]
9147pub struct ThreadItemEntry {
9148 #[serde(
9151 rename = "completedAtMs",
9152 default,
9153 skip_serializing_if = "Option::is_none"
9154 )]
9155 pub completed_at_ms: Option<i64>,
9156 #[serde()]
9157 pub item: ThreadItem,
9158 #[serde(
9161 rename = "startedAtMs",
9162 default,
9163 skip_serializing_if = "Option::is_none"
9164 )]
9165 pub started_at_ms: Option<i64>,
9166 #[serde(rename = "turnId", default)]
9167 pub turn_id: String,
9168}
9169
9170#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9172#[serde(rename_all = "camelCase")]
9173pub struct ThreadItemsListParams {
9174 #[serde(default, skip_serializing_if = "Option::is_none")]
9180 pub cursor: Option<ThreadItemsListCursor>,
9181 #[serde(default, skip_serializing_if = "Option::is_none")]
9182 pub limit: Option<u32>,
9183 #[serde(
9184 rename = "sortDirection",
9185 default,
9186 skip_serializing_if = "Option::is_none"
9187 )]
9188 pub sort_direction: Option<SortDirection>,
9189 #[serde(rename = "threadId", default)]
9190 pub thread_id: String,
9191 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
9193 pub turn_id: Option<String>,
9194}
9195
9196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9201#[serde(untagged)]
9202pub enum ThreadItemsListCursor {
9203 Opaque(String),
9204 Anchor(ThreadItemsListAnchor),
9205}
9206
9207#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9210#[serde(tag = "type", rename_all = "camelCase")]
9211pub enum ThreadItemsListAnchor {
9212 Item {
9213 #[serde(rename = "itemId")]
9214 item_id: String,
9215 },
9216}
9217
9218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9220#[serde(rename_all = "camelCase")]
9221pub struct ThreadItemsListResponse {
9222 #[serde(
9223 rename = "backwardsCursor",
9224 default,
9225 skip_serializing_if = "Option::is_none"
9226 )]
9227 pub backwards_cursor: Option<String>,
9228 #[serde(default)]
9229 pub data: Vec<ThreadItemEntry>,
9230 #[serde(
9231 rename = "nextCursor",
9232 default,
9233 skip_serializing_if = "Option::is_none"
9234 )]
9235 pub next_cursor: Option<String>,
9236}
9237
9238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9242pub struct ThreadRealtimeItem {
9243 #[serde(default)]
9244 pub id: String,
9245 #[serde(rename = "realtimeSessionId", default)]
9246 pub realtime_session_id: String,
9247 #[serde(flatten)]
9248 pub detail: ThreadRealtimeItemDetail,
9249}
9250
9251#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9253#[serde(tag = "type", rename_all = "camelCase")]
9254pub enum ThreadRealtimeItemDetail {
9255 #[serde(rename = "realtimeSessionStarted")]
9256 RealtimeSessionStarted,
9257 #[serde(rename = "transcriptSegment")]
9258 TranscriptSegment {
9259 role: ThreadRealtimeTranscriptRole,
9260 text: String,
9261 },
9262 #[serde(rename = "bemItemPromoted")]
9263 BemItemPromoted {
9264 item_id: String,
9265 presentation: ThreadRealtimeBemItemPresentation,
9266 turn_id: String,
9267 },
9268 #[serde(rename = "realtimeSessionClosed")]
9269 RealtimeSessionClosed {
9270 outcome: ThreadRealtimeSessionOutcome,
9271 },
9272}
9273
9274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9277#[serde(tag = "type", rename_all = "camelCase")]
9278pub enum ThreadRealtimeBemItemPresentation {
9279 #[serde(rename = "wholeItem")]
9280 WholeItem,
9281 #[serde(rename = "inlineMarkdown")]
9282 InlineMarkdown,
9283 #[serde(rename = "inlineVisualization")]
9284 InlineVisualization { index: u32 },
9285}
9286
9287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9289#[serde(rename_all = "camelCase")]
9290pub struct ThreadRealtimeItemStartedNotification {
9291 #[serde()]
9292 pub item: ThreadRealtimeItem,
9293 #[serde(rename = "threadId", default)]
9294 pub thread_id: String,
9295}
9296
9297#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9299#[serde(rename_all = "camelCase")]
9300pub struct ThreadRealtimeItemCompletedNotification {
9301 #[serde()]
9302 pub item: ThreadRealtimeItem,
9303 #[serde(rename = "threadId", default)]
9304 pub thread_id: String,
9305}
9306
9307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9310#[serde(rename_all = "camelCase")]
9311pub struct ThreadRealtimeItemTranscriptDeltaNotification {
9312 #[serde(default)]
9313 pub delta: String,
9314 #[serde(rename = "itemId", default)]
9315 pub item_id: String,
9316 #[serde(rename = "threadId", default)]
9317 pub thread_id: String,
9318}
9319
9320#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9322pub enum ThreadRealtimeSessionOutcome {
9323 #[serde(rename = "ended")]
9324 Ended,
9325 #[serde(rename = "failed")]
9326 Failed,
9327}
9328
9329#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9331pub enum ThreadRealtimeTranscriptRole {
9332 #[serde(rename = "user")]
9333 User,
9334 #[serde(rename = "assistant")]
9335 Assistant,
9336}
9337
9338#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9342#[serde(rename_all = "camelCase")]
9343pub struct ThreadRevertParams {
9344 #[serde(rename = "beforeTurnId", default)]
9346 pub before_turn_id: String,
9347 #[serde(rename = "threadId", default)]
9348 pub thread_id: String,
9349}
9350
9351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9354#[serde(rename_all = "camelCase")]
9355pub struct ThreadRevertResponse {
9356 #[serde(
9357 rename = "itemsBackwardsCursor",
9358 default,
9359 skip_serializing_if = "Option::is_none"
9360 )]
9361 pub items_backwards_cursor: Option<String>,
9362 #[serde()]
9363 pub thread: Thread,
9364 #[serde(
9365 rename = "turnsBackwardsCursor",
9366 default,
9367 skip_serializing_if = "Option::is_none"
9368 )]
9369 pub turns_backwards_cursor: Option<String>,
9370}
9371
9372#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9373#[serde(rename_all = "camelCase")]
9374pub struct ThreadSection {
9375 #[serde(default, skip_serializing_if = "Option::is_none")]
9376 pub appearance: Option<ThreadSectionAppearance>,
9377 #[serde(default)]
9378 pub id: String,
9379 #[serde(default)]
9380 pub name: String,
9381}
9382
9383#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9384#[serde(rename_all = "camelCase")]
9385pub struct ThreadSectionAppearance {
9386 #[serde(default, skip_serializing_if = "Option::is_none")]
9387 pub color: Option<String>,
9388 #[serde(default, skip_serializing_if = "Option::is_none")]
9389 pub icon: Option<String>,
9390}
9391
9392#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9393#[serde(rename_all = "camelCase")]
9394pub struct ThreadSectionCreateParams {
9395 #[serde(default, skip_serializing_if = "Option::is_none")]
9396 pub appearance: Option<ThreadSectionAppearance>,
9397 #[serde(default)]
9398 pub name: String,
9399}
9400
9401#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9402#[serde(rename_all = "camelCase")]
9403pub struct ThreadSectionCreateResponse {
9404 #[serde()]
9405 pub section: ThreadSection,
9406}
9407
9408#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9409#[serde(rename_all = "camelCase")]
9410pub struct ThreadSectionDeleteParams {
9411 #[serde(rename = "sectionId", default)]
9412 pub section_id: String,
9413}
9414
9415#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9416#[serde(rename_all = "camelCase")]
9417pub struct ThreadSectionDeleteResponse {
9418 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9419 pub extra: serde_json::Map<String, Value>,
9420}
9421
9422#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9423#[serde(rename_all = "camelCase")]
9424pub struct ThreadSectionListParams {
9425 #[serde(default, skip_serializing_if = "Option::is_none")]
9426 pub cursor: Option<String>,
9427 #[serde(default, skip_serializing_if = "Option::is_none")]
9428 pub limit: Option<i64>,
9429}
9430
9431#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9432#[serde(rename_all = "camelCase")]
9433pub struct ThreadSectionListResponse {
9434 #[serde(default)]
9435 pub data: Vec<ThreadSection>,
9436 #[serde(
9437 rename = "nextCursor",
9438 default,
9439 skip_serializing_if = "Option::is_none"
9440 )]
9441 pub next_cursor: Option<String>,
9442}
9443
9444#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9445#[serde(rename_all = "camelCase")]
9446pub struct ThreadSectionMoveParams {
9447 #[serde(
9448 rename = "beforeThreadId",
9449 default,
9450 skip_serializing_if = "Option::is_none"
9451 )]
9452 pub before_thread_id: Option<String>,
9453 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
9454 pub section_id: Option<String>,
9455 #[serde(rename = "threadId", default)]
9456 pub thread_id: String,
9457}
9458
9459#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9460#[serde(rename_all = "camelCase")]
9461pub struct ThreadSectionMoveResponse {
9462 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9463 pub extra: serde_json::Map<String, Value>,
9464}
9465
9466#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9467#[serde(rename_all = "camelCase")]
9468pub struct ThreadSectionUpdateParams {
9469 #[serde(default, skip_serializing_if = "Option::is_none")]
9470 pub appearance: Option<ThreadSectionAppearance>,
9471 #[serde(default)]
9472 pub name: String,
9473 #[serde(rename = "sectionId", default)]
9474 pub section_id: String,
9475}
9476
9477#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9478#[serde(rename_all = "camelCase")]
9479pub struct ThreadSectionUpdateResponse {
9480 #[serde()]
9481 pub section: ThreadSection,
9482}
9483
9484#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9485#[serde(rename_all = "camelCase")]
9486pub struct ThreadSetNameParams {
9487 #[serde(default)]
9488 pub name: String,
9489 #[serde(rename = "threadId", default)]
9490 pub thread_id: String,
9491}
9492
9493#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9494#[serde(rename_all = "camelCase")]
9495pub struct ThreadSetNameResponse {
9496 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9497 pub extra: serde_json::Map<String, Value>,
9498}
9499
9500#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9501#[serde(rename_all = "camelCase")]
9502pub struct ThreadSettings {
9503 #[serde(
9504 rename = "activePermissionProfile",
9505 default,
9506 skip_serializing_if = "Option::is_none"
9507 )]
9508 pub active_permission_profile: Option<ActivePermissionProfile>,
9509 #[serde(rename = "approvalPolicy")]
9510 pub approval_policy: AskForApproval,
9511 #[serde(rename = "approvalsReviewer")]
9512 pub approvals_reviewer: ApprovalsReviewer,
9513 #[serde(rename = "collaborationMode")]
9514 pub collaboration_mode: CollaborationMode,
9515 #[serde()]
9516 pub cwd: AbsolutePathBuf,
9517 #[serde(rename = "disabledPluginIds", default)]
9520 pub disabled_plugin_ids: Vec<String>,
9521 #[serde(default, skip_serializing_if = "Option::is_none")]
9522 pub effort: Option<ReasoningEffort>,
9523 #[serde(default)]
9524 pub model: String,
9525 #[serde(rename = "modelProvider", default)]
9526 pub model_provider: String,
9527 #[serde(default, skip_serializing_if = "Option::is_none")]
9528 pub personality: Option<Personality>,
9529 #[serde(rename = "sandboxPolicy")]
9530 pub sandbox_policy: SandboxPolicy,
9531 #[serde(
9532 rename = "serviceTier",
9533 default,
9534 skip_serializing_if = "Option::is_none"
9535 )]
9536 pub service_tier: Option<String>,
9537 #[serde(default, skip_serializing_if = "Option::is_none")]
9538 pub summary: Option<ReasoningSummary>,
9539}
9540
9541#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9542#[serde(rename_all = "camelCase")]
9543pub struct ThreadSettingsUpdatedNotification {
9544 #[serde(rename = "threadId", default)]
9545 pub thread_id: String,
9546 #[serde(rename = "threadSettings")]
9547 pub thread_settings: ThreadSettings,
9548}
9549
9550#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9551#[serde(rename_all = "camelCase")]
9552pub struct ThreadShellCommandParams {
9553 #[serde(default)]
9554 pub command: String,
9555 #[serde(rename = "threadId", default)]
9556 pub thread_id: String,
9557 #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
9560 pub timeout_ms: Option<i64>,
9561}
9562
9563#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9564#[serde(rename_all = "camelCase")]
9565pub struct ThreadShellCommandResponse {
9566 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9567 pub extra: serde_json::Map<String, Value>,
9568}
9569
9570#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9571pub enum ThreadSortKey {
9572 #[serde(rename = "created_at")]
9573 Created_at,
9574 #[serde(rename = "updated_at")]
9575 Updated_at,
9576 #[serde(rename = "recency_at")]
9577 Recency_at,
9578 #[serde(rename = "section_position")]
9579 Section_position,
9580}
9581
9582#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
9583#[serde(transparent)]
9584pub struct ThreadSource(pub String);
9585
9586#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9587pub enum ThreadSourceKind {
9588 #[serde(rename = "cli")]
9589 Cli,
9590 #[serde(rename = "vscode")]
9591 Vscode,
9592 #[serde(rename = "exec")]
9593 Exec,
9594 #[serde(rename = "appServer")]
9595 AppServer,
9596 #[serde(rename = "subAgent")]
9597 SubAgent,
9598 #[serde(rename = "subAgentReview")]
9599 SubAgentReview,
9600 #[serde(rename = "subAgentCompact")]
9601 SubAgentCompact,
9602 #[serde(rename = "subAgentThreadSpawn")]
9603 SubAgentThreadSpawn,
9604 #[serde(rename = "subAgentOther")]
9605 SubAgentOther,
9606 #[serde(rename = "unknown")]
9607 Unknown,
9608}
9609
9610#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9611#[serde(rename_all = "camelCase")]
9612pub struct ThreadStartParams {
9613 #[serde(
9614 rename = "approvalPolicy",
9615 default,
9616 skip_serializing_if = "Option::is_none"
9617 )]
9618 pub approval_policy: Option<AskForApproval>,
9619 #[serde(
9620 rename = "approvalsReviewer",
9621 default,
9622 skip_serializing_if = "Option::is_none"
9623 )]
9624 pub approvals_reviewer: Option<ApprovalsReviewer>,
9625 #[serde(
9626 rename = "baseInstructions",
9627 default,
9628 skip_serializing_if = "Option::is_none"
9629 )]
9630 pub base_instructions: Option<String>,
9631 #[serde(default, skip_serializing_if = "Option::is_none")]
9632 pub config: Option<Value>,
9633 #[serde(default, skip_serializing_if = "Option::is_none")]
9634 pub cwd: Option<String>,
9635 #[serde(
9636 rename = "developerInstructions",
9637 default,
9638 skip_serializing_if = "Option::is_none"
9639 )]
9640 pub developer_instructions: Option<String>,
9641 #[serde(default, skip_serializing_if = "Option::is_none")]
9642 pub ephemeral: Option<bool>,
9643 #[serde(default, skip_serializing_if = "Option::is_none")]
9644 pub model: Option<String>,
9645 #[serde(
9646 rename = "modelProvider",
9647 default,
9648 skip_serializing_if = "Option::is_none"
9649 )]
9650 pub model_provider: Option<String>,
9651 #[serde(default, skip_serializing_if = "Option::is_none")]
9652 pub personality: Option<Personality>,
9653 #[serde(default, skip_serializing_if = "Option::is_none")]
9654 pub sandbox: Option<SandboxMode>,
9655 #[serde(
9656 rename = "serviceName",
9657 default,
9658 skip_serializing_if = "Option::is_none"
9659 )]
9660 pub service_name: Option<String>,
9661 #[serde(
9662 rename = "serviceTier",
9663 default,
9664 skip_serializing_if = "Option::is_none"
9665 )]
9666 pub service_tier: Option<String>,
9667 #[serde(
9668 rename = "sessionStartSource",
9669 default,
9670 skip_serializing_if = "Option::is_none"
9671 )]
9672 pub session_start_source: Option<ThreadStartSource>,
9673 #[serde(
9674 rename = "threadSource",
9675 default,
9676 skip_serializing_if = "Option::is_none"
9677 )]
9678 pub thread_source: Option<ThreadSource>,
9679}
9680
9681#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9682#[serde(rename_all = "camelCase")]
9683pub struct ThreadStartResponse {
9684 #[serde(rename = "approvalPolicy")]
9685 pub approval_policy: AskForApproval,
9686 #[serde(rename = "approvalsReviewer", default)]
9687 pub approvals_reviewer: Value,
9688 #[serde()]
9689 pub cwd: AbsolutePathBuf,
9690 #[serde(rename = "disabledPluginIds", default)]
9693 pub disabled_plugin_ids: Vec<String>,
9694 #[serde(
9695 rename = "instructionSources",
9696 default,
9697 skip_serializing_if = "Option::is_none"
9698 )]
9699 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9700 #[serde(default)]
9701 pub model: String,
9702 #[serde(rename = "modelProvider", default)]
9703 pub model_provider: String,
9704 #[serde(
9705 rename = "reasoningEffort",
9706 default,
9707 skip_serializing_if = "Option::is_none"
9708 )]
9709 pub reasoning_effort: Option<ReasoningEffort>,
9710 #[serde(default)]
9711 pub sandbox: Value,
9712 #[serde(
9713 rename = "serviceTier",
9714 default,
9715 skip_serializing_if = "Option::is_none"
9716 )]
9717 pub service_tier: Option<String>,
9718 #[serde()]
9719 pub thread: Thread,
9720}
9721
9722#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9723pub enum ThreadStartSource {
9724 #[serde(rename = "startup")]
9725 Startup,
9726 #[serde(rename = "clear")]
9727 Clear,
9728}
9729
9730#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9731#[serde(rename_all = "camelCase")]
9732pub struct ThreadStartedNotification {
9733 #[serde()]
9734 pub thread: Thread,
9735}
9736
9737#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9738#[serde(tag = "type", rename_all = "camelCase")]
9739pub enum ThreadStatus {
9740 #[serde(rename = "notLoaded")]
9741 NotLoaded,
9742 Idle,
9743 #[serde(rename = "systemError")]
9744 SystemError,
9745 Active {
9746 #[serde(rename = "activeFlags")]
9747 active_flags: Vec<ThreadActiveFlag>,
9748 },
9749}
9750
9751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9752#[serde(rename_all = "camelCase")]
9753pub struct ThreadStatusChangedNotification {
9754 #[serde()]
9755 pub status: ThreadStatus,
9756 #[serde(rename = "threadId", default)]
9757 pub thread_id: String,
9758}
9759
9760#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9761#[serde(rename_all = "camelCase")]
9762pub struct ThreadTokenUsage {
9763 #[serde()]
9764 pub last: TokenUsageBreakdown,
9765 #[serde(
9766 rename = "modelContextWindow",
9767 default,
9768 skip_serializing_if = "Option::is_none"
9769 )]
9770 pub model_context_window: Option<i64>,
9771 #[serde()]
9772 pub total: TokenUsageBreakdown,
9773}
9774
9775#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9776#[serde(rename_all = "camelCase")]
9777pub struct ThreadTokenUsageUpdatedNotification {
9778 #[serde(rename = "threadId", default)]
9779 pub thread_id: String,
9780 #[serde(rename = "tokenUsage")]
9781 pub token_usage: ThreadTokenUsage,
9782 #[serde(rename = "turnId", default)]
9783 pub turn_id: String,
9784}
9785
9786#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9787#[serde(rename_all = "camelCase")]
9788pub struct ThreadUnarchiveParams {
9789 #[serde(rename = "threadId", default)]
9790 pub thread_id: String,
9791}
9792
9793#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9794#[serde(rename_all = "camelCase")]
9795pub struct ThreadUnarchiveResponse {
9796 #[serde()]
9797 pub thread: Thread,
9798}
9799
9800#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9801#[serde(rename_all = "camelCase")]
9802pub struct ThreadUnarchivedNotification {
9803 #[serde(rename = "threadId", default)]
9804 pub thread_id: String,
9805}
9806
9807#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9808#[serde(tag = "type", rename_all = "camelCase")]
9809pub enum ThreadUnreadPosition {
9810 #[serde(rename = "threadStart")]
9812 ThreadStart,
9813 Turn {
9815 #[serde(rename = "turnId")]
9816 turn_id: String,
9817 },
9818}
9819
9820#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9825#[serde(tag = "type", rename_all = "camelCase")]
9826#[allow(clippy::large_enum_variant)] pub enum ThreadTimelineEntry {
9828 Item {
9829 item: ThreadItem,
9830 position: u64,
9831 #[serde(rename = "turnId")]
9832 turn_id: String,
9833 },
9834 Realtime {
9835 item: ThreadRealtimeItem,
9836 position: u64,
9837 },
9838 TurnStarted {
9839 position: u64,
9840 #[serde(default, skip_serializing_if = "Option::is_none")]
9841 started_at: Option<i64>,
9842 turn_id: String,
9843 },
9844 TurnCompleted {
9845 #[serde(default, skip_serializing_if = "Option::is_none")]
9846 completed_at: Option<i64>,
9847 #[serde(default, skip_serializing_if = "Option::is_none")]
9848 duration_ms: Option<i64>,
9849 #[serde(default, skip_serializing_if = "Option::is_none")]
9850 error: Option<TurnError>,
9851 position: u64,
9852 #[serde(default, skip_serializing_if = "Option::is_none")]
9853 started_at: Option<i64>,
9854 status: TurnStatus,
9855 turn_id: String,
9856 },
9857}
9858
9859#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9861#[serde(rename_all = "camelCase")]
9862pub struct ThreadTurnsListParams {
9863 #[serde(default, skip_serializing_if = "Option::is_none")]
9864 pub cursor: Option<String>,
9865 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9867 pub items_view: Option<TurnItemsView>,
9868 #[serde(default, skip_serializing_if = "Option::is_none")]
9869 pub limit: Option<u32>,
9870 #[serde(
9871 rename = "sortDirection",
9872 default,
9873 skip_serializing_if = "Option::is_none"
9874 )]
9875 pub sort_direction: Option<SortDirection>,
9876 #[serde(rename = "threadId", default)]
9877 pub thread_id: String,
9878}
9879
9880#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9882#[serde(rename_all = "camelCase")]
9883pub struct ThreadTurnsListResponse {
9884 #[serde(
9885 rename = "backwardsCursor",
9886 default,
9887 skip_serializing_if = "Option::is_none"
9888 )]
9889 pub backwards_cursor: Option<String>,
9890 #[serde(default)]
9891 pub data: Vec<Turn>,
9892 #[serde(
9893 rename = "nextCursor",
9894 default,
9895 skip_serializing_if = "Option::is_none"
9896 )]
9897 pub next_cursor: Option<String>,
9898}
9899
9900#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9901#[serde(rename_all = "camelCase")]
9902pub struct ThreadUnsubscribeParams {
9903 #[serde(rename = "threadId", default)]
9904 pub thread_id: String,
9905}
9906
9907#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9908#[serde(rename_all = "camelCase")]
9909pub struct ThreadUnsubscribeResponse {
9910 #[serde()]
9911 pub status: ThreadUnsubscribeStatus,
9912}
9913
9914#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9915pub enum ThreadUnsubscribeStatus {
9916 #[serde(rename = "notLoaded")]
9917 NotLoaded,
9918 #[serde(rename = "notSubscribed")]
9919 NotSubscribed,
9920 #[serde(rename = "unsubscribed")]
9921 Unsubscribed,
9922}
9923
9924#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9925#[serde(rename_all = "camelCase")]
9926pub struct TokenUsageBreakdown {
9927 #[serde(
9928 rename = "cacheWriteInputTokens",
9929 default,
9930 skip_serializing_if = "Option::is_none"
9931 )]
9932 pub cache_write_input_tokens: Option<i64>,
9933 #[serde(rename = "cachedInputTokens", default)]
9934 pub cached_input_tokens: i64,
9935 #[serde(rename = "inputTokens", default)]
9936 pub input_tokens: i64,
9937 #[serde(rename = "outputTokens", default)]
9938 pub output_tokens: i64,
9939 #[serde(rename = "reasoningOutputTokens", default)]
9940 pub reasoning_output_tokens: i64,
9941 #[serde(rename = "totalTokens", default)]
9942 pub total_tokens: i64,
9943}
9944
9945#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9946#[serde(rename_all = "camelCase")]
9947pub struct Tool {
9948 #[serde(default, skip_serializing_if = "Option::is_none")]
9949 pub _meta: Option<Value>,
9950 #[serde(default, skip_serializing_if = "Option::is_none")]
9951 pub annotations: Option<Value>,
9952 #[serde(default, skip_serializing_if = "Option::is_none")]
9953 pub description: Option<String>,
9954 #[serde(default, skip_serializing_if = "Option::is_none")]
9955 pub icons: Option<Vec<Value>>,
9956 #[serde(rename = "inputSchema", default)]
9957 pub input_schema: Value,
9958 #[serde(default)]
9959 pub name: String,
9960 #[serde(
9961 rename = "outputSchema",
9962 default,
9963 skip_serializing_if = "Option::is_none"
9964 )]
9965 pub output_schema: Option<Value>,
9966 #[serde(default, skip_serializing_if = "Option::is_none")]
9967 pub title: Option<String>,
9968}
9969
9970#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9971#[serde(rename_all = "camelCase")]
9972pub struct ToolRequestUserInputAnswer {
9973 #[serde(default)]
9974 pub answers: Vec<String>,
9975}
9976
9977#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9978#[serde(rename_all = "camelCase")]
9979pub struct ToolRequestUserInputOption {
9980 #[serde(default)]
9981 pub description: String,
9982 #[serde(default)]
9983 pub label: String,
9984}
9985
9986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9987#[serde(rename_all = "camelCase")]
9988pub struct ToolRequestUserInputParams {
9989 #[serde(
9990 rename = "autoResolutionMs",
9991 default,
9992 skip_serializing_if = "Option::is_none"
9993 )]
9994 pub auto_resolution_ms: Option<i64>,
9995 #[serde(rename = "isBlocking", default)]
9996 pub is_blocking: bool,
9997 #[serde(rename = "itemId", default)]
9998 pub item_id: String,
9999 #[serde(default)]
10000 pub questions: Vec<ToolRequestUserInputQuestion>,
10001 #[serde(rename = "threadId", default)]
10002 pub thread_id: String,
10003 #[serde(rename = "turnId", default)]
10004 pub turn_id: String,
10005}
10006
10007#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10008#[serde(rename_all = "camelCase")]
10009pub struct ToolRequestUserInputQuestion {
10010 #[serde(default)]
10011 pub header: String,
10012 #[serde(default)]
10013 pub id: String,
10014 #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
10015 pub is_other: Option<bool>,
10016 #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
10017 pub is_secret: Option<bool>,
10018 #[serde(default, skip_serializing_if = "Option::is_none")]
10019 pub options: Option<Vec<ToolRequestUserInputOption>>,
10020 #[serde(default)]
10021 pub question: String,
10022}
10023
10024#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10025#[serde(rename_all = "camelCase")]
10026pub struct ToolRequestUserInputResponse {
10027 #[serde(default)]
10028 pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
10029}
10030
10031#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10032#[serde(rename_all = "camelCase")]
10033pub struct ToolsV2 {
10034 #[serde(default, skip_serializing_if = "Option::is_none")]
10035 pub web_search: Option<WebSearchToolConfig>,
10036}
10037
10038#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10039#[serde(rename_all = "camelCase")]
10040pub struct Turn {
10041 #[serde(
10042 rename = "completedAt",
10043 default,
10044 skip_serializing_if = "Option::is_none"
10045 )]
10046 pub completed_at: Option<i64>,
10047 #[serde(
10048 rename = "durationMs",
10049 default,
10050 skip_serializing_if = "Option::is_none"
10051 )]
10052 pub duration_ms: Option<i64>,
10053 #[serde(default, skip_serializing_if = "Option::is_none")]
10054 pub error: Option<TurnError>,
10055 #[serde(default)]
10056 pub id: String,
10057 #[serde(default)]
10058 pub items: Vec<ThreadItem>,
10059 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
10060 pub items_view: Option<Value>,
10061 #[serde(
10065 rename = "rootTurnId",
10066 default,
10067 skip_serializing_if = "Option::is_none"
10068 )]
10069 pub root_turn_id: Option<String>,
10070 #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
10071 pub started_at: Option<i64>,
10072 #[serde()]
10073 pub status: TurnStatus,
10074}
10075
10076#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10077#[serde(rename_all = "camelCase")]
10078pub struct TurnCompletedNotification {
10079 #[serde(rename = "threadId", default)]
10080 pub thread_id: String,
10081 #[serde()]
10082 pub turn: Turn,
10083}
10084
10085#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10086#[serde(rename_all = "camelCase")]
10087pub struct TurnDiffUpdatedNotification {
10088 #[serde(default)]
10089 pub diff: String,
10090 #[serde(rename = "threadId", default)]
10091 pub thread_id: String,
10092 #[serde(rename = "turnId", default)]
10093 pub turn_id: String,
10094}
10095
10096#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10097#[serde(rename_all = "camelCase")]
10098pub struct TurnError {
10099 #[serde(
10100 rename = "additionalDetails",
10101 default,
10102 skip_serializing_if = "Option::is_none"
10103 )]
10104 pub additional_details: Option<String>,
10105 #[serde(
10106 rename = "codexErrorInfo",
10107 default,
10108 skip_serializing_if = "Option::is_none"
10109 )]
10110 pub codex_error_info: Option<CodexErrorInfo>,
10111 #[serde(default)]
10112 pub message: String,
10113 #[serde(default, skip_serializing_if = "Option::is_none")]
10116 pub misalignment: Option<MisalignmentErrorDetails>,
10117}
10118
10119#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10120#[serde(rename_all = "camelCase")]
10121pub struct TurnInterruptParams {
10122 #[serde(rename = "threadId", default)]
10123 pub thread_id: String,
10124 #[serde(rename = "turnId", default)]
10125 pub turn_id: String,
10126}
10127
10128#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10129#[serde(rename_all = "camelCase")]
10130pub struct TurnInterruptResponse {
10131 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
10132 pub extra: serde_json::Map<String, Value>,
10133}
10134
10135#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
10136pub enum TurnItemsView {
10137 #[serde(rename = "notLoaded")]
10138 NotLoaded,
10139 #[serde(rename = "summary")]
10140 Summary,
10141 #[serde(rename = "full")]
10142 Full,
10143}
10144
10145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10146#[serde(rename_all = "camelCase")]
10147pub struct TurnModerationMetadataNotification {
10148 #[serde(default)]
10149 pub metadata: Value,
10150 #[serde(rename = "threadId", default)]
10151 pub thread_id: String,
10152 #[serde(rename = "turnId", default)]
10153 pub turn_id: String,
10154}
10155
10156#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10157#[serde(rename_all = "camelCase")]
10158pub struct TurnPlanStep {
10159 #[serde()]
10160 pub status: TurnPlanStepStatus,
10161 #[serde(default)]
10162 pub step: String,
10163}
10164
10165#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10166pub enum TurnPlanStepStatus {
10167 #[serde(rename = "pending")]
10168 Pending,
10169 #[serde(rename = "inProgress")]
10170 InProgress,
10171 #[serde(rename = "completed")]
10172 Completed,
10173}
10174
10175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10176#[serde(rename_all = "camelCase")]
10177pub struct TurnPlanUpdatedNotification {
10178 #[serde(default, skip_serializing_if = "Option::is_none")]
10179 pub explanation: Option<String>,
10180 #[serde(default)]
10181 pub plan: Vec<TurnPlanStep>,
10182 #[serde(rename = "threadId", default)]
10183 pub thread_id: String,
10184 #[serde(rename = "turnId", default)]
10185 pub turn_id: String,
10186}
10187
10188#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10189#[serde(rename_all = "camelCase")]
10190pub struct TurnStartParams {
10191 #[serde(
10192 rename = "approvalPolicy",
10193 default,
10194 skip_serializing_if = "Option::is_none"
10195 )]
10196 pub approval_policy: Option<AskForApproval>,
10197 #[serde(
10198 rename = "approvalsReviewer",
10199 default,
10200 skip_serializing_if = "Option::is_none"
10201 )]
10202 pub approvals_reviewer: Option<ApprovalsReviewer>,
10203 #[serde(
10204 rename = "clientUserMessageId",
10205 default,
10206 skip_serializing_if = "Option::is_none"
10207 )]
10208 pub client_user_message_id: Option<String>,
10209 #[serde(default, skip_serializing_if = "Option::is_none")]
10210 pub cwd: Option<String>,
10211 #[serde(
10214 rename = "disabledPluginIds",
10215 default,
10216 skip_serializing_if = "Option::is_none"
10217 )]
10218 pub disabled_plugin_ids: Option<Vec<String>>,
10219 #[serde(default, skip_serializing_if = "Option::is_none")]
10220 pub effort: Option<ReasoningEffort>,
10221 #[serde(default)]
10222 pub input: Vec<UserInput>,
10223 #[serde(default, skip_serializing_if = "Option::is_none")]
10224 pub model: Option<String>,
10225 #[serde(
10226 rename = "outputSchema",
10227 default,
10228 skip_serializing_if = "Option::is_none"
10229 )]
10230 pub output_schema: Option<Value>,
10231 #[serde(
10235 rename = "parentTurnId",
10236 default,
10237 skip_serializing_if = "Option::is_none"
10238 )]
10239 pub parent_turn_id: Option<String>,
10240 #[serde(default, skip_serializing_if = "Option::is_none")]
10241 pub personality: Option<Personality>,
10242 #[serde(
10247 rename = "rootTurnId",
10248 default,
10249 skip_serializing_if = "Option::is_none"
10250 )]
10251 pub root_turn_id: Option<String>,
10252 #[serde(
10253 rename = "sandboxPolicy",
10254 default,
10255 skip_serializing_if = "Option::is_none"
10256 )]
10257 pub sandbox_policy: Option<SandboxPolicy>,
10258 #[serde(
10259 rename = "serviceTier",
10260 default,
10261 skip_serializing_if = "Option::is_none"
10262 )]
10263 pub service_tier: Option<String>,
10264 #[serde(
10267 rename = "serviceTierForTurn",
10268 default,
10269 skip_serializing_if = "Option::is_none"
10270 )]
10271 pub service_tier_for_turn: Option<String>,
10272 #[serde(default, skip_serializing_if = "Option::is_none")]
10273 pub summary: Option<ReasoningSummary>,
10274 #[serde(rename = "threadId", default)]
10275 pub thread_id: String,
10276 #[serde(
10279 rename = "toolOutput",
10280 default,
10281 skip_serializing_if = "Option::is_none"
10282 )]
10283 pub tool_output: Option<TurnToolOutput>,
10284 #[serde(
10287 rename = "turnTrigger",
10288 default,
10289 skip_serializing_if = "Option::is_none"
10290 )]
10291 pub turn_trigger: Option<String>,
10292}
10293
10294#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10295#[serde(rename_all = "camelCase")]
10296pub struct TurnStartResponse {
10297 #[serde()]
10298 pub turn: Turn,
10299}
10300
10301#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10302#[serde(rename_all = "camelCase")]
10303pub struct TurnStartedNotification {
10304 #[serde(rename = "threadId", default)]
10305 pub thread_id: String,
10306 #[serde()]
10307 pub turn: Turn,
10308}
10309
10310#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10311pub enum TurnStatus {
10312 #[serde(rename = "completed")]
10313 Completed,
10314 #[serde(rename = "interrupted")]
10315 Interrupted,
10316 #[serde(rename = "failed")]
10317 Failed,
10318 #[serde(rename = "inProgress")]
10319 InProgress,
10320}
10321
10322#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10325#[serde(rename_all = "camelCase")]
10326pub struct TurnToolOutput {
10327 #[serde(default)]
10328 pub name: String,
10329 #[serde(default, skip_serializing_if = "Option::is_none")]
10330 pub namespace: Option<String>,
10331 #[serde()]
10332 pub output: FunctionCallOutputBody,
10333 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
10336 pub retain: bool,
10337}
10338
10339#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10340#[serde(rename_all = "camelCase")]
10341pub struct TurnSteerParams {
10342 #[serde(
10343 rename = "clientUserMessageId",
10344 default,
10345 skip_serializing_if = "Option::is_none"
10346 )]
10347 pub client_user_message_id: Option<String>,
10348 #[serde(rename = "expectedTurnId", default)]
10349 pub expected_turn_id: String,
10350 #[serde(default)]
10351 pub input: Vec<UserInput>,
10352 #[serde(rename = "threadId", default)]
10353 pub thread_id: String,
10354}
10355
10356#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10357#[serde(rename_all = "camelCase")]
10358pub struct TurnSteerResponse {
10359 #[serde(rename = "turnId", default)]
10360 pub turn_id: String,
10361}
10362
10363#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10364#[serde(tag = "type", rename_all = "camelCase")]
10365pub enum UserInput {
10366 Text {
10367 text: String,
10368 #[serde(default, skip_serializing_if = "Option::is_none")]
10369 text_elements: Option<Vec<TextElement>>,
10370 },
10371 Image {
10372 #[serde(default, skip_serializing_if = "Option::is_none")]
10373 detail: Option<ImageDetail>,
10374 #[serde(flatten)]
10375 image: UserInputImageReference,
10376 },
10377 #[serde(rename = "localImage")]
10378 LocalImage {
10379 #[serde(default, skip_serializing_if = "Option::is_none")]
10380 detail: Option<ImageDetail>,
10381 path: String,
10382 },
10383 Audio {
10384 #[serde(flatten)]
10385 audio: UserInputAudioReference,
10386 },
10387 #[serde(rename = "localAudio")]
10388 LocalAudio {
10389 path: String,
10390 },
10391 Skill {
10392 name: String,
10393 path: String,
10394 },
10395 Mention {
10396 name: String,
10397 path: String,
10398 },
10399}
10400
10401#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10407#[serde(untagged)]
10408pub enum UserInputImageReference {
10409 Inline {
10410 url: String,
10411 },
10412 File {
10413 #[serde(rename = "fileId")]
10414 file_id: String,
10415 },
10416}
10417
10418#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10423#[serde(untagged)]
10424pub enum UserInputAudioReference {
10425 Inline {
10426 url: String,
10427 },
10428 File {
10429 #[serde(rename = "fileId")]
10430 file_id: String,
10431 },
10432}
10433
10434#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10435pub enum Verbosity {
10436 #[serde(rename = "low")]
10437 Low,
10438 #[serde(rename = "medium")]
10439 Medium,
10440 #[serde(rename = "high")]
10441 High,
10442}
10443
10444#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10445#[serde(rename_all = "camelCase")]
10446pub struct WarningNotification {
10447 #[serde(default)]
10448 pub message: String,
10449 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
10450 pub thread_id: Option<String>,
10451}
10452
10453#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10454#[serde(tag = "type", rename_all = "camelCase")]
10455pub enum WebSearchAction {
10456 Search {
10457 #[serde(default, skip_serializing_if = "Option::is_none")]
10458 queries: Option<Vec<String>>,
10459 #[serde(default, skip_serializing_if = "Option::is_none")]
10460 query: Option<String>,
10461 },
10462 #[serde(rename = "openPage")]
10463 OpenPage {
10464 #[serde(default, skip_serializing_if = "Option::is_none")]
10465 url: Option<String>,
10466 },
10467 #[serde(rename = "findInPage")]
10468 FindInPage {
10469 #[serde(default, skip_serializing_if = "Option::is_none")]
10470 pattern: Option<String>,
10471 #[serde(default, skip_serializing_if = "Option::is_none")]
10472 url: Option<String>,
10473 },
10474 Other,
10475}
10476
10477#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10478pub enum WebSearchContextSize {
10479 #[serde(rename = "low")]
10480 Low,
10481 #[serde(rename = "medium")]
10482 Medium,
10483 #[serde(rename = "high")]
10484 High,
10485}
10486
10487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10488#[serde(rename_all = "camelCase")]
10489pub struct WebSearchLocation {
10490 #[serde(default, skip_serializing_if = "Option::is_none")]
10491 pub city: Option<String>,
10492 #[serde(default, skip_serializing_if = "Option::is_none")]
10493 pub country: Option<String>,
10494 #[serde(default, skip_serializing_if = "Option::is_none")]
10495 pub region: Option<String>,
10496 #[serde(default, skip_serializing_if = "Option::is_none")]
10497 pub timezone: Option<String>,
10498}
10499
10500#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10501pub enum WebSearchMode {
10502 #[serde(rename = "disabled")]
10503 Disabled,
10504 #[serde(rename = "cached")]
10505 Cached,
10506 #[serde(rename = "indexed")]
10507 Indexed,
10508 #[serde(rename = "live")]
10509 Live,
10510}
10511
10512#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10515pub enum WebSearchProvider {
10516 #[serde(rename = "standalone")]
10517 Standalone,
10518 #[serde(rename = "search_mcp")]
10519 SearchMcp,
10520}
10521
10522#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10523#[serde(rename_all = "camelCase")]
10524pub struct WebSearchToolConfig {
10525 #[serde(default, skip_serializing_if = "Option::is_none")]
10526 pub allowed_domains: Option<Vec<String>>,
10527 #[serde(default, skip_serializing_if = "Option::is_none")]
10528 pub context_size: Option<WebSearchContextSize>,
10529 #[serde(default, skip_serializing_if = "Option::is_none")]
10530 pub location: Option<WebSearchLocation>,
10531}
10532
10533#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10534pub enum WindowsSandboxReadiness {
10535 #[serde(rename = "ready")]
10536 Ready,
10537 #[serde(rename = "notConfigured")]
10538 NotConfigured,
10539 #[serde(rename = "updateRequired")]
10540 UpdateRequired,
10541}
10542
10543#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10544#[serde(rename_all = "camelCase")]
10545pub struct WindowsSandboxReadinessResponse {
10546 #[serde()]
10547 pub status: WindowsSandboxReadiness,
10548}
10549
10550#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10551#[serde(rename_all = "camelCase")]
10552pub struct WindowsSandboxSetupCompletedNotification {
10553 #[serde(default, skip_serializing_if = "Option::is_none")]
10554 pub error: Option<String>,
10555 #[serde()]
10556 pub mode: WindowsSandboxSetupMode,
10557 #[serde(default)]
10558 pub success: bool,
10559}
10560
10561#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10562pub enum WindowsSandboxSetupMode {
10563 #[serde(rename = "elevated")]
10564 Elevated,
10565 #[serde(rename = "unelevated")]
10566 Unelevated,
10567}
10568
10569#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10573pub enum WindowsSandboxImplementation {
10574 #[serde(rename = "elevated")]
10575 Elevated,
10576 #[serde(rename = "unelevated")]
10577 Unelevated,
10578 #[serde(rename = "mxc")]
10579 Mxc,
10580}
10581
10582#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10583#[serde(rename_all = "camelCase")]
10584pub struct WindowsSandboxSetupStartParams {
10585 #[serde(default, skip_serializing_if = "Option::is_none")]
10586 pub cwd: Option<AbsolutePathBuf>,
10587 #[serde()]
10588 pub mode: WindowsSandboxSetupMode,
10589}
10590
10591#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10592#[serde(rename_all = "camelCase")]
10593pub struct WindowsSandboxSetupStartResponse {
10594 #[serde(default)]
10595 pub started: bool,
10596}
10597
10598#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10599#[serde(rename_all = "camelCase")]
10600pub struct WindowsWorldWritableWarningNotification {
10601 #[serde(rename = "extraCount", default)]
10602 pub extra_count: i64,
10603 #[serde(rename = "failedScan", default)]
10604 pub failed_scan: bool,
10605 #[serde(rename = "samplePaths", default)]
10606 pub sample_paths: Vec<String>,
10607}
10608
10609#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10610#[serde(rename_all = "camelCase")]
10611pub struct WorkspaceMessage {
10612 #[serde(
10613 rename = "archivedAt",
10614 default,
10615 skip_serializing_if = "Option::is_none"
10616 )]
10617 pub archived_at: Option<i64>,
10618 #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
10619 pub created_at: Option<i64>,
10620 #[serde(rename = "messageBody", default)]
10621 pub message_body: String,
10622 #[serde(rename = "messageId", default)]
10623 pub message_id: String,
10624 #[serde(rename = "messageType")]
10625 pub message_type: WorkspaceMessageType,
10626}
10627
10628#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10629pub enum WorkspaceMessageType {
10630 #[serde(rename = "headline")]
10631 Headline,
10632 #[serde(rename = "announcement")]
10633 Announcement,
10634 #[serde(rename = "unknown")]
10635 Unknown,
10636}
10637
10638#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10639pub enum WriteStatus {
10640 #[serde(rename = "ok")]
10641 Ok,
10642 #[serde(rename = "okOverridden")]
10643 OkOverridden,
10644}