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