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