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