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