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(rename = "_meta", default, skip_serializing_if = "Option::is_none")]
4327 pub meta: Option<serde_json::Map<String, Value>>,
4328 #[serde(
4329 rename = "connectorId",
4330 default,
4331 skip_serializing_if = "Option::is_none"
4332 )]
4333 pub connector_id: Option<String>,
4334 #[serde(
4336 rename = "originCallId",
4337 default,
4338 skip_serializing_if = "Option::is_none"
4339 )]
4340 pub origin_call_id: Option<String>,
4341 #[serde(default)]
4342 pub server: String,
4343 #[serde(default, skip_serializing_if = "Option::is_none")]
4345 pub target: Option<McpResourceReadTarget>,
4346 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4347 pub thread_id: Option<String>,
4348 #[serde(default)]
4349 pub uri: String,
4350}
4351
4352#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4354#[serde(rename_all = "camelCase")]
4355pub struct McpResourceReadTarget {
4356 #[serde(rename = "connectorId", default)]
4357 pub connector_id: String,
4358 #[serde(rename = "linkId", default)]
4361 pub link_id: Option<String>,
4362}
4363
4364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4365#[serde(rename_all = "camelCase")]
4366pub struct McpResourceReadResponse {
4367 #[serde(default)]
4368 pub contents: Vec<ResourceContent>,
4369 #[serde(
4372 rename = "originCallId",
4373 default,
4374 skip_serializing_if = "Option::is_none"
4375 )]
4376 pub origin_call_id: Option<String>,
4377}
4378
4379#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4380pub enum McpServerElicitationAction {
4381 #[serde(rename = "accept")]
4382 Accept,
4383 #[serde(rename = "decline")]
4384 Decline,
4385 #[serde(rename = "cancel")]
4386 Cancel,
4387}
4388
4389#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4390#[serde(tag = "mode", rename_all = "camelCase")]
4391pub enum McpServerElicitationRequestParams {
4392 Form {
4393 #[serde(default, skip_serializing_if = "Option::is_none")]
4394 _meta: Option<Value>,
4395 message: String,
4396 #[serde(rename = "requestedSchema")]
4397 requested_schema: McpElicitationSchema,
4398 },
4399 #[serde(rename = "openai/form")]
4400 OpenaiForm {
4401 #[serde(default, skip_serializing_if = "Option::is_none")]
4402 _meta: Option<Value>,
4403 message: String,
4404 #[serde(rename = "requestedSchema")]
4405 requested_schema: Value,
4406 },
4407 #[serde(rename = "openaiForm")]
4408 OpenAiElicitationForm {
4409 #[serde(default, skip_serializing_if = "Option::is_none")]
4410 _meta: Option<Value>,
4411 message: String,
4412 #[serde(rename = "requestedSchema")]
4413 requested_schema: Value,
4414 },
4415 Url {
4416 #[serde(default, skip_serializing_if = "Option::is_none")]
4417 _meta: Option<Value>,
4418 #[serde(rename = "elicitationId")]
4419 elicitation_id: String,
4420 message: String,
4421 url: String,
4422 },
4423}
4424
4425#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4426#[serde(rename_all = "camelCase")]
4427pub struct McpServerElicitationRequestResponse {
4428 #[serde(default, skip_serializing_if = "Option::is_none")]
4429 pub _meta: Option<Value>,
4430 #[serde()]
4431 pub action: McpServerElicitationAction,
4432 #[serde(default, skip_serializing_if = "Option::is_none")]
4433 pub content: Option<Value>,
4434}
4435
4436#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4437#[serde(rename_all = "camelCase")]
4438pub struct McpServerInfo {
4439 #[serde(default, skip_serializing_if = "Option::is_none")]
4440 pub description: Option<String>,
4441 #[serde(default, skip_serializing_if = "Option::is_none")]
4442 pub icons: Option<Vec<Value>>,
4443 #[serde(default)]
4444 pub name: String,
4445 #[serde(default, skip_serializing_if = "Option::is_none")]
4446 pub title: Option<String>,
4447 #[serde(default)]
4448 pub version: String,
4449 #[serde(
4450 rename = "websiteUrl",
4451 default,
4452 skip_serializing_if = "Option::is_none"
4453 )]
4454 pub website_url: Option<String>,
4455}
4456
4457#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4458#[serde(rename_all = "camelCase")]
4459pub struct McpServerMigration {
4460 #[serde(default)]
4461 pub name: String,
4462}
4463
4464#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4465#[serde(rename_all = "camelCase")]
4466pub struct McpServerOauthLoginCompletedNotification {
4467 #[serde(default, skip_serializing_if = "Option::is_none")]
4468 pub error: Option<String>,
4469 #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4471 pub login_id: Option<String>,
4472 #[serde(default)]
4473 pub name: String,
4474 #[serde(default)]
4475 pub success: bool,
4476 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4477 pub thread_id: Option<String>,
4478}
4479
4480#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4481#[serde(rename_all = "camelCase")]
4482pub struct McpServerOauthLoginParams {
4483 #[serde(
4484 rename = "clientRegistration",
4485 default,
4486 skip_serializing_if = "Option::is_none"
4487 )]
4488 pub client_registration: Option<McpServerOauthClientRegistration>,
4489 #[serde(default)]
4490 pub name: String,
4491 #[serde(default, skip_serializing_if = "Option::is_none")]
4492 pub scopes: Option<Vec<String>>,
4493 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4494 pub thread_id: Option<String>,
4495 #[serde(
4496 rename = "timeoutSecs",
4497 default,
4498 skip_serializing_if = "Option::is_none"
4499 )]
4500 pub timeout_secs: Option<i64>,
4501}
4502
4503#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4504#[serde(rename_all = "camelCase")]
4505pub struct McpServerOauthLoginResponse {
4506 #[serde(rename = "authorizationUrl", default)]
4507 pub authorization_url: String,
4508 #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4512 pub login_id: Option<String>,
4513}
4514
4515#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4516#[serde(rename_all = "camelCase")]
4517pub struct McpServerRefreshResponse {
4518 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4519 pub extra: serde_json::Map<String, Value>,
4520}
4521
4522#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4523pub enum McpServerStartupFailureReason {
4524 #[serde(rename = "reauthenticationRequired")]
4525 ReauthenticationRequired,
4526}
4527
4528#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4529pub enum McpServerStartupState {
4530 #[serde(rename = "starting")]
4531 Starting,
4532 #[serde(rename = "ready")]
4533 Ready,
4534 #[serde(rename = "failed")]
4535 Failed,
4536 #[serde(rename = "cancelled")]
4537 Cancelled,
4538}
4539
4540#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4541#[serde(rename_all = "camelCase")]
4542pub struct McpServerStatus {
4543 #[serde(rename = "authStatus")]
4544 pub auth_status: McpAuthStatus,
4545 #[serde(
4549 rename = "httpOrigin",
4550 default,
4551 skip_serializing_if = "Option::is_none"
4552 )]
4553 pub http_origin: Option<String>,
4554 #[serde(
4556 rename = "runtimeStatus",
4557 default,
4558 skip_serializing_if = "Option::is_none"
4559 )]
4560 pub runtime_status: Option<McpServerConnectionStatus>,
4561 #[serde(default)]
4562 pub name: String,
4563 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
4564 pub plugin_id: Option<String>,
4565 #[serde(rename = "resourceTemplates", default)]
4566 pub resource_templates: Vec<ResourceTemplate>,
4567 #[serde(default)]
4568 pub resources: Vec<Resource>,
4569 #[serde(
4572 rename = "serverCapabilities",
4573 default,
4574 skip_serializing_if = "Option::is_none"
4575 )]
4576 pub server_capabilities: Option<Value>,
4577 #[serde(
4578 rename = "serverInfo",
4579 default,
4580 skip_serializing_if = "Option::is_none"
4581 )]
4582 pub server_info: Option<McpServerInfo>,
4583 #[serde(
4586 rename = "toolListMeta",
4587 default,
4588 skip_serializing_if = "Option::is_none"
4589 )]
4590 pub tool_list_meta: Option<Value>,
4591 #[serde(default)]
4592 pub tools: std::collections::BTreeMap<String, Tool>,
4593 #[serde(
4596 rename = "toolsError",
4597 default,
4598 skip_serializing_if = "Option::is_none"
4599 )]
4600 pub tools_error: Option<String>,
4601}
4602
4603#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4604pub enum McpServerStatusDetail {
4605 #[serde(rename = "full")]
4606 Full,
4607 #[serde(rename = "toolsAndAuthOnly")]
4608 ToolsAndAuthOnly,
4609}
4610
4611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4612#[serde(rename_all = "camelCase")]
4613pub struct McpServerStatusUpdatedNotification {
4614 #[serde(default, skip_serializing_if = "Option::is_none")]
4615 pub error: Option<String>,
4616 #[serde(
4617 rename = "failureReason",
4618 default,
4619 skip_serializing_if = "Option::is_none"
4620 )]
4621 pub failure_reason: Option<McpServerStartupFailureReason>,
4622 #[serde(default)]
4623 pub name: String,
4624 #[serde()]
4625 pub status: McpServerStartupState,
4626 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4627 pub thread_id: Option<String>,
4628}
4629
4630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4631#[serde(rename_all = "camelCase")]
4632pub struct McpServerToolCallParams {
4633 #[serde(default, skip_serializing_if = "Option::is_none")]
4634 pub _meta: Option<Value>,
4635 #[serde(default, skip_serializing_if = "Option::is_none")]
4636 pub arguments: Option<Value>,
4637 #[serde(default)]
4638 pub server: String,
4639 #[serde(rename = "threadId", default)]
4640 pub thread_id: String,
4641 #[serde(default)]
4642 pub tool: String,
4643}
4644
4645#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4646#[serde(rename_all = "camelCase")]
4647pub struct McpServerToolCallResponse {
4648 #[serde(default, skip_serializing_if = "Option::is_none")]
4649 pub _meta: Option<Value>,
4650 #[serde(default)]
4651 pub content: Vec<Value>,
4652 #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
4653 pub is_error: Option<bool>,
4654 #[serde(
4655 rename = "structuredContent",
4656 default,
4657 skip_serializing_if = "Option::is_none"
4658 )]
4659 pub structured_content: Option<Value>,
4660}
4661
4662#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
4665#[serde(rename_all = "camelCase")]
4666pub struct McpAppUi {
4667 #[serde(rename = "resourceUri")]
4668 pub resource_uri: String,
4669 #[serde(rename = "preferredModelDisplayMode")]
4670 pub preferred_model_display_mode: McpAppDisplayMode,
4671}
4672
4673#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4674pub enum McpAppDisplayMode {
4675 #[serde(rename = "inline")]
4676 Inline,
4677 #[serde(rename = "fullscreen")]
4678 Fullscreen,
4679}
4680
4681#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4682#[serde(rename_all = "camelCase")]
4683pub struct McpToolCallAppContext {
4684 #[serde(
4685 rename = "actionName",
4686 default,
4687 skip_serializing_if = "Option::is_none"
4688 )]
4689 pub action_name: Option<String>,
4690 #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
4691 pub app_name: Option<String>,
4692 #[serde(rename = "connectorId", default)]
4693 pub connector_id: String,
4694 #[serde(rename = "linkId", default, skip_serializing_if = "Option::is_none")]
4695 pub link_id: Option<String>,
4696 #[serde(
4697 rename = "resourceUri",
4698 default,
4699 skip_serializing_if = "Option::is_none"
4700 )]
4701 pub resource_uri: Option<String>,
4702}
4703
4704#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4705#[serde(rename_all = "camelCase")]
4706pub struct McpToolCallError {
4707 #[serde(default)]
4708 pub message: String,
4709}
4710
4711#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4712#[serde(rename_all = "camelCase")]
4713pub struct McpToolCallProgressNotification {
4714 #[serde(rename = "itemId", default)]
4715 pub item_id: String,
4716 #[serde(default)]
4717 pub message: String,
4718 #[serde(rename = "threadId", default)]
4719 pub thread_id: String,
4720 #[serde(rename = "turnId", default)]
4721 pub turn_id: String,
4722}
4723
4724#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4725#[serde(rename_all = "camelCase")]
4726pub struct McpToolCallResult {
4727 #[serde(default, skip_serializing_if = "Option::is_none")]
4728 pub _meta: Option<Value>,
4729 #[serde(default)]
4730 pub content: Vec<Value>,
4731 #[serde(
4732 rename = "structuredContent",
4733 default,
4734 skip_serializing_if = "Option::is_none"
4735 )]
4736 pub structured_content: Option<Value>,
4737}
4738
4739#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4740pub enum McpToolCallStatus {
4741 #[serde(rename = "inProgress")]
4742 InProgress,
4743 #[serde(rename = "completed")]
4744 Completed,
4745 #[serde(rename = "failed")]
4746 Failed,
4747}
4748
4749#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4750#[serde(rename_all = "camelCase")]
4751pub struct MemoryCitation {
4752 #[serde(default)]
4753 pub entries: Vec<MemoryCitationEntry>,
4754 #[serde(rename = "threadIds", default)]
4755 pub thread_ids: Vec<String>,
4756}
4757
4758#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4759#[serde(rename_all = "camelCase")]
4760pub struct MemoryCitationEntry {
4761 #[serde(rename = "lineEnd", default)]
4762 pub line_end: i64,
4763 #[serde(rename = "lineStart", default)]
4764 pub line_start: i64,
4765 #[serde(default)]
4766 pub note: String,
4767 #[serde(default)]
4768 pub path: String,
4769}
4770
4771#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4772pub enum MergeStrategy {
4773 #[serde(rename = "replace")]
4774 Replace,
4775 #[serde(rename = "upsert")]
4776 Upsert,
4777}
4778
4779#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4780pub enum MessagePhase {
4781 #[serde(rename = "commentary")]
4782 Commentary,
4783 #[serde(rename = "partial_answer")]
4786 PartialAnswer,
4787 #[serde(rename = "final_answer")]
4788 FinalAnswer,
4789}
4790
4791#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4792#[serde(rename_all = "camelCase")]
4793pub struct MigrationDetails {
4794 #[serde(default, skip_serializing_if = "Option::is_none")]
4795 pub commands: Option<Vec<CommandMigration>>,
4796 #[serde(default, skip_serializing_if = "Option::is_none")]
4797 pub hooks: Option<Vec<HookMigration>>,
4798 #[serde(
4799 rename = "mcpServers",
4800 default,
4801 skip_serializing_if = "Option::is_none"
4802 )]
4803 pub mcp_servers: Option<Vec<McpServerMigration>>,
4804 #[serde(default, skip_serializing_if = "Option::is_none")]
4805 pub memory: Option<Vec<String>>,
4806 #[serde(default, skip_serializing_if = "Option::is_none")]
4807 pub plugins: Option<Vec<PluginsMigration>>,
4808 #[serde(default, skip_serializing_if = "Option::is_none")]
4809 pub sessions: Option<Vec<SessionMigration>>,
4810 #[serde(default, skip_serializing_if = "Option::is_none")]
4811 pub skills: Option<Vec<SkillMigration>>,
4812 #[serde(default, skip_serializing_if = "Option::is_none")]
4813 pub subagents: Option<Vec<SubagentMigration>>,
4814}
4815
4816#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4819#[serde(rename_all = "camelCase")]
4820pub struct MisalignmentErrorDetails {
4821 #[serde(
4822 rename = "detailedExplanation",
4823 default,
4824 skip_serializing_if = "Option::is_none"
4825 )]
4826 pub detailed_explanation: Option<String>,
4827 #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
4829 pub error_type: Option<String>,
4830 #[serde(
4833 rename = "reviewTarget",
4834 default,
4835 skip_serializing_if = "Option::is_none"
4836 )]
4837 pub review_target: Option<String>,
4838 #[serde(default, skip_serializing_if = "Option::is_none")]
4841 pub steer: Option<MisalignmentSteer>,
4842}
4843
4844#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4846#[serde(rename_all = "camelCase")]
4847pub struct MisalignmentSteer {
4848 #[serde(default)]
4849 pub message: String,
4850}
4851
4852#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4853pub enum ModeKind {
4854 #[serde(rename = "plan")]
4855 Plan,
4856 #[serde(rename = "default")]
4857 Default,
4858}
4859
4860#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4861#[serde(rename_all = "camelCase")]
4862pub struct Model {
4863 #[serde(
4864 rename = "additionalSpeedTiers",
4865 default,
4866 skip_serializing_if = "Option::is_none"
4867 )]
4868 pub additional_speed_tiers: Option<Vec<String>>,
4869 #[serde(
4870 rename = "availabilityNux",
4871 default,
4872 skip_serializing_if = "Option::is_none"
4873 )]
4874 pub availability_nux: Option<ModelAvailabilityNux>,
4875 #[serde(
4877 rename = "availableAccessPrograms",
4878 default,
4879 skip_serializing_if = "Option::is_none"
4880 )]
4881 pub available_access_programs: Option<ModelAccessPrograms>,
4882 #[serde(rename = "defaultReasoningEffort")]
4883 pub default_reasoning_effort: ReasoningEffort,
4884 #[serde(
4885 rename = "defaultServiceTier",
4886 default,
4887 skip_serializing_if = "Option::is_none"
4888 )]
4889 pub default_service_tier: Option<String>,
4890 #[serde(default)]
4891 pub description: String,
4892 #[serde(rename = "displayName", default)]
4893 pub display_name: String,
4894 #[serde(default)]
4895 pub hidden: bool,
4896 #[serde(default)]
4897 pub id: String,
4898 #[serde(
4899 rename = "inputModalities",
4900 default,
4901 skip_serializing_if = "Option::is_none"
4902 )]
4903 pub input_modalities: Option<Vec<InputModality>>,
4904 #[serde(rename = "isDefault", default)]
4905 pub is_default: bool,
4906 #[serde(default)]
4907 pub model: String,
4908 #[serde(
4909 rename = "modelSpecialty",
4910 default,
4911 skip_serializing_if = "Option::is_none"
4912 )]
4913 pub model_specialty: Option<String>,
4914 #[serde(
4915 rename = "multiAgentVersion",
4916 default,
4917 skip_serializing_if = "Option::is_none"
4918 )]
4919 pub multi_agent_version: Option<MultiAgentVersion>,
4920 #[serde(
4921 rename = "serviceTiers",
4922 default,
4923 skip_serializing_if = "Option::is_none"
4924 )]
4925 pub service_tiers: Option<Vec<ModelServiceTier>>,
4926 #[serde(rename = "supportedReasoningEfforts", default)]
4927 pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
4928 #[serde(
4931 rename = "supportsPersonality",
4932 default,
4933 skip_serializing_if = "Option::is_none"
4934 )]
4935 pub supports_personality: Option<bool>,
4936 #[serde(default, skip_serializing_if = "Option::is_none")]
4937 pub upgrade: Option<String>,
4938 #[serde(
4939 rename = "upgradeInfo",
4940 default,
4941 skip_serializing_if = "Option::is_none"
4942 )]
4943 pub upgrade_info: Option<ModelUpgradeInfo>,
4944}
4945
4946#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4948#[serde(rename_all = "camelCase")]
4949pub struct ModelAccessPrograms {
4950 #[serde(default)]
4952 pub cyber: Vec<CyberAccessProgram>,
4953}
4954
4955#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4956#[serde(rename_all = "camelCase")]
4957pub struct ModelAvailabilityNux {
4958 #[serde(default)]
4959 pub message: String,
4960}
4961
4962#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4963#[serde(rename_all = "camelCase")]
4964pub struct ModelListParams {
4965 #[serde(default, skip_serializing_if = "Option::is_none")]
4966 pub cursor: Option<String>,
4967 #[serde(
4968 rename = "includeHidden",
4969 default,
4970 skip_serializing_if = "Option::is_none"
4971 )]
4972 pub include_hidden: Option<bool>,
4973 #[serde(default, skip_serializing_if = "Option::is_none")]
4974 pub limit: Option<i64>,
4975}
4976
4977#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4978#[serde(rename_all = "camelCase")]
4979pub struct ModelListResponse {
4980 #[serde(default)]
4981 pub data: Vec<Model>,
4982 #[serde(
4983 rename = "nextCursor",
4984 default,
4985 skip_serializing_if = "Option::is_none"
4986 )]
4987 pub next_cursor: Option<String>,
4988}
4989
4990#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4991#[serde(rename_all = "camelCase")]
4992pub struct ModelProviderCapabilitiesReadParams {
4993 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4994 pub extra: serde_json::Map<String, Value>,
4995}
4996
4997#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4998#[serde(rename_all = "camelCase")]
4999pub struct ModelProviderCapabilitiesReadResponse {
5000 #[serde(rename = "imageGeneration", default)]
5001 pub image_generation: bool,
5002 #[serde(rename = "webSearch", default)]
5003 pub web_search: bool,
5004}
5005
5006#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5008#[serde(rename_all = "camelCase")]
5009pub struct ModelProviderListParams {
5010 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5011 pub extra: serde_json::Map<String, Value>,
5012}
5013
5014#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5016#[serde(rename_all = "camelCase")]
5017pub struct ModelProviderListResponse {
5018 pub data: Vec<ModelProviderSummary>,
5019 #[serde(rename = "defaultProviderId")]
5020 pub default_provider_id: String,
5021 #[serde(rename = "canChangeDefault")]
5022 pub can_change_default: bool,
5023}
5024
5025#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5027#[serde(rename_all = "camelCase")]
5028pub struct ModelProviderSummary {
5029 pub id: String,
5030 pub name: String,
5031 #[serde(rename = "canEdit")]
5033 pub can_edit: bool,
5034 #[serde(rename = "baseUrl", default)]
5036 pub base_url: Option<String>,
5037 pub settings: ProviderSettings,
5038}
5039
5040#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5042#[serde(tag = "type", rename_all = "camelCase")]
5043pub enum ProviderSettings {
5044 #[serde(rename = "openai")]
5045 OpenAi,
5046 #[serde(rename = "customGateway")]
5047 CustomGateway { auth: GatewayAuth },
5048 #[serde(rename = "bedrock")]
5049 Bedrock {
5050 #[serde(default)]
5051 profile: Option<String>,
5052 #[serde(default)]
5053 region: Option<String>,
5054 },
5055 #[serde(rename = "gcp")]
5056 Gcp {
5057 #[serde(rename = "projectId", default)]
5058 project_id: Option<String>,
5059 #[serde(default)]
5060 location: Option<String>,
5061 #[serde(rename = "credentialFile", default)]
5063 credential_file: Option<String>,
5064 },
5065}
5066
5067#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5069#[serde(tag = "mode", rename_all = "camelCase")]
5070pub enum GatewayAuth {
5071 #[serde(rename = "none")]
5072 None,
5073 #[serde(rename = "environmentVariable")]
5074 EnvironmentVariable {
5075 #[serde(rename = "envKey")]
5076 env_key: String,
5077 },
5078 #[serde(rename = "externallyConfigured")]
5080 ExternallyConfigured {
5081 #[serde(rename = "envKey", default)]
5082 env_key: Option<String>,
5083 },
5084}
5085
5086#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5088#[serde(rename_all = "camelCase")]
5089pub struct ModelProviderConfigWriteParams {
5090 pub settings: ProviderSettingsPatch,
5091}
5092
5093#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5095#[serde(rename_all = "camelCase")]
5096pub struct ModelProviderConfigWriteResponse {
5097 pub provider: ModelProviderSummary,
5098}
5099
5100#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5105#[serde(tag = "type", rename_all = "camelCase")]
5106pub enum ProviderSettingsPatch {
5107 #[serde(rename = "customGateway")]
5108 CustomGateway {
5109 #[serde(
5111 rename = "providerId",
5112 default,
5113 skip_serializing_if = "Option::is_none"
5114 )]
5115 provider_id: Option<String>,
5116 #[serde(
5118 default,
5119 deserialize_with = "deserialize_patch_name",
5120 skip_serializing_if = "Option::is_none"
5121 )]
5122 name: Option<String>,
5123 #[serde(
5124 rename = "baseUrl",
5125 default,
5126 deserialize_with = "deserialize_patch_field",
5127 skip_serializing_if = "Option::is_none"
5128 )]
5129 base_url: Option<Option<String>>,
5130 #[serde(
5131 rename = "envKey",
5132 default,
5133 deserialize_with = "deserialize_patch_field",
5134 skip_serializing_if = "Option::is_none"
5135 )]
5136 env_key: Option<Option<String>>,
5137 },
5138 #[serde(rename = "bedrock")]
5140 Bedrock {
5141 #[serde(rename = "providerId")]
5142 provider_id: BedrockProviderId,
5143 #[serde(
5144 default,
5145 deserialize_with = "deserialize_patch_field",
5146 skip_serializing_if = "Option::is_none"
5147 )]
5148 profile: Option<Option<String>>,
5149 #[serde(
5150 default,
5151 deserialize_with = "deserialize_patch_field",
5152 skip_serializing_if = "Option::is_none"
5153 )]
5154 region: Option<Option<String>>,
5155 },
5156 #[serde(rename = "gcp")]
5158 Gcp {
5159 #[serde(rename = "providerId")]
5160 provider_id: GcpProviderId,
5161 #[serde(
5162 rename = "projectId",
5163 default,
5164 deserialize_with = "deserialize_patch_field",
5165 skip_serializing_if = "Option::is_none"
5166 )]
5167 project_id: Option<Option<String>>,
5168 #[serde(
5169 default,
5170 deserialize_with = "deserialize_patch_field",
5171 skip_serializing_if = "Option::is_none"
5172 )]
5173 location: Option<Option<String>>,
5174 #[serde(
5175 rename = "credentialFile",
5176 default,
5177 deserialize_with = "deserialize_patch_field",
5178 skip_serializing_if = "Option::is_none"
5179 )]
5180 credential_file: Option<Option<String>>,
5181 },
5182}
5183
5184fn deserialize_patch_field<'de, D>(deserializer: D) -> Result<Option<Option<String>>, D::Error>
5186where
5187 D: serde::Deserializer<'de>,
5188{
5189 Option::<String>::deserialize(deserializer).map(Some)
5190}
5191
5192fn deserialize_patch_name<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
5194where
5195 D: serde::Deserializer<'de>,
5196{
5197 String::deserialize(deserializer).map(Some)
5198}
5199
5200#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
5202pub enum BedrockProviderId {
5203 #[serde(rename = "amazon-bedrock")]
5204 AmazonBedrock,
5205 #[serde(rename = "amazon-bedrock-runtime")]
5206 AmazonBedrockRuntime,
5207}
5208
5209#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
5211pub enum GcpProviderId {
5212 #[serde(rename = "gcp")]
5213 Gcp,
5214}
5215
5216#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5221#[serde(tag = "type", rename_all = "camelCase")]
5222pub enum ModelProviderError {
5223 #[serde(rename = "modelProviderMismatch")]
5224 ModelProviderMismatch {
5225 #[serde(rename = "modelProvider")]
5226 model_provider: String,
5227 #[serde(rename = "currentModelProvider")]
5228 current_model_provider: String,
5229 },
5230 #[serde(rename = "modelProviderNotConfigured")]
5231 ModelProviderNotConfigured {
5232 #[serde(rename = "modelProvider")]
5233 model_provider: String,
5234 },
5235 #[serde(rename = "modelProviderPolicyConflict")]
5236 ModelProviderPolicyConflict {
5237 #[serde(rename = "modelProvider")]
5238 model_provider: String,
5239 #[serde(rename = "requiredModelProvider")]
5240 required_model_provider: String,
5241 },
5242}
5243
5244#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5245pub enum ModelRerouteReason {
5246 #[serde(rename = "highRiskCyberActivity")]
5247 HighRiskCyberActivity,
5248}
5249
5250#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5251#[serde(rename_all = "camelCase")]
5252pub struct ModelReroutedNotification {
5253 #[serde(rename = "fromModel", default)]
5254 pub from_model: String,
5255 #[serde()]
5256 pub reason: ModelRerouteReason,
5257 #[serde(rename = "threadId", default)]
5258 pub thread_id: String,
5259 #[serde(rename = "toModel", default)]
5260 pub to_model: String,
5261 #[serde(rename = "turnId", default)]
5262 pub turn_id: String,
5263}
5264
5265#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5266#[serde(rename_all = "camelCase")]
5267pub struct ModelSafetyBufferingUpdatedNotification {
5268 #[serde(
5269 rename = "fasterModel",
5270 default,
5271 skip_serializing_if = "Option::is_none"
5272 )]
5273 pub faster_model: Option<String>,
5274 #[serde(default)]
5275 pub model: String,
5276 #[serde(default)]
5277 pub reasons: Vec<String>,
5278 #[serde(rename = "showBufferingUi", default)]
5279 pub show_buffering_ui: bool,
5280 #[serde(rename = "threadId", default)]
5281 pub thread_id: String,
5282 #[serde(rename = "turnId", default)]
5283 pub turn_id: String,
5284 #[serde(rename = "useCases", default)]
5285 pub use_cases: Vec<String>,
5286}
5287
5288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5289#[serde(rename_all = "camelCase")]
5290pub struct ModelServiceTier {
5291 #[serde(default)]
5292 pub description: String,
5293 #[serde(default)]
5294 pub id: String,
5295 #[serde(default)]
5296 pub name: String,
5297}
5298
5299#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5300#[serde(rename_all = "camelCase")]
5301pub struct ModelUpgradeInfo {
5302 #[serde(
5303 rename = "migrationMarkdown",
5304 default,
5305 skip_serializing_if = "Option::is_none"
5306 )]
5307 pub migration_markdown: Option<String>,
5308 #[serde(default)]
5309 pub model: String,
5310 #[serde(
5313 rename = "retirementAt",
5314 default,
5315 skip_serializing_if = "Option::is_none"
5316 )]
5317 pub retirement_at: Option<i64>,
5318 #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
5319 pub model_link: Option<String>,
5320 #[serde(
5321 rename = "upgradeCopy",
5322 default,
5323 skip_serializing_if = "Option::is_none"
5324 )]
5325 pub upgrade_copy: Option<String>,
5326}
5327
5328#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5329pub enum ModelVerification {
5330 #[serde(rename = "trustedAccessForCyber")]
5331 TrustedAccessForCyber,
5332}
5333
5334#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5335#[serde(rename_all = "camelCase")]
5336pub struct ModelVerificationNotification {
5337 #[serde(rename = "threadId", default)]
5338 pub thread_id: String,
5339 #[serde(rename = "turnId", default)]
5340 pub turn_id: String,
5341 #[serde(default)]
5342 pub verifications: Vec<ModelVerification>,
5343}
5344
5345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5346#[serde(rename_all = "camelCase")]
5347pub struct ModelsRequirements {
5348 #[serde(rename = "newThread", default, skip_serializing_if = "Option::is_none")]
5349 pub new_thread: Option<NewThreadModelDefaults>,
5350}
5351
5352#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5353pub enum MultiAgentVersion {
5354 #[serde(rename = "disabled")]
5355 Disabled,
5356 #[serde(rename = "v1")]
5357 V1,
5358 #[serde(rename = "v2")]
5359 V2,
5360}
5361
5362#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5363pub enum NetworkAccess {
5364 #[serde(rename = "restricted")]
5365 Restricted,
5366 #[serde(rename = "enabled")]
5367 Enabled,
5368}
5369
5370#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5371#[serde(rename_all = "camelCase")]
5372pub struct NetworkApprovalContext {
5373 #[serde(default)]
5374 pub host: String,
5375 #[serde()]
5376 pub protocol: NetworkApprovalProtocol,
5377}
5378
5379#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5380pub enum NetworkApprovalProtocol {
5381 #[serde(rename = "http")]
5382 Http,
5383 #[serde(rename = "https")]
5384 Https,
5385 #[serde(rename = "socks5Tcp")]
5386 Socks5Tcp,
5387 #[serde(rename = "socks5Udp")]
5388 Socks5Udp,
5389}
5390
5391#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5392#[serde(rename_all = "camelCase")]
5393pub struct NetworkPolicyAmendment {
5394 #[serde()]
5395 pub action: NetworkPolicyRuleAction,
5396 #[serde(default)]
5397 pub host: String,
5398}
5399
5400#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5401pub enum NetworkPolicyRuleAction {
5402 #[serde(rename = "allow")]
5403 Allow,
5404 #[serde(rename = "deny")]
5405 Deny,
5406}
5407
5408#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5409#[serde(rename_all = "camelCase")]
5410pub struct NewThreadModelDefaults {
5411 #[serde(default, skip_serializing_if = "Option::is_none")]
5412 pub model: Option<String>,
5413 #[serde(
5414 rename = "modelReasoningEffort",
5415 default,
5416 skip_serializing_if = "Option::is_none"
5417 )]
5418 pub model_reasoning_effort: Option<ReasoningEffort>,
5419 #[serde(
5420 rename = "serviceTier",
5421 default,
5422 skip_serializing_if = "Option::is_none"
5423 )]
5424 pub service_tier: Option<String>,
5425}
5426
5427#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5428pub enum NonSteerableTurnKind {
5429 #[serde(rename = "review")]
5430 Review,
5431 #[serde(rename = "compact")]
5432 Compact,
5433}
5434
5435#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5437#[serde(rename_all = "kebab-case")]
5438pub enum OtelExporter {
5439 None,
5440 Statsig,
5441 OtlpHttp {
5442 endpoint: String,
5443 headers: std::collections::BTreeMap<String, String>,
5445 protocol: OtelHttpProtocol,
5446 #[serde(default, skip_serializing_if = "Option::is_none")]
5447 tls: Option<OtelTlsConfig>,
5448 },
5449 OtlpGrpc {
5450 endpoint: String,
5451 headers: std::collections::BTreeMap<String, String>,
5453 #[serde(default, skip_serializing_if = "Option::is_none")]
5454 tls: Option<OtelTlsConfig>,
5455 },
5456}
5457
5458#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5459#[serde(rename_all = "kebab-case")]
5460pub enum OtelHttpProtocol {
5461 Binary,
5462 Json,
5463}
5464
5465#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5468#[serde(rename_all = "snake_case")]
5469pub struct OtelRequirements {
5470 #[serde(default, skip_serializing_if = "Option::is_none")]
5471 pub tool_result: Option<OtelToolResultLogConfig>,
5472 #[serde(default, skip_serializing_if = "Option::is_none")]
5473 pub log_sse_deltas: Option<bool>,
5474 #[serde(default, skip_serializing_if = "Option::is_none")]
5475 pub log_user_prompt: Option<bool>,
5476 #[serde(default, skip_serializing_if = "Option::is_none")]
5477 pub log_agent_responses: Option<bool>,
5478 #[serde(default, skip_serializing_if = "Option::is_none")]
5479 pub log_guardian_assessments: Option<bool>,
5480 #[serde(default, skip_serializing_if = "Option::is_none")]
5481 pub environment: Option<String>,
5482 #[serde(default, skip_serializing_if = "Option::is_none")]
5483 pub exporter: Option<OtelExporter>,
5484 #[serde(default, skip_serializing_if = "Option::is_none")]
5485 pub trace_exporter: Option<OtelExporter>,
5486 #[serde(default, skip_serializing_if = "Option::is_none")]
5487 pub metrics_exporter: Option<OtelExporter>,
5488 #[serde(default, skip_serializing_if = "Option::is_none")]
5489 pub span_attributes: Option<std::collections::BTreeMap<String, String>>,
5490 #[serde(default, skip_serializing_if = "Option::is_none")]
5491 pub tracestate:
5492 Option<std::collections::BTreeMap<String, std::collections::BTreeMap<String, String>>>,
5493}
5494
5495#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
5496#[serde(rename_all = "kebab-case")]
5497pub struct OtelTlsConfig {
5498 #[serde(default, skip_serializing_if = "Option::is_none")]
5499 pub ca_certificate: Option<String>,
5500 #[serde(default, skip_serializing_if = "Option::is_none")]
5501 pub client_certificate: Option<String>,
5502 #[serde(default, skip_serializing_if = "Option::is_none")]
5503 pub client_private_key: Option<String>,
5504}
5505
5506#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
5507#[serde(rename_all = "snake_case")]
5508pub struct OtelToolResultLogConfig {
5509 pub max_bytes: u64,
5510}
5511
5512#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5513#[serde(rename_all = "camelCase")]
5514pub struct OverriddenMetadata {
5515 #[serde(rename = "effectiveValue", default)]
5516 pub effective_value: Value,
5517 #[serde(default)]
5518 pub message: String,
5519 #[serde(rename = "overridingLayer")]
5520 pub overriding_layer: ConfigLayerMetadata,
5521}
5522
5523#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5524#[serde(tag = "type", rename_all = "camelCase")]
5525pub enum ParsedCommand {
5526 Read {
5527 cmd: String,
5528 name: String,
5529 path: String,
5530 },
5531 List_files {
5532 cmd: String,
5533 #[serde(default, skip_serializing_if = "Option::is_none")]
5534 path: Option<String>,
5535 },
5536 Search {
5537 cmd: String,
5538 #[serde(default, skip_serializing_if = "Option::is_none")]
5539 path: Option<String>,
5540 #[serde(default, skip_serializing_if = "Option::is_none")]
5541 query: Option<String>,
5542 },
5543 Unknown {
5544 cmd: String,
5545 },
5546}
5547
5548#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5549pub enum PatchApplyStatus {
5550 #[serde(rename = "inProgress")]
5551 InProgress,
5552 #[serde(rename = "completed")]
5553 Completed,
5554 #[serde(rename = "failed")]
5555 Failed,
5556 #[serde(rename = "declined")]
5557 Declined,
5558}
5559
5560#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5561#[serde(tag = "type", rename_all = "camelCase")]
5562pub enum PatchChangeKind {
5563 Add,
5564 Delete,
5565 Update {
5566 #[serde(default, skip_serializing_if = "Option::is_none")]
5567 move_path: Option<String>,
5568 },
5569}
5570
5571#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5572pub enum PermissionGrantScope {
5573 #[serde(rename = "turn")]
5574 Turn,
5575 #[serde(rename = "session")]
5576 Session,
5577}
5578
5579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5580#[serde(rename_all = "camelCase")]
5581pub struct PermissionProfileListParams {
5582 #[serde(default, skip_serializing_if = "Option::is_none")]
5583 pub cursor: Option<String>,
5584 #[serde(default, skip_serializing_if = "Option::is_none")]
5585 pub cwd: Option<String>,
5586 #[serde(default, skip_serializing_if = "Option::is_none")]
5587 pub limit: Option<i64>,
5588}
5589
5590#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5591#[serde(rename_all = "camelCase")]
5592pub struct PermissionProfileListResponse {
5593 #[serde(default)]
5594 pub data: Vec<PermissionProfileSummary>,
5595 #[serde(
5596 rename = "nextCursor",
5597 default,
5598 skip_serializing_if = "Option::is_none"
5599 )]
5600 pub next_cursor: Option<String>,
5601}
5602
5603#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5604#[serde(rename_all = "camelCase")]
5605pub struct PermissionProfileSummary {
5606 #[serde(default)]
5607 pub allowed: bool,
5608 #[serde(default, skip_serializing_if = "Option::is_none")]
5609 pub description: Option<String>,
5610 #[serde(default)]
5611 pub id: String,
5612}
5613
5614#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5615#[serde(rename_all = "camelCase")]
5616pub struct PermissionsRequestApprovalParams {
5617 #[serde()]
5618 pub cwd: LegacyAppPathString,
5619 #[serde(
5620 rename = "environmentId",
5621 default,
5622 skip_serializing_if = "Option::is_none"
5623 )]
5624 pub environment_id: Option<String>,
5625 #[serde(rename = "itemId", default)]
5626 pub item_id: String,
5627 #[serde()]
5628 pub permissions: RequestPermissionProfile,
5629 #[serde(default, skip_serializing_if = "Option::is_none")]
5630 pub reason: Option<String>,
5631 #[serde(rename = "startedAtMs", default)]
5632 pub started_at_ms: i64,
5633 #[serde(rename = "threadId", default)]
5634 pub thread_id: String,
5635 #[serde(rename = "turnId", default)]
5636 pub turn_id: String,
5637}
5638
5639#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5640#[serde(rename_all = "camelCase")]
5641pub struct PermissionsRequestApprovalResponse {
5642 #[serde()]
5643 pub permissions: GrantedPermissionProfile,
5644 #[serde(default, skip_serializing_if = "Option::is_none")]
5645 pub scope: Option<Value>,
5646 #[serde(
5647 rename = "strictAutoReview",
5648 default,
5649 skip_serializing_if = "Option::is_none"
5650 )]
5651 pub strict_auto_review: Option<bool>,
5652}
5653
5654#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5659pub enum Personality {
5660 #[serde(rename = "none")]
5661 None,
5662 #[serde(rename = "friendly")]
5663 Friendly,
5664 #[serde(rename = "pragmatic")]
5665 Pragmatic,
5666}
5667
5668#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5669#[serde(rename_all = "camelCase")]
5670pub struct PlanDeltaNotification {
5671 #[serde(default)]
5672 pub delta: String,
5673 #[serde(rename = "itemId", default)]
5674 pub item_id: String,
5675 #[serde(rename = "threadId", default)]
5676 pub thread_id: String,
5677 #[serde(rename = "turnId", default)]
5678 pub turn_id: String,
5679}
5680
5681#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5682pub enum PlanType {
5683 #[serde(rename = "free")]
5684 Free,
5685 #[serde(rename = "go")]
5686 Go,
5687 #[serde(rename = "plus")]
5688 Plus,
5689 #[serde(rename = "pro")]
5690 Pro,
5691 #[serde(rename = "prolite")]
5692 Prolite,
5693 #[serde(rename = "promax")]
5694 Promax,
5695 #[serde(rename = "edu_plus")]
5696 Edu_plus,
5697 #[serde(rename = "edu_pro")]
5698 Edu_pro,
5699 #[serde(rename = "team")]
5700 Team,
5701 #[serde(rename = "self_serve_business_prolite")]
5702 Self_serve_business_prolite,
5703 #[serde(rename = "self_serve_business_usage_based")]
5704 Self_serve_business_usage_based,
5705 #[serde(rename = "business")]
5706 Business,
5707 #[serde(rename = "ent26")]
5708 Ent26,
5709 #[serde(rename = "enterprise_cbp_automation")]
5710 Enterprise_cbp_automation,
5711 #[serde(rename = "enterprise_cbp_usage_based")]
5712 Enterprise_cbp_usage_based,
5713 #[serde(rename = "enterprise")]
5714 Enterprise,
5715 #[serde(rename = "edu")]
5716 Edu,
5717 #[serde(rename = "sci")]
5718 Sci,
5719 #[serde(rename = "sci_plus")]
5720 Sci_plus,
5721 #[serde(rename = "unknown")]
5722 Unknown,
5723}
5724
5725#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5726pub enum PluginAuthPolicy {
5727 #[serde(rename = "ON_INSTALL")]
5728 ON_INSTALL,
5729 #[serde(rename = "ON_USE")]
5730 ON_USE,
5731}
5732
5733#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5734pub enum PluginAvailability {
5735 #[serde(rename = "DISABLED_BY_ADMIN")]
5736 DISABLEDBYADMIN,
5737 AVAILABLE,
5738}
5739
5740#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5741#[serde(rename_all = "camelCase")]
5742pub struct PluginDetail {
5743 #[serde(rename = "appTemplates", default)]
5744 pub app_templates: Vec<AppTemplateSummary>,
5745 #[serde(default)]
5746 pub apps: Vec<AppSummary>,
5747 #[serde(default, skip_serializing_if = "Option::is_none")]
5748 pub description: Option<String>,
5749 #[serde(default)]
5750 pub hooks: Vec<PluginHookSummary>,
5751 #[serde(rename = "marketplaceName", default)]
5752 pub marketplace_name: String,
5753 #[serde(
5754 rename = "marketplacePath",
5755 default,
5756 skip_serializing_if = "Option::is_none"
5757 )]
5758 pub marketplace_path: Option<AbsolutePathBuf>,
5759 #[serde(rename = "mcpServers", default)]
5760 pub mcp_servers: Vec<String>,
5761 #[serde(
5763 rename = "onboardingSkill",
5764 default,
5765 skip_serializing_if = "Option::is_none"
5766 )]
5767 pub onboarding_skill: Option<SkillSummary>,
5768 #[serde(
5769 rename = "scheduledTasks",
5770 default,
5771 skip_serializing_if = "Option::is_none"
5772 )]
5773 pub scheduled_tasks: Option<Vec<ScheduledTaskSummary>>,
5774 #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5775 pub share_url: Option<String>,
5776 #[serde(default)]
5777 pub skills: Vec<SkillSummary>,
5778 #[serde()]
5779 pub summary: PluginSummary,
5780}
5781
5782#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5783pub enum PluginDisabledReason {
5784 #[serde(rename = "disabled_by_admin")]
5785 Disabled_by_admin,
5786 #[serde(rename = "plan_not_eligible")]
5787 Plan_not_eligible,
5788 #[serde(rename = "required_app_unavailable")]
5789 Required_app_unavailable,
5790 #[serde(rename = "unknown")]
5791 Unknown,
5792}
5793
5794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5795#[serde(rename_all = "camelCase")]
5796pub struct PluginHookSummary {
5797 #[serde(rename = "eventName")]
5798 pub event_name: HookEventName,
5799 #[serde(default)]
5800 pub key: String,
5801}
5802
5803#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5804#[serde(rename_all = "camelCase")]
5805pub struct PluginInstallParams {
5806 #[serde(
5807 rename = "installAttemptId",
5808 default,
5809 skip_serializing_if = "Option::is_none"
5810 )]
5811 pub install_attempt_id: Option<String>,
5812 #[serde(
5813 rename = "marketplacePath",
5814 default,
5815 skip_serializing_if = "Option::is_none"
5816 )]
5817 pub marketplace_path: Option<AbsolutePathBuf>,
5818 #[serde(rename = "pluginName", default)]
5819 pub plugin_name: String,
5820 #[serde(
5821 rename = "remoteMarketplaceName",
5822 default,
5823 skip_serializing_if = "Option::is_none"
5824 )]
5825 pub remote_marketplace_name: Option<String>,
5826}
5827
5828#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5829pub enum PluginInstallPolicy {
5830 #[serde(rename = "NOT_AVAILABLE")]
5831 NOT_AVAILABLE,
5832 #[serde(rename = "AVAILABLE")]
5833 AVAILABLE,
5834 #[serde(rename = "INSTALLED_BY_DEFAULT")]
5835 INSTALLED_BY_DEFAULT,
5836}
5837
5838#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5839pub enum PluginInstallPolicySource {
5840 #[serde(rename = "WORKSPACE_SETTING")]
5841 WORKSPACE_SETTING,
5842 #[serde(rename = "IMPLICIT_CANONICAL_APP")]
5843 IMPLICIT_CANONICAL_APP,
5844}
5845
5846#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5847#[serde(rename_all = "camelCase")]
5848pub struct PluginInstallResponse {
5849 #[serde(rename = "appsNeedingAuth", default)]
5850 pub apps_needing_auth: Vec<AppSummary>,
5851 #[serde(rename = "authPolicy")]
5852 pub auth_policy: PluginAuthPolicy,
5853}
5854
5855#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5856#[serde(rename_all = "camelCase")]
5857pub struct PluginInstalledParams {
5858 #[serde(default, skip_serializing_if = "Option::is_none")]
5859 pub cwds: Option<Vec<AbsolutePathBuf>>,
5860 #[serde(
5861 rename = "installSuggestionPluginNames",
5862 default,
5863 skip_serializing_if = "Option::is_none"
5864 )]
5865 pub install_suggestion_plugin_names: Option<Vec<String>>,
5866}
5867
5868#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5869#[serde(rename_all = "camelCase")]
5870pub struct PluginInstalledResponse {
5871 #[serde(
5872 rename = "marketplaceLoadErrors",
5873 default,
5874 skip_serializing_if = "Option::is_none"
5875 )]
5876 pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5877 #[serde(default)]
5878 pub marketplaces: Vec<PluginMarketplaceEntry>,
5879}
5880
5881#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5882#[serde(rename_all = "camelCase")]
5883pub struct PluginInterface {
5884 #[serde(
5885 rename = "brandColor",
5886 default,
5887 skip_serializing_if = "Option::is_none"
5888 )]
5889 pub brand_color: Option<String>,
5890 #[serde(default)]
5891 pub capabilities: Vec<String>,
5892 #[serde(default, skip_serializing_if = "Option::is_none")]
5893 pub category: Option<String>,
5894 #[serde(
5895 rename = "composerIcon",
5896 default,
5897 skip_serializing_if = "Option::is_none"
5898 )]
5899 pub composer_icon: Option<AbsolutePathBuf>,
5900 #[serde(
5901 rename = "composerIconUrl",
5902 default,
5903 skip_serializing_if = "Option::is_none"
5904 )]
5905 pub composer_icon_url: Option<String>,
5906 #[serde(
5907 rename = "defaultPrompt",
5908 default,
5909 skip_serializing_if = "Option::is_none"
5910 )]
5911 pub default_prompt: Option<Vec<String>>,
5912 #[serde(
5913 rename = "developerName",
5914 default,
5915 skip_serializing_if = "Option::is_none"
5916 )]
5917 pub developer_name: Option<String>,
5918 #[serde(
5919 rename = "displayName",
5920 default,
5921 skip_serializing_if = "Option::is_none"
5922 )]
5923 pub display_name: Option<String>,
5924 #[serde(default, skip_serializing_if = "Option::is_none")]
5925 pub logo: Option<AbsolutePathBuf>,
5926 #[serde(rename = "logoDark", default, skip_serializing_if = "Option::is_none")]
5927 pub logo_dark: Option<AbsolutePathBuf>,
5928 #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
5929 pub logo_url: Option<String>,
5930 #[serde(
5931 rename = "logoUrlDark",
5932 default,
5933 skip_serializing_if = "Option::is_none"
5934 )]
5935 pub logo_url_dark: Option<String>,
5936 #[serde(
5937 rename = "longDescription",
5938 default,
5939 skip_serializing_if = "Option::is_none"
5940 )]
5941 pub long_description: Option<String>,
5942 #[serde(
5943 rename = "privacyPolicyUrl",
5944 default,
5945 skip_serializing_if = "Option::is_none"
5946 )]
5947 pub privacy_policy_url: Option<String>,
5948 #[serde(rename = "screenshotUrls", default)]
5949 pub screenshot_urls: Vec<String>,
5950 #[serde(default)]
5951 pub screenshots: Vec<AbsolutePathBuf>,
5952 #[serde(
5953 rename = "shortDescription",
5954 default,
5955 skip_serializing_if = "Option::is_none"
5956 )]
5957 pub short_description: Option<String>,
5958 #[serde(
5959 rename = "termsOfServiceUrl",
5960 default,
5961 skip_serializing_if = "Option::is_none"
5962 )]
5963 pub terms_of_service_url: Option<String>,
5964 #[serde(
5965 rename = "websiteUrl",
5966 default,
5967 skip_serializing_if = "Option::is_none"
5968 )]
5969 pub website_url: Option<String>,
5970}
5971
5972#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5973pub enum PluginListMarketplaceKind {
5974 #[serde(rename = "local")]
5975 Local,
5976 #[serde(rename = "vertical")]
5977 Vertical,
5978 #[serde(rename = "workspace-directory")]
5979 Workspace_directory,
5980 #[serde(rename = "shared-with-me")]
5981 Shared_with_me,
5982 #[serde(rename = "created-by-me-remote")]
5983 Created_by_me_remote,
5984}
5985
5986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5987#[serde(rename_all = "camelCase")]
5988pub struct PluginListParams {
5989 #[serde(default, skip_serializing_if = "Option::is_none")]
5990 pub cwds: Option<Vec<AbsolutePathBuf>>,
5991 #[serde(
5992 rename = "forceRefetch",
5993 default,
5994 skip_serializing_if = "Option::is_none"
5995 )]
5996 pub force_refetch: Option<bool>,
5997 #[serde(
5998 rename = "marketplaceKinds",
5999 default,
6000 skip_serializing_if = "Option::is_none"
6001 )]
6002 pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
6003}
6004
6005#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6006#[serde(rename_all = "camelCase")]
6007pub struct PluginListResponse {
6008 #[serde(
6009 rename = "featuredPluginIds",
6010 default,
6011 skip_serializing_if = "Option::is_none"
6012 )]
6013 pub featured_plugin_ids: Option<Vec<String>>,
6014 #[serde(
6015 rename = "marketplaceLoadErrors",
6016 default,
6017 skip_serializing_if = "Option::is_none"
6018 )]
6019 pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
6020 #[serde(default)]
6021 pub marketplaces: Vec<PluginMarketplaceEntry>,
6022}
6023
6024#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6025#[serde(rename_all = "camelCase")]
6026pub struct PluginMarketplaceEntry {
6027 #[serde(default, skip_serializing_if = "Option::is_none")]
6028 pub interface: Option<MarketplaceInterface>,
6029 #[serde(default)]
6030 pub name: String,
6031 #[serde(default, skip_serializing_if = "Option::is_none")]
6032 pub path: Option<AbsolutePathBuf>,
6033 #[serde(default)]
6034 pub plugins: Vec<PluginSummary>,
6035}
6036
6037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6038#[serde(rename_all = "camelCase")]
6039pub struct PluginReadParams {
6040 #[serde(
6041 rename = "marketplacePath",
6042 default,
6043 skip_serializing_if = "Option::is_none"
6044 )]
6045 pub marketplace_path: Option<AbsolutePathBuf>,
6046 #[serde(rename = "pluginName", default)]
6047 pub plugin_name: String,
6048 #[serde(
6049 rename = "remoteMarketplaceName",
6050 default,
6051 skip_serializing_if = "Option::is_none"
6052 )]
6053 pub remote_marketplace_name: Option<String>,
6054}
6055
6056#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6057#[serde(rename_all = "camelCase")]
6058pub struct PluginReadResponse {
6059 #[serde()]
6060 pub plugin: PluginDetail,
6061}
6062
6063#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6069#[serde(rename_all = "camelCase")]
6070pub struct PluginReconcileChangedPlugin {
6071 #[serde(rename = "hasApps", default)]
6072 pub has_apps: bool,
6073 #[serde(rename = "hasHooks", default)]
6074 pub has_hooks: bool,
6075 #[serde(rename = "hasMcps", default)]
6076 pub has_mcps: bool,
6077 #[serde(rename = "hasSkills", default)]
6080 pub has_skills: bool,
6081 #[serde(default)]
6083 pub id: String,
6084}
6085
6086#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6087#[serde(rename_all = "camelCase")]
6088pub struct PluginReconcileParams {
6089 #[serde(default, skip_serializing_if = "Option::is_none")]
6092 pub reason: Option<String>,
6093}
6094
6095#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6099#[serde(rename_all = "camelCase")]
6100pub struct PluginReconcileResponse {
6101 #[serde(rename = "changedPlugins", default)]
6106 pub changed_plugins: Vec<PluginReconcileChangedPlugin>,
6107 #[serde(rename = "failedMaterializationRemotePluginIds", default)]
6110 pub failed_materialization_remote_plugin_ids: Vec<String>,
6111 #[serde(rename = "failedRemotePluginIds", default)]
6113 pub failed_remote_plugin_ids: Vec<String>,
6114}
6115
6116#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6117#[serde(rename_all = "camelCase")]
6118pub struct PluginShareCheckoutParams {
6119 #[serde(rename = "remotePluginId", default)]
6120 pub remote_plugin_id: String,
6121}
6122
6123#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6124#[serde(rename_all = "camelCase")]
6125pub struct PluginShareCheckoutResponse {
6126 #[serde(rename = "marketplaceName", default)]
6127 pub marketplace_name: String,
6128 #[serde(rename = "marketplacePath")]
6129 pub marketplace_path: AbsolutePathBuf,
6130 #[serde(rename = "pluginId", default)]
6131 pub plugin_id: String,
6132 #[serde(rename = "pluginName", default)]
6133 pub plugin_name: String,
6134 #[serde(rename = "pluginPath")]
6135 pub plugin_path: AbsolutePathBuf,
6136 #[serde(rename = "remotePluginId", default)]
6137 pub remote_plugin_id: String,
6138 #[serde(
6139 rename = "remoteVersion",
6140 default,
6141 skip_serializing_if = "Option::is_none"
6142 )]
6143 pub remote_version: Option<String>,
6144}
6145
6146#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6147#[serde(rename_all = "camelCase")]
6148pub struct PluginShareContext {
6149 #[serde(
6150 rename = "canPublishToWorkspace",
6151 default,
6152 skip_serializing_if = "Option::is_none"
6153 )]
6154 pub can_publish_to_workspace: Option<bool>,
6155 #[serde(
6156 rename = "creatorAccountUserId",
6157 default,
6158 skip_serializing_if = "Option::is_none"
6159 )]
6160 pub creator_account_user_id: Option<String>,
6161 #[serde(
6162 rename = "creatorName",
6163 default,
6164 skip_serializing_if = "Option::is_none"
6165 )]
6166 pub creator_name: Option<String>,
6167 #[serde(default, skip_serializing_if = "Option::is_none")]
6168 pub discoverability: Option<PluginShareDiscoverability>,
6169 #[serde(rename = "remotePluginId", default)]
6170 pub remote_plugin_id: String,
6171 #[serde(
6172 rename = "remoteVersion",
6173 default,
6174 skip_serializing_if = "Option::is_none"
6175 )]
6176 pub remote_version: Option<String>,
6177 #[serde(
6178 rename = "sharePrincipals",
6179 default,
6180 skip_serializing_if = "Option::is_none"
6181 )]
6182 pub share_principals: Option<Vec<PluginSharePrincipal>>,
6183 #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
6184 pub share_url: Option<String>,
6185}
6186
6187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6188#[serde(rename_all = "camelCase")]
6189pub struct PluginShareDeleteParams {
6190 #[serde(rename = "remotePluginId", default)]
6191 pub remote_plugin_id: String,
6192}
6193
6194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6195#[serde(rename_all = "camelCase")]
6196pub struct PluginShareDeleteResponse {
6197 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6198 pub extra: serde_json::Map<String, Value>,
6199}
6200
6201#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6202pub enum PluginShareDiscoverability {
6203 #[serde(rename = "LISTED")]
6204 LISTED,
6205 #[serde(rename = "UNLISTED")]
6206 UNLISTED,
6207 #[serde(rename = "PRIVATE")]
6208 PRIVATE,
6209}
6210
6211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6212#[serde(rename_all = "camelCase")]
6213pub struct PluginShareListItem {
6214 #[serde(
6215 rename = "localPluginPath",
6216 default,
6217 skip_serializing_if = "Option::is_none"
6218 )]
6219 pub local_plugin_path: Option<AbsolutePathBuf>,
6220 #[serde()]
6221 pub plugin: PluginSummary,
6222}
6223
6224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6225#[serde(rename_all = "camelCase")]
6226pub struct PluginShareListParams {
6227 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6228 pub extra: serde_json::Map<String, Value>,
6229}
6230
6231#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6232#[serde(rename_all = "camelCase")]
6233pub struct PluginShareListResponse {
6234 #[serde(default)]
6235 pub data: Vec<PluginShareListItem>,
6236}
6237
6238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6239#[serde(rename_all = "camelCase")]
6240pub struct PluginSharePrincipal {
6241 #[serde(default)]
6242 pub name: String,
6243 #[serde(rename = "principalId", default)]
6244 pub principal_id: String,
6245 #[serde(rename = "principalType")]
6246 pub principal_type: PluginSharePrincipalType,
6247 #[serde()]
6248 pub role: PluginSharePrincipalRole,
6249}
6250
6251#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6252pub enum PluginSharePrincipalRole {
6253 #[serde(rename = "reader")]
6254 Reader,
6255 #[serde(rename = "editor")]
6256 Editor,
6257 #[serde(rename = "owner")]
6258 Owner,
6259}
6260
6261#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6262pub enum PluginSharePrincipalType {
6263 #[serde(rename = "user")]
6264 User,
6265 #[serde(rename = "group")]
6266 Group,
6267 #[serde(rename = "workspace")]
6268 Workspace,
6269}
6270
6271#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6272#[serde(rename_all = "camelCase")]
6273pub struct PluginShareSaveParams {
6274 #[serde(default, skip_serializing_if = "Option::is_none")]
6275 pub discoverability: Option<PluginShareDiscoverability>,
6276 #[serde(rename = "pluginPath")]
6277 pub plugin_path: AbsolutePathBuf,
6278 #[serde(
6279 rename = "remotePluginId",
6280 default,
6281 skip_serializing_if = "Option::is_none"
6282 )]
6283 pub remote_plugin_id: Option<String>,
6284 #[serde(
6285 rename = "shareTargets",
6286 default,
6287 skip_serializing_if = "Option::is_none"
6288 )]
6289 pub share_targets: Option<Vec<PluginShareTarget>>,
6290}
6291
6292#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6293#[serde(rename_all = "camelCase")]
6294pub struct PluginShareSaveResponse {
6295 #[serde(
6296 rename = "canPublishToWorkspace",
6297 default,
6298 skip_serializing_if = "Option::is_none"
6299 )]
6300 pub can_publish_to_workspace: Option<bool>,
6301 #[serde(rename = "remotePluginId", default)]
6302 pub remote_plugin_id: String,
6303 #[serde(rename = "shareUrl", default)]
6304 pub share_url: String,
6305}
6306
6307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6308#[serde(rename_all = "camelCase")]
6309pub struct PluginShareTarget {
6310 #[serde(rename = "principalId", default)]
6311 pub principal_id: String,
6312 #[serde(rename = "principalType")]
6313 pub principal_type: PluginSharePrincipalType,
6314 #[serde()]
6315 pub role: PluginShareTargetRole,
6316}
6317
6318#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6319pub enum PluginShareTargetRole {
6320 #[serde(rename = "reader")]
6321 Reader,
6322 #[serde(rename = "editor")]
6323 Editor,
6324}
6325
6326#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6327pub enum PluginShareUpdateDiscoverability {
6328 #[serde(rename = "UNLISTED")]
6329 UNLISTED,
6330 #[serde(rename = "PRIVATE")]
6331 PRIVATE,
6332 #[serde(rename = "LISTED")]
6333 LISTED,
6334}
6335
6336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6337#[serde(rename_all = "camelCase")]
6338pub struct PluginShareUpdateTargetsParams {
6339 #[serde()]
6340 pub discoverability: PluginShareUpdateDiscoverability,
6341 #[serde(rename = "remotePluginId", default)]
6342 pub remote_plugin_id: String,
6343 #[serde(rename = "shareTargets", default)]
6344 pub share_targets: Vec<PluginShareTarget>,
6345}
6346
6347#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6348#[serde(rename_all = "camelCase")]
6349pub struct PluginShareUpdateTargetsResponse {
6350 #[serde()]
6351 pub discoverability: PluginShareDiscoverability,
6352 #[serde(default)]
6353 pub principals: Vec<PluginSharePrincipal>,
6354}
6355
6356#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6357#[serde(rename_all = "camelCase")]
6358pub struct PluginSkillReadParams {
6359 #[serde(rename = "remoteMarketplaceName", default)]
6360 pub remote_marketplace_name: String,
6361 #[serde(rename = "remotePluginId", default)]
6362 pub remote_plugin_id: String,
6363 #[serde(rename = "skillName", default)]
6364 pub skill_name: String,
6365}
6366
6367#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6368#[serde(rename_all = "camelCase")]
6369pub struct PluginSkillReadResponse {
6370 #[serde(default, skip_serializing_if = "Option::is_none")]
6371 pub contents: Option<String>,
6372}
6373
6374#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6375#[serde(tag = "type", rename_all = "camelCase")]
6376pub enum PluginSource {
6377 Local {
6378 path: AbsolutePathBuf,
6379 },
6380 Git {
6381 #[serde(default, skip_serializing_if = "Option::is_none")]
6382 path: Option<String>,
6383 #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
6384 ref_name: Option<String>,
6385 #[serde(default, skip_serializing_if = "Option::is_none")]
6386 sha: Option<String>,
6387 url: String,
6388 },
6389 Npm {
6390 package: String,
6391 #[serde(default, skip_serializing_if = "Option::is_none")]
6392 registry: Option<String>,
6393 #[serde(default, skip_serializing_if = "Option::is_none")]
6394 version: Option<String>,
6395 },
6396 Remote,
6397}
6398
6399#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6400#[serde(rename_all = "camelCase")]
6401pub struct PluginSummary {
6402 #[serde(rename = "authPolicy")]
6403 pub auth_policy: PluginAuthPolicy,
6404 #[serde(default, skip_serializing_if = "Option::is_none")]
6405 pub availability: Option<Value>,
6406 #[serde(
6407 rename = "disabledReason",
6408 default,
6409 skip_serializing_if = "Option::is_none"
6410 )]
6411 pub disabled_reason: Option<PluginDisabledReason>,
6412 #[serde(
6413 rename = "eligiblePlanTypes",
6414 default,
6415 skip_serializing_if = "Option::is_none"
6416 )]
6417 pub eligible_plan_types: Option<Vec<String>>,
6418 #[serde(default)]
6419 pub enabled: bool,
6420 #[serde(default)]
6421 pub id: String,
6422 #[serde(rename = "installPolicy")]
6423 pub install_policy: PluginInstallPolicy,
6424 #[serde(
6425 rename = "installPolicySource",
6426 default,
6427 skip_serializing_if = "Option::is_none"
6428 )]
6429 pub install_policy_source: Option<PluginInstallPolicySource>,
6430 #[serde(default)]
6431 pub installed: bool,
6432 #[serde(
6433 rename = "installedAt",
6434 default,
6435 skip_serializing_if = "Option::is_none"
6436 )]
6437 pub installed_at: Option<i64>,
6438 #[serde(default, skip_serializing_if = "Option::is_none")]
6439 pub interface: Option<PluginInterface>,
6440 #[serde(default, skip_serializing_if = "Option::is_none")]
6441 pub keywords: Option<Vec<String>>,
6442 #[serde(
6443 rename = "localVersion",
6444 default,
6445 skip_serializing_if = "Option::is_none"
6446 )]
6447 pub local_version: Option<String>,
6448 #[serde(
6449 rename = "mustShowInstallationInterstitial",
6450 default,
6451 skip_serializing_if = "Option::is_none"
6452 )]
6453 pub must_show_installation_interstitial: Option<bool>,
6454 #[serde(default)]
6455 pub name: String,
6456 #[serde(
6457 rename = "remotePluginId",
6458 default,
6459 skip_serializing_if = "Option::is_none"
6460 )]
6461 pub remote_plugin_id: Option<String>,
6462 #[serde(
6463 rename = "shareContext",
6464 default,
6465 skip_serializing_if = "Option::is_none"
6466 )]
6467 pub share_context: Option<PluginShareContext>,
6468 #[serde()]
6469 pub source: PluginSource,
6470 #[serde(default, skip_serializing_if = "Option::is_none")]
6471 pub version: Option<String>,
6472}
6473
6474#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6475#[serde(rename_all = "camelCase")]
6476pub struct PluginUninstallParams {
6477 #[serde(rename = "pluginId", default)]
6478 pub plugin_id: String,
6479}
6480
6481#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6482#[serde(rename_all = "camelCase")]
6483pub struct PluginUninstallResponse {
6484 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6485 pub extra: serde_json::Map<String, Value>,
6486}
6487
6488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6489#[serde(rename_all = "camelCase")]
6490pub struct PluginsMigration {
6491 #[serde(rename = "marketplaceName", default)]
6492 pub marketplace_name: String,
6493 #[serde(rename = "pluginNames", default)]
6494 pub plugin_names: Vec<String>,
6495}
6496
6497#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6498#[serde(rename_all = "camelCase")]
6499pub struct ProcessExitedNotification {
6500 #[serde(rename = "exitCode", default)]
6501 pub exit_code: i64,
6502 #[serde(
6506 rename = "outputDrainTimedOut",
6507 default,
6508 skip_serializing_if = "Option::is_none"
6509 )]
6510 pub output_drain_timed_out: Option<bool>,
6511 #[serde(rename = "processHandle", default)]
6512 pub process_handle: String,
6513 #[serde(default)]
6514 pub stderr: String,
6515 #[serde(rename = "stderrCapReached", default)]
6516 pub stderr_cap_reached: bool,
6517 #[serde(default)]
6518 pub stdout: String,
6519 #[serde(rename = "stdoutCapReached", default)]
6520 pub stdout_cap_reached: bool,
6521}
6522
6523#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6524#[serde(rename_all = "camelCase")]
6525pub struct ProcessOutputDeltaNotification {
6526 #[serde(rename = "capReached", default)]
6527 pub cap_reached: bool,
6528 #[serde(rename = "deltaBase64", default)]
6529 pub delta_base64: String,
6530 #[serde(rename = "processHandle", default)]
6531 pub process_handle: String,
6532 #[serde(default)]
6533 pub stream: Value,
6534}
6535
6536#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6537pub enum ProcessOutputStream {
6538 #[serde(rename = "stdout")]
6539 Stdout,
6540 #[serde(rename = "stderr")]
6541 Stderr,
6542}
6543
6544#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6545pub enum RateLimitReachedType {
6546 #[serde(rename = "rate_limit_reached")]
6547 Rate_limit_reached,
6548 #[serde(rename = "workspace_owner_credits_depleted")]
6549 Workspace_owner_credits_depleted,
6550 #[serde(rename = "workspace_member_credits_depleted")]
6551 Workspace_member_credits_depleted,
6552 #[serde(rename = "workspace_owner_usage_limit_reached")]
6553 Workspace_owner_usage_limit_reached,
6554 #[serde(rename = "workspace_member_usage_limit_reached")]
6555 Workspace_member_usage_limit_reached,
6556}
6557
6558#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6559#[serde(rename_all = "camelCase")]
6560pub struct RateLimitResetCredit {
6561 #[serde(default, skip_serializing_if = "Option::is_none")]
6562 pub description: Option<String>,
6563 #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
6564 pub expires_at: Option<i64>,
6565 #[serde(rename = "grantedAt", default)]
6566 pub granted_at: i64,
6567 #[serde(default)]
6568 pub id: String,
6569 #[serde(rename = "resetType")]
6570 pub reset_type: RateLimitResetType,
6571 #[serde()]
6572 pub status: RateLimitResetCreditStatus,
6573 #[serde(default, skip_serializing_if = "Option::is_none")]
6574 pub title: Option<String>,
6575}
6576
6577#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6578pub enum RateLimitResetCreditStatus {
6579 #[serde(rename = "available")]
6580 Available,
6581 #[serde(rename = "redeeming")]
6582 Redeeming,
6583 #[serde(rename = "redeemed")]
6584 Redeemed,
6585 #[serde(rename = "unknown")]
6586 Unknown,
6587}
6588
6589#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6590#[serde(rename_all = "camelCase")]
6591pub struct RateLimitResetCreditsSummary {
6592 #[serde(rename = "availableCount", default)]
6593 pub available_count: i64,
6594 #[serde(default, skip_serializing_if = "Option::is_none")]
6595 pub credits: Option<Vec<RateLimitResetCredit>>,
6596}
6597
6598#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6599pub enum RateLimitResetType {
6600 #[serde(rename = "codexRateLimits")]
6601 CodexRateLimits,
6602 #[serde(rename = "unknown")]
6603 Unknown,
6604}
6605
6606#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6607#[serde(rename_all = "camelCase")]
6608pub struct RateLimitSnapshot {
6609 #[serde(default, skip_serializing_if = "Option::is_none")]
6610 pub credits: Option<CreditsSnapshot>,
6611 #[serde(
6612 rename = "individualLimit",
6613 default,
6614 skip_serializing_if = "Option::is_none"
6615 )]
6616 pub individual_limit: Option<SpendControlLimitSnapshot>,
6617 #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
6618 pub limit_id: Option<String>,
6619 #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
6620 pub limit_name: Option<String>,
6621 #[serde(
6624 rename = "normalModelSlug",
6625 default,
6626 skip_serializing_if = "Option::is_none"
6627 )]
6628 pub normal_model_slug: Option<String>,
6629 #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
6630 pub plan_type: Option<PlanType>,
6631 #[serde(default, skip_serializing_if = "Option::is_none")]
6632 pub primary: Option<RateLimitWindow>,
6633 #[serde(
6634 rename = "rateLimitReachedType",
6635 default,
6636 skip_serializing_if = "Option::is_none"
6637 )]
6638 pub rate_limit_reached_type: Option<RateLimitReachedType>,
6639 #[serde(default, skip_serializing_if = "Option::is_none")]
6640 pub secondary: Option<RateLimitWindow>,
6641 #[serde(
6642 rename = "spendControlReached",
6643 default,
6644 skip_serializing_if = "Option::is_none"
6645 )]
6646 pub spend_control_reached: Option<bool>,
6647}
6648
6649#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6650#[serde(rename_all = "camelCase")]
6651pub struct RateLimitWindow {
6652 #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
6653 pub resets_at: Option<i64>,
6654 #[serde(rename = "usedPercent", default)]
6655 pub used_percent: i64,
6656 #[serde(
6657 rename = "windowDurationMins",
6658 default,
6659 skip_serializing_if = "Option::is_none"
6660 )]
6661 pub window_duration_mins: Option<i64>,
6662}
6663
6664#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6665pub enum RealtimeConversationVersion {
6666 #[serde(rename = "v1")]
6667 V1,
6668 #[serde(rename = "v2")]
6669 V2,
6670 #[serde(rename = "v3")]
6671 V3,
6672}
6673
6674#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
6676#[serde(transparent)]
6677pub struct ReasoningEffort(pub String);
6678
6679#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6680#[serde(rename_all = "camelCase")]
6681pub struct ReasoningEffortOption {
6682 #[serde(default)]
6683 pub description: String,
6684 #[serde(rename = "reasoningEffort")]
6685 pub reasoning_effort: ReasoningEffort,
6686}
6687
6688#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6689pub enum ReasoningSummary {
6690 #[serde(rename = "auto")]
6691 Auto,
6692 #[serde(rename = "concise")]
6693 Concise,
6694 #[serde(rename = "detailed")]
6695 Detailed,
6696 #[serde(rename = "none")]
6697 None,
6698}
6699
6700#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6701#[serde(rename_all = "camelCase")]
6702pub struct ReasoningSummaryPartAddedNotification {
6703 #[serde(rename = "itemId", default)]
6704 pub item_id: String,
6705 #[serde(rename = "summaryIndex", default)]
6706 pub summary_index: i64,
6707 #[serde(rename = "threadId", default)]
6708 pub thread_id: String,
6709 #[serde(rename = "turnId", default)]
6710 pub turn_id: String,
6711}
6712
6713#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6714#[serde(rename_all = "camelCase")]
6715pub struct ReasoningSummaryTextDeltaNotification {
6716 #[serde(default)]
6717 pub delta: String,
6718 #[serde(rename = "itemId", default)]
6719 pub item_id: String,
6720 #[serde(rename = "summaryIndex", default)]
6721 pub summary_index: i64,
6722 #[serde(rename = "threadId", default)]
6723 pub thread_id: String,
6724 #[serde(rename = "turnId", default)]
6725 pub turn_id: String,
6726}
6727
6728#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6729#[serde(rename_all = "camelCase")]
6730pub struct ReasoningTextDeltaNotification {
6731 #[serde(rename = "contentIndex", default)]
6732 pub content_index: i64,
6733 #[serde(default)]
6734 pub delta: String,
6735 #[serde(rename = "itemId", default)]
6736 pub item_id: String,
6737 #[serde(rename = "threadId", default)]
6738 pub thread_id: String,
6739 #[serde(rename = "turnId", default)]
6740 pub turn_id: String,
6741}
6742
6743#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6744pub enum RemoteControlConnectionStatus {
6745 #[serde(rename = "disabled")]
6746 Disabled,
6747 #[serde(rename = "connecting")]
6748 Connecting,
6749 #[serde(rename = "connected")]
6750 Connected,
6751 #[serde(rename = "errored")]
6752 Errored,
6753}
6754
6755#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6756#[serde(rename_all = "camelCase")]
6757pub struct RemoteControlStatusChangedNotification {
6758 #[serde(
6759 rename = "environmentId",
6760 default,
6761 skip_serializing_if = "Option::is_none"
6762 )]
6763 pub environment_id: Option<String>,
6764 #[serde(rename = "installationId", default)]
6765 pub installation_id: String,
6766 #[serde(rename = "serverName", default)]
6767 pub server_name: String,
6768 #[serde()]
6769 pub status: RemoteControlConnectionStatus,
6770}
6771
6772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6773#[serde(untagged)]
6774pub enum RequestId {
6775 Variant0(String),
6776 Variant1(i64),
6777}
6778
6779#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6780#[serde(rename_all = "camelCase")]
6781pub struct RequestPermissionProfile {
6782 #[serde(
6783 rename = "fileSystem",
6784 default,
6785 skip_serializing_if = "Option::is_none"
6786 )]
6787 pub file_system: Option<AdditionalFileSystemPermissions>,
6788 #[serde(default, skip_serializing_if = "Option::is_none")]
6789 pub network: Option<AdditionalNetworkPermissions>,
6790}
6791
6792#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6793pub enum ResidencyRequirement {
6794 #[serde(rename = "us")]
6795 Us,
6796}
6797
6798#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6799#[serde(rename_all = "camelCase")]
6800pub struct Resource {
6801 #[serde(default, skip_serializing_if = "Option::is_none")]
6802 pub _meta: Option<Value>,
6803 #[serde(default, skip_serializing_if = "Option::is_none")]
6804 pub annotations: Option<Value>,
6805 #[serde(default, skip_serializing_if = "Option::is_none")]
6806 pub description: Option<String>,
6807 #[serde(default, skip_serializing_if = "Option::is_none")]
6808 pub icons: Option<Vec<Value>>,
6809 #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6810 pub mime_type: Option<String>,
6811 #[serde(default)]
6812 pub name: String,
6813 #[serde(default, skip_serializing_if = "Option::is_none")]
6814 pub size: Option<i64>,
6815 #[serde(default, skip_serializing_if = "Option::is_none")]
6816 pub title: Option<String>,
6817 #[serde(default)]
6818 pub uri: String,
6819}
6820
6821#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6822#[serde(untagged)]
6823pub enum ResourceContent {
6824 Variant0(Value),
6825 Variant1(Value),
6826}
6827
6828#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6829#[serde(rename_all = "camelCase")]
6830pub struct ResourceTemplate {
6831 #[serde(default, skip_serializing_if = "Option::is_none")]
6832 pub annotations: Option<Value>,
6833 #[serde(default, skip_serializing_if = "Option::is_none")]
6834 pub description: Option<String>,
6835 #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6836 pub mime_type: Option<String>,
6837 #[serde(default)]
6838 pub name: String,
6839 #[serde(default, skip_serializing_if = "Option::is_none")]
6840 pub title: Option<String>,
6841 #[serde(rename = "uriTemplate", default)]
6842 pub uri_template: String,
6843}
6844
6845#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6847#[serde(rename_all = "camelCase")]
6848pub struct ResponseUsageMetadata {
6849 #[serde(default, skip_serializing_if = "Option::is_none")]
6850 pub amount: Option<String>,
6851 #[serde(default, skip_serializing_if = "Option::is_none")]
6852 pub metadata: Option<Value>,
6853}
6854
6855#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6856pub enum ReviewDecision {
6857 #[serde(rename = "approved")]
6858 Approved,
6859 #[serde(rename = "approved_execpolicy_amendment")]
6860 ApprovedExecpolicyAmendment {
6861 proposed_execpolicy_amendment: Vec<String>,
6862 },
6863 #[serde(rename = "approved_for_session")]
6864 ApprovedForSession,
6865 #[serde(rename = "approved_mcp_policy_amendment")]
6866 ApprovedMcpPolicyAmendment,
6867 #[serde(rename = "network_policy_amendment")]
6868 NetworkPolicyAmendment {
6869 network_policy_amendment: NetworkPolicyAmendment,
6870 },
6871 #[serde(rename = "denied")]
6872 Denied { rejection: String },
6873 #[serde(rename = "timed_out")]
6874 TimedOut,
6875 #[serde(rename = "abort")]
6876 Abort,
6877}
6878
6879#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6880pub enum ReviewDelivery {
6881 #[serde(rename = "inline")]
6882 Inline,
6883}
6884
6885#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6886#[serde(rename_all = "camelCase")]
6887pub struct ReviewStartParams {
6888 #[serde(default, skip_serializing_if = "Option::is_none")]
6892 pub delivery: Option<ReviewDelivery>,
6893 #[serde()]
6894 pub target: ReviewTarget,
6895 #[serde(rename = "threadId", default)]
6896 pub thread_id: String,
6897}
6898
6899#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6900#[serde(rename_all = "camelCase")]
6901pub struct ReviewStartResponse {
6902 #[serde(rename = "reviewThreadId", default)]
6904 pub review_thread_id: String,
6905 #[serde()]
6906 pub turn: Turn,
6907}
6908
6909#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6910#[serde(tag = "type", rename_all = "camelCase")]
6911pub enum ReviewTarget {
6912 #[serde(rename = "uncommittedChanges")]
6913 UncommittedChanges,
6914 #[serde(rename = "baseBranch")]
6915 BaseBranch {
6916 branch: String,
6917 },
6918 Commit {
6919 sha: String,
6920 #[serde(default, skip_serializing_if = "Option::is_none")]
6921 title: Option<String>,
6922 },
6923 Custom {
6924 instructions: String,
6925 },
6926}
6927
6928#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6930pub enum AgentMessageDelivery {
6931 #[serde(rename = "async")]
6932 Async,
6933}
6934
6935#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6937pub enum CliAuthCredentialsStoreMode {
6938 #[serde(rename = "file")]
6939 File,
6940 #[serde(rename = "keyring")]
6941 Keyring,
6942 #[serde(rename = "auto")]
6943 Auto,
6944 #[serde(rename = "ephemeral")]
6945 Ephemeral,
6946}
6947
6948#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6950pub struct Project {
6951 #[serde(rename = "createdAt", default)]
6952 pub created_at: i64,
6953 #[serde(default)]
6954 pub id: String,
6955 #[serde(default)]
6956 pub metadata: std::collections::HashMap<String, String>,
6957 #[serde(default)]
6958 pub name: String,
6959 #[serde(default)]
6960 pub position: i64,
6961 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
6964 pub recency_at: Option<i64>,
6965 #[serde(default)]
6966 pub roots: Vec<ProjectRoot>,
6967 #[serde(rename = "updatedAt", default)]
6968 pub updated_at: i64,
6969}
6970
6971#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6973pub enum ProjectSortKey {
6974 #[serde(rename = "position")]
6975 Position,
6976 #[serde(rename = "recencyAt")]
6977 RecencyAt,
6978}
6979
6980#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6981pub enum ProjectChangeType {
6982 #[serde(rename = "created")]
6983 Created,
6984 #[serde(rename = "updated")]
6985 Updated,
6986 #[serde(rename = "deleted")]
6987 Deleted,
6988}
6989
6990#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6992pub struct ProjectChangedNotification {
6993 #[serde(rename = "changeType")]
6994 pub change_type: ProjectChangeType,
6995 #[serde(rename = "projectId", default)]
6996 pub project_id: String,
6997}
6998
6999#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7000pub struct ProjectRoot {
7001 pub path: AbsolutePathBuf,
7002}
7003
7004#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7006pub struct QueuedSubmission {
7007 #[serde(rename = "clientUserMessageId", default)]
7008 pub client_user_message_id: String,
7009 #[serde(default)]
7010 pub id: String,
7011 #[serde(default)]
7012 pub input: Vec<UserInput>,
7013}
7014
7015#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7017pub struct StrictReviewRequiredNotification {
7018 #[serde(rename = "startedAtMs", default)]
7020 pub started_at_ms: i64,
7021 #[serde(rename = "threadId", default)]
7022 pub thread_id: String,
7023 #[serde(rename = "turnId", default)]
7024 pub turn_id: String,
7025}
7026
7027#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7029pub struct ThreadProjectUpdatedNotification {
7030 #[serde(rename = "projectId", default)]
7031 pub project_id: Option<String>,
7032 #[serde(rename = "threadId", default)]
7033 pub thread_id: String,
7034}
7035
7036#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7038pub struct ThreadQueueChangedNotification {
7039 #[serde(rename = "threadId", default)]
7040 pub thread_id: String,
7041}
7042
7043#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7045pub struct ThreadRevertedNotification {
7046 #[serde(rename = "threadId", default)]
7047 pub thread_id: String,
7048}
7049
7050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7053#[serde(rename_all = "camelCase")]
7054pub struct ThreadPredictionUpdatedNotification {
7055 pub result: ThreadPredictionResult,
7056 #[serde(rename = "sourceTurnId", default)]
7057 pub source_turn_id: String,
7058 #[serde(rename = "threadId", default)]
7059 pub thread_id: String,
7060}
7061
7062#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7064#[serde(tag = "type", rename_all = "camelCase")]
7065pub enum ThreadPredictionResult {
7066 Completed {
7067 #[serde(default, skip_serializing_if = "Option::is_none")]
7068 text: Option<String>,
7069 },
7070 Failed,
7071}
7072
7073#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7075#[serde(rename_all = "camelCase")]
7076pub struct InAppBrowserRequirements {
7077 #[serde(
7078 rename = "allowExternalBrowserSettingsImport",
7079 default,
7080 skip_serializing_if = "Option::is_none"
7081 )]
7082 pub allow_external_browser_settings_import: Option<bool>,
7083}
7084
7085#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7087pub struct McpServerEventNotification {
7088 #[serde(default)]
7089 pub method: String,
7090 #[serde(default)]
7091 pub params: Value,
7092}
7093
7094#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7097pub struct McpServerEventStreamNotification {
7098 pub notification: McpServerEventNotification,
7099 #[serde(rename = "subscriptionId", default)]
7100 pub subscription_id: String,
7101}
7102
7103#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7106pub enum AllowDenyRequirement {
7107 #[serde(rename = "allow")]
7108 Allow,
7109 #[serde(rename = "deny")]
7110 Deny,
7111}
7112
7113#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7115pub enum BrowserUseAccessApprovalLifetime {
7116 #[serde(rename = "turn")]
7117 Turn,
7118 #[serde(rename = "thread")]
7119 Thread,
7120}
7121
7122#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7124pub enum McpServerConnectionStatus {
7125 #[serde(rename = "notStarted")]
7126 NotStarted,
7127 #[serde(rename = "starting")]
7128 Starting,
7129 #[serde(rename = "connected")]
7130 Connected,
7131 #[serde(rename = "authenticationRequired")]
7132 AuthenticationRequired,
7133 #[serde(rename = "failed")]
7134 Failed,
7135 #[serde(rename = "cancelled")]
7136 Cancelled,
7137 #[serde(rename = "disabled")]
7138 Disabled,
7139}
7140
7141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7143#[serde(rename_all = "camelCase")]
7144pub struct BrowserUseOriginPolicy {
7145 #[serde(default, skip_serializing_if = "Option::is_none")]
7146 pub access: Option<AllowDenyRequirement>,
7147 #[serde(
7148 rename = "accessApprovalLifetime",
7149 default,
7150 skip_serializing_if = "Option::is_none"
7151 )]
7152 pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
7153 #[serde(
7154 rename = "autoReview",
7155 default,
7156 skip_serializing_if = "Option::is_none"
7157 )]
7158 pub auto_review: Option<AllowDenyRequirement>,
7159 #[serde(default, skip_serializing_if = "Option::is_none")]
7160 pub downloads: Option<AllowDenyRequirement>,
7161 #[serde(
7162 rename = "fullCdpAccess",
7163 default,
7164 skip_serializing_if = "Option::is_none"
7165 )]
7166 pub full_cdp_access: Option<AllowDenyRequirement>,
7167 #[serde(
7168 rename = "persistentApproval",
7169 default,
7170 skip_serializing_if = "Option::is_none"
7171 )]
7172 pub persistent_approval: Option<bool>,
7173 #[serde(default, skip_serializing_if = "Option::is_none")]
7174 pub uploads: Option<AllowDenyRequirement>,
7175}
7176
7177#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7179pub struct BrowserUseOriginPolicyConfig {
7180 #[serde(default, skip_serializing_if = "Option::is_none")]
7181 pub access: Option<AllowDenyRequirement>,
7182 #[serde(default, skip_serializing_if = "Option::is_none")]
7183 pub downloads: Option<AllowDenyRequirement>,
7184 #[serde(default, skip_serializing_if = "Option::is_none")]
7185 pub full_cdp_access: Option<AllowDenyRequirement>,
7186 #[serde(default, skip_serializing_if = "Option::is_none")]
7187 pub uploads: Option<AllowDenyRequirement>,
7188}
7189
7190#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7192pub struct BrowserUseConfig {
7193 #[serde(default, skip_serializing_if = "Option::is_none")]
7194 pub allow_history_access: Option<bool>,
7195 #[serde(default, skip_serializing_if = "Option::is_none")]
7196 pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
7197 #[serde(default, skip_serializing_if = "Option::is_none")]
7198 pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
7199}
7200
7201#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7203pub struct ComputerUseConfig {
7204 #[serde(default, skip_serializing_if = "Option::is_none")]
7205 pub default_app_access: Option<AllowDenyRequirement>,
7206 #[serde(default, skip_serializing_if = "Option::is_none")]
7207 pub macos: Option<ComputerUseMacosConfig>,
7208 #[serde(default, skip_serializing_if = "Option::is_none")]
7209 pub windows: Option<ComputerUseWindowsConfig>,
7210}
7211
7212#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7213pub struct ComputerUseMacosConfig {
7214 #[serde(default, skip_serializing_if = "Option::is_none")]
7215 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7216}
7217
7218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7219pub struct ComputerUseWindowsConfig {
7220 #[serde(default, skip_serializing_if = "Option::is_none")]
7221 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7222 #[serde(default, skip_serializing_if = "Option::is_none")]
7223 pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
7224}
7225
7226#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7227pub struct ComputerUseWindowsExeConfig {
7228 pub access: AllowDenyRequirement,
7229 #[serde(default, skip_serializing_if = "Option::is_none")]
7230 pub binary_name: Option<String>,
7231 #[serde(default)]
7232 pub product_name: String,
7233 #[serde(default)]
7234 pub publisher_name: String,
7235}
7236
7237#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7239#[serde(rename_all = "camelCase")]
7240pub struct ComputerUseMacosRequirements {
7241 #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
7242 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7243}
7244
7245#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7246#[serde(rename_all = "camelCase")]
7247pub struct ComputerUseWindowsRequirements {
7248 #[serde(default, skip_serializing_if = "Option::is_none")]
7249 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7250 #[serde(default, skip_serializing_if = "Option::is_none")]
7251 pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
7252}
7253
7254#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7255#[serde(rename_all = "camelCase")]
7256pub struct ComputerUseWindowsExeRequirement {
7257 pub access: AllowDenyRequirement,
7258 #[serde(
7259 rename = "binaryName",
7260 default,
7261 skip_serializing_if = "Option::is_none"
7262 )]
7263 pub binary_name: Option<String>,
7264 #[serde(rename = "productName", default)]
7265 pub product_name: String,
7266 #[serde(rename = "publisherName", default)]
7267 pub publisher_name: String,
7268}
7269
7270#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7271pub enum SandboxMode {
7272 #[serde(rename = "read-only")]
7273 Read_only,
7274 #[serde(rename = "workspace-write")]
7275 Workspace_write,
7276 #[serde(rename = "danger-full-access")]
7277 Danger_full_access,
7278}
7279
7280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7281#[serde(tag = "type", rename_all = "camelCase")]
7282pub enum SandboxPolicy {
7283 #[serde(rename = "dangerFullAccess")]
7284 DangerFullAccess,
7285 #[serde(rename = "readOnly")]
7286 ReadOnly {
7287 #[serde(
7288 rename = "networkAccess",
7289 default,
7290 skip_serializing_if = "Option::is_none"
7291 )]
7292 network_access: Option<bool>,
7293 },
7294 #[serde(rename = "externalSandbox")]
7295 ExternalSandbox {
7296 #[serde(
7297 rename = "networkAccess",
7298 default,
7299 skip_serializing_if = "Option::is_none"
7300 )]
7301 network_access: Option<Value>,
7302 },
7303 #[serde(rename = "workspaceWrite")]
7304 WorkspaceWrite {
7305 #[serde(
7306 rename = "excludeSlashTmp",
7307 default,
7308 skip_serializing_if = "Option::is_none"
7309 )]
7310 exclude_slash_tmp: Option<bool>,
7311 #[serde(
7312 rename = "excludeTmpdirEnvVar",
7313 default,
7314 skip_serializing_if = "Option::is_none"
7315 )]
7316 exclude_tmpdir_env_var: Option<bool>,
7317 #[serde(
7318 rename = "networkAccess",
7319 default,
7320 skip_serializing_if = "Option::is_none"
7321 )]
7322 network_access: Option<bool>,
7323 #[serde(
7324 rename = "writableRoots",
7325 default,
7326 skip_serializing_if = "Option::is_none"
7327 )]
7328 writable_roots: Option<Vec<AbsolutePathBuf>>,
7329 },
7330}
7331
7332#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7333#[serde(rename_all = "snake_case")]
7334pub struct SandboxWorkspaceWrite {
7335 #[serde(default, skip_serializing_if = "Option::is_none")]
7336 pub exclude_slash_tmp: Option<bool>,
7337 #[serde(default, skip_serializing_if = "Option::is_none")]
7338 pub exclude_tmpdir_env_var: Option<bool>,
7339 #[serde(default, skip_serializing_if = "Option::is_none")]
7340 pub network_access: Option<bool>,
7341 #[serde(default, skip_serializing_if = "Option::is_none")]
7342 pub writable_roots: Option<Vec<String>>,
7343}
7344
7345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7346#[serde(tag = "type", rename_all = "camelCase")]
7347pub enum ScheduledTaskSchedule {
7348 Hourly {
7349 #[serde(default, skip_serializing_if = "Option::is_none")]
7350 days: Option<Vec<ScheduledTaskWeekday>>,
7351 #[serde(rename = "intervalHours")]
7352 interval_hours: i64,
7353 },
7354 Daily {
7355 time: String,
7356 },
7357 Weekdays {
7358 time: String,
7359 },
7360 Weekly {
7361 days: Vec<ScheduledTaskWeekday>,
7362 time: String,
7363 },
7364}
7365
7366#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7367#[serde(rename_all = "camelCase")]
7368pub struct ScheduledTaskSummary {
7369 #[serde(default)]
7370 pub key: String,
7371 #[serde(default)]
7372 pub name: String,
7373 #[serde(default)]
7374 pub prompt: String,
7375 #[serde()]
7376 pub schedule: ScheduledTaskSchedule,
7377}
7378
7379#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7380pub enum ScheduledTaskWeekday {
7381 #[serde(rename = "MO")]
7382 MO,
7383 #[serde(rename = "TU")]
7384 TU,
7385 #[serde(rename = "WE")]
7386 WE,
7387 #[serde(rename = "TH")]
7388 TH,
7389 #[serde(rename = "FR")]
7390 FR,
7391 #[serde(rename = "SA")]
7392 SA,
7393 #[serde(rename = "SU")]
7394 SU,
7395}
7396
7397#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7398#[serde(rename_all = "camelCase")]
7399pub struct SendAddCreditsNudgeEmailParams {
7400 #[serde(rename = "creditType")]
7401 pub credit_type: AddCreditsNudgeCreditType,
7402}
7403
7404#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7405#[serde(rename_all = "camelCase")]
7406pub struct SendAddCreditsNudgeEmailResponse {
7407 #[serde()]
7408 pub status: AddCreditsNudgeEmailStatus,
7409}
7410
7411#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7412#[serde(rename_all = "camelCase")]
7413pub struct ServerRequestResolvedNotification {
7414 #[serde(rename = "requestId")]
7415 pub request_id: RequestId,
7416 #[serde(rename = "threadId", default)]
7417 pub thread_id: String,
7418}
7419
7420#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7421#[serde(rename_all = "camelCase")]
7422pub struct SessionMigration {
7423 #[serde(default)]
7424 pub cwd: String,
7425 #[serde(default)]
7426 pub path: String,
7427 #[serde(default, skip_serializing_if = "Option::is_none")]
7428 pub title: Option<String>,
7429}
7430
7431#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7432pub enum SessionSource {
7433 #[serde(rename = "cli")]
7434 Cli,
7435 #[serde(rename = "vscode")]
7436 Vscode,
7437 #[serde(rename = "exec")]
7438 Exec,
7439 #[serde(rename = "appServer")]
7440 AppServer,
7441 #[serde(rename = "unknown")]
7442 Unknown,
7443 #[serde(rename = "custom")]
7444 Custom(String),
7445 #[serde(rename = "subAgent")]
7446 SubAgent(SubAgentSource),
7447}
7448
7449#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7450#[serde(rename_all = "camelCase")]
7451pub struct Settings {
7452 #[serde(default, skip_serializing_if = "Option::is_none")]
7453 pub developer_instructions: Option<String>,
7454 #[serde(default)]
7455 pub model: String,
7456 #[serde(default, skip_serializing_if = "Option::is_none")]
7457 pub reasoning_effort: Option<ReasoningEffort>,
7458}
7459
7460#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7461#[serde(rename_all = "camelCase")]
7462pub struct SkillDependencies {
7463 #[serde(default)]
7464 pub tools: Vec<SkillToolDependency>,
7465}
7466
7467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7468#[serde(rename_all = "camelCase")]
7469pub struct SkillErrorInfo {
7470 #[serde(default)]
7471 pub message: String,
7472 #[serde(default)]
7473 pub path: String,
7474}
7475
7476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7477#[serde(rename_all = "camelCase")]
7478pub struct SkillInterface {
7479 #[serde(
7480 rename = "brandColor",
7481 default,
7482 skip_serializing_if = "Option::is_none"
7483 )]
7484 pub brand_color: Option<String>,
7485 #[serde(
7486 rename = "defaultPrompt",
7487 default,
7488 skip_serializing_if = "Option::is_none"
7489 )]
7490 pub default_prompt: Option<String>,
7491 #[serde(
7492 rename = "displayName",
7493 default,
7494 skip_serializing_if = "Option::is_none"
7495 )]
7496 pub display_name: Option<String>,
7497 #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
7498 pub icon_large: Option<AbsolutePathBuf>,
7499 #[serde(
7500 rename = "iconLargeUrl",
7501 default,
7502 skip_serializing_if = "Option::is_none"
7503 )]
7504 pub icon_large_url: Option<String>,
7505 #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
7506 pub icon_small: Option<AbsolutePathBuf>,
7507 #[serde(
7508 rename = "iconSmallUrl",
7509 default,
7510 skip_serializing_if = "Option::is_none"
7511 )]
7512 pub icon_small_url: Option<String>,
7513 #[serde(
7514 rename = "shortDescription",
7515 default,
7516 skip_serializing_if = "Option::is_none"
7517 )]
7518 pub short_description: Option<String>,
7519}
7520
7521#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7522#[serde(rename_all = "camelCase")]
7523pub struct SkillMetadata {
7524 #[serde(default, skip_serializing_if = "Option::is_none")]
7525 pub dependencies: Option<SkillDependencies>,
7526 #[serde(default)]
7527 pub description: String,
7528 #[serde(default)]
7529 pub enabled: bool,
7530 #[serde(default, skip_serializing_if = "Option::is_none")]
7531 pub interface: Option<SkillInterface>,
7532 #[serde(default)]
7533 pub name: String,
7534 #[serde()]
7535 pub path: LegacyAppPathString,
7536 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7537 pub plugin_id: Option<String>,
7538 #[serde()]
7539 pub scope: SkillScope,
7540 #[serde(
7541 rename = "shortDescription",
7542 default,
7543 skip_serializing_if = "Option::is_none"
7544 )]
7545 pub short_description: Option<String>,
7546}
7547
7548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7549#[serde(rename_all = "camelCase")]
7550pub struct SkillMigration {
7551 #[serde(default)]
7552 pub name: String,
7553}
7554
7555#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7556pub enum SkillScope {
7557 #[serde(rename = "user")]
7558 User,
7559 #[serde(rename = "repo")]
7560 Repo,
7561 #[serde(rename = "system")]
7562 System,
7563 #[serde(rename = "admin")]
7564 Admin,
7565}
7566
7567#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7568#[serde(rename_all = "camelCase")]
7569pub struct SkillSummary {
7570 #[serde(default)]
7571 pub description: String,
7572 #[serde(default)]
7573 pub enabled: bool,
7574 #[serde(default, skip_serializing_if = "Option::is_none")]
7575 pub interface: Option<SkillInterface>,
7576 #[serde(default)]
7577 pub name: String,
7578 #[serde(default, skip_serializing_if = "Option::is_none")]
7579 pub path: Option<LegacyAppPathString>,
7580 #[serde(
7581 rename = "shortDescription",
7582 default,
7583 skip_serializing_if = "Option::is_none"
7584 )]
7585 pub short_description: Option<String>,
7586}
7587
7588#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7589#[serde(rename_all = "camelCase")]
7590pub struct SkillToolDependency {
7591 #[serde(default, skip_serializing_if = "Option::is_none")]
7592 pub command: Option<String>,
7593 #[serde(default, skip_serializing_if = "Option::is_none")]
7594 pub description: Option<String>,
7595 #[serde(default, skip_serializing_if = "Option::is_none")]
7596 pub transport: Option<String>,
7597 #[serde(rename = "type", default)]
7598 pub type_: String,
7599 #[serde(default, skip_serializing_if = "Option::is_none")]
7600 pub url: Option<String>,
7601 #[serde(default)]
7602 pub value: String,
7603}
7604
7605#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7606#[serde(rename_all = "camelCase")]
7607pub struct SkillsChangedNotification {
7608 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7609 pub extra: serde_json::Map<String, Value>,
7610}
7611
7612#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7613#[serde(rename_all = "camelCase")]
7614pub struct SkillsConfigWriteParams {
7615 #[serde(default)]
7616 pub enabled: bool,
7617 #[serde(default, skip_serializing_if = "Option::is_none")]
7618 pub name: Option<String>,
7619 #[serde(default, skip_serializing_if = "Option::is_none")]
7620 pub path: Option<AbsolutePathBuf>,
7621}
7622
7623#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7624#[serde(rename_all = "camelCase")]
7625pub struct SkillsConfigWriteResponse {
7626 #[serde(rename = "effectiveEnabled", default)]
7627 pub effective_enabled: bool,
7628}
7629
7630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7631#[serde(rename_all = "camelCase")]
7632pub struct SkillsExtraRootsSetParams {
7633 #[serde(rename = "extraRoots", default)]
7634 pub extra_roots: Vec<AbsolutePathBuf>,
7635}
7636
7637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7638#[serde(rename_all = "camelCase")]
7639pub struct SkillsExtraRootsSetResponse {
7640 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7641 pub extra: serde_json::Map<String, Value>,
7642}
7643
7644#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7645#[serde(rename_all = "camelCase")]
7646pub struct SkillsListEntry {
7647 #[serde(default)]
7648 pub cwd: String,
7649 #[serde(default)]
7650 pub errors: Vec<SkillErrorInfo>,
7651 #[serde(default)]
7652 pub skills: Vec<SkillMetadata>,
7653}
7654
7655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7656#[serde(rename_all = "camelCase")]
7657pub struct SkillsListParams {
7658 #[serde(default, skip_serializing_if = "Option::is_none")]
7659 pub cwds: Option<Vec<String>>,
7660 #[serde(
7661 rename = "forceReload",
7662 default,
7663 skip_serializing_if = "Option::is_none"
7664 )]
7665 pub force_reload: Option<bool>,
7666}
7667
7668#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7669#[serde(rename_all = "camelCase")]
7670pub struct SkillsListResponse {
7671 #[serde(default)]
7672 pub data: Vec<SkillsListEntry>,
7673}
7674
7675#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7676pub enum SortDirection {
7677 #[serde(rename = "asc")]
7678 Asc,
7679 #[serde(rename = "desc")]
7680 Desc,
7681}
7682
7683#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7684#[serde(rename_all = "camelCase")]
7685pub struct SpendControlLimitSnapshot {
7686 #[serde(default)]
7687 pub limit: String,
7688 #[serde(rename = "remainingPercent", default)]
7689 pub remaining_percent: i64,
7690 #[serde(rename = "resetsAt", default)]
7691 pub resets_at: i64,
7692 #[serde(default)]
7693 pub used: String,
7694}
7695
7696#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7697pub enum SubAgentActivityKind {
7698 #[serde(rename = "started")]
7699 Started,
7700 #[serde(rename = "interacted")]
7701 Interacted,
7702 #[serde(rename = "interrupted")]
7703 Interrupted,
7704 #[serde(rename = "completed")]
7705 Completed,
7706}
7707
7708#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7709pub enum SubAgentSource {
7710 #[serde(rename = "review")]
7711 Review,
7712 #[serde(rename = "compact")]
7713 Compact,
7714 #[serde(rename = "memory_consolidation")]
7715 MemoryConsolidation,
7716 #[serde(rename = "thread_spawn")]
7717 ThreadSpawn {
7718 #[serde(default, skip_serializing_if = "Option::is_none")]
7719 agent_nickname: Option<String>,
7720 #[serde(default, skip_serializing_if = "Option::is_none")]
7721 agent_path: Option<AgentPath>,
7722 #[serde(default, skip_serializing_if = "Option::is_none")]
7723 agent_role: Option<String>,
7724 depth: i64,
7725 parent_thread_id: ThreadId,
7726 },
7727 #[serde(rename = "other")]
7728 Other(String),
7729}
7730
7731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7732#[serde(rename_all = "camelCase")]
7733pub struct SubagentMigration {
7734 #[serde(default)]
7735 pub name: String,
7736}
7737
7738#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7739#[serde(rename_all = "camelCase")]
7740pub struct TerminalInteractionNotification {
7741 #[serde(rename = "itemId", default)]
7742 pub item_id: String,
7743 #[serde(rename = "processId", default)]
7744 pub process_id: String,
7745 #[serde(default)]
7746 pub stdin: String,
7747 #[serde(rename = "threadId", default)]
7748 pub thread_id: String,
7749 #[serde(rename = "turnId", default)]
7750 pub turn_id: String,
7751}
7752
7753#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7754#[serde(rename_all = "camelCase")]
7755pub struct TextElement {
7756 #[serde(rename = "byteRange", default)]
7757 pub byte_range: Value,
7758 #[serde(default, skip_serializing_if = "Option::is_none")]
7759 pub placeholder: Option<String>,
7760}
7761
7762#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7763#[serde(rename_all = "camelCase")]
7764pub struct TextPosition {
7765 #[serde(default)]
7766 pub column: i64,
7767 #[serde(default)]
7768 pub line: i64,
7769}
7770
7771#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7772#[serde(rename_all = "camelCase")]
7773pub struct TextRange {
7774 #[serde()]
7775 pub end: TextPosition,
7776 #[serde()]
7777 pub start: TextPosition,
7778}
7779
7780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7781#[serde(rename_all = "camelCase")]
7782pub struct Thread {
7783 #[serde(
7784 rename = "agentNickname",
7785 default,
7786 skip_serializing_if = "Option::is_none"
7787 )]
7788 pub agent_nickname: Option<String>,
7789 #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
7790 pub agent_role: Option<String>,
7791 #[serde(rename = "cliVersion", default)]
7792 pub cli_version: String,
7793 #[serde(rename = "createdAt", default)]
7794 pub created_at: i64,
7795 #[serde(default)]
7796 pub cwd: Value,
7797 #[serde(default)]
7798 pub ephemeral: bool,
7799 #[serde(
7800 rename = "forkedFromId",
7801 default,
7802 skip_serializing_if = "Option::is_none"
7803 )]
7804 pub forked_from_id: Option<String>,
7805 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
7806 pub git_info: Option<GitInfo>,
7807 #[serde(
7810 rename = "historyMode",
7811 default,
7812 skip_serializing_if = "Option::is_none"
7813 )]
7814 pub history_mode: Option<ThreadHistoryMode>,
7815 #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
7818 pub project_id: Option<String>,
7819 #[serde(default)]
7820 pub id: String,
7821 #[serde(default, skip_serializing_if = "Option::is_none")]
7824 pub model: Option<String>,
7825 #[serde(rename = "modelProvider", default)]
7826 pub model_provider: String,
7827 #[serde(default, skip_serializing_if = "Option::is_none")]
7828 pub name: Option<String>,
7829 #[serde(default, skip_serializing_if = "Option::is_none")]
7833 pub originator: Option<String>,
7834 #[serde(
7835 rename = "parentThreadId",
7836 default,
7837 skip_serializing_if = "Option::is_none"
7838 )]
7839 pub parent_thread_id: Option<String>,
7840 #[serde(default, skip_serializing_if = "Option::is_none")]
7841 pub path: Option<String>,
7842 #[serde(default)]
7843 pub preview: String,
7844 #[serde(
7848 rename = "reasoningEffort",
7849 default,
7850 skip_serializing_if = "Option::is_none"
7851 )]
7852 pub reasoning_effort: Option<ReasoningEffort>,
7853 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7854 pub recency_at: Option<i64>,
7855 #[serde(default, skip_serializing_if = "Option::is_none")]
7856 pub section: Option<ThreadSection>,
7857 #[serde(
7858 rename = "sectionEnteredAt",
7859 default,
7860 skip_serializing_if = "Option::is_none"
7861 )]
7862 pub section_entered_at: Option<i64>,
7863 #[serde(rename = "sessionId", default)]
7864 pub session_id: String,
7865 #[serde(default)]
7866 pub source: Value,
7867 #[serde(default)]
7868 pub status: Value,
7869 #[serde(
7870 rename = "threadSource",
7871 default,
7872 skip_serializing_if = "Option::is_none"
7873 )]
7874 pub thread_source: Option<ThreadSource>,
7875 #[serde(default)]
7876 pub turns: Vec<Turn>,
7877 #[serde(rename = "updatedAt", default)]
7878 pub updated_at: i64,
7879}
7880
7881#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7882pub enum ThreadActiveFlag {
7883 #[serde(rename = "waitingOnApproval")]
7884 WaitingOnApproval,
7885 #[serde(rename = "waitingOnUserInput")]
7886 WaitingOnUserInput,
7887}
7888
7889#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7890#[serde(rename_all = "camelCase")]
7891pub struct ThreadApproveGuardianDeniedActionParams {
7892 #[serde(default)]
7893 pub event: Value,
7894 #[serde(rename = "threadId", default)]
7895 pub thread_id: String,
7896}
7897
7898#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7899#[serde(rename_all = "camelCase")]
7900pub struct ThreadApproveGuardianDeniedActionResponse {
7901 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7902 pub extra: serde_json::Map<String, Value>,
7903}
7904
7905#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7906#[serde(rename_all = "camelCase")]
7907pub struct ThreadArchiveParams {
7908 #[serde(rename = "threadId", default)]
7909 pub thread_id: String,
7910}
7911
7912#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7913#[serde(rename_all = "camelCase")]
7914pub struct ThreadArchiveResponse {
7915 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7916 pub extra: serde_json::Map<String, Value>,
7917}
7918
7919#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7920#[serde(rename_all = "camelCase")]
7921pub struct ThreadArchivedNotification {
7922 #[serde(rename = "threadId", default)]
7923 pub thread_id: String,
7924}
7925
7926#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7928#[serde(rename_all = "camelCase")]
7929pub struct ThreadAttachment {
7930 #[serde(rename = "attachmentType", default)]
7931 pub attachment_type: String,
7932 #[serde(rename = "createdAt", default)]
7933 pub created_at: i64,
7934 #[serde(default)]
7935 pub id: String,
7936 #[serde(rename = "identityKey", default)]
7937 pub identity_key: String,
7938 #[serde(default)]
7939 pub payload: Value,
7940}
7941
7942#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7944pub enum ThreadAttachmentAddOutcome {
7945 #[serde(rename = "created")]
7946 Created,
7947 #[serde(rename = "existing")]
7948 Existing,
7949}
7950
7951#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7953#[serde(rename_all = "camelCase")]
7954pub struct ThreadAttachmentAddParams {
7955 #[serde(rename = "attachmentType", default)]
7956 pub attachment_type: String,
7957 #[serde(rename = "identityKey", default)]
7958 pub identity_key: String,
7959 #[serde(default)]
7960 pub payload: Value,
7961 #[serde(rename = "threadId", default)]
7962 pub thread_id: String,
7963}
7964
7965#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7967#[serde(rename_all = "camelCase")]
7968pub struct ThreadAttachmentAddResponse {
7969 pub attachment: ThreadAttachment,
7970 pub outcome: ThreadAttachmentAddOutcome,
7971}
7972
7973#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7975#[serde(rename_all = "camelCase")]
7976pub struct ThreadAttachmentListParams {
7977 #[serde(default, skip_serializing_if = "Option::is_none")]
7978 pub cursor: Option<String>,
7979 #[serde(default, skip_serializing_if = "Option::is_none")]
7980 pub limit: Option<i64>,
7981 #[serde(rename = "threadId", default)]
7982 pub thread_id: String,
7983}
7984
7985#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7987#[serde(rename_all = "camelCase")]
7988pub struct ThreadAttachmentListResponse {
7989 #[serde(default)]
7990 pub data: Vec<ThreadAttachment>,
7991 #[serde(
7992 rename = "nextCursor",
7993 default,
7994 skip_serializing_if = "Option::is_none"
7995 )]
7996 pub next_cursor: Option<String>,
7997}
7998
7999#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8001pub enum ThreadAttachmentOperation {
8002 #[serde(rename = "created")]
8003 Created,
8004 #[serde(rename = "deleted")]
8005 Deleted,
8006}
8007
8008#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8010#[serde(rename_all = "camelCase")]
8011pub struct ThreadAttachmentOwner {
8012 #[serde(default)]
8014 pub archived: bool,
8015 #[serde(rename = "threadId", default)]
8016 pub thread_id: String,
8017}
8018
8019#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8021#[serde(rename_all = "camelCase")]
8022pub struct ThreadAttachmentOwnerListParams {
8023 #[serde(default, skip_serializing_if = "Option::is_none")]
8025 pub archived: Option<bool>,
8026 #[serde(rename = "attachmentType", default)]
8027 pub attachment_type: String,
8028 #[serde(default, skip_serializing_if = "Option::is_none")]
8029 pub cursor: Option<String>,
8030 #[serde(rename = "identityKey", default)]
8031 pub identity_key: String,
8032 #[serde(default, skip_serializing_if = "Option::is_none")]
8033 pub limit: Option<i64>,
8034}
8035
8036#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8038#[serde(rename_all = "camelCase")]
8039pub struct ThreadAttachmentOwnerListResponse {
8040 #[serde(default)]
8041 pub data: Vec<ThreadAttachmentOwner>,
8042 #[serde(
8043 rename = "nextCursor",
8044 default,
8045 skip_serializing_if = "Option::is_none"
8046 )]
8047 pub next_cursor: Option<String>,
8048}
8049
8050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8052#[serde(rename_all = "camelCase")]
8053pub struct ThreadAttachmentRemoveParams {
8054 #[serde(rename = "attachmentType", default)]
8055 pub attachment_type: String,
8056 #[serde(rename = "identityKey", default)]
8057 pub identity_key: String,
8058 #[serde(rename = "threadId", default)]
8059 pub thread_id: String,
8060}
8061
8062#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8064#[serde(rename_all = "camelCase")]
8065pub struct ThreadAttachmentRemoveResponse {
8066 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8067 pub extra: serde_json::Map<String, Value>,
8068}
8069
8070#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8072#[serde(rename_all = "camelCase")]
8073pub struct ThreadAttachmentUpdatedNotification {
8074 #[serde(rename = "attachmentId", default)]
8075 pub attachment_id: String,
8076 #[serde(rename = "attachmentType", default)]
8077 pub attachment_type: String,
8078 #[serde(rename = "identityKey", default)]
8079 pub identity_key: String,
8080 pub operation: ThreadAttachmentOperation,
8081 #[serde(rename = "threadId", default)]
8082 pub thread_id: String,
8083}
8084
8085#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8086#[serde(rename_all = "camelCase")]
8087pub struct ThreadClosedNotification {
8088 #[serde(rename = "threadId", default)]
8089 pub thread_id: String,
8090}
8091
8092#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8093#[serde(rename_all = "camelCase")]
8094pub struct ThreadCompactStartParams {
8095 #[serde(rename = "threadId", default)]
8096 pub thread_id: String,
8097}
8098
8099#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8100#[serde(rename_all = "camelCase")]
8101pub struct ThreadCompactStartResponse {
8102 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8103 pub extra: serde_json::Map<String, Value>,
8104}
8105
8106#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8107#[serde(rename_all = "camelCase")]
8108pub struct ThreadDeleteParams {
8109 #[serde(rename = "threadId", default)]
8110 pub thread_id: String,
8111}
8112
8113#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8114#[serde(rename_all = "camelCase")]
8115pub struct ThreadDeleteResponse {
8116 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8117 pub extra: serde_json::Map<String, Value>,
8118}
8119
8120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8121#[serde(rename_all = "camelCase")]
8122pub struct ThreadDeletedNotification {
8123 #[serde(rename = "threadId", default)]
8124 pub thread_id: String,
8125}
8126
8127#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8128#[serde(rename_all = "camelCase")]
8129pub struct ThreadForkParams {
8130 #[serde(
8131 rename = "approvalPolicy",
8132 default,
8133 skip_serializing_if = "Option::is_none"
8134 )]
8135 pub approval_policy: Option<AskForApproval>,
8136 #[serde(
8137 rename = "approvalsReviewer",
8138 default,
8139 skip_serializing_if = "Option::is_none"
8140 )]
8141 pub approvals_reviewer: Option<ApprovalsReviewer>,
8142 #[serde(
8143 rename = "baseInstructions",
8144 default,
8145 skip_serializing_if = "Option::is_none"
8146 )]
8147 pub base_instructions: Option<String>,
8148 #[serde(default, skip_serializing_if = "Option::is_none")]
8149 pub config: Option<Value>,
8150 #[serde(default, skip_serializing_if = "Option::is_none")]
8151 pub cwd: Option<String>,
8152 #[serde(
8153 rename = "developerInstructions",
8154 default,
8155 skip_serializing_if = "Option::is_none"
8156 )]
8157 pub developer_instructions: Option<String>,
8158 #[serde(default, skip_serializing_if = "Option::is_none")]
8159 pub ephemeral: Option<bool>,
8160 #[serde(
8161 rename = "excludeTurns",
8162 default,
8163 skip_serializing_if = "Option::is_none"
8164 )]
8165 pub exclude_turns: Option<bool>,
8166 #[serde(
8167 rename = "lastTurnId",
8168 default,
8169 skip_serializing_if = "Option::is_none"
8170 )]
8171 pub last_turn_id: Option<String>,
8172 #[serde(default, skip_serializing_if = "Option::is_none")]
8173 pub model: Option<String>,
8174 #[serde(
8175 rename = "modelProvider",
8176 default,
8177 skip_serializing_if = "Option::is_none"
8178 )]
8179 pub model_provider: Option<String>,
8180 #[serde(default, skip_serializing_if = "Option::is_none")]
8181 pub sandbox: Option<SandboxMode>,
8182 #[serde(
8183 rename = "serviceTier",
8184 default,
8185 skip_serializing_if = "Option::is_none"
8186 )]
8187 pub service_tier: Option<String>,
8188 #[serde(rename = "threadId", default)]
8189 pub thread_id: String,
8190 #[serde(
8191 rename = "threadSource",
8192 default,
8193 skip_serializing_if = "Option::is_none"
8194 )]
8195 pub thread_source: Option<ThreadSource>,
8196}
8197
8198#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8199#[serde(rename_all = "camelCase")]
8200pub struct ThreadForkResponse {
8201 #[serde(rename = "approvalPolicy")]
8202 pub approval_policy: AskForApproval,
8203 #[serde(rename = "approvalsReviewer", default)]
8204 pub approvals_reviewer: Value,
8205 #[serde()]
8206 pub cwd: AbsolutePathBuf,
8207 #[serde(rename = "disabledPluginIds", default)]
8210 pub disabled_plugin_ids: Vec<String>,
8211 #[serde(
8212 rename = "instructionSources",
8213 default,
8214 skip_serializing_if = "Option::is_none"
8215 )]
8216 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8217 #[serde(default)]
8218 pub model: String,
8219 #[serde(rename = "modelProvider", default)]
8220 pub model_provider: String,
8221 #[serde(
8222 rename = "reasoningEffort",
8223 default,
8224 skip_serializing_if = "Option::is_none"
8225 )]
8226 pub reasoning_effort: Option<ReasoningEffort>,
8227 #[serde(default)]
8228 pub sandbox: Value,
8229 #[serde(
8230 rename = "serviceTier",
8231 default,
8232 skip_serializing_if = "Option::is_none"
8233 )]
8234 pub service_tier: Option<String>,
8235 #[serde()]
8236 pub thread: Thread,
8237}
8238
8239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8240#[serde(rename_all = "camelCase")]
8241pub struct ThreadGoal {
8242 #[serde(rename = "createdAt", default)]
8243 pub created_at: i64,
8244 #[serde(default)]
8245 pub objective: String,
8246 #[serde()]
8247 pub status: ThreadGoalStatus,
8248 #[serde(rename = "threadId", default)]
8249 pub thread_id: String,
8250 #[serde(rename = "timeUsedSeconds", default)]
8251 pub time_used_seconds: i64,
8252 #[serde(
8253 rename = "tokenBudget",
8254 default,
8255 skip_serializing_if = "Option::is_none"
8256 )]
8257 pub token_budget: Option<i64>,
8258 #[serde(rename = "tokensUsed", default)]
8259 pub tokens_used: i64,
8260 #[serde(rename = "updatedAt", default)]
8261 pub updated_at: i64,
8262}
8263
8264#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8265#[serde(rename_all = "camelCase")]
8266pub struct ThreadGoalClearParams {
8267 #[serde(default, skip_serializing_if = "Option::is_none")]
8269 pub origin: Option<ThreadGoalMutationOrigin>,
8270 #[serde(rename = "threadId", default)]
8271 pub thread_id: String,
8272}
8273
8274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8275#[serde(rename_all = "camelCase")]
8276pub struct ThreadGoalClearResponse {
8277 #[serde(default)]
8278 pub cleared: bool,
8279}
8280
8281#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8282#[serde(rename_all = "camelCase")]
8283pub struct ThreadGoalClearedNotification {
8284 #[serde(rename = "threadId", default)]
8285 pub thread_id: String,
8286}
8287
8288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8289#[serde(rename_all = "camelCase")]
8290pub struct ThreadGoalGetParams {
8291 #[serde(rename = "threadId", default)]
8292 pub thread_id: String,
8293}
8294
8295#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8296#[serde(rename_all = "camelCase")]
8297pub struct ThreadGoalGetResponse {
8298 #[serde(default, skip_serializing_if = "Option::is_none")]
8299 pub goal: Option<ThreadGoal>,
8300}
8301
8302#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8304pub enum ThreadGoalMutationOrigin {
8305 #[serde(rename = "user")]
8306 User,
8307 #[serde(rename = "automatic")]
8308 Automatic,
8309}
8310
8311#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8312#[serde(rename_all = "camelCase")]
8313pub struct ThreadGoalSetParams {
8314 #[serde(default, skip_serializing_if = "Option::is_none")]
8315 pub objective: Option<String>,
8316 #[serde(default, skip_serializing_if = "Option::is_none")]
8318 pub origin: Option<ThreadGoalMutationOrigin>,
8319 #[serde(default, skip_serializing_if = "Option::is_none")]
8320 pub status: Option<ThreadGoalStatus>,
8321 #[serde(rename = "threadId", default)]
8322 pub thread_id: String,
8323 #[serde(
8324 rename = "tokenBudget",
8325 default,
8326 skip_serializing_if = "Option::is_none"
8327 )]
8328 pub token_budget: Option<i64>,
8329}
8330
8331#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8332#[serde(rename_all = "camelCase")]
8333pub struct ThreadGoalSetResponse {
8334 #[serde()]
8335 pub goal: ThreadGoal,
8336}
8337
8338#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8339pub enum ThreadGoalStatus {
8340 #[serde(rename = "active")]
8341 Active,
8342 #[serde(rename = "paused")]
8343 Paused,
8344 #[serde(rename = "blocked")]
8345 Blocked,
8346 #[serde(rename = "usageLimited")]
8347 UsageLimited,
8348 #[serde(rename = "budgetLimited")]
8349 BudgetLimited,
8350 #[serde(rename = "complete")]
8351 Complete,
8352}
8353
8354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8355#[serde(rename_all = "camelCase")]
8356pub struct ThreadGoalUpdatedNotification {
8357 #[serde()]
8358 pub goal: ThreadGoal,
8359 #[serde(rename = "threadId", default)]
8360 pub thread_id: String,
8361 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8362 pub turn_id: Option<String>,
8363}
8364
8365#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
8366#[serde(transparent)]
8367pub struct ThreadId(pub String);
8368
8369#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8370#[serde(rename_all = "camelCase")]
8371pub struct ThreadInjectItemsParams {
8372 #[serde(default)]
8373 pub items: Vec<Value>,
8374 #[serde(rename = "threadId", default)]
8375 pub thread_id: String,
8376}
8377
8378#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8379#[serde(rename_all = "camelCase")]
8380pub struct ThreadInjectItemsResponse {
8381 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8382 pub extra: serde_json::Map<String, Value>,
8383}
8384
8385#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8387#[serde(rename_all = "camelCase")]
8388pub struct ThreadItem {
8389 #[serde(flatten)]
8390 pub payload: ThreadItemPayload,
8391 #[serde(
8393 rename = "startedAtMs",
8394 default,
8395 skip_serializing_if = "Option::is_none"
8396 )]
8397 pub started_at_ms: Option<i64>,
8398 #[serde(
8400 rename = "completedAtMs",
8401 default,
8402 skip_serializing_if = "Option::is_none"
8403 )]
8404 pub completed_at_ms: Option<i64>,
8405}
8406
8407impl ThreadItem {
8408 pub fn untimed(payload: ThreadItemPayload) -> Self {
8410 Self {
8411 payload,
8412 started_at_ms: None,
8413 completed_at_ms: None,
8414 }
8415 }
8416}
8417
8418impl From<ThreadItemPayload> for ThreadItem {
8419 fn from(payload: ThreadItemPayload) -> Self {
8420 Self::untimed(payload)
8421 }
8422}
8423
8424#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8426#[serde(tag = "type", rename_all = "camelCase")]
8427pub enum ThreadItemPayload {
8428 #[serde(rename = "userMessage")]
8429 UserMessage {
8430 #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
8431 client_id: Option<String>,
8432 content: Vec<UserInput>,
8433 id: String,
8434 },
8435 #[serde(rename = "hookPrompt")]
8436 HookPrompt {
8437 fragments: Vec<HookPromptFragment>,
8438 id: String,
8439 },
8440 #[serde(rename = "agentMessage")]
8441 AgentMessage {
8442 #[serde(default, skip_serializing_if = "Option::is_none")]
8443 delivery: Option<AgentMessageDelivery>,
8444 id: String,
8445 #[serde(
8446 rename = "memoryCitation",
8447 default,
8448 skip_serializing_if = "Option::is_none"
8449 )]
8450 memory_citation: Option<MemoryCitation>,
8451 #[serde(default, skip_serializing_if = "Option::is_none")]
8452 phase: Option<MessagePhase>,
8453 #[serde(default, skip_serializing_if = "Option::is_none")]
8454 questions: Option<Vec<AsyncUserInputQuestion>>,
8455 text: String,
8456 },
8457 Plan {
8458 id: String,
8459 text: String,
8460 },
8461 Reasoning {
8462 #[serde(default, skip_serializing_if = "Option::is_none")]
8463 content: Option<Vec<String>>,
8464 id: String,
8465 #[serde(default, skip_serializing_if = "Option::is_none")]
8466 summary: Option<Vec<String>>,
8467 },
8468 #[serde(rename = "commandExecution")]
8469 CommandExecution {
8470 #[serde(
8471 rename = "aggregatedOutput",
8472 default,
8473 skip_serializing_if = "Option::is_none"
8474 )]
8475 aggregated_output: Option<String>,
8476 command: String,
8477 #[serde(rename = "commandActions")]
8478 command_actions: Vec<CommandAction>,
8479 cwd: Value,
8480 #[serde(
8481 rename = "durationMs",
8482 default,
8483 skip_serializing_if = "Option::is_none"
8484 )]
8485 duration_ms: Option<i64>,
8486 #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
8487 exit_code: Option<i64>,
8488 id: String,
8489 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8490 plugin_id: Option<String>,
8491 #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
8492 process_id: Option<String>,
8493 #[serde(
8494 rename = "scriptPath",
8495 default,
8496 skip_serializing_if = "Option::is_none"
8497 )]
8498 script_path: Option<String>,
8499 #[serde(default, skip_serializing_if = "Option::is_none")]
8500 source: Option<Value>,
8501 status: CommandExecutionStatus,
8502 },
8503 #[serde(rename = "fileChange")]
8504 FileChange {
8505 changes: Vec<FileUpdateChange>,
8506 id: String,
8507 status: PatchApplyStatus,
8508 },
8509 #[serde(rename = "mcpToolCall")]
8510 McpToolCall {
8511 #[serde(
8512 rename = "appContext",
8513 default,
8514 skip_serializing_if = "Option::is_none"
8515 )]
8516 app_context: Option<McpToolCallAppContext>,
8517 arguments: Value,
8518 #[serde(
8519 rename = "durationMs",
8520 default,
8521 skip_serializing_if = "Option::is_none"
8522 )]
8523 duration_ms: Option<i64>,
8524 #[serde(default, skip_serializing_if = "Option::is_none")]
8525 error: Option<McpToolCallError>,
8526 id: String,
8527 #[serde(
8530 rename = "mcpAppResourceUri",
8531 default,
8532 skip_serializing_if = "Option::is_none"
8533 )]
8534 mcp_app_resource_uri: Option<String>,
8535 #[serde(rename = "mcpAppUi", default, skip_serializing_if = "Option::is_none")]
8538 mcp_app_ui: Option<McpAppUi>,
8539 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8540 plugin_id: Option<String>,
8541 #[serde(
8542 rename = "readOnlyHint",
8543 default,
8544 skip_serializing_if = "Option::is_none"
8545 )]
8546 read_only_hint: Option<bool>,
8547 #[serde(default, skip_serializing_if = "Option::is_none")]
8548 result: Option<McpToolCallResult>,
8549 server: String,
8550 status: McpToolCallStatus,
8551 tool: String,
8552 },
8553 #[serde(rename = "dynamicToolCall")]
8554 DynamicToolCall {
8555 arguments: Value,
8556 #[serde(
8557 rename = "contentItems",
8558 default,
8559 skip_serializing_if = "Option::is_none"
8560 )]
8561 content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
8562 #[serde(
8563 rename = "durationMs",
8564 default,
8565 skip_serializing_if = "Option::is_none"
8566 )]
8567 duration_ms: Option<i64>,
8568 id: String,
8569 #[serde(default, skip_serializing_if = "Option::is_none")]
8570 namespace: Option<String>,
8571 status: DynamicToolCallStatus,
8572 #[serde(default, skip_serializing_if = "Option::is_none")]
8573 success: Option<bool>,
8574 tool: String,
8575 },
8576 #[serde(rename = "collabAgentToolCall")]
8577 CollabAgentToolCall {
8578 #[serde(rename = "agentsStates")]
8579 agents_states: std::collections::BTreeMap<String, CollabAgentState>,
8580 id: String,
8581 #[serde(default, skip_serializing_if = "Option::is_none")]
8582 model: Option<String>,
8583 #[serde(default, skip_serializing_if = "Option::is_none")]
8584 prompt: Option<String>,
8585 #[serde(
8586 rename = "reasoningEffort",
8587 default,
8588 skip_serializing_if = "Option::is_none"
8589 )]
8590 reasoning_effort: Option<ReasoningEffort>,
8591 #[serde(rename = "receiverThreadIds")]
8592 receiver_thread_ids: Vec<String>,
8593 #[serde(rename = "senderThreadId")]
8594 sender_thread_id: String,
8595 status: Value,
8596 tool: Value,
8597 },
8598 #[serde(rename = "subAgentActivity")]
8599 SubAgentActivity {
8600 #[serde(rename = "agentPath")]
8601 agent_path: String,
8602 #[serde(rename = "agentThreadId")]
8603 agent_thread_id: String,
8604 id: String,
8605 kind: SubAgentActivityKind,
8606 #[serde(default, skip_serializing_if = "Option::is_none")]
8609 model: Option<String>,
8610 #[serde(
8612 rename = "reasoningEffort",
8613 default,
8614 skip_serializing_if = "Option::is_none"
8615 )]
8616 reasoning_effort: Option<ReasoningEffort>,
8617 },
8618 #[serde(rename = "webSearch")]
8619 WebSearch {
8620 #[serde(default, skip_serializing_if = "Option::is_none")]
8621 action: Option<WebSearchAction>,
8622 id: String,
8623 query: String,
8624 #[serde(default, skip_serializing_if = "Option::is_none")]
8625 results: Option<Vec<Value>>,
8626 },
8627 #[serde(rename = "imageView")]
8628 ImageView {
8629 id: String,
8630 path: LegacyAppPathString,
8631 },
8632 Sleep {
8633 #[serde(rename = "durationMs")]
8634 duration_ms: i64,
8635 id: String,
8636 },
8637 #[serde(rename = "imageGeneration")]
8638 ImageGeneration {
8639 #[serde(default, skip_serializing_if = "Option::is_none")]
8640 failure: Option<ImageGenerationFailure>,
8641 #[serde(
8643 rename = "generationId",
8644 default,
8645 skip_serializing_if = "Option::is_none"
8646 )]
8647 generation_id: Option<String>,
8648 id: String,
8649 #[serde(flatten)]
8650 image: GeneratedImageRef,
8651 #[serde(
8653 rename = "inputImages",
8654 default,
8655 skip_serializing_if = "Option::is_none"
8656 )]
8657 input_images: Option<Vec<ImageGenerationInputImage>>,
8658 #[serde(
8659 rename = "revisedPrompt",
8660 default,
8661 skip_serializing_if = "Option::is_none"
8662 )]
8663 revised_prompt: Option<String>,
8664 #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
8665 saved_path: Option<AbsolutePathBuf>,
8666 status: String,
8667 #[serde(
8668 rename = "transparentBackground",
8669 default,
8670 skip_serializing_if = "Option::is_none"
8671 )]
8672 transparent_background: Option<bool>,
8673 },
8674 #[serde(rename = "enteredReviewMode")]
8675 EnteredReviewMode {
8676 id: String,
8677 review: String,
8678 },
8679 #[serde(rename = "exitedReviewMode")]
8680 ExitedReviewMode {
8681 id: String,
8682 review: String,
8683 },
8684 #[serde(rename = "contextCompaction")]
8685 ContextCompaction {
8686 id: String,
8687 },
8688 #[serde(rename = "functionCallOutput")]
8689 FunctionCallOutput {
8690 id: String,
8691 name: String,
8692 #[serde(default, skip_serializing_if = "Option::is_none")]
8693 namespace: Option<String>,
8694 output: FunctionCallOutputBody,
8695 },
8696}
8697
8698#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8699#[serde(untagged)]
8700pub enum ThreadListCwdFilter {
8701 Variant0(String),
8702 Variant1(Vec<String>),
8703}
8704
8705#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8706#[serde(rename_all = "camelCase")]
8707pub struct ThreadListParams {
8708 #[serde(default, skip_serializing_if = "Option::is_none")]
8709 pub archived: Option<bool>,
8710 #[serde(
8713 rename = "currentAccountOnly",
8714 default,
8715 skip_serializing_if = "Option::is_none"
8716 )]
8717 pub current_account_only: Option<bool>,
8718 #[serde(default, skip_serializing_if = "Option::is_none")]
8719 pub cursor: Option<String>,
8720 #[serde(default, skip_serializing_if = "Option::is_none")]
8721 pub cwd: Option<ThreadListCwdFilter>,
8722 #[serde(
8727 rename = "excludedThreadIds",
8728 default,
8729 skip_serializing_if = "Option::is_none"
8730 )]
8731 pub excluded_thread_ids: Option<Vec<String>>,
8732 #[serde(default, skip_serializing_if = "Option::is_none")]
8733 pub limit: Option<i64>,
8734 #[serde(
8735 rename = "modelProviders",
8736 default,
8737 skip_serializing_if = "Option::is_none"
8738 )]
8739 pub model_providers: Option<Vec<String>>,
8740 #[serde(default, skip_serializing_if = "Option::is_none")]
8744 pub originators: Option<Vec<String>>,
8745 #[serde(
8746 rename = "searchTerm",
8747 default,
8748 skip_serializing_if = "Option::is_none"
8749 )]
8750 pub search_term: Option<String>,
8751 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8752 pub section_id: Option<String>,
8753 #[serde(
8754 rename = "sortDirection",
8755 default,
8756 skip_serializing_if = "Option::is_none"
8757 )]
8758 pub sort_direction: Option<SortDirection>,
8759 #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
8760 pub sort_key: Option<ThreadSortKey>,
8761 #[serde(
8762 rename = "sourceKinds",
8763 default,
8764 skip_serializing_if = "Option::is_none"
8765 )]
8766 pub source_kinds: Option<Vec<ThreadSourceKind>>,
8767 #[serde(
8768 rename = "useStateDbOnly",
8769 default,
8770 skip_serializing_if = "Option::is_none"
8771 )]
8772 pub use_state_db_only: Option<bool>,
8773}
8774
8775#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8776#[serde(rename_all = "camelCase")]
8777pub struct ThreadListResponse {
8778 #[serde(
8779 rename = "backwardsCursor",
8780 default,
8781 skip_serializing_if = "Option::is_none"
8782 )]
8783 pub backwards_cursor: Option<String>,
8784 #[serde(default)]
8785 pub data: Vec<Thread>,
8786 #[serde(
8787 rename = "nextCursor",
8788 default,
8789 skip_serializing_if = "Option::is_none"
8790 )]
8791 pub next_cursor: Option<String>,
8792}
8793
8794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8795#[serde(rename_all = "camelCase")]
8796pub struct ThreadLoadedListParams {
8797 #[serde(default, skip_serializing_if = "Option::is_none")]
8798 pub cursor: Option<String>,
8799 #[serde(default, skip_serializing_if = "Option::is_none")]
8800 pub limit: Option<i64>,
8801}
8802
8803#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8804#[serde(rename_all = "camelCase")]
8805pub struct ThreadLoadedListResponse {
8806 #[serde(default)]
8807 pub data: Vec<String>,
8808 #[serde(
8809 rename = "nextCursor",
8810 default,
8811 skip_serializing_if = "Option::is_none"
8812 )]
8813 pub next_cursor: Option<String>,
8814}
8815
8816#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8817#[serde(rename_all = "camelCase")]
8818pub struct ThreadMetadataGitInfoUpdateParams {
8819 #[serde(default, skip_serializing_if = "Option::is_none")]
8820 pub branch: Option<String>,
8821 #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
8822 pub origin_url: Option<String>,
8823 #[serde(default, skip_serializing_if = "Option::is_none")]
8824 pub sha: Option<String>,
8825}
8826
8827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8828#[serde(rename_all = "camelCase")]
8829pub struct ThreadMetadataUpdateParams {
8830 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
8831 pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
8832 #[serde(rename = "threadId", default)]
8833 pub thread_id: String,
8834}
8835
8836#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8837#[serde(rename_all = "camelCase")]
8838pub struct ThreadMetadataUpdateResponse {
8839 #[serde()]
8840 pub thread: Thread,
8841}
8842
8843#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8844#[serde(rename_all = "camelCase")]
8845pub struct ThreadNameUpdatedNotification {
8846 #[serde(rename = "threadId", default)]
8847 pub thread_id: String,
8848 #[serde(
8849 rename = "threadName",
8850 default,
8851 skip_serializing_if = "Option::is_none"
8852 )]
8853 pub thread_name: Option<String>,
8854}
8855
8856#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8857#[serde(rename_all = "camelCase")]
8858pub struct ThreadReadParams {
8859 #[serde(
8860 rename = "includeTurns",
8861 default,
8862 skip_serializing_if = "Option::is_none"
8863 )]
8864 pub include_turns: Option<bool>,
8865 #[serde(rename = "threadId", default)]
8866 pub thread_id: String,
8867}
8868
8869#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8870#[serde(rename_all = "camelCase")]
8871pub struct ThreadReadResponse {
8872 #[serde()]
8873 pub thread: Thread,
8874}
8875
8876#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8879#[serde(rename_all = "camelCase")]
8880pub struct ThreadReadState {
8881 #[serde(
8882 rename = "firstUnread",
8883 default,
8884 skip_serializing_if = "Option::is_none"
8885 )]
8886 pub first_unread: Option<ThreadUnreadPosition>,
8887 #[serde(default)]
8888 pub revision: String,
8889}
8890
8891#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8892#[serde(rename_all = "camelCase")]
8893pub struct ThreadReadStateChangedNotification {
8894 #[serde(rename = "readState")]
8895 pub read_state: ThreadReadState,
8896 #[serde(rename = "threadId", default)]
8897 pub thread_id: String,
8898}
8899
8900#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
8902#[serde(rename_all = "camelCase")]
8903pub struct ThreadSectionChangedNotification {
8904 #[serde(rename = "threadId")]
8905 pub thread_id: String,
8906 #[serde(rename = "sectionId")]
8909 pub section_id: Option<String>,
8910}
8911
8912#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8913#[serde(rename_all = "camelCase")]
8914pub struct ThreadRealtimeAudioChunk {
8915 #[serde(default)]
8916 pub data: String,
8917 #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
8918 pub item_id: Option<String>,
8919 #[serde(rename = "numChannels", default)]
8920 pub num_channels: i64,
8921 #[serde(rename = "sampleRate", default)]
8922 pub sample_rate: i64,
8923 #[serde(
8924 rename = "samplesPerChannel",
8925 default,
8926 skip_serializing_if = "Option::is_none"
8927 )]
8928 pub samples_per_channel: Option<i64>,
8929}
8930
8931#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8932#[serde(rename_all = "camelCase")]
8933pub struct ThreadRealtimeClosedNotification {
8934 #[serde(default, skip_serializing_if = "Option::is_none")]
8935 pub reason: Option<String>,
8936 #[serde(rename = "threadId", default)]
8937 pub thread_id: String,
8938}
8939
8940#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8941#[serde(rename_all = "camelCase")]
8942pub struct ThreadRealtimeErrorNotification {
8943 #[serde(default)]
8944 pub message: String,
8945 #[serde(rename = "threadId", default)]
8946 pub thread_id: String,
8947}
8948
8949#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8950#[serde(rename_all = "camelCase")]
8951pub struct ThreadRealtimeItemAddedNotification {
8952 #[serde(default)]
8953 pub item: Value,
8954 #[serde(rename = "threadId", default)]
8955 pub thread_id: String,
8956}
8957
8958#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8959#[serde(rename_all = "camelCase")]
8960pub struct ThreadRealtimeOutputAudioDeltaNotification {
8961 #[serde()]
8962 pub audio: ThreadRealtimeAudioChunk,
8963 #[serde(rename = "threadId", default)]
8964 pub thread_id: String,
8965}
8966
8967#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8968#[serde(rename_all = "camelCase")]
8969pub struct ThreadRealtimeSdpNotification {
8970 #[serde(default)]
8971 pub sdp: String,
8972 #[serde(rename = "threadId", default)]
8973 pub thread_id: String,
8974}
8975
8976#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8977#[serde(rename_all = "camelCase")]
8978pub struct ThreadRealtimeStartedNotification {
8979 #[serde(
8980 rename = "realtimeSessionId",
8981 default,
8982 skip_serializing_if = "Option::is_none"
8983 )]
8984 pub realtime_session_id: Option<String>,
8985 #[serde(rename = "threadId", default)]
8986 pub thread_id: String,
8987 #[serde()]
8988 pub version: RealtimeConversationVersion,
8989}
8990
8991#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8992#[serde(rename_all = "camelCase")]
8993pub struct ThreadRealtimeTranscriptDeltaNotification {
8994 #[serde(default)]
8995 pub delta: String,
8996 #[serde(default)]
8997 pub role: String,
8998 #[serde(rename = "threadId", default)]
8999 pub thread_id: String,
9000}
9001
9002#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9003#[serde(rename_all = "camelCase")]
9004pub struct ThreadRealtimeTranscriptDoneNotification {
9005 #[serde(default)]
9006 pub role: String,
9007 #[serde(default)]
9008 pub text: String,
9009 #[serde(rename = "threadId", default)]
9010 pub thread_id: String,
9011}
9012
9013#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9014#[serde(rename_all = "camelCase")]
9015pub struct ThreadResumeParams {
9016 #[serde(
9017 rename = "approvalPolicy",
9018 default,
9019 skip_serializing_if = "Option::is_none"
9020 )]
9021 pub approval_policy: Option<AskForApproval>,
9022 #[serde(
9023 rename = "approvalsReviewer",
9024 default,
9025 skip_serializing_if = "Option::is_none"
9026 )]
9027 pub approvals_reviewer: Option<ApprovalsReviewer>,
9028 #[serde(
9029 rename = "baseInstructions",
9030 default,
9031 skip_serializing_if = "Option::is_none"
9032 )]
9033 pub base_instructions: Option<String>,
9034 #[serde(default, skip_serializing_if = "Option::is_none")]
9035 pub config: Option<Value>,
9036 #[serde(default, skip_serializing_if = "Option::is_none")]
9037 pub cwd: Option<String>,
9038 #[serde(
9039 rename = "developerInstructions",
9040 default,
9041 skip_serializing_if = "Option::is_none"
9042 )]
9043 pub developer_instructions: Option<String>,
9044 #[serde(default, skip_serializing_if = "Option::is_none")]
9045 pub model: Option<String>,
9046 #[serde(
9047 rename = "modelProvider",
9048 default,
9049 skip_serializing_if = "Option::is_none"
9050 )]
9051 pub model_provider: Option<String>,
9052 #[serde(default, skip_serializing_if = "Option::is_none")]
9053 pub personality: Option<Personality>,
9054 #[serde(default, skip_serializing_if = "Option::is_none")]
9055 pub sandbox: Option<SandboxMode>,
9056 #[serde(
9057 rename = "serviceTier",
9058 default,
9059 skip_serializing_if = "Option::is_none"
9060 )]
9061 pub service_tier: Option<String>,
9062 #[serde(rename = "threadId", default)]
9063 pub thread_id: String,
9064 #[serde(
9065 rename = "excludeTurns",
9066 default,
9067 skip_serializing_if = "Option::is_none"
9068 )]
9069 pub exclude_turns: Option<bool>,
9070}
9071
9072#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9073#[serde(rename_all = "camelCase")]
9074pub struct ThreadResumeResponse {
9075 #[serde(rename = "approvalPolicy")]
9076 pub approval_policy: AskForApproval,
9077 #[serde(rename = "approvalsReviewer", default)]
9078 pub approvals_reviewer: Value,
9079 #[serde(
9082 rename = "collaborationMode",
9083 default,
9084 skip_serializing_if = "Option::is_none"
9085 )]
9086 pub collaboration_mode: Option<CollaborationMode>,
9087 #[serde()]
9088 pub cwd: AbsolutePathBuf,
9089 #[serde(rename = "disabledPluginIds", default)]
9092 pub disabled_plugin_ids: Vec<String>,
9093 #[serde(
9094 rename = "instructionSources",
9095 default,
9096 skip_serializing_if = "Option::is_none"
9097 )]
9098 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9099 #[serde(
9102 rename = "itemsBackwardsCursor",
9103 default,
9104 skip_serializing_if = "Option::is_none"
9105 )]
9106 pub items_backwards_cursor: Option<String>,
9107 #[serde(default)]
9108 pub model: String,
9109 #[serde(rename = "modelProvider", default)]
9110 pub model_provider: String,
9111 #[serde(
9112 rename = "reasoningEffort",
9113 default,
9114 skip_serializing_if = "Option::is_none"
9115 )]
9116 pub reasoning_effort: Option<ReasoningEffort>,
9117 #[serde(default)]
9118 pub sandbox: Value,
9119 #[serde(
9120 rename = "serviceTier",
9121 default,
9122 skip_serializing_if = "Option::is_none"
9123 )]
9124 pub service_tier: Option<String>,
9125 #[serde()]
9126 pub thread: Thread,
9127 #[serde(
9130 rename = "turnsBackwardsCursor",
9131 default,
9132 skip_serializing_if = "Option::is_none"
9133 )]
9134 pub turns_backwards_cursor: Option<String>,
9135}
9136
9137#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9139pub enum ThreadHistoryMode {
9140 #[serde(rename = "legacy")]
9141 Legacy,
9142 #[serde(rename = "paginated")]
9143 Paginated,
9144}
9145
9146#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9149#[serde(rename_all = "camelCase")]
9150pub struct ThreadItemEntry {
9151 #[serde(
9154 rename = "completedAtMs",
9155 default,
9156 skip_serializing_if = "Option::is_none"
9157 )]
9158 pub completed_at_ms: Option<i64>,
9159 #[serde()]
9160 pub item: ThreadItem,
9161 #[serde(
9164 rename = "startedAtMs",
9165 default,
9166 skip_serializing_if = "Option::is_none"
9167 )]
9168 pub started_at_ms: Option<i64>,
9169 #[serde(rename = "turnId", default)]
9170 pub turn_id: String,
9171}
9172
9173#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9175#[serde(rename_all = "camelCase")]
9176pub struct ThreadItemsListParams {
9177 #[serde(default, skip_serializing_if = "Option::is_none")]
9183 pub cursor: Option<ThreadItemsListCursor>,
9184 #[serde(default, skip_serializing_if = "Option::is_none")]
9185 pub limit: Option<u32>,
9186 #[serde(
9187 rename = "sortDirection",
9188 default,
9189 skip_serializing_if = "Option::is_none"
9190 )]
9191 pub sort_direction: Option<SortDirection>,
9192 #[serde(rename = "threadId", default)]
9193 pub thread_id: String,
9194 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
9196 pub turn_id: Option<String>,
9197}
9198
9199#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9204#[serde(untagged)]
9205pub enum ThreadItemsListCursor {
9206 Opaque(String),
9207 Anchor(ThreadItemsListAnchor),
9208}
9209
9210#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9213#[serde(tag = "type", rename_all = "camelCase")]
9214pub enum ThreadItemsListAnchor {
9215 Item {
9216 #[serde(rename = "itemId")]
9217 item_id: String,
9218 },
9219}
9220
9221#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9223#[serde(rename_all = "camelCase")]
9224pub struct ThreadItemsListResponse {
9225 #[serde(
9226 rename = "backwardsCursor",
9227 default,
9228 skip_serializing_if = "Option::is_none"
9229 )]
9230 pub backwards_cursor: Option<String>,
9231 #[serde(default)]
9232 pub data: Vec<ThreadItemEntry>,
9233 #[serde(
9234 rename = "nextCursor",
9235 default,
9236 skip_serializing_if = "Option::is_none"
9237 )]
9238 pub next_cursor: Option<String>,
9239}
9240
9241#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9245pub struct ThreadRealtimeItem {
9246 #[serde(default)]
9247 pub id: String,
9248 #[serde(rename = "realtimeSessionId", default)]
9249 pub realtime_session_id: String,
9250 #[serde(flatten)]
9251 pub detail: ThreadRealtimeItemDetail,
9252}
9253
9254#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9256#[serde(tag = "type", rename_all = "camelCase")]
9257pub enum ThreadRealtimeItemDetail {
9258 #[serde(rename = "realtimeSessionStarted")]
9259 RealtimeSessionStarted,
9260 #[serde(rename = "transcriptSegment")]
9261 TranscriptSegment {
9262 role: ThreadRealtimeTranscriptRole,
9263 text: String,
9264 },
9265 #[serde(rename = "bemItemPromoted")]
9266 BemItemPromoted {
9267 item_id: String,
9268 presentation: ThreadRealtimeBemItemPresentation,
9269 turn_id: String,
9270 },
9271 #[serde(rename = "realtimeSessionClosed")]
9272 RealtimeSessionClosed {
9273 outcome: ThreadRealtimeSessionOutcome,
9274 },
9275}
9276
9277#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9280#[serde(tag = "type", rename_all = "camelCase")]
9281pub enum ThreadRealtimeBemItemPresentation {
9282 #[serde(rename = "wholeItem")]
9283 WholeItem,
9284 #[serde(rename = "inlineMarkdown")]
9285 InlineMarkdown,
9286 #[serde(rename = "inlineVisualization")]
9287 InlineVisualization { index: u32 },
9288}
9289
9290#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9292#[serde(rename_all = "camelCase")]
9293pub struct ThreadRealtimeItemStartedNotification {
9294 #[serde()]
9295 pub item: ThreadRealtimeItem,
9296 #[serde(rename = "threadId", default)]
9297 pub thread_id: String,
9298}
9299
9300#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9302#[serde(rename_all = "camelCase")]
9303pub struct ThreadRealtimeItemCompletedNotification {
9304 #[serde()]
9305 pub item: ThreadRealtimeItem,
9306 #[serde(rename = "threadId", default)]
9307 pub thread_id: String,
9308}
9309
9310#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9313#[serde(rename_all = "camelCase")]
9314pub struct ThreadRealtimeItemTranscriptDeltaNotification {
9315 #[serde(default)]
9316 pub delta: String,
9317 #[serde(rename = "itemId", default)]
9318 pub item_id: String,
9319 #[serde(rename = "threadId", default)]
9320 pub thread_id: String,
9321}
9322
9323#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9325pub enum ThreadRealtimeSessionOutcome {
9326 #[serde(rename = "ended")]
9327 Ended,
9328 #[serde(rename = "failed")]
9329 Failed,
9330}
9331
9332#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9334pub enum ThreadRealtimeTranscriptRole {
9335 #[serde(rename = "user")]
9336 User,
9337 #[serde(rename = "assistant")]
9338 Assistant,
9339}
9340
9341#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9345#[serde(rename_all = "camelCase")]
9346pub struct ThreadRevertParams {
9347 #[serde(rename = "beforeTurnId", default)]
9349 pub before_turn_id: String,
9350 #[serde(rename = "threadId", default)]
9351 pub thread_id: String,
9352}
9353
9354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9357#[serde(rename_all = "camelCase")]
9358pub struct ThreadRevertResponse {
9359 #[serde(
9360 rename = "itemsBackwardsCursor",
9361 default,
9362 skip_serializing_if = "Option::is_none"
9363 )]
9364 pub items_backwards_cursor: Option<String>,
9365 #[serde()]
9366 pub thread: Thread,
9367 #[serde(
9368 rename = "turnsBackwardsCursor",
9369 default,
9370 skip_serializing_if = "Option::is_none"
9371 )]
9372 pub turns_backwards_cursor: Option<String>,
9373}
9374
9375#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9376#[serde(rename_all = "camelCase")]
9377pub struct ThreadSection {
9378 #[serde(default, skip_serializing_if = "Option::is_none")]
9379 pub appearance: Option<ThreadSectionAppearance>,
9380 #[serde(default)]
9381 pub id: String,
9382 #[serde(default)]
9383 pub name: String,
9384}
9385
9386#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9387#[serde(rename_all = "camelCase")]
9388pub struct ThreadSectionAppearance {
9389 #[serde(default, skip_serializing_if = "Option::is_none")]
9390 pub color: Option<String>,
9391 #[serde(default, skip_serializing_if = "Option::is_none")]
9392 pub icon: Option<String>,
9393}
9394
9395#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9396#[serde(rename_all = "camelCase")]
9397pub struct ThreadSectionCreateParams {
9398 #[serde(default, skip_serializing_if = "Option::is_none")]
9399 pub appearance: Option<ThreadSectionAppearance>,
9400 #[serde(default)]
9401 pub name: String,
9402}
9403
9404#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9405#[serde(rename_all = "camelCase")]
9406pub struct ThreadSectionCreateResponse {
9407 #[serde()]
9408 pub section: ThreadSection,
9409}
9410
9411#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9412#[serde(rename_all = "camelCase")]
9413pub struct ThreadSectionDeleteParams {
9414 #[serde(rename = "sectionId", default)]
9415 pub section_id: String,
9416}
9417
9418#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9419#[serde(rename_all = "camelCase")]
9420pub struct ThreadSectionDeleteResponse {
9421 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9422 pub extra: serde_json::Map<String, Value>,
9423}
9424
9425#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9426#[serde(rename_all = "camelCase")]
9427pub struct ThreadSectionListParams {
9428 #[serde(default, skip_serializing_if = "Option::is_none")]
9429 pub cursor: Option<String>,
9430 #[serde(default, skip_serializing_if = "Option::is_none")]
9431 pub limit: Option<i64>,
9432}
9433
9434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9435#[serde(rename_all = "camelCase")]
9436pub struct ThreadSectionListResponse {
9437 #[serde(default)]
9438 pub data: Vec<ThreadSection>,
9439 #[serde(
9440 rename = "nextCursor",
9441 default,
9442 skip_serializing_if = "Option::is_none"
9443 )]
9444 pub next_cursor: Option<String>,
9445}
9446
9447#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9448#[serde(rename_all = "camelCase")]
9449pub struct ThreadSectionMoveParams {
9450 #[serde(
9451 rename = "beforeThreadId",
9452 default,
9453 skip_serializing_if = "Option::is_none"
9454 )]
9455 pub before_thread_id: Option<String>,
9456 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
9457 pub section_id: Option<String>,
9458 #[serde(rename = "threadId", default)]
9459 pub thread_id: String,
9460}
9461
9462#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9463#[serde(rename_all = "camelCase")]
9464pub struct ThreadSectionMoveResponse {
9465 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9466 pub extra: serde_json::Map<String, Value>,
9467}
9468
9469#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9470#[serde(rename_all = "camelCase")]
9471pub struct ThreadSectionUpdateParams {
9472 #[serde(default, skip_serializing_if = "Option::is_none")]
9473 pub appearance: Option<ThreadSectionAppearance>,
9474 #[serde(default)]
9475 pub name: String,
9476 #[serde(rename = "sectionId", default)]
9477 pub section_id: String,
9478}
9479
9480#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9481#[serde(rename_all = "camelCase")]
9482pub struct ThreadSectionUpdateResponse {
9483 #[serde()]
9484 pub section: ThreadSection,
9485}
9486
9487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9488#[serde(rename_all = "camelCase")]
9489pub struct ThreadSetNameParams {
9490 #[serde(default)]
9491 pub name: String,
9492 #[serde(rename = "threadId", default)]
9493 pub thread_id: String,
9494}
9495
9496#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9497#[serde(rename_all = "camelCase")]
9498pub struct ThreadSetNameResponse {
9499 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9500 pub extra: serde_json::Map<String, Value>,
9501}
9502
9503#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9504#[serde(rename_all = "camelCase")]
9505pub struct ThreadSettings {
9506 #[serde(
9507 rename = "activePermissionProfile",
9508 default,
9509 skip_serializing_if = "Option::is_none"
9510 )]
9511 pub active_permission_profile: Option<ActivePermissionProfile>,
9512 #[serde(rename = "approvalPolicy")]
9513 pub approval_policy: AskForApproval,
9514 #[serde(rename = "approvalsReviewer")]
9515 pub approvals_reviewer: ApprovalsReviewer,
9516 #[serde(rename = "collaborationMode")]
9517 pub collaboration_mode: CollaborationMode,
9518 #[serde()]
9519 pub cwd: AbsolutePathBuf,
9520 #[serde(rename = "disabledPluginIds", default)]
9523 pub disabled_plugin_ids: Vec<String>,
9524 #[serde(default, skip_serializing_if = "Option::is_none")]
9525 pub effort: Option<ReasoningEffort>,
9526 #[serde(default)]
9527 pub model: String,
9528 #[serde(rename = "modelProvider", default)]
9529 pub model_provider: String,
9530 #[serde(default, skip_serializing_if = "Option::is_none")]
9531 pub personality: Option<Personality>,
9532 #[serde(rename = "sandboxPolicy")]
9533 pub sandbox_policy: SandboxPolicy,
9534 #[serde(
9535 rename = "serviceTier",
9536 default,
9537 skip_serializing_if = "Option::is_none"
9538 )]
9539 pub service_tier: Option<String>,
9540 #[serde(default, skip_serializing_if = "Option::is_none")]
9541 pub summary: Option<ReasoningSummary>,
9542}
9543
9544#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9545#[serde(rename_all = "camelCase")]
9546pub struct ThreadSettingsUpdatedNotification {
9547 #[serde(rename = "threadId", default)]
9548 pub thread_id: String,
9549 #[serde(rename = "threadSettings")]
9550 pub thread_settings: ThreadSettings,
9551}
9552
9553#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9554#[serde(rename_all = "camelCase")]
9555pub struct ThreadShellCommandParams {
9556 #[serde(default)]
9557 pub command: String,
9558 #[serde(rename = "threadId", default)]
9559 pub thread_id: String,
9560 #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
9563 pub timeout_ms: Option<i64>,
9564}
9565
9566#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9567#[serde(rename_all = "camelCase")]
9568pub struct ThreadShellCommandResponse {
9569 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9570 pub extra: serde_json::Map<String, Value>,
9571}
9572
9573#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9574pub enum ThreadSortKey {
9575 #[serde(rename = "created_at")]
9576 Created_at,
9577 #[serde(rename = "updated_at")]
9578 Updated_at,
9579 #[serde(rename = "recency_at")]
9580 Recency_at,
9581 #[serde(rename = "section_position")]
9582 Section_position,
9583}
9584
9585#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
9586#[serde(transparent)]
9587pub struct ThreadSource(pub String);
9588
9589#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9590pub enum ThreadSourceKind {
9591 #[serde(rename = "cli")]
9592 Cli,
9593 #[serde(rename = "vscode")]
9594 Vscode,
9595 #[serde(rename = "exec")]
9596 Exec,
9597 #[serde(rename = "appServer")]
9598 AppServer,
9599 #[serde(rename = "subAgent")]
9600 SubAgent,
9601 #[serde(rename = "subAgentReview")]
9602 SubAgentReview,
9603 #[serde(rename = "subAgentCompact")]
9604 SubAgentCompact,
9605 #[serde(rename = "subAgentThreadSpawn")]
9606 SubAgentThreadSpawn,
9607 #[serde(rename = "subAgentOther")]
9608 SubAgentOther,
9609 #[serde(rename = "unknown")]
9610 Unknown,
9611}
9612
9613#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9614#[serde(rename_all = "camelCase")]
9615pub struct ThreadStartParams {
9616 #[serde(
9617 rename = "approvalPolicy",
9618 default,
9619 skip_serializing_if = "Option::is_none"
9620 )]
9621 pub approval_policy: Option<AskForApproval>,
9622 #[serde(
9623 rename = "approvalsReviewer",
9624 default,
9625 skip_serializing_if = "Option::is_none"
9626 )]
9627 pub approvals_reviewer: Option<ApprovalsReviewer>,
9628 #[serde(
9629 rename = "baseInstructions",
9630 default,
9631 skip_serializing_if = "Option::is_none"
9632 )]
9633 pub base_instructions: Option<String>,
9634 #[serde(default, skip_serializing_if = "Option::is_none")]
9635 pub config: Option<Value>,
9636 #[serde(default, skip_serializing_if = "Option::is_none")]
9637 pub cwd: Option<String>,
9638 #[serde(
9639 rename = "developerInstructions",
9640 default,
9641 skip_serializing_if = "Option::is_none"
9642 )]
9643 pub developer_instructions: Option<String>,
9644 #[serde(default, skip_serializing_if = "Option::is_none")]
9645 pub ephemeral: Option<bool>,
9646 #[serde(default, skip_serializing_if = "Option::is_none")]
9647 pub model: Option<String>,
9648 #[serde(
9649 rename = "modelProvider",
9650 default,
9651 skip_serializing_if = "Option::is_none"
9652 )]
9653 pub model_provider: Option<String>,
9654 #[serde(default, skip_serializing_if = "Option::is_none")]
9655 pub personality: Option<Personality>,
9656 #[serde(default, skip_serializing_if = "Option::is_none")]
9657 pub sandbox: Option<SandboxMode>,
9658 #[serde(
9659 rename = "serviceName",
9660 default,
9661 skip_serializing_if = "Option::is_none"
9662 )]
9663 pub service_name: Option<String>,
9664 #[serde(
9665 rename = "serviceTier",
9666 default,
9667 skip_serializing_if = "Option::is_none"
9668 )]
9669 pub service_tier: Option<String>,
9670 #[serde(
9671 rename = "sessionStartSource",
9672 default,
9673 skip_serializing_if = "Option::is_none"
9674 )]
9675 pub session_start_source: Option<ThreadStartSource>,
9676 #[serde(
9677 rename = "threadSource",
9678 default,
9679 skip_serializing_if = "Option::is_none"
9680 )]
9681 pub thread_source: Option<ThreadSource>,
9682}
9683
9684#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9685#[serde(rename_all = "camelCase")]
9686pub struct ThreadStartResponse {
9687 #[serde(rename = "approvalPolicy")]
9688 pub approval_policy: AskForApproval,
9689 #[serde(rename = "approvalsReviewer", default)]
9690 pub approvals_reviewer: Value,
9691 #[serde()]
9692 pub cwd: AbsolutePathBuf,
9693 #[serde(rename = "disabledPluginIds", default)]
9696 pub disabled_plugin_ids: Vec<String>,
9697 #[serde(
9698 rename = "instructionSources",
9699 default,
9700 skip_serializing_if = "Option::is_none"
9701 )]
9702 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9703 #[serde(default)]
9704 pub model: String,
9705 #[serde(rename = "modelProvider", default)]
9706 pub model_provider: String,
9707 #[serde(
9708 rename = "reasoningEffort",
9709 default,
9710 skip_serializing_if = "Option::is_none"
9711 )]
9712 pub reasoning_effort: Option<ReasoningEffort>,
9713 #[serde(default)]
9714 pub sandbox: Value,
9715 #[serde(
9716 rename = "serviceTier",
9717 default,
9718 skip_serializing_if = "Option::is_none"
9719 )]
9720 pub service_tier: Option<String>,
9721 #[serde()]
9722 pub thread: Thread,
9723}
9724
9725#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9726pub enum ThreadStartSource {
9727 #[serde(rename = "startup")]
9728 Startup,
9729 #[serde(rename = "clear")]
9730 Clear,
9731}
9732
9733#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9734#[serde(rename_all = "camelCase")]
9735pub struct ThreadStartedNotification {
9736 #[serde()]
9737 pub thread: Thread,
9738}
9739
9740#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9741#[serde(tag = "type", rename_all = "camelCase")]
9742pub enum ThreadStatus {
9743 #[serde(rename = "notLoaded")]
9744 NotLoaded,
9745 Idle,
9746 #[serde(rename = "systemError")]
9747 SystemError,
9748 Active {
9749 #[serde(rename = "activeFlags")]
9750 active_flags: Vec<ThreadActiveFlag>,
9751 },
9752}
9753
9754#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9755#[serde(rename_all = "camelCase")]
9756pub struct ThreadStatusChangedNotification {
9757 #[serde()]
9758 pub status: ThreadStatus,
9759 #[serde(rename = "threadId", default)]
9760 pub thread_id: String,
9761}
9762
9763#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9764#[serde(rename_all = "camelCase")]
9765pub struct ThreadTokenUsage {
9766 #[serde()]
9767 pub last: TokenUsageBreakdown,
9768 #[serde(
9769 rename = "modelContextWindow",
9770 default,
9771 skip_serializing_if = "Option::is_none"
9772 )]
9773 pub model_context_window: Option<i64>,
9774 #[serde()]
9775 pub total: TokenUsageBreakdown,
9776}
9777
9778#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9779#[serde(rename_all = "camelCase")]
9780pub struct ThreadTokenUsageUpdatedNotification {
9781 #[serde(rename = "threadId", default)]
9782 pub thread_id: String,
9783 #[serde(rename = "tokenUsage")]
9784 pub token_usage: ThreadTokenUsage,
9785 #[serde(rename = "turnId", default)]
9786 pub turn_id: String,
9787}
9788
9789#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9790#[serde(rename_all = "camelCase")]
9791pub struct ThreadUnarchiveParams {
9792 #[serde(rename = "threadId", default)]
9793 pub thread_id: String,
9794}
9795
9796#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9797#[serde(rename_all = "camelCase")]
9798pub struct ThreadUnarchiveResponse {
9799 #[serde()]
9800 pub thread: Thread,
9801}
9802
9803#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9804#[serde(rename_all = "camelCase")]
9805pub struct ThreadUnarchivedNotification {
9806 #[serde(rename = "threadId", default)]
9807 pub thread_id: String,
9808}
9809
9810#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9811#[serde(tag = "type", rename_all = "camelCase")]
9812pub enum ThreadUnreadPosition {
9813 #[serde(rename = "threadStart")]
9815 ThreadStart,
9816 Turn {
9818 #[serde(rename = "turnId")]
9819 turn_id: String,
9820 },
9821}
9822
9823#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9828#[serde(tag = "type", rename_all = "camelCase")]
9829#[allow(clippy::large_enum_variant)] pub enum ThreadTimelineEntry {
9831 Item {
9832 item: ThreadItem,
9833 position: u64,
9834 #[serde(rename = "turnId")]
9835 turn_id: String,
9836 },
9837 Realtime {
9838 item: ThreadRealtimeItem,
9839 position: u64,
9840 },
9841 TurnStarted {
9842 position: u64,
9843 #[serde(default, skip_serializing_if = "Option::is_none")]
9844 started_at: Option<i64>,
9845 turn_id: String,
9846 },
9847 TurnCompleted {
9848 #[serde(default, skip_serializing_if = "Option::is_none")]
9849 completed_at: Option<i64>,
9850 #[serde(default, skip_serializing_if = "Option::is_none")]
9851 duration_ms: Option<i64>,
9852 #[serde(default, skip_serializing_if = "Option::is_none")]
9853 error: Option<TurnError>,
9854 position: u64,
9855 #[serde(default, skip_serializing_if = "Option::is_none")]
9856 started_at: Option<i64>,
9857 status: TurnStatus,
9858 turn_id: String,
9859 },
9860}
9861
9862#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9864#[serde(rename_all = "camelCase")]
9865pub struct ThreadTurnsListParams {
9866 #[serde(default, skip_serializing_if = "Option::is_none")]
9867 pub cursor: Option<String>,
9868 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9870 pub items_view: Option<TurnItemsView>,
9871 #[serde(default, skip_serializing_if = "Option::is_none")]
9872 pub limit: Option<u32>,
9873 #[serde(
9874 rename = "sortDirection",
9875 default,
9876 skip_serializing_if = "Option::is_none"
9877 )]
9878 pub sort_direction: Option<SortDirection>,
9879 #[serde(rename = "threadId", default)]
9880 pub thread_id: String,
9881}
9882
9883#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9885#[serde(rename_all = "camelCase")]
9886pub struct ThreadTurnsListResponse {
9887 #[serde(
9888 rename = "backwardsCursor",
9889 default,
9890 skip_serializing_if = "Option::is_none"
9891 )]
9892 pub backwards_cursor: Option<String>,
9893 #[serde(default)]
9894 pub data: Vec<Turn>,
9895 #[serde(
9896 rename = "nextCursor",
9897 default,
9898 skip_serializing_if = "Option::is_none"
9899 )]
9900 pub next_cursor: Option<String>,
9901}
9902
9903#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9904#[serde(rename_all = "camelCase")]
9905pub struct ThreadUnsubscribeParams {
9906 #[serde(rename = "threadId", default)]
9907 pub thread_id: String,
9908}
9909
9910#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9911#[serde(rename_all = "camelCase")]
9912pub struct ThreadUnsubscribeResponse {
9913 #[serde()]
9914 pub status: ThreadUnsubscribeStatus,
9915}
9916
9917#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9918pub enum ThreadUnsubscribeStatus {
9919 #[serde(rename = "notLoaded")]
9920 NotLoaded,
9921 #[serde(rename = "notSubscribed")]
9922 NotSubscribed,
9923 #[serde(rename = "unsubscribed")]
9924 Unsubscribed,
9925}
9926
9927#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9928#[serde(rename_all = "camelCase")]
9929pub struct TokenUsageBreakdown {
9930 #[serde(
9931 rename = "cacheWriteInputTokens",
9932 default,
9933 skip_serializing_if = "Option::is_none"
9934 )]
9935 pub cache_write_input_tokens: Option<i64>,
9936 #[serde(rename = "cachedInputTokens", default)]
9937 pub cached_input_tokens: i64,
9938 #[serde(rename = "inputTokens", default)]
9939 pub input_tokens: i64,
9940 #[serde(rename = "outputTokens", default)]
9941 pub output_tokens: i64,
9942 #[serde(rename = "reasoningOutputTokens", default)]
9943 pub reasoning_output_tokens: i64,
9944 #[serde(rename = "totalTokens", default)]
9945 pub total_tokens: i64,
9946}
9947
9948#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9949#[serde(rename_all = "camelCase")]
9950pub struct Tool {
9951 #[serde(default, skip_serializing_if = "Option::is_none")]
9952 pub _meta: Option<Value>,
9953 #[serde(default, skip_serializing_if = "Option::is_none")]
9954 pub annotations: Option<Value>,
9955 #[serde(default, skip_serializing_if = "Option::is_none")]
9956 pub description: Option<String>,
9957 #[serde(default, skip_serializing_if = "Option::is_none")]
9958 pub icons: Option<Vec<Value>>,
9959 #[serde(rename = "inputSchema", default)]
9960 pub input_schema: Value,
9961 #[serde(default)]
9962 pub name: String,
9963 #[serde(
9964 rename = "outputSchema",
9965 default,
9966 skip_serializing_if = "Option::is_none"
9967 )]
9968 pub output_schema: Option<Value>,
9969 #[serde(default, skip_serializing_if = "Option::is_none")]
9970 pub title: Option<String>,
9971}
9972
9973#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9974#[serde(rename_all = "camelCase")]
9975pub struct ToolRequestUserInputAnswer {
9976 #[serde(default)]
9977 pub answers: Vec<String>,
9978}
9979
9980#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9981#[serde(rename_all = "camelCase")]
9982pub struct ToolRequestUserInputOption {
9983 #[serde(default)]
9984 pub description: String,
9985 #[serde(default)]
9986 pub label: String,
9987}
9988
9989#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9990#[serde(rename_all = "camelCase")]
9991pub struct ToolRequestUserInputParams {
9992 #[serde(
9993 rename = "autoResolutionMs",
9994 default,
9995 skip_serializing_if = "Option::is_none"
9996 )]
9997 pub auto_resolution_ms: Option<i64>,
9998 #[serde(rename = "isBlocking", default)]
9999 pub is_blocking: bool,
10000 #[serde(rename = "itemId", default)]
10001 pub item_id: String,
10002 #[serde(default)]
10003 pub questions: Vec<ToolRequestUserInputQuestion>,
10004 #[serde(rename = "threadId", default)]
10005 pub thread_id: String,
10006 #[serde(rename = "turnId", default)]
10007 pub turn_id: String,
10008}
10009
10010#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10011#[serde(rename_all = "camelCase")]
10012pub struct ToolRequestUserInputQuestion {
10013 #[serde(default)]
10014 pub header: String,
10015 #[serde(default)]
10016 pub id: String,
10017 #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
10018 pub is_other: Option<bool>,
10019 #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
10020 pub is_secret: Option<bool>,
10021 #[serde(default, skip_serializing_if = "Option::is_none")]
10022 pub options: Option<Vec<ToolRequestUserInputOption>>,
10023 #[serde(default)]
10024 pub question: String,
10025}
10026
10027#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10028#[serde(rename_all = "camelCase")]
10029pub struct ToolRequestUserInputResponse {
10030 #[serde(default)]
10031 pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
10032}
10033
10034#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10035#[serde(rename_all = "camelCase")]
10036pub struct ToolsV2 {
10037 #[serde(default, skip_serializing_if = "Option::is_none")]
10038 pub web_search: Option<WebSearchToolConfig>,
10039}
10040
10041#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10042#[serde(rename_all = "camelCase")]
10043pub struct Turn {
10044 #[serde(
10045 rename = "completedAt",
10046 default,
10047 skip_serializing_if = "Option::is_none"
10048 )]
10049 pub completed_at: Option<i64>,
10050 #[serde(
10051 rename = "durationMs",
10052 default,
10053 skip_serializing_if = "Option::is_none"
10054 )]
10055 pub duration_ms: Option<i64>,
10056 #[serde(default, skip_serializing_if = "Option::is_none")]
10057 pub error: Option<TurnError>,
10058 #[serde(default)]
10059 pub id: String,
10060 #[serde(default)]
10061 pub items: Vec<ThreadItem>,
10062 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
10063 pub items_view: Option<Value>,
10064 #[serde(
10068 rename = "rootTurnId",
10069 default,
10070 skip_serializing_if = "Option::is_none"
10071 )]
10072 pub root_turn_id: Option<String>,
10073 #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
10074 pub started_at: Option<i64>,
10075 #[serde()]
10076 pub status: TurnStatus,
10077}
10078
10079#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10080#[serde(rename_all = "camelCase")]
10081pub struct TurnCompletedNotification {
10082 #[serde(rename = "threadId", default)]
10083 pub thread_id: String,
10084 #[serde()]
10085 pub turn: Turn,
10086}
10087
10088#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10089#[serde(rename_all = "camelCase")]
10090pub struct TurnDiffUpdatedNotification {
10091 #[serde(default)]
10092 pub diff: String,
10093 #[serde(rename = "threadId", default)]
10094 pub thread_id: String,
10095 #[serde(rename = "turnId", default)]
10096 pub turn_id: String,
10097}
10098
10099#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10100#[serde(rename_all = "camelCase")]
10101pub struct TurnError {
10102 #[serde(
10103 rename = "additionalDetails",
10104 default,
10105 skip_serializing_if = "Option::is_none"
10106 )]
10107 pub additional_details: Option<String>,
10108 #[serde(
10109 rename = "codexErrorInfo",
10110 default,
10111 skip_serializing_if = "Option::is_none"
10112 )]
10113 pub codex_error_info: Option<CodexErrorInfo>,
10114 #[serde(default)]
10115 pub message: String,
10116 #[serde(default, skip_serializing_if = "Option::is_none")]
10119 pub misalignment: Option<MisalignmentErrorDetails>,
10120}
10121
10122#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10123#[serde(rename_all = "camelCase")]
10124pub struct TurnInterruptParams {
10125 #[serde(rename = "threadId", default)]
10126 pub thread_id: String,
10127 #[serde(rename = "turnId", default)]
10128 pub turn_id: String,
10129}
10130
10131#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10132#[serde(rename_all = "camelCase")]
10133pub struct TurnInterruptResponse {
10134 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
10135 pub extra: serde_json::Map<String, Value>,
10136}
10137
10138#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
10139pub enum TurnItemsView {
10140 #[serde(rename = "notLoaded")]
10141 NotLoaded,
10142 #[serde(rename = "summary")]
10143 Summary,
10144 #[serde(rename = "full")]
10145 Full,
10146}
10147
10148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10149#[serde(rename_all = "camelCase")]
10150pub struct TurnModerationMetadataNotification {
10151 #[serde(default)]
10152 pub metadata: Value,
10153 #[serde(rename = "threadId", default)]
10154 pub thread_id: String,
10155 #[serde(rename = "turnId", default)]
10156 pub turn_id: String,
10157}
10158
10159#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10160#[serde(rename_all = "camelCase")]
10161pub struct TurnPlanStep {
10162 #[serde()]
10163 pub status: TurnPlanStepStatus,
10164 #[serde(default)]
10165 pub step: String,
10166}
10167
10168#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10169pub enum TurnPlanStepStatus {
10170 #[serde(rename = "pending")]
10171 Pending,
10172 #[serde(rename = "inProgress")]
10173 InProgress,
10174 #[serde(rename = "completed")]
10175 Completed,
10176}
10177
10178#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10179#[serde(rename_all = "camelCase")]
10180pub struct TurnPlanUpdatedNotification {
10181 #[serde(default, skip_serializing_if = "Option::is_none")]
10182 pub explanation: Option<String>,
10183 #[serde(default)]
10184 pub plan: Vec<TurnPlanStep>,
10185 #[serde(rename = "threadId", default)]
10186 pub thread_id: String,
10187 #[serde(rename = "turnId", default)]
10188 pub turn_id: String,
10189}
10190
10191#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10192#[serde(rename_all = "camelCase")]
10193pub struct TurnStartParams {
10194 #[serde(
10195 rename = "approvalPolicy",
10196 default,
10197 skip_serializing_if = "Option::is_none"
10198 )]
10199 pub approval_policy: Option<AskForApproval>,
10200 #[serde(
10201 rename = "approvalsReviewer",
10202 default,
10203 skip_serializing_if = "Option::is_none"
10204 )]
10205 pub approvals_reviewer: Option<ApprovalsReviewer>,
10206 #[serde(
10207 rename = "clientUserMessageId",
10208 default,
10209 skip_serializing_if = "Option::is_none"
10210 )]
10211 pub client_user_message_id: Option<String>,
10212 #[serde(default, skip_serializing_if = "Option::is_none")]
10213 pub cwd: Option<String>,
10214 #[serde(
10217 rename = "disabledPluginIds",
10218 default,
10219 skip_serializing_if = "Option::is_none"
10220 )]
10221 pub disabled_plugin_ids: Option<Vec<String>>,
10222 #[serde(default, skip_serializing_if = "Option::is_none")]
10223 pub effort: Option<ReasoningEffort>,
10224 #[serde(default)]
10225 pub input: Vec<UserInput>,
10226 #[serde(default, skip_serializing_if = "Option::is_none")]
10227 pub model: Option<String>,
10228 #[serde(
10229 rename = "outputSchema",
10230 default,
10231 skip_serializing_if = "Option::is_none"
10232 )]
10233 pub output_schema: Option<Value>,
10234 #[serde(
10238 rename = "parentTurnId",
10239 default,
10240 skip_serializing_if = "Option::is_none"
10241 )]
10242 pub parent_turn_id: Option<String>,
10243 #[serde(default, skip_serializing_if = "Option::is_none")]
10244 pub personality: Option<Personality>,
10245 #[serde(
10250 rename = "rootTurnId",
10251 default,
10252 skip_serializing_if = "Option::is_none"
10253 )]
10254 pub root_turn_id: Option<String>,
10255 #[serde(
10256 rename = "sandboxPolicy",
10257 default,
10258 skip_serializing_if = "Option::is_none"
10259 )]
10260 pub sandbox_policy: Option<SandboxPolicy>,
10261 #[serde(
10262 rename = "serviceTier",
10263 default,
10264 skip_serializing_if = "Option::is_none"
10265 )]
10266 pub service_tier: Option<String>,
10267 #[serde(
10270 rename = "serviceTierForTurn",
10271 default,
10272 skip_serializing_if = "Option::is_none"
10273 )]
10274 pub service_tier_for_turn: Option<String>,
10275 #[serde(default, skip_serializing_if = "Option::is_none")]
10276 pub summary: Option<ReasoningSummary>,
10277 #[serde(rename = "threadId", default)]
10278 pub thread_id: String,
10279 #[serde(
10282 rename = "toolOutput",
10283 default,
10284 skip_serializing_if = "Option::is_none"
10285 )]
10286 pub tool_output: Option<TurnToolOutput>,
10287 #[serde(
10290 rename = "turnTrigger",
10291 default,
10292 skip_serializing_if = "Option::is_none"
10293 )]
10294 pub turn_trigger: Option<String>,
10295}
10296
10297#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10298#[serde(rename_all = "camelCase")]
10299pub struct TurnStartResponse {
10300 #[serde()]
10301 pub turn: Turn,
10302}
10303
10304#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10305#[serde(rename_all = "camelCase")]
10306pub struct TurnStartedNotification {
10307 #[serde(rename = "threadId", default)]
10308 pub thread_id: String,
10309 #[serde()]
10310 pub turn: Turn,
10311}
10312
10313#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10314pub enum TurnStatus {
10315 #[serde(rename = "completed")]
10316 Completed,
10317 #[serde(rename = "interrupted")]
10318 Interrupted,
10319 #[serde(rename = "failed")]
10320 Failed,
10321 #[serde(rename = "inProgress")]
10322 InProgress,
10323}
10324
10325#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10328#[serde(rename_all = "camelCase")]
10329pub struct TurnToolOutput {
10330 #[serde(default)]
10331 pub name: String,
10332 #[serde(default, skip_serializing_if = "Option::is_none")]
10333 pub namespace: Option<String>,
10334 #[serde()]
10335 pub output: FunctionCallOutputBody,
10336 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
10339 pub retain: bool,
10340}
10341
10342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10343#[serde(rename_all = "camelCase")]
10344pub struct TurnSteerParams {
10345 #[serde(
10346 rename = "clientUserMessageId",
10347 default,
10348 skip_serializing_if = "Option::is_none"
10349 )]
10350 pub client_user_message_id: Option<String>,
10351 #[serde(rename = "expectedTurnId", default)]
10352 pub expected_turn_id: String,
10353 #[serde(default)]
10354 pub input: Vec<UserInput>,
10355 #[serde(rename = "threadId", default)]
10356 pub thread_id: String,
10357}
10358
10359#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10360#[serde(rename_all = "camelCase")]
10361pub struct TurnSteerResponse {
10362 #[serde(rename = "turnId", default)]
10363 pub turn_id: String,
10364}
10365
10366#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10367#[serde(tag = "type", rename_all = "camelCase")]
10368pub enum UserInput {
10369 Text {
10370 text: String,
10371 #[serde(default, skip_serializing_if = "Option::is_none")]
10372 text_elements: Option<Vec<TextElement>>,
10373 },
10374 Image {
10375 #[serde(default, skip_serializing_if = "Option::is_none")]
10376 detail: Option<ImageDetail>,
10377 #[serde(flatten)]
10378 image: UserInputImageReference,
10379 },
10380 #[serde(rename = "localImage")]
10381 LocalImage {
10382 #[serde(default, skip_serializing_if = "Option::is_none")]
10383 detail: Option<ImageDetail>,
10384 path: String,
10385 },
10386 Audio {
10387 #[serde(flatten)]
10388 audio: UserInputAudioReference,
10389 },
10390 #[serde(rename = "localAudio")]
10391 LocalAudio {
10392 path: String,
10393 },
10394 Skill {
10395 name: String,
10396 path: String,
10397 },
10398 Mention {
10399 name: String,
10400 path: String,
10401 },
10402}
10403
10404#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10410#[serde(untagged)]
10411pub enum UserInputImageReference {
10412 Inline {
10413 url: String,
10414 },
10415 File {
10416 #[serde(rename = "fileId")]
10417 file_id: String,
10418 },
10419}
10420
10421#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10426#[serde(untagged)]
10427pub enum UserInputAudioReference {
10428 Inline {
10429 url: String,
10430 },
10431 File {
10432 #[serde(rename = "fileId")]
10433 file_id: String,
10434 },
10435}
10436
10437#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10438pub enum Verbosity {
10439 #[serde(rename = "low")]
10440 Low,
10441 #[serde(rename = "medium")]
10442 Medium,
10443 #[serde(rename = "high")]
10444 High,
10445}
10446
10447#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10448#[serde(rename_all = "camelCase")]
10449pub struct WarningNotification {
10450 #[serde(default)]
10451 pub message: String,
10452 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
10453 pub thread_id: Option<String>,
10454}
10455
10456#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10457#[serde(tag = "type", rename_all = "camelCase")]
10458pub enum WebSearchAction {
10459 Search {
10460 #[serde(default, skip_serializing_if = "Option::is_none")]
10461 queries: Option<Vec<String>>,
10462 #[serde(default, skip_serializing_if = "Option::is_none")]
10463 query: Option<String>,
10464 },
10465 #[serde(rename = "openPage")]
10466 OpenPage {
10467 #[serde(default, skip_serializing_if = "Option::is_none")]
10468 url: Option<String>,
10469 },
10470 #[serde(rename = "findInPage")]
10471 FindInPage {
10472 #[serde(default, skip_serializing_if = "Option::is_none")]
10473 pattern: Option<String>,
10474 #[serde(default, skip_serializing_if = "Option::is_none")]
10475 url: Option<String>,
10476 },
10477 Other,
10478}
10479
10480#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10481pub enum WebSearchContextSize {
10482 #[serde(rename = "low")]
10483 Low,
10484 #[serde(rename = "medium")]
10485 Medium,
10486 #[serde(rename = "high")]
10487 High,
10488}
10489
10490#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10491#[serde(rename_all = "camelCase")]
10492pub struct WebSearchLocation {
10493 #[serde(default, skip_serializing_if = "Option::is_none")]
10494 pub city: Option<String>,
10495 #[serde(default, skip_serializing_if = "Option::is_none")]
10496 pub country: Option<String>,
10497 #[serde(default, skip_serializing_if = "Option::is_none")]
10498 pub region: Option<String>,
10499 #[serde(default, skip_serializing_if = "Option::is_none")]
10500 pub timezone: Option<String>,
10501}
10502
10503#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10504pub enum WebSearchMode {
10505 #[serde(rename = "disabled")]
10506 Disabled,
10507 #[serde(rename = "cached")]
10508 Cached,
10509 #[serde(rename = "indexed")]
10510 Indexed,
10511 #[serde(rename = "live")]
10512 Live,
10513}
10514
10515#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10518pub enum WebSearchProvider {
10519 #[serde(rename = "standalone")]
10520 Standalone,
10521 #[serde(rename = "search_mcp")]
10522 SearchMcp,
10523}
10524
10525#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10526#[serde(rename_all = "camelCase")]
10527pub struct WebSearchToolConfig {
10528 #[serde(default, skip_serializing_if = "Option::is_none")]
10529 pub allowed_domains: Option<Vec<String>>,
10530 #[serde(default, skip_serializing_if = "Option::is_none")]
10531 pub context_size: Option<WebSearchContextSize>,
10532 #[serde(default, skip_serializing_if = "Option::is_none")]
10533 pub location: Option<WebSearchLocation>,
10534}
10535
10536#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10537pub enum WindowsSandboxReadiness {
10538 #[serde(rename = "ready")]
10539 Ready,
10540 #[serde(rename = "notConfigured")]
10541 NotConfigured,
10542 #[serde(rename = "updateRequired")]
10543 UpdateRequired,
10544}
10545
10546#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10547#[serde(rename_all = "camelCase")]
10548pub struct WindowsSandboxReadinessResponse {
10549 #[serde()]
10550 pub status: WindowsSandboxReadiness,
10551}
10552
10553#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10554#[serde(rename_all = "camelCase")]
10555pub struct WindowsSandboxSetupCompletedNotification {
10556 #[serde(default, skip_serializing_if = "Option::is_none")]
10557 pub error: Option<String>,
10558 #[serde()]
10559 pub mode: WindowsSandboxSetupMode,
10560 #[serde(default)]
10561 pub success: bool,
10562}
10563
10564#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10565pub enum WindowsSandboxSetupMode {
10566 #[serde(rename = "elevated")]
10567 Elevated,
10568 #[serde(rename = "unelevated")]
10569 Unelevated,
10570}
10571
10572#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10576pub enum WindowsSandboxImplementation {
10577 #[serde(rename = "elevated")]
10578 Elevated,
10579 #[serde(rename = "unelevated")]
10580 Unelevated,
10581 #[serde(rename = "mxc")]
10582 Mxc,
10583}
10584
10585#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10586#[serde(rename_all = "camelCase")]
10587pub struct WindowsSandboxSetupStartParams {
10588 #[serde(default, skip_serializing_if = "Option::is_none")]
10589 pub cwd: Option<AbsolutePathBuf>,
10590 #[serde()]
10591 pub mode: WindowsSandboxSetupMode,
10592}
10593
10594#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10595#[serde(rename_all = "camelCase")]
10596pub struct WindowsSandboxSetupStartResponse {
10597 #[serde(default)]
10598 pub started: bool,
10599}
10600
10601#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10602#[serde(rename_all = "camelCase")]
10603pub struct WindowsWorldWritableWarningNotification {
10604 #[serde(rename = "extraCount", default)]
10605 pub extra_count: i64,
10606 #[serde(rename = "failedScan", default)]
10607 pub failed_scan: bool,
10608 #[serde(rename = "samplePaths", default)]
10609 pub sample_paths: Vec<String>,
10610}
10611
10612#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10613#[serde(rename_all = "camelCase")]
10614pub struct WorkspaceMessage {
10615 #[serde(
10616 rename = "archivedAt",
10617 default,
10618 skip_serializing_if = "Option::is_none"
10619 )]
10620 pub archived_at: Option<i64>,
10621 #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
10622 pub created_at: Option<i64>,
10623 #[serde(rename = "messageBody", default)]
10624 pub message_body: String,
10625 #[serde(rename = "messageId", default)]
10626 pub message_id: String,
10627 #[serde(rename = "messageType")]
10628 pub message_type: WorkspaceMessageType,
10629}
10630
10631#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10632pub enum WorkspaceMessageType {
10633 #[serde(rename = "headline")]
10634 Headline,
10635 #[serde(rename = "announcement")]
10636 Announcement,
10637 #[serde(rename = "unknown")]
10638 Unknown,
10639}
10640
10641#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10642pub enum WriteStatus {
10643 #[serde(rename = "ok")]
10644 Ok,
10645 #[serde(rename = "okOverridden")]
10646 OkOverridden,
10647}