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