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