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