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)]
2325#[serde(rename_all = "camelCase")]
2326pub struct FeedbackUploadParams {
2327 #[serde(default)]
2328 pub classification: String,
2329 #[serde(
2330 rename = "extraLogFiles",
2331 default,
2332 skip_serializing_if = "Option::is_none"
2333 )]
2334 pub extra_log_files: Option<Vec<String>>,
2335 #[serde(
2336 rename = "includeLogs",
2337 default,
2338 skip_serializing_if = "Option::is_none"
2339 )]
2340 pub include_logs: Option<bool>,
2341 #[serde(default, skip_serializing_if = "Option::is_none")]
2342 pub reason: Option<String>,
2343 #[serde(default, skip_serializing_if = "Option::is_none")]
2344 pub tags: Option<std::collections::BTreeMap<String, String>>,
2345 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
2346 pub thread_id: Option<String>,
2347}
2348
2349#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2350#[serde(rename_all = "camelCase")]
2351pub struct FeedbackUploadResponse {
2352 #[serde(rename = "threadId", default)]
2353 pub thread_id: String,
2354 #[serde(
2358 rename = "promptHash",
2359 default,
2360 skip_serializing_if = "Option::is_none"
2361 )]
2362 pub prompt_hash: Option<String>,
2363}
2364
2365#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2366#[serde(tag = "type", rename_all = "camelCase")]
2367pub enum FileChange {
2368 Add {
2369 content: String,
2370 },
2371 Delete {
2372 content: String,
2373 },
2374 Update {
2375 #[serde(default, skip_serializing_if = "Option::is_none")]
2376 move_path: Option<String>,
2377 unified_diff: String,
2378 },
2379}
2380
2381#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
2382pub enum FileChangeApprovalDecision {
2383 #[serde(rename = "accept")]
2384 Accept,
2385 #[serde(rename = "acceptForSession")]
2386 AcceptForSession,
2387 #[serde(rename = "decline")]
2388 Decline,
2389 #[serde(rename = "cancel")]
2390 Cancel,
2391}
2392
2393#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2394#[serde(rename_all = "camelCase")]
2395pub struct FileChangeOutputDeltaNotification {
2396 #[serde(default)]
2397 pub delta: String,
2398 #[serde(rename = "itemId", default)]
2399 pub item_id: String,
2400 #[serde(rename = "threadId", default)]
2401 pub thread_id: String,
2402 #[serde(rename = "turnId", default)]
2403 pub turn_id: String,
2404}
2405
2406#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2407#[serde(rename_all = "camelCase")]
2408pub struct FileChangePatchUpdatedNotification {
2409 #[serde(default)]
2410 pub changes: Vec<FileUpdateChange>,
2411 #[serde(rename = "itemId", default)]
2412 pub item_id: String,
2413 #[serde(rename = "threadId", default)]
2414 pub thread_id: String,
2415 #[serde(rename = "turnId", default)]
2416 pub turn_id: String,
2417}
2418
2419#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2420#[serde(rename_all = "camelCase")]
2421pub struct FileChangeRequestApprovalParams {
2422 #[serde(rename = "grantRoot", default, skip_serializing_if = "Option::is_none")]
2423 pub grant_root: Option<String>,
2424 #[serde(rename = "itemId", default)]
2425 pub item_id: String,
2426 #[serde(default, skip_serializing_if = "Option::is_none")]
2427 pub reason: Option<String>,
2428 #[serde(rename = "startedAtMs", default)]
2429 pub started_at_ms: i64,
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)]
2437#[serde(rename_all = "camelCase")]
2438pub struct FileChangeRequestApprovalResponse {
2439 #[serde()]
2440 pub decision: FileChangeApprovalDecision,
2441}
2442
2443#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2444pub enum FileSystemAccessMode {
2445 #[serde(rename = "read")]
2446 Read,
2447 #[serde(rename = "write")]
2448 Write,
2449 #[serde(rename = "deny")]
2450 Deny,
2451}
2452
2453#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2454#[serde(tag = "type", rename_all = "camelCase")]
2455pub enum FileSystemPath {
2456 Path { path: LegacyAppPathString },
2457 Glob_pattern { pattern: String },
2458 Special { value: FileSystemSpecialPath },
2459}
2460
2461#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2462#[serde(rename_all = "camelCase")]
2463pub struct FileSystemSandboxEntry {
2464 #[serde()]
2465 pub access: FileSystemAccessMode,
2466 #[serde()]
2467 pub path: FileSystemPath,
2468}
2469
2470#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2471#[serde(tag = "kind", rename_all = "camelCase")]
2472pub enum FileSystemSpecialPath {
2473 Root,
2474 Minimal,
2475 ProjectRoots {
2476 #[serde(default, skip_serializing_if = "Option::is_none")]
2477 subpath: Option<LegacyAppPathString>,
2478 },
2479 Tmpdir,
2480 SlashTmp,
2481 Unknown {
2482 path: String,
2483 #[serde(default, skip_serializing_if = "Option::is_none")]
2484 subpath: Option<LegacyAppPathString>,
2485 },
2486}
2487
2488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2489#[serde(rename_all = "camelCase")]
2490pub struct FileUpdateChange {
2491 #[serde(default)]
2492 pub diff: String,
2493 #[serde()]
2494 pub kind: PatchChangeKind,
2495 #[serde(default)]
2496 pub path: String,
2497}
2498
2499#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2500#[serde(untagged)]
2501pub enum ForcedChatgptWorkspaceIds {
2502 Variant0(String),
2503 Variant1(Vec<String>),
2504}
2505
2506#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2507pub enum ForcedLoginMethod {
2508 #[serde(rename = "chatgpt")]
2509 Chatgpt,
2510 #[serde(rename = "api")]
2511 Api,
2512}
2513
2514#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2515#[serde(rename_all = "camelCase")]
2516pub struct FsChangedNotification {
2517 #[serde(rename = "changedPaths", default)]
2518 pub changed_paths: Vec<AbsolutePathBuf>,
2519 #[serde(rename = "watchId", default)]
2520 pub watch_id: String,
2521}
2522
2523#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2524#[serde(rename_all = "camelCase")]
2525pub struct FsCopyParams {
2526 #[serde(rename = "destinationPath", default)]
2527 pub destination_path: Value,
2528 #[serde(default, skip_serializing_if = "Option::is_none")]
2529 pub recursive: Option<bool>,
2530 #[serde(rename = "sourcePath", default)]
2531 pub source_path: Value,
2532}
2533
2534#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2535#[serde(rename_all = "camelCase")]
2536pub struct FsCopyResponse {
2537 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2538 pub extra: serde_json::Map<String, Value>,
2539}
2540
2541#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2542#[serde(rename_all = "camelCase")]
2543pub struct FsCreateDirectoryParams {
2544 #[serde(default)]
2545 pub path: Value,
2546 #[serde(default, skip_serializing_if = "Option::is_none")]
2547 pub recursive: Option<bool>,
2548}
2549
2550#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2551#[serde(rename_all = "camelCase")]
2552pub struct FsCreateDirectoryResponse {
2553 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2554 pub extra: serde_json::Map<String, Value>,
2555}
2556
2557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2558#[serde(rename_all = "camelCase")]
2559pub struct FsGetMetadataParams {
2560 #[serde(default)]
2561 pub path: Value,
2562}
2563
2564#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2565#[serde(rename_all = "camelCase")]
2566pub struct FsGetMetadataResponse {
2567 #[serde(rename = "createdAtMs", default)]
2568 pub created_at_ms: i64,
2569 #[serde(rename = "isDirectory", default)]
2570 pub is_directory: bool,
2571 #[serde(rename = "isFile", default)]
2572 pub is_file: bool,
2573 #[serde(rename = "isSymlink", default)]
2574 pub is_symlink: bool,
2575 #[serde(rename = "modifiedAtMs", default)]
2576 pub modified_at_ms: i64,
2577}
2578
2579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2580#[serde(rename_all = "camelCase")]
2581pub struct FsReadDirectoryEntry {
2582 #[serde(rename = "fileName", default)]
2583 pub file_name: String,
2584 #[serde(rename = "isDirectory", default)]
2585 pub is_directory: bool,
2586 #[serde(rename = "isFile", default)]
2587 pub is_file: bool,
2588}
2589
2590#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2591#[serde(rename_all = "camelCase")]
2592pub struct FsReadDirectoryParams {
2593 #[serde(default)]
2594 pub path: Value,
2595}
2596
2597#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2598#[serde(rename_all = "camelCase")]
2599pub struct FsReadDirectoryResponse {
2600 #[serde(default)]
2601 pub entries: Vec<FsReadDirectoryEntry>,
2602}
2603
2604#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2605#[serde(rename_all = "camelCase")]
2606pub struct FsReadFileParams {
2607 #[serde(default)]
2608 pub path: Value,
2609}
2610
2611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2612#[serde(rename_all = "camelCase")]
2613pub struct FsReadFileResponse {
2614 #[serde(rename = "dataBase64", default)]
2615 pub data_base64: String,
2616}
2617
2618#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2619#[serde(rename_all = "camelCase")]
2620pub struct FsRemoveParams {
2621 #[serde(default, skip_serializing_if = "Option::is_none")]
2622 pub force: Option<bool>,
2623 #[serde(default)]
2624 pub path: Value,
2625 #[serde(default, skip_serializing_if = "Option::is_none")]
2626 pub recursive: Option<bool>,
2627}
2628
2629#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2630#[serde(rename_all = "camelCase")]
2631pub struct FsRemoveResponse {
2632 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2633 pub extra: serde_json::Map<String, Value>,
2634}
2635
2636#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2637#[serde(rename_all = "camelCase")]
2638pub struct FsUnwatchParams {
2639 #[serde(rename = "watchId", default)]
2640 pub watch_id: String,
2641}
2642
2643#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2644#[serde(rename_all = "camelCase")]
2645pub struct FsUnwatchResponse {
2646 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2647 pub extra: serde_json::Map<String, Value>,
2648}
2649
2650#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2651#[serde(rename_all = "camelCase")]
2652pub struct FsWatchParams {
2653 #[serde(default)]
2654 pub path: Value,
2655 #[serde(rename = "watchId", default)]
2656 pub watch_id: String,
2657}
2658
2659#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2660#[serde(rename_all = "camelCase")]
2661pub struct FsWatchResponse {
2662 #[serde(default)]
2663 pub path: Value,
2664}
2665
2666#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2667#[serde(rename_all = "camelCase")]
2668pub struct FsWriteFileParams {
2669 #[serde(rename = "dataBase64", default)]
2670 pub data_base64: String,
2671 #[serde(default)]
2672 pub path: Value,
2673}
2674
2675#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2676#[serde(rename_all = "camelCase")]
2677pub struct FsWriteFileResponse {
2678 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2679 pub extra: serde_json::Map<String, Value>,
2680}
2681
2682#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2683pub enum FuzzyFileSearchMatchType {
2684 #[serde(rename = "file")]
2685 File,
2686 #[serde(rename = "directory")]
2687 Directory,
2688}
2689
2690#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2691#[serde(rename_all = "camelCase")]
2692pub struct FuzzyFileSearchParams {
2693 #[serde(
2694 rename = "cancellationToken",
2695 default,
2696 skip_serializing_if = "Option::is_none"
2697 )]
2698 pub cancellation_token: Option<String>,
2699 #[serde(default)]
2700 pub query: String,
2701 #[serde(default)]
2702 pub roots: Vec<String>,
2703}
2704
2705#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2706#[serde(rename_all = "camelCase")]
2707pub struct FuzzyFileSearchResponse {
2708 #[serde(default)]
2709 pub files: Vec<FuzzyFileSearchResult>,
2710}
2711
2712#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2715#[serde(untagged)]
2716pub enum FunctionCallOutputBody {
2717 Text(String),
2718 Items(Vec<FunctionCallOutputContentItem>),
2719}
2720
2721#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2725#[serde(tag = "type")]
2726pub enum FunctionCallOutputContentItem {
2727 #[serde(rename = "input_text")]
2728 InputText { text: String },
2729 #[serde(rename = "input_image")]
2730 InputImage {
2731 #[serde(default, skip_serializing_if = "Option::is_none")]
2732 detail: Option<ImageDetail>,
2733 #[serde(flatten)]
2734 image: ImageReference,
2735 },
2736 #[serde(rename = "input_audio")]
2737 InputAudio { audio_url: String },
2738 #[serde(rename = "encrypted_content")]
2739 EncryptedContent { encrypted_content: String },
2740}
2741
2742#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2747#[serde(untagged)]
2748pub enum ImageReference {
2749 Inline { image_url: String },
2750 File { file_id: String },
2751}
2752
2753#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2754#[serde(rename_all = "camelCase")]
2755pub struct FuzzyFileSearchResult {
2756 #[serde(default)]
2757 pub file_name: String,
2758 #[serde(default, skip_serializing_if = "Option::is_none")]
2759 pub indices: Option<Vec<i64>>,
2760 #[serde()]
2761 pub match_type: FuzzyFileSearchMatchType,
2762 #[serde(default)]
2763 pub path: String,
2764 #[serde(default)]
2765 pub root: String,
2766 #[serde(default)]
2767 pub score: i64,
2768}
2769
2770#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2771#[serde(rename_all = "camelCase")]
2772pub struct FuzzyFileSearchSessionCompletedNotification {
2773 #[serde(rename = "sessionId", default)]
2774 pub session_id: String,
2775}
2776
2777#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2778#[serde(rename_all = "camelCase")]
2779pub struct FuzzyFileSearchSessionUpdatedNotification {
2780 #[serde(default)]
2781 pub files: Vec<FuzzyFileSearchResult>,
2782 #[serde(default)]
2783 pub query: String,
2784 #[serde(rename = "sessionId", default)]
2785 pub session_id: String,
2786}
2787
2788#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2789#[serde(rename_all = "camelCase")]
2790pub struct GatewayOAuthCancelResponse {}
2791
2792#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2795#[serde(rename_all = "camelCase")]
2796pub struct GatewayOAuthChangedNotification {
2797 #[serde(rename = "authUrl", default, skip_serializing_if = "Option::is_none")]
2800 pub auth_url: Option<String>,
2801 #[serde(default, skip_serializing_if = "Option::is_none")]
2802 pub error: Option<String>,
2803 #[serde(rename = "providerId", default)]
2804 pub provider_id: String,
2805 pub status: GatewayOAuthStatus,
2806}
2807
2808#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2809#[serde(rename_all = "camelCase")]
2810pub struct GatewayOAuthLoginResponse {}
2811
2812#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2815#[serde(rename_all = "camelCase")]
2816pub struct GatewayOAuthReadResponse {
2817 #[serde(default, skip_serializing_if = "Option::is_none")]
2818 pub error: Option<String>,
2819 #[serde(rename = "providerId", default)]
2820 pub provider_id: String,
2821 #[serde(rename = "providerName", default)]
2822 pub provider_name: String,
2823 #[serde(default)]
2826 pub required: bool,
2827 #[serde(default, skip_serializing_if = "Option::is_none")]
2829 pub status: Option<GatewayOAuthStatus>,
2830}
2831
2832#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
2833pub enum GatewayOAuthStatus {
2834 #[serde(rename = "notReady")]
2835 NotReady,
2836 #[serde(rename = "started")]
2837 Started,
2838 #[serde(rename = "succeeded")]
2839 Succeeded,
2840 #[serde(rename = "failed")]
2841 Failed,
2842}
2843
2844#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2845#[serde(rename_all = "camelCase")]
2846pub struct GetAccountParams {
2847 #[serde(
2848 rename = "refreshToken",
2849 default,
2850 skip_serializing_if = "Option::is_none"
2851 )]
2852 pub refresh_token: Option<bool>,
2853}
2854
2855#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
2859#[serde(rename_all = "camelCase")]
2860pub struct GetAccountRateLimitsParams {
2861 #[serde(
2865 rename = "excludeResetCreditDetails",
2866 default,
2867 skip_serializing_if = "std::ops::Not::not"
2868 )]
2869 pub exclude_reset_credit_details: bool,
2870 #[serde(
2874 rename = "supportsLunaReserve",
2875 default,
2876 skip_serializing_if = "std::ops::Not::not"
2877 )]
2878 pub supports_luna_reserve: bool,
2879}
2880
2881#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2882#[serde(rename_all = "camelCase")]
2883pub struct GetAccountRateLimitsResponse {
2884 #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
2885 pub account_id: Option<String>,
2886 #[serde(
2890 rename = "ordinaryUsageAllowed",
2891 default,
2892 skip_serializing_if = "Option::is_none"
2893 )]
2894 pub ordinary_usage_allowed: Option<bool>,
2895 #[serde(
2896 rename = "rateLimitResetCredits",
2897 default,
2898 skip_serializing_if = "Option::is_none"
2899 )]
2900 pub rate_limit_reset_credits: Option<RateLimitResetCreditsSummary>,
2901 #[serde(
2902 rename = "rateLimitUpsell",
2903 default,
2904 skip_serializing_if = "Option::is_none"
2905 )]
2906 pub rate_limit_upsell: Option<Value>,
2907 #[serde(rename = "rateLimits", default)]
2908 pub rate_limits: Value,
2909 #[serde(
2910 rename = "rateLimitsByLimitId",
2911 default,
2912 skip_serializing_if = "Option::is_none"
2913 )]
2914 pub rate_limits_by_limit_id: Option<std::collections::BTreeMap<String, RateLimitSnapshot>>,
2915}
2916
2917#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2918#[serde(rename_all = "camelCase")]
2919pub struct GetAccountResponse {
2920 #[serde(default, skip_serializing_if = "Option::is_none")]
2921 pub account: Option<Account>,
2922 #[serde(rename = "requiresOpenaiAuth", default)]
2923 pub requires_openai_auth: bool,
2924}
2925
2926#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2927#[serde(rename_all = "camelCase")]
2928pub struct GetAccountTokenUsageResponse {
2929 #[serde(
2930 rename = "dailyUsageBuckets",
2931 default,
2932 skip_serializing_if = "Option::is_none"
2933 )]
2934 pub daily_usage_buckets: Option<Vec<AccountTokenUsageDailyBucket>>,
2935 #[serde()]
2936 pub summary: AccountTokenUsageSummary,
2937 #[serde(
2938 rename = "threadUsage",
2939 default,
2940 skip_serializing_if = "Option::is_none"
2941 )]
2942 pub thread_usage: Option<ThreadUsage>,
2943}
2944
2945#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2946#[serde(rename_all = "camelCase")]
2947pub struct GetAccountTokenUsageParams {
2948 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
2949 pub thread_id: Option<String>,
2950}
2951
2952#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2953#[serde(rename_all = "camelCase")]
2954pub struct ThreadUsage {
2955 #[serde(rename = "estimatedUsageCreditsMicros", default)]
2956 pub estimated_usage_credits_micros: i64,
2957 #[serde(
2958 rename = "estimatedUsageUsdMicros",
2959 default,
2960 skip_serializing_if = "Option::is_none"
2961 )]
2962 pub estimated_usage_usd_micros: Option<i64>,
2963 #[serde(default)]
2964 pub groups: Vec<ThreadUsageBreakdownGroup>,
2965 #[serde(rename = "threadId", default)]
2966 pub thread_id: String,
2967}
2968
2969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2970#[serde(rename_all = "camelCase")]
2971pub struct ThreadUsageBreakdownGroup {
2972 #[serde(
2973 rename = "cachedInputTokens",
2974 default,
2975 skip_serializing_if = "Option::is_none"
2976 )]
2977 pub cached_input_tokens: Option<i64>,
2978 #[serde(rename = "estimatedUsageCreditsMicros", default)]
2979 pub estimated_usage_credits_micros: i64,
2980 #[serde(
2981 rename = "inputTokens",
2982 default,
2983 skip_serializing_if = "Option::is_none"
2984 )]
2985 pub input_tokens: Option<i64>,
2986 #[serde(default, skip_serializing_if = "Option::is_none")]
2987 pub model: Option<String>,
2988 #[serde(
2989 rename = "netNewInputTokens",
2990 default,
2991 skip_serializing_if = "Option::is_none"
2992 )]
2993 pub net_new_input_tokens: Option<i64>,
2994 #[serde(
2995 rename = "outputTokens",
2996 default,
2997 skip_serializing_if = "Option::is_none"
2998 )]
2999 pub output_tokens: Option<i64>,
3000 #[serde(
3001 rename = "reasoningEffort",
3002 default,
3003 skip_serializing_if = "Option::is_none"
3004 )]
3005 pub reasoning_effort: Option<String>,
3006 #[serde(default, skip_serializing_if = "Option::is_none")]
3007 pub speed: Option<String>,
3008 #[serde(
3009 rename = "totalTokens",
3010 default,
3011 skip_serializing_if = "Option::is_none"
3012 )]
3013 pub total_tokens: Option<i64>,
3014}
3015
3016#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3021#[serde(untagged)]
3022pub enum GeneratedImageRef {
3023 File {
3024 #[serde(rename = "fileId")]
3025 file_id: String,
3026 },
3027 Inline {
3028 result: String,
3029 },
3030}
3031
3032#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3034pub struct ImageGenerationInputImage {
3035 pub path: AbsolutePathBuf,
3036 pub sha256: String,
3038}
3039
3040#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3041#[serde(tag = "type", rename_all = "camelCase")]
3042pub enum ImageGenerationFailure {
3043 #[serde(rename = "usageLimitExceeded")]
3044 UsageLimitExceeded {
3045 #[serde(rename = "limitId")]
3046 limit_id: String,
3047 #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
3048 resets_at: Option<i64>,
3049 },
3050}
3051
3052#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3053#[serde(rename_all = "lowercase")]
3054pub enum McpServerOauthClientRegistration {
3055 Auto,
3056 Cimd,
3057 Dcr,
3058}
3059
3060#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3061#[serde(rename_all = "camelCase")]
3062pub struct GetWorkspaceMessagesResponse {
3063 #[serde(rename = "featureEnabled", default)]
3064 pub feature_enabled: bool,
3065 #[serde(default)]
3066 pub messages: Vec<WorkspaceMessage>,
3067}
3068
3069#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3070#[serde(rename_all = "camelCase")]
3071pub struct GitInfo {
3072 #[serde(default, skip_serializing_if = "Option::is_none")]
3073 pub branch: Option<String>,
3074 #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
3075 pub origin_url: Option<String>,
3076 #[serde(default, skip_serializing_if = "Option::is_none")]
3077 pub sha: Option<String>,
3078}
3079
3080#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3081#[serde(rename_all = "camelCase")]
3082pub struct GrantedPermissionProfile {
3083 #[serde(
3084 rename = "fileSystem",
3085 default,
3086 skip_serializing_if = "Option::is_none"
3087 )]
3088 pub file_system: Option<AdditionalFileSystemPermissions>,
3089 #[serde(default, skip_serializing_if = "Option::is_none")]
3090 pub network: Option<AdditionalNetworkPermissions>,
3091}
3092
3093#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3094#[serde(rename_all = "camelCase")]
3095pub struct GuardianApprovalReview {
3096 #[serde(default, skip_serializing_if = "Option::is_none")]
3097 pub rationale: Option<String>,
3098 #[serde(rename = "riskLevel", default, skip_serializing_if = "Option::is_none")]
3099 pub risk_level: Option<GuardianRiskLevel>,
3100 #[serde()]
3101 pub status: GuardianApprovalReviewStatus,
3102 #[serde(
3103 rename = "userAuthorization",
3104 default,
3105 skip_serializing_if = "Option::is_none"
3106 )]
3107 pub user_authorization: Option<GuardianUserAuthorization>,
3108}
3109
3110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3111#[serde(tag = "type", rename_all = "camelCase")]
3112pub enum GuardianApprovalReviewAction {
3113 Command {
3114 command: String,
3115 cwd: LegacyAppPathString,
3116 source: GuardianCommandSource,
3117 },
3118 Execve {
3119 argv: Vec<String>,
3120 cwd: AbsolutePathBuf,
3121 program: String,
3122 source: GuardianCommandSource,
3123 },
3124 #[serde(rename = "writeStdin")]
3125 WriteStdin {
3126 #[serde(rename = "approvalId")]
3127 approval_id: String,
3128 cwd: LegacyAppPathString,
3129 #[serde(rename = "processId")]
3130 process_id: String,
3131 stdin: String,
3132 },
3133 #[serde(rename = "applyPatch")]
3134 ApplyPatch {
3135 cwd: LegacyAppPathString,
3136 files: Vec<LegacyAppPathString>,
3137 },
3138 #[serde(rename = "networkAccess")]
3139 NetworkAccess {
3140 host: String,
3141 port: i64,
3142 protocol: NetworkApprovalProtocol,
3143 target: String,
3144 },
3145 #[serde(rename = "mcpToolCall")]
3146 McpToolCall {
3147 #[serde(
3148 rename = "connectorId",
3149 default,
3150 skip_serializing_if = "Option::is_none"
3151 )]
3152 connector_id: Option<String>,
3153 #[serde(
3154 rename = "connectorName",
3155 default,
3156 skip_serializing_if = "Option::is_none"
3157 )]
3158 connector_name: Option<String>,
3159 server: String,
3160 #[serde(rename = "toolName")]
3161 tool_name: String,
3162 #[serde(rename = "toolTitle", default, skip_serializing_if = "Option::is_none")]
3163 tool_title: Option<String>,
3164 },
3165 #[serde(rename = "requestPermissions")]
3166 RequestPermissions {
3167 permissions: RequestPermissionProfile,
3168 #[serde(default, skip_serializing_if = "Option::is_none")]
3169 reason: Option<String>,
3170 },
3171}
3172
3173#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3174pub enum GuardianApprovalReviewStatus {
3175 #[serde(rename = "inProgress")]
3176 InProgress,
3177 #[serde(rename = "approved")]
3178 Approved,
3179 #[serde(rename = "denied")]
3180 Denied,
3181 #[serde(rename = "timedOut")]
3182 TimedOut,
3183 #[serde(rename = "aborted")]
3184 Aborted,
3185}
3186
3187#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3188pub enum GuardianCommandSource {
3189 #[serde(rename = "shell")]
3190 Shell,
3191 #[serde(rename = "unifiedExec")]
3192 UnifiedExec,
3193}
3194
3195#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3196pub enum GuardianRiskLevel {
3197 #[serde(rename = "low")]
3198 Low,
3199 #[serde(rename = "medium")]
3200 Medium,
3201 #[serde(rename = "high")]
3202 High,
3203 #[serde(rename = "critical")]
3204 Critical,
3205}
3206
3207#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3208pub enum GuardianUserAuthorization {
3209 #[serde(rename = "unknown")]
3210 Unknown,
3211 #[serde(rename = "low")]
3212 Low,
3213 #[serde(rename = "medium")]
3214 Medium,
3215 #[serde(rename = "high")]
3216 High,
3217}
3218
3219#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3220#[serde(rename_all = "camelCase")]
3221pub struct GuardianWarningNotification {
3222 #[serde(default)]
3223 pub message: String,
3224 #[serde(rename = "threadId", default)]
3225 pub thread_id: String,
3226}
3227
3228#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3229#[serde(rename_all = "camelCase")]
3230pub struct HookCompletedNotification {
3231 #[serde()]
3232 pub run: HookRunSummary,
3233 #[serde(rename = "threadId", default)]
3234 pub thread_id: String,
3235 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
3236 pub turn_id: Option<String>,
3237}
3238
3239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3240#[serde(rename_all = "camelCase")]
3241pub struct HookErrorInfo {
3242 #[serde(default)]
3243 pub message: String,
3244 #[serde(default)]
3245 pub path: String,
3246}
3247
3248#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3249pub enum HookEventName {
3250 #[serde(rename = "preModelRequest")]
3251 PreModelRequest,
3252 #[serde(rename = "postModelRequest")]
3253 PostModelRequest,
3254 #[serde(rename = "preToolUse")]
3255 PreToolUse,
3256 #[serde(rename = "permissionRequest")]
3257 PermissionRequest,
3258 #[serde(rename = "postToolUse")]
3259 PostToolUse,
3260 #[serde(rename = "preCompact")]
3261 PreCompact,
3262 #[serde(rename = "postCompact")]
3263 PostCompact,
3264 #[serde(rename = "sessionStart")]
3265 SessionStart,
3266 #[serde(rename = "sessionEnd")]
3267 SessionEnd,
3268 #[serde(rename = "userPromptSubmit")]
3269 UserPromptSubmit,
3270 #[serde(rename = "subagentStart")]
3271 SubagentStart,
3272 #[serde(rename = "subagentStop")]
3273 SubagentStop,
3274 #[serde(rename = "stop")]
3275 Stop,
3276 #[serde(rename = "interrupt")]
3277 Interrupt,
3278}
3279
3280#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3281pub enum HookExecutionMode {
3282 #[serde(rename = "sync")]
3283 Sync,
3284 #[serde(rename = "async")]
3285 Async,
3286}
3287
3288#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3289pub enum HookHandlerType {
3290 #[serde(rename = "command")]
3291 Command,
3292 #[serde(rename = "mcpTool")]
3293 McpTool,
3294 #[serde(rename = "prompt")]
3295 Prompt,
3296 #[serde(rename = "agent")]
3297 Agent,
3298}
3299
3300#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3301#[serde(rename_all = "camelCase")]
3302pub struct HookMetadata {
3303 #[serde(
3304 rename = "additionalContextLimit",
3305 default,
3306 skip_serializing_if = "Option::is_none"
3307 )]
3308 pub additional_context_limit: Option<i64>,
3309 #[serde(rename = "async", default, skip_serializing_if = "Option::is_none")]
3310 pub is_async: Option<bool>,
3311 #[serde(default, skip_serializing_if = "Option::is_none")]
3312 pub command: Option<String>,
3313 #[serde(rename = "currentHash", default)]
3314 pub current_hash: String,
3315 #[serde(default, skip_serializing_if = "Option::is_none")]
3317 pub server: Option<String>,
3318 #[serde(default, skip_serializing_if = "Option::is_none")]
3320 pub tool: Option<String>,
3321 #[serde(rename = "displayOrder", default)]
3322 pub display_order: i64,
3323 #[serde(default)]
3324 pub enabled: bool,
3325 #[serde(rename = "eventName")]
3326 pub event_name: HookEventName,
3327 #[serde(
3328 rename = "executionMode",
3329 default,
3330 skip_serializing_if = "Option::is_none"
3331 )]
3332 pub execution_mode: Option<Value>,
3333 #[serde(rename = "handlerType")]
3334 pub handler_type: HookHandlerType,
3335 #[serde(rename = "isManaged", default)]
3336 pub is_managed: bool,
3337 #[serde(default)]
3338 pub key: String,
3339 #[serde(default, skip_serializing_if = "Option::is_none")]
3340 pub matcher: Option<String>,
3341 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
3342 pub plugin_id: Option<String>,
3343 #[serde()]
3344 pub source: HookSource,
3345 #[serde(rename = "sourcePath")]
3346 pub source_path: AbsolutePathBuf,
3347 #[serde(
3348 rename = "statusMessage",
3349 default,
3350 skip_serializing_if = "Option::is_none"
3351 )]
3352 pub status_message: Option<String>,
3353 #[serde(rename = "timeoutSec", default)]
3354 pub timeout_sec: i64,
3355 #[serde(rename = "trustStatus")]
3356 pub trust_status: HookTrustStatus,
3357}
3358
3359#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3360#[serde(rename_all = "camelCase")]
3361pub struct HookMigration {
3362 #[serde(default)]
3363 pub name: String,
3364}
3365
3366#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3367#[serde(rename_all = "camelCase")]
3368pub struct HookOutputEntry {
3369 #[serde()]
3370 pub kind: HookOutputEntryKind,
3371 #[serde(default)]
3372 pub text: String,
3373}
3374
3375#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3376pub enum HookOutputEntryKind {
3377 #[serde(rename = "warning")]
3378 Warning,
3379 #[serde(rename = "stop")]
3380 Stop,
3381 #[serde(rename = "feedback")]
3382 Feedback,
3383 #[serde(rename = "context")]
3384 Context,
3385 #[serde(rename = "error")]
3386 Error,
3387}
3388
3389#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3390#[serde(rename_all = "camelCase")]
3391pub struct HookPromptFragment {
3392 #[serde(rename = "hookRunId", default)]
3393 pub hook_run_id: String,
3394 #[serde(default)]
3395 pub text: String,
3396}
3397
3398#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3399pub enum HookRunStatus {
3400 #[serde(rename = "running")]
3401 Running,
3402 #[serde(rename = "completed")]
3403 Completed,
3404 #[serde(rename = "failed")]
3405 Failed,
3406 #[serde(rename = "blocked")]
3407 Blocked,
3408 #[serde(rename = "stopped")]
3409 Stopped,
3410}
3411
3412#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3413#[serde(rename_all = "camelCase")]
3414pub struct HookRunSummary {
3415 #[serde(
3416 rename = "completedAt",
3417 default,
3418 skip_serializing_if = "Option::is_none"
3419 )]
3420 pub completed_at: Option<i64>,
3421 #[serde(rename = "displayOrder", default)]
3422 pub display_order: i64,
3423 #[serde(
3424 rename = "durationMs",
3425 default,
3426 skip_serializing_if = "Option::is_none"
3427 )]
3428 pub duration_ms: Option<i64>,
3429 #[serde(default)]
3430 pub entries: Vec<HookOutputEntry>,
3431 #[serde(rename = "eventName")]
3432 pub event_name: HookEventName,
3433 #[serde(rename = "executionMode")]
3434 pub execution_mode: HookExecutionMode,
3435 #[serde(rename = "handlerType")]
3436 pub handler_type: HookHandlerType,
3437 #[serde(default)]
3438 pub id: String,
3439 #[serde()]
3440 pub scope: HookScope,
3441 #[serde(default, skip_serializing_if = "Option::is_none")]
3442 pub source: Option<Value>,
3443 #[serde(rename = "sourcePath")]
3444 pub source_path: AbsolutePathBuf,
3445 #[serde(rename = "startedAt", default)]
3446 pub started_at: i64,
3447 #[serde()]
3448 pub status: HookRunStatus,
3449 #[serde(
3450 rename = "statusMessage",
3451 default,
3452 skip_serializing_if = "Option::is_none"
3453 )]
3454 pub status_message: Option<String>,
3455}
3456
3457#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3458pub enum HookScope {
3459 #[serde(rename = "thread")]
3460 Thread,
3461 #[serde(rename = "turn")]
3462 Turn,
3463}
3464
3465#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3466pub enum HookSource {
3467 #[serde(rename = "system")]
3468 System,
3469 #[serde(rename = "user")]
3470 User,
3471 #[serde(rename = "project")]
3472 Project,
3473 #[serde(rename = "mdm")]
3474 Mdm,
3475 #[serde(rename = "sessionFlags")]
3476 SessionFlags,
3477 #[serde(rename = "plugin")]
3478 Plugin,
3479 #[serde(rename = "cloudRequirements")]
3480 CloudRequirements,
3481 #[serde(rename = "cloudManagedConfig")]
3482 CloudManagedConfig,
3483 #[serde(rename = "legacyManagedConfigFile")]
3484 LegacyManagedConfigFile,
3485 #[serde(rename = "legacyManagedConfigMdm")]
3486 LegacyManagedConfigMdm,
3487 #[serde(rename = "unknown")]
3488 Unknown,
3489}
3490
3491#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3492#[serde(rename_all = "camelCase")]
3493pub struct HookStartedNotification {
3494 #[serde()]
3495 pub run: HookRunSummary,
3496 #[serde(rename = "threadId", default)]
3497 pub thread_id: String,
3498 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
3499 pub turn_id: Option<String>,
3500}
3501
3502#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3503pub enum HookTrustStatus {
3504 #[serde(rename = "managed")]
3505 Managed,
3506 #[serde(rename = "untrusted")]
3507 Untrusted,
3508 #[serde(rename = "trusted")]
3509 Trusted,
3510 #[serde(rename = "modified")]
3511 Modified,
3512}
3513
3514#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3515#[serde(rename_all = "camelCase")]
3516pub struct HooksListEntry {
3517 #[serde(default)]
3518 pub cwd: String,
3519 #[serde(default)]
3520 pub errors: Vec<HookErrorInfo>,
3521 #[serde(default)]
3522 pub hooks: Vec<HookMetadata>,
3523 #[serde(default)]
3524 pub warnings: Vec<String>,
3525}
3526
3527#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3528#[serde(rename_all = "camelCase")]
3529pub struct HooksListParams {
3530 #[serde(default, skip_serializing_if = "Option::is_none")]
3531 pub cwds: Option<Vec<String>>,
3532}
3533
3534#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3535#[serde(rename_all = "camelCase")]
3536pub struct HooksListResponse {
3537 #[serde(default)]
3538 pub data: Vec<HooksListEntry>,
3539}
3540
3541#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3542pub enum ImageDetail {
3543 #[serde(rename = "auto")]
3544 Auto,
3545 #[serde(rename = "low")]
3546 Low,
3547 #[serde(rename = "high")]
3548 High,
3549 #[serde(rename = "original")]
3550 Original,
3551}
3552
3553#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3554#[serde(rename_all = "camelCase")]
3555pub struct InitializeCapabilities {
3556 #[serde(
3557 rename = "experimentalApi",
3558 default,
3559 skip_serializing_if = "Option::is_none"
3560 )]
3561 pub experimental_api: Option<bool>,
3562 #[serde(
3566 rename = "explicitGatewayOauth",
3567 default,
3568 skip_serializing_if = "Option::is_none"
3569 )]
3570 pub explicit_gateway_oauth: Option<bool>,
3571 #[serde(default, skip_serializing_if = "Option::is_none")]
3572 pub extensions: Option<Value>,
3573 #[serde(
3574 rename = "mcpServerOpenaiFormElicitation",
3575 default,
3576 skip_serializing_if = "Option::is_none"
3577 )]
3578 pub mcp_server_openai_form_elicitation: Option<bool>,
3579 #[serde(
3580 rename = "optOutNotificationMethods",
3581 default,
3582 skip_serializing_if = "Option::is_none"
3583 )]
3584 pub opt_out_notification_methods: Option<Vec<String>>,
3585 #[serde(
3586 rename = "requestAttestation",
3587 default,
3588 skip_serializing_if = "Option::is_none"
3589 )]
3590 pub request_attestation: Option<bool>,
3591}
3592
3593#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3594#[serde(rename_all = "camelCase")]
3595pub struct InitializeParams {
3596 #[serde(default, skip_serializing_if = "Option::is_none")]
3597 pub capabilities: Option<InitializeCapabilities>,
3598 #[serde(rename = "clientInfo")]
3599 pub client_info: ClientInfo,
3600}
3601
3602#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3603#[serde(rename_all = "camelCase")]
3604pub struct InitializeResponse {
3605 #[serde(rename = "codexHome", default)]
3606 pub codex_home: Value,
3607 #[serde(rename = "platformFamily", default)]
3608 pub platform_family: String,
3609 #[serde(rename = "platformOs", default)]
3610 pub platform_os: String,
3611 #[serde(rename = "userAgent", default)]
3612 pub user_agent: String,
3613}
3614
3615#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
3616pub enum InputModality {
3617 #[serde(rename = "text")]
3618 Text,
3619 #[serde(rename = "image")]
3620 Image,
3621 #[serde(rename = "audio")]
3622 Audio,
3623}
3624
3625#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3626#[serde(rename_all = "camelCase")]
3627pub struct InstalledApp {
3628 #[serde(default)]
3629 pub callable: bool,
3630 #[serde(default)]
3631 pub enabled: bool,
3632 #[serde(default)]
3633 pub id: String,
3634 #[serde(
3635 rename = "runtimeName",
3636 default,
3637 skip_serializing_if = "Option::is_none"
3638 )]
3639 pub runtime_name: Option<String>,
3640}
3641
3642#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3643#[serde(rename_all = "camelCase")]
3644pub struct ItemCompletedNotification {
3645 #[serde(rename = "completedAtMs", default)]
3646 pub completed_at_ms: i64,
3647 #[serde()]
3648 pub item: ThreadItem,
3649 #[serde(rename = "threadId", default)]
3650 pub thread_id: String,
3651 #[serde(rename = "turnId", default)]
3652 pub turn_id: String,
3653}
3654
3655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3656#[serde(rename_all = "camelCase")]
3657pub struct ItemGuardianApprovalReviewCompletedNotification {
3658 #[serde()]
3659 pub action: GuardianApprovalReviewAction,
3660 #[serde(rename = "completedAtMs", default)]
3661 pub completed_at_ms: i64,
3662 #[serde(rename = "decisionSource")]
3663 pub decision_source: AutoReviewDecisionSource,
3664 #[serde()]
3665 pub review: GuardianApprovalReview,
3666 #[serde(rename = "reviewId", default)]
3667 pub review_id: String,
3668 #[serde(rename = "startedAtMs", default)]
3669 pub started_at_ms: i64,
3670 #[serde(
3671 rename = "targetItemId",
3672 default,
3673 skip_serializing_if = "Option::is_none"
3674 )]
3675 pub target_item_id: Option<String>,
3676 #[serde(rename = "threadId", default)]
3677 pub thread_id: String,
3678 #[serde(rename = "turnId", default)]
3679 pub turn_id: String,
3680}
3681
3682#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3683#[serde(rename_all = "camelCase")]
3684pub struct ItemGuardianApprovalReviewStartedNotification {
3685 #[serde()]
3686 pub action: GuardianApprovalReviewAction,
3687 #[serde()]
3688 pub review: GuardianApprovalReview,
3689 #[serde(rename = "reviewId", default)]
3690 pub review_id: String,
3691 #[serde(rename = "startedAtMs", default)]
3692 pub started_at_ms: i64,
3693 #[serde(
3694 rename = "targetItemId",
3695 default,
3696 skip_serializing_if = "Option::is_none"
3697 )]
3698 pub target_item_id: Option<String>,
3699 #[serde(rename = "threadId", default)]
3700 pub thread_id: String,
3701 #[serde(rename = "turnId", default)]
3702 pub turn_id: String,
3703}
3704
3705#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3706#[serde(rename_all = "camelCase")]
3707pub struct ItemStartedNotification {
3708 #[serde()]
3709 pub item: ThreadItem,
3710 #[serde(rename = "startedAtMs", default)]
3711 pub started_at_ms: i64,
3712 #[serde(rename = "threadId", default)]
3713 pub thread_id: String,
3714 #[serde(rename = "turnId", default)]
3715 pub turn_id: String,
3716}
3717
3718#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3719#[serde(rename_all = "camelCase")]
3720pub struct JSONRPCResponse {
3721 #[serde()]
3722 pub id: RequestId,
3723 #[serde(default)]
3724 pub result: Value,
3725}
3726
3727#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
3728#[serde(transparent)]
3729pub struct LegacyAppPathString(pub String);
3730
3731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3732#[serde(rename_all = "camelCase")]
3733pub struct ListMcpServerStatusParams {
3734 #[serde(default, skip_serializing_if = "Option::is_none")]
3735 pub cursor: Option<String>,
3736 #[serde(default, skip_serializing_if = "Option::is_none")]
3737 pub detail: Option<McpServerStatusDetail>,
3738 #[serde(default, skip_serializing_if = "Option::is_none")]
3739 pub limit: Option<i64>,
3740 #[serde(
3743 rename = "serverName",
3744 default,
3745 skip_serializing_if = "Option::is_none"
3746 )]
3747 pub server_name: Option<String>,
3748 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3749 pub thread_id: Option<String>,
3750}
3751
3752#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3753#[serde(rename_all = "camelCase")]
3754pub struct ListMcpServerStatusResponse {
3755 #[serde(default)]
3756 pub data: Vec<McpServerStatus>,
3757 #[serde(
3758 rename = "nextCursor",
3759 default,
3760 skip_serializing_if = "Option::is_none"
3761 )]
3762 pub next_cursor: Option<String>,
3763}
3764
3765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3766#[serde(tag = "type", rename_all = "camelCase")]
3767pub enum LoginAccountParams {
3768 #[serde(rename = "apiKey")]
3769 ApiKey {
3770 #[serde(rename = "apiKey")]
3771 api_key: String,
3772 },
3773 Chatgpt {
3774 #[serde(rename = "appBrand", default, skip_serializing_if = "Option::is_none")]
3775 app_brand: Option<LoginAppBrand>,
3776 #[serde(
3777 rename = "codexStreamlinedLogin",
3778 default,
3779 skip_serializing_if = "Option::is_none"
3780 )]
3781 codex_streamlined_login: Option<bool>,
3782 #[serde(
3783 rename = "useHostedLoginSuccessPage",
3784 default,
3785 skip_serializing_if = "Option::is_none"
3786 )]
3787 use_hosted_login_success_page: Option<bool>,
3788 },
3789 #[serde(rename = "chatgptDeviceCode")]
3790 ChatgptDeviceCode,
3791 #[serde(rename = "chatgptAuthTokens")]
3792 ChatgptAuthTokens {
3793 #[serde(rename = "accessToken")]
3794 access_token: String,
3795 #[serde(rename = "chatgptAccountId")]
3796 chatgpt_account_id: String,
3797 #[serde(
3798 rename = "chatgptPlanType",
3799 default,
3800 skip_serializing_if = "Option::is_none"
3801 )]
3802 chatgpt_plan_type: Option<String>,
3803 },
3804 #[serde(rename = "amazonBedrock")]
3805 AmazonBedrock {
3806 #[serde(rename = "apiKey")]
3807 api_key: String,
3808 region: String,
3809 },
3810 #[serde(rename = "amazonBedrockAccessKeys")]
3811 AmazonBedrockAccessKeys {
3812 #[serde(rename = "accessKeyId")]
3813 access_key_id: String,
3814 region: String,
3815 #[serde(rename = "secretAccessKey")]
3816 secret_access_key: String,
3817 #[serde(
3818 rename = "sessionToken",
3819 default,
3820 skip_serializing_if = "Option::is_none"
3821 )]
3822 session_token: Option<String>,
3823 },
3824}
3825
3826#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3827#[serde(tag = "type", rename_all = "camelCase")]
3828pub enum LoginAccountResponse {
3829 #[serde(rename = "apiKey")]
3830 ApiKey,
3831 Chatgpt {
3832 #[serde(rename = "authUrl")]
3833 auth_url: String,
3834 #[serde(rename = "loginId")]
3835 login_id: String,
3836 },
3837 #[serde(rename = "chatgptDeviceCode")]
3838 ChatgptDeviceCode {
3839 #[serde(rename = "loginId")]
3840 login_id: String,
3841 #[serde(rename = "userCode")]
3842 user_code: String,
3843 #[serde(rename = "verificationUrl")]
3844 verification_url: String,
3845 },
3846 #[serde(rename = "chatgptAuthTokens")]
3847 ChatgptAuthTokens,
3848 #[serde(rename = "amazonBedrock")]
3849 AmazonBedrock,
3850}
3851
3852#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3853pub enum LoginAppBrand {
3854 #[serde(rename = "codex")]
3855 Codex,
3856 #[serde(rename = "chatgpt")]
3857 Chatgpt,
3858}
3859
3860#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3861#[serde(rename_all = "camelCase")]
3862pub struct LogoutAccountResponse {
3863 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
3864 pub extra: serde_json::Map<String, Value>,
3865}
3866
3867#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3868#[serde(rename_all = "camelCase")]
3869pub struct MarketplaceAddParams {
3870 #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
3871 pub ref_name: Option<String>,
3872 #[serde(default)]
3873 pub source: String,
3874 #[serde(
3875 rename = "sparsePaths",
3876 default,
3877 skip_serializing_if = "Option::is_none"
3878 )]
3879 pub sparse_paths: Option<Vec<String>>,
3880}
3881
3882#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3883#[serde(rename_all = "camelCase")]
3884pub struct MarketplaceAddResponse {
3885 #[serde(rename = "alreadyAdded", default)]
3886 pub already_added: bool,
3887 #[serde(rename = "installedRoot")]
3888 pub installed_root: AbsolutePathBuf,
3889 #[serde(rename = "marketplaceName", default)]
3890 pub marketplace_name: String,
3891}
3892
3893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3894#[serde(rename_all = "camelCase")]
3895pub struct MarketplaceInterface {
3896 #[serde(
3897 rename = "displayName",
3898 default,
3899 skip_serializing_if = "Option::is_none"
3900 )]
3901 pub display_name: Option<String>,
3902}
3903
3904#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3905#[serde(rename_all = "camelCase")]
3906pub struct MarketplaceLoadErrorInfo {
3907 #[serde(rename = "marketplacePath")]
3908 pub marketplace_path: AbsolutePathBuf,
3909 #[serde(default)]
3910 pub message: String,
3911}
3912
3913#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3914#[serde(rename_all = "camelCase")]
3915pub struct MarketplaceRemoveParams {
3916 #[serde(rename = "marketplaceName", default)]
3917 pub marketplace_name: String,
3918}
3919
3920#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3921#[serde(rename_all = "camelCase")]
3922pub struct MarketplaceRemoveResponse {
3923 #[serde(
3924 rename = "installedRoot",
3925 default,
3926 skip_serializing_if = "Option::is_none"
3927 )]
3928 pub installed_root: Option<AbsolutePathBuf>,
3929 #[serde(rename = "marketplaceName", default)]
3930 pub marketplace_name: String,
3931}
3932
3933#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3934#[serde(rename_all = "camelCase")]
3935pub struct MarketplaceUpgradeErrorInfo {
3936 #[serde(rename = "marketplaceName", default)]
3937 pub marketplace_name: String,
3938 #[serde(default)]
3939 pub message: String,
3940}
3941
3942#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3943#[serde(rename_all = "camelCase")]
3944pub struct MarketplaceUpgradeParams {
3945 #[serde(
3946 rename = "marketplaceName",
3947 default,
3948 skip_serializing_if = "Option::is_none"
3949 )]
3950 pub marketplace_name: Option<String>,
3951}
3952
3953#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3954#[serde(rename_all = "camelCase")]
3955pub struct MarketplaceUpgradeResponse {
3956 #[serde(default)]
3957 pub errors: Vec<MarketplaceUpgradeErrorInfo>,
3958 #[serde(rename = "selectedMarketplaces", default)]
3959 pub selected_marketplaces: Vec<String>,
3960 #[serde(rename = "upgradedRoots", default)]
3961 pub upgraded_roots: Vec<AbsolutePathBuf>,
3962}
3963
3964#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3965pub enum McpAuthStatus {
3966 #[serde(rename = "unknown")]
3967 Unknown,
3968 #[serde(rename = "unsupported")]
3969 Unsupported,
3970 #[serde(rename = "notLoggedIn")]
3971 NotLoggedIn,
3972 #[serde(rename = "bearerToken")]
3973 BearerToken,
3974 #[serde(rename = "oAuth")]
3975 OAuth,
3976}
3977
3978#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3979pub enum McpElicitationArrayType {
3980 #[serde(rename = "array")]
3981 Array,
3982}
3983
3984#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3985#[serde(rename_all = "camelCase")]
3986pub struct McpElicitationBooleanSchema {
3987 #[serde(default, skip_serializing_if = "Option::is_none")]
3988 pub default: Option<bool>,
3989 #[serde(default, skip_serializing_if = "Option::is_none")]
3990 pub description: Option<String>,
3991 #[serde(default, skip_serializing_if = "Option::is_none")]
3992 pub title: Option<String>,
3993 #[serde(rename = "type")]
3994 pub type_: McpElicitationBooleanType,
3995}
3996
3997#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3998pub enum McpElicitationBooleanType {
3999 #[serde(rename = "boolean")]
4000 Boolean,
4001}
4002
4003#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4004#[serde(rename_all = "camelCase")]
4005pub struct McpElicitationConstOption {
4006 #[serde(rename = "const", default)]
4007 pub const_: String,
4008 #[serde(default)]
4009 pub title: String,
4010}
4011
4012#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4013#[serde(untagged)]
4014pub enum McpElicitationEnumSchema {
4015 McpElicitationSingleSelectEnumSchema(McpElicitationSingleSelectEnumSchema),
4016 McpElicitationMultiSelectEnumSchema(McpElicitationMultiSelectEnumSchema),
4017 McpElicitationLegacyTitledEnumSchema(McpElicitationLegacyTitledEnumSchema),
4018}
4019
4020#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4021#[serde(rename_all = "camelCase")]
4022pub struct McpElicitationLegacyTitledEnumSchema {
4023 #[serde(default, skip_serializing_if = "Option::is_none")]
4024 pub default: Option<String>,
4025 #[serde(default, skip_serializing_if = "Option::is_none")]
4026 pub description: Option<String>,
4027 #[serde(rename = "enum", default)]
4028 pub enum_: Vec<String>,
4029 #[serde(rename = "enumNames", default, skip_serializing_if = "Option::is_none")]
4030 pub enum_names: Option<Vec<String>>,
4031 #[serde(default, skip_serializing_if = "Option::is_none")]
4032 pub title: Option<String>,
4033 #[serde(rename = "type")]
4034 pub type_: McpElicitationStringType,
4035}
4036
4037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4038#[serde(untagged)]
4039pub enum McpElicitationMultiSelectEnumSchema {
4040 McpElicitationUntitledMultiSelectEnumSchema(McpElicitationUntitledMultiSelectEnumSchema),
4041 McpElicitationTitledMultiSelectEnumSchema(McpElicitationTitledMultiSelectEnumSchema),
4042}
4043
4044#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4045#[serde(rename_all = "camelCase")]
4046pub struct McpElicitationNumberSchema {
4047 #[serde(default, skip_serializing_if = "Option::is_none")]
4048 pub default: Option<f64>,
4049 #[serde(default, skip_serializing_if = "Option::is_none")]
4050 pub description: Option<String>,
4051 #[serde(default, skip_serializing_if = "Option::is_none")]
4052 pub maximum: Option<f64>,
4053 #[serde(default, skip_serializing_if = "Option::is_none")]
4054 pub minimum: Option<f64>,
4055 #[serde(default, skip_serializing_if = "Option::is_none")]
4056 pub title: Option<String>,
4057 #[serde(rename = "type")]
4058 pub type_: McpElicitationNumberType,
4059}
4060
4061#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4062pub enum McpElicitationNumberType {
4063 #[serde(rename = "number")]
4064 Number,
4065 #[serde(rename = "integer")]
4066 Integer,
4067}
4068
4069#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4070pub enum McpElicitationObjectType {
4071 #[serde(rename = "object")]
4072 Object,
4073}
4074
4075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4076#[serde(untagged)]
4077pub enum McpElicitationPrimitiveSchema {
4078 McpElicitationEnumSchema(McpElicitationEnumSchema),
4079 McpElicitationStringSchema(McpElicitationStringSchema),
4080 McpElicitationNumberSchema(McpElicitationNumberSchema),
4081 McpElicitationBooleanSchema(McpElicitationBooleanSchema),
4082}
4083
4084#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4085#[serde(rename_all = "camelCase")]
4086pub struct McpElicitationSchema {
4087 #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
4088 pub schema: Option<String>,
4089 #[serde(default)]
4090 pub properties: std::collections::BTreeMap<String, McpElicitationPrimitiveSchema>,
4091 #[serde(default, skip_serializing_if = "Option::is_none")]
4092 pub required: Option<Vec<String>>,
4093 #[serde(rename = "type")]
4094 pub type_: McpElicitationObjectType,
4095}
4096
4097#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4098#[serde(untagged)]
4099pub enum McpElicitationSingleSelectEnumSchema {
4100 McpElicitationUntitledSingleSelectEnumSchema(McpElicitationUntitledSingleSelectEnumSchema),
4101 McpElicitationTitledSingleSelectEnumSchema(McpElicitationTitledSingleSelectEnumSchema),
4102}
4103
4104#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4105pub enum McpElicitationStringFormat {
4106 #[serde(rename = "email")]
4107 Email,
4108 #[serde(rename = "uri")]
4109 Uri,
4110 #[serde(rename = "date")]
4111 Date,
4112 #[serde(rename = "date-time")]
4113 Date_time,
4114}
4115
4116#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4117#[serde(rename_all = "camelCase")]
4118pub struct McpElicitationStringSchema {
4119 #[serde(default, skip_serializing_if = "Option::is_none")]
4120 pub default: Option<String>,
4121 #[serde(default, skip_serializing_if = "Option::is_none")]
4122 pub description: Option<String>,
4123 #[serde(default, skip_serializing_if = "Option::is_none")]
4124 pub format: Option<McpElicitationStringFormat>,
4125 #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
4126 pub max_length: Option<i64>,
4127 #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
4128 pub min_length: Option<i64>,
4129 #[serde(default, skip_serializing_if = "Option::is_none")]
4130 pub title: Option<String>,
4131 #[serde(rename = "type")]
4132 pub type_: McpElicitationStringType,
4133}
4134
4135#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4136pub enum McpElicitationStringType {
4137 #[serde(rename = "string")]
4138 String,
4139}
4140
4141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4142#[serde(rename_all = "camelCase")]
4143pub struct McpElicitationTitledEnumItems {
4144 #[serde(rename = "anyOf", default)]
4145 pub any_of: Vec<McpElicitationConstOption>,
4146}
4147
4148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4149#[serde(rename_all = "camelCase")]
4150pub struct McpElicitationTitledMultiSelectEnumSchema {
4151 #[serde(default, skip_serializing_if = "Option::is_none")]
4152 pub default: Option<Vec<String>>,
4153 #[serde(default, skip_serializing_if = "Option::is_none")]
4154 pub description: Option<String>,
4155 #[serde()]
4156 pub items: McpElicitationTitledEnumItems,
4157 #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4158 pub max_items: Option<i64>,
4159 #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4160 pub min_items: Option<i64>,
4161 #[serde(default, skip_serializing_if = "Option::is_none")]
4162 pub title: Option<String>,
4163 #[serde(rename = "type")]
4164 pub type_: McpElicitationArrayType,
4165}
4166
4167#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4168#[serde(rename_all = "camelCase")]
4169pub struct McpElicitationTitledSingleSelectEnumSchema {
4170 #[serde(default, skip_serializing_if = "Option::is_none")]
4171 pub default: Option<String>,
4172 #[serde(default, skip_serializing_if = "Option::is_none")]
4173 pub description: Option<String>,
4174 #[serde(rename = "oneOf", default)]
4175 pub one_of: Vec<McpElicitationConstOption>,
4176 #[serde(default, skip_serializing_if = "Option::is_none")]
4177 pub title: Option<String>,
4178 #[serde(rename = "type")]
4179 pub type_: McpElicitationStringType,
4180}
4181
4182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4183#[serde(rename_all = "camelCase")]
4184pub struct McpElicitationUntitledEnumItems {
4185 #[serde(rename = "enum", default)]
4186 pub enum_: Vec<String>,
4187 #[serde(rename = "type")]
4188 pub type_: McpElicitationStringType,
4189}
4190
4191#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4192#[serde(rename_all = "camelCase")]
4193pub struct McpElicitationUntitledMultiSelectEnumSchema {
4194 #[serde(default, skip_serializing_if = "Option::is_none")]
4195 pub default: Option<Vec<String>>,
4196 #[serde(default, skip_serializing_if = "Option::is_none")]
4197 pub description: Option<String>,
4198 #[serde()]
4199 pub items: McpElicitationUntitledEnumItems,
4200 #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4201 pub max_items: Option<i64>,
4202 #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4203 pub min_items: Option<i64>,
4204 #[serde(default, skip_serializing_if = "Option::is_none")]
4205 pub title: Option<String>,
4206 #[serde(rename = "type")]
4207 pub type_: McpElicitationArrayType,
4208}
4209
4210#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4211#[serde(rename_all = "camelCase")]
4212pub struct McpElicitationUntitledSingleSelectEnumSchema {
4213 #[serde(default, skip_serializing_if = "Option::is_none")]
4214 pub default: Option<String>,
4215 #[serde(default, skip_serializing_if = "Option::is_none")]
4216 pub description: Option<String>,
4217 #[serde(rename = "enum", default)]
4218 pub enum_: Vec<String>,
4219 #[serde(default, skip_serializing_if = "Option::is_none")]
4220 pub title: Option<String>,
4221 #[serde(rename = "type")]
4222 pub type_: McpElicitationStringType,
4223}
4224
4225#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4226#[serde(rename_all = "camelCase")]
4227pub struct McpResourceReadParams {
4228 #[serde(
4229 rename = "connectorId",
4230 default,
4231 skip_serializing_if = "Option::is_none"
4232 )]
4233 pub connector_id: Option<String>,
4234 #[serde(
4236 rename = "originCallId",
4237 default,
4238 skip_serializing_if = "Option::is_none"
4239 )]
4240 pub origin_call_id: Option<String>,
4241 #[serde(default)]
4242 pub server: String,
4243 #[serde(default, skip_serializing_if = "Option::is_none")]
4245 pub target: Option<McpResourceReadTarget>,
4246 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4247 pub thread_id: Option<String>,
4248 #[serde(default)]
4249 pub uri: String,
4250}
4251
4252#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4254#[serde(rename_all = "camelCase")]
4255pub struct McpResourceReadTarget {
4256 #[serde(rename = "connectorId", default)]
4257 pub connector_id: String,
4258 #[serde(rename = "linkId", default)]
4261 pub link_id: Option<String>,
4262}
4263
4264#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4265#[serde(rename_all = "camelCase")]
4266pub struct McpResourceReadResponse {
4267 #[serde(default)]
4268 pub contents: Vec<ResourceContent>,
4269 #[serde(
4272 rename = "originCallId",
4273 default,
4274 skip_serializing_if = "Option::is_none"
4275 )]
4276 pub origin_call_id: Option<String>,
4277}
4278
4279#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4280pub enum McpServerElicitationAction {
4281 #[serde(rename = "accept")]
4282 Accept,
4283 #[serde(rename = "decline")]
4284 Decline,
4285 #[serde(rename = "cancel")]
4286 Cancel,
4287}
4288
4289#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4290#[serde(tag = "mode", rename_all = "camelCase")]
4291pub enum McpServerElicitationRequestParams {
4292 Form {
4293 #[serde(default, skip_serializing_if = "Option::is_none")]
4294 _meta: Option<Value>,
4295 message: String,
4296 #[serde(rename = "requestedSchema")]
4297 requested_schema: McpElicitationSchema,
4298 },
4299 #[serde(rename = "openai/form")]
4300 OpenaiForm {
4301 #[serde(default, skip_serializing_if = "Option::is_none")]
4302 _meta: Option<Value>,
4303 message: String,
4304 #[serde(rename = "requestedSchema")]
4305 requested_schema: Value,
4306 },
4307 #[serde(rename = "openaiForm")]
4308 OpenAiElicitationForm {
4309 #[serde(default, skip_serializing_if = "Option::is_none")]
4310 _meta: Option<Value>,
4311 message: String,
4312 #[serde(rename = "requestedSchema")]
4313 requested_schema: Value,
4314 },
4315 Url {
4316 #[serde(default, skip_serializing_if = "Option::is_none")]
4317 _meta: Option<Value>,
4318 #[serde(rename = "elicitationId")]
4319 elicitation_id: String,
4320 message: String,
4321 url: String,
4322 },
4323}
4324
4325#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4326#[serde(rename_all = "camelCase")]
4327pub struct McpServerElicitationRequestResponse {
4328 #[serde(default, skip_serializing_if = "Option::is_none")]
4329 pub _meta: Option<Value>,
4330 #[serde()]
4331 pub action: McpServerElicitationAction,
4332 #[serde(default, skip_serializing_if = "Option::is_none")]
4333 pub content: Option<Value>,
4334}
4335
4336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4337#[serde(rename_all = "camelCase")]
4338pub struct McpServerInfo {
4339 #[serde(default, skip_serializing_if = "Option::is_none")]
4340 pub description: Option<String>,
4341 #[serde(default, skip_serializing_if = "Option::is_none")]
4342 pub icons: Option<Vec<Value>>,
4343 #[serde(default)]
4344 pub name: String,
4345 #[serde(default, skip_serializing_if = "Option::is_none")]
4346 pub title: Option<String>,
4347 #[serde(default)]
4348 pub version: String,
4349 #[serde(
4350 rename = "websiteUrl",
4351 default,
4352 skip_serializing_if = "Option::is_none"
4353 )]
4354 pub website_url: Option<String>,
4355}
4356
4357#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4358#[serde(rename_all = "camelCase")]
4359pub struct McpServerMigration {
4360 #[serde(default)]
4361 pub name: String,
4362}
4363
4364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4365#[serde(rename_all = "camelCase")]
4366pub struct McpServerOauthLoginCompletedNotification {
4367 #[serde(default, skip_serializing_if = "Option::is_none")]
4368 pub error: Option<String>,
4369 #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4371 pub login_id: Option<String>,
4372 #[serde(default)]
4373 pub name: String,
4374 #[serde(default)]
4375 pub success: bool,
4376 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4377 pub thread_id: Option<String>,
4378}
4379
4380#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4381#[serde(rename_all = "camelCase")]
4382pub struct McpServerOauthLoginParams {
4383 #[serde(
4384 rename = "clientRegistration",
4385 default,
4386 skip_serializing_if = "Option::is_none"
4387 )]
4388 pub client_registration: Option<McpServerOauthClientRegistration>,
4389 #[serde(default)]
4390 pub name: String,
4391 #[serde(default, skip_serializing_if = "Option::is_none")]
4392 pub scopes: Option<Vec<String>>,
4393 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4394 pub thread_id: Option<String>,
4395 #[serde(
4396 rename = "timeoutSecs",
4397 default,
4398 skip_serializing_if = "Option::is_none"
4399 )]
4400 pub timeout_secs: Option<i64>,
4401}
4402
4403#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4404#[serde(rename_all = "camelCase")]
4405pub struct McpServerOauthLoginResponse {
4406 #[serde(rename = "authorizationUrl", default)]
4407 pub authorization_url: String,
4408 #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4412 pub login_id: Option<String>,
4413}
4414
4415#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4416#[serde(rename_all = "camelCase")]
4417pub struct McpServerRefreshResponse {
4418 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4419 pub extra: serde_json::Map<String, Value>,
4420}
4421
4422#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4423pub enum McpServerStartupFailureReason {
4424 #[serde(rename = "reauthenticationRequired")]
4425 ReauthenticationRequired,
4426}
4427
4428#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4429pub enum McpServerStartupState {
4430 #[serde(rename = "starting")]
4431 Starting,
4432 #[serde(rename = "ready")]
4433 Ready,
4434 #[serde(rename = "failed")]
4435 Failed,
4436 #[serde(rename = "cancelled")]
4437 Cancelled,
4438}
4439
4440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4441#[serde(rename_all = "camelCase")]
4442pub struct McpServerStatus {
4443 #[serde(rename = "authStatus")]
4444 pub auth_status: McpAuthStatus,
4445 #[serde(
4449 rename = "httpOrigin",
4450 default,
4451 skip_serializing_if = "Option::is_none"
4452 )]
4453 pub http_origin: Option<String>,
4454 #[serde(
4456 rename = "runtimeStatus",
4457 default,
4458 skip_serializing_if = "Option::is_none"
4459 )]
4460 pub runtime_status: Option<McpServerConnectionStatus>,
4461 #[serde(default)]
4462 pub name: String,
4463 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
4464 pub plugin_id: Option<String>,
4465 #[serde(rename = "resourceTemplates", default)]
4466 pub resource_templates: Vec<ResourceTemplate>,
4467 #[serde(default)]
4468 pub resources: Vec<Resource>,
4469 #[serde(
4472 rename = "serverCapabilities",
4473 default,
4474 skip_serializing_if = "Option::is_none"
4475 )]
4476 pub server_capabilities: Option<Value>,
4477 #[serde(
4478 rename = "serverInfo",
4479 default,
4480 skip_serializing_if = "Option::is_none"
4481 )]
4482 pub server_info: Option<McpServerInfo>,
4483 #[serde(
4486 rename = "toolListMeta",
4487 default,
4488 skip_serializing_if = "Option::is_none"
4489 )]
4490 pub tool_list_meta: Option<Value>,
4491 #[serde(default)]
4492 pub tools: std::collections::BTreeMap<String, Tool>,
4493 #[serde(
4496 rename = "toolsError",
4497 default,
4498 skip_serializing_if = "Option::is_none"
4499 )]
4500 pub tools_error: Option<String>,
4501}
4502
4503#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4504pub enum McpServerStatusDetail {
4505 #[serde(rename = "full")]
4506 Full,
4507 #[serde(rename = "toolsAndAuthOnly")]
4508 ToolsAndAuthOnly,
4509}
4510
4511#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4512#[serde(rename_all = "camelCase")]
4513pub struct McpServerStatusUpdatedNotification {
4514 #[serde(default, skip_serializing_if = "Option::is_none")]
4515 pub error: Option<String>,
4516 #[serde(
4517 rename = "failureReason",
4518 default,
4519 skip_serializing_if = "Option::is_none"
4520 )]
4521 pub failure_reason: Option<McpServerStartupFailureReason>,
4522 #[serde(default)]
4523 pub name: String,
4524 #[serde()]
4525 pub status: McpServerStartupState,
4526 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4527 pub thread_id: Option<String>,
4528}
4529
4530#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4531#[serde(rename_all = "camelCase")]
4532pub struct McpServerToolCallParams {
4533 #[serde(default, skip_serializing_if = "Option::is_none")]
4534 pub _meta: Option<Value>,
4535 #[serde(default, skip_serializing_if = "Option::is_none")]
4536 pub arguments: Option<Value>,
4537 #[serde(default)]
4538 pub server: String,
4539 #[serde(rename = "threadId", default)]
4540 pub thread_id: String,
4541 #[serde(default)]
4542 pub tool: String,
4543}
4544
4545#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4546#[serde(rename_all = "camelCase")]
4547pub struct McpServerToolCallResponse {
4548 #[serde(default, skip_serializing_if = "Option::is_none")]
4549 pub _meta: Option<Value>,
4550 #[serde(default)]
4551 pub content: Vec<Value>,
4552 #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
4553 pub is_error: Option<bool>,
4554 #[serde(
4555 rename = "structuredContent",
4556 default,
4557 skip_serializing_if = "Option::is_none"
4558 )]
4559 pub structured_content: Option<Value>,
4560}
4561
4562#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
4565#[serde(rename_all = "camelCase")]
4566pub struct McpAppUi {
4567 #[serde(rename = "resourceUri")]
4568 pub resource_uri: String,
4569 #[serde(rename = "preferredModelDisplayMode")]
4570 pub preferred_model_display_mode: McpAppDisplayMode,
4571}
4572
4573#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4574pub enum McpAppDisplayMode {
4575 #[serde(rename = "inline")]
4576 Inline,
4577 #[serde(rename = "fullscreen")]
4578 Fullscreen,
4579}
4580
4581#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4582#[serde(rename_all = "camelCase")]
4583pub struct McpToolCallAppContext {
4584 #[serde(
4585 rename = "actionName",
4586 default,
4587 skip_serializing_if = "Option::is_none"
4588 )]
4589 pub action_name: Option<String>,
4590 #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
4591 pub app_name: Option<String>,
4592 #[serde(rename = "connectorId", default)]
4593 pub connector_id: String,
4594 #[serde(rename = "linkId", default, skip_serializing_if = "Option::is_none")]
4595 pub link_id: Option<String>,
4596 #[serde(
4597 rename = "resourceUri",
4598 default,
4599 skip_serializing_if = "Option::is_none"
4600 )]
4601 pub resource_uri: Option<String>,
4602}
4603
4604#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4605#[serde(rename_all = "camelCase")]
4606pub struct McpToolCallError {
4607 #[serde(default)]
4608 pub message: String,
4609}
4610
4611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4612#[serde(rename_all = "camelCase")]
4613pub struct McpToolCallProgressNotification {
4614 #[serde(rename = "itemId", default)]
4615 pub item_id: String,
4616 #[serde(default)]
4617 pub message: String,
4618 #[serde(rename = "threadId", default)]
4619 pub thread_id: String,
4620 #[serde(rename = "turnId", default)]
4621 pub turn_id: String,
4622}
4623
4624#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4625#[serde(rename_all = "camelCase")]
4626pub struct McpToolCallResult {
4627 #[serde(default, skip_serializing_if = "Option::is_none")]
4628 pub _meta: Option<Value>,
4629 #[serde(default)]
4630 pub content: Vec<Value>,
4631 #[serde(
4632 rename = "structuredContent",
4633 default,
4634 skip_serializing_if = "Option::is_none"
4635 )]
4636 pub structured_content: Option<Value>,
4637}
4638
4639#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4640pub enum McpToolCallStatus {
4641 #[serde(rename = "inProgress")]
4642 InProgress,
4643 #[serde(rename = "completed")]
4644 Completed,
4645 #[serde(rename = "failed")]
4646 Failed,
4647}
4648
4649#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4650#[serde(rename_all = "camelCase")]
4651pub struct MemoryCitation {
4652 #[serde(default)]
4653 pub entries: Vec<MemoryCitationEntry>,
4654 #[serde(rename = "threadIds", default)]
4655 pub thread_ids: Vec<String>,
4656}
4657
4658#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4659#[serde(rename_all = "camelCase")]
4660pub struct MemoryCitationEntry {
4661 #[serde(rename = "lineEnd", default)]
4662 pub line_end: i64,
4663 #[serde(rename = "lineStart", default)]
4664 pub line_start: i64,
4665 #[serde(default)]
4666 pub note: String,
4667 #[serde(default)]
4668 pub path: String,
4669}
4670
4671#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4672pub enum MergeStrategy {
4673 #[serde(rename = "replace")]
4674 Replace,
4675 #[serde(rename = "upsert")]
4676 Upsert,
4677}
4678
4679#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4680pub enum MessagePhase {
4681 #[serde(rename = "commentary")]
4682 Commentary,
4683 #[serde(rename = "partial_answer")]
4686 PartialAnswer,
4687 #[serde(rename = "final_answer")]
4688 FinalAnswer,
4689}
4690
4691#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4692#[serde(rename_all = "camelCase")]
4693pub struct MigrationDetails {
4694 #[serde(default, skip_serializing_if = "Option::is_none")]
4695 pub commands: Option<Vec<CommandMigration>>,
4696 #[serde(default, skip_serializing_if = "Option::is_none")]
4697 pub hooks: Option<Vec<HookMigration>>,
4698 #[serde(
4699 rename = "mcpServers",
4700 default,
4701 skip_serializing_if = "Option::is_none"
4702 )]
4703 pub mcp_servers: Option<Vec<McpServerMigration>>,
4704 #[serde(default, skip_serializing_if = "Option::is_none")]
4705 pub memory: Option<Vec<String>>,
4706 #[serde(default, skip_serializing_if = "Option::is_none")]
4707 pub plugins: Option<Vec<PluginsMigration>>,
4708 #[serde(default, skip_serializing_if = "Option::is_none")]
4709 pub sessions: Option<Vec<SessionMigration>>,
4710 #[serde(default, skip_serializing_if = "Option::is_none")]
4711 pub skills: Option<Vec<SkillMigration>>,
4712 #[serde(default, skip_serializing_if = "Option::is_none")]
4713 pub subagents: Option<Vec<SubagentMigration>>,
4714}
4715
4716#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4719#[serde(rename_all = "camelCase")]
4720pub struct MisalignmentErrorDetails {
4721 #[serde(
4722 rename = "detailedExplanation",
4723 default,
4724 skip_serializing_if = "Option::is_none"
4725 )]
4726 pub detailed_explanation: Option<String>,
4727 #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
4729 pub error_type: Option<String>,
4730 #[serde(
4733 rename = "reviewTarget",
4734 default,
4735 skip_serializing_if = "Option::is_none"
4736 )]
4737 pub review_target: Option<String>,
4738 #[serde(default, skip_serializing_if = "Option::is_none")]
4741 pub steer: Option<MisalignmentSteer>,
4742}
4743
4744#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4746#[serde(rename_all = "camelCase")]
4747pub struct MisalignmentSteer {
4748 #[serde(default)]
4749 pub message: String,
4750}
4751
4752#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4753pub enum ModeKind {
4754 #[serde(rename = "plan")]
4755 Plan,
4756 #[serde(rename = "default")]
4757 Default,
4758}
4759
4760#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4761#[serde(rename_all = "camelCase")]
4762pub struct Model {
4763 #[serde(
4764 rename = "additionalSpeedTiers",
4765 default,
4766 skip_serializing_if = "Option::is_none"
4767 )]
4768 pub additional_speed_tiers: Option<Vec<String>>,
4769 #[serde(
4770 rename = "availabilityNux",
4771 default,
4772 skip_serializing_if = "Option::is_none"
4773 )]
4774 pub availability_nux: Option<ModelAvailabilityNux>,
4775 #[serde(
4777 rename = "availableAccessPrograms",
4778 default,
4779 skip_serializing_if = "Option::is_none"
4780 )]
4781 pub available_access_programs: Option<ModelAccessPrograms>,
4782 #[serde(rename = "defaultReasoningEffort")]
4783 pub default_reasoning_effort: ReasoningEffort,
4784 #[serde(
4785 rename = "defaultServiceTier",
4786 default,
4787 skip_serializing_if = "Option::is_none"
4788 )]
4789 pub default_service_tier: Option<String>,
4790 #[serde(default)]
4791 pub description: String,
4792 #[serde(rename = "displayName", default)]
4793 pub display_name: String,
4794 #[serde(default)]
4795 pub hidden: bool,
4796 #[serde(default)]
4797 pub id: String,
4798 #[serde(
4799 rename = "inputModalities",
4800 default,
4801 skip_serializing_if = "Option::is_none"
4802 )]
4803 pub input_modalities: Option<Vec<InputModality>>,
4804 #[serde(rename = "isDefault", default)]
4805 pub is_default: bool,
4806 #[serde(default)]
4807 pub model: String,
4808 #[serde(
4809 rename = "modelSpecialty",
4810 default,
4811 skip_serializing_if = "Option::is_none"
4812 )]
4813 pub model_specialty: Option<String>,
4814 #[serde(
4815 rename = "multiAgentVersion",
4816 default,
4817 skip_serializing_if = "Option::is_none"
4818 )]
4819 pub multi_agent_version: Option<MultiAgentVersion>,
4820 #[serde(
4821 rename = "serviceTiers",
4822 default,
4823 skip_serializing_if = "Option::is_none"
4824 )]
4825 pub service_tiers: Option<Vec<ModelServiceTier>>,
4826 #[serde(rename = "supportedReasoningEfforts", default)]
4827 pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
4828 #[serde(
4831 rename = "supportsPersonality",
4832 default,
4833 skip_serializing_if = "Option::is_none"
4834 )]
4835 pub supports_personality: Option<bool>,
4836 #[serde(default, skip_serializing_if = "Option::is_none")]
4837 pub upgrade: Option<String>,
4838 #[serde(
4839 rename = "upgradeInfo",
4840 default,
4841 skip_serializing_if = "Option::is_none"
4842 )]
4843 pub upgrade_info: Option<ModelUpgradeInfo>,
4844}
4845
4846#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4848#[serde(rename_all = "camelCase")]
4849pub struct ModelAccessPrograms {
4850 #[serde(default)]
4852 pub cyber: Vec<CyberAccessProgram>,
4853}
4854
4855#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4856#[serde(rename_all = "camelCase")]
4857pub struct ModelAvailabilityNux {
4858 #[serde(default)]
4859 pub message: String,
4860}
4861
4862#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4863#[serde(rename_all = "camelCase")]
4864pub struct ModelListParams {
4865 #[serde(default, skip_serializing_if = "Option::is_none")]
4866 pub cursor: Option<String>,
4867 #[serde(
4868 rename = "includeHidden",
4869 default,
4870 skip_serializing_if = "Option::is_none"
4871 )]
4872 pub include_hidden: Option<bool>,
4873 #[serde(default, skip_serializing_if = "Option::is_none")]
4874 pub limit: Option<i64>,
4875}
4876
4877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4878#[serde(rename_all = "camelCase")]
4879pub struct ModelListResponse {
4880 #[serde(default)]
4881 pub data: Vec<Model>,
4882 #[serde(
4883 rename = "nextCursor",
4884 default,
4885 skip_serializing_if = "Option::is_none"
4886 )]
4887 pub next_cursor: Option<String>,
4888}
4889
4890#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4891#[serde(rename_all = "camelCase")]
4892pub struct ModelProviderCapabilitiesReadParams {
4893 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4894 pub extra: serde_json::Map<String, Value>,
4895}
4896
4897#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4898#[serde(rename_all = "camelCase")]
4899pub struct ModelProviderCapabilitiesReadResponse {
4900 #[serde(rename = "imageGeneration", default)]
4901 pub image_generation: bool,
4902 #[serde(rename = "webSearch", default)]
4903 pub web_search: bool,
4904}
4905
4906#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4907pub enum ModelRerouteReason {
4908 #[serde(rename = "highRiskCyberActivity")]
4909 HighRiskCyberActivity,
4910}
4911
4912#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4913#[serde(rename_all = "camelCase")]
4914pub struct ModelReroutedNotification {
4915 #[serde(rename = "fromModel", default)]
4916 pub from_model: String,
4917 #[serde()]
4918 pub reason: ModelRerouteReason,
4919 #[serde(rename = "threadId", default)]
4920 pub thread_id: String,
4921 #[serde(rename = "toModel", default)]
4922 pub to_model: String,
4923 #[serde(rename = "turnId", default)]
4924 pub turn_id: String,
4925}
4926
4927#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4928#[serde(rename_all = "camelCase")]
4929pub struct ModelSafetyBufferingUpdatedNotification {
4930 #[serde(
4931 rename = "fasterModel",
4932 default,
4933 skip_serializing_if = "Option::is_none"
4934 )]
4935 pub faster_model: Option<String>,
4936 #[serde(default)]
4937 pub model: String,
4938 #[serde(default)]
4939 pub reasons: Vec<String>,
4940 #[serde(rename = "showBufferingUi", default)]
4941 pub show_buffering_ui: bool,
4942 #[serde(rename = "threadId", default)]
4943 pub thread_id: String,
4944 #[serde(rename = "turnId", default)]
4945 pub turn_id: String,
4946 #[serde(rename = "useCases", default)]
4947 pub use_cases: Vec<String>,
4948}
4949
4950#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4951#[serde(rename_all = "camelCase")]
4952pub struct ModelServiceTier {
4953 #[serde(default)]
4954 pub description: String,
4955 #[serde(default)]
4956 pub id: String,
4957 #[serde(default)]
4958 pub name: String,
4959}
4960
4961#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4962#[serde(rename_all = "camelCase")]
4963pub struct ModelUpgradeInfo {
4964 #[serde(
4965 rename = "migrationMarkdown",
4966 default,
4967 skip_serializing_if = "Option::is_none"
4968 )]
4969 pub migration_markdown: Option<String>,
4970 #[serde(default)]
4971 pub model: String,
4972 #[serde(
4975 rename = "retirementAt",
4976 default,
4977 skip_serializing_if = "Option::is_none"
4978 )]
4979 pub retirement_at: Option<i64>,
4980 #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
4981 pub model_link: Option<String>,
4982 #[serde(
4983 rename = "upgradeCopy",
4984 default,
4985 skip_serializing_if = "Option::is_none"
4986 )]
4987 pub upgrade_copy: Option<String>,
4988}
4989
4990#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4991pub enum ModelVerification {
4992 #[serde(rename = "trustedAccessForCyber")]
4993 TrustedAccessForCyber,
4994}
4995
4996#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4997#[serde(rename_all = "camelCase")]
4998pub struct ModelVerificationNotification {
4999 #[serde(rename = "threadId", default)]
5000 pub thread_id: String,
5001 #[serde(rename = "turnId", default)]
5002 pub turn_id: String,
5003 #[serde(default)]
5004 pub verifications: Vec<ModelVerification>,
5005}
5006
5007#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5008#[serde(rename_all = "camelCase")]
5009pub struct ModelsRequirements {
5010 #[serde(rename = "newThread", default, skip_serializing_if = "Option::is_none")]
5011 pub new_thread: Option<NewThreadModelDefaults>,
5012}
5013
5014#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5015pub enum MultiAgentVersion {
5016 #[serde(rename = "disabled")]
5017 Disabled,
5018 #[serde(rename = "v1")]
5019 V1,
5020 #[serde(rename = "v2")]
5021 V2,
5022}
5023
5024#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5025pub enum NetworkAccess {
5026 #[serde(rename = "restricted")]
5027 Restricted,
5028 #[serde(rename = "enabled")]
5029 Enabled,
5030}
5031
5032#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5033#[serde(rename_all = "camelCase")]
5034pub struct NetworkApprovalContext {
5035 #[serde(default)]
5036 pub host: String,
5037 #[serde()]
5038 pub protocol: NetworkApprovalProtocol,
5039}
5040
5041#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5042pub enum NetworkApprovalProtocol {
5043 #[serde(rename = "http")]
5044 Http,
5045 #[serde(rename = "https")]
5046 Https,
5047 #[serde(rename = "socks5Tcp")]
5048 Socks5Tcp,
5049 #[serde(rename = "socks5Udp")]
5050 Socks5Udp,
5051}
5052
5053#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5054#[serde(rename_all = "camelCase")]
5055pub struct NetworkPolicyAmendment {
5056 #[serde()]
5057 pub action: NetworkPolicyRuleAction,
5058 #[serde(default)]
5059 pub host: String,
5060}
5061
5062#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5063pub enum NetworkPolicyRuleAction {
5064 #[serde(rename = "allow")]
5065 Allow,
5066 #[serde(rename = "deny")]
5067 Deny,
5068}
5069
5070#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5071#[serde(rename_all = "camelCase")]
5072pub struct NewThreadModelDefaults {
5073 #[serde(default, skip_serializing_if = "Option::is_none")]
5074 pub model: Option<String>,
5075 #[serde(
5076 rename = "modelReasoningEffort",
5077 default,
5078 skip_serializing_if = "Option::is_none"
5079 )]
5080 pub model_reasoning_effort: Option<ReasoningEffort>,
5081 #[serde(
5082 rename = "serviceTier",
5083 default,
5084 skip_serializing_if = "Option::is_none"
5085 )]
5086 pub service_tier: Option<String>,
5087}
5088
5089#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5090pub enum NonSteerableTurnKind {
5091 #[serde(rename = "review")]
5092 Review,
5093 #[serde(rename = "compact")]
5094 Compact,
5095}
5096
5097#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5098#[serde(rename_all = "camelCase")]
5099pub struct OverriddenMetadata {
5100 #[serde(rename = "effectiveValue", default)]
5101 pub effective_value: Value,
5102 #[serde(default)]
5103 pub message: String,
5104 #[serde(rename = "overridingLayer")]
5105 pub overriding_layer: ConfigLayerMetadata,
5106}
5107
5108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5109#[serde(tag = "type", rename_all = "camelCase")]
5110pub enum ParsedCommand {
5111 Read {
5112 cmd: String,
5113 name: String,
5114 path: String,
5115 },
5116 List_files {
5117 cmd: String,
5118 #[serde(default, skip_serializing_if = "Option::is_none")]
5119 path: Option<String>,
5120 },
5121 Search {
5122 cmd: String,
5123 #[serde(default, skip_serializing_if = "Option::is_none")]
5124 path: Option<String>,
5125 #[serde(default, skip_serializing_if = "Option::is_none")]
5126 query: Option<String>,
5127 },
5128 Unknown {
5129 cmd: String,
5130 },
5131}
5132
5133#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5134pub enum PatchApplyStatus {
5135 #[serde(rename = "inProgress")]
5136 InProgress,
5137 #[serde(rename = "completed")]
5138 Completed,
5139 #[serde(rename = "failed")]
5140 Failed,
5141 #[serde(rename = "declined")]
5142 Declined,
5143}
5144
5145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5146#[serde(tag = "type", rename_all = "camelCase")]
5147pub enum PatchChangeKind {
5148 Add,
5149 Delete,
5150 Update {
5151 #[serde(default, skip_serializing_if = "Option::is_none")]
5152 move_path: Option<String>,
5153 },
5154}
5155
5156#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5157pub enum PermissionGrantScope {
5158 #[serde(rename = "turn")]
5159 Turn,
5160 #[serde(rename = "session")]
5161 Session,
5162}
5163
5164#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5165#[serde(rename_all = "camelCase")]
5166pub struct PermissionProfileListParams {
5167 #[serde(default, skip_serializing_if = "Option::is_none")]
5168 pub cursor: Option<String>,
5169 #[serde(default, skip_serializing_if = "Option::is_none")]
5170 pub cwd: Option<String>,
5171 #[serde(default, skip_serializing_if = "Option::is_none")]
5172 pub limit: Option<i64>,
5173}
5174
5175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5176#[serde(rename_all = "camelCase")]
5177pub struct PermissionProfileListResponse {
5178 #[serde(default)]
5179 pub data: Vec<PermissionProfileSummary>,
5180 #[serde(
5181 rename = "nextCursor",
5182 default,
5183 skip_serializing_if = "Option::is_none"
5184 )]
5185 pub next_cursor: Option<String>,
5186}
5187
5188#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5189#[serde(rename_all = "camelCase")]
5190pub struct PermissionProfileSummary {
5191 #[serde(default)]
5192 pub allowed: bool,
5193 #[serde(default, skip_serializing_if = "Option::is_none")]
5194 pub description: Option<String>,
5195 #[serde(default)]
5196 pub id: String,
5197}
5198
5199#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5200#[serde(rename_all = "camelCase")]
5201pub struct PermissionsRequestApprovalParams {
5202 #[serde()]
5203 pub cwd: LegacyAppPathString,
5204 #[serde(
5205 rename = "environmentId",
5206 default,
5207 skip_serializing_if = "Option::is_none"
5208 )]
5209 pub environment_id: Option<String>,
5210 #[serde(rename = "itemId", default)]
5211 pub item_id: String,
5212 #[serde()]
5213 pub permissions: RequestPermissionProfile,
5214 #[serde(default, skip_serializing_if = "Option::is_none")]
5215 pub reason: Option<String>,
5216 #[serde(rename = "startedAtMs", default)]
5217 pub started_at_ms: i64,
5218 #[serde(rename = "threadId", default)]
5219 pub thread_id: String,
5220 #[serde(rename = "turnId", default)]
5221 pub turn_id: String,
5222}
5223
5224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5225#[serde(rename_all = "camelCase")]
5226pub struct PermissionsRequestApprovalResponse {
5227 #[serde()]
5228 pub permissions: GrantedPermissionProfile,
5229 #[serde(default, skip_serializing_if = "Option::is_none")]
5230 pub scope: Option<Value>,
5231 #[serde(
5232 rename = "strictAutoReview",
5233 default,
5234 skip_serializing_if = "Option::is_none"
5235 )]
5236 pub strict_auto_review: Option<bool>,
5237}
5238
5239#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5244pub enum Personality {
5245 #[serde(rename = "none")]
5246 None,
5247 #[serde(rename = "friendly")]
5248 Friendly,
5249 #[serde(rename = "pragmatic")]
5250 Pragmatic,
5251}
5252
5253#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5254#[serde(rename_all = "camelCase")]
5255pub struct PlanDeltaNotification {
5256 #[serde(default)]
5257 pub delta: String,
5258 #[serde(rename = "itemId", default)]
5259 pub item_id: String,
5260 #[serde(rename = "threadId", default)]
5261 pub thread_id: String,
5262 #[serde(rename = "turnId", default)]
5263 pub turn_id: String,
5264}
5265
5266#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5267pub enum PlanType {
5268 #[serde(rename = "free")]
5269 Free,
5270 #[serde(rename = "go")]
5271 Go,
5272 #[serde(rename = "plus")]
5273 Plus,
5274 #[serde(rename = "pro")]
5275 Pro,
5276 #[serde(rename = "prolite")]
5277 Prolite,
5278 #[serde(rename = "promax")]
5279 Promax,
5280 #[serde(rename = "edu_plus")]
5281 Edu_plus,
5282 #[serde(rename = "edu_pro")]
5283 Edu_pro,
5284 #[serde(rename = "team")]
5285 Team,
5286 #[serde(rename = "self_serve_business_prolite")]
5287 Self_serve_business_prolite,
5288 #[serde(rename = "self_serve_business_usage_based")]
5289 Self_serve_business_usage_based,
5290 #[serde(rename = "business")]
5291 Business,
5292 #[serde(rename = "ent26")]
5293 Ent26,
5294 #[serde(rename = "enterprise_cbp_automation")]
5295 Enterprise_cbp_automation,
5296 #[serde(rename = "enterprise_cbp_usage_based")]
5297 Enterprise_cbp_usage_based,
5298 #[serde(rename = "enterprise")]
5299 Enterprise,
5300 #[serde(rename = "edu")]
5301 Edu,
5302 #[serde(rename = "sci")]
5303 Sci,
5304 #[serde(rename = "sci_plus")]
5305 Sci_plus,
5306 #[serde(rename = "unknown")]
5307 Unknown,
5308}
5309
5310#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5311pub enum PluginAuthPolicy {
5312 #[serde(rename = "ON_INSTALL")]
5313 ON_INSTALL,
5314 #[serde(rename = "ON_USE")]
5315 ON_USE,
5316}
5317
5318#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5319pub enum PluginAvailability {
5320 #[serde(rename = "DISABLED_BY_ADMIN")]
5321 DISABLEDBYADMIN,
5322 AVAILABLE,
5323}
5324
5325#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5326#[serde(rename_all = "camelCase")]
5327pub struct PluginDetail {
5328 #[serde(rename = "appTemplates", default)]
5329 pub app_templates: Vec<AppTemplateSummary>,
5330 #[serde(default)]
5331 pub apps: Vec<AppSummary>,
5332 #[serde(default, skip_serializing_if = "Option::is_none")]
5333 pub description: Option<String>,
5334 #[serde(default)]
5335 pub hooks: Vec<PluginHookSummary>,
5336 #[serde(rename = "marketplaceName", default)]
5337 pub marketplace_name: String,
5338 #[serde(
5339 rename = "marketplacePath",
5340 default,
5341 skip_serializing_if = "Option::is_none"
5342 )]
5343 pub marketplace_path: Option<AbsolutePathBuf>,
5344 #[serde(rename = "mcpServers", default)]
5345 pub mcp_servers: Vec<String>,
5346 #[serde(
5348 rename = "onboardingSkill",
5349 default,
5350 skip_serializing_if = "Option::is_none"
5351 )]
5352 pub onboarding_skill: Option<SkillSummary>,
5353 #[serde(
5354 rename = "scheduledTasks",
5355 default,
5356 skip_serializing_if = "Option::is_none"
5357 )]
5358 pub scheduled_tasks: Option<Vec<ScheduledTaskSummary>>,
5359 #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5360 pub share_url: Option<String>,
5361 #[serde(default)]
5362 pub skills: Vec<SkillSummary>,
5363 #[serde()]
5364 pub summary: PluginSummary,
5365}
5366
5367#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5368pub enum PluginDisabledReason {
5369 #[serde(rename = "disabled_by_admin")]
5370 Disabled_by_admin,
5371 #[serde(rename = "plan_not_eligible")]
5372 Plan_not_eligible,
5373 #[serde(rename = "required_app_unavailable")]
5374 Required_app_unavailable,
5375 #[serde(rename = "unknown")]
5376 Unknown,
5377}
5378
5379#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5380#[serde(rename_all = "camelCase")]
5381pub struct PluginHookSummary {
5382 #[serde(rename = "eventName")]
5383 pub event_name: HookEventName,
5384 #[serde(default)]
5385 pub key: String,
5386}
5387
5388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5389#[serde(rename_all = "camelCase")]
5390pub struct PluginInstallParams {
5391 #[serde(
5392 rename = "installAttemptId",
5393 default,
5394 skip_serializing_if = "Option::is_none"
5395 )]
5396 pub install_attempt_id: Option<String>,
5397 #[serde(
5398 rename = "marketplacePath",
5399 default,
5400 skip_serializing_if = "Option::is_none"
5401 )]
5402 pub marketplace_path: Option<AbsolutePathBuf>,
5403 #[serde(rename = "pluginName", default)]
5404 pub plugin_name: String,
5405 #[serde(
5406 rename = "remoteMarketplaceName",
5407 default,
5408 skip_serializing_if = "Option::is_none"
5409 )]
5410 pub remote_marketplace_name: Option<String>,
5411}
5412
5413#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5414pub enum PluginInstallPolicy {
5415 #[serde(rename = "NOT_AVAILABLE")]
5416 NOT_AVAILABLE,
5417 #[serde(rename = "AVAILABLE")]
5418 AVAILABLE,
5419 #[serde(rename = "INSTALLED_BY_DEFAULT")]
5420 INSTALLED_BY_DEFAULT,
5421}
5422
5423#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5424pub enum PluginInstallPolicySource {
5425 #[serde(rename = "WORKSPACE_SETTING")]
5426 WORKSPACE_SETTING,
5427 #[serde(rename = "IMPLICIT_CANONICAL_APP")]
5428 IMPLICIT_CANONICAL_APP,
5429}
5430
5431#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5432#[serde(rename_all = "camelCase")]
5433pub struct PluginInstallResponse {
5434 #[serde(rename = "appsNeedingAuth", default)]
5435 pub apps_needing_auth: Vec<AppSummary>,
5436 #[serde(rename = "authPolicy")]
5437 pub auth_policy: PluginAuthPolicy,
5438}
5439
5440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5441#[serde(rename_all = "camelCase")]
5442pub struct PluginInstalledParams {
5443 #[serde(default, skip_serializing_if = "Option::is_none")]
5444 pub cwds: Option<Vec<AbsolutePathBuf>>,
5445 #[serde(
5446 rename = "installSuggestionPluginNames",
5447 default,
5448 skip_serializing_if = "Option::is_none"
5449 )]
5450 pub install_suggestion_plugin_names: Option<Vec<String>>,
5451}
5452
5453#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5454#[serde(rename_all = "camelCase")]
5455pub struct PluginInstalledResponse {
5456 #[serde(
5457 rename = "marketplaceLoadErrors",
5458 default,
5459 skip_serializing_if = "Option::is_none"
5460 )]
5461 pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5462 #[serde(default)]
5463 pub marketplaces: Vec<PluginMarketplaceEntry>,
5464}
5465
5466#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5467#[serde(rename_all = "camelCase")]
5468pub struct PluginInterface {
5469 #[serde(
5470 rename = "brandColor",
5471 default,
5472 skip_serializing_if = "Option::is_none"
5473 )]
5474 pub brand_color: Option<String>,
5475 #[serde(default)]
5476 pub capabilities: Vec<String>,
5477 #[serde(default, skip_serializing_if = "Option::is_none")]
5478 pub category: Option<String>,
5479 #[serde(
5480 rename = "composerIcon",
5481 default,
5482 skip_serializing_if = "Option::is_none"
5483 )]
5484 pub composer_icon: Option<AbsolutePathBuf>,
5485 #[serde(
5486 rename = "composerIconUrl",
5487 default,
5488 skip_serializing_if = "Option::is_none"
5489 )]
5490 pub composer_icon_url: Option<String>,
5491 #[serde(
5492 rename = "defaultPrompt",
5493 default,
5494 skip_serializing_if = "Option::is_none"
5495 )]
5496 pub default_prompt: Option<Vec<String>>,
5497 #[serde(
5498 rename = "developerName",
5499 default,
5500 skip_serializing_if = "Option::is_none"
5501 )]
5502 pub developer_name: Option<String>,
5503 #[serde(
5504 rename = "displayName",
5505 default,
5506 skip_serializing_if = "Option::is_none"
5507 )]
5508 pub display_name: Option<String>,
5509 #[serde(default, skip_serializing_if = "Option::is_none")]
5510 pub logo: Option<AbsolutePathBuf>,
5511 #[serde(rename = "logoDark", default, skip_serializing_if = "Option::is_none")]
5512 pub logo_dark: Option<AbsolutePathBuf>,
5513 #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
5514 pub logo_url: Option<String>,
5515 #[serde(
5516 rename = "logoUrlDark",
5517 default,
5518 skip_serializing_if = "Option::is_none"
5519 )]
5520 pub logo_url_dark: Option<String>,
5521 #[serde(
5522 rename = "longDescription",
5523 default,
5524 skip_serializing_if = "Option::is_none"
5525 )]
5526 pub long_description: Option<String>,
5527 #[serde(
5528 rename = "privacyPolicyUrl",
5529 default,
5530 skip_serializing_if = "Option::is_none"
5531 )]
5532 pub privacy_policy_url: Option<String>,
5533 #[serde(rename = "screenshotUrls", default)]
5534 pub screenshot_urls: Vec<String>,
5535 #[serde(default)]
5536 pub screenshots: Vec<AbsolutePathBuf>,
5537 #[serde(
5538 rename = "shortDescription",
5539 default,
5540 skip_serializing_if = "Option::is_none"
5541 )]
5542 pub short_description: Option<String>,
5543 #[serde(
5544 rename = "termsOfServiceUrl",
5545 default,
5546 skip_serializing_if = "Option::is_none"
5547 )]
5548 pub terms_of_service_url: Option<String>,
5549 #[serde(
5550 rename = "websiteUrl",
5551 default,
5552 skip_serializing_if = "Option::is_none"
5553 )]
5554 pub website_url: Option<String>,
5555}
5556
5557#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5558pub enum PluginListMarketplaceKind {
5559 #[serde(rename = "local")]
5560 Local,
5561 #[serde(rename = "vertical")]
5562 Vertical,
5563 #[serde(rename = "workspace-directory")]
5564 Workspace_directory,
5565 #[serde(rename = "shared-with-me")]
5566 Shared_with_me,
5567 #[serde(rename = "created-by-me-remote")]
5568 Created_by_me_remote,
5569}
5570
5571#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5572#[serde(rename_all = "camelCase")]
5573pub struct PluginListParams {
5574 #[serde(default, skip_serializing_if = "Option::is_none")]
5575 pub cwds: Option<Vec<AbsolutePathBuf>>,
5576 #[serde(
5577 rename = "forceRefetch",
5578 default,
5579 skip_serializing_if = "Option::is_none"
5580 )]
5581 pub force_refetch: Option<bool>,
5582 #[serde(
5583 rename = "marketplaceKinds",
5584 default,
5585 skip_serializing_if = "Option::is_none"
5586 )]
5587 pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
5588}
5589
5590#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5591#[serde(rename_all = "camelCase")]
5592pub struct PluginListResponse {
5593 #[serde(
5594 rename = "featuredPluginIds",
5595 default,
5596 skip_serializing_if = "Option::is_none"
5597 )]
5598 pub featured_plugin_ids: Option<Vec<String>>,
5599 #[serde(
5600 rename = "marketplaceLoadErrors",
5601 default,
5602 skip_serializing_if = "Option::is_none"
5603 )]
5604 pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5605 #[serde(default)]
5606 pub marketplaces: Vec<PluginMarketplaceEntry>,
5607}
5608
5609#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5610#[serde(rename_all = "camelCase")]
5611pub struct PluginMarketplaceEntry {
5612 #[serde(default, skip_serializing_if = "Option::is_none")]
5613 pub interface: Option<MarketplaceInterface>,
5614 #[serde(default)]
5615 pub name: String,
5616 #[serde(default, skip_serializing_if = "Option::is_none")]
5617 pub path: Option<AbsolutePathBuf>,
5618 #[serde(default)]
5619 pub plugins: Vec<PluginSummary>,
5620}
5621
5622#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5623#[serde(rename_all = "camelCase")]
5624pub struct PluginReadParams {
5625 #[serde(
5626 rename = "marketplacePath",
5627 default,
5628 skip_serializing_if = "Option::is_none"
5629 )]
5630 pub marketplace_path: Option<AbsolutePathBuf>,
5631 #[serde(rename = "pluginName", default)]
5632 pub plugin_name: String,
5633 #[serde(
5634 rename = "remoteMarketplaceName",
5635 default,
5636 skip_serializing_if = "Option::is_none"
5637 )]
5638 pub remote_marketplace_name: Option<String>,
5639}
5640
5641#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5642#[serde(rename_all = "camelCase")]
5643pub struct PluginReadResponse {
5644 #[serde()]
5645 pub plugin: PluginDetail,
5646}
5647
5648#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5654#[serde(rename_all = "camelCase")]
5655pub struct PluginReconcileChangedPlugin {
5656 #[serde(rename = "hasApps", default)]
5657 pub has_apps: bool,
5658 #[serde(rename = "hasHooks", default)]
5659 pub has_hooks: bool,
5660 #[serde(rename = "hasMcps", default)]
5661 pub has_mcps: bool,
5662 #[serde(rename = "hasSkills", default)]
5665 pub has_skills: bool,
5666 #[serde(default)]
5668 pub id: String,
5669}
5670
5671#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5672#[serde(rename_all = "camelCase")]
5673pub struct PluginReconcileParams {
5674 #[serde(default, skip_serializing_if = "Option::is_none")]
5677 pub reason: Option<String>,
5678}
5679
5680#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5684#[serde(rename_all = "camelCase")]
5685pub struct PluginReconcileResponse {
5686 #[serde(rename = "changedPlugins", default)]
5691 pub changed_plugins: Vec<PluginReconcileChangedPlugin>,
5692 #[serde(rename = "failedMaterializationRemotePluginIds", default)]
5695 pub failed_materialization_remote_plugin_ids: Vec<String>,
5696 #[serde(rename = "failedRemotePluginIds", default)]
5698 pub failed_remote_plugin_ids: Vec<String>,
5699}
5700
5701#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5702#[serde(rename_all = "camelCase")]
5703pub struct PluginShareCheckoutParams {
5704 #[serde(rename = "remotePluginId", default)]
5705 pub remote_plugin_id: String,
5706}
5707
5708#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5709#[serde(rename_all = "camelCase")]
5710pub struct PluginShareCheckoutResponse {
5711 #[serde(rename = "marketplaceName", default)]
5712 pub marketplace_name: String,
5713 #[serde(rename = "marketplacePath")]
5714 pub marketplace_path: AbsolutePathBuf,
5715 #[serde(rename = "pluginId", default)]
5716 pub plugin_id: String,
5717 #[serde(rename = "pluginName", default)]
5718 pub plugin_name: String,
5719 #[serde(rename = "pluginPath")]
5720 pub plugin_path: AbsolutePathBuf,
5721 #[serde(rename = "remotePluginId", default)]
5722 pub remote_plugin_id: String,
5723 #[serde(
5724 rename = "remoteVersion",
5725 default,
5726 skip_serializing_if = "Option::is_none"
5727 )]
5728 pub remote_version: Option<String>,
5729}
5730
5731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5732#[serde(rename_all = "camelCase")]
5733pub struct PluginShareContext {
5734 #[serde(
5735 rename = "canPublishToWorkspace",
5736 default,
5737 skip_serializing_if = "Option::is_none"
5738 )]
5739 pub can_publish_to_workspace: Option<bool>,
5740 #[serde(
5741 rename = "creatorAccountUserId",
5742 default,
5743 skip_serializing_if = "Option::is_none"
5744 )]
5745 pub creator_account_user_id: Option<String>,
5746 #[serde(
5747 rename = "creatorName",
5748 default,
5749 skip_serializing_if = "Option::is_none"
5750 )]
5751 pub creator_name: Option<String>,
5752 #[serde(default, skip_serializing_if = "Option::is_none")]
5753 pub discoverability: Option<PluginShareDiscoverability>,
5754 #[serde(rename = "remotePluginId", default)]
5755 pub remote_plugin_id: String,
5756 #[serde(
5757 rename = "remoteVersion",
5758 default,
5759 skip_serializing_if = "Option::is_none"
5760 )]
5761 pub remote_version: Option<String>,
5762 #[serde(
5763 rename = "sharePrincipals",
5764 default,
5765 skip_serializing_if = "Option::is_none"
5766 )]
5767 pub share_principals: Option<Vec<PluginSharePrincipal>>,
5768 #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5769 pub share_url: Option<String>,
5770}
5771
5772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5773#[serde(rename_all = "camelCase")]
5774pub struct PluginShareDeleteParams {
5775 #[serde(rename = "remotePluginId", default)]
5776 pub remote_plugin_id: String,
5777}
5778
5779#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5780#[serde(rename_all = "camelCase")]
5781pub struct PluginShareDeleteResponse {
5782 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5783 pub extra: serde_json::Map<String, Value>,
5784}
5785
5786#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5787pub enum PluginShareDiscoverability {
5788 #[serde(rename = "LISTED")]
5789 LISTED,
5790 #[serde(rename = "UNLISTED")]
5791 UNLISTED,
5792 #[serde(rename = "PRIVATE")]
5793 PRIVATE,
5794}
5795
5796#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5797#[serde(rename_all = "camelCase")]
5798pub struct PluginShareListItem {
5799 #[serde(
5800 rename = "localPluginPath",
5801 default,
5802 skip_serializing_if = "Option::is_none"
5803 )]
5804 pub local_plugin_path: Option<AbsolutePathBuf>,
5805 #[serde()]
5806 pub plugin: PluginSummary,
5807}
5808
5809#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5810#[serde(rename_all = "camelCase")]
5811pub struct PluginShareListParams {
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, PartialEq, Serialize, Deserialize, Default)]
5817#[serde(rename_all = "camelCase")]
5818pub struct PluginShareListResponse {
5819 #[serde(default)]
5820 pub data: Vec<PluginShareListItem>,
5821}
5822
5823#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5824#[serde(rename_all = "camelCase")]
5825pub struct PluginSharePrincipal {
5826 #[serde(default)]
5827 pub name: String,
5828 #[serde(rename = "principalId", default)]
5829 pub principal_id: String,
5830 #[serde(rename = "principalType")]
5831 pub principal_type: PluginSharePrincipalType,
5832 #[serde()]
5833 pub role: PluginSharePrincipalRole,
5834}
5835
5836#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5837pub enum PluginSharePrincipalRole {
5838 #[serde(rename = "reader")]
5839 Reader,
5840 #[serde(rename = "editor")]
5841 Editor,
5842 #[serde(rename = "owner")]
5843 Owner,
5844}
5845
5846#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5847pub enum PluginSharePrincipalType {
5848 #[serde(rename = "user")]
5849 User,
5850 #[serde(rename = "group")]
5851 Group,
5852 #[serde(rename = "workspace")]
5853 Workspace,
5854}
5855
5856#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5857#[serde(rename_all = "camelCase")]
5858pub struct PluginShareSaveParams {
5859 #[serde(default, skip_serializing_if = "Option::is_none")]
5860 pub discoverability: Option<PluginShareDiscoverability>,
5861 #[serde(rename = "pluginPath")]
5862 pub plugin_path: AbsolutePathBuf,
5863 #[serde(
5864 rename = "remotePluginId",
5865 default,
5866 skip_serializing_if = "Option::is_none"
5867 )]
5868 pub remote_plugin_id: Option<String>,
5869 #[serde(
5870 rename = "shareTargets",
5871 default,
5872 skip_serializing_if = "Option::is_none"
5873 )]
5874 pub share_targets: Option<Vec<PluginShareTarget>>,
5875}
5876
5877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5878#[serde(rename_all = "camelCase")]
5879pub struct PluginShareSaveResponse {
5880 #[serde(
5881 rename = "canPublishToWorkspace",
5882 default,
5883 skip_serializing_if = "Option::is_none"
5884 )]
5885 pub can_publish_to_workspace: Option<bool>,
5886 #[serde(rename = "remotePluginId", default)]
5887 pub remote_plugin_id: String,
5888 #[serde(rename = "shareUrl", default)]
5889 pub share_url: String,
5890}
5891
5892#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5893#[serde(rename_all = "camelCase")]
5894pub struct PluginShareTarget {
5895 #[serde(rename = "principalId", default)]
5896 pub principal_id: String,
5897 #[serde(rename = "principalType")]
5898 pub principal_type: PluginSharePrincipalType,
5899 #[serde()]
5900 pub role: PluginShareTargetRole,
5901}
5902
5903#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5904pub enum PluginShareTargetRole {
5905 #[serde(rename = "reader")]
5906 Reader,
5907 #[serde(rename = "editor")]
5908 Editor,
5909}
5910
5911#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5912pub enum PluginShareUpdateDiscoverability {
5913 #[serde(rename = "UNLISTED")]
5914 UNLISTED,
5915 #[serde(rename = "PRIVATE")]
5916 PRIVATE,
5917 #[serde(rename = "LISTED")]
5918 LISTED,
5919}
5920
5921#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5922#[serde(rename_all = "camelCase")]
5923pub struct PluginShareUpdateTargetsParams {
5924 #[serde()]
5925 pub discoverability: PluginShareUpdateDiscoverability,
5926 #[serde(rename = "remotePluginId", default)]
5927 pub remote_plugin_id: String,
5928 #[serde(rename = "shareTargets", default)]
5929 pub share_targets: Vec<PluginShareTarget>,
5930}
5931
5932#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5933#[serde(rename_all = "camelCase")]
5934pub struct PluginShareUpdateTargetsResponse {
5935 #[serde()]
5936 pub discoverability: PluginShareDiscoverability,
5937 #[serde(default)]
5938 pub principals: Vec<PluginSharePrincipal>,
5939}
5940
5941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5942#[serde(rename_all = "camelCase")]
5943pub struct PluginSkillReadParams {
5944 #[serde(rename = "remoteMarketplaceName", default)]
5945 pub remote_marketplace_name: String,
5946 #[serde(rename = "remotePluginId", default)]
5947 pub remote_plugin_id: String,
5948 #[serde(rename = "skillName", default)]
5949 pub skill_name: String,
5950}
5951
5952#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5953#[serde(rename_all = "camelCase")]
5954pub struct PluginSkillReadResponse {
5955 #[serde(default, skip_serializing_if = "Option::is_none")]
5956 pub contents: Option<String>,
5957}
5958
5959#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5960#[serde(tag = "type", rename_all = "camelCase")]
5961pub enum PluginSource {
5962 Local {
5963 path: AbsolutePathBuf,
5964 },
5965 Git {
5966 #[serde(default, skip_serializing_if = "Option::is_none")]
5967 path: Option<String>,
5968 #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
5969 ref_name: Option<String>,
5970 #[serde(default, skip_serializing_if = "Option::is_none")]
5971 sha: Option<String>,
5972 url: String,
5973 },
5974 Npm {
5975 package: String,
5976 #[serde(default, skip_serializing_if = "Option::is_none")]
5977 registry: Option<String>,
5978 #[serde(default, skip_serializing_if = "Option::is_none")]
5979 version: Option<String>,
5980 },
5981 Remote,
5982}
5983
5984#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5985#[serde(rename_all = "camelCase")]
5986pub struct PluginSummary {
5987 #[serde(rename = "authPolicy")]
5988 pub auth_policy: PluginAuthPolicy,
5989 #[serde(default, skip_serializing_if = "Option::is_none")]
5990 pub availability: Option<Value>,
5991 #[serde(
5992 rename = "disabledReason",
5993 default,
5994 skip_serializing_if = "Option::is_none"
5995 )]
5996 pub disabled_reason: Option<PluginDisabledReason>,
5997 #[serde(
5998 rename = "eligiblePlanTypes",
5999 default,
6000 skip_serializing_if = "Option::is_none"
6001 )]
6002 pub eligible_plan_types: Option<Vec<String>>,
6003 #[serde(default)]
6004 pub enabled: bool,
6005 #[serde(default)]
6006 pub id: String,
6007 #[serde(rename = "installPolicy")]
6008 pub install_policy: PluginInstallPolicy,
6009 #[serde(
6010 rename = "installPolicySource",
6011 default,
6012 skip_serializing_if = "Option::is_none"
6013 )]
6014 pub install_policy_source: Option<PluginInstallPolicySource>,
6015 #[serde(default)]
6016 pub installed: bool,
6017 #[serde(
6018 rename = "installedAt",
6019 default,
6020 skip_serializing_if = "Option::is_none"
6021 )]
6022 pub installed_at: Option<i64>,
6023 #[serde(default, skip_serializing_if = "Option::is_none")]
6024 pub interface: Option<PluginInterface>,
6025 #[serde(default, skip_serializing_if = "Option::is_none")]
6026 pub keywords: Option<Vec<String>>,
6027 #[serde(
6028 rename = "localVersion",
6029 default,
6030 skip_serializing_if = "Option::is_none"
6031 )]
6032 pub local_version: Option<String>,
6033 #[serde(
6034 rename = "mustShowInstallationInterstitial",
6035 default,
6036 skip_serializing_if = "Option::is_none"
6037 )]
6038 pub must_show_installation_interstitial: Option<bool>,
6039 #[serde(default)]
6040 pub name: String,
6041 #[serde(
6042 rename = "remotePluginId",
6043 default,
6044 skip_serializing_if = "Option::is_none"
6045 )]
6046 pub remote_plugin_id: Option<String>,
6047 #[serde(
6048 rename = "shareContext",
6049 default,
6050 skip_serializing_if = "Option::is_none"
6051 )]
6052 pub share_context: Option<PluginShareContext>,
6053 #[serde()]
6054 pub source: PluginSource,
6055 #[serde(default, skip_serializing_if = "Option::is_none")]
6056 pub version: Option<String>,
6057}
6058
6059#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6060#[serde(rename_all = "camelCase")]
6061pub struct PluginUninstallParams {
6062 #[serde(rename = "pluginId", default)]
6063 pub plugin_id: String,
6064}
6065
6066#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6067#[serde(rename_all = "camelCase")]
6068pub struct PluginUninstallResponse {
6069 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6070 pub extra: serde_json::Map<String, Value>,
6071}
6072
6073#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6074#[serde(rename_all = "camelCase")]
6075pub struct PluginsMigration {
6076 #[serde(rename = "marketplaceName", default)]
6077 pub marketplace_name: String,
6078 #[serde(rename = "pluginNames", default)]
6079 pub plugin_names: Vec<String>,
6080}
6081
6082#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6083#[serde(rename_all = "camelCase")]
6084pub struct ProcessExitedNotification {
6085 #[serde(rename = "exitCode", default)]
6086 pub exit_code: i64,
6087 #[serde(rename = "processHandle", default)]
6088 pub process_handle: String,
6089 #[serde(default)]
6090 pub stderr: String,
6091 #[serde(rename = "stderrCapReached", default)]
6092 pub stderr_cap_reached: bool,
6093 #[serde(default)]
6094 pub stdout: String,
6095 #[serde(rename = "stdoutCapReached", default)]
6096 pub stdout_cap_reached: bool,
6097}
6098
6099#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6100#[serde(rename_all = "camelCase")]
6101pub struct ProcessOutputDeltaNotification {
6102 #[serde(rename = "capReached", default)]
6103 pub cap_reached: bool,
6104 #[serde(rename = "deltaBase64", default)]
6105 pub delta_base64: String,
6106 #[serde(rename = "processHandle", default)]
6107 pub process_handle: String,
6108 #[serde(default)]
6109 pub stream: Value,
6110}
6111
6112#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6113pub enum ProcessOutputStream {
6114 #[serde(rename = "stdout")]
6115 Stdout,
6116 #[serde(rename = "stderr")]
6117 Stderr,
6118}
6119
6120#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6121pub enum RateLimitReachedType {
6122 #[serde(rename = "rate_limit_reached")]
6123 Rate_limit_reached,
6124 #[serde(rename = "workspace_owner_credits_depleted")]
6125 Workspace_owner_credits_depleted,
6126 #[serde(rename = "workspace_member_credits_depleted")]
6127 Workspace_member_credits_depleted,
6128 #[serde(rename = "workspace_owner_usage_limit_reached")]
6129 Workspace_owner_usage_limit_reached,
6130 #[serde(rename = "workspace_member_usage_limit_reached")]
6131 Workspace_member_usage_limit_reached,
6132}
6133
6134#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6135#[serde(rename_all = "camelCase")]
6136pub struct RateLimitResetCredit {
6137 #[serde(default, skip_serializing_if = "Option::is_none")]
6138 pub description: Option<String>,
6139 #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
6140 pub expires_at: Option<i64>,
6141 #[serde(rename = "grantedAt", default)]
6142 pub granted_at: i64,
6143 #[serde(default)]
6144 pub id: String,
6145 #[serde(rename = "resetType")]
6146 pub reset_type: RateLimitResetType,
6147 #[serde()]
6148 pub status: RateLimitResetCreditStatus,
6149 #[serde(default, skip_serializing_if = "Option::is_none")]
6150 pub title: Option<String>,
6151}
6152
6153#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6154pub enum RateLimitResetCreditStatus {
6155 #[serde(rename = "available")]
6156 Available,
6157 #[serde(rename = "redeeming")]
6158 Redeeming,
6159 #[serde(rename = "redeemed")]
6160 Redeemed,
6161 #[serde(rename = "unknown")]
6162 Unknown,
6163}
6164
6165#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6166#[serde(rename_all = "camelCase")]
6167pub struct RateLimitResetCreditsSummary {
6168 #[serde(rename = "availableCount", default)]
6169 pub available_count: i64,
6170 #[serde(default, skip_serializing_if = "Option::is_none")]
6171 pub credits: Option<Vec<RateLimitResetCredit>>,
6172}
6173
6174#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6175pub enum RateLimitResetType {
6176 #[serde(rename = "codexRateLimits")]
6177 CodexRateLimits,
6178 #[serde(rename = "unknown")]
6179 Unknown,
6180}
6181
6182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6183#[serde(rename_all = "camelCase")]
6184pub struct RateLimitSnapshot {
6185 #[serde(default, skip_serializing_if = "Option::is_none")]
6186 pub credits: Option<CreditsSnapshot>,
6187 #[serde(
6188 rename = "individualLimit",
6189 default,
6190 skip_serializing_if = "Option::is_none"
6191 )]
6192 pub individual_limit: Option<SpendControlLimitSnapshot>,
6193 #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
6194 pub limit_id: Option<String>,
6195 #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
6196 pub limit_name: Option<String>,
6197 #[serde(
6200 rename = "normalModelSlug",
6201 default,
6202 skip_serializing_if = "Option::is_none"
6203 )]
6204 pub normal_model_slug: Option<String>,
6205 #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
6206 pub plan_type: Option<PlanType>,
6207 #[serde(default, skip_serializing_if = "Option::is_none")]
6208 pub primary: Option<RateLimitWindow>,
6209 #[serde(
6210 rename = "rateLimitReachedType",
6211 default,
6212 skip_serializing_if = "Option::is_none"
6213 )]
6214 pub rate_limit_reached_type: Option<RateLimitReachedType>,
6215 #[serde(default, skip_serializing_if = "Option::is_none")]
6216 pub secondary: Option<RateLimitWindow>,
6217 #[serde(
6218 rename = "spendControlReached",
6219 default,
6220 skip_serializing_if = "Option::is_none"
6221 )]
6222 pub spend_control_reached: Option<bool>,
6223}
6224
6225#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6226#[serde(rename_all = "camelCase")]
6227pub struct RateLimitWindow {
6228 #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
6229 pub resets_at: Option<i64>,
6230 #[serde(rename = "usedPercent", default)]
6231 pub used_percent: i64,
6232 #[serde(
6233 rename = "windowDurationMins",
6234 default,
6235 skip_serializing_if = "Option::is_none"
6236 )]
6237 pub window_duration_mins: Option<i64>,
6238}
6239
6240#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6241pub enum RealtimeConversationVersion {
6242 #[serde(rename = "v1")]
6243 V1,
6244 #[serde(rename = "v2")]
6245 V2,
6246 #[serde(rename = "v3")]
6247 V3,
6248}
6249
6250#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
6252#[serde(transparent)]
6253pub struct ReasoningEffort(pub String);
6254
6255#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6256#[serde(rename_all = "camelCase")]
6257pub struct ReasoningEffortOption {
6258 #[serde(default)]
6259 pub description: String,
6260 #[serde(rename = "reasoningEffort")]
6261 pub reasoning_effort: ReasoningEffort,
6262}
6263
6264#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6265pub enum ReasoningSummary {
6266 #[serde(rename = "auto")]
6267 Auto,
6268 #[serde(rename = "concise")]
6269 Concise,
6270 #[serde(rename = "detailed")]
6271 Detailed,
6272 #[serde(rename = "none")]
6273 None,
6274}
6275
6276#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6277#[serde(rename_all = "camelCase")]
6278pub struct ReasoningSummaryPartAddedNotification {
6279 #[serde(rename = "itemId", default)]
6280 pub item_id: String,
6281 #[serde(rename = "summaryIndex", default)]
6282 pub summary_index: i64,
6283 #[serde(rename = "threadId", default)]
6284 pub thread_id: String,
6285 #[serde(rename = "turnId", default)]
6286 pub turn_id: String,
6287}
6288
6289#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6290#[serde(rename_all = "camelCase")]
6291pub struct ReasoningSummaryTextDeltaNotification {
6292 #[serde(default)]
6293 pub delta: String,
6294 #[serde(rename = "itemId", default)]
6295 pub item_id: String,
6296 #[serde(rename = "summaryIndex", default)]
6297 pub summary_index: i64,
6298 #[serde(rename = "threadId", default)]
6299 pub thread_id: String,
6300 #[serde(rename = "turnId", default)]
6301 pub turn_id: String,
6302}
6303
6304#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6305#[serde(rename_all = "camelCase")]
6306pub struct ReasoningTextDeltaNotification {
6307 #[serde(rename = "contentIndex", default)]
6308 pub content_index: i64,
6309 #[serde(default)]
6310 pub delta: String,
6311 #[serde(rename = "itemId", default)]
6312 pub item_id: String,
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, Serialize, Deserialize, PartialEq, Eq)]
6320pub enum RemoteControlConnectionStatus {
6321 #[serde(rename = "disabled")]
6322 Disabled,
6323 #[serde(rename = "connecting")]
6324 Connecting,
6325 #[serde(rename = "connected")]
6326 Connected,
6327 #[serde(rename = "errored")]
6328 Errored,
6329}
6330
6331#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6332#[serde(rename_all = "camelCase")]
6333pub struct RemoteControlStatusChangedNotification {
6334 #[serde(
6335 rename = "environmentId",
6336 default,
6337 skip_serializing_if = "Option::is_none"
6338 )]
6339 pub environment_id: Option<String>,
6340 #[serde(rename = "installationId", default)]
6341 pub installation_id: String,
6342 #[serde(rename = "serverName", default)]
6343 pub server_name: String,
6344 #[serde()]
6345 pub status: RemoteControlConnectionStatus,
6346}
6347
6348#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6349#[serde(untagged)]
6350pub enum RequestId {
6351 Variant0(String),
6352 Variant1(i64),
6353}
6354
6355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6356#[serde(rename_all = "camelCase")]
6357pub struct RequestPermissionProfile {
6358 #[serde(
6359 rename = "fileSystem",
6360 default,
6361 skip_serializing_if = "Option::is_none"
6362 )]
6363 pub file_system: Option<AdditionalFileSystemPermissions>,
6364 #[serde(default, skip_serializing_if = "Option::is_none")]
6365 pub network: Option<AdditionalNetworkPermissions>,
6366}
6367
6368#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6369pub enum ResidencyRequirement {
6370 #[serde(rename = "us")]
6371 Us,
6372}
6373
6374#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6375#[serde(rename_all = "camelCase")]
6376pub struct Resource {
6377 #[serde(default, skip_serializing_if = "Option::is_none")]
6378 pub _meta: Option<Value>,
6379 #[serde(default, skip_serializing_if = "Option::is_none")]
6380 pub annotations: Option<Value>,
6381 #[serde(default, skip_serializing_if = "Option::is_none")]
6382 pub description: Option<String>,
6383 #[serde(default, skip_serializing_if = "Option::is_none")]
6384 pub icons: Option<Vec<Value>>,
6385 #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6386 pub mime_type: Option<String>,
6387 #[serde(default)]
6388 pub name: String,
6389 #[serde(default, skip_serializing_if = "Option::is_none")]
6390 pub size: Option<i64>,
6391 #[serde(default, skip_serializing_if = "Option::is_none")]
6392 pub title: Option<String>,
6393 #[serde(default)]
6394 pub uri: String,
6395}
6396
6397#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6398#[serde(untagged)]
6399pub enum ResourceContent {
6400 Variant0(Value),
6401 Variant1(Value),
6402}
6403
6404#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6405#[serde(rename_all = "camelCase")]
6406pub struct ResourceTemplate {
6407 #[serde(default, skip_serializing_if = "Option::is_none")]
6408 pub annotations: Option<Value>,
6409 #[serde(default, skip_serializing_if = "Option::is_none")]
6410 pub description: Option<String>,
6411 #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6412 pub mime_type: Option<String>,
6413 #[serde(default)]
6414 pub name: String,
6415 #[serde(default, skip_serializing_if = "Option::is_none")]
6416 pub title: Option<String>,
6417 #[serde(rename = "uriTemplate", default)]
6418 pub uri_template: String,
6419}
6420
6421#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6423#[serde(rename_all = "camelCase")]
6424pub struct ResponseUsageMetadata {
6425 #[serde(default, skip_serializing_if = "Option::is_none")]
6426 pub amount: Option<String>,
6427 #[serde(default, skip_serializing_if = "Option::is_none")]
6428 pub metadata: Option<Value>,
6429}
6430
6431#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6432pub enum ReviewDecision {
6433 #[serde(rename = "approved")]
6434 Approved,
6435 #[serde(rename = "approved_execpolicy_amendment")]
6436 ApprovedExecpolicyAmendment {
6437 proposed_execpolicy_amendment: Vec<String>,
6438 },
6439 #[serde(rename = "approved_for_session")]
6440 ApprovedForSession,
6441 #[serde(rename = "approved_mcp_policy_amendment")]
6442 ApprovedMcpPolicyAmendment,
6443 #[serde(rename = "network_policy_amendment")]
6444 NetworkPolicyAmendment {
6445 network_policy_amendment: NetworkPolicyAmendment,
6446 },
6447 #[serde(rename = "denied")]
6448 Denied { rejection: String },
6449 #[serde(rename = "timed_out")]
6450 TimedOut,
6451 #[serde(rename = "abort")]
6452 Abort,
6453}
6454
6455#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6456pub enum ReviewDelivery {
6457 #[serde(rename = "inline")]
6458 Inline,
6459 #[serde(rename = "detached")]
6460 Detached,
6461}
6462
6463#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6464#[serde(rename_all = "camelCase")]
6465pub struct ReviewStartParams {
6466 #[serde(default, skip_serializing_if = "Option::is_none")]
6467 pub delivery: Option<ReviewDelivery>,
6468 #[serde()]
6469 pub target: ReviewTarget,
6470 #[serde(rename = "threadId", default)]
6471 pub thread_id: String,
6472}
6473
6474#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6475#[serde(rename_all = "camelCase")]
6476pub struct ReviewStartResponse {
6477 #[serde(rename = "reviewThreadId", default)]
6478 pub review_thread_id: String,
6479 #[serde()]
6480 pub turn: Turn,
6481}
6482
6483#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6484#[serde(tag = "type", rename_all = "camelCase")]
6485pub enum ReviewTarget {
6486 #[serde(rename = "uncommittedChanges")]
6487 UncommittedChanges,
6488 #[serde(rename = "baseBranch")]
6489 BaseBranch {
6490 branch: String,
6491 },
6492 Commit {
6493 sha: String,
6494 #[serde(default, skip_serializing_if = "Option::is_none")]
6495 title: Option<String>,
6496 },
6497 Custom {
6498 instructions: String,
6499 },
6500}
6501
6502#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6504pub enum AgentMessageDelivery {
6505 #[serde(rename = "async")]
6506 Async,
6507}
6508
6509#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6511pub enum CliAuthCredentialsStoreMode {
6512 #[serde(rename = "file")]
6513 File,
6514 #[serde(rename = "keyring")]
6515 Keyring,
6516 #[serde(rename = "auto")]
6517 Auto,
6518 #[serde(rename = "ephemeral")]
6519 Ephemeral,
6520}
6521
6522#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6524pub struct Project {
6525 #[serde(rename = "createdAt", default)]
6526 pub created_at: i64,
6527 #[serde(default)]
6528 pub id: String,
6529 #[serde(default)]
6530 pub metadata: std::collections::HashMap<String, String>,
6531 #[serde(default)]
6532 pub name: String,
6533 #[serde(default)]
6534 pub position: i64,
6535 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
6538 pub recency_at: Option<i64>,
6539 #[serde(default)]
6540 pub roots: Vec<ProjectRoot>,
6541 #[serde(rename = "updatedAt", default)]
6542 pub updated_at: i64,
6543}
6544
6545#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6547pub enum ProjectSortKey {
6548 #[serde(rename = "position")]
6549 Position,
6550 #[serde(rename = "recencyAt")]
6551 RecencyAt,
6552}
6553
6554#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6555pub enum ProjectChangeType {
6556 #[serde(rename = "created")]
6557 Created,
6558 #[serde(rename = "updated")]
6559 Updated,
6560 #[serde(rename = "deleted")]
6561 Deleted,
6562}
6563
6564#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6566pub struct ProjectChangedNotification {
6567 #[serde(rename = "changeType")]
6568 pub change_type: ProjectChangeType,
6569 #[serde(rename = "projectId", default)]
6570 pub project_id: String,
6571}
6572
6573#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6574pub struct ProjectRoot {
6575 pub path: AbsolutePathBuf,
6576}
6577
6578#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6580pub struct QueuedSubmission {
6581 #[serde(rename = "clientUserMessageId", default)]
6582 pub client_user_message_id: String,
6583 #[serde(default)]
6584 pub id: String,
6585 #[serde(default)]
6586 pub input: Vec<UserInput>,
6587}
6588
6589#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6591pub struct StrictReviewRequiredNotification {
6592 #[serde(rename = "startedAtMs", default)]
6594 pub started_at_ms: i64,
6595 #[serde(rename = "threadId", default)]
6596 pub thread_id: String,
6597 #[serde(rename = "turnId", default)]
6598 pub turn_id: String,
6599}
6600
6601#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6603pub struct ThreadProjectUpdatedNotification {
6604 #[serde(rename = "projectId", default)]
6605 pub project_id: Option<String>,
6606 #[serde(rename = "threadId", default)]
6607 pub thread_id: String,
6608}
6609
6610#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6612pub struct ThreadQueueChangedNotification {
6613 #[serde(rename = "threadId", default)]
6614 pub thread_id: String,
6615}
6616
6617#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6619pub struct ThreadRevertedNotification {
6620 #[serde(rename = "threadId", default)]
6621 pub thread_id: String,
6622}
6623
6624#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6627#[serde(rename_all = "camelCase")]
6628pub struct ThreadPredictionUpdatedNotification {
6629 pub result: ThreadPredictionResult,
6630 #[serde(rename = "sourceTurnId", default)]
6631 pub source_turn_id: String,
6632 #[serde(rename = "threadId", default)]
6633 pub thread_id: String,
6634}
6635
6636#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6638#[serde(tag = "type", rename_all = "camelCase")]
6639pub enum ThreadPredictionResult {
6640 Completed {
6641 #[serde(default, skip_serializing_if = "Option::is_none")]
6642 text: Option<String>,
6643 },
6644 Failed,
6645}
6646
6647#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6649#[serde(rename_all = "camelCase")]
6650pub struct InAppBrowserRequirements {
6651 #[serde(
6652 rename = "allowExternalBrowserSettingsImport",
6653 default,
6654 skip_serializing_if = "Option::is_none"
6655 )]
6656 pub allow_external_browser_settings_import: Option<bool>,
6657}
6658
6659#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6661pub struct McpServerEventNotification {
6662 #[serde(default)]
6663 pub method: String,
6664 #[serde(default)]
6665 pub params: Value,
6666}
6667
6668#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6671pub struct McpServerEventStreamNotification {
6672 pub notification: McpServerEventNotification,
6673 #[serde(rename = "subscriptionId", default)]
6674 pub subscription_id: String,
6675}
6676
6677#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6680pub enum AllowDenyRequirement {
6681 #[serde(rename = "allow")]
6682 Allow,
6683 #[serde(rename = "deny")]
6684 Deny,
6685}
6686
6687#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6689pub enum BrowserUseAccessApprovalLifetime {
6690 #[serde(rename = "turn")]
6691 Turn,
6692 #[serde(rename = "thread")]
6693 Thread,
6694}
6695
6696#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6698pub enum McpServerConnectionStatus {
6699 #[serde(rename = "notStarted")]
6700 NotStarted,
6701 #[serde(rename = "starting")]
6702 Starting,
6703 #[serde(rename = "connected")]
6704 Connected,
6705 #[serde(rename = "authenticationRequired")]
6706 AuthenticationRequired,
6707 #[serde(rename = "failed")]
6708 Failed,
6709 #[serde(rename = "cancelled")]
6710 Cancelled,
6711 #[serde(rename = "disabled")]
6712 Disabled,
6713}
6714
6715#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6717#[serde(rename_all = "camelCase")]
6718pub struct BrowserUseOriginPolicy {
6719 #[serde(default, skip_serializing_if = "Option::is_none")]
6720 pub access: Option<AllowDenyRequirement>,
6721 #[serde(
6722 rename = "accessApprovalLifetime",
6723 default,
6724 skip_serializing_if = "Option::is_none"
6725 )]
6726 pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
6727 #[serde(
6728 rename = "autoReview",
6729 default,
6730 skip_serializing_if = "Option::is_none"
6731 )]
6732 pub auto_review: Option<AllowDenyRequirement>,
6733 #[serde(default, skip_serializing_if = "Option::is_none")]
6734 pub downloads: Option<AllowDenyRequirement>,
6735 #[serde(
6736 rename = "fullCdpAccess",
6737 default,
6738 skip_serializing_if = "Option::is_none"
6739 )]
6740 pub full_cdp_access: Option<AllowDenyRequirement>,
6741 #[serde(
6742 rename = "persistentApproval",
6743 default,
6744 skip_serializing_if = "Option::is_none"
6745 )]
6746 pub persistent_approval: Option<bool>,
6747 #[serde(default, skip_serializing_if = "Option::is_none")]
6748 pub uploads: Option<AllowDenyRequirement>,
6749}
6750
6751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6753pub struct BrowserUseOriginPolicyConfig {
6754 #[serde(default, skip_serializing_if = "Option::is_none")]
6755 pub access: Option<AllowDenyRequirement>,
6756 #[serde(default, skip_serializing_if = "Option::is_none")]
6757 pub downloads: Option<AllowDenyRequirement>,
6758 #[serde(default, skip_serializing_if = "Option::is_none")]
6759 pub full_cdp_access: Option<AllowDenyRequirement>,
6760 #[serde(default, skip_serializing_if = "Option::is_none")]
6761 pub uploads: Option<AllowDenyRequirement>,
6762}
6763
6764#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6766pub struct BrowserUseConfig {
6767 #[serde(default, skip_serializing_if = "Option::is_none")]
6768 pub allow_history_access: Option<bool>,
6769 #[serde(default, skip_serializing_if = "Option::is_none")]
6770 pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
6771 #[serde(default, skip_serializing_if = "Option::is_none")]
6772 pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
6773}
6774
6775#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6777pub struct ComputerUseConfig {
6778 #[serde(default, skip_serializing_if = "Option::is_none")]
6779 pub default_app_access: Option<AllowDenyRequirement>,
6780 #[serde(default, skip_serializing_if = "Option::is_none")]
6781 pub macos: Option<ComputerUseMacosConfig>,
6782 #[serde(default, skip_serializing_if = "Option::is_none")]
6783 pub windows: Option<ComputerUseWindowsConfig>,
6784}
6785
6786#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6787pub struct ComputerUseMacosConfig {
6788 #[serde(default, skip_serializing_if = "Option::is_none")]
6789 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6790}
6791
6792#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6793pub struct ComputerUseWindowsConfig {
6794 #[serde(default, skip_serializing_if = "Option::is_none")]
6795 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6796 #[serde(default, skip_serializing_if = "Option::is_none")]
6797 pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
6798}
6799
6800#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6801pub struct ComputerUseWindowsExeConfig {
6802 pub access: AllowDenyRequirement,
6803 #[serde(default, skip_serializing_if = "Option::is_none")]
6804 pub binary_name: Option<String>,
6805 #[serde(default)]
6806 pub product_name: String,
6807 #[serde(default)]
6808 pub publisher_name: String,
6809}
6810
6811#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6813#[serde(rename_all = "camelCase")]
6814pub struct ComputerUseMacosRequirements {
6815 #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
6816 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6817}
6818
6819#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6820#[serde(rename_all = "camelCase")]
6821pub struct ComputerUseWindowsRequirements {
6822 #[serde(default, skip_serializing_if = "Option::is_none")]
6823 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6824 #[serde(default, skip_serializing_if = "Option::is_none")]
6825 pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
6826}
6827
6828#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6829#[serde(rename_all = "camelCase")]
6830pub struct ComputerUseWindowsExeRequirement {
6831 pub access: AllowDenyRequirement,
6832 #[serde(
6833 rename = "binaryName",
6834 default,
6835 skip_serializing_if = "Option::is_none"
6836 )]
6837 pub binary_name: Option<String>,
6838 #[serde(rename = "productName", default)]
6839 pub product_name: String,
6840 #[serde(rename = "publisherName", default)]
6841 pub publisher_name: String,
6842}
6843
6844#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6845pub enum SandboxMode {
6846 #[serde(rename = "read-only")]
6847 Read_only,
6848 #[serde(rename = "workspace-write")]
6849 Workspace_write,
6850 #[serde(rename = "danger-full-access")]
6851 Danger_full_access,
6852}
6853
6854#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6855#[serde(tag = "type", rename_all = "camelCase")]
6856pub enum SandboxPolicy {
6857 #[serde(rename = "dangerFullAccess")]
6858 DangerFullAccess,
6859 #[serde(rename = "readOnly")]
6860 ReadOnly {
6861 #[serde(
6862 rename = "networkAccess",
6863 default,
6864 skip_serializing_if = "Option::is_none"
6865 )]
6866 network_access: Option<bool>,
6867 },
6868 #[serde(rename = "externalSandbox")]
6869 ExternalSandbox {
6870 #[serde(
6871 rename = "networkAccess",
6872 default,
6873 skip_serializing_if = "Option::is_none"
6874 )]
6875 network_access: Option<Value>,
6876 },
6877 #[serde(rename = "workspaceWrite")]
6878 WorkspaceWrite {
6879 #[serde(
6880 rename = "excludeSlashTmp",
6881 default,
6882 skip_serializing_if = "Option::is_none"
6883 )]
6884 exclude_slash_tmp: Option<bool>,
6885 #[serde(
6886 rename = "excludeTmpdirEnvVar",
6887 default,
6888 skip_serializing_if = "Option::is_none"
6889 )]
6890 exclude_tmpdir_env_var: Option<bool>,
6891 #[serde(
6892 rename = "networkAccess",
6893 default,
6894 skip_serializing_if = "Option::is_none"
6895 )]
6896 network_access: Option<bool>,
6897 #[serde(
6898 rename = "writableRoots",
6899 default,
6900 skip_serializing_if = "Option::is_none"
6901 )]
6902 writable_roots: Option<Vec<AbsolutePathBuf>>,
6903 },
6904}
6905
6906#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6907#[serde(rename_all = "snake_case")]
6908pub struct SandboxWorkspaceWrite {
6909 #[serde(default, skip_serializing_if = "Option::is_none")]
6910 pub exclude_slash_tmp: Option<bool>,
6911 #[serde(default, skip_serializing_if = "Option::is_none")]
6912 pub exclude_tmpdir_env_var: Option<bool>,
6913 #[serde(default, skip_serializing_if = "Option::is_none")]
6914 pub network_access: Option<bool>,
6915 #[serde(default, skip_serializing_if = "Option::is_none")]
6916 pub writable_roots: Option<Vec<String>>,
6917}
6918
6919#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6920#[serde(tag = "type", rename_all = "camelCase")]
6921pub enum ScheduledTaskSchedule {
6922 Hourly {
6923 #[serde(default, skip_serializing_if = "Option::is_none")]
6924 days: Option<Vec<ScheduledTaskWeekday>>,
6925 #[serde(rename = "intervalHours")]
6926 interval_hours: i64,
6927 },
6928 Daily {
6929 time: String,
6930 },
6931 Weekdays {
6932 time: String,
6933 },
6934 Weekly {
6935 days: Vec<ScheduledTaskWeekday>,
6936 time: String,
6937 },
6938}
6939
6940#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6941#[serde(rename_all = "camelCase")]
6942pub struct ScheduledTaskSummary {
6943 #[serde(default)]
6944 pub key: String,
6945 #[serde(default)]
6946 pub name: String,
6947 #[serde(default)]
6948 pub prompt: String,
6949 #[serde()]
6950 pub schedule: ScheduledTaskSchedule,
6951}
6952
6953#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6954pub enum ScheduledTaskWeekday {
6955 #[serde(rename = "MO")]
6956 MO,
6957 #[serde(rename = "TU")]
6958 TU,
6959 #[serde(rename = "WE")]
6960 WE,
6961 #[serde(rename = "TH")]
6962 TH,
6963 #[serde(rename = "FR")]
6964 FR,
6965 #[serde(rename = "SA")]
6966 SA,
6967 #[serde(rename = "SU")]
6968 SU,
6969}
6970
6971#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6972#[serde(rename_all = "camelCase")]
6973pub struct SendAddCreditsNudgeEmailParams {
6974 #[serde(rename = "creditType")]
6975 pub credit_type: AddCreditsNudgeCreditType,
6976}
6977
6978#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6979#[serde(rename_all = "camelCase")]
6980pub struct SendAddCreditsNudgeEmailResponse {
6981 #[serde()]
6982 pub status: AddCreditsNudgeEmailStatus,
6983}
6984
6985#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6986#[serde(rename_all = "camelCase")]
6987pub struct ServerRequestResolvedNotification {
6988 #[serde(rename = "requestId")]
6989 pub request_id: RequestId,
6990 #[serde(rename = "threadId", default)]
6991 pub thread_id: String,
6992}
6993
6994#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6995#[serde(rename_all = "camelCase")]
6996pub struct SessionMigration {
6997 #[serde(default)]
6998 pub cwd: String,
6999 #[serde(default)]
7000 pub path: String,
7001 #[serde(default, skip_serializing_if = "Option::is_none")]
7002 pub title: Option<String>,
7003}
7004
7005#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7006pub enum SessionSource {
7007 #[serde(rename = "cli")]
7008 Cli,
7009 #[serde(rename = "vscode")]
7010 Vscode,
7011 #[serde(rename = "exec")]
7012 Exec,
7013 #[serde(rename = "appServer")]
7014 AppServer,
7015 #[serde(rename = "unknown")]
7016 Unknown,
7017 #[serde(rename = "custom")]
7018 Custom(String),
7019 #[serde(rename = "subAgent")]
7020 SubAgent(SubAgentSource),
7021}
7022
7023#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7024#[serde(rename_all = "camelCase")]
7025pub struct Settings {
7026 #[serde(default, skip_serializing_if = "Option::is_none")]
7027 pub developer_instructions: Option<String>,
7028 #[serde(default)]
7029 pub model: String,
7030 #[serde(default, skip_serializing_if = "Option::is_none")]
7031 pub reasoning_effort: Option<ReasoningEffort>,
7032}
7033
7034#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7035#[serde(rename_all = "camelCase")]
7036pub struct SkillDependencies {
7037 #[serde(default)]
7038 pub tools: Vec<SkillToolDependency>,
7039}
7040
7041#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7042#[serde(rename_all = "camelCase")]
7043pub struct SkillErrorInfo {
7044 #[serde(default)]
7045 pub message: String,
7046 #[serde(default)]
7047 pub path: String,
7048}
7049
7050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7051#[serde(rename_all = "camelCase")]
7052pub struct SkillInterface {
7053 #[serde(
7054 rename = "brandColor",
7055 default,
7056 skip_serializing_if = "Option::is_none"
7057 )]
7058 pub brand_color: Option<String>,
7059 #[serde(
7060 rename = "defaultPrompt",
7061 default,
7062 skip_serializing_if = "Option::is_none"
7063 )]
7064 pub default_prompt: Option<String>,
7065 #[serde(
7066 rename = "displayName",
7067 default,
7068 skip_serializing_if = "Option::is_none"
7069 )]
7070 pub display_name: Option<String>,
7071 #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
7072 pub icon_large: Option<AbsolutePathBuf>,
7073 #[serde(
7074 rename = "iconLargeUrl",
7075 default,
7076 skip_serializing_if = "Option::is_none"
7077 )]
7078 pub icon_large_url: Option<String>,
7079 #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
7080 pub icon_small: Option<AbsolutePathBuf>,
7081 #[serde(
7082 rename = "iconSmallUrl",
7083 default,
7084 skip_serializing_if = "Option::is_none"
7085 )]
7086 pub icon_small_url: Option<String>,
7087 #[serde(
7088 rename = "shortDescription",
7089 default,
7090 skip_serializing_if = "Option::is_none"
7091 )]
7092 pub short_description: Option<String>,
7093}
7094
7095#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7096#[serde(rename_all = "camelCase")]
7097pub struct SkillMetadata {
7098 #[serde(default, skip_serializing_if = "Option::is_none")]
7099 pub dependencies: Option<SkillDependencies>,
7100 #[serde(default)]
7101 pub description: String,
7102 #[serde(default)]
7103 pub enabled: bool,
7104 #[serde(default, skip_serializing_if = "Option::is_none")]
7105 pub interface: Option<SkillInterface>,
7106 #[serde(default)]
7107 pub name: String,
7108 #[serde()]
7109 pub path: LegacyAppPathString,
7110 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7111 pub plugin_id: Option<String>,
7112 #[serde()]
7113 pub scope: SkillScope,
7114 #[serde(
7115 rename = "shortDescription",
7116 default,
7117 skip_serializing_if = "Option::is_none"
7118 )]
7119 pub short_description: Option<String>,
7120}
7121
7122#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7123#[serde(rename_all = "camelCase")]
7124pub struct SkillMigration {
7125 #[serde(default)]
7126 pub name: String,
7127}
7128
7129#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7130pub enum SkillScope {
7131 #[serde(rename = "user")]
7132 User,
7133 #[serde(rename = "repo")]
7134 Repo,
7135 #[serde(rename = "system")]
7136 System,
7137 #[serde(rename = "admin")]
7138 Admin,
7139}
7140
7141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7142#[serde(rename_all = "camelCase")]
7143pub struct SkillSummary {
7144 #[serde(default)]
7145 pub description: String,
7146 #[serde(default)]
7147 pub enabled: bool,
7148 #[serde(default, skip_serializing_if = "Option::is_none")]
7149 pub interface: Option<SkillInterface>,
7150 #[serde(default)]
7151 pub name: String,
7152 #[serde(default, skip_serializing_if = "Option::is_none")]
7153 pub path: Option<LegacyAppPathString>,
7154 #[serde(
7155 rename = "shortDescription",
7156 default,
7157 skip_serializing_if = "Option::is_none"
7158 )]
7159 pub short_description: Option<String>,
7160}
7161
7162#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7163#[serde(rename_all = "camelCase")]
7164pub struct SkillToolDependency {
7165 #[serde(default, skip_serializing_if = "Option::is_none")]
7166 pub command: Option<String>,
7167 #[serde(default, skip_serializing_if = "Option::is_none")]
7168 pub description: Option<String>,
7169 #[serde(default, skip_serializing_if = "Option::is_none")]
7170 pub transport: Option<String>,
7171 #[serde(rename = "type", default)]
7172 pub type_: String,
7173 #[serde(default, skip_serializing_if = "Option::is_none")]
7174 pub url: Option<String>,
7175 #[serde(default)]
7176 pub value: String,
7177}
7178
7179#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7180#[serde(rename_all = "camelCase")]
7181pub struct SkillsChangedNotification {
7182 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7183 pub extra: serde_json::Map<String, Value>,
7184}
7185
7186#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7187#[serde(rename_all = "camelCase")]
7188pub struct SkillsConfigWriteParams {
7189 #[serde(default)]
7190 pub enabled: bool,
7191 #[serde(default, skip_serializing_if = "Option::is_none")]
7192 pub name: Option<String>,
7193 #[serde(default, skip_serializing_if = "Option::is_none")]
7194 pub path: Option<AbsolutePathBuf>,
7195}
7196
7197#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7198#[serde(rename_all = "camelCase")]
7199pub struct SkillsConfigWriteResponse {
7200 #[serde(rename = "effectiveEnabled", default)]
7201 pub effective_enabled: bool,
7202}
7203
7204#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7205#[serde(rename_all = "camelCase")]
7206pub struct SkillsExtraRootsSetParams {
7207 #[serde(rename = "extraRoots", default)]
7208 pub extra_roots: Vec<AbsolutePathBuf>,
7209}
7210
7211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7212#[serde(rename_all = "camelCase")]
7213pub struct SkillsExtraRootsSetResponse {
7214 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7215 pub extra: serde_json::Map<String, Value>,
7216}
7217
7218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7219#[serde(rename_all = "camelCase")]
7220pub struct SkillsListEntry {
7221 #[serde(default)]
7222 pub cwd: String,
7223 #[serde(default)]
7224 pub errors: Vec<SkillErrorInfo>,
7225 #[serde(default)]
7226 pub skills: Vec<SkillMetadata>,
7227}
7228
7229#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7230#[serde(rename_all = "camelCase")]
7231pub struct SkillsListParams {
7232 #[serde(default, skip_serializing_if = "Option::is_none")]
7233 pub cwds: Option<Vec<String>>,
7234 #[serde(
7235 rename = "forceReload",
7236 default,
7237 skip_serializing_if = "Option::is_none"
7238 )]
7239 pub force_reload: Option<bool>,
7240}
7241
7242#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7243#[serde(rename_all = "camelCase")]
7244pub struct SkillsListResponse {
7245 #[serde(default)]
7246 pub data: Vec<SkillsListEntry>,
7247}
7248
7249#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7250pub enum SortDirection {
7251 #[serde(rename = "asc")]
7252 Asc,
7253 #[serde(rename = "desc")]
7254 Desc,
7255}
7256
7257#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7258#[serde(rename_all = "camelCase")]
7259pub struct SpendControlLimitSnapshot {
7260 #[serde(default)]
7261 pub limit: String,
7262 #[serde(rename = "remainingPercent", default)]
7263 pub remaining_percent: i64,
7264 #[serde(rename = "resetsAt", default)]
7265 pub resets_at: i64,
7266 #[serde(default)]
7267 pub used: String,
7268}
7269
7270#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7271pub enum SubAgentActivityKind {
7272 #[serde(rename = "started")]
7273 Started,
7274 #[serde(rename = "interacted")]
7275 Interacted,
7276 #[serde(rename = "interrupted")]
7277 Interrupted,
7278 #[serde(rename = "completed")]
7279 Completed,
7280}
7281
7282#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7283pub enum SubAgentSource {
7284 #[serde(rename = "review")]
7285 Review,
7286 #[serde(rename = "compact")]
7287 Compact,
7288 #[serde(rename = "memory_consolidation")]
7289 MemoryConsolidation,
7290 #[serde(rename = "thread_spawn")]
7291 ThreadSpawn {
7292 #[serde(default, skip_serializing_if = "Option::is_none")]
7293 agent_nickname: Option<String>,
7294 #[serde(default, skip_serializing_if = "Option::is_none")]
7295 agent_path: Option<AgentPath>,
7296 #[serde(default, skip_serializing_if = "Option::is_none")]
7297 agent_role: Option<String>,
7298 depth: i64,
7299 parent_thread_id: ThreadId,
7300 },
7301 #[serde(rename = "other")]
7302 Other(String),
7303}
7304
7305#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7306#[serde(rename_all = "camelCase")]
7307pub struct SubagentMigration {
7308 #[serde(default)]
7309 pub name: String,
7310}
7311
7312#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7313#[serde(rename_all = "camelCase")]
7314pub struct TerminalInteractionNotification {
7315 #[serde(rename = "itemId", default)]
7316 pub item_id: String,
7317 #[serde(rename = "processId", default)]
7318 pub process_id: String,
7319 #[serde(default)]
7320 pub stdin: String,
7321 #[serde(rename = "threadId", default)]
7322 pub thread_id: String,
7323 #[serde(rename = "turnId", default)]
7324 pub turn_id: String,
7325}
7326
7327#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7328#[serde(rename_all = "camelCase")]
7329pub struct TextElement {
7330 #[serde(rename = "byteRange", default)]
7331 pub byte_range: Value,
7332 #[serde(default, skip_serializing_if = "Option::is_none")]
7333 pub placeholder: Option<String>,
7334}
7335
7336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7337#[serde(rename_all = "camelCase")]
7338pub struct TextPosition {
7339 #[serde(default)]
7340 pub column: i64,
7341 #[serde(default)]
7342 pub line: i64,
7343}
7344
7345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7346#[serde(rename_all = "camelCase")]
7347pub struct TextRange {
7348 #[serde()]
7349 pub end: TextPosition,
7350 #[serde()]
7351 pub start: TextPosition,
7352}
7353
7354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7355#[serde(rename_all = "camelCase")]
7356pub struct Thread {
7357 #[serde(
7358 rename = "agentNickname",
7359 default,
7360 skip_serializing_if = "Option::is_none"
7361 )]
7362 pub agent_nickname: Option<String>,
7363 #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
7364 pub agent_role: Option<String>,
7365 #[serde(rename = "cliVersion", default)]
7366 pub cli_version: String,
7367 #[serde(rename = "createdAt", default)]
7368 pub created_at: i64,
7369 #[serde(default)]
7370 pub cwd: Value,
7371 #[serde(default)]
7372 pub ephemeral: bool,
7373 #[serde(
7374 rename = "forkedFromId",
7375 default,
7376 skip_serializing_if = "Option::is_none"
7377 )]
7378 pub forked_from_id: Option<String>,
7379 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
7380 pub git_info: Option<GitInfo>,
7381 #[serde(
7384 rename = "historyMode",
7385 default,
7386 skip_serializing_if = "Option::is_none"
7387 )]
7388 pub history_mode: Option<ThreadHistoryMode>,
7389 #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
7392 pub project_id: Option<String>,
7393 #[serde(default)]
7394 pub id: String,
7395 #[serde(default, skip_serializing_if = "Option::is_none")]
7398 pub model: Option<String>,
7399 #[serde(rename = "modelProvider", default)]
7400 pub model_provider: String,
7401 #[serde(default, skip_serializing_if = "Option::is_none")]
7402 pub name: Option<String>,
7403 #[serde(default, skip_serializing_if = "Option::is_none")]
7407 pub originator: Option<String>,
7408 #[serde(
7409 rename = "parentThreadId",
7410 default,
7411 skip_serializing_if = "Option::is_none"
7412 )]
7413 pub parent_thread_id: Option<String>,
7414 #[serde(default, skip_serializing_if = "Option::is_none")]
7415 pub path: Option<String>,
7416 #[serde(default)]
7417 pub preview: String,
7418 #[serde(
7422 rename = "reasoningEffort",
7423 default,
7424 skip_serializing_if = "Option::is_none"
7425 )]
7426 pub reasoning_effort: Option<ReasoningEffort>,
7427 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7428 pub recency_at: Option<i64>,
7429 #[serde(default, skip_serializing_if = "Option::is_none")]
7430 pub section: Option<ThreadSection>,
7431 #[serde(
7432 rename = "sectionEnteredAt",
7433 default,
7434 skip_serializing_if = "Option::is_none"
7435 )]
7436 pub section_entered_at: Option<i64>,
7437 #[serde(rename = "sessionId", default)]
7438 pub session_id: String,
7439 #[serde(default)]
7440 pub source: Value,
7441 #[serde(default)]
7442 pub status: Value,
7443 #[serde(
7444 rename = "threadSource",
7445 default,
7446 skip_serializing_if = "Option::is_none"
7447 )]
7448 pub thread_source: Option<ThreadSource>,
7449 #[serde(default)]
7450 pub turns: Vec<Turn>,
7451 #[serde(rename = "updatedAt", default)]
7452 pub updated_at: i64,
7453}
7454
7455#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7456pub enum ThreadActiveFlag {
7457 #[serde(rename = "waitingOnApproval")]
7458 WaitingOnApproval,
7459 #[serde(rename = "waitingOnUserInput")]
7460 WaitingOnUserInput,
7461}
7462
7463#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7464#[serde(rename_all = "camelCase")]
7465pub struct ThreadApproveGuardianDeniedActionParams {
7466 #[serde(default)]
7467 pub event: Value,
7468 #[serde(rename = "threadId", default)]
7469 pub thread_id: String,
7470}
7471
7472#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7473#[serde(rename_all = "camelCase")]
7474pub struct ThreadApproveGuardianDeniedActionResponse {
7475 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7476 pub extra: serde_json::Map<String, Value>,
7477}
7478
7479#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7480#[serde(rename_all = "camelCase")]
7481pub struct ThreadArchiveParams {
7482 #[serde(rename = "threadId", default)]
7483 pub thread_id: String,
7484}
7485
7486#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7487#[serde(rename_all = "camelCase")]
7488pub struct ThreadArchiveResponse {
7489 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7490 pub extra: serde_json::Map<String, Value>,
7491}
7492
7493#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7494#[serde(rename_all = "camelCase")]
7495pub struct ThreadArchivedNotification {
7496 #[serde(rename = "threadId", default)]
7497 pub thread_id: String,
7498}
7499
7500#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7502#[serde(rename_all = "camelCase")]
7503pub struct ThreadAttachment {
7504 #[serde(rename = "attachmentType", default)]
7505 pub attachment_type: String,
7506 #[serde(rename = "createdAt", default)]
7507 pub created_at: i64,
7508 #[serde(default)]
7509 pub id: String,
7510 #[serde(rename = "identityKey", default)]
7511 pub identity_key: String,
7512 #[serde(default)]
7513 pub payload: Value,
7514}
7515
7516#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7518pub enum ThreadAttachmentAddOutcome {
7519 #[serde(rename = "created")]
7520 Created,
7521 #[serde(rename = "existing")]
7522 Existing,
7523}
7524
7525#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7527#[serde(rename_all = "camelCase")]
7528pub struct ThreadAttachmentAddParams {
7529 #[serde(rename = "attachmentType", default)]
7530 pub attachment_type: String,
7531 #[serde(rename = "identityKey", default)]
7532 pub identity_key: String,
7533 #[serde(default)]
7534 pub payload: Value,
7535 #[serde(rename = "threadId", default)]
7536 pub thread_id: String,
7537}
7538
7539#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7541#[serde(rename_all = "camelCase")]
7542pub struct ThreadAttachmentAddResponse {
7543 pub attachment: ThreadAttachment,
7544 pub outcome: ThreadAttachmentAddOutcome,
7545}
7546
7547#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7549#[serde(rename_all = "camelCase")]
7550pub struct ThreadAttachmentListParams {
7551 #[serde(default, skip_serializing_if = "Option::is_none")]
7552 pub cursor: Option<String>,
7553 #[serde(default, skip_serializing_if = "Option::is_none")]
7554 pub limit: Option<i64>,
7555 #[serde(rename = "threadId", default)]
7556 pub thread_id: String,
7557}
7558
7559#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7561#[serde(rename_all = "camelCase")]
7562pub struct ThreadAttachmentListResponse {
7563 #[serde(default)]
7564 pub data: Vec<ThreadAttachment>,
7565 #[serde(
7566 rename = "nextCursor",
7567 default,
7568 skip_serializing_if = "Option::is_none"
7569 )]
7570 pub next_cursor: Option<String>,
7571}
7572
7573#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7575pub enum ThreadAttachmentOperation {
7576 #[serde(rename = "created")]
7577 Created,
7578 #[serde(rename = "deleted")]
7579 Deleted,
7580}
7581
7582#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7584#[serde(rename_all = "camelCase")]
7585pub struct ThreadAttachmentOwner {
7586 #[serde(default)]
7588 pub archived: bool,
7589 #[serde(rename = "threadId", default)]
7590 pub thread_id: String,
7591}
7592
7593#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7595#[serde(rename_all = "camelCase")]
7596pub struct ThreadAttachmentOwnerListParams {
7597 #[serde(default, skip_serializing_if = "Option::is_none")]
7599 pub archived: Option<bool>,
7600 #[serde(rename = "attachmentType", default)]
7601 pub attachment_type: String,
7602 #[serde(default, skip_serializing_if = "Option::is_none")]
7603 pub cursor: Option<String>,
7604 #[serde(rename = "identityKey", default)]
7605 pub identity_key: String,
7606 #[serde(default, skip_serializing_if = "Option::is_none")]
7607 pub limit: Option<i64>,
7608}
7609
7610#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7612#[serde(rename_all = "camelCase")]
7613pub struct ThreadAttachmentOwnerListResponse {
7614 #[serde(default)]
7615 pub data: Vec<ThreadAttachmentOwner>,
7616 #[serde(
7617 rename = "nextCursor",
7618 default,
7619 skip_serializing_if = "Option::is_none"
7620 )]
7621 pub next_cursor: Option<String>,
7622}
7623
7624#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7626#[serde(rename_all = "camelCase")]
7627pub struct ThreadAttachmentRemoveParams {
7628 #[serde(rename = "attachmentType", default)]
7629 pub attachment_type: String,
7630 #[serde(rename = "identityKey", default)]
7631 pub identity_key: String,
7632 #[serde(rename = "threadId", default)]
7633 pub thread_id: String,
7634}
7635
7636#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7638#[serde(rename_all = "camelCase")]
7639pub struct ThreadAttachmentRemoveResponse {
7640 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7641 pub extra: serde_json::Map<String, Value>,
7642}
7643
7644#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7646#[serde(rename_all = "camelCase")]
7647pub struct ThreadAttachmentUpdatedNotification {
7648 #[serde(rename = "attachmentId", default)]
7649 pub attachment_id: String,
7650 #[serde(rename = "attachmentType", default)]
7651 pub attachment_type: String,
7652 #[serde(rename = "identityKey", default)]
7653 pub identity_key: String,
7654 pub operation: ThreadAttachmentOperation,
7655 #[serde(rename = "threadId", default)]
7656 pub thread_id: String,
7657}
7658
7659#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7660#[serde(rename_all = "camelCase")]
7661pub struct ThreadClosedNotification {
7662 #[serde(rename = "threadId", default)]
7663 pub thread_id: String,
7664}
7665
7666#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7667#[serde(rename_all = "camelCase")]
7668pub struct ThreadCompactStartParams {
7669 #[serde(rename = "threadId", default)]
7670 pub thread_id: String,
7671}
7672
7673#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7674#[serde(rename_all = "camelCase")]
7675pub struct ThreadCompactStartResponse {
7676 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7677 pub extra: serde_json::Map<String, Value>,
7678}
7679
7680#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7681#[serde(rename_all = "camelCase")]
7682pub struct ThreadDeleteParams {
7683 #[serde(rename = "threadId", default)]
7684 pub thread_id: String,
7685}
7686
7687#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7688#[serde(rename_all = "camelCase")]
7689pub struct ThreadDeleteResponse {
7690 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7691 pub extra: serde_json::Map<String, Value>,
7692}
7693
7694#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7695#[serde(rename_all = "camelCase")]
7696pub struct ThreadDeletedNotification {
7697 #[serde(rename = "threadId", default)]
7698 pub thread_id: String,
7699}
7700
7701#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7702#[serde(rename_all = "camelCase")]
7703pub struct ThreadForkParams {
7704 #[serde(
7705 rename = "approvalPolicy",
7706 default,
7707 skip_serializing_if = "Option::is_none"
7708 )]
7709 pub approval_policy: Option<AskForApproval>,
7710 #[serde(
7711 rename = "approvalsReviewer",
7712 default,
7713 skip_serializing_if = "Option::is_none"
7714 )]
7715 pub approvals_reviewer: Option<ApprovalsReviewer>,
7716 #[serde(
7717 rename = "baseInstructions",
7718 default,
7719 skip_serializing_if = "Option::is_none"
7720 )]
7721 pub base_instructions: Option<String>,
7722 #[serde(default, skip_serializing_if = "Option::is_none")]
7723 pub config: Option<Value>,
7724 #[serde(default, skip_serializing_if = "Option::is_none")]
7725 pub cwd: Option<String>,
7726 #[serde(
7727 rename = "developerInstructions",
7728 default,
7729 skip_serializing_if = "Option::is_none"
7730 )]
7731 pub developer_instructions: Option<String>,
7732 #[serde(default, skip_serializing_if = "Option::is_none")]
7733 pub ephemeral: Option<bool>,
7734 #[serde(
7735 rename = "excludeTurns",
7736 default,
7737 skip_serializing_if = "Option::is_none"
7738 )]
7739 pub exclude_turns: Option<bool>,
7740 #[serde(
7741 rename = "lastTurnId",
7742 default,
7743 skip_serializing_if = "Option::is_none"
7744 )]
7745 pub last_turn_id: Option<String>,
7746 #[serde(default, skip_serializing_if = "Option::is_none")]
7747 pub model: Option<String>,
7748 #[serde(
7749 rename = "modelProvider",
7750 default,
7751 skip_serializing_if = "Option::is_none"
7752 )]
7753 pub model_provider: Option<String>,
7754 #[serde(default, skip_serializing_if = "Option::is_none")]
7755 pub sandbox: Option<SandboxMode>,
7756 #[serde(
7757 rename = "serviceTier",
7758 default,
7759 skip_serializing_if = "Option::is_none"
7760 )]
7761 pub service_tier: Option<String>,
7762 #[serde(rename = "threadId", default)]
7763 pub thread_id: String,
7764 #[serde(
7765 rename = "threadSource",
7766 default,
7767 skip_serializing_if = "Option::is_none"
7768 )]
7769 pub thread_source: Option<ThreadSource>,
7770}
7771
7772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7773#[serde(rename_all = "camelCase")]
7774pub struct ThreadForkResponse {
7775 #[serde(rename = "approvalPolicy")]
7776 pub approval_policy: AskForApproval,
7777 #[serde(rename = "approvalsReviewer", default)]
7778 pub approvals_reviewer: Value,
7779 #[serde()]
7780 pub cwd: AbsolutePathBuf,
7781 #[serde(rename = "disabledPluginIds", default)]
7784 pub disabled_plugin_ids: Vec<String>,
7785 #[serde(
7786 rename = "instructionSources",
7787 default,
7788 skip_serializing_if = "Option::is_none"
7789 )]
7790 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
7791 #[serde(default)]
7792 pub model: String,
7793 #[serde(rename = "modelProvider", default)]
7794 pub model_provider: String,
7795 #[serde(
7796 rename = "reasoningEffort",
7797 default,
7798 skip_serializing_if = "Option::is_none"
7799 )]
7800 pub reasoning_effort: Option<ReasoningEffort>,
7801 #[serde(default)]
7802 pub sandbox: Value,
7803 #[serde(
7804 rename = "serviceTier",
7805 default,
7806 skip_serializing_if = "Option::is_none"
7807 )]
7808 pub service_tier: Option<String>,
7809 #[serde()]
7810 pub thread: Thread,
7811}
7812
7813#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7814#[serde(rename_all = "camelCase")]
7815pub struct ThreadGoal {
7816 #[serde(rename = "createdAt", default)]
7817 pub created_at: i64,
7818 #[serde(default)]
7819 pub objective: String,
7820 #[serde()]
7821 pub status: ThreadGoalStatus,
7822 #[serde(rename = "threadId", default)]
7823 pub thread_id: String,
7824 #[serde(rename = "timeUsedSeconds", default)]
7825 pub time_used_seconds: i64,
7826 #[serde(
7827 rename = "tokenBudget",
7828 default,
7829 skip_serializing_if = "Option::is_none"
7830 )]
7831 pub token_budget: Option<i64>,
7832 #[serde(rename = "tokensUsed", default)]
7833 pub tokens_used: i64,
7834 #[serde(rename = "updatedAt", default)]
7835 pub updated_at: i64,
7836}
7837
7838#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7839#[serde(rename_all = "camelCase")]
7840pub struct ThreadGoalClearParams {
7841 #[serde(default, skip_serializing_if = "Option::is_none")]
7843 pub origin: Option<ThreadGoalMutationOrigin>,
7844 #[serde(rename = "threadId", default)]
7845 pub thread_id: String,
7846}
7847
7848#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7849#[serde(rename_all = "camelCase")]
7850pub struct ThreadGoalClearResponse {
7851 #[serde(default)]
7852 pub cleared: bool,
7853}
7854
7855#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7856#[serde(rename_all = "camelCase")]
7857pub struct ThreadGoalClearedNotification {
7858 #[serde(rename = "threadId", default)]
7859 pub thread_id: String,
7860}
7861
7862#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7863#[serde(rename_all = "camelCase")]
7864pub struct ThreadGoalGetParams {
7865 #[serde(rename = "threadId", default)]
7866 pub thread_id: String,
7867}
7868
7869#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7870#[serde(rename_all = "camelCase")]
7871pub struct ThreadGoalGetResponse {
7872 #[serde(default, skip_serializing_if = "Option::is_none")]
7873 pub goal: Option<ThreadGoal>,
7874}
7875
7876#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7878pub enum ThreadGoalMutationOrigin {
7879 #[serde(rename = "user")]
7880 User,
7881 #[serde(rename = "automatic")]
7882 Automatic,
7883}
7884
7885#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7886#[serde(rename_all = "camelCase")]
7887pub struct ThreadGoalSetParams {
7888 #[serde(default, skip_serializing_if = "Option::is_none")]
7889 pub objective: Option<String>,
7890 #[serde(default, skip_serializing_if = "Option::is_none")]
7892 pub origin: Option<ThreadGoalMutationOrigin>,
7893 #[serde(default, skip_serializing_if = "Option::is_none")]
7894 pub status: Option<ThreadGoalStatus>,
7895 #[serde(rename = "threadId", default)]
7896 pub thread_id: String,
7897 #[serde(
7898 rename = "tokenBudget",
7899 default,
7900 skip_serializing_if = "Option::is_none"
7901 )]
7902 pub token_budget: Option<i64>,
7903}
7904
7905#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7906#[serde(rename_all = "camelCase")]
7907pub struct ThreadGoalSetResponse {
7908 #[serde()]
7909 pub goal: ThreadGoal,
7910}
7911
7912#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7913pub enum ThreadGoalStatus {
7914 #[serde(rename = "active")]
7915 Active,
7916 #[serde(rename = "paused")]
7917 Paused,
7918 #[serde(rename = "blocked")]
7919 Blocked,
7920 #[serde(rename = "usageLimited")]
7921 UsageLimited,
7922 #[serde(rename = "budgetLimited")]
7923 BudgetLimited,
7924 #[serde(rename = "complete")]
7925 Complete,
7926}
7927
7928#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7929#[serde(rename_all = "camelCase")]
7930pub struct ThreadGoalUpdatedNotification {
7931 #[serde()]
7932 pub goal: ThreadGoal,
7933 #[serde(rename = "threadId", default)]
7934 pub thread_id: String,
7935 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
7936 pub turn_id: Option<String>,
7937}
7938
7939#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
7940#[serde(transparent)]
7941pub struct ThreadId(pub String);
7942
7943#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7944#[serde(rename_all = "camelCase")]
7945pub struct ThreadInjectItemsParams {
7946 #[serde(default)]
7947 pub items: Vec<Value>,
7948 #[serde(rename = "threadId", default)]
7949 pub thread_id: String,
7950}
7951
7952#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7953#[serde(rename_all = "camelCase")]
7954pub struct ThreadInjectItemsResponse {
7955 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7956 pub extra: serde_json::Map<String, Value>,
7957}
7958
7959#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7960#[serde(tag = "type", rename_all = "camelCase")]
7961pub enum ThreadItem {
7962 #[serde(rename = "userMessage")]
7963 UserMessage {
7964 #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
7965 client_id: Option<String>,
7966 content: Vec<UserInput>,
7967 id: String,
7968 },
7969 #[serde(rename = "hookPrompt")]
7970 HookPrompt {
7971 fragments: Vec<HookPromptFragment>,
7972 id: String,
7973 },
7974 #[serde(rename = "agentMessage")]
7975 AgentMessage {
7976 #[serde(default, skip_serializing_if = "Option::is_none")]
7977 delivery: Option<AgentMessageDelivery>,
7978 id: String,
7979 #[serde(
7980 rename = "memoryCitation",
7981 default,
7982 skip_serializing_if = "Option::is_none"
7983 )]
7984 memory_citation: Option<MemoryCitation>,
7985 #[serde(default, skip_serializing_if = "Option::is_none")]
7986 phase: Option<MessagePhase>,
7987 #[serde(default, skip_serializing_if = "Option::is_none")]
7988 questions: Option<Vec<AsyncUserInputQuestion>>,
7989 text: String,
7990 },
7991 Plan {
7992 id: String,
7993 text: String,
7994 },
7995 Reasoning {
7996 #[serde(default, skip_serializing_if = "Option::is_none")]
7997 content: Option<Vec<String>>,
7998 id: String,
7999 #[serde(default, skip_serializing_if = "Option::is_none")]
8000 summary: Option<Vec<String>>,
8001 },
8002 #[serde(rename = "commandExecution")]
8003 CommandExecution {
8004 #[serde(
8005 rename = "aggregatedOutput",
8006 default,
8007 skip_serializing_if = "Option::is_none"
8008 )]
8009 aggregated_output: Option<String>,
8010 command: String,
8011 #[serde(rename = "commandActions")]
8012 command_actions: Vec<CommandAction>,
8013 cwd: Value,
8014 #[serde(
8015 rename = "durationMs",
8016 default,
8017 skip_serializing_if = "Option::is_none"
8018 )]
8019 duration_ms: Option<i64>,
8020 #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
8021 exit_code: Option<i64>,
8022 id: String,
8023 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8024 plugin_id: Option<String>,
8025 #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
8026 process_id: Option<String>,
8027 #[serde(
8028 rename = "scriptPath",
8029 default,
8030 skip_serializing_if = "Option::is_none"
8031 )]
8032 script_path: Option<String>,
8033 #[serde(default, skip_serializing_if = "Option::is_none")]
8034 source: Option<Value>,
8035 status: CommandExecutionStatus,
8036 },
8037 #[serde(rename = "fileChange")]
8038 FileChange {
8039 changes: Vec<FileUpdateChange>,
8040 id: String,
8041 status: PatchApplyStatus,
8042 },
8043 #[serde(rename = "mcpToolCall")]
8044 McpToolCall {
8045 #[serde(
8046 rename = "appContext",
8047 default,
8048 skip_serializing_if = "Option::is_none"
8049 )]
8050 app_context: Option<McpToolCallAppContext>,
8051 arguments: Value,
8052 #[serde(
8053 rename = "durationMs",
8054 default,
8055 skip_serializing_if = "Option::is_none"
8056 )]
8057 duration_ms: Option<i64>,
8058 #[serde(default, skip_serializing_if = "Option::is_none")]
8059 error: Option<McpToolCallError>,
8060 id: String,
8061 #[serde(
8064 rename = "mcpAppResourceUri",
8065 default,
8066 skip_serializing_if = "Option::is_none"
8067 )]
8068 mcp_app_resource_uri: Option<String>,
8069 #[serde(rename = "mcpAppUi", default, skip_serializing_if = "Option::is_none")]
8072 mcp_app_ui: Option<McpAppUi>,
8073 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8074 plugin_id: Option<String>,
8075 #[serde(
8076 rename = "readOnlyHint",
8077 default,
8078 skip_serializing_if = "Option::is_none"
8079 )]
8080 read_only_hint: Option<bool>,
8081 #[serde(default, skip_serializing_if = "Option::is_none")]
8082 result: Option<McpToolCallResult>,
8083 server: String,
8084 status: McpToolCallStatus,
8085 tool: String,
8086 },
8087 #[serde(rename = "dynamicToolCall")]
8088 DynamicToolCall {
8089 arguments: Value,
8090 #[serde(
8091 rename = "contentItems",
8092 default,
8093 skip_serializing_if = "Option::is_none"
8094 )]
8095 content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
8096 #[serde(
8097 rename = "durationMs",
8098 default,
8099 skip_serializing_if = "Option::is_none"
8100 )]
8101 duration_ms: Option<i64>,
8102 id: String,
8103 #[serde(default, skip_serializing_if = "Option::is_none")]
8104 namespace: Option<String>,
8105 status: DynamicToolCallStatus,
8106 #[serde(default, skip_serializing_if = "Option::is_none")]
8107 success: Option<bool>,
8108 tool: String,
8109 },
8110 #[serde(rename = "collabAgentToolCall")]
8111 CollabAgentToolCall {
8112 #[serde(rename = "agentsStates")]
8113 agents_states: std::collections::BTreeMap<String, CollabAgentState>,
8114 id: String,
8115 #[serde(default, skip_serializing_if = "Option::is_none")]
8116 model: Option<String>,
8117 #[serde(default, skip_serializing_if = "Option::is_none")]
8118 prompt: Option<String>,
8119 #[serde(
8120 rename = "reasoningEffort",
8121 default,
8122 skip_serializing_if = "Option::is_none"
8123 )]
8124 reasoning_effort: Option<ReasoningEffort>,
8125 #[serde(rename = "receiverThreadIds")]
8126 receiver_thread_ids: Vec<String>,
8127 #[serde(rename = "senderThreadId")]
8128 sender_thread_id: String,
8129 status: Value,
8130 tool: Value,
8131 },
8132 #[serde(rename = "subAgentActivity")]
8133 SubAgentActivity {
8134 #[serde(rename = "agentPath")]
8135 agent_path: String,
8136 #[serde(rename = "agentThreadId")]
8137 agent_thread_id: String,
8138 id: String,
8139 kind: SubAgentActivityKind,
8140 #[serde(default, skip_serializing_if = "Option::is_none")]
8143 model: Option<String>,
8144 #[serde(
8146 rename = "reasoningEffort",
8147 default,
8148 skip_serializing_if = "Option::is_none"
8149 )]
8150 reasoning_effort: Option<ReasoningEffort>,
8151 },
8152 #[serde(rename = "webSearch")]
8153 WebSearch {
8154 #[serde(default, skip_serializing_if = "Option::is_none")]
8155 action: Option<WebSearchAction>,
8156 id: String,
8157 query: String,
8158 #[serde(default, skip_serializing_if = "Option::is_none")]
8159 results: Option<Vec<Value>>,
8160 },
8161 #[serde(rename = "imageView")]
8162 ImageView {
8163 id: String,
8164 path: LegacyAppPathString,
8165 },
8166 Sleep {
8167 #[serde(rename = "durationMs")]
8168 duration_ms: i64,
8169 id: String,
8170 },
8171 #[serde(rename = "imageGeneration")]
8172 ImageGeneration {
8173 #[serde(default, skip_serializing_if = "Option::is_none")]
8174 failure: Option<ImageGenerationFailure>,
8175 id: String,
8176 #[serde(flatten)]
8177 image: GeneratedImageRef,
8178 #[serde(
8180 rename = "inputImages",
8181 default,
8182 skip_serializing_if = "Option::is_none"
8183 )]
8184 input_images: Option<Vec<ImageGenerationInputImage>>,
8185 #[serde(
8186 rename = "revisedPrompt",
8187 default,
8188 skip_serializing_if = "Option::is_none"
8189 )]
8190 revised_prompt: Option<String>,
8191 #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
8192 saved_path: Option<AbsolutePathBuf>,
8193 status: String,
8194 #[serde(
8195 rename = "transparentBackground",
8196 default,
8197 skip_serializing_if = "Option::is_none"
8198 )]
8199 transparent_background: Option<bool>,
8200 },
8201 #[serde(rename = "enteredReviewMode")]
8202 EnteredReviewMode {
8203 id: String,
8204 review: String,
8205 },
8206 #[serde(rename = "exitedReviewMode")]
8207 ExitedReviewMode {
8208 id: String,
8209 review: String,
8210 },
8211 #[serde(rename = "contextCompaction")]
8212 ContextCompaction {
8213 id: String,
8214 },
8215 #[serde(rename = "functionCallOutput")]
8216 FunctionCallOutput {
8217 id: String,
8218 name: String,
8219 #[serde(default, skip_serializing_if = "Option::is_none")]
8220 namespace: Option<String>,
8221 output: FunctionCallOutputBody,
8222 },
8223}
8224
8225#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8226#[serde(untagged)]
8227pub enum ThreadListCwdFilter {
8228 Variant0(String),
8229 Variant1(Vec<String>),
8230}
8231
8232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8233#[serde(rename_all = "camelCase")]
8234pub struct ThreadListParams {
8235 #[serde(default, skip_serializing_if = "Option::is_none")]
8236 pub archived: Option<bool>,
8237 #[serde(default, skip_serializing_if = "Option::is_none")]
8238 pub cursor: Option<String>,
8239 #[serde(default, skip_serializing_if = "Option::is_none")]
8240 pub cwd: Option<ThreadListCwdFilter>,
8241 #[serde(
8246 rename = "excludedThreadIds",
8247 default,
8248 skip_serializing_if = "Option::is_none"
8249 )]
8250 pub excluded_thread_ids: Option<Vec<String>>,
8251 #[serde(default, skip_serializing_if = "Option::is_none")]
8252 pub limit: Option<i64>,
8253 #[serde(
8254 rename = "modelProviders",
8255 default,
8256 skip_serializing_if = "Option::is_none"
8257 )]
8258 pub model_providers: Option<Vec<String>>,
8259 #[serde(default, skip_serializing_if = "Option::is_none")]
8263 pub originators: Option<Vec<String>>,
8264 #[serde(
8265 rename = "searchTerm",
8266 default,
8267 skip_serializing_if = "Option::is_none"
8268 )]
8269 pub search_term: Option<String>,
8270 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8271 pub section_id: Option<String>,
8272 #[serde(
8273 rename = "sortDirection",
8274 default,
8275 skip_serializing_if = "Option::is_none"
8276 )]
8277 pub sort_direction: Option<SortDirection>,
8278 #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
8279 pub sort_key: Option<ThreadSortKey>,
8280 #[serde(
8281 rename = "sourceKinds",
8282 default,
8283 skip_serializing_if = "Option::is_none"
8284 )]
8285 pub source_kinds: Option<Vec<ThreadSourceKind>>,
8286 #[serde(
8287 rename = "useStateDbOnly",
8288 default,
8289 skip_serializing_if = "Option::is_none"
8290 )]
8291 pub use_state_db_only: Option<bool>,
8292}
8293
8294#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8295#[serde(rename_all = "camelCase")]
8296pub struct ThreadListResponse {
8297 #[serde(
8298 rename = "backwardsCursor",
8299 default,
8300 skip_serializing_if = "Option::is_none"
8301 )]
8302 pub backwards_cursor: Option<String>,
8303 #[serde(default)]
8304 pub data: Vec<Thread>,
8305 #[serde(
8306 rename = "nextCursor",
8307 default,
8308 skip_serializing_if = "Option::is_none"
8309 )]
8310 pub next_cursor: Option<String>,
8311}
8312
8313#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8314#[serde(rename_all = "camelCase")]
8315pub struct ThreadLoadedListParams {
8316 #[serde(default, skip_serializing_if = "Option::is_none")]
8317 pub cursor: Option<String>,
8318 #[serde(default, skip_serializing_if = "Option::is_none")]
8319 pub limit: Option<i64>,
8320}
8321
8322#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8323#[serde(rename_all = "camelCase")]
8324pub struct ThreadLoadedListResponse {
8325 #[serde(default)]
8326 pub data: Vec<String>,
8327 #[serde(
8328 rename = "nextCursor",
8329 default,
8330 skip_serializing_if = "Option::is_none"
8331 )]
8332 pub next_cursor: Option<String>,
8333}
8334
8335#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8336#[serde(rename_all = "camelCase")]
8337pub struct ThreadMetadataGitInfoUpdateParams {
8338 #[serde(default, skip_serializing_if = "Option::is_none")]
8339 pub branch: Option<String>,
8340 #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
8341 pub origin_url: Option<String>,
8342 #[serde(default, skip_serializing_if = "Option::is_none")]
8343 pub sha: Option<String>,
8344}
8345
8346#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8347#[serde(rename_all = "camelCase")]
8348pub struct ThreadMetadataUpdateParams {
8349 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
8350 pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
8351 #[serde(rename = "threadId", default)]
8352 pub thread_id: String,
8353}
8354
8355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8356#[serde(rename_all = "camelCase")]
8357pub struct ThreadMetadataUpdateResponse {
8358 #[serde()]
8359 pub thread: Thread,
8360}
8361
8362#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8363#[serde(rename_all = "camelCase")]
8364pub struct ThreadNameUpdatedNotification {
8365 #[serde(rename = "threadId", default)]
8366 pub thread_id: String,
8367 #[serde(
8368 rename = "threadName",
8369 default,
8370 skip_serializing_if = "Option::is_none"
8371 )]
8372 pub thread_name: Option<String>,
8373}
8374
8375#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8376#[serde(rename_all = "camelCase")]
8377pub struct ThreadReadParams {
8378 #[serde(
8379 rename = "includeTurns",
8380 default,
8381 skip_serializing_if = "Option::is_none"
8382 )]
8383 pub include_turns: Option<bool>,
8384 #[serde(rename = "threadId", default)]
8385 pub thread_id: String,
8386}
8387
8388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8389#[serde(rename_all = "camelCase")]
8390pub struct ThreadReadResponse {
8391 #[serde()]
8392 pub thread: Thread,
8393}
8394
8395#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8398#[serde(rename_all = "camelCase")]
8399pub struct ThreadReadState {
8400 #[serde(
8401 rename = "firstUnread",
8402 default,
8403 skip_serializing_if = "Option::is_none"
8404 )]
8405 pub first_unread: Option<ThreadUnreadPosition>,
8406 #[serde(default)]
8407 pub revision: String,
8408}
8409
8410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8411#[serde(rename_all = "camelCase")]
8412pub struct ThreadReadStateChangedNotification {
8413 #[serde(rename = "readState")]
8414 pub read_state: ThreadReadState,
8415 #[serde(rename = "threadId", default)]
8416 pub thread_id: String,
8417}
8418
8419#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8420#[serde(rename_all = "camelCase")]
8421pub struct ThreadRealtimeAudioChunk {
8422 #[serde(default)]
8423 pub data: String,
8424 #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
8425 pub item_id: Option<String>,
8426 #[serde(rename = "numChannels", default)]
8427 pub num_channels: i64,
8428 #[serde(rename = "sampleRate", default)]
8429 pub sample_rate: i64,
8430 #[serde(
8431 rename = "samplesPerChannel",
8432 default,
8433 skip_serializing_if = "Option::is_none"
8434 )]
8435 pub samples_per_channel: Option<i64>,
8436}
8437
8438#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8439#[serde(rename_all = "camelCase")]
8440pub struct ThreadRealtimeClosedNotification {
8441 #[serde(default, skip_serializing_if = "Option::is_none")]
8442 pub reason: Option<String>,
8443 #[serde(rename = "threadId", default)]
8444 pub thread_id: String,
8445}
8446
8447#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8448#[serde(rename_all = "camelCase")]
8449pub struct ThreadRealtimeErrorNotification {
8450 #[serde(default)]
8451 pub message: String,
8452 #[serde(rename = "threadId", default)]
8453 pub thread_id: String,
8454}
8455
8456#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8457#[serde(rename_all = "camelCase")]
8458pub struct ThreadRealtimeItemAddedNotification {
8459 #[serde(default)]
8460 pub item: Value,
8461 #[serde(rename = "threadId", default)]
8462 pub thread_id: String,
8463}
8464
8465#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8466#[serde(rename_all = "camelCase")]
8467pub struct ThreadRealtimeOutputAudioDeltaNotification {
8468 #[serde()]
8469 pub audio: ThreadRealtimeAudioChunk,
8470 #[serde(rename = "threadId", default)]
8471 pub thread_id: String,
8472}
8473
8474#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8475#[serde(rename_all = "camelCase")]
8476pub struct ThreadRealtimeSdpNotification {
8477 #[serde(default)]
8478 pub sdp: String,
8479 #[serde(rename = "threadId", default)]
8480 pub thread_id: String,
8481}
8482
8483#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8484#[serde(rename_all = "camelCase")]
8485pub struct ThreadRealtimeStartedNotification {
8486 #[serde(
8487 rename = "realtimeSessionId",
8488 default,
8489 skip_serializing_if = "Option::is_none"
8490 )]
8491 pub realtime_session_id: Option<String>,
8492 #[serde(rename = "threadId", default)]
8493 pub thread_id: String,
8494 #[serde()]
8495 pub version: RealtimeConversationVersion,
8496}
8497
8498#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8499#[serde(rename_all = "camelCase")]
8500pub struct ThreadRealtimeTranscriptDeltaNotification {
8501 #[serde(default)]
8502 pub delta: String,
8503 #[serde(default)]
8504 pub role: String,
8505 #[serde(rename = "threadId", default)]
8506 pub thread_id: String,
8507}
8508
8509#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8510#[serde(rename_all = "camelCase")]
8511pub struct ThreadRealtimeTranscriptDoneNotification {
8512 #[serde(default)]
8513 pub role: String,
8514 #[serde(default)]
8515 pub text: String,
8516 #[serde(rename = "threadId", default)]
8517 pub thread_id: String,
8518}
8519
8520#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8521#[serde(rename_all = "camelCase")]
8522pub struct ThreadResumeParams {
8523 #[serde(
8524 rename = "approvalPolicy",
8525 default,
8526 skip_serializing_if = "Option::is_none"
8527 )]
8528 pub approval_policy: Option<AskForApproval>,
8529 #[serde(
8530 rename = "approvalsReviewer",
8531 default,
8532 skip_serializing_if = "Option::is_none"
8533 )]
8534 pub approvals_reviewer: Option<ApprovalsReviewer>,
8535 #[serde(
8536 rename = "baseInstructions",
8537 default,
8538 skip_serializing_if = "Option::is_none"
8539 )]
8540 pub base_instructions: Option<String>,
8541 #[serde(default, skip_serializing_if = "Option::is_none")]
8542 pub config: Option<Value>,
8543 #[serde(default, skip_serializing_if = "Option::is_none")]
8544 pub cwd: Option<String>,
8545 #[serde(
8546 rename = "developerInstructions",
8547 default,
8548 skip_serializing_if = "Option::is_none"
8549 )]
8550 pub developer_instructions: Option<String>,
8551 #[serde(default, skip_serializing_if = "Option::is_none")]
8552 pub model: Option<String>,
8553 #[serde(
8554 rename = "modelProvider",
8555 default,
8556 skip_serializing_if = "Option::is_none"
8557 )]
8558 pub model_provider: Option<String>,
8559 #[serde(default, skip_serializing_if = "Option::is_none")]
8560 pub personality: Option<Personality>,
8561 #[serde(default, skip_serializing_if = "Option::is_none")]
8562 pub sandbox: Option<SandboxMode>,
8563 #[serde(
8564 rename = "serviceTier",
8565 default,
8566 skip_serializing_if = "Option::is_none"
8567 )]
8568 pub service_tier: Option<String>,
8569 #[serde(rename = "threadId", default)]
8570 pub thread_id: String,
8571 #[serde(
8572 rename = "excludeTurns",
8573 default,
8574 skip_serializing_if = "Option::is_none"
8575 )]
8576 pub exclude_turns: Option<bool>,
8577}
8578
8579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8580#[serde(rename_all = "camelCase")]
8581pub struct ThreadResumeResponse {
8582 #[serde(rename = "approvalPolicy")]
8583 pub approval_policy: AskForApproval,
8584 #[serde(rename = "approvalsReviewer", default)]
8585 pub approvals_reviewer: Value,
8586 #[serde(
8589 rename = "collaborationMode",
8590 default,
8591 skip_serializing_if = "Option::is_none"
8592 )]
8593 pub collaboration_mode: Option<CollaborationMode>,
8594 #[serde()]
8595 pub cwd: AbsolutePathBuf,
8596 #[serde(rename = "disabledPluginIds", default)]
8599 pub disabled_plugin_ids: Vec<String>,
8600 #[serde(
8601 rename = "instructionSources",
8602 default,
8603 skip_serializing_if = "Option::is_none"
8604 )]
8605 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8606 #[serde(
8609 rename = "itemsBackwardsCursor",
8610 default,
8611 skip_serializing_if = "Option::is_none"
8612 )]
8613 pub items_backwards_cursor: Option<String>,
8614 #[serde(default)]
8615 pub model: String,
8616 #[serde(rename = "modelProvider", default)]
8617 pub model_provider: String,
8618 #[serde(
8619 rename = "reasoningEffort",
8620 default,
8621 skip_serializing_if = "Option::is_none"
8622 )]
8623 pub reasoning_effort: Option<ReasoningEffort>,
8624 #[serde(default)]
8625 pub sandbox: Value,
8626 #[serde(
8627 rename = "serviceTier",
8628 default,
8629 skip_serializing_if = "Option::is_none"
8630 )]
8631 pub service_tier: Option<String>,
8632 #[serde()]
8633 pub thread: Thread,
8634 #[serde(
8637 rename = "turnsBackwardsCursor",
8638 default,
8639 skip_serializing_if = "Option::is_none"
8640 )]
8641 pub turns_backwards_cursor: Option<String>,
8642}
8643
8644#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8646pub enum ThreadHistoryMode {
8647 #[serde(rename = "legacy")]
8648 Legacy,
8649 #[serde(rename = "paginated")]
8650 Paginated,
8651}
8652
8653#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8656#[serde(rename_all = "camelCase")]
8657pub struct ThreadItemEntry {
8658 #[serde(
8661 rename = "completedAtMs",
8662 default,
8663 skip_serializing_if = "Option::is_none"
8664 )]
8665 pub completed_at_ms: Option<i64>,
8666 #[serde()]
8667 pub item: ThreadItem,
8668 #[serde(
8671 rename = "startedAtMs",
8672 default,
8673 skip_serializing_if = "Option::is_none"
8674 )]
8675 pub started_at_ms: Option<i64>,
8676 #[serde(rename = "turnId", default)]
8677 pub turn_id: String,
8678}
8679
8680#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8682#[serde(rename_all = "camelCase")]
8683pub struct ThreadItemsListParams {
8684 #[serde(default, skip_serializing_if = "Option::is_none")]
8690 pub cursor: Option<ThreadItemsListCursor>,
8691 #[serde(default, skip_serializing_if = "Option::is_none")]
8692 pub limit: Option<u32>,
8693 #[serde(
8694 rename = "sortDirection",
8695 default,
8696 skip_serializing_if = "Option::is_none"
8697 )]
8698 pub sort_direction: Option<SortDirection>,
8699 #[serde(rename = "threadId", default)]
8700 pub thread_id: String,
8701 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8703 pub turn_id: Option<String>,
8704}
8705
8706#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8711#[serde(untagged)]
8712pub enum ThreadItemsListCursor {
8713 Opaque(String),
8714 Anchor(ThreadItemsListAnchor),
8715}
8716
8717#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8720#[serde(tag = "type", rename_all = "camelCase")]
8721pub enum ThreadItemsListAnchor {
8722 Item {
8723 #[serde(rename = "itemId")]
8724 item_id: String,
8725 },
8726}
8727
8728#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8730#[serde(rename_all = "camelCase")]
8731pub struct ThreadItemsListResponse {
8732 #[serde(
8733 rename = "backwardsCursor",
8734 default,
8735 skip_serializing_if = "Option::is_none"
8736 )]
8737 pub backwards_cursor: Option<String>,
8738 #[serde(default)]
8739 pub data: Vec<ThreadItemEntry>,
8740 #[serde(
8741 rename = "nextCursor",
8742 default,
8743 skip_serializing_if = "Option::is_none"
8744 )]
8745 pub next_cursor: Option<String>,
8746}
8747
8748#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8752pub struct ThreadRealtimeItem {
8753 #[serde(default)]
8754 pub id: String,
8755 #[serde(rename = "realtimeSessionId", default)]
8756 pub realtime_session_id: String,
8757 #[serde(flatten)]
8758 pub detail: ThreadRealtimeItemDetail,
8759}
8760
8761#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8763#[serde(tag = "type", rename_all = "camelCase")]
8764pub enum ThreadRealtimeItemDetail {
8765 #[serde(rename = "realtimeSessionStarted")]
8766 RealtimeSessionStarted,
8767 #[serde(rename = "transcriptSegment")]
8768 TranscriptSegment {
8769 role: ThreadRealtimeTranscriptRole,
8770 text: String,
8771 },
8772 #[serde(rename = "bemItemPromoted")]
8773 BemItemPromoted {
8774 item_id: String,
8775 presentation: ThreadRealtimeBemItemPresentation,
8776 turn_id: String,
8777 },
8778 #[serde(rename = "realtimeSessionClosed")]
8779 RealtimeSessionClosed {
8780 outcome: ThreadRealtimeSessionOutcome,
8781 },
8782}
8783
8784#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8787#[serde(tag = "type", rename_all = "camelCase")]
8788pub enum ThreadRealtimeBemItemPresentation {
8789 #[serde(rename = "wholeItem")]
8790 WholeItem,
8791 #[serde(rename = "inlineMarkdown")]
8792 InlineMarkdown,
8793 #[serde(rename = "inlineVisualization")]
8794 InlineVisualization { index: u32 },
8795}
8796
8797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8799#[serde(rename_all = "camelCase")]
8800pub struct ThreadRealtimeItemStartedNotification {
8801 #[serde()]
8802 pub item: ThreadRealtimeItem,
8803 #[serde(rename = "threadId", default)]
8804 pub thread_id: String,
8805}
8806
8807#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8809#[serde(rename_all = "camelCase")]
8810pub struct ThreadRealtimeItemCompletedNotification {
8811 #[serde()]
8812 pub item: ThreadRealtimeItem,
8813 #[serde(rename = "threadId", default)]
8814 pub thread_id: String,
8815}
8816
8817#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8820#[serde(rename_all = "camelCase")]
8821pub struct ThreadRealtimeItemTranscriptDeltaNotification {
8822 #[serde(default)]
8823 pub delta: String,
8824 #[serde(rename = "itemId", default)]
8825 pub item_id: String,
8826 #[serde(rename = "threadId", default)]
8827 pub thread_id: String,
8828}
8829
8830#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8832pub enum ThreadRealtimeSessionOutcome {
8833 #[serde(rename = "ended")]
8834 Ended,
8835 #[serde(rename = "failed")]
8836 Failed,
8837}
8838
8839#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8841pub enum ThreadRealtimeTranscriptRole {
8842 #[serde(rename = "user")]
8843 User,
8844 #[serde(rename = "assistant")]
8845 Assistant,
8846}
8847
8848#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8852#[serde(rename_all = "camelCase")]
8853pub struct ThreadRevertParams {
8854 #[serde(rename = "beforeTurnId", default)]
8856 pub before_turn_id: String,
8857 #[serde(rename = "threadId", default)]
8858 pub thread_id: String,
8859}
8860
8861#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8864#[serde(rename_all = "camelCase")]
8865pub struct ThreadRevertResponse {
8866 #[serde(
8867 rename = "itemsBackwardsCursor",
8868 default,
8869 skip_serializing_if = "Option::is_none"
8870 )]
8871 pub items_backwards_cursor: Option<String>,
8872 #[serde()]
8873 pub thread: Thread,
8874 #[serde(
8875 rename = "turnsBackwardsCursor",
8876 default,
8877 skip_serializing_if = "Option::is_none"
8878 )]
8879 pub turns_backwards_cursor: Option<String>,
8880}
8881
8882#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8883#[serde(rename_all = "camelCase")]
8884pub struct ThreadSection {
8885 #[serde(default, skip_serializing_if = "Option::is_none")]
8886 pub appearance: Option<ThreadSectionAppearance>,
8887 #[serde(default)]
8888 pub id: String,
8889 #[serde(default)]
8890 pub name: String,
8891}
8892
8893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8894#[serde(rename_all = "camelCase")]
8895pub struct ThreadSectionAppearance {
8896 #[serde(default, skip_serializing_if = "Option::is_none")]
8897 pub color: Option<String>,
8898 #[serde(default, skip_serializing_if = "Option::is_none")]
8899 pub icon: Option<String>,
8900}
8901
8902#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8903#[serde(rename_all = "camelCase")]
8904pub struct ThreadSectionCreateParams {
8905 #[serde(default, skip_serializing_if = "Option::is_none")]
8906 pub appearance: Option<ThreadSectionAppearance>,
8907 #[serde(default)]
8908 pub name: String,
8909}
8910
8911#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8912#[serde(rename_all = "camelCase")]
8913pub struct ThreadSectionCreateResponse {
8914 #[serde()]
8915 pub section: ThreadSection,
8916}
8917
8918#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8919#[serde(rename_all = "camelCase")]
8920pub struct ThreadSectionDeleteParams {
8921 #[serde(rename = "sectionId", default)]
8922 pub section_id: String,
8923}
8924
8925#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8926#[serde(rename_all = "camelCase")]
8927pub struct ThreadSectionDeleteResponse {
8928 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8929 pub extra: serde_json::Map<String, Value>,
8930}
8931
8932#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8933#[serde(rename_all = "camelCase")]
8934pub struct ThreadSectionListParams {
8935 #[serde(default, skip_serializing_if = "Option::is_none")]
8936 pub cursor: Option<String>,
8937 #[serde(default, skip_serializing_if = "Option::is_none")]
8938 pub limit: Option<i64>,
8939}
8940
8941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8942#[serde(rename_all = "camelCase")]
8943pub struct ThreadSectionListResponse {
8944 #[serde(default)]
8945 pub data: Vec<ThreadSection>,
8946 #[serde(
8947 rename = "nextCursor",
8948 default,
8949 skip_serializing_if = "Option::is_none"
8950 )]
8951 pub next_cursor: Option<String>,
8952}
8953
8954#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8955#[serde(rename_all = "camelCase")]
8956pub struct ThreadSectionMoveParams {
8957 #[serde(
8958 rename = "beforeThreadId",
8959 default,
8960 skip_serializing_if = "Option::is_none"
8961 )]
8962 pub before_thread_id: Option<String>,
8963 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8964 pub section_id: Option<String>,
8965 #[serde(rename = "threadId", default)]
8966 pub thread_id: String,
8967}
8968
8969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8970#[serde(rename_all = "camelCase")]
8971pub struct ThreadSectionMoveResponse {
8972 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8973 pub extra: serde_json::Map<String, Value>,
8974}
8975
8976#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8977#[serde(rename_all = "camelCase")]
8978pub struct ThreadSectionUpdateParams {
8979 #[serde(default, skip_serializing_if = "Option::is_none")]
8980 pub appearance: Option<ThreadSectionAppearance>,
8981 #[serde(default)]
8982 pub name: String,
8983 #[serde(rename = "sectionId", default)]
8984 pub section_id: String,
8985}
8986
8987#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8988#[serde(rename_all = "camelCase")]
8989pub struct ThreadSectionUpdateResponse {
8990 #[serde()]
8991 pub section: ThreadSection,
8992}
8993
8994#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8995#[serde(rename_all = "camelCase")]
8996pub struct ThreadSetNameParams {
8997 #[serde(default)]
8998 pub name: String,
8999 #[serde(rename = "threadId", default)]
9000 pub thread_id: String,
9001}
9002
9003#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9004#[serde(rename_all = "camelCase")]
9005pub struct ThreadSetNameResponse {
9006 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9007 pub extra: serde_json::Map<String, Value>,
9008}
9009
9010#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9011#[serde(rename_all = "camelCase")]
9012pub struct ThreadSettings {
9013 #[serde(
9014 rename = "activePermissionProfile",
9015 default,
9016 skip_serializing_if = "Option::is_none"
9017 )]
9018 pub active_permission_profile: Option<ActivePermissionProfile>,
9019 #[serde(rename = "approvalPolicy")]
9020 pub approval_policy: AskForApproval,
9021 #[serde(rename = "approvalsReviewer")]
9022 pub approvals_reviewer: ApprovalsReviewer,
9023 #[serde(rename = "collaborationMode")]
9024 pub collaboration_mode: CollaborationMode,
9025 #[serde()]
9026 pub cwd: AbsolutePathBuf,
9027 #[serde(rename = "disabledPluginIds", default)]
9030 pub disabled_plugin_ids: Vec<String>,
9031 #[serde(default, skip_serializing_if = "Option::is_none")]
9032 pub effort: Option<ReasoningEffort>,
9033 #[serde(default)]
9034 pub model: String,
9035 #[serde(rename = "modelProvider", default)]
9036 pub model_provider: String,
9037 #[serde(default, skip_serializing_if = "Option::is_none")]
9038 pub personality: Option<Personality>,
9039 #[serde(rename = "sandboxPolicy")]
9040 pub sandbox_policy: SandboxPolicy,
9041 #[serde(
9042 rename = "serviceTier",
9043 default,
9044 skip_serializing_if = "Option::is_none"
9045 )]
9046 pub service_tier: Option<String>,
9047 #[serde(default, skip_serializing_if = "Option::is_none")]
9048 pub summary: Option<ReasoningSummary>,
9049}
9050
9051#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9052#[serde(rename_all = "camelCase")]
9053pub struct ThreadSettingsUpdatedNotification {
9054 #[serde(rename = "threadId", default)]
9055 pub thread_id: String,
9056 #[serde(rename = "threadSettings")]
9057 pub thread_settings: ThreadSettings,
9058}
9059
9060#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9061#[serde(rename_all = "camelCase")]
9062pub struct ThreadShellCommandParams {
9063 #[serde(default)]
9064 pub command: String,
9065 #[serde(rename = "threadId", default)]
9066 pub thread_id: String,
9067 #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
9070 pub timeout_ms: Option<i64>,
9071}
9072
9073#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9074#[serde(rename_all = "camelCase")]
9075pub struct ThreadShellCommandResponse {
9076 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9077 pub extra: serde_json::Map<String, Value>,
9078}
9079
9080#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9081pub enum ThreadSortKey {
9082 #[serde(rename = "created_at")]
9083 Created_at,
9084 #[serde(rename = "updated_at")]
9085 Updated_at,
9086 #[serde(rename = "recency_at")]
9087 Recency_at,
9088 #[serde(rename = "section_position")]
9089 Section_position,
9090}
9091
9092#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
9093#[serde(transparent)]
9094pub struct ThreadSource(pub String);
9095
9096#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9097pub enum ThreadSourceKind {
9098 #[serde(rename = "cli")]
9099 Cli,
9100 #[serde(rename = "vscode")]
9101 Vscode,
9102 #[serde(rename = "exec")]
9103 Exec,
9104 #[serde(rename = "appServer")]
9105 AppServer,
9106 #[serde(rename = "subAgent")]
9107 SubAgent,
9108 #[serde(rename = "subAgentReview")]
9109 SubAgentReview,
9110 #[serde(rename = "subAgentCompact")]
9111 SubAgentCompact,
9112 #[serde(rename = "subAgentThreadSpawn")]
9113 SubAgentThreadSpawn,
9114 #[serde(rename = "subAgentOther")]
9115 SubAgentOther,
9116 #[serde(rename = "unknown")]
9117 Unknown,
9118}
9119
9120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9121#[serde(rename_all = "camelCase")]
9122pub struct ThreadStartParams {
9123 #[serde(
9124 rename = "approvalPolicy",
9125 default,
9126 skip_serializing_if = "Option::is_none"
9127 )]
9128 pub approval_policy: Option<AskForApproval>,
9129 #[serde(
9130 rename = "approvalsReviewer",
9131 default,
9132 skip_serializing_if = "Option::is_none"
9133 )]
9134 pub approvals_reviewer: Option<ApprovalsReviewer>,
9135 #[serde(
9136 rename = "baseInstructions",
9137 default,
9138 skip_serializing_if = "Option::is_none"
9139 )]
9140 pub base_instructions: Option<String>,
9141 #[serde(default, skip_serializing_if = "Option::is_none")]
9142 pub config: Option<Value>,
9143 #[serde(default, skip_serializing_if = "Option::is_none")]
9144 pub cwd: Option<String>,
9145 #[serde(
9146 rename = "developerInstructions",
9147 default,
9148 skip_serializing_if = "Option::is_none"
9149 )]
9150 pub developer_instructions: Option<String>,
9151 #[serde(default, skip_serializing_if = "Option::is_none")]
9152 pub ephemeral: Option<bool>,
9153 #[serde(default, skip_serializing_if = "Option::is_none")]
9154 pub model: Option<String>,
9155 #[serde(
9156 rename = "modelProvider",
9157 default,
9158 skip_serializing_if = "Option::is_none"
9159 )]
9160 pub model_provider: Option<String>,
9161 #[serde(default, skip_serializing_if = "Option::is_none")]
9162 pub personality: Option<Personality>,
9163 #[serde(default, skip_serializing_if = "Option::is_none")]
9164 pub sandbox: Option<SandboxMode>,
9165 #[serde(
9166 rename = "serviceName",
9167 default,
9168 skip_serializing_if = "Option::is_none"
9169 )]
9170 pub service_name: Option<String>,
9171 #[serde(
9172 rename = "serviceTier",
9173 default,
9174 skip_serializing_if = "Option::is_none"
9175 )]
9176 pub service_tier: Option<String>,
9177 #[serde(
9178 rename = "sessionStartSource",
9179 default,
9180 skip_serializing_if = "Option::is_none"
9181 )]
9182 pub session_start_source: Option<ThreadStartSource>,
9183 #[serde(
9184 rename = "threadSource",
9185 default,
9186 skip_serializing_if = "Option::is_none"
9187 )]
9188 pub thread_source: Option<ThreadSource>,
9189}
9190
9191#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9192#[serde(rename_all = "camelCase")]
9193pub struct ThreadStartResponse {
9194 #[serde(rename = "approvalPolicy")]
9195 pub approval_policy: AskForApproval,
9196 #[serde(rename = "approvalsReviewer", default)]
9197 pub approvals_reviewer: Value,
9198 #[serde()]
9199 pub cwd: AbsolutePathBuf,
9200 #[serde(rename = "disabledPluginIds", default)]
9203 pub disabled_plugin_ids: Vec<String>,
9204 #[serde(
9205 rename = "instructionSources",
9206 default,
9207 skip_serializing_if = "Option::is_none"
9208 )]
9209 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9210 #[serde(default)]
9211 pub model: String,
9212 #[serde(rename = "modelProvider", default)]
9213 pub model_provider: String,
9214 #[serde(
9215 rename = "reasoningEffort",
9216 default,
9217 skip_serializing_if = "Option::is_none"
9218 )]
9219 pub reasoning_effort: Option<ReasoningEffort>,
9220 #[serde(default)]
9221 pub sandbox: Value,
9222 #[serde(
9223 rename = "serviceTier",
9224 default,
9225 skip_serializing_if = "Option::is_none"
9226 )]
9227 pub service_tier: Option<String>,
9228 #[serde()]
9229 pub thread: Thread,
9230}
9231
9232#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9233pub enum ThreadStartSource {
9234 #[serde(rename = "startup")]
9235 Startup,
9236 #[serde(rename = "clear")]
9237 Clear,
9238}
9239
9240#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9241#[serde(rename_all = "camelCase")]
9242pub struct ThreadStartedNotification {
9243 #[serde()]
9244 pub thread: Thread,
9245}
9246
9247#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9248#[serde(tag = "type", rename_all = "camelCase")]
9249pub enum ThreadStatus {
9250 #[serde(rename = "notLoaded")]
9251 NotLoaded,
9252 Idle,
9253 #[serde(rename = "systemError")]
9254 SystemError,
9255 Active {
9256 #[serde(rename = "activeFlags")]
9257 active_flags: Vec<ThreadActiveFlag>,
9258 },
9259}
9260
9261#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9262#[serde(rename_all = "camelCase")]
9263pub struct ThreadStatusChangedNotification {
9264 #[serde()]
9265 pub status: ThreadStatus,
9266 #[serde(rename = "threadId", default)]
9267 pub thread_id: String,
9268}
9269
9270#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9271#[serde(rename_all = "camelCase")]
9272pub struct ThreadTokenUsage {
9273 #[serde()]
9274 pub last: TokenUsageBreakdown,
9275 #[serde(
9276 rename = "modelContextWindow",
9277 default,
9278 skip_serializing_if = "Option::is_none"
9279 )]
9280 pub model_context_window: Option<i64>,
9281 #[serde()]
9282 pub total: TokenUsageBreakdown,
9283}
9284
9285#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9286#[serde(rename_all = "camelCase")]
9287pub struct ThreadTokenUsageUpdatedNotification {
9288 #[serde(rename = "threadId", default)]
9289 pub thread_id: String,
9290 #[serde(rename = "tokenUsage")]
9291 pub token_usage: ThreadTokenUsage,
9292 #[serde(rename = "turnId", default)]
9293 pub turn_id: String,
9294}
9295
9296#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9297#[serde(rename_all = "camelCase")]
9298pub struct ThreadUnarchiveParams {
9299 #[serde(rename = "threadId", default)]
9300 pub thread_id: String,
9301}
9302
9303#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9304#[serde(rename_all = "camelCase")]
9305pub struct ThreadUnarchiveResponse {
9306 #[serde()]
9307 pub thread: Thread,
9308}
9309
9310#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9311#[serde(rename_all = "camelCase")]
9312pub struct ThreadUnarchivedNotification {
9313 #[serde(rename = "threadId", default)]
9314 pub thread_id: String,
9315}
9316
9317#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9318#[serde(tag = "type", rename_all = "camelCase")]
9319pub enum ThreadUnreadPosition {
9320 #[serde(rename = "threadStart")]
9322 ThreadStart,
9323 Turn {
9325 #[serde(rename = "turnId")]
9326 turn_id: String,
9327 },
9328}
9329
9330#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9335#[serde(tag = "type", rename_all = "camelCase")]
9336#[allow(clippy::large_enum_variant)] pub enum ThreadTimelineEntry {
9338 Item {
9339 item: ThreadItem,
9340 position: u64,
9341 #[serde(rename = "turnId")]
9342 turn_id: String,
9343 },
9344 Realtime {
9345 item: ThreadRealtimeItem,
9346 position: u64,
9347 },
9348 TurnStarted {
9349 position: u64,
9350 #[serde(default, skip_serializing_if = "Option::is_none")]
9351 started_at: Option<i64>,
9352 turn_id: String,
9353 },
9354 TurnCompleted {
9355 #[serde(default, skip_serializing_if = "Option::is_none")]
9356 completed_at: Option<i64>,
9357 #[serde(default, skip_serializing_if = "Option::is_none")]
9358 duration_ms: Option<i64>,
9359 #[serde(default, skip_serializing_if = "Option::is_none")]
9360 error: Option<TurnError>,
9361 position: u64,
9362 #[serde(default, skip_serializing_if = "Option::is_none")]
9363 started_at: Option<i64>,
9364 status: TurnStatus,
9365 turn_id: String,
9366 },
9367}
9368
9369#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9371#[serde(rename_all = "camelCase")]
9372pub struct ThreadTurnsListParams {
9373 #[serde(default, skip_serializing_if = "Option::is_none")]
9374 pub cursor: Option<String>,
9375 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9377 pub items_view: Option<TurnItemsView>,
9378 #[serde(default, skip_serializing_if = "Option::is_none")]
9379 pub limit: Option<u32>,
9380 #[serde(
9381 rename = "sortDirection",
9382 default,
9383 skip_serializing_if = "Option::is_none"
9384 )]
9385 pub sort_direction: Option<SortDirection>,
9386 #[serde(rename = "threadId", default)]
9387 pub thread_id: String,
9388}
9389
9390#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9392#[serde(rename_all = "camelCase")]
9393pub struct ThreadTurnsListResponse {
9394 #[serde(
9395 rename = "backwardsCursor",
9396 default,
9397 skip_serializing_if = "Option::is_none"
9398 )]
9399 pub backwards_cursor: Option<String>,
9400 #[serde(default)]
9401 pub data: Vec<Turn>,
9402 #[serde(
9403 rename = "nextCursor",
9404 default,
9405 skip_serializing_if = "Option::is_none"
9406 )]
9407 pub next_cursor: Option<String>,
9408}
9409
9410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9411#[serde(rename_all = "camelCase")]
9412pub struct ThreadUnsubscribeParams {
9413 #[serde(rename = "threadId", default)]
9414 pub thread_id: String,
9415}
9416
9417#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9418#[serde(rename_all = "camelCase")]
9419pub struct ThreadUnsubscribeResponse {
9420 #[serde()]
9421 pub status: ThreadUnsubscribeStatus,
9422}
9423
9424#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9425pub enum ThreadUnsubscribeStatus {
9426 #[serde(rename = "notLoaded")]
9427 NotLoaded,
9428 #[serde(rename = "notSubscribed")]
9429 NotSubscribed,
9430 #[serde(rename = "unsubscribed")]
9431 Unsubscribed,
9432}
9433
9434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9435#[serde(rename_all = "camelCase")]
9436pub struct TokenUsageBreakdown {
9437 #[serde(
9438 rename = "cacheWriteInputTokens",
9439 default,
9440 skip_serializing_if = "Option::is_none"
9441 )]
9442 pub cache_write_input_tokens: Option<i64>,
9443 #[serde(rename = "cachedInputTokens", default)]
9444 pub cached_input_tokens: i64,
9445 #[serde(rename = "inputTokens", default)]
9446 pub input_tokens: i64,
9447 #[serde(rename = "outputTokens", default)]
9448 pub output_tokens: i64,
9449 #[serde(rename = "reasoningOutputTokens", default)]
9450 pub reasoning_output_tokens: i64,
9451 #[serde(rename = "totalTokens", default)]
9452 pub total_tokens: i64,
9453}
9454
9455#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9456#[serde(rename_all = "camelCase")]
9457pub struct Tool {
9458 #[serde(default, skip_serializing_if = "Option::is_none")]
9459 pub _meta: Option<Value>,
9460 #[serde(default, skip_serializing_if = "Option::is_none")]
9461 pub annotations: Option<Value>,
9462 #[serde(default, skip_serializing_if = "Option::is_none")]
9463 pub description: Option<String>,
9464 #[serde(default, skip_serializing_if = "Option::is_none")]
9465 pub icons: Option<Vec<Value>>,
9466 #[serde(rename = "inputSchema", default)]
9467 pub input_schema: Value,
9468 #[serde(default)]
9469 pub name: String,
9470 #[serde(
9471 rename = "outputSchema",
9472 default,
9473 skip_serializing_if = "Option::is_none"
9474 )]
9475 pub output_schema: Option<Value>,
9476 #[serde(default, skip_serializing_if = "Option::is_none")]
9477 pub title: Option<String>,
9478}
9479
9480#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9481#[serde(rename_all = "camelCase")]
9482pub struct ToolRequestUserInputAnswer {
9483 #[serde(default)]
9484 pub answers: Vec<String>,
9485}
9486
9487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9488#[serde(rename_all = "camelCase")]
9489pub struct ToolRequestUserInputOption {
9490 #[serde(default)]
9491 pub description: String,
9492 #[serde(default)]
9493 pub label: String,
9494}
9495
9496#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9497#[serde(rename_all = "camelCase")]
9498pub struct ToolRequestUserInputParams {
9499 #[serde(
9500 rename = "autoResolutionMs",
9501 default,
9502 skip_serializing_if = "Option::is_none"
9503 )]
9504 pub auto_resolution_ms: Option<i64>,
9505 #[serde(rename = "isBlocking", default)]
9506 pub is_blocking: bool,
9507 #[serde(rename = "itemId", default)]
9508 pub item_id: String,
9509 #[serde(default)]
9510 pub questions: Vec<ToolRequestUserInputQuestion>,
9511 #[serde(rename = "threadId", default)]
9512 pub thread_id: String,
9513 #[serde(rename = "turnId", default)]
9514 pub turn_id: String,
9515}
9516
9517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9518#[serde(rename_all = "camelCase")]
9519pub struct ToolRequestUserInputQuestion {
9520 #[serde(default)]
9521 pub header: String,
9522 #[serde(default)]
9523 pub id: String,
9524 #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
9525 pub is_other: Option<bool>,
9526 #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
9527 pub is_secret: Option<bool>,
9528 #[serde(default, skip_serializing_if = "Option::is_none")]
9529 pub options: Option<Vec<ToolRequestUserInputOption>>,
9530 #[serde(default)]
9531 pub question: String,
9532}
9533
9534#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9535#[serde(rename_all = "camelCase")]
9536pub struct ToolRequestUserInputResponse {
9537 #[serde(default)]
9538 pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
9539}
9540
9541#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9542#[serde(rename_all = "camelCase")]
9543pub struct ToolsV2 {
9544 #[serde(default, skip_serializing_if = "Option::is_none")]
9545 pub web_search: Option<WebSearchToolConfig>,
9546}
9547
9548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9549#[serde(rename_all = "camelCase")]
9550pub struct Turn {
9551 #[serde(
9552 rename = "completedAt",
9553 default,
9554 skip_serializing_if = "Option::is_none"
9555 )]
9556 pub completed_at: Option<i64>,
9557 #[serde(
9558 rename = "durationMs",
9559 default,
9560 skip_serializing_if = "Option::is_none"
9561 )]
9562 pub duration_ms: Option<i64>,
9563 #[serde(default, skip_serializing_if = "Option::is_none")]
9564 pub error: Option<TurnError>,
9565 #[serde(default)]
9566 pub id: String,
9567 #[serde(default)]
9568 pub items: Vec<ThreadItem>,
9569 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9570 pub items_view: Option<Value>,
9571 #[serde(
9575 rename = "rootTurnId",
9576 default,
9577 skip_serializing_if = "Option::is_none"
9578 )]
9579 pub root_turn_id: Option<String>,
9580 #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
9581 pub started_at: Option<i64>,
9582 #[serde()]
9583 pub status: TurnStatus,
9584}
9585
9586#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9587#[serde(rename_all = "camelCase")]
9588pub struct TurnCompletedNotification {
9589 #[serde(rename = "threadId", default)]
9590 pub thread_id: String,
9591 #[serde()]
9592 pub turn: Turn,
9593}
9594
9595#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9596#[serde(rename_all = "camelCase")]
9597pub struct TurnDiffUpdatedNotification {
9598 #[serde(default)]
9599 pub diff: String,
9600 #[serde(rename = "threadId", default)]
9601 pub thread_id: String,
9602 #[serde(rename = "turnId", default)]
9603 pub turn_id: String,
9604}
9605
9606#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9607#[serde(rename_all = "camelCase")]
9608pub struct TurnError {
9609 #[serde(
9610 rename = "additionalDetails",
9611 default,
9612 skip_serializing_if = "Option::is_none"
9613 )]
9614 pub additional_details: Option<String>,
9615 #[serde(
9616 rename = "codexErrorInfo",
9617 default,
9618 skip_serializing_if = "Option::is_none"
9619 )]
9620 pub codex_error_info: Option<CodexErrorInfo>,
9621 #[serde(default)]
9622 pub message: String,
9623 #[serde(default, skip_serializing_if = "Option::is_none")]
9626 pub misalignment: Option<MisalignmentErrorDetails>,
9627}
9628
9629#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9630#[serde(rename_all = "camelCase")]
9631pub struct TurnInterruptParams {
9632 #[serde(rename = "threadId", default)]
9633 pub thread_id: String,
9634 #[serde(rename = "turnId", default)]
9635 pub turn_id: String,
9636}
9637
9638#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9639#[serde(rename_all = "camelCase")]
9640pub struct TurnInterruptResponse {
9641 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9642 pub extra: serde_json::Map<String, Value>,
9643}
9644
9645#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
9646pub enum TurnItemsView {
9647 #[serde(rename = "notLoaded")]
9648 NotLoaded,
9649 #[serde(rename = "summary")]
9650 Summary,
9651 #[serde(rename = "full")]
9652 Full,
9653}
9654
9655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9656#[serde(rename_all = "camelCase")]
9657pub struct TurnModerationMetadataNotification {
9658 #[serde(default)]
9659 pub metadata: Value,
9660 #[serde(rename = "threadId", default)]
9661 pub thread_id: String,
9662 #[serde(rename = "turnId", default)]
9663 pub turn_id: String,
9664}
9665
9666#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9667#[serde(rename_all = "camelCase")]
9668pub struct TurnPlanStep {
9669 #[serde()]
9670 pub status: TurnPlanStepStatus,
9671 #[serde(default)]
9672 pub step: String,
9673}
9674
9675#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9676pub enum TurnPlanStepStatus {
9677 #[serde(rename = "pending")]
9678 Pending,
9679 #[serde(rename = "inProgress")]
9680 InProgress,
9681 #[serde(rename = "completed")]
9682 Completed,
9683}
9684
9685#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9686#[serde(rename_all = "camelCase")]
9687pub struct TurnPlanUpdatedNotification {
9688 #[serde(default, skip_serializing_if = "Option::is_none")]
9689 pub explanation: Option<String>,
9690 #[serde(default)]
9691 pub plan: Vec<TurnPlanStep>,
9692 #[serde(rename = "threadId", default)]
9693 pub thread_id: String,
9694 #[serde(rename = "turnId", default)]
9695 pub turn_id: String,
9696}
9697
9698#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9699#[serde(rename_all = "camelCase")]
9700pub struct TurnStartParams {
9701 #[serde(
9702 rename = "approvalPolicy",
9703 default,
9704 skip_serializing_if = "Option::is_none"
9705 )]
9706 pub approval_policy: Option<AskForApproval>,
9707 #[serde(
9708 rename = "approvalsReviewer",
9709 default,
9710 skip_serializing_if = "Option::is_none"
9711 )]
9712 pub approvals_reviewer: Option<ApprovalsReviewer>,
9713 #[serde(
9714 rename = "clientUserMessageId",
9715 default,
9716 skip_serializing_if = "Option::is_none"
9717 )]
9718 pub client_user_message_id: Option<String>,
9719 #[serde(default, skip_serializing_if = "Option::is_none")]
9720 pub cwd: Option<String>,
9721 #[serde(
9724 rename = "disabledPluginIds",
9725 default,
9726 skip_serializing_if = "Option::is_none"
9727 )]
9728 pub disabled_plugin_ids: Option<Vec<String>>,
9729 #[serde(default, skip_serializing_if = "Option::is_none")]
9730 pub effort: Option<ReasoningEffort>,
9731 #[serde(default)]
9732 pub input: Vec<UserInput>,
9733 #[serde(default, skip_serializing_if = "Option::is_none")]
9734 pub model: Option<String>,
9735 #[serde(
9736 rename = "outputSchema",
9737 default,
9738 skip_serializing_if = "Option::is_none"
9739 )]
9740 pub output_schema: Option<Value>,
9741 #[serde(
9745 rename = "parentTurnId",
9746 default,
9747 skip_serializing_if = "Option::is_none"
9748 )]
9749 pub parent_turn_id: Option<String>,
9750 #[serde(default, skip_serializing_if = "Option::is_none")]
9751 pub personality: Option<Personality>,
9752 #[serde(
9757 rename = "rootTurnId",
9758 default,
9759 skip_serializing_if = "Option::is_none"
9760 )]
9761 pub root_turn_id: Option<String>,
9762 #[serde(
9763 rename = "sandboxPolicy",
9764 default,
9765 skip_serializing_if = "Option::is_none"
9766 )]
9767 pub sandbox_policy: Option<SandboxPolicy>,
9768 #[serde(
9769 rename = "serviceTier",
9770 default,
9771 skip_serializing_if = "Option::is_none"
9772 )]
9773 pub service_tier: Option<String>,
9774 #[serde(
9777 rename = "serviceTierForTurn",
9778 default,
9779 skip_serializing_if = "Option::is_none"
9780 )]
9781 pub service_tier_for_turn: Option<String>,
9782 #[serde(default, skip_serializing_if = "Option::is_none")]
9783 pub summary: Option<ReasoningSummary>,
9784 #[serde(rename = "threadId", default)]
9785 pub thread_id: String,
9786 #[serde(
9789 rename = "toolOutput",
9790 default,
9791 skip_serializing_if = "Option::is_none"
9792 )]
9793 pub tool_output: Option<TurnToolOutput>,
9794 #[serde(
9797 rename = "turnTrigger",
9798 default,
9799 skip_serializing_if = "Option::is_none"
9800 )]
9801 pub turn_trigger: Option<String>,
9802}
9803
9804#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9805#[serde(rename_all = "camelCase")]
9806pub struct TurnStartResponse {
9807 #[serde()]
9808 pub turn: Turn,
9809}
9810
9811#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9812#[serde(rename_all = "camelCase")]
9813pub struct TurnStartedNotification {
9814 #[serde(rename = "threadId", default)]
9815 pub thread_id: String,
9816 #[serde()]
9817 pub turn: Turn,
9818}
9819
9820#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9821pub enum TurnStatus {
9822 #[serde(rename = "completed")]
9823 Completed,
9824 #[serde(rename = "interrupted")]
9825 Interrupted,
9826 #[serde(rename = "failed")]
9827 Failed,
9828 #[serde(rename = "inProgress")]
9829 InProgress,
9830}
9831
9832#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9835#[serde(rename_all = "camelCase")]
9836pub struct TurnToolOutput {
9837 #[serde(default)]
9838 pub name: String,
9839 #[serde(default, skip_serializing_if = "Option::is_none")]
9840 pub namespace: Option<String>,
9841 #[serde()]
9842 pub output: FunctionCallOutputBody,
9843 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9846 pub retain: bool,
9847}
9848
9849#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9850#[serde(rename_all = "camelCase")]
9851pub struct TurnSteerParams {
9852 #[serde(
9853 rename = "clientUserMessageId",
9854 default,
9855 skip_serializing_if = "Option::is_none"
9856 )]
9857 pub client_user_message_id: Option<String>,
9858 #[serde(rename = "expectedTurnId", default)]
9859 pub expected_turn_id: String,
9860 #[serde(default)]
9861 pub input: Vec<UserInput>,
9862 #[serde(rename = "threadId", default)]
9863 pub thread_id: String,
9864}
9865
9866#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9867#[serde(rename_all = "camelCase")]
9868pub struct TurnSteerResponse {
9869 #[serde(rename = "turnId", default)]
9870 pub turn_id: String,
9871}
9872
9873#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9874#[serde(tag = "type", rename_all = "camelCase")]
9875pub enum UserInput {
9876 Text {
9877 text: String,
9878 #[serde(default, skip_serializing_if = "Option::is_none")]
9879 text_elements: Option<Vec<TextElement>>,
9880 },
9881 Image {
9882 #[serde(default, skip_serializing_if = "Option::is_none")]
9883 detail: Option<ImageDetail>,
9884 #[serde(flatten)]
9885 image: UserInputImageReference,
9886 },
9887 #[serde(rename = "localImage")]
9888 LocalImage {
9889 #[serde(default, skip_serializing_if = "Option::is_none")]
9890 detail: Option<ImageDetail>,
9891 path: String,
9892 },
9893 Audio {
9894 url: String,
9895 },
9896 #[serde(rename = "localAudio")]
9897 LocalAudio {
9898 path: String,
9899 },
9900 Skill {
9901 name: String,
9902 path: String,
9903 },
9904 Mention {
9905 name: String,
9906 path: String,
9907 },
9908}
9909
9910#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9916#[serde(untagged)]
9917pub enum UserInputImageReference {
9918 Inline {
9919 url: String,
9920 },
9921 File {
9922 #[serde(rename = "fileId")]
9923 file_id: String,
9924 },
9925}
9926
9927#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9928pub enum Verbosity {
9929 #[serde(rename = "low")]
9930 Low,
9931 #[serde(rename = "medium")]
9932 Medium,
9933 #[serde(rename = "high")]
9934 High,
9935}
9936
9937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9938#[serde(rename_all = "camelCase")]
9939pub struct WarningNotification {
9940 #[serde(default)]
9941 pub message: String,
9942 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
9943 pub thread_id: Option<String>,
9944}
9945
9946#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9947#[serde(tag = "type", rename_all = "camelCase")]
9948pub enum WebSearchAction {
9949 Search {
9950 #[serde(default, skip_serializing_if = "Option::is_none")]
9951 queries: Option<Vec<String>>,
9952 #[serde(default, skip_serializing_if = "Option::is_none")]
9953 query: Option<String>,
9954 },
9955 #[serde(rename = "openPage")]
9956 OpenPage {
9957 #[serde(default, skip_serializing_if = "Option::is_none")]
9958 url: Option<String>,
9959 },
9960 #[serde(rename = "findInPage")]
9961 FindInPage {
9962 #[serde(default, skip_serializing_if = "Option::is_none")]
9963 pattern: Option<String>,
9964 #[serde(default, skip_serializing_if = "Option::is_none")]
9965 url: Option<String>,
9966 },
9967 Other,
9968}
9969
9970#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9971pub enum WebSearchContextSize {
9972 #[serde(rename = "low")]
9973 Low,
9974 #[serde(rename = "medium")]
9975 Medium,
9976 #[serde(rename = "high")]
9977 High,
9978}
9979
9980#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9981#[serde(rename_all = "camelCase")]
9982pub struct WebSearchLocation {
9983 #[serde(default, skip_serializing_if = "Option::is_none")]
9984 pub city: Option<String>,
9985 #[serde(default, skip_serializing_if = "Option::is_none")]
9986 pub country: Option<String>,
9987 #[serde(default, skip_serializing_if = "Option::is_none")]
9988 pub region: Option<String>,
9989 #[serde(default, skip_serializing_if = "Option::is_none")]
9990 pub timezone: Option<String>,
9991}
9992
9993#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9994pub enum WebSearchMode {
9995 #[serde(rename = "disabled")]
9996 Disabled,
9997 #[serde(rename = "cached")]
9998 Cached,
9999 #[serde(rename = "indexed")]
10000 Indexed,
10001 #[serde(rename = "live")]
10002 Live,
10003}
10004
10005#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10006#[serde(rename_all = "camelCase")]
10007pub struct WebSearchToolConfig {
10008 #[serde(default, skip_serializing_if = "Option::is_none")]
10009 pub allowed_domains: Option<Vec<String>>,
10010 #[serde(default, skip_serializing_if = "Option::is_none")]
10011 pub context_size: Option<WebSearchContextSize>,
10012 #[serde(default, skip_serializing_if = "Option::is_none")]
10013 pub location: Option<WebSearchLocation>,
10014}
10015
10016#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10017pub enum WindowsSandboxReadiness {
10018 #[serde(rename = "ready")]
10019 Ready,
10020 #[serde(rename = "notConfigured")]
10021 NotConfigured,
10022 #[serde(rename = "updateRequired")]
10023 UpdateRequired,
10024}
10025
10026#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10027#[serde(rename_all = "camelCase")]
10028pub struct WindowsSandboxReadinessResponse {
10029 #[serde()]
10030 pub status: WindowsSandboxReadiness,
10031}
10032
10033#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10034#[serde(rename_all = "camelCase")]
10035pub struct WindowsSandboxSetupCompletedNotification {
10036 #[serde(default, skip_serializing_if = "Option::is_none")]
10037 pub error: Option<String>,
10038 #[serde()]
10039 pub mode: WindowsSandboxSetupMode,
10040 #[serde(default)]
10041 pub success: bool,
10042}
10043
10044#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10045pub enum WindowsSandboxSetupMode {
10046 #[serde(rename = "elevated")]
10047 Elevated,
10048 #[serde(rename = "unelevated")]
10049 Unelevated,
10050}
10051
10052#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10056pub enum WindowsSandboxImplementation {
10057 #[serde(rename = "elevated")]
10058 Elevated,
10059 #[serde(rename = "unelevated")]
10060 Unelevated,
10061 #[serde(rename = "mxc")]
10062 Mxc,
10063}
10064
10065#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10066#[serde(rename_all = "camelCase")]
10067pub struct WindowsSandboxSetupStartParams {
10068 #[serde(default, skip_serializing_if = "Option::is_none")]
10069 pub cwd: Option<AbsolutePathBuf>,
10070 #[serde()]
10071 pub mode: WindowsSandboxSetupMode,
10072}
10073
10074#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10075#[serde(rename_all = "camelCase")]
10076pub struct WindowsSandboxSetupStartResponse {
10077 #[serde(default)]
10078 pub started: bool,
10079}
10080
10081#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10082#[serde(rename_all = "camelCase")]
10083pub struct WindowsWorldWritableWarningNotification {
10084 #[serde(rename = "extraCount", default)]
10085 pub extra_count: i64,
10086 #[serde(rename = "failedScan", default)]
10087 pub failed_scan: bool,
10088 #[serde(rename = "samplePaths", default)]
10089 pub sample_paths: Vec<String>,
10090}
10091
10092#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10093#[serde(rename_all = "camelCase")]
10094pub struct WorkspaceMessage {
10095 #[serde(
10096 rename = "archivedAt",
10097 default,
10098 skip_serializing_if = "Option::is_none"
10099 )]
10100 pub archived_at: Option<i64>,
10101 #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
10102 pub created_at: Option<i64>,
10103 #[serde(rename = "messageBody", default)]
10104 pub message_body: String,
10105 #[serde(rename = "messageId", default)]
10106 pub message_id: String,
10107 #[serde(rename = "messageType")]
10108 pub message_type: WorkspaceMessageType,
10109}
10110
10111#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10112pub enum WorkspaceMessageType {
10113 #[serde(rename = "headline")]
10114 Headline,
10115 #[serde(rename = "announcement")]
10116 Announcement,
10117 #[serde(rename = "unknown")]
10118 Unknown,
10119}
10120
10121#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10122pub enum WriteStatus {
10123 #[serde(rename = "ok")]
10124 Ok,
10125 #[serde(rename = "okOverridden")]
10126 OkOverridden,
10127}