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