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