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