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(default)]
4480 pub tools: std::collections::BTreeMap<String, Tool>,
4481 #[serde(
4484 rename = "toolsError",
4485 default,
4486 skip_serializing_if = "Option::is_none"
4487 )]
4488 pub tools_error: Option<String>,
4489}
4490
4491#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4492pub enum McpServerStatusDetail {
4493 #[serde(rename = "full")]
4494 Full,
4495 #[serde(rename = "toolsAndAuthOnly")]
4496 ToolsAndAuthOnly,
4497}
4498
4499#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4500#[serde(rename_all = "camelCase")]
4501pub struct McpServerStatusUpdatedNotification {
4502 #[serde(default, skip_serializing_if = "Option::is_none")]
4503 pub error: Option<String>,
4504 #[serde(
4505 rename = "failureReason",
4506 default,
4507 skip_serializing_if = "Option::is_none"
4508 )]
4509 pub failure_reason: Option<McpServerStartupFailureReason>,
4510 #[serde(default)]
4511 pub name: String,
4512 #[serde()]
4513 pub status: McpServerStartupState,
4514 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4515 pub thread_id: Option<String>,
4516}
4517
4518#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4519#[serde(rename_all = "camelCase")]
4520pub struct McpServerToolCallParams {
4521 #[serde(default, skip_serializing_if = "Option::is_none")]
4522 pub _meta: Option<Value>,
4523 #[serde(default, skip_serializing_if = "Option::is_none")]
4524 pub arguments: Option<Value>,
4525 #[serde(default)]
4526 pub server: String,
4527 #[serde(rename = "threadId", default)]
4528 pub thread_id: String,
4529 #[serde(default)]
4530 pub tool: String,
4531}
4532
4533#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4534#[serde(rename_all = "camelCase")]
4535pub struct McpServerToolCallResponse {
4536 #[serde(default, skip_serializing_if = "Option::is_none")]
4537 pub _meta: Option<Value>,
4538 #[serde(default)]
4539 pub content: Vec<Value>,
4540 #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
4541 pub is_error: Option<bool>,
4542 #[serde(
4543 rename = "structuredContent",
4544 default,
4545 skip_serializing_if = "Option::is_none"
4546 )]
4547 pub structured_content: Option<Value>,
4548}
4549
4550#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
4553#[serde(rename_all = "camelCase")]
4554pub struct McpAppUi {
4555 #[serde(rename = "resourceUri")]
4556 pub resource_uri: String,
4557 #[serde(rename = "preferredModelDisplayMode")]
4558 pub preferred_model_display_mode: McpAppDisplayMode,
4559}
4560
4561#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4562pub enum McpAppDisplayMode {
4563 #[serde(rename = "inline")]
4564 Inline,
4565 #[serde(rename = "fullscreen")]
4566 Fullscreen,
4567}
4568
4569#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4570#[serde(rename_all = "camelCase")]
4571pub struct McpToolCallAppContext {
4572 #[serde(
4573 rename = "actionName",
4574 default,
4575 skip_serializing_if = "Option::is_none"
4576 )]
4577 pub action_name: Option<String>,
4578 #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
4579 pub app_name: Option<String>,
4580 #[serde(rename = "connectorId", default)]
4581 pub connector_id: String,
4582 #[serde(rename = "linkId", default, skip_serializing_if = "Option::is_none")]
4583 pub link_id: Option<String>,
4584 #[serde(
4585 rename = "resourceUri",
4586 default,
4587 skip_serializing_if = "Option::is_none"
4588 )]
4589 pub resource_uri: Option<String>,
4590}
4591
4592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4593#[serde(rename_all = "camelCase")]
4594pub struct McpToolCallError {
4595 #[serde(default)]
4596 pub message: String,
4597}
4598
4599#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4600#[serde(rename_all = "camelCase")]
4601pub struct McpToolCallProgressNotification {
4602 #[serde(rename = "itemId", default)]
4603 pub item_id: String,
4604 #[serde(default)]
4605 pub message: String,
4606 #[serde(rename = "threadId", default)]
4607 pub thread_id: String,
4608 #[serde(rename = "turnId", default)]
4609 pub turn_id: String,
4610}
4611
4612#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4613#[serde(rename_all = "camelCase")]
4614pub struct McpToolCallResult {
4615 #[serde(default, skip_serializing_if = "Option::is_none")]
4616 pub _meta: Option<Value>,
4617 #[serde(default)]
4618 pub content: Vec<Value>,
4619 #[serde(
4620 rename = "structuredContent",
4621 default,
4622 skip_serializing_if = "Option::is_none"
4623 )]
4624 pub structured_content: Option<Value>,
4625}
4626
4627#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4628pub enum McpToolCallStatus {
4629 #[serde(rename = "inProgress")]
4630 InProgress,
4631 #[serde(rename = "completed")]
4632 Completed,
4633 #[serde(rename = "failed")]
4634 Failed,
4635}
4636
4637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4638#[serde(rename_all = "camelCase")]
4639pub struct MemoryCitation {
4640 #[serde(default)]
4641 pub entries: Vec<MemoryCitationEntry>,
4642 #[serde(rename = "threadIds", default)]
4643 pub thread_ids: Vec<String>,
4644}
4645
4646#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4647#[serde(rename_all = "camelCase")]
4648pub struct MemoryCitationEntry {
4649 #[serde(rename = "lineEnd", default)]
4650 pub line_end: i64,
4651 #[serde(rename = "lineStart", default)]
4652 pub line_start: i64,
4653 #[serde(default)]
4654 pub note: String,
4655 #[serde(default)]
4656 pub path: String,
4657}
4658
4659#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4660pub enum MergeStrategy {
4661 #[serde(rename = "replace")]
4662 Replace,
4663 #[serde(rename = "upsert")]
4664 Upsert,
4665}
4666
4667#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4668pub enum MessagePhase {
4669 #[serde(rename = "commentary")]
4670 Commentary,
4671 #[serde(rename = "partial_answer")]
4674 PartialAnswer,
4675 #[serde(rename = "final_answer")]
4676 FinalAnswer,
4677}
4678
4679#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4680#[serde(rename_all = "camelCase")]
4681pub struct MigrationDetails {
4682 #[serde(default, skip_serializing_if = "Option::is_none")]
4683 pub commands: Option<Vec<CommandMigration>>,
4684 #[serde(default, skip_serializing_if = "Option::is_none")]
4685 pub hooks: Option<Vec<HookMigration>>,
4686 #[serde(
4687 rename = "mcpServers",
4688 default,
4689 skip_serializing_if = "Option::is_none"
4690 )]
4691 pub mcp_servers: Option<Vec<McpServerMigration>>,
4692 #[serde(default, skip_serializing_if = "Option::is_none")]
4693 pub memory: Option<Vec<String>>,
4694 #[serde(default, skip_serializing_if = "Option::is_none")]
4695 pub plugins: Option<Vec<PluginsMigration>>,
4696 #[serde(default, skip_serializing_if = "Option::is_none")]
4697 pub sessions: Option<Vec<SessionMigration>>,
4698 #[serde(default, skip_serializing_if = "Option::is_none")]
4699 pub skills: Option<Vec<SkillMigration>>,
4700 #[serde(default, skip_serializing_if = "Option::is_none")]
4701 pub subagents: Option<Vec<SubagentMigration>>,
4702}
4703
4704#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4707#[serde(rename_all = "camelCase")]
4708pub struct MisalignmentErrorDetails {
4709 #[serde(
4710 rename = "detailedExplanation",
4711 default,
4712 skip_serializing_if = "Option::is_none"
4713 )]
4714 pub detailed_explanation: Option<String>,
4715 #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
4717 pub error_type: Option<String>,
4718 #[serde(
4721 rename = "reviewTarget",
4722 default,
4723 skip_serializing_if = "Option::is_none"
4724 )]
4725 pub review_target: Option<String>,
4726 #[serde(default, skip_serializing_if = "Option::is_none")]
4729 pub steer: Option<MisalignmentSteer>,
4730}
4731
4732#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4734#[serde(rename_all = "camelCase")]
4735pub struct MisalignmentSteer {
4736 #[serde(default)]
4737 pub message: String,
4738}
4739
4740#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4741pub enum ModeKind {
4742 #[serde(rename = "plan")]
4743 Plan,
4744 #[serde(rename = "default")]
4745 Default,
4746}
4747
4748#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4749#[serde(rename_all = "camelCase")]
4750pub struct Model {
4751 #[serde(
4752 rename = "additionalSpeedTiers",
4753 default,
4754 skip_serializing_if = "Option::is_none"
4755 )]
4756 pub additional_speed_tiers: Option<Vec<String>>,
4757 #[serde(
4758 rename = "availabilityNux",
4759 default,
4760 skip_serializing_if = "Option::is_none"
4761 )]
4762 pub availability_nux: Option<ModelAvailabilityNux>,
4763 #[serde(
4765 rename = "availableAccessPrograms",
4766 default,
4767 skip_serializing_if = "Option::is_none"
4768 )]
4769 pub available_access_programs: Option<ModelAccessPrograms>,
4770 #[serde(rename = "defaultReasoningEffort")]
4771 pub default_reasoning_effort: ReasoningEffort,
4772 #[serde(
4773 rename = "defaultServiceTier",
4774 default,
4775 skip_serializing_if = "Option::is_none"
4776 )]
4777 pub default_service_tier: Option<String>,
4778 #[serde(default)]
4779 pub description: String,
4780 #[serde(rename = "displayName", default)]
4781 pub display_name: String,
4782 #[serde(default)]
4783 pub hidden: bool,
4784 #[serde(default)]
4785 pub id: String,
4786 #[serde(
4787 rename = "inputModalities",
4788 default,
4789 skip_serializing_if = "Option::is_none"
4790 )]
4791 pub input_modalities: Option<Vec<InputModality>>,
4792 #[serde(rename = "isDefault", default)]
4793 pub is_default: bool,
4794 #[serde(default)]
4795 pub model: String,
4796 #[serde(
4797 rename = "modelSpecialty",
4798 default,
4799 skip_serializing_if = "Option::is_none"
4800 )]
4801 pub model_specialty: Option<String>,
4802 #[serde(
4803 rename = "multiAgentVersion",
4804 default,
4805 skip_serializing_if = "Option::is_none"
4806 )]
4807 pub multi_agent_version: Option<MultiAgentVersion>,
4808 #[serde(
4809 rename = "serviceTiers",
4810 default,
4811 skip_serializing_if = "Option::is_none"
4812 )]
4813 pub service_tiers: Option<Vec<ModelServiceTier>>,
4814 #[serde(rename = "supportedReasoningEfforts", default)]
4815 pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
4816 #[serde(
4819 rename = "supportsPersonality",
4820 default,
4821 skip_serializing_if = "Option::is_none"
4822 )]
4823 pub supports_personality: Option<bool>,
4824 #[serde(default, skip_serializing_if = "Option::is_none")]
4825 pub upgrade: Option<String>,
4826 #[serde(
4827 rename = "upgradeInfo",
4828 default,
4829 skip_serializing_if = "Option::is_none"
4830 )]
4831 pub upgrade_info: Option<ModelUpgradeInfo>,
4832}
4833
4834#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4836#[serde(rename_all = "camelCase")]
4837pub struct ModelAccessPrograms {
4838 #[serde(default)]
4840 pub cyber: Vec<CyberAccessProgram>,
4841}
4842
4843#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4844#[serde(rename_all = "camelCase")]
4845pub struct ModelAvailabilityNux {
4846 #[serde(default)]
4847 pub message: String,
4848}
4849
4850#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4851#[serde(rename_all = "camelCase")]
4852pub struct ModelListParams {
4853 #[serde(default, skip_serializing_if = "Option::is_none")]
4854 pub cursor: Option<String>,
4855 #[serde(
4856 rename = "includeHidden",
4857 default,
4858 skip_serializing_if = "Option::is_none"
4859 )]
4860 pub include_hidden: Option<bool>,
4861 #[serde(default, skip_serializing_if = "Option::is_none")]
4862 pub limit: Option<i64>,
4863}
4864
4865#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4866#[serde(rename_all = "camelCase")]
4867pub struct ModelListResponse {
4868 #[serde(default)]
4869 pub data: Vec<Model>,
4870 #[serde(
4871 rename = "nextCursor",
4872 default,
4873 skip_serializing_if = "Option::is_none"
4874 )]
4875 pub next_cursor: Option<String>,
4876}
4877
4878#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4879#[serde(rename_all = "camelCase")]
4880pub struct ModelProviderCapabilitiesReadParams {
4881 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4882 pub extra: serde_json::Map<String, Value>,
4883}
4884
4885#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4886#[serde(rename_all = "camelCase")]
4887pub struct ModelProviderCapabilitiesReadResponse {
4888 #[serde(rename = "imageGeneration", default)]
4889 pub image_generation: bool,
4890 #[serde(rename = "webSearch", default)]
4891 pub web_search: bool,
4892}
4893
4894#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4895pub enum ModelRerouteReason {
4896 #[serde(rename = "highRiskCyberActivity")]
4897 HighRiskCyberActivity,
4898}
4899
4900#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4901#[serde(rename_all = "camelCase")]
4902pub struct ModelReroutedNotification {
4903 #[serde(rename = "fromModel", default)]
4904 pub from_model: String,
4905 #[serde()]
4906 pub reason: ModelRerouteReason,
4907 #[serde(rename = "threadId", default)]
4908 pub thread_id: String,
4909 #[serde(rename = "toModel", default)]
4910 pub to_model: String,
4911 #[serde(rename = "turnId", default)]
4912 pub turn_id: String,
4913}
4914
4915#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4916#[serde(rename_all = "camelCase")]
4917pub struct ModelSafetyBufferingUpdatedNotification {
4918 #[serde(
4919 rename = "fasterModel",
4920 default,
4921 skip_serializing_if = "Option::is_none"
4922 )]
4923 pub faster_model: Option<String>,
4924 #[serde(default)]
4925 pub model: String,
4926 #[serde(default)]
4927 pub reasons: Vec<String>,
4928 #[serde(rename = "showBufferingUi", default)]
4929 pub show_buffering_ui: bool,
4930 #[serde(rename = "threadId", default)]
4931 pub thread_id: String,
4932 #[serde(rename = "turnId", default)]
4933 pub turn_id: String,
4934 #[serde(rename = "useCases", default)]
4935 pub use_cases: Vec<String>,
4936}
4937
4938#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4939#[serde(rename_all = "camelCase")]
4940pub struct ModelServiceTier {
4941 #[serde(default)]
4942 pub description: String,
4943 #[serde(default)]
4944 pub id: String,
4945 #[serde(default)]
4946 pub name: String,
4947}
4948
4949#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4950#[serde(rename_all = "camelCase")]
4951pub struct ModelUpgradeInfo {
4952 #[serde(
4953 rename = "migrationMarkdown",
4954 default,
4955 skip_serializing_if = "Option::is_none"
4956 )]
4957 pub migration_markdown: Option<String>,
4958 #[serde(default)]
4959 pub model: String,
4960 #[serde(
4963 rename = "retirementAt",
4964 default,
4965 skip_serializing_if = "Option::is_none"
4966 )]
4967 pub retirement_at: Option<i64>,
4968 #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
4969 pub model_link: Option<String>,
4970 #[serde(
4971 rename = "upgradeCopy",
4972 default,
4973 skip_serializing_if = "Option::is_none"
4974 )]
4975 pub upgrade_copy: Option<String>,
4976}
4977
4978#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4979pub enum ModelVerification {
4980 #[serde(rename = "trustedAccessForCyber")]
4981 TrustedAccessForCyber,
4982}
4983
4984#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4985#[serde(rename_all = "camelCase")]
4986pub struct ModelVerificationNotification {
4987 #[serde(rename = "threadId", default)]
4988 pub thread_id: String,
4989 #[serde(rename = "turnId", default)]
4990 pub turn_id: String,
4991 #[serde(default)]
4992 pub verifications: Vec<ModelVerification>,
4993}
4994
4995#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4996#[serde(rename_all = "camelCase")]
4997pub struct ModelsRequirements {
4998 #[serde(rename = "newThread", default, skip_serializing_if = "Option::is_none")]
4999 pub new_thread: Option<NewThreadModelDefaults>,
5000}
5001
5002#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5003pub enum MultiAgentVersion {
5004 #[serde(rename = "disabled")]
5005 Disabled,
5006 #[serde(rename = "v1")]
5007 V1,
5008 #[serde(rename = "v2")]
5009 V2,
5010}
5011
5012#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5013pub enum NetworkAccess {
5014 #[serde(rename = "restricted")]
5015 Restricted,
5016 #[serde(rename = "enabled")]
5017 Enabled,
5018}
5019
5020#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5021#[serde(rename_all = "camelCase")]
5022pub struct NetworkApprovalContext {
5023 #[serde(default)]
5024 pub host: String,
5025 #[serde()]
5026 pub protocol: NetworkApprovalProtocol,
5027}
5028
5029#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5030pub enum NetworkApprovalProtocol {
5031 #[serde(rename = "http")]
5032 Http,
5033 #[serde(rename = "https")]
5034 Https,
5035 #[serde(rename = "socks5Tcp")]
5036 Socks5Tcp,
5037 #[serde(rename = "socks5Udp")]
5038 Socks5Udp,
5039}
5040
5041#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5042#[serde(rename_all = "camelCase")]
5043pub struct NetworkPolicyAmendment {
5044 #[serde()]
5045 pub action: NetworkPolicyRuleAction,
5046 #[serde(default)]
5047 pub host: String,
5048}
5049
5050#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5051pub enum NetworkPolicyRuleAction {
5052 #[serde(rename = "allow")]
5053 Allow,
5054 #[serde(rename = "deny")]
5055 Deny,
5056}
5057
5058#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5059#[serde(rename_all = "camelCase")]
5060pub struct NewThreadModelDefaults {
5061 #[serde(default, skip_serializing_if = "Option::is_none")]
5062 pub model: Option<String>,
5063 #[serde(
5064 rename = "modelReasoningEffort",
5065 default,
5066 skip_serializing_if = "Option::is_none"
5067 )]
5068 pub model_reasoning_effort: Option<ReasoningEffort>,
5069 #[serde(
5070 rename = "serviceTier",
5071 default,
5072 skip_serializing_if = "Option::is_none"
5073 )]
5074 pub service_tier: Option<String>,
5075}
5076
5077#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5078pub enum NonSteerableTurnKind {
5079 #[serde(rename = "review")]
5080 Review,
5081 #[serde(rename = "compact")]
5082 Compact,
5083}
5084
5085#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5086#[serde(rename_all = "camelCase")]
5087pub struct OverriddenMetadata {
5088 #[serde(rename = "effectiveValue", default)]
5089 pub effective_value: Value,
5090 #[serde(default)]
5091 pub message: String,
5092 #[serde(rename = "overridingLayer")]
5093 pub overriding_layer: ConfigLayerMetadata,
5094}
5095
5096#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5097#[serde(tag = "type", rename_all = "camelCase")]
5098pub enum ParsedCommand {
5099 Read {
5100 cmd: String,
5101 name: String,
5102 path: String,
5103 },
5104 List_files {
5105 cmd: String,
5106 #[serde(default, skip_serializing_if = "Option::is_none")]
5107 path: Option<String>,
5108 },
5109 Search {
5110 cmd: String,
5111 #[serde(default, skip_serializing_if = "Option::is_none")]
5112 path: Option<String>,
5113 #[serde(default, skip_serializing_if = "Option::is_none")]
5114 query: Option<String>,
5115 },
5116 Unknown {
5117 cmd: String,
5118 },
5119}
5120
5121#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5122pub enum PatchApplyStatus {
5123 #[serde(rename = "inProgress")]
5124 InProgress,
5125 #[serde(rename = "completed")]
5126 Completed,
5127 #[serde(rename = "failed")]
5128 Failed,
5129 #[serde(rename = "declined")]
5130 Declined,
5131}
5132
5133#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5134#[serde(tag = "type", rename_all = "camelCase")]
5135pub enum PatchChangeKind {
5136 Add,
5137 Delete,
5138 Update {
5139 #[serde(default, skip_serializing_if = "Option::is_none")]
5140 move_path: Option<String>,
5141 },
5142}
5143
5144#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5145pub enum PermissionGrantScope {
5146 #[serde(rename = "turn")]
5147 Turn,
5148 #[serde(rename = "session")]
5149 Session,
5150}
5151
5152#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5153#[serde(rename_all = "camelCase")]
5154pub struct PermissionProfileListParams {
5155 #[serde(default, skip_serializing_if = "Option::is_none")]
5156 pub cursor: Option<String>,
5157 #[serde(default, skip_serializing_if = "Option::is_none")]
5158 pub cwd: Option<String>,
5159 #[serde(default, skip_serializing_if = "Option::is_none")]
5160 pub limit: Option<i64>,
5161}
5162
5163#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5164#[serde(rename_all = "camelCase")]
5165pub struct PermissionProfileListResponse {
5166 #[serde(default)]
5167 pub data: Vec<PermissionProfileSummary>,
5168 #[serde(
5169 rename = "nextCursor",
5170 default,
5171 skip_serializing_if = "Option::is_none"
5172 )]
5173 pub next_cursor: Option<String>,
5174}
5175
5176#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5177#[serde(rename_all = "camelCase")]
5178pub struct PermissionProfileSummary {
5179 #[serde(default)]
5180 pub allowed: bool,
5181 #[serde(default, skip_serializing_if = "Option::is_none")]
5182 pub description: Option<String>,
5183 #[serde(default)]
5184 pub id: String,
5185}
5186
5187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5188#[serde(rename_all = "camelCase")]
5189pub struct PermissionsRequestApprovalParams {
5190 #[serde()]
5191 pub cwd: LegacyAppPathString,
5192 #[serde(
5193 rename = "environmentId",
5194 default,
5195 skip_serializing_if = "Option::is_none"
5196 )]
5197 pub environment_id: Option<String>,
5198 #[serde(rename = "itemId", default)]
5199 pub item_id: String,
5200 #[serde()]
5201 pub permissions: RequestPermissionProfile,
5202 #[serde(default, skip_serializing_if = "Option::is_none")]
5203 pub reason: Option<String>,
5204 #[serde(rename = "startedAtMs", default)]
5205 pub started_at_ms: i64,
5206 #[serde(rename = "threadId", default)]
5207 pub thread_id: String,
5208 #[serde(rename = "turnId", default)]
5209 pub turn_id: String,
5210}
5211
5212#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5213#[serde(rename_all = "camelCase")]
5214pub struct PermissionsRequestApprovalResponse {
5215 #[serde()]
5216 pub permissions: GrantedPermissionProfile,
5217 #[serde(default, skip_serializing_if = "Option::is_none")]
5218 pub scope: Option<Value>,
5219 #[serde(
5220 rename = "strictAutoReview",
5221 default,
5222 skip_serializing_if = "Option::is_none"
5223 )]
5224 pub strict_auto_review: Option<bool>,
5225}
5226
5227#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5232pub enum Personality {
5233 #[serde(rename = "none")]
5234 None,
5235 #[serde(rename = "friendly")]
5236 Friendly,
5237 #[serde(rename = "pragmatic")]
5238 Pragmatic,
5239}
5240
5241#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5242#[serde(rename_all = "camelCase")]
5243pub struct PlanDeltaNotification {
5244 #[serde(default)]
5245 pub delta: String,
5246 #[serde(rename = "itemId", default)]
5247 pub item_id: String,
5248 #[serde(rename = "threadId", default)]
5249 pub thread_id: String,
5250 #[serde(rename = "turnId", default)]
5251 pub turn_id: String,
5252}
5253
5254#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5255pub enum PlanType {
5256 #[serde(rename = "free")]
5257 Free,
5258 #[serde(rename = "go")]
5259 Go,
5260 #[serde(rename = "plus")]
5261 Plus,
5262 #[serde(rename = "pro")]
5263 Pro,
5264 #[serde(rename = "prolite")]
5265 Prolite,
5266 #[serde(rename = "promax")]
5267 Promax,
5268 #[serde(rename = "edu_plus")]
5269 Edu_plus,
5270 #[serde(rename = "edu_pro")]
5271 Edu_pro,
5272 #[serde(rename = "team")]
5273 Team,
5274 #[serde(rename = "self_serve_business_prolite")]
5275 Self_serve_business_prolite,
5276 #[serde(rename = "self_serve_business_usage_based")]
5277 Self_serve_business_usage_based,
5278 #[serde(rename = "business")]
5279 Business,
5280 #[serde(rename = "ent26")]
5281 Ent26,
5282 #[serde(rename = "enterprise_cbp_automation")]
5283 Enterprise_cbp_automation,
5284 #[serde(rename = "enterprise_cbp_usage_based")]
5285 Enterprise_cbp_usage_based,
5286 #[serde(rename = "enterprise")]
5287 Enterprise,
5288 #[serde(rename = "edu")]
5289 Edu,
5290 #[serde(rename = "unknown")]
5291 Unknown,
5292}
5293
5294#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5295pub enum PluginAuthPolicy {
5296 #[serde(rename = "ON_INSTALL")]
5297 ON_INSTALL,
5298 #[serde(rename = "ON_USE")]
5299 ON_USE,
5300}
5301
5302#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5303pub enum PluginAvailability {
5304 #[serde(rename = "DISABLED_BY_ADMIN")]
5305 DISABLEDBYADMIN,
5306 AVAILABLE,
5307}
5308
5309#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5310#[serde(rename_all = "camelCase")]
5311pub struct PluginDetail {
5312 #[serde(rename = "appTemplates", default)]
5313 pub app_templates: Vec<AppTemplateSummary>,
5314 #[serde(default)]
5315 pub apps: Vec<AppSummary>,
5316 #[serde(default, skip_serializing_if = "Option::is_none")]
5317 pub description: Option<String>,
5318 #[serde(default)]
5319 pub hooks: Vec<PluginHookSummary>,
5320 #[serde(rename = "marketplaceName", default)]
5321 pub marketplace_name: String,
5322 #[serde(
5323 rename = "marketplacePath",
5324 default,
5325 skip_serializing_if = "Option::is_none"
5326 )]
5327 pub marketplace_path: Option<AbsolutePathBuf>,
5328 #[serde(rename = "mcpServers", default)]
5329 pub mcp_servers: Vec<String>,
5330 #[serde(
5332 rename = "onboardingSkill",
5333 default,
5334 skip_serializing_if = "Option::is_none"
5335 )]
5336 pub onboarding_skill: Option<SkillSummary>,
5337 #[serde(
5338 rename = "scheduledTasks",
5339 default,
5340 skip_serializing_if = "Option::is_none"
5341 )]
5342 pub scheduled_tasks: Option<Vec<ScheduledTaskSummary>>,
5343 #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5344 pub share_url: Option<String>,
5345 #[serde(default)]
5346 pub skills: Vec<SkillSummary>,
5347 #[serde()]
5348 pub summary: PluginSummary,
5349}
5350
5351#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5352pub enum PluginDisabledReason {
5353 #[serde(rename = "disabled_by_admin")]
5354 Disabled_by_admin,
5355 #[serde(rename = "plan_not_eligible")]
5356 Plan_not_eligible,
5357 #[serde(rename = "required_app_unavailable")]
5358 Required_app_unavailable,
5359 #[serde(rename = "unknown")]
5360 Unknown,
5361}
5362
5363#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5364#[serde(rename_all = "camelCase")]
5365pub struct PluginHookSummary {
5366 #[serde(rename = "eventName")]
5367 pub event_name: HookEventName,
5368 #[serde(default)]
5369 pub key: String,
5370}
5371
5372#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5373#[serde(rename_all = "camelCase")]
5374pub struct PluginInstallParams {
5375 #[serde(
5376 rename = "installAttemptId",
5377 default,
5378 skip_serializing_if = "Option::is_none"
5379 )]
5380 pub install_attempt_id: Option<String>,
5381 #[serde(
5382 rename = "marketplacePath",
5383 default,
5384 skip_serializing_if = "Option::is_none"
5385 )]
5386 pub marketplace_path: Option<AbsolutePathBuf>,
5387 #[serde(rename = "pluginName", default)]
5388 pub plugin_name: String,
5389 #[serde(
5390 rename = "remoteMarketplaceName",
5391 default,
5392 skip_serializing_if = "Option::is_none"
5393 )]
5394 pub remote_marketplace_name: Option<String>,
5395}
5396
5397#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5398pub enum PluginInstallPolicy {
5399 #[serde(rename = "NOT_AVAILABLE")]
5400 NOT_AVAILABLE,
5401 #[serde(rename = "AVAILABLE")]
5402 AVAILABLE,
5403 #[serde(rename = "INSTALLED_BY_DEFAULT")]
5404 INSTALLED_BY_DEFAULT,
5405}
5406
5407#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5408pub enum PluginInstallPolicySource {
5409 #[serde(rename = "WORKSPACE_SETTING")]
5410 WORKSPACE_SETTING,
5411 #[serde(rename = "IMPLICIT_CANONICAL_APP")]
5412 IMPLICIT_CANONICAL_APP,
5413}
5414
5415#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5416#[serde(rename_all = "camelCase")]
5417pub struct PluginInstallResponse {
5418 #[serde(rename = "appsNeedingAuth", default)]
5419 pub apps_needing_auth: Vec<AppSummary>,
5420 #[serde(rename = "authPolicy")]
5421 pub auth_policy: PluginAuthPolicy,
5422}
5423
5424#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5425#[serde(rename_all = "camelCase")]
5426pub struct PluginInstalledParams {
5427 #[serde(default, skip_serializing_if = "Option::is_none")]
5428 pub cwds: Option<Vec<AbsolutePathBuf>>,
5429 #[serde(
5430 rename = "installSuggestionPluginNames",
5431 default,
5432 skip_serializing_if = "Option::is_none"
5433 )]
5434 pub install_suggestion_plugin_names: Option<Vec<String>>,
5435}
5436
5437#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5438#[serde(rename_all = "camelCase")]
5439pub struct PluginInstalledResponse {
5440 #[serde(
5441 rename = "marketplaceLoadErrors",
5442 default,
5443 skip_serializing_if = "Option::is_none"
5444 )]
5445 pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5446 #[serde(default)]
5447 pub marketplaces: Vec<PluginMarketplaceEntry>,
5448}
5449
5450#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5451#[serde(rename_all = "camelCase")]
5452pub struct PluginInterface {
5453 #[serde(
5454 rename = "brandColor",
5455 default,
5456 skip_serializing_if = "Option::is_none"
5457 )]
5458 pub brand_color: Option<String>,
5459 #[serde(default)]
5460 pub capabilities: Vec<String>,
5461 #[serde(default, skip_serializing_if = "Option::is_none")]
5462 pub category: Option<String>,
5463 #[serde(
5464 rename = "composerIcon",
5465 default,
5466 skip_serializing_if = "Option::is_none"
5467 )]
5468 pub composer_icon: Option<AbsolutePathBuf>,
5469 #[serde(
5470 rename = "composerIconUrl",
5471 default,
5472 skip_serializing_if = "Option::is_none"
5473 )]
5474 pub composer_icon_url: Option<String>,
5475 #[serde(
5476 rename = "defaultPrompt",
5477 default,
5478 skip_serializing_if = "Option::is_none"
5479 )]
5480 pub default_prompt: Option<Vec<String>>,
5481 #[serde(
5482 rename = "developerName",
5483 default,
5484 skip_serializing_if = "Option::is_none"
5485 )]
5486 pub developer_name: Option<String>,
5487 #[serde(
5488 rename = "displayName",
5489 default,
5490 skip_serializing_if = "Option::is_none"
5491 )]
5492 pub display_name: Option<String>,
5493 #[serde(default, skip_serializing_if = "Option::is_none")]
5494 pub logo: Option<AbsolutePathBuf>,
5495 #[serde(rename = "logoDark", default, skip_serializing_if = "Option::is_none")]
5496 pub logo_dark: Option<AbsolutePathBuf>,
5497 #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
5498 pub logo_url: Option<String>,
5499 #[serde(
5500 rename = "logoUrlDark",
5501 default,
5502 skip_serializing_if = "Option::is_none"
5503 )]
5504 pub logo_url_dark: Option<String>,
5505 #[serde(
5506 rename = "longDescription",
5507 default,
5508 skip_serializing_if = "Option::is_none"
5509 )]
5510 pub long_description: Option<String>,
5511 #[serde(
5512 rename = "privacyPolicyUrl",
5513 default,
5514 skip_serializing_if = "Option::is_none"
5515 )]
5516 pub privacy_policy_url: Option<String>,
5517 #[serde(rename = "screenshotUrls", default)]
5518 pub screenshot_urls: Vec<String>,
5519 #[serde(default)]
5520 pub screenshots: Vec<AbsolutePathBuf>,
5521 #[serde(
5522 rename = "shortDescription",
5523 default,
5524 skip_serializing_if = "Option::is_none"
5525 )]
5526 pub short_description: Option<String>,
5527 #[serde(
5528 rename = "termsOfServiceUrl",
5529 default,
5530 skip_serializing_if = "Option::is_none"
5531 )]
5532 pub terms_of_service_url: Option<String>,
5533 #[serde(
5534 rename = "websiteUrl",
5535 default,
5536 skip_serializing_if = "Option::is_none"
5537 )]
5538 pub website_url: Option<String>,
5539}
5540
5541#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5542pub enum PluginListMarketplaceKind {
5543 #[serde(rename = "local")]
5544 Local,
5545 #[serde(rename = "vertical")]
5546 Vertical,
5547 #[serde(rename = "workspace-directory")]
5548 Workspace_directory,
5549 #[serde(rename = "shared-with-me")]
5550 Shared_with_me,
5551 #[serde(rename = "created-by-me-remote")]
5552 Created_by_me_remote,
5553}
5554
5555#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5556#[serde(rename_all = "camelCase")]
5557pub struct PluginListParams {
5558 #[serde(default, skip_serializing_if = "Option::is_none")]
5559 pub cwds: Option<Vec<AbsolutePathBuf>>,
5560 #[serde(
5561 rename = "forceRefetch",
5562 default,
5563 skip_serializing_if = "Option::is_none"
5564 )]
5565 pub force_refetch: Option<bool>,
5566 #[serde(
5567 rename = "marketplaceKinds",
5568 default,
5569 skip_serializing_if = "Option::is_none"
5570 )]
5571 pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
5572}
5573
5574#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5575#[serde(rename_all = "camelCase")]
5576pub struct PluginListResponse {
5577 #[serde(
5578 rename = "featuredPluginIds",
5579 default,
5580 skip_serializing_if = "Option::is_none"
5581 )]
5582 pub featured_plugin_ids: Option<Vec<String>>,
5583 #[serde(
5584 rename = "marketplaceLoadErrors",
5585 default,
5586 skip_serializing_if = "Option::is_none"
5587 )]
5588 pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5589 #[serde(default)]
5590 pub marketplaces: Vec<PluginMarketplaceEntry>,
5591}
5592
5593#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5594#[serde(rename_all = "camelCase")]
5595pub struct PluginMarketplaceEntry {
5596 #[serde(default, skip_serializing_if = "Option::is_none")]
5597 pub interface: Option<MarketplaceInterface>,
5598 #[serde(default)]
5599 pub name: String,
5600 #[serde(default, skip_serializing_if = "Option::is_none")]
5601 pub path: Option<AbsolutePathBuf>,
5602 #[serde(default)]
5603 pub plugins: Vec<PluginSummary>,
5604}
5605
5606#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5607#[serde(rename_all = "camelCase")]
5608pub struct PluginReadParams {
5609 #[serde(
5610 rename = "marketplacePath",
5611 default,
5612 skip_serializing_if = "Option::is_none"
5613 )]
5614 pub marketplace_path: Option<AbsolutePathBuf>,
5615 #[serde(rename = "pluginName", default)]
5616 pub plugin_name: String,
5617 #[serde(
5618 rename = "remoteMarketplaceName",
5619 default,
5620 skip_serializing_if = "Option::is_none"
5621 )]
5622 pub remote_marketplace_name: Option<String>,
5623}
5624
5625#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5626#[serde(rename_all = "camelCase")]
5627pub struct PluginReadResponse {
5628 #[serde()]
5629 pub plugin: PluginDetail,
5630}
5631
5632#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5638#[serde(rename_all = "camelCase")]
5639pub struct PluginReconcileChangedPlugin {
5640 #[serde(rename = "hasApps", default)]
5641 pub has_apps: bool,
5642 #[serde(rename = "hasHooks", default)]
5643 pub has_hooks: bool,
5644 #[serde(rename = "hasMcps", default)]
5645 pub has_mcps: bool,
5646 #[serde(rename = "hasSkills", default)]
5649 pub has_skills: bool,
5650 #[serde(default)]
5652 pub id: String,
5653}
5654
5655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5656#[serde(rename_all = "camelCase")]
5657pub struct PluginReconcileParams {
5658 #[serde(default, skip_serializing_if = "Option::is_none")]
5661 pub reason: Option<String>,
5662}
5663
5664#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5668#[serde(rename_all = "camelCase")]
5669pub struct PluginReconcileResponse {
5670 #[serde(rename = "changedPlugins", default)]
5675 pub changed_plugins: Vec<PluginReconcileChangedPlugin>,
5676 #[serde(rename = "failedMaterializationRemotePluginIds", default)]
5679 pub failed_materialization_remote_plugin_ids: Vec<String>,
5680 #[serde(rename = "failedRemotePluginIds", default)]
5682 pub failed_remote_plugin_ids: Vec<String>,
5683}
5684
5685#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5686#[serde(rename_all = "camelCase")]
5687pub struct PluginShareCheckoutParams {
5688 #[serde(rename = "remotePluginId", default)]
5689 pub remote_plugin_id: String,
5690}
5691
5692#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5693#[serde(rename_all = "camelCase")]
5694pub struct PluginShareCheckoutResponse {
5695 #[serde(rename = "marketplaceName", default)]
5696 pub marketplace_name: String,
5697 #[serde(rename = "marketplacePath")]
5698 pub marketplace_path: AbsolutePathBuf,
5699 #[serde(rename = "pluginId", default)]
5700 pub plugin_id: String,
5701 #[serde(rename = "pluginName", default)]
5702 pub plugin_name: String,
5703 #[serde(rename = "pluginPath")]
5704 pub plugin_path: AbsolutePathBuf,
5705 #[serde(rename = "remotePluginId", default)]
5706 pub remote_plugin_id: String,
5707 #[serde(
5708 rename = "remoteVersion",
5709 default,
5710 skip_serializing_if = "Option::is_none"
5711 )]
5712 pub remote_version: Option<String>,
5713}
5714
5715#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5716#[serde(rename_all = "camelCase")]
5717pub struct PluginShareContext {
5718 #[serde(
5719 rename = "canPublishToWorkspace",
5720 default,
5721 skip_serializing_if = "Option::is_none"
5722 )]
5723 pub can_publish_to_workspace: Option<bool>,
5724 #[serde(
5725 rename = "creatorAccountUserId",
5726 default,
5727 skip_serializing_if = "Option::is_none"
5728 )]
5729 pub creator_account_user_id: Option<String>,
5730 #[serde(
5731 rename = "creatorName",
5732 default,
5733 skip_serializing_if = "Option::is_none"
5734 )]
5735 pub creator_name: Option<String>,
5736 #[serde(default, skip_serializing_if = "Option::is_none")]
5737 pub discoverability: Option<PluginShareDiscoverability>,
5738 #[serde(rename = "remotePluginId", default)]
5739 pub remote_plugin_id: String,
5740 #[serde(
5741 rename = "remoteVersion",
5742 default,
5743 skip_serializing_if = "Option::is_none"
5744 )]
5745 pub remote_version: Option<String>,
5746 #[serde(
5747 rename = "sharePrincipals",
5748 default,
5749 skip_serializing_if = "Option::is_none"
5750 )]
5751 pub share_principals: Option<Vec<PluginSharePrincipal>>,
5752 #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5753 pub share_url: Option<String>,
5754}
5755
5756#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5757#[serde(rename_all = "camelCase")]
5758pub struct PluginShareDeleteParams {
5759 #[serde(rename = "remotePluginId", default)]
5760 pub remote_plugin_id: String,
5761}
5762
5763#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5764#[serde(rename_all = "camelCase")]
5765pub struct PluginShareDeleteResponse {
5766 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5767 pub extra: serde_json::Map<String, Value>,
5768}
5769
5770#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5771pub enum PluginShareDiscoverability {
5772 #[serde(rename = "LISTED")]
5773 LISTED,
5774 #[serde(rename = "UNLISTED")]
5775 UNLISTED,
5776 #[serde(rename = "PRIVATE")]
5777 PRIVATE,
5778}
5779
5780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5781#[serde(rename_all = "camelCase")]
5782pub struct PluginShareListItem {
5783 #[serde(
5784 rename = "localPluginPath",
5785 default,
5786 skip_serializing_if = "Option::is_none"
5787 )]
5788 pub local_plugin_path: Option<AbsolutePathBuf>,
5789 #[serde()]
5790 pub plugin: PluginSummary,
5791}
5792
5793#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5794#[serde(rename_all = "camelCase")]
5795pub struct PluginShareListParams {
5796 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5797 pub extra: serde_json::Map<String, Value>,
5798}
5799
5800#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5801#[serde(rename_all = "camelCase")]
5802pub struct PluginShareListResponse {
5803 #[serde(default)]
5804 pub data: Vec<PluginShareListItem>,
5805}
5806
5807#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5808#[serde(rename_all = "camelCase")]
5809pub struct PluginSharePrincipal {
5810 #[serde(default)]
5811 pub name: String,
5812 #[serde(rename = "principalId", default)]
5813 pub principal_id: String,
5814 #[serde(rename = "principalType")]
5815 pub principal_type: PluginSharePrincipalType,
5816 #[serde()]
5817 pub role: PluginSharePrincipalRole,
5818}
5819
5820#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5821pub enum PluginSharePrincipalRole {
5822 #[serde(rename = "reader")]
5823 Reader,
5824 #[serde(rename = "editor")]
5825 Editor,
5826 #[serde(rename = "owner")]
5827 Owner,
5828}
5829
5830#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5831pub enum PluginSharePrincipalType {
5832 #[serde(rename = "user")]
5833 User,
5834 #[serde(rename = "group")]
5835 Group,
5836 #[serde(rename = "workspace")]
5837 Workspace,
5838}
5839
5840#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5841#[serde(rename_all = "camelCase")]
5842pub struct PluginShareSaveParams {
5843 #[serde(default, skip_serializing_if = "Option::is_none")]
5844 pub discoverability: Option<PluginShareDiscoverability>,
5845 #[serde(rename = "pluginPath")]
5846 pub plugin_path: AbsolutePathBuf,
5847 #[serde(
5848 rename = "remotePluginId",
5849 default,
5850 skip_serializing_if = "Option::is_none"
5851 )]
5852 pub remote_plugin_id: Option<String>,
5853 #[serde(
5854 rename = "shareTargets",
5855 default,
5856 skip_serializing_if = "Option::is_none"
5857 )]
5858 pub share_targets: Option<Vec<PluginShareTarget>>,
5859}
5860
5861#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5862#[serde(rename_all = "camelCase")]
5863pub struct PluginShareSaveResponse {
5864 #[serde(
5865 rename = "canPublishToWorkspace",
5866 default,
5867 skip_serializing_if = "Option::is_none"
5868 )]
5869 pub can_publish_to_workspace: Option<bool>,
5870 #[serde(rename = "remotePluginId", default)]
5871 pub remote_plugin_id: String,
5872 #[serde(rename = "shareUrl", default)]
5873 pub share_url: String,
5874}
5875
5876#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5877#[serde(rename_all = "camelCase")]
5878pub struct PluginShareTarget {
5879 #[serde(rename = "principalId", default)]
5880 pub principal_id: String,
5881 #[serde(rename = "principalType")]
5882 pub principal_type: PluginSharePrincipalType,
5883 #[serde()]
5884 pub role: PluginShareTargetRole,
5885}
5886
5887#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5888pub enum PluginShareTargetRole {
5889 #[serde(rename = "reader")]
5890 Reader,
5891 #[serde(rename = "editor")]
5892 Editor,
5893}
5894
5895#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5896pub enum PluginShareUpdateDiscoverability {
5897 #[serde(rename = "UNLISTED")]
5898 UNLISTED,
5899 #[serde(rename = "PRIVATE")]
5900 PRIVATE,
5901 #[serde(rename = "LISTED")]
5902 LISTED,
5903}
5904
5905#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5906#[serde(rename_all = "camelCase")]
5907pub struct PluginShareUpdateTargetsParams {
5908 #[serde()]
5909 pub discoverability: PluginShareUpdateDiscoverability,
5910 #[serde(rename = "remotePluginId", default)]
5911 pub remote_plugin_id: String,
5912 #[serde(rename = "shareTargets", default)]
5913 pub share_targets: Vec<PluginShareTarget>,
5914}
5915
5916#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5917#[serde(rename_all = "camelCase")]
5918pub struct PluginShareUpdateTargetsResponse {
5919 #[serde()]
5920 pub discoverability: PluginShareDiscoverability,
5921 #[serde(default)]
5922 pub principals: Vec<PluginSharePrincipal>,
5923}
5924
5925#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5926#[serde(rename_all = "camelCase")]
5927pub struct PluginSkillReadParams {
5928 #[serde(rename = "remoteMarketplaceName", default)]
5929 pub remote_marketplace_name: String,
5930 #[serde(rename = "remotePluginId", default)]
5931 pub remote_plugin_id: String,
5932 #[serde(rename = "skillName", default)]
5933 pub skill_name: String,
5934}
5935
5936#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5937#[serde(rename_all = "camelCase")]
5938pub struct PluginSkillReadResponse {
5939 #[serde(default, skip_serializing_if = "Option::is_none")]
5940 pub contents: Option<String>,
5941}
5942
5943#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5944#[serde(tag = "type", rename_all = "camelCase")]
5945pub enum PluginSource {
5946 Local {
5947 path: AbsolutePathBuf,
5948 },
5949 Git {
5950 #[serde(default, skip_serializing_if = "Option::is_none")]
5951 path: Option<String>,
5952 #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
5953 ref_name: Option<String>,
5954 #[serde(default, skip_serializing_if = "Option::is_none")]
5955 sha: Option<String>,
5956 url: String,
5957 },
5958 Npm {
5959 package: String,
5960 #[serde(default, skip_serializing_if = "Option::is_none")]
5961 registry: Option<String>,
5962 #[serde(default, skip_serializing_if = "Option::is_none")]
5963 version: Option<String>,
5964 },
5965 Remote,
5966}
5967
5968#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5969#[serde(rename_all = "camelCase")]
5970pub struct PluginSummary {
5971 #[serde(rename = "authPolicy")]
5972 pub auth_policy: PluginAuthPolicy,
5973 #[serde(default, skip_serializing_if = "Option::is_none")]
5974 pub availability: Option<Value>,
5975 #[serde(
5976 rename = "disabledReason",
5977 default,
5978 skip_serializing_if = "Option::is_none"
5979 )]
5980 pub disabled_reason: Option<PluginDisabledReason>,
5981 #[serde(
5982 rename = "eligiblePlanTypes",
5983 default,
5984 skip_serializing_if = "Option::is_none"
5985 )]
5986 pub eligible_plan_types: Option<Vec<String>>,
5987 #[serde(default)]
5988 pub enabled: bool,
5989 #[serde(default)]
5990 pub id: String,
5991 #[serde(rename = "installPolicy")]
5992 pub install_policy: PluginInstallPolicy,
5993 #[serde(
5994 rename = "installPolicySource",
5995 default,
5996 skip_serializing_if = "Option::is_none"
5997 )]
5998 pub install_policy_source: Option<PluginInstallPolicySource>,
5999 #[serde(default)]
6000 pub installed: bool,
6001 #[serde(
6002 rename = "installedAt",
6003 default,
6004 skip_serializing_if = "Option::is_none"
6005 )]
6006 pub installed_at: Option<i64>,
6007 #[serde(default, skip_serializing_if = "Option::is_none")]
6008 pub interface: Option<PluginInterface>,
6009 #[serde(default, skip_serializing_if = "Option::is_none")]
6010 pub keywords: Option<Vec<String>>,
6011 #[serde(
6012 rename = "localVersion",
6013 default,
6014 skip_serializing_if = "Option::is_none"
6015 )]
6016 pub local_version: Option<String>,
6017 #[serde(
6018 rename = "mustShowInstallationInterstitial",
6019 default,
6020 skip_serializing_if = "Option::is_none"
6021 )]
6022 pub must_show_installation_interstitial: Option<bool>,
6023 #[serde(default)]
6024 pub name: String,
6025 #[serde(
6026 rename = "remotePluginId",
6027 default,
6028 skip_serializing_if = "Option::is_none"
6029 )]
6030 pub remote_plugin_id: Option<String>,
6031 #[serde(
6032 rename = "shareContext",
6033 default,
6034 skip_serializing_if = "Option::is_none"
6035 )]
6036 pub share_context: Option<PluginShareContext>,
6037 #[serde()]
6038 pub source: PluginSource,
6039 #[serde(default, skip_serializing_if = "Option::is_none")]
6040 pub version: Option<String>,
6041}
6042
6043#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6044#[serde(rename_all = "camelCase")]
6045pub struct PluginUninstallParams {
6046 #[serde(rename = "pluginId", default)]
6047 pub plugin_id: String,
6048}
6049
6050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6051#[serde(rename_all = "camelCase")]
6052pub struct PluginUninstallResponse {
6053 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6054 pub extra: serde_json::Map<String, Value>,
6055}
6056
6057#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6058#[serde(rename_all = "camelCase")]
6059pub struct PluginsMigration {
6060 #[serde(rename = "marketplaceName", default)]
6061 pub marketplace_name: String,
6062 #[serde(rename = "pluginNames", default)]
6063 pub plugin_names: Vec<String>,
6064}
6065
6066#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6067#[serde(rename_all = "camelCase")]
6068pub struct ProcessExitedNotification {
6069 #[serde(rename = "exitCode", default)]
6070 pub exit_code: i64,
6071 #[serde(rename = "processHandle", default)]
6072 pub process_handle: String,
6073 #[serde(default)]
6074 pub stderr: String,
6075 #[serde(rename = "stderrCapReached", default)]
6076 pub stderr_cap_reached: bool,
6077 #[serde(default)]
6078 pub stdout: String,
6079 #[serde(rename = "stdoutCapReached", default)]
6080 pub stdout_cap_reached: bool,
6081}
6082
6083#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6084#[serde(rename_all = "camelCase")]
6085pub struct ProcessOutputDeltaNotification {
6086 #[serde(rename = "capReached", default)]
6087 pub cap_reached: bool,
6088 #[serde(rename = "deltaBase64", default)]
6089 pub delta_base64: String,
6090 #[serde(rename = "processHandle", default)]
6091 pub process_handle: String,
6092 #[serde(default)]
6093 pub stream: Value,
6094}
6095
6096#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6097pub enum ProcessOutputStream {
6098 #[serde(rename = "stdout")]
6099 Stdout,
6100 #[serde(rename = "stderr")]
6101 Stderr,
6102}
6103
6104#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6105pub enum RateLimitReachedType {
6106 #[serde(rename = "rate_limit_reached")]
6107 Rate_limit_reached,
6108 #[serde(rename = "workspace_owner_credits_depleted")]
6109 Workspace_owner_credits_depleted,
6110 #[serde(rename = "workspace_member_credits_depleted")]
6111 Workspace_member_credits_depleted,
6112 #[serde(rename = "workspace_owner_usage_limit_reached")]
6113 Workspace_owner_usage_limit_reached,
6114 #[serde(rename = "workspace_member_usage_limit_reached")]
6115 Workspace_member_usage_limit_reached,
6116}
6117
6118#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6119#[serde(rename_all = "camelCase")]
6120pub struct RateLimitResetCredit {
6121 #[serde(default, skip_serializing_if = "Option::is_none")]
6122 pub description: Option<String>,
6123 #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
6124 pub expires_at: Option<i64>,
6125 #[serde(rename = "grantedAt", default)]
6126 pub granted_at: i64,
6127 #[serde(default)]
6128 pub id: String,
6129 #[serde(rename = "resetType")]
6130 pub reset_type: RateLimitResetType,
6131 #[serde()]
6132 pub status: RateLimitResetCreditStatus,
6133 #[serde(default, skip_serializing_if = "Option::is_none")]
6134 pub title: Option<String>,
6135}
6136
6137#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6138pub enum RateLimitResetCreditStatus {
6139 #[serde(rename = "available")]
6140 Available,
6141 #[serde(rename = "redeeming")]
6142 Redeeming,
6143 #[serde(rename = "redeemed")]
6144 Redeemed,
6145 #[serde(rename = "unknown")]
6146 Unknown,
6147}
6148
6149#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6150#[serde(rename_all = "camelCase")]
6151pub struct RateLimitResetCreditsSummary {
6152 #[serde(rename = "availableCount", default)]
6153 pub available_count: i64,
6154 #[serde(default, skip_serializing_if = "Option::is_none")]
6155 pub credits: Option<Vec<RateLimitResetCredit>>,
6156}
6157
6158#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6159pub enum RateLimitResetType {
6160 #[serde(rename = "codexRateLimits")]
6161 CodexRateLimits,
6162 #[serde(rename = "unknown")]
6163 Unknown,
6164}
6165
6166#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6167#[serde(rename_all = "camelCase")]
6168pub struct RateLimitSnapshot {
6169 #[serde(default, skip_serializing_if = "Option::is_none")]
6170 pub credits: Option<CreditsSnapshot>,
6171 #[serde(
6172 rename = "individualLimit",
6173 default,
6174 skip_serializing_if = "Option::is_none"
6175 )]
6176 pub individual_limit: Option<SpendControlLimitSnapshot>,
6177 #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
6178 pub limit_id: Option<String>,
6179 #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
6180 pub limit_name: Option<String>,
6181 #[serde(
6184 rename = "normalModelSlug",
6185 default,
6186 skip_serializing_if = "Option::is_none"
6187 )]
6188 pub normal_model_slug: Option<String>,
6189 #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
6190 pub plan_type: Option<PlanType>,
6191 #[serde(default, skip_serializing_if = "Option::is_none")]
6192 pub primary: Option<RateLimitWindow>,
6193 #[serde(
6194 rename = "rateLimitReachedType",
6195 default,
6196 skip_serializing_if = "Option::is_none"
6197 )]
6198 pub rate_limit_reached_type: Option<RateLimitReachedType>,
6199 #[serde(default, skip_serializing_if = "Option::is_none")]
6200 pub secondary: Option<RateLimitWindow>,
6201 #[serde(
6202 rename = "spendControlReached",
6203 default,
6204 skip_serializing_if = "Option::is_none"
6205 )]
6206 pub spend_control_reached: Option<bool>,
6207}
6208
6209#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6210#[serde(rename_all = "camelCase")]
6211pub struct RateLimitWindow {
6212 #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
6213 pub resets_at: Option<i64>,
6214 #[serde(rename = "usedPercent", default)]
6215 pub used_percent: i64,
6216 #[serde(
6217 rename = "windowDurationMins",
6218 default,
6219 skip_serializing_if = "Option::is_none"
6220 )]
6221 pub window_duration_mins: Option<i64>,
6222}
6223
6224#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6225pub enum RealtimeConversationVersion {
6226 #[serde(rename = "v1")]
6227 V1,
6228 #[serde(rename = "v2")]
6229 V2,
6230 #[serde(rename = "v3")]
6231 V3,
6232}
6233
6234#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
6236#[serde(transparent)]
6237pub struct ReasoningEffort(pub String);
6238
6239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6240#[serde(rename_all = "camelCase")]
6241pub struct ReasoningEffortOption {
6242 #[serde(default)]
6243 pub description: String,
6244 #[serde(rename = "reasoningEffort")]
6245 pub reasoning_effort: ReasoningEffort,
6246}
6247
6248#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6249pub enum ReasoningSummary {
6250 #[serde(rename = "auto")]
6251 Auto,
6252 #[serde(rename = "concise")]
6253 Concise,
6254 #[serde(rename = "detailed")]
6255 Detailed,
6256 #[serde(rename = "none")]
6257 None,
6258}
6259
6260#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6261#[serde(rename_all = "camelCase")]
6262pub struct ReasoningSummaryPartAddedNotification {
6263 #[serde(rename = "itemId", default)]
6264 pub item_id: String,
6265 #[serde(rename = "summaryIndex", default)]
6266 pub summary_index: i64,
6267 #[serde(rename = "threadId", default)]
6268 pub thread_id: String,
6269 #[serde(rename = "turnId", default)]
6270 pub turn_id: String,
6271}
6272
6273#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6274#[serde(rename_all = "camelCase")]
6275pub struct ReasoningSummaryTextDeltaNotification {
6276 #[serde(default)]
6277 pub delta: String,
6278 #[serde(rename = "itemId", default)]
6279 pub item_id: String,
6280 #[serde(rename = "summaryIndex", default)]
6281 pub summary_index: i64,
6282 #[serde(rename = "threadId", default)]
6283 pub thread_id: String,
6284 #[serde(rename = "turnId", default)]
6285 pub turn_id: String,
6286}
6287
6288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6289#[serde(rename_all = "camelCase")]
6290pub struct ReasoningTextDeltaNotification {
6291 #[serde(rename = "contentIndex", default)]
6292 pub content_index: i64,
6293 #[serde(default)]
6294 pub delta: String,
6295 #[serde(rename = "itemId", default)]
6296 pub item_id: String,
6297 #[serde(rename = "threadId", default)]
6298 pub thread_id: String,
6299 #[serde(rename = "turnId", default)]
6300 pub turn_id: String,
6301}
6302
6303#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6304pub enum RemoteControlConnectionStatus {
6305 #[serde(rename = "disabled")]
6306 Disabled,
6307 #[serde(rename = "connecting")]
6308 Connecting,
6309 #[serde(rename = "connected")]
6310 Connected,
6311 #[serde(rename = "errored")]
6312 Errored,
6313}
6314
6315#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6316#[serde(rename_all = "camelCase")]
6317pub struct RemoteControlStatusChangedNotification {
6318 #[serde(
6319 rename = "environmentId",
6320 default,
6321 skip_serializing_if = "Option::is_none"
6322 )]
6323 pub environment_id: Option<String>,
6324 #[serde(rename = "installationId", default)]
6325 pub installation_id: String,
6326 #[serde(rename = "serverName", default)]
6327 pub server_name: String,
6328 #[serde()]
6329 pub status: RemoteControlConnectionStatus,
6330}
6331
6332#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6333#[serde(untagged)]
6334pub enum RequestId {
6335 Variant0(String),
6336 Variant1(i64),
6337}
6338
6339#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6340#[serde(rename_all = "camelCase")]
6341pub struct RequestPermissionProfile {
6342 #[serde(
6343 rename = "fileSystem",
6344 default,
6345 skip_serializing_if = "Option::is_none"
6346 )]
6347 pub file_system: Option<AdditionalFileSystemPermissions>,
6348 #[serde(default, skip_serializing_if = "Option::is_none")]
6349 pub network: Option<AdditionalNetworkPermissions>,
6350}
6351
6352#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6353pub enum ResidencyRequirement {
6354 #[serde(rename = "us")]
6355 Us,
6356}
6357
6358#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6359#[serde(rename_all = "camelCase")]
6360pub struct Resource {
6361 #[serde(default, skip_serializing_if = "Option::is_none")]
6362 pub _meta: Option<Value>,
6363 #[serde(default, skip_serializing_if = "Option::is_none")]
6364 pub annotations: Option<Value>,
6365 #[serde(default, skip_serializing_if = "Option::is_none")]
6366 pub description: Option<String>,
6367 #[serde(default, skip_serializing_if = "Option::is_none")]
6368 pub icons: Option<Vec<Value>>,
6369 #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6370 pub mime_type: Option<String>,
6371 #[serde(default)]
6372 pub name: String,
6373 #[serde(default, skip_serializing_if = "Option::is_none")]
6374 pub size: Option<i64>,
6375 #[serde(default, skip_serializing_if = "Option::is_none")]
6376 pub title: Option<String>,
6377 #[serde(default)]
6378 pub uri: String,
6379}
6380
6381#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6382#[serde(untagged)]
6383pub enum ResourceContent {
6384 Variant0(Value),
6385 Variant1(Value),
6386}
6387
6388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6389#[serde(rename_all = "camelCase")]
6390pub struct ResourceTemplate {
6391 #[serde(default, skip_serializing_if = "Option::is_none")]
6392 pub annotations: Option<Value>,
6393 #[serde(default, skip_serializing_if = "Option::is_none")]
6394 pub description: Option<String>,
6395 #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6396 pub mime_type: Option<String>,
6397 #[serde(default)]
6398 pub name: String,
6399 #[serde(default, skip_serializing_if = "Option::is_none")]
6400 pub title: Option<String>,
6401 #[serde(rename = "uriTemplate", default)]
6402 pub uri_template: String,
6403}
6404
6405#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6407#[serde(rename_all = "camelCase")]
6408pub struct ResponseUsageMetadata {
6409 #[serde(default, skip_serializing_if = "Option::is_none")]
6410 pub amount: Option<String>,
6411 #[serde(default, skip_serializing_if = "Option::is_none")]
6412 pub metadata: Option<Value>,
6413}
6414
6415#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6416pub enum ReviewDecision {
6417 #[serde(rename = "approved")]
6418 Approved,
6419 #[serde(rename = "approved_execpolicy_amendment")]
6420 ApprovedExecpolicyAmendment {
6421 proposed_execpolicy_amendment: Vec<String>,
6422 },
6423 #[serde(rename = "approved_for_session")]
6424 ApprovedForSession,
6425 #[serde(rename = "approved_mcp_policy_amendment")]
6426 ApprovedMcpPolicyAmendment,
6427 #[serde(rename = "network_policy_amendment")]
6428 NetworkPolicyAmendment {
6429 network_policy_amendment: NetworkPolicyAmendment,
6430 },
6431 #[serde(rename = "denied")]
6432 Denied { rejection: String },
6433 #[serde(rename = "timed_out")]
6434 TimedOut,
6435 #[serde(rename = "abort")]
6436 Abort,
6437}
6438
6439#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6440pub enum ReviewDelivery {
6441 #[serde(rename = "inline")]
6442 Inline,
6443 #[serde(rename = "detached")]
6444 Detached,
6445}
6446
6447#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6448#[serde(rename_all = "camelCase")]
6449pub struct ReviewStartParams {
6450 #[serde(default, skip_serializing_if = "Option::is_none")]
6451 pub delivery: Option<ReviewDelivery>,
6452 #[serde()]
6453 pub target: ReviewTarget,
6454 #[serde(rename = "threadId", default)]
6455 pub thread_id: String,
6456}
6457
6458#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6459#[serde(rename_all = "camelCase")]
6460pub struct ReviewStartResponse {
6461 #[serde(rename = "reviewThreadId", default)]
6462 pub review_thread_id: String,
6463 #[serde()]
6464 pub turn: Turn,
6465}
6466
6467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6468#[serde(tag = "type", rename_all = "camelCase")]
6469pub enum ReviewTarget {
6470 #[serde(rename = "uncommittedChanges")]
6471 UncommittedChanges,
6472 #[serde(rename = "baseBranch")]
6473 BaseBranch {
6474 branch: String,
6475 },
6476 Commit {
6477 sha: String,
6478 #[serde(default, skip_serializing_if = "Option::is_none")]
6479 title: Option<String>,
6480 },
6481 Custom {
6482 instructions: String,
6483 },
6484}
6485
6486#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6488pub enum AgentMessageDelivery {
6489 #[serde(rename = "async")]
6490 Async,
6491}
6492
6493#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6495pub enum CliAuthCredentialsStoreMode {
6496 #[serde(rename = "file")]
6497 File,
6498 #[serde(rename = "keyring")]
6499 Keyring,
6500 #[serde(rename = "auto")]
6501 Auto,
6502 #[serde(rename = "ephemeral")]
6503 Ephemeral,
6504}
6505
6506#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6508pub struct Project {
6509 #[serde(rename = "createdAt", default)]
6510 pub created_at: i64,
6511 #[serde(default)]
6512 pub id: String,
6513 #[serde(default)]
6514 pub metadata: std::collections::HashMap<String, String>,
6515 #[serde(default)]
6516 pub name: String,
6517 #[serde(default)]
6518 pub position: i64,
6519 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
6522 pub recency_at: Option<i64>,
6523 #[serde(default)]
6524 pub roots: Vec<ProjectRoot>,
6525 #[serde(rename = "updatedAt", default)]
6526 pub updated_at: i64,
6527}
6528
6529#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6531pub enum ProjectSortKey {
6532 #[serde(rename = "position")]
6533 Position,
6534 #[serde(rename = "recencyAt")]
6535 RecencyAt,
6536}
6537
6538#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6539pub enum ProjectChangeType {
6540 #[serde(rename = "created")]
6541 Created,
6542 #[serde(rename = "updated")]
6543 Updated,
6544 #[serde(rename = "deleted")]
6545 Deleted,
6546}
6547
6548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6550pub struct ProjectChangedNotification {
6551 #[serde(rename = "changeType")]
6552 pub change_type: ProjectChangeType,
6553 #[serde(rename = "projectId", default)]
6554 pub project_id: String,
6555}
6556
6557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6558pub struct ProjectRoot {
6559 pub path: AbsolutePathBuf,
6560}
6561
6562#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6564pub struct QueuedSubmission {
6565 #[serde(rename = "clientUserMessageId", default)]
6566 pub client_user_message_id: String,
6567 #[serde(default)]
6568 pub id: String,
6569 #[serde(default)]
6570 pub input: Vec<UserInput>,
6571}
6572
6573#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6575pub struct StrictReviewRequiredNotification {
6576 #[serde(rename = "startedAtMs", default)]
6578 pub started_at_ms: i64,
6579 #[serde(rename = "threadId", default)]
6580 pub thread_id: String,
6581 #[serde(rename = "turnId", default)]
6582 pub turn_id: String,
6583}
6584
6585#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6587pub struct ThreadProjectUpdatedNotification {
6588 #[serde(rename = "projectId", default)]
6589 pub project_id: Option<String>,
6590 #[serde(rename = "threadId", default)]
6591 pub thread_id: String,
6592}
6593
6594#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6596pub struct ThreadQueueChangedNotification {
6597 #[serde(rename = "threadId", default)]
6598 pub thread_id: String,
6599}
6600
6601#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6603pub struct ThreadRevertedNotification {
6604 #[serde(rename = "threadId", default)]
6605 pub thread_id: String,
6606}
6607
6608#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6611#[serde(rename_all = "camelCase")]
6612pub struct ThreadPredictionUpdatedNotification {
6613 pub result: ThreadPredictionResult,
6614 #[serde(rename = "sourceTurnId", default)]
6615 pub source_turn_id: String,
6616 #[serde(rename = "threadId", default)]
6617 pub thread_id: String,
6618}
6619
6620#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6622#[serde(tag = "type", rename_all = "camelCase")]
6623pub enum ThreadPredictionResult {
6624 Completed {
6625 #[serde(default, skip_serializing_if = "Option::is_none")]
6626 text: Option<String>,
6627 },
6628 Failed,
6629}
6630
6631#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6633#[serde(rename_all = "camelCase")]
6634pub struct InAppBrowserRequirements {
6635 #[serde(
6636 rename = "allowExternalBrowserSettingsImport",
6637 default,
6638 skip_serializing_if = "Option::is_none"
6639 )]
6640 pub allow_external_browser_settings_import: Option<bool>,
6641}
6642
6643#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6645pub struct McpServerEventNotification {
6646 #[serde(default)]
6647 pub method: String,
6648 #[serde(default)]
6649 pub params: Value,
6650}
6651
6652#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6655pub struct McpServerEventStreamNotification {
6656 pub notification: McpServerEventNotification,
6657 #[serde(rename = "subscriptionId", default)]
6658 pub subscription_id: String,
6659}
6660
6661#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6664pub enum AllowDenyRequirement {
6665 #[serde(rename = "allow")]
6666 Allow,
6667 #[serde(rename = "deny")]
6668 Deny,
6669}
6670
6671#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6673pub enum BrowserUseAccessApprovalLifetime {
6674 #[serde(rename = "turn")]
6675 Turn,
6676 #[serde(rename = "thread")]
6677 Thread,
6678}
6679
6680#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
6682pub enum McpServerConnectionStatus {
6683 #[serde(rename = "notStarted")]
6684 NotStarted,
6685 #[serde(rename = "starting")]
6686 Starting,
6687 #[serde(rename = "connected")]
6688 Connected,
6689 #[serde(rename = "authenticationRequired")]
6690 AuthenticationRequired,
6691 #[serde(rename = "failed")]
6692 Failed,
6693 #[serde(rename = "cancelled")]
6694 Cancelled,
6695 #[serde(rename = "disabled")]
6696 Disabled,
6697}
6698
6699#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6701#[serde(rename_all = "camelCase")]
6702pub struct BrowserUseOriginPolicy {
6703 #[serde(default, skip_serializing_if = "Option::is_none")]
6704 pub access: Option<AllowDenyRequirement>,
6705 #[serde(
6706 rename = "accessApprovalLifetime",
6707 default,
6708 skip_serializing_if = "Option::is_none"
6709 )]
6710 pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
6711 #[serde(
6712 rename = "autoReview",
6713 default,
6714 skip_serializing_if = "Option::is_none"
6715 )]
6716 pub auto_review: Option<AllowDenyRequirement>,
6717 #[serde(default, skip_serializing_if = "Option::is_none")]
6718 pub downloads: Option<AllowDenyRequirement>,
6719 #[serde(
6720 rename = "fullCdpAccess",
6721 default,
6722 skip_serializing_if = "Option::is_none"
6723 )]
6724 pub full_cdp_access: Option<AllowDenyRequirement>,
6725 #[serde(
6726 rename = "persistentApproval",
6727 default,
6728 skip_serializing_if = "Option::is_none"
6729 )]
6730 pub persistent_approval: Option<bool>,
6731 #[serde(default, skip_serializing_if = "Option::is_none")]
6732 pub uploads: Option<AllowDenyRequirement>,
6733}
6734
6735#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6737pub struct BrowserUseOriginPolicyConfig {
6738 #[serde(default, skip_serializing_if = "Option::is_none")]
6739 pub access: Option<AllowDenyRequirement>,
6740 #[serde(default, skip_serializing_if = "Option::is_none")]
6741 pub downloads: Option<AllowDenyRequirement>,
6742 #[serde(default, skip_serializing_if = "Option::is_none")]
6743 pub full_cdp_access: Option<AllowDenyRequirement>,
6744 #[serde(default, skip_serializing_if = "Option::is_none")]
6745 pub uploads: Option<AllowDenyRequirement>,
6746}
6747
6748#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6750pub struct BrowserUseConfig {
6751 #[serde(default, skip_serializing_if = "Option::is_none")]
6752 pub allow_history_access: Option<bool>,
6753 #[serde(default, skip_serializing_if = "Option::is_none")]
6754 pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
6755 #[serde(default, skip_serializing_if = "Option::is_none")]
6756 pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
6757}
6758
6759#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6761pub struct ComputerUseConfig {
6762 #[serde(default, skip_serializing_if = "Option::is_none")]
6763 pub default_app_access: Option<AllowDenyRequirement>,
6764 #[serde(default, skip_serializing_if = "Option::is_none")]
6765 pub macos: Option<ComputerUseMacosConfig>,
6766 #[serde(default, skip_serializing_if = "Option::is_none")]
6767 pub windows: Option<ComputerUseWindowsConfig>,
6768}
6769
6770#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6771pub struct ComputerUseMacosConfig {
6772 #[serde(default, skip_serializing_if = "Option::is_none")]
6773 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6774}
6775
6776#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6777pub struct ComputerUseWindowsConfig {
6778 #[serde(default, skip_serializing_if = "Option::is_none")]
6779 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6780 #[serde(default, skip_serializing_if = "Option::is_none")]
6781 pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
6782}
6783
6784#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6785pub struct ComputerUseWindowsExeConfig {
6786 pub access: AllowDenyRequirement,
6787 #[serde(default, skip_serializing_if = "Option::is_none")]
6788 pub binary_name: Option<String>,
6789 #[serde(default)]
6790 pub product_name: String,
6791 #[serde(default)]
6792 pub publisher_name: String,
6793}
6794
6795#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6797#[serde(rename_all = "camelCase")]
6798pub struct ComputerUseMacosRequirements {
6799 #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
6800 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6801}
6802
6803#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6804#[serde(rename_all = "camelCase")]
6805pub struct ComputerUseWindowsRequirements {
6806 #[serde(default, skip_serializing_if = "Option::is_none")]
6807 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
6808 #[serde(default, skip_serializing_if = "Option::is_none")]
6809 pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
6810}
6811
6812#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6813#[serde(rename_all = "camelCase")]
6814pub struct ComputerUseWindowsExeRequirement {
6815 pub access: AllowDenyRequirement,
6816 #[serde(
6817 rename = "binaryName",
6818 default,
6819 skip_serializing_if = "Option::is_none"
6820 )]
6821 pub binary_name: Option<String>,
6822 #[serde(rename = "productName", default)]
6823 pub product_name: String,
6824 #[serde(rename = "publisherName", default)]
6825 pub publisher_name: String,
6826}
6827
6828#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6829pub enum SandboxMode {
6830 #[serde(rename = "read-only")]
6831 Read_only,
6832 #[serde(rename = "workspace-write")]
6833 Workspace_write,
6834 #[serde(rename = "danger-full-access")]
6835 Danger_full_access,
6836}
6837
6838#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6839#[serde(tag = "type", rename_all = "camelCase")]
6840pub enum SandboxPolicy {
6841 #[serde(rename = "dangerFullAccess")]
6842 DangerFullAccess,
6843 #[serde(rename = "readOnly")]
6844 ReadOnly {
6845 #[serde(
6846 rename = "networkAccess",
6847 default,
6848 skip_serializing_if = "Option::is_none"
6849 )]
6850 network_access: Option<bool>,
6851 },
6852 #[serde(rename = "externalSandbox")]
6853 ExternalSandbox {
6854 #[serde(
6855 rename = "networkAccess",
6856 default,
6857 skip_serializing_if = "Option::is_none"
6858 )]
6859 network_access: Option<Value>,
6860 },
6861 #[serde(rename = "workspaceWrite")]
6862 WorkspaceWrite {
6863 #[serde(
6864 rename = "excludeSlashTmp",
6865 default,
6866 skip_serializing_if = "Option::is_none"
6867 )]
6868 exclude_slash_tmp: Option<bool>,
6869 #[serde(
6870 rename = "excludeTmpdirEnvVar",
6871 default,
6872 skip_serializing_if = "Option::is_none"
6873 )]
6874 exclude_tmpdir_env_var: Option<bool>,
6875 #[serde(
6876 rename = "networkAccess",
6877 default,
6878 skip_serializing_if = "Option::is_none"
6879 )]
6880 network_access: Option<bool>,
6881 #[serde(
6882 rename = "writableRoots",
6883 default,
6884 skip_serializing_if = "Option::is_none"
6885 )]
6886 writable_roots: Option<Vec<AbsolutePathBuf>>,
6887 },
6888}
6889
6890#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6891#[serde(rename_all = "snake_case")]
6892pub struct SandboxWorkspaceWrite {
6893 #[serde(default, skip_serializing_if = "Option::is_none")]
6894 pub exclude_slash_tmp: Option<bool>,
6895 #[serde(default, skip_serializing_if = "Option::is_none")]
6896 pub exclude_tmpdir_env_var: Option<bool>,
6897 #[serde(default, skip_serializing_if = "Option::is_none")]
6898 pub network_access: Option<bool>,
6899 #[serde(default, skip_serializing_if = "Option::is_none")]
6900 pub writable_roots: Option<Vec<String>>,
6901}
6902
6903#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6904#[serde(tag = "type", rename_all = "camelCase")]
6905pub enum ScheduledTaskSchedule {
6906 Hourly {
6907 #[serde(default, skip_serializing_if = "Option::is_none")]
6908 days: Option<Vec<ScheduledTaskWeekday>>,
6909 #[serde(rename = "intervalHours")]
6910 interval_hours: i64,
6911 },
6912 Daily {
6913 time: String,
6914 },
6915 Weekdays {
6916 time: String,
6917 },
6918 Weekly {
6919 days: Vec<ScheduledTaskWeekday>,
6920 time: String,
6921 },
6922}
6923
6924#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6925#[serde(rename_all = "camelCase")]
6926pub struct ScheduledTaskSummary {
6927 #[serde(default)]
6928 pub key: String,
6929 #[serde(default)]
6930 pub name: String,
6931 #[serde(default)]
6932 pub prompt: String,
6933 #[serde()]
6934 pub schedule: ScheduledTaskSchedule,
6935}
6936
6937#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6938pub enum ScheduledTaskWeekday {
6939 #[serde(rename = "MO")]
6940 MO,
6941 #[serde(rename = "TU")]
6942 TU,
6943 #[serde(rename = "WE")]
6944 WE,
6945 #[serde(rename = "TH")]
6946 TH,
6947 #[serde(rename = "FR")]
6948 FR,
6949 #[serde(rename = "SA")]
6950 SA,
6951 #[serde(rename = "SU")]
6952 SU,
6953}
6954
6955#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6956#[serde(rename_all = "camelCase")]
6957pub struct SendAddCreditsNudgeEmailParams {
6958 #[serde(rename = "creditType")]
6959 pub credit_type: AddCreditsNudgeCreditType,
6960}
6961
6962#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6963#[serde(rename_all = "camelCase")]
6964pub struct SendAddCreditsNudgeEmailResponse {
6965 #[serde()]
6966 pub status: AddCreditsNudgeEmailStatus,
6967}
6968
6969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6970#[serde(rename_all = "camelCase")]
6971pub struct ServerRequestResolvedNotification {
6972 #[serde(rename = "requestId")]
6973 pub request_id: RequestId,
6974 #[serde(rename = "threadId", default)]
6975 pub thread_id: String,
6976}
6977
6978#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6979#[serde(rename_all = "camelCase")]
6980pub struct SessionMigration {
6981 #[serde(default)]
6982 pub cwd: String,
6983 #[serde(default)]
6984 pub path: String,
6985 #[serde(default, skip_serializing_if = "Option::is_none")]
6986 pub title: Option<String>,
6987}
6988
6989#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6990pub enum SessionSource {
6991 #[serde(rename = "cli")]
6992 Cli,
6993 #[serde(rename = "vscode")]
6994 Vscode,
6995 #[serde(rename = "exec")]
6996 Exec,
6997 #[serde(rename = "appServer")]
6998 AppServer,
6999 #[serde(rename = "unknown")]
7000 Unknown,
7001 #[serde(rename = "custom")]
7002 Custom(String),
7003 #[serde(rename = "subAgent")]
7004 SubAgent(SubAgentSource),
7005}
7006
7007#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7008#[serde(rename_all = "camelCase")]
7009pub struct Settings {
7010 #[serde(default, skip_serializing_if = "Option::is_none")]
7011 pub developer_instructions: Option<String>,
7012 #[serde(default)]
7013 pub model: String,
7014 #[serde(default, skip_serializing_if = "Option::is_none")]
7015 pub reasoning_effort: Option<ReasoningEffort>,
7016}
7017
7018#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7019#[serde(rename_all = "camelCase")]
7020pub struct SkillDependencies {
7021 #[serde(default)]
7022 pub tools: Vec<SkillToolDependency>,
7023}
7024
7025#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7026#[serde(rename_all = "camelCase")]
7027pub struct SkillErrorInfo {
7028 #[serde(default)]
7029 pub message: String,
7030 #[serde(default)]
7031 pub path: String,
7032}
7033
7034#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7035#[serde(rename_all = "camelCase")]
7036pub struct SkillInterface {
7037 #[serde(
7038 rename = "brandColor",
7039 default,
7040 skip_serializing_if = "Option::is_none"
7041 )]
7042 pub brand_color: Option<String>,
7043 #[serde(
7044 rename = "defaultPrompt",
7045 default,
7046 skip_serializing_if = "Option::is_none"
7047 )]
7048 pub default_prompt: Option<String>,
7049 #[serde(
7050 rename = "displayName",
7051 default,
7052 skip_serializing_if = "Option::is_none"
7053 )]
7054 pub display_name: Option<String>,
7055 #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
7056 pub icon_large: Option<AbsolutePathBuf>,
7057 #[serde(
7058 rename = "iconLargeUrl",
7059 default,
7060 skip_serializing_if = "Option::is_none"
7061 )]
7062 pub icon_large_url: Option<String>,
7063 #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
7064 pub icon_small: Option<AbsolutePathBuf>,
7065 #[serde(
7066 rename = "iconSmallUrl",
7067 default,
7068 skip_serializing_if = "Option::is_none"
7069 )]
7070 pub icon_small_url: Option<String>,
7071 #[serde(
7072 rename = "shortDescription",
7073 default,
7074 skip_serializing_if = "Option::is_none"
7075 )]
7076 pub short_description: Option<String>,
7077}
7078
7079#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7080#[serde(rename_all = "camelCase")]
7081pub struct SkillMetadata {
7082 #[serde(default, skip_serializing_if = "Option::is_none")]
7083 pub dependencies: Option<SkillDependencies>,
7084 #[serde(default)]
7085 pub description: String,
7086 #[serde(default)]
7087 pub enabled: bool,
7088 #[serde(default, skip_serializing_if = "Option::is_none")]
7089 pub interface: Option<SkillInterface>,
7090 #[serde(default)]
7091 pub name: String,
7092 #[serde()]
7093 pub path: LegacyAppPathString,
7094 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7095 pub plugin_id: Option<String>,
7096 #[serde()]
7097 pub scope: SkillScope,
7098 #[serde(
7099 rename = "shortDescription",
7100 default,
7101 skip_serializing_if = "Option::is_none"
7102 )]
7103 pub short_description: Option<String>,
7104}
7105
7106#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7107#[serde(rename_all = "camelCase")]
7108pub struct SkillMigration {
7109 #[serde(default)]
7110 pub name: String,
7111}
7112
7113#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7114pub enum SkillScope {
7115 #[serde(rename = "user")]
7116 User,
7117 #[serde(rename = "repo")]
7118 Repo,
7119 #[serde(rename = "system")]
7120 System,
7121 #[serde(rename = "admin")]
7122 Admin,
7123}
7124
7125#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7126#[serde(rename_all = "camelCase")]
7127pub struct SkillSummary {
7128 #[serde(default)]
7129 pub description: String,
7130 #[serde(default)]
7131 pub enabled: bool,
7132 #[serde(default, skip_serializing_if = "Option::is_none")]
7133 pub interface: Option<SkillInterface>,
7134 #[serde(default)]
7135 pub name: String,
7136 #[serde(default, skip_serializing_if = "Option::is_none")]
7137 pub path: Option<LegacyAppPathString>,
7138 #[serde(
7139 rename = "shortDescription",
7140 default,
7141 skip_serializing_if = "Option::is_none"
7142 )]
7143 pub short_description: Option<String>,
7144}
7145
7146#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7147#[serde(rename_all = "camelCase")]
7148pub struct SkillToolDependency {
7149 #[serde(default, skip_serializing_if = "Option::is_none")]
7150 pub command: Option<String>,
7151 #[serde(default, skip_serializing_if = "Option::is_none")]
7152 pub description: Option<String>,
7153 #[serde(default, skip_serializing_if = "Option::is_none")]
7154 pub transport: Option<String>,
7155 #[serde(rename = "type", default)]
7156 pub type_: String,
7157 #[serde(default, skip_serializing_if = "Option::is_none")]
7158 pub url: Option<String>,
7159 #[serde(default)]
7160 pub value: String,
7161}
7162
7163#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7164#[serde(rename_all = "camelCase")]
7165pub struct SkillsChangedNotification {
7166 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7167 pub extra: serde_json::Map<String, Value>,
7168}
7169
7170#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7171#[serde(rename_all = "camelCase")]
7172pub struct SkillsConfigWriteParams {
7173 #[serde(default)]
7174 pub enabled: bool,
7175 #[serde(default, skip_serializing_if = "Option::is_none")]
7176 pub name: Option<String>,
7177 #[serde(default, skip_serializing_if = "Option::is_none")]
7178 pub path: Option<AbsolutePathBuf>,
7179}
7180
7181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7182#[serde(rename_all = "camelCase")]
7183pub struct SkillsConfigWriteResponse {
7184 #[serde(rename = "effectiveEnabled", default)]
7185 pub effective_enabled: bool,
7186}
7187
7188#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7189#[serde(rename_all = "camelCase")]
7190pub struct SkillsExtraRootsSetParams {
7191 #[serde(rename = "extraRoots", default)]
7192 pub extra_roots: Vec<AbsolutePathBuf>,
7193}
7194
7195#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7196#[serde(rename_all = "camelCase")]
7197pub struct SkillsExtraRootsSetResponse {
7198 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7199 pub extra: serde_json::Map<String, Value>,
7200}
7201
7202#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7203#[serde(rename_all = "camelCase")]
7204pub struct SkillsListEntry {
7205 #[serde(default)]
7206 pub cwd: String,
7207 #[serde(default)]
7208 pub errors: Vec<SkillErrorInfo>,
7209 #[serde(default)]
7210 pub skills: Vec<SkillMetadata>,
7211}
7212
7213#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7214#[serde(rename_all = "camelCase")]
7215pub struct SkillsListParams {
7216 #[serde(default, skip_serializing_if = "Option::is_none")]
7217 pub cwds: Option<Vec<String>>,
7218 #[serde(
7219 rename = "forceReload",
7220 default,
7221 skip_serializing_if = "Option::is_none"
7222 )]
7223 pub force_reload: Option<bool>,
7224}
7225
7226#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7227#[serde(rename_all = "camelCase")]
7228pub struct SkillsListResponse {
7229 #[serde(default)]
7230 pub data: Vec<SkillsListEntry>,
7231}
7232
7233#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7234pub enum SortDirection {
7235 #[serde(rename = "asc")]
7236 Asc,
7237 #[serde(rename = "desc")]
7238 Desc,
7239}
7240
7241#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7242#[serde(rename_all = "camelCase")]
7243pub struct SpendControlLimitSnapshot {
7244 #[serde(default)]
7245 pub limit: String,
7246 #[serde(rename = "remainingPercent", default)]
7247 pub remaining_percent: i64,
7248 #[serde(rename = "resetsAt", default)]
7249 pub resets_at: i64,
7250 #[serde(default)]
7251 pub used: String,
7252}
7253
7254#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7255pub enum SubAgentActivityKind {
7256 #[serde(rename = "started")]
7257 Started,
7258 #[serde(rename = "interacted")]
7259 Interacted,
7260 #[serde(rename = "interrupted")]
7261 Interrupted,
7262 #[serde(rename = "completed")]
7263 Completed,
7264}
7265
7266#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7267pub enum SubAgentSource {
7268 #[serde(rename = "review")]
7269 Review,
7270 #[serde(rename = "compact")]
7271 Compact,
7272 #[serde(rename = "memory_consolidation")]
7273 MemoryConsolidation,
7274 #[serde(rename = "thread_spawn")]
7275 ThreadSpawn {
7276 #[serde(default, skip_serializing_if = "Option::is_none")]
7277 agent_nickname: Option<String>,
7278 #[serde(default, skip_serializing_if = "Option::is_none")]
7279 agent_path: Option<AgentPath>,
7280 #[serde(default, skip_serializing_if = "Option::is_none")]
7281 agent_role: Option<String>,
7282 depth: i64,
7283 parent_thread_id: ThreadId,
7284 },
7285 #[serde(rename = "other")]
7286 Other(String),
7287}
7288
7289#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7290#[serde(rename_all = "camelCase")]
7291pub struct SubagentMigration {
7292 #[serde(default)]
7293 pub name: String,
7294}
7295
7296#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7297#[serde(rename_all = "camelCase")]
7298pub struct TerminalInteractionNotification {
7299 #[serde(rename = "itemId", default)]
7300 pub item_id: String,
7301 #[serde(rename = "processId", default)]
7302 pub process_id: String,
7303 #[serde(default)]
7304 pub stdin: String,
7305 #[serde(rename = "threadId", default)]
7306 pub thread_id: String,
7307 #[serde(rename = "turnId", default)]
7308 pub turn_id: String,
7309}
7310
7311#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7312#[serde(rename_all = "camelCase")]
7313pub struct TextElement {
7314 #[serde(rename = "byteRange", default)]
7315 pub byte_range: Value,
7316 #[serde(default, skip_serializing_if = "Option::is_none")]
7317 pub placeholder: Option<String>,
7318}
7319
7320#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7321#[serde(rename_all = "camelCase")]
7322pub struct TextPosition {
7323 #[serde(default)]
7324 pub column: i64,
7325 #[serde(default)]
7326 pub line: i64,
7327}
7328
7329#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7330#[serde(rename_all = "camelCase")]
7331pub struct TextRange {
7332 #[serde()]
7333 pub end: TextPosition,
7334 #[serde()]
7335 pub start: TextPosition,
7336}
7337
7338#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7339#[serde(rename_all = "camelCase")]
7340pub struct Thread {
7341 #[serde(
7342 rename = "agentNickname",
7343 default,
7344 skip_serializing_if = "Option::is_none"
7345 )]
7346 pub agent_nickname: Option<String>,
7347 #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
7348 pub agent_role: Option<String>,
7349 #[serde(rename = "cliVersion", default)]
7350 pub cli_version: String,
7351 #[serde(rename = "createdAt", default)]
7352 pub created_at: i64,
7353 #[serde(default)]
7354 pub cwd: Value,
7355 #[serde(default)]
7356 pub ephemeral: bool,
7357 #[serde(
7358 rename = "forkedFromId",
7359 default,
7360 skip_serializing_if = "Option::is_none"
7361 )]
7362 pub forked_from_id: Option<String>,
7363 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
7364 pub git_info: Option<GitInfo>,
7365 #[serde(
7368 rename = "historyMode",
7369 default,
7370 skip_serializing_if = "Option::is_none"
7371 )]
7372 pub history_mode: Option<ThreadHistoryMode>,
7373 #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
7376 pub project_id: Option<String>,
7377 #[serde(default)]
7378 pub id: String,
7379 #[serde(default, skip_serializing_if = "Option::is_none")]
7382 pub model: Option<String>,
7383 #[serde(rename = "modelProvider", default)]
7384 pub model_provider: String,
7385 #[serde(default, skip_serializing_if = "Option::is_none")]
7386 pub name: Option<String>,
7387 #[serde(default, skip_serializing_if = "Option::is_none")]
7391 pub originator: Option<String>,
7392 #[serde(
7393 rename = "parentThreadId",
7394 default,
7395 skip_serializing_if = "Option::is_none"
7396 )]
7397 pub parent_thread_id: Option<String>,
7398 #[serde(default, skip_serializing_if = "Option::is_none")]
7399 pub path: Option<String>,
7400 #[serde(default)]
7401 pub preview: String,
7402 #[serde(
7406 rename = "reasoningEffort",
7407 default,
7408 skip_serializing_if = "Option::is_none"
7409 )]
7410 pub reasoning_effort: Option<ReasoningEffort>,
7411 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7412 pub recency_at: Option<i64>,
7413 #[serde(default, skip_serializing_if = "Option::is_none")]
7414 pub section: Option<ThreadSection>,
7415 #[serde(
7416 rename = "sectionEnteredAt",
7417 default,
7418 skip_serializing_if = "Option::is_none"
7419 )]
7420 pub section_entered_at: Option<i64>,
7421 #[serde(rename = "sessionId", default)]
7422 pub session_id: String,
7423 #[serde(default)]
7424 pub source: Value,
7425 #[serde(default)]
7426 pub status: Value,
7427 #[serde(
7428 rename = "threadSource",
7429 default,
7430 skip_serializing_if = "Option::is_none"
7431 )]
7432 pub thread_source: Option<ThreadSource>,
7433 #[serde(default)]
7434 pub turns: Vec<Turn>,
7435 #[serde(rename = "updatedAt", default)]
7436 pub updated_at: i64,
7437}
7438
7439#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7440pub enum ThreadActiveFlag {
7441 #[serde(rename = "waitingOnApproval")]
7442 WaitingOnApproval,
7443 #[serde(rename = "waitingOnUserInput")]
7444 WaitingOnUserInput,
7445}
7446
7447#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7448#[serde(rename_all = "camelCase")]
7449pub struct ThreadApproveGuardianDeniedActionParams {
7450 #[serde(default)]
7451 pub event: Value,
7452 #[serde(rename = "threadId", default)]
7453 pub thread_id: String,
7454}
7455
7456#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7457#[serde(rename_all = "camelCase")]
7458pub struct ThreadApproveGuardianDeniedActionResponse {
7459 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7460 pub extra: serde_json::Map<String, Value>,
7461}
7462
7463#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7464#[serde(rename_all = "camelCase")]
7465pub struct ThreadArchiveParams {
7466 #[serde(rename = "threadId", default)]
7467 pub thread_id: String,
7468}
7469
7470#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7471#[serde(rename_all = "camelCase")]
7472pub struct ThreadArchiveResponse {
7473 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7474 pub extra: serde_json::Map<String, Value>,
7475}
7476
7477#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7478#[serde(rename_all = "camelCase")]
7479pub struct ThreadArchivedNotification {
7480 #[serde(rename = "threadId", default)]
7481 pub thread_id: String,
7482}
7483
7484#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7486#[serde(rename_all = "camelCase")]
7487pub struct ThreadAttachment {
7488 #[serde(rename = "attachmentType", default)]
7489 pub attachment_type: String,
7490 #[serde(rename = "createdAt", default)]
7491 pub created_at: i64,
7492 #[serde(default)]
7493 pub id: String,
7494 #[serde(rename = "identityKey", default)]
7495 pub identity_key: String,
7496 #[serde(default)]
7497 pub payload: Value,
7498}
7499
7500#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7502pub enum ThreadAttachmentAddOutcome {
7503 #[serde(rename = "created")]
7504 Created,
7505 #[serde(rename = "existing")]
7506 Existing,
7507}
7508
7509#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7511#[serde(rename_all = "camelCase")]
7512pub struct ThreadAttachmentAddParams {
7513 #[serde(rename = "attachmentType", default)]
7514 pub attachment_type: String,
7515 #[serde(rename = "identityKey", default)]
7516 pub identity_key: String,
7517 #[serde(default)]
7518 pub payload: Value,
7519 #[serde(rename = "threadId", default)]
7520 pub thread_id: String,
7521}
7522
7523#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7525#[serde(rename_all = "camelCase")]
7526pub struct ThreadAttachmentAddResponse {
7527 pub attachment: ThreadAttachment,
7528 pub outcome: ThreadAttachmentAddOutcome,
7529}
7530
7531#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7533#[serde(rename_all = "camelCase")]
7534pub struct ThreadAttachmentListParams {
7535 #[serde(default, skip_serializing_if = "Option::is_none")]
7536 pub cursor: Option<String>,
7537 #[serde(default, skip_serializing_if = "Option::is_none")]
7538 pub limit: Option<i64>,
7539 #[serde(rename = "threadId", default)]
7540 pub thread_id: String,
7541}
7542
7543#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7545#[serde(rename_all = "camelCase")]
7546pub struct ThreadAttachmentListResponse {
7547 #[serde(default)]
7548 pub data: Vec<ThreadAttachment>,
7549 #[serde(
7550 rename = "nextCursor",
7551 default,
7552 skip_serializing_if = "Option::is_none"
7553 )]
7554 pub next_cursor: Option<String>,
7555}
7556
7557#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7559pub enum ThreadAttachmentOperation {
7560 #[serde(rename = "created")]
7561 Created,
7562 #[serde(rename = "deleted")]
7563 Deleted,
7564}
7565
7566#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7568#[serde(rename_all = "camelCase")]
7569pub struct ThreadAttachmentOwner {
7570 #[serde(default)]
7572 pub archived: bool,
7573 #[serde(rename = "threadId", default)]
7574 pub thread_id: String,
7575}
7576
7577#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7579#[serde(rename_all = "camelCase")]
7580pub struct ThreadAttachmentOwnerListParams {
7581 #[serde(default, skip_serializing_if = "Option::is_none")]
7583 pub archived: Option<bool>,
7584 #[serde(rename = "attachmentType", default)]
7585 pub attachment_type: String,
7586 #[serde(default, skip_serializing_if = "Option::is_none")]
7587 pub cursor: Option<String>,
7588 #[serde(rename = "identityKey", default)]
7589 pub identity_key: String,
7590 #[serde(default, skip_serializing_if = "Option::is_none")]
7591 pub limit: Option<i64>,
7592}
7593
7594#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7596#[serde(rename_all = "camelCase")]
7597pub struct ThreadAttachmentOwnerListResponse {
7598 #[serde(default)]
7599 pub data: Vec<ThreadAttachmentOwner>,
7600 #[serde(
7601 rename = "nextCursor",
7602 default,
7603 skip_serializing_if = "Option::is_none"
7604 )]
7605 pub next_cursor: Option<String>,
7606}
7607
7608#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7610#[serde(rename_all = "camelCase")]
7611pub struct ThreadAttachmentRemoveParams {
7612 #[serde(rename = "attachmentType", default)]
7613 pub attachment_type: String,
7614 #[serde(rename = "identityKey", default)]
7615 pub identity_key: String,
7616 #[serde(rename = "threadId", default)]
7617 pub thread_id: String,
7618}
7619
7620#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7622#[serde(rename_all = "camelCase")]
7623pub struct ThreadAttachmentRemoveResponse {
7624 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7625 pub extra: serde_json::Map<String, Value>,
7626}
7627
7628#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7630#[serde(rename_all = "camelCase")]
7631pub struct ThreadAttachmentUpdatedNotification {
7632 #[serde(rename = "attachmentId", default)]
7633 pub attachment_id: String,
7634 #[serde(rename = "attachmentType", default)]
7635 pub attachment_type: String,
7636 #[serde(rename = "identityKey", default)]
7637 pub identity_key: String,
7638 pub operation: ThreadAttachmentOperation,
7639 #[serde(rename = "threadId", default)]
7640 pub thread_id: String,
7641}
7642
7643#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7644#[serde(rename_all = "camelCase")]
7645pub struct ThreadClosedNotification {
7646 #[serde(rename = "threadId", default)]
7647 pub thread_id: String,
7648}
7649
7650#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7651#[serde(rename_all = "camelCase")]
7652pub struct ThreadCompactStartParams {
7653 #[serde(rename = "threadId", default)]
7654 pub thread_id: String,
7655}
7656
7657#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7658#[serde(rename_all = "camelCase")]
7659pub struct ThreadCompactStartResponse {
7660 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7661 pub extra: serde_json::Map<String, Value>,
7662}
7663
7664#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7665#[serde(rename_all = "camelCase")]
7666pub struct ThreadDeleteParams {
7667 #[serde(rename = "threadId", default)]
7668 pub thread_id: String,
7669}
7670
7671#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7672#[serde(rename_all = "camelCase")]
7673pub struct ThreadDeleteResponse {
7674 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7675 pub extra: serde_json::Map<String, Value>,
7676}
7677
7678#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7679#[serde(rename_all = "camelCase")]
7680pub struct ThreadDeletedNotification {
7681 #[serde(rename = "threadId", default)]
7682 pub thread_id: String,
7683}
7684
7685#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7686#[serde(rename_all = "camelCase")]
7687pub struct ThreadForkParams {
7688 #[serde(
7689 rename = "approvalPolicy",
7690 default,
7691 skip_serializing_if = "Option::is_none"
7692 )]
7693 pub approval_policy: Option<AskForApproval>,
7694 #[serde(
7695 rename = "approvalsReviewer",
7696 default,
7697 skip_serializing_if = "Option::is_none"
7698 )]
7699 pub approvals_reviewer: Option<ApprovalsReviewer>,
7700 #[serde(
7701 rename = "baseInstructions",
7702 default,
7703 skip_serializing_if = "Option::is_none"
7704 )]
7705 pub base_instructions: Option<String>,
7706 #[serde(default, skip_serializing_if = "Option::is_none")]
7707 pub config: Option<Value>,
7708 #[serde(default, skip_serializing_if = "Option::is_none")]
7709 pub cwd: Option<String>,
7710 #[serde(
7711 rename = "developerInstructions",
7712 default,
7713 skip_serializing_if = "Option::is_none"
7714 )]
7715 pub developer_instructions: Option<String>,
7716 #[serde(default, skip_serializing_if = "Option::is_none")]
7717 pub ephemeral: Option<bool>,
7718 #[serde(
7719 rename = "excludeTurns",
7720 default,
7721 skip_serializing_if = "Option::is_none"
7722 )]
7723 pub exclude_turns: Option<bool>,
7724 #[serde(
7725 rename = "lastTurnId",
7726 default,
7727 skip_serializing_if = "Option::is_none"
7728 )]
7729 pub last_turn_id: Option<String>,
7730 #[serde(default, skip_serializing_if = "Option::is_none")]
7731 pub model: Option<String>,
7732 #[serde(
7733 rename = "modelProvider",
7734 default,
7735 skip_serializing_if = "Option::is_none"
7736 )]
7737 pub model_provider: Option<String>,
7738 #[serde(default, skip_serializing_if = "Option::is_none")]
7739 pub sandbox: Option<SandboxMode>,
7740 #[serde(
7741 rename = "serviceTier",
7742 default,
7743 skip_serializing_if = "Option::is_none"
7744 )]
7745 pub service_tier: Option<String>,
7746 #[serde(rename = "threadId", default)]
7747 pub thread_id: String,
7748 #[serde(
7749 rename = "threadSource",
7750 default,
7751 skip_serializing_if = "Option::is_none"
7752 )]
7753 pub thread_source: Option<ThreadSource>,
7754}
7755
7756#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7757#[serde(rename_all = "camelCase")]
7758pub struct ThreadForkResponse {
7759 #[serde(rename = "approvalPolicy")]
7760 pub approval_policy: AskForApproval,
7761 #[serde(rename = "approvalsReviewer", default)]
7762 pub approvals_reviewer: Value,
7763 #[serde()]
7764 pub cwd: AbsolutePathBuf,
7765 #[serde(rename = "disabledPluginIds", default)]
7768 pub disabled_plugin_ids: Vec<String>,
7769 #[serde(
7770 rename = "instructionSources",
7771 default,
7772 skip_serializing_if = "Option::is_none"
7773 )]
7774 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
7775 #[serde(default)]
7776 pub model: String,
7777 #[serde(rename = "modelProvider", default)]
7778 pub model_provider: String,
7779 #[serde(
7780 rename = "reasoningEffort",
7781 default,
7782 skip_serializing_if = "Option::is_none"
7783 )]
7784 pub reasoning_effort: Option<ReasoningEffort>,
7785 #[serde(default)]
7786 pub sandbox: Value,
7787 #[serde(
7788 rename = "serviceTier",
7789 default,
7790 skip_serializing_if = "Option::is_none"
7791 )]
7792 pub service_tier: Option<String>,
7793 #[serde()]
7794 pub thread: Thread,
7795}
7796
7797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7798#[serde(rename_all = "camelCase")]
7799pub struct ThreadGoal {
7800 #[serde(rename = "createdAt", default)]
7801 pub created_at: i64,
7802 #[serde(default)]
7803 pub objective: String,
7804 #[serde()]
7805 pub status: ThreadGoalStatus,
7806 #[serde(rename = "threadId", default)]
7807 pub thread_id: String,
7808 #[serde(rename = "timeUsedSeconds", default)]
7809 pub time_used_seconds: i64,
7810 #[serde(
7811 rename = "tokenBudget",
7812 default,
7813 skip_serializing_if = "Option::is_none"
7814 )]
7815 pub token_budget: Option<i64>,
7816 #[serde(rename = "tokensUsed", default)]
7817 pub tokens_used: i64,
7818 #[serde(rename = "updatedAt", default)]
7819 pub updated_at: i64,
7820}
7821
7822#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7823#[serde(rename_all = "camelCase")]
7824pub struct ThreadGoalClearParams {
7825 #[serde(default, skip_serializing_if = "Option::is_none")]
7827 pub origin: Option<ThreadGoalMutationOrigin>,
7828 #[serde(rename = "threadId", default)]
7829 pub thread_id: String,
7830}
7831
7832#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7833#[serde(rename_all = "camelCase")]
7834pub struct ThreadGoalClearResponse {
7835 #[serde(default)]
7836 pub cleared: bool,
7837}
7838
7839#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7840#[serde(rename_all = "camelCase")]
7841pub struct ThreadGoalClearedNotification {
7842 #[serde(rename = "threadId", default)]
7843 pub thread_id: String,
7844}
7845
7846#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7847#[serde(rename_all = "camelCase")]
7848pub struct ThreadGoalGetParams {
7849 #[serde(rename = "threadId", default)]
7850 pub thread_id: String,
7851}
7852
7853#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7854#[serde(rename_all = "camelCase")]
7855pub struct ThreadGoalGetResponse {
7856 #[serde(default, skip_serializing_if = "Option::is_none")]
7857 pub goal: Option<ThreadGoal>,
7858}
7859
7860#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7862pub enum ThreadGoalMutationOrigin {
7863 #[serde(rename = "user")]
7864 User,
7865 #[serde(rename = "automatic")]
7866 Automatic,
7867}
7868
7869#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7870#[serde(rename_all = "camelCase")]
7871pub struct ThreadGoalSetParams {
7872 #[serde(default, skip_serializing_if = "Option::is_none")]
7873 pub objective: Option<String>,
7874 #[serde(default, skip_serializing_if = "Option::is_none")]
7876 pub origin: Option<ThreadGoalMutationOrigin>,
7877 #[serde(default, skip_serializing_if = "Option::is_none")]
7878 pub status: Option<ThreadGoalStatus>,
7879 #[serde(rename = "threadId", default)]
7880 pub thread_id: String,
7881 #[serde(
7882 rename = "tokenBudget",
7883 default,
7884 skip_serializing_if = "Option::is_none"
7885 )]
7886 pub token_budget: Option<i64>,
7887}
7888
7889#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7890#[serde(rename_all = "camelCase")]
7891pub struct ThreadGoalSetResponse {
7892 #[serde()]
7893 pub goal: ThreadGoal,
7894}
7895
7896#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7897pub enum ThreadGoalStatus {
7898 #[serde(rename = "active")]
7899 Active,
7900 #[serde(rename = "paused")]
7901 Paused,
7902 #[serde(rename = "blocked")]
7903 Blocked,
7904 #[serde(rename = "usageLimited")]
7905 UsageLimited,
7906 #[serde(rename = "budgetLimited")]
7907 BudgetLimited,
7908 #[serde(rename = "complete")]
7909 Complete,
7910}
7911
7912#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7913#[serde(rename_all = "camelCase")]
7914pub struct ThreadGoalUpdatedNotification {
7915 #[serde()]
7916 pub goal: ThreadGoal,
7917 #[serde(rename = "threadId", default)]
7918 pub thread_id: String,
7919 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
7920 pub turn_id: Option<String>,
7921}
7922
7923#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
7924#[serde(transparent)]
7925pub struct ThreadId(pub String);
7926
7927#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7928#[serde(rename_all = "camelCase")]
7929pub struct ThreadInjectItemsParams {
7930 #[serde(default)]
7931 pub items: Vec<Value>,
7932 #[serde(rename = "threadId", default)]
7933 pub thread_id: String,
7934}
7935
7936#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7937#[serde(rename_all = "camelCase")]
7938pub struct ThreadInjectItemsResponse {
7939 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7940 pub extra: serde_json::Map<String, Value>,
7941}
7942
7943#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7944#[serde(tag = "type", rename_all = "camelCase")]
7945pub enum ThreadItem {
7946 #[serde(rename = "userMessage")]
7947 UserMessage {
7948 #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
7949 client_id: Option<String>,
7950 content: Vec<UserInput>,
7951 id: String,
7952 },
7953 #[serde(rename = "hookPrompt")]
7954 HookPrompt {
7955 fragments: Vec<HookPromptFragment>,
7956 id: String,
7957 },
7958 #[serde(rename = "agentMessage")]
7959 AgentMessage {
7960 #[serde(default, skip_serializing_if = "Option::is_none")]
7961 delivery: Option<AgentMessageDelivery>,
7962 id: String,
7963 #[serde(
7964 rename = "memoryCitation",
7965 default,
7966 skip_serializing_if = "Option::is_none"
7967 )]
7968 memory_citation: Option<MemoryCitation>,
7969 #[serde(default, skip_serializing_if = "Option::is_none")]
7970 phase: Option<MessagePhase>,
7971 #[serde(default, skip_serializing_if = "Option::is_none")]
7972 questions: Option<Vec<AsyncUserInputQuestion>>,
7973 text: String,
7974 },
7975 Plan {
7976 id: String,
7977 text: String,
7978 },
7979 Reasoning {
7980 #[serde(default, skip_serializing_if = "Option::is_none")]
7981 content: Option<Vec<String>>,
7982 id: String,
7983 #[serde(default, skip_serializing_if = "Option::is_none")]
7984 summary: Option<Vec<String>>,
7985 },
7986 #[serde(rename = "commandExecution")]
7987 CommandExecution {
7988 #[serde(
7989 rename = "aggregatedOutput",
7990 default,
7991 skip_serializing_if = "Option::is_none"
7992 )]
7993 aggregated_output: Option<String>,
7994 command: String,
7995 #[serde(rename = "commandActions")]
7996 command_actions: Vec<CommandAction>,
7997 cwd: Value,
7998 #[serde(
7999 rename = "durationMs",
8000 default,
8001 skip_serializing_if = "Option::is_none"
8002 )]
8003 duration_ms: Option<i64>,
8004 #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
8005 exit_code: Option<i64>,
8006 id: String,
8007 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8008 plugin_id: Option<String>,
8009 #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
8010 process_id: Option<String>,
8011 #[serde(
8012 rename = "scriptPath",
8013 default,
8014 skip_serializing_if = "Option::is_none"
8015 )]
8016 script_path: Option<String>,
8017 #[serde(default, skip_serializing_if = "Option::is_none")]
8018 source: Option<Value>,
8019 status: CommandExecutionStatus,
8020 },
8021 #[serde(rename = "fileChange")]
8022 FileChange {
8023 changes: Vec<FileUpdateChange>,
8024 id: String,
8025 status: PatchApplyStatus,
8026 },
8027 #[serde(rename = "mcpToolCall")]
8028 McpToolCall {
8029 #[serde(
8030 rename = "appContext",
8031 default,
8032 skip_serializing_if = "Option::is_none"
8033 )]
8034 app_context: Option<McpToolCallAppContext>,
8035 arguments: Value,
8036 #[serde(
8037 rename = "durationMs",
8038 default,
8039 skip_serializing_if = "Option::is_none"
8040 )]
8041 duration_ms: Option<i64>,
8042 #[serde(default, skip_serializing_if = "Option::is_none")]
8043 error: Option<McpToolCallError>,
8044 id: String,
8045 #[serde(
8048 rename = "mcpAppResourceUri",
8049 default,
8050 skip_serializing_if = "Option::is_none"
8051 )]
8052 mcp_app_resource_uri: Option<String>,
8053 #[serde(rename = "mcpAppUi", default, skip_serializing_if = "Option::is_none")]
8056 mcp_app_ui: Option<McpAppUi>,
8057 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8058 plugin_id: Option<String>,
8059 #[serde(
8060 rename = "readOnlyHint",
8061 default,
8062 skip_serializing_if = "Option::is_none"
8063 )]
8064 read_only_hint: Option<bool>,
8065 #[serde(default, skip_serializing_if = "Option::is_none")]
8066 result: Option<McpToolCallResult>,
8067 server: String,
8068 status: McpToolCallStatus,
8069 tool: String,
8070 },
8071 #[serde(rename = "dynamicToolCall")]
8072 DynamicToolCall {
8073 arguments: Value,
8074 #[serde(
8075 rename = "contentItems",
8076 default,
8077 skip_serializing_if = "Option::is_none"
8078 )]
8079 content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
8080 #[serde(
8081 rename = "durationMs",
8082 default,
8083 skip_serializing_if = "Option::is_none"
8084 )]
8085 duration_ms: Option<i64>,
8086 id: String,
8087 #[serde(default, skip_serializing_if = "Option::is_none")]
8088 namespace: Option<String>,
8089 status: DynamicToolCallStatus,
8090 #[serde(default, skip_serializing_if = "Option::is_none")]
8091 success: Option<bool>,
8092 tool: String,
8093 },
8094 #[serde(rename = "collabAgentToolCall")]
8095 CollabAgentToolCall {
8096 #[serde(rename = "agentsStates")]
8097 agents_states: std::collections::BTreeMap<String, CollabAgentState>,
8098 id: String,
8099 #[serde(default, skip_serializing_if = "Option::is_none")]
8100 model: Option<String>,
8101 #[serde(default, skip_serializing_if = "Option::is_none")]
8102 prompt: Option<String>,
8103 #[serde(
8104 rename = "reasoningEffort",
8105 default,
8106 skip_serializing_if = "Option::is_none"
8107 )]
8108 reasoning_effort: Option<ReasoningEffort>,
8109 #[serde(rename = "receiverThreadIds")]
8110 receiver_thread_ids: Vec<String>,
8111 #[serde(rename = "senderThreadId")]
8112 sender_thread_id: String,
8113 status: Value,
8114 tool: Value,
8115 },
8116 #[serde(rename = "subAgentActivity")]
8117 SubAgentActivity {
8118 #[serde(rename = "agentPath")]
8119 agent_path: String,
8120 #[serde(rename = "agentThreadId")]
8121 agent_thread_id: String,
8122 id: String,
8123 kind: SubAgentActivityKind,
8124 #[serde(default, skip_serializing_if = "Option::is_none")]
8127 model: Option<String>,
8128 #[serde(
8130 rename = "reasoningEffort",
8131 default,
8132 skip_serializing_if = "Option::is_none"
8133 )]
8134 reasoning_effort: Option<ReasoningEffort>,
8135 },
8136 #[serde(rename = "webSearch")]
8137 WebSearch {
8138 #[serde(default, skip_serializing_if = "Option::is_none")]
8139 action: Option<WebSearchAction>,
8140 id: String,
8141 query: String,
8142 #[serde(default, skip_serializing_if = "Option::is_none")]
8143 results: Option<Vec<Value>>,
8144 },
8145 #[serde(rename = "imageView")]
8146 ImageView {
8147 id: String,
8148 path: LegacyAppPathString,
8149 },
8150 Sleep {
8151 #[serde(rename = "durationMs")]
8152 duration_ms: i64,
8153 id: String,
8154 },
8155 #[serde(rename = "imageGeneration")]
8156 ImageGeneration {
8157 #[serde(default, skip_serializing_if = "Option::is_none")]
8158 failure: Option<ImageGenerationFailure>,
8159 id: String,
8160 #[serde(flatten)]
8161 image: GeneratedImageRef,
8162 #[serde(
8164 rename = "inputImages",
8165 default,
8166 skip_serializing_if = "Option::is_none"
8167 )]
8168 input_images: Option<Vec<ImageGenerationInputImage>>,
8169 #[serde(
8170 rename = "revisedPrompt",
8171 default,
8172 skip_serializing_if = "Option::is_none"
8173 )]
8174 revised_prompt: Option<String>,
8175 #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
8176 saved_path: Option<AbsolutePathBuf>,
8177 status: String,
8178 #[serde(
8179 rename = "transparentBackground",
8180 default,
8181 skip_serializing_if = "Option::is_none"
8182 )]
8183 transparent_background: Option<bool>,
8184 },
8185 #[serde(rename = "enteredReviewMode")]
8186 EnteredReviewMode {
8187 id: String,
8188 review: String,
8189 },
8190 #[serde(rename = "exitedReviewMode")]
8191 ExitedReviewMode {
8192 id: String,
8193 review: String,
8194 },
8195 #[serde(rename = "contextCompaction")]
8196 ContextCompaction {
8197 id: String,
8198 },
8199 #[serde(rename = "functionCallOutput")]
8200 FunctionCallOutput {
8201 id: String,
8202 name: String,
8203 #[serde(default, skip_serializing_if = "Option::is_none")]
8204 namespace: Option<String>,
8205 output: FunctionCallOutputBody,
8206 },
8207}
8208
8209#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8210#[serde(untagged)]
8211pub enum ThreadListCwdFilter {
8212 Variant0(String),
8213 Variant1(Vec<String>),
8214}
8215
8216#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8217#[serde(rename_all = "camelCase")]
8218pub struct ThreadListParams {
8219 #[serde(default, skip_serializing_if = "Option::is_none")]
8220 pub archived: Option<bool>,
8221 #[serde(default, skip_serializing_if = "Option::is_none")]
8222 pub cursor: Option<String>,
8223 #[serde(default, skip_serializing_if = "Option::is_none")]
8224 pub cwd: Option<ThreadListCwdFilter>,
8225 #[serde(
8230 rename = "excludedThreadIds",
8231 default,
8232 skip_serializing_if = "Option::is_none"
8233 )]
8234 pub excluded_thread_ids: Option<Vec<String>>,
8235 #[serde(default, skip_serializing_if = "Option::is_none")]
8236 pub limit: Option<i64>,
8237 #[serde(
8238 rename = "modelProviders",
8239 default,
8240 skip_serializing_if = "Option::is_none"
8241 )]
8242 pub model_providers: Option<Vec<String>>,
8243 #[serde(default, skip_serializing_if = "Option::is_none")]
8247 pub originators: Option<Vec<String>>,
8248 #[serde(
8249 rename = "searchTerm",
8250 default,
8251 skip_serializing_if = "Option::is_none"
8252 )]
8253 pub search_term: Option<String>,
8254 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8255 pub section_id: Option<String>,
8256 #[serde(
8257 rename = "sortDirection",
8258 default,
8259 skip_serializing_if = "Option::is_none"
8260 )]
8261 pub sort_direction: Option<SortDirection>,
8262 #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
8263 pub sort_key: Option<ThreadSortKey>,
8264 #[serde(
8265 rename = "sourceKinds",
8266 default,
8267 skip_serializing_if = "Option::is_none"
8268 )]
8269 pub source_kinds: Option<Vec<ThreadSourceKind>>,
8270 #[serde(
8271 rename = "useStateDbOnly",
8272 default,
8273 skip_serializing_if = "Option::is_none"
8274 )]
8275 pub use_state_db_only: Option<bool>,
8276}
8277
8278#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8279#[serde(rename_all = "camelCase")]
8280pub struct ThreadListResponse {
8281 #[serde(
8282 rename = "backwardsCursor",
8283 default,
8284 skip_serializing_if = "Option::is_none"
8285 )]
8286 pub backwards_cursor: Option<String>,
8287 #[serde(default)]
8288 pub data: Vec<Thread>,
8289 #[serde(
8290 rename = "nextCursor",
8291 default,
8292 skip_serializing_if = "Option::is_none"
8293 )]
8294 pub next_cursor: Option<String>,
8295}
8296
8297#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8298#[serde(rename_all = "camelCase")]
8299pub struct ThreadLoadedListParams {
8300 #[serde(default, skip_serializing_if = "Option::is_none")]
8301 pub cursor: Option<String>,
8302 #[serde(default, skip_serializing_if = "Option::is_none")]
8303 pub limit: Option<i64>,
8304}
8305
8306#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8307#[serde(rename_all = "camelCase")]
8308pub struct ThreadLoadedListResponse {
8309 #[serde(default)]
8310 pub data: Vec<String>,
8311 #[serde(
8312 rename = "nextCursor",
8313 default,
8314 skip_serializing_if = "Option::is_none"
8315 )]
8316 pub next_cursor: Option<String>,
8317}
8318
8319#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8320#[serde(rename_all = "camelCase")]
8321pub struct ThreadMetadataGitInfoUpdateParams {
8322 #[serde(default, skip_serializing_if = "Option::is_none")]
8323 pub branch: Option<String>,
8324 #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
8325 pub origin_url: Option<String>,
8326 #[serde(default, skip_serializing_if = "Option::is_none")]
8327 pub sha: Option<String>,
8328}
8329
8330#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8331#[serde(rename_all = "camelCase")]
8332pub struct ThreadMetadataUpdateParams {
8333 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
8334 pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
8335 #[serde(rename = "threadId", default)]
8336 pub thread_id: String,
8337}
8338
8339#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8340#[serde(rename_all = "camelCase")]
8341pub struct ThreadMetadataUpdateResponse {
8342 #[serde()]
8343 pub thread: Thread,
8344}
8345
8346#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8347#[serde(rename_all = "camelCase")]
8348pub struct ThreadNameUpdatedNotification {
8349 #[serde(rename = "threadId", default)]
8350 pub thread_id: String,
8351 #[serde(
8352 rename = "threadName",
8353 default,
8354 skip_serializing_if = "Option::is_none"
8355 )]
8356 pub thread_name: Option<String>,
8357}
8358
8359#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8360#[serde(rename_all = "camelCase")]
8361pub struct ThreadReadParams {
8362 #[serde(
8363 rename = "includeTurns",
8364 default,
8365 skip_serializing_if = "Option::is_none"
8366 )]
8367 pub include_turns: Option<bool>,
8368 #[serde(rename = "threadId", default)]
8369 pub thread_id: String,
8370}
8371
8372#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8373#[serde(rename_all = "camelCase")]
8374pub struct ThreadReadResponse {
8375 #[serde()]
8376 pub thread: Thread,
8377}
8378
8379#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8382#[serde(rename_all = "camelCase")]
8383pub struct ThreadReadState {
8384 #[serde(
8385 rename = "firstUnread",
8386 default,
8387 skip_serializing_if = "Option::is_none"
8388 )]
8389 pub first_unread: Option<ThreadUnreadPosition>,
8390 #[serde(default)]
8391 pub revision: String,
8392}
8393
8394#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8395#[serde(rename_all = "camelCase")]
8396pub struct ThreadReadStateChangedNotification {
8397 #[serde(rename = "readState")]
8398 pub read_state: ThreadReadState,
8399 #[serde(rename = "threadId", default)]
8400 pub thread_id: String,
8401}
8402
8403#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8404#[serde(rename_all = "camelCase")]
8405pub struct ThreadRealtimeAudioChunk {
8406 #[serde(default)]
8407 pub data: String,
8408 #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
8409 pub item_id: Option<String>,
8410 #[serde(rename = "numChannels", default)]
8411 pub num_channels: i64,
8412 #[serde(rename = "sampleRate", default)]
8413 pub sample_rate: i64,
8414 #[serde(
8415 rename = "samplesPerChannel",
8416 default,
8417 skip_serializing_if = "Option::is_none"
8418 )]
8419 pub samples_per_channel: Option<i64>,
8420}
8421
8422#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8423#[serde(rename_all = "camelCase")]
8424pub struct ThreadRealtimeClosedNotification {
8425 #[serde(default, skip_serializing_if = "Option::is_none")]
8426 pub reason: Option<String>,
8427 #[serde(rename = "threadId", default)]
8428 pub thread_id: String,
8429}
8430
8431#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8432#[serde(rename_all = "camelCase")]
8433pub struct ThreadRealtimeErrorNotification {
8434 #[serde(default)]
8435 pub message: String,
8436 #[serde(rename = "threadId", default)]
8437 pub thread_id: String,
8438}
8439
8440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8441#[serde(rename_all = "camelCase")]
8442pub struct ThreadRealtimeItemAddedNotification {
8443 #[serde(default)]
8444 pub item: Value,
8445 #[serde(rename = "threadId", default)]
8446 pub thread_id: String,
8447}
8448
8449#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8450#[serde(rename_all = "camelCase")]
8451pub struct ThreadRealtimeOutputAudioDeltaNotification {
8452 #[serde()]
8453 pub audio: ThreadRealtimeAudioChunk,
8454 #[serde(rename = "threadId", default)]
8455 pub thread_id: String,
8456}
8457
8458#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8459#[serde(rename_all = "camelCase")]
8460pub struct ThreadRealtimeSdpNotification {
8461 #[serde(default)]
8462 pub sdp: String,
8463 #[serde(rename = "threadId", default)]
8464 pub thread_id: String,
8465}
8466
8467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8468#[serde(rename_all = "camelCase")]
8469pub struct ThreadRealtimeStartedNotification {
8470 #[serde(
8471 rename = "realtimeSessionId",
8472 default,
8473 skip_serializing_if = "Option::is_none"
8474 )]
8475 pub realtime_session_id: Option<String>,
8476 #[serde(rename = "threadId", default)]
8477 pub thread_id: String,
8478 #[serde()]
8479 pub version: RealtimeConversationVersion,
8480}
8481
8482#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8483#[serde(rename_all = "camelCase")]
8484pub struct ThreadRealtimeTranscriptDeltaNotification {
8485 #[serde(default)]
8486 pub delta: String,
8487 #[serde(default)]
8488 pub role: String,
8489 #[serde(rename = "threadId", default)]
8490 pub thread_id: String,
8491}
8492
8493#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8494#[serde(rename_all = "camelCase")]
8495pub struct ThreadRealtimeTranscriptDoneNotification {
8496 #[serde(default)]
8497 pub role: String,
8498 #[serde(default)]
8499 pub text: String,
8500 #[serde(rename = "threadId", default)]
8501 pub thread_id: String,
8502}
8503
8504#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8505#[serde(rename_all = "camelCase")]
8506pub struct ThreadResumeParams {
8507 #[serde(
8508 rename = "approvalPolicy",
8509 default,
8510 skip_serializing_if = "Option::is_none"
8511 )]
8512 pub approval_policy: Option<AskForApproval>,
8513 #[serde(
8514 rename = "approvalsReviewer",
8515 default,
8516 skip_serializing_if = "Option::is_none"
8517 )]
8518 pub approvals_reviewer: Option<ApprovalsReviewer>,
8519 #[serde(
8520 rename = "baseInstructions",
8521 default,
8522 skip_serializing_if = "Option::is_none"
8523 )]
8524 pub base_instructions: Option<String>,
8525 #[serde(default, skip_serializing_if = "Option::is_none")]
8526 pub config: Option<Value>,
8527 #[serde(default, skip_serializing_if = "Option::is_none")]
8528 pub cwd: Option<String>,
8529 #[serde(
8530 rename = "developerInstructions",
8531 default,
8532 skip_serializing_if = "Option::is_none"
8533 )]
8534 pub developer_instructions: Option<String>,
8535 #[serde(default, skip_serializing_if = "Option::is_none")]
8536 pub model: Option<String>,
8537 #[serde(
8538 rename = "modelProvider",
8539 default,
8540 skip_serializing_if = "Option::is_none"
8541 )]
8542 pub model_provider: Option<String>,
8543 #[serde(default, skip_serializing_if = "Option::is_none")]
8544 pub personality: Option<Personality>,
8545 #[serde(default, skip_serializing_if = "Option::is_none")]
8546 pub sandbox: Option<SandboxMode>,
8547 #[serde(
8548 rename = "serviceTier",
8549 default,
8550 skip_serializing_if = "Option::is_none"
8551 )]
8552 pub service_tier: Option<String>,
8553 #[serde(rename = "threadId", default)]
8554 pub thread_id: String,
8555 #[serde(
8556 rename = "excludeTurns",
8557 default,
8558 skip_serializing_if = "Option::is_none"
8559 )]
8560 pub exclude_turns: Option<bool>,
8561}
8562
8563#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8564#[serde(rename_all = "camelCase")]
8565pub struct ThreadResumeResponse {
8566 #[serde(rename = "approvalPolicy")]
8567 pub approval_policy: AskForApproval,
8568 #[serde(rename = "approvalsReviewer", default)]
8569 pub approvals_reviewer: Value,
8570 #[serde(
8573 rename = "collaborationMode",
8574 default,
8575 skip_serializing_if = "Option::is_none"
8576 )]
8577 pub collaboration_mode: Option<CollaborationMode>,
8578 #[serde()]
8579 pub cwd: AbsolutePathBuf,
8580 #[serde(rename = "disabledPluginIds", default)]
8583 pub disabled_plugin_ids: Vec<String>,
8584 #[serde(
8585 rename = "instructionSources",
8586 default,
8587 skip_serializing_if = "Option::is_none"
8588 )]
8589 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8590 #[serde(
8593 rename = "itemsBackwardsCursor",
8594 default,
8595 skip_serializing_if = "Option::is_none"
8596 )]
8597 pub items_backwards_cursor: Option<String>,
8598 #[serde(default)]
8599 pub model: String,
8600 #[serde(rename = "modelProvider", default)]
8601 pub model_provider: String,
8602 #[serde(
8603 rename = "reasoningEffort",
8604 default,
8605 skip_serializing_if = "Option::is_none"
8606 )]
8607 pub reasoning_effort: Option<ReasoningEffort>,
8608 #[serde(default)]
8609 pub sandbox: Value,
8610 #[serde(
8611 rename = "serviceTier",
8612 default,
8613 skip_serializing_if = "Option::is_none"
8614 )]
8615 pub service_tier: Option<String>,
8616 #[serde()]
8617 pub thread: Thread,
8618 #[serde(
8621 rename = "turnsBackwardsCursor",
8622 default,
8623 skip_serializing_if = "Option::is_none"
8624 )]
8625 pub turns_backwards_cursor: Option<String>,
8626}
8627
8628#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8630pub enum ThreadHistoryMode {
8631 #[serde(rename = "legacy")]
8632 Legacy,
8633 #[serde(rename = "paginated")]
8634 Paginated,
8635}
8636
8637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8640#[serde(rename_all = "camelCase")]
8641pub struct ThreadItemEntry {
8642 #[serde(
8645 rename = "completedAtMs",
8646 default,
8647 skip_serializing_if = "Option::is_none"
8648 )]
8649 pub completed_at_ms: Option<i64>,
8650 #[serde()]
8651 pub item: ThreadItem,
8652 #[serde(
8655 rename = "startedAtMs",
8656 default,
8657 skip_serializing_if = "Option::is_none"
8658 )]
8659 pub started_at_ms: Option<i64>,
8660 #[serde(rename = "turnId", default)]
8661 pub turn_id: String,
8662}
8663
8664#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8666#[serde(rename_all = "camelCase")]
8667pub struct ThreadItemsListParams {
8668 #[serde(default, skip_serializing_if = "Option::is_none")]
8674 pub cursor: Option<ThreadItemsListCursor>,
8675 #[serde(default, skip_serializing_if = "Option::is_none")]
8676 pub limit: Option<u32>,
8677 #[serde(
8678 rename = "sortDirection",
8679 default,
8680 skip_serializing_if = "Option::is_none"
8681 )]
8682 pub sort_direction: Option<SortDirection>,
8683 #[serde(rename = "threadId", default)]
8684 pub thread_id: String,
8685 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8687 pub turn_id: Option<String>,
8688}
8689
8690#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8695#[serde(untagged)]
8696pub enum ThreadItemsListCursor {
8697 Opaque(String),
8698 Anchor(ThreadItemsListAnchor),
8699}
8700
8701#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8704#[serde(tag = "type", rename_all = "camelCase")]
8705pub enum ThreadItemsListAnchor {
8706 Item {
8707 #[serde(rename = "itemId")]
8708 item_id: String,
8709 },
8710}
8711
8712#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8714#[serde(rename_all = "camelCase")]
8715pub struct ThreadItemsListResponse {
8716 #[serde(
8717 rename = "backwardsCursor",
8718 default,
8719 skip_serializing_if = "Option::is_none"
8720 )]
8721 pub backwards_cursor: Option<String>,
8722 #[serde(default)]
8723 pub data: Vec<ThreadItemEntry>,
8724 #[serde(
8725 rename = "nextCursor",
8726 default,
8727 skip_serializing_if = "Option::is_none"
8728 )]
8729 pub next_cursor: Option<String>,
8730}
8731
8732#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8736pub struct ThreadRealtimeItem {
8737 #[serde(default)]
8738 pub id: String,
8739 #[serde(rename = "realtimeSessionId", default)]
8740 pub realtime_session_id: String,
8741 #[serde(flatten)]
8742 pub detail: ThreadRealtimeItemDetail,
8743}
8744
8745#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8747#[serde(tag = "type", rename_all = "camelCase")]
8748pub enum ThreadRealtimeItemDetail {
8749 #[serde(rename = "realtimeSessionStarted")]
8750 RealtimeSessionStarted,
8751 #[serde(rename = "transcriptSegment")]
8752 TranscriptSegment {
8753 role: ThreadRealtimeTranscriptRole,
8754 text: String,
8755 },
8756 #[serde(rename = "bemItemPromoted")]
8757 BemItemPromoted {
8758 item_id: String,
8759 presentation: ThreadRealtimeBemItemPresentation,
8760 turn_id: String,
8761 },
8762 #[serde(rename = "realtimeSessionClosed")]
8763 RealtimeSessionClosed {
8764 outcome: ThreadRealtimeSessionOutcome,
8765 },
8766}
8767
8768#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8771#[serde(tag = "type", rename_all = "camelCase")]
8772pub enum ThreadRealtimeBemItemPresentation {
8773 #[serde(rename = "wholeItem")]
8774 WholeItem,
8775 #[serde(rename = "inlineMarkdown")]
8776 InlineMarkdown,
8777 #[serde(rename = "inlineVisualization")]
8778 InlineVisualization { index: u32 },
8779}
8780
8781#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8783#[serde(rename_all = "camelCase")]
8784pub struct ThreadRealtimeItemStartedNotification {
8785 #[serde()]
8786 pub item: ThreadRealtimeItem,
8787 #[serde(rename = "threadId", default)]
8788 pub thread_id: String,
8789}
8790
8791#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8793#[serde(rename_all = "camelCase")]
8794pub struct ThreadRealtimeItemCompletedNotification {
8795 #[serde()]
8796 pub item: ThreadRealtimeItem,
8797 #[serde(rename = "threadId", default)]
8798 pub thread_id: String,
8799}
8800
8801#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8804#[serde(rename_all = "camelCase")]
8805pub struct ThreadRealtimeItemTranscriptDeltaNotification {
8806 #[serde(default)]
8807 pub delta: String,
8808 #[serde(rename = "itemId", default)]
8809 pub item_id: String,
8810 #[serde(rename = "threadId", default)]
8811 pub thread_id: String,
8812}
8813
8814#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8816pub enum ThreadRealtimeSessionOutcome {
8817 #[serde(rename = "ended")]
8818 Ended,
8819 #[serde(rename = "failed")]
8820 Failed,
8821}
8822
8823#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8825pub enum ThreadRealtimeTranscriptRole {
8826 #[serde(rename = "user")]
8827 User,
8828 #[serde(rename = "assistant")]
8829 Assistant,
8830}
8831
8832#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8836#[serde(rename_all = "camelCase")]
8837pub struct ThreadRevertParams {
8838 #[serde(rename = "beforeTurnId", default)]
8840 pub before_turn_id: String,
8841 #[serde(rename = "threadId", default)]
8842 pub thread_id: String,
8843}
8844
8845#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8848#[serde(rename_all = "camelCase")]
8849pub struct ThreadRevertResponse {
8850 #[serde(
8851 rename = "itemsBackwardsCursor",
8852 default,
8853 skip_serializing_if = "Option::is_none"
8854 )]
8855 pub items_backwards_cursor: Option<String>,
8856 #[serde()]
8857 pub thread: Thread,
8858 #[serde(
8859 rename = "turnsBackwardsCursor",
8860 default,
8861 skip_serializing_if = "Option::is_none"
8862 )]
8863 pub turns_backwards_cursor: Option<String>,
8864}
8865
8866#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8867#[serde(rename_all = "camelCase")]
8868pub struct ThreadSection {
8869 #[serde(default, skip_serializing_if = "Option::is_none")]
8870 pub appearance: Option<ThreadSectionAppearance>,
8871 #[serde(default)]
8872 pub id: String,
8873 #[serde(default)]
8874 pub name: String,
8875}
8876
8877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8878#[serde(rename_all = "camelCase")]
8879pub struct ThreadSectionAppearance {
8880 #[serde(default, skip_serializing_if = "Option::is_none")]
8881 pub color: Option<String>,
8882 #[serde(default, skip_serializing_if = "Option::is_none")]
8883 pub icon: Option<String>,
8884}
8885
8886#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8887#[serde(rename_all = "camelCase")]
8888pub struct ThreadSectionCreateParams {
8889 #[serde(default, skip_serializing_if = "Option::is_none")]
8890 pub appearance: Option<ThreadSectionAppearance>,
8891 #[serde(default)]
8892 pub name: String,
8893}
8894
8895#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8896#[serde(rename_all = "camelCase")]
8897pub struct ThreadSectionCreateResponse {
8898 #[serde()]
8899 pub section: ThreadSection,
8900}
8901
8902#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8903#[serde(rename_all = "camelCase")]
8904pub struct ThreadSectionDeleteParams {
8905 #[serde(rename = "sectionId", default)]
8906 pub section_id: String,
8907}
8908
8909#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8910#[serde(rename_all = "camelCase")]
8911pub struct ThreadSectionDeleteResponse {
8912 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8913 pub extra: serde_json::Map<String, Value>,
8914}
8915
8916#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8917#[serde(rename_all = "camelCase")]
8918pub struct ThreadSectionListParams {
8919 #[serde(default, skip_serializing_if = "Option::is_none")]
8920 pub cursor: Option<String>,
8921 #[serde(default, skip_serializing_if = "Option::is_none")]
8922 pub limit: Option<i64>,
8923}
8924
8925#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8926#[serde(rename_all = "camelCase")]
8927pub struct ThreadSectionListResponse {
8928 #[serde(default)]
8929 pub data: Vec<ThreadSection>,
8930 #[serde(
8931 rename = "nextCursor",
8932 default,
8933 skip_serializing_if = "Option::is_none"
8934 )]
8935 pub next_cursor: Option<String>,
8936}
8937
8938#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8939#[serde(rename_all = "camelCase")]
8940pub struct ThreadSectionMoveParams {
8941 #[serde(
8942 rename = "beforeThreadId",
8943 default,
8944 skip_serializing_if = "Option::is_none"
8945 )]
8946 pub before_thread_id: Option<String>,
8947 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8948 pub section_id: Option<String>,
8949 #[serde(rename = "threadId", default)]
8950 pub thread_id: String,
8951}
8952
8953#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8954#[serde(rename_all = "camelCase")]
8955pub struct ThreadSectionMoveResponse {
8956 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8957 pub extra: serde_json::Map<String, Value>,
8958}
8959
8960#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8961#[serde(rename_all = "camelCase")]
8962pub struct ThreadSectionUpdateParams {
8963 #[serde(default, skip_serializing_if = "Option::is_none")]
8964 pub appearance: Option<ThreadSectionAppearance>,
8965 #[serde(default)]
8966 pub name: String,
8967 #[serde(rename = "sectionId", default)]
8968 pub section_id: String,
8969}
8970
8971#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8972#[serde(rename_all = "camelCase")]
8973pub struct ThreadSectionUpdateResponse {
8974 #[serde()]
8975 pub section: ThreadSection,
8976}
8977
8978#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8979#[serde(rename_all = "camelCase")]
8980pub struct ThreadSetNameParams {
8981 #[serde(default)]
8982 pub name: String,
8983 #[serde(rename = "threadId", default)]
8984 pub thread_id: String,
8985}
8986
8987#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8988#[serde(rename_all = "camelCase")]
8989pub struct ThreadSetNameResponse {
8990 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8991 pub extra: serde_json::Map<String, Value>,
8992}
8993
8994#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8995#[serde(rename_all = "camelCase")]
8996pub struct ThreadSettings {
8997 #[serde(
8998 rename = "activePermissionProfile",
8999 default,
9000 skip_serializing_if = "Option::is_none"
9001 )]
9002 pub active_permission_profile: Option<ActivePermissionProfile>,
9003 #[serde(rename = "approvalPolicy")]
9004 pub approval_policy: AskForApproval,
9005 #[serde(rename = "approvalsReviewer")]
9006 pub approvals_reviewer: ApprovalsReviewer,
9007 #[serde(rename = "collaborationMode")]
9008 pub collaboration_mode: CollaborationMode,
9009 #[serde()]
9010 pub cwd: AbsolutePathBuf,
9011 #[serde(rename = "disabledPluginIds", default)]
9014 pub disabled_plugin_ids: Vec<String>,
9015 #[serde(default, skip_serializing_if = "Option::is_none")]
9016 pub effort: Option<ReasoningEffort>,
9017 #[serde(default)]
9018 pub model: String,
9019 #[serde(rename = "modelProvider", default)]
9020 pub model_provider: String,
9021 #[serde(default, skip_serializing_if = "Option::is_none")]
9022 pub personality: Option<Personality>,
9023 #[serde(rename = "sandboxPolicy")]
9024 pub sandbox_policy: SandboxPolicy,
9025 #[serde(
9026 rename = "serviceTier",
9027 default,
9028 skip_serializing_if = "Option::is_none"
9029 )]
9030 pub service_tier: Option<String>,
9031 #[serde(default, skip_serializing_if = "Option::is_none")]
9032 pub summary: Option<ReasoningSummary>,
9033}
9034
9035#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9036#[serde(rename_all = "camelCase")]
9037pub struct ThreadSettingsUpdatedNotification {
9038 #[serde(rename = "threadId", default)]
9039 pub thread_id: String,
9040 #[serde(rename = "threadSettings")]
9041 pub thread_settings: ThreadSettings,
9042}
9043
9044#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9045#[serde(rename_all = "camelCase")]
9046pub struct ThreadShellCommandParams {
9047 #[serde(default)]
9048 pub command: String,
9049 #[serde(rename = "threadId", default)]
9050 pub thread_id: String,
9051 #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
9054 pub timeout_ms: Option<i64>,
9055}
9056
9057#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9058#[serde(rename_all = "camelCase")]
9059pub struct ThreadShellCommandResponse {
9060 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9061 pub extra: serde_json::Map<String, Value>,
9062}
9063
9064#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9065pub enum ThreadSortKey {
9066 #[serde(rename = "created_at")]
9067 Created_at,
9068 #[serde(rename = "updated_at")]
9069 Updated_at,
9070 #[serde(rename = "recency_at")]
9071 Recency_at,
9072 #[serde(rename = "section_position")]
9073 Section_position,
9074}
9075
9076#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
9077#[serde(transparent)]
9078pub struct ThreadSource(pub String);
9079
9080#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9081pub enum ThreadSourceKind {
9082 #[serde(rename = "cli")]
9083 Cli,
9084 #[serde(rename = "vscode")]
9085 Vscode,
9086 #[serde(rename = "exec")]
9087 Exec,
9088 #[serde(rename = "appServer")]
9089 AppServer,
9090 #[serde(rename = "subAgent")]
9091 SubAgent,
9092 #[serde(rename = "subAgentReview")]
9093 SubAgentReview,
9094 #[serde(rename = "subAgentCompact")]
9095 SubAgentCompact,
9096 #[serde(rename = "subAgentThreadSpawn")]
9097 SubAgentThreadSpawn,
9098 #[serde(rename = "subAgentOther")]
9099 SubAgentOther,
9100 #[serde(rename = "unknown")]
9101 Unknown,
9102}
9103
9104#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9105#[serde(rename_all = "camelCase")]
9106pub struct ThreadStartParams {
9107 #[serde(
9108 rename = "approvalPolicy",
9109 default,
9110 skip_serializing_if = "Option::is_none"
9111 )]
9112 pub approval_policy: Option<AskForApproval>,
9113 #[serde(
9114 rename = "approvalsReviewer",
9115 default,
9116 skip_serializing_if = "Option::is_none"
9117 )]
9118 pub approvals_reviewer: Option<ApprovalsReviewer>,
9119 #[serde(
9120 rename = "baseInstructions",
9121 default,
9122 skip_serializing_if = "Option::is_none"
9123 )]
9124 pub base_instructions: Option<String>,
9125 #[serde(default, skip_serializing_if = "Option::is_none")]
9126 pub config: Option<Value>,
9127 #[serde(default, skip_serializing_if = "Option::is_none")]
9128 pub cwd: Option<String>,
9129 #[serde(
9130 rename = "developerInstructions",
9131 default,
9132 skip_serializing_if = "Option::is_none"
9133 )]
9134 pub developer_instructions: Option<String>,
9135 #[serde(default, skip_serializing_if = "Option::is_none")]
9136 pub ephemeral: Option<bool>,
9137 #[serde(default, skip_serializing_if = "Option::is_none")]
9138 pub model: Option<String>,
9139 #[serde(
9140 rename = "modelProvider",
9141 default,
9142 skip_serializing_if = "Option::is_none"
9143 )]
9144 pub model_provider: Option<String>,
9145 #[serde(default, skip_serializing_if = "Option::is_none")]
9146 pub personality: Option<Personality>,
9147 #[serde(default, skip_serializing_if = "Option::is_none")]
9148 pub sandbox: Option<SandboxMode>,
9149 #[serde(
9150 rename = "serviceName",
9151 default,
9152 skip_serializing_if = "Option::is_none"
9153 )]
9154 pub service_name: Option<String>,
9155 #[serde(
9156 rename = "serviceTier",
9157 default,
9158 skip_serializing_if = "Option::is_none"
9159 )]
9160 pub service_tier: Option<String>,
9161 #[serde(
9162 rename = "sessionStartSource",
9163 default,
9164 skip_serializing_if = "Option::is_none"
9165 )]
9166 pub session_start_source: Option<ThreadStartSource>,
9167 #[serde(
9168 rename = "threadSource",
9169 default,
9170 skip_serializing_if = "Option::is_none"
9171 )]
9172 pub thread_source: Option<ThreadSource>,
9173}
9174
9175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9176#[serde(rename_all = "camelCase")]
9177pub struct ThreadStartResponse {
9178 #[serde(rename = "approvalPolicy")]
9179 pub approval_policy: AskForApproval,
9180 #[serde(rename = "approvalsReviewer", default)]
9181 pub approvals_reviewer: Value,
9182 #[serde()]
9183 pub cwd: AbsolutePathBuf,
9184 #[serde(rename = "disabledPluginIds", default)]
9187 pub disabled_plugin_ids: Vec<String>,
9188 #[serde(
9189 rename = "instructionSources",
9190 default,
9191 skip_serializing_if = "Option::is_none"
9192 )]
9193 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9194 #[serde(default)]
9195 pub model: String,
9196 #[serde(rename = "modelProvider", default)]
9197 pub model_provider: String,
9198 #[serde(
9199 rename = "reasoningEffort",
9200 default,
9201 skip_serializing_if = "Option::is_none"
9202 )]
9203 pub reasoning_effort: Option<ReasoningEffort>,
9204 #[serde(default)]
9205 pub sandbox: Value,
9206 #[serde(
9207 rename = "serviceTier",
9208 default,
9209 skip_serializing_if = "Option::is_none"
9210 )]
9211 pub service_tier: Option<String>,
9212 #[serde()]
9213 pub thread: Thread,
9214}
9215
9216#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9217pub enum ThreadStartSource {
9218 #[serde(rename = "startup")]
9219 Startup,
9220 #[serde(rename = "clear")]
9221 Clear,
9222}
9223
9224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9225#[serde(rename_all = "camelCase")]
9226pub struct ThreadStartedNotification {
9227 #[serde()]
9228 pub thread: Thread,
9229}
9230
9231#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9232#[serde(tag = "type", rename_all = "camelCase")]
9233pub enum ThreadStatus {
9234 #[serde(rename = "notLoaded")]
9235 NotLoaded,
9236 Idle,
9237 #[serde(rename = "systemError")]
9238 SystemError,
9239 Active {
9240 #[serde(rename = "activeFlags")]
9241 active_flags: Vec<ThreadActiveFlag>,
9242 },
9243}
9244
9245#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9246#[serde(rename_all = "camelCase")]
9247pub struct ThreadStatusChangedNotification {
9248 #[serde()]
9249 pub status: ThreadStatus,
9250 #[serde(rename = "threadId", default)]
9251 pub thread_id: String,
9252}
9253
9254#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9255#[serde(rename_all = "camelCase")]
9256pub struct ThreadTokenUsage {
9257 #[serde()]
9258 pub last: TokenUsageBreakdown,
9259 #[serde(
9260 rename = "modelContextWindow",
9261 default,
9262 skip_serializing_if = "Option::is_none"
9263 )]
9264 pub model_context_window: Option<i64>,
9265 #[serde()]
9266 pub total: TokenUsageBreakdown,
9267}
9268
9269#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9270#[serde(rename_all = "camelCase")]
9271pub struct ThreadTokenUsageUpdatedNotification {
9272 #[serde(rename = "threadId", default)]
9273 pub thread_id: String,
9274 #[serde(rename = "tokenUsage")]
9275 pub token_usage: ThreadTokenUsage,
9276 #[serde(rename = "turnId", default)]
9277 pub turn_id: String,
9278}
9279
9280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9281#[serde(rename_all = "camelCase")]
9282pub struct ThreadUnarchiveParams {
9283 #[serde(rename = "threadId", default)]
9284 pub thread_id: String,
9285}
9286
9287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9288#[serde(rename_all = "camelCase")]
9289pub struct ThreadUnarchiveResponse {
9290 #[serde()]
9291 pub thread: Thread,
9292}
9293
9294#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9295#[serde(rename_all = "camelCase")]
9296pub struct ThreadUnarchivedNotification {
9297 #[serde(rename = "threadId", default)]
9298 pub thread_id: String,
9299}
9300
9301#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9302#[serde(tag = "type", rename_all = "camelCase")]
9303pub enum ThreadUnreadPosition {
9304 #[serde(rename = "threadStart")]
9306 ThreadStart,
9307 Turn {
9309 #[serde(rename = "turnId")]
9310 turn_id: String,
9311 },
9312}
9313
9314#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9319#[serde(tag = "type", rename_all = "camelCase")]
9320#[allow(clippy::large_enum_variant)] pub enum ThreadTimelineEntry {
9322 Item {
9323 item: ThreadItem,
9324 position: u64,
9325 #[serde(rename = "turnId")]
9326 turn_id: String,
9327 },
9328 Realtime {
9329 item: ThreadRealtimeItem,
9330 position: u64,
9331 },
9332 TurnStarted {
9333 position: u64,
9334 #[serde(default, skip_serializing_if = "Option::is_none")]
9335 started_at: Option<i64>,
9336 turn_id: String,
9337 },
9338 TurnCompleted {
9339 #[serde(default, skip_serializing_if = "Option::is_none")]
9340 completed_at: Option<i64>,
9341 #[serde(default, skip_serializing_if = "Option::is_none")]
9342 duration_ms: Option<i64>,
9343 #[serde(default, skip_serializing_if = "Option::is_none")]
9344 error: Option<TurnError>,
9345 position: u64,
9346 #[serde(default, skip_serializing_if = "Option::is_none")]
9347 started_at: Option<i64>,
9348 status: TurnStatus,
9349 turn_id: String,
9350 },
9351}
9352
9353#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9355#[serde(rename_all = "camelCase")]
9356pub struct ThreadTurnsListParams {
9357 #[serde(default, skip_serializing_if = "Option::is_none")]
9358 pub cursor: Option<String>,
9359 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9361 pub items_view: Option<TurnItemsView>,
9362 #[serde(default, skip_serializing_if = "Option::is_none")]
9363 pub limit: Option<u32>,
9364 #[serde(
9365 rename = "sortDirection",
9366 default,
9367 skip_serializing_if = "Option::is_none"
9368 )]
9369 pub sort_direction: Option<SortDirection>,
9370 #[serde(rename = "threadId", default)]
9371 pub thread_id: String,
9372}
9373
9374#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9376#[serde(rename_all = "camelCase")]
9377pub struct ThreadTurnsListResponse {
9378 #[serde(
9379 rename = "backwardsCursor",
9380 default,
9381 skip_serializing_if = "Option::is_none"
9382 )]
9383 pub backwards_cursor: Option<String>,
9384 #[serde(default)]
9385 pub data: Vec<Turn>,
9386 #[serde(
9387 rename = "nextCursor",
9388 default,
9389 skip_serializing_if = "Option::is_none"
9390 )]
9391 pub next_cursor: Option<String>,
9392}
9393
9394#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9395#[serde(rename_all = "camelCase")]
9396pub struct ThreadUnsubscribeParams {
9397 #[serde(rename = "threadId", default)]
9398 pub thread_id: String,
9399}
9400
9401#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9402#[serde(rename_all = "camelCase")]
9403pub struct ThreadUnsubscribeResponse {
9404 #[serde()]
9405 pub status: ThreadUnsubscribeStatus,
9406}
9407
9408#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9409pub enum ThreadUnsubscribeStatus {
9410 #[serde(rename = "notLoaded")]
9411 NotLoaded,
9412 #[serde(rename = "notSubscribed")]
9413 NotSubscribed,
9414 #[serde(rename = "unsubscribed")]
9415 Unsubscribed,
9416}
9417
9418#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9419#[serde(rename_all = "camelCase")]
9420pub struct TokenUsageBreakdown {
9421 #[serde(
9422 rename = "cacheWriteInputTokens",
9423 default,
9424 skip_serializing_if = "Option::is_none"
9425 )]
9426 pub cache_write_input_tokens: Option<i64>,
9427 #[serde(rename = "cachedInputTokens", default)]
9428 pub cached_input_tokens: i64,
9429 #[serde(rename = "inputTokens", default)]
9430 pub input_tokens: i64,
9431 #[serde(rename = "outputTokens", default)]
9432 pub output_tokens: i64,
9433 #[serde(rename = "reasoningOutputTokens", default)]
9434 pub reasoning_output_tokens: i64,
9435 #[serde(rename = "totalTokens", default)]
9436 pub total_tokens: i64,
9437}
9438
9439#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9440#[serde(rename_all = "camelCase")]
9441pub struct Tool {
9442 #[serde(default, skip_serializing_if = "Option::is_none")]
9443 pub _meta: Option<Value>,
9444 #[serde(default, skip_serializing_if = "Option::is_none")]
9445 pub annotations: Option<Value>,
9446 #[serde(default, skip_serializing_if = "Option::is_none")]
9447 pub description: Option<String>,
9448 #[serde(default, skip_serializing_if = "Option::is_none")]
9449 pub icons: Option<Vec<Value>>,
9450 #[serde(rename = "inputSchema", default)]
9451 pub input_schema: Value,
9452 #[serde(default)]
9453 pub name: String,
9454 #[serde(
9455 rename = "outputSchema",
9456 default,
9457 skip_serializing_if = "Option::is_none"
9458 )]
9459 pub output_schema: Option<Value>,
9460 #[serde(default, skip_serializing_if = "Option::is_none")]
9461 pub title: Option<String>,
9462}
9463
9464#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9465#[serde(rename_all = "camelCase")]
9466pub struct ToolRequestUserInputAnswer {
9467 #[serde(default)]
9468 pub answers: Vec<String>,
9469}
9470
9471#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9472#[serde(rename_all = "camelCase")]
9473pub struct ToolRequestUserInputOption {
9474 #[serde(default)]
9475 pub description: String,
9476 #[serde(default)]
9477 pub label: String,
9478}
9479
9480#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9481#[serde(rename_all = "camelCase")]
9482pub struct ToolRequestUserInputParams {
9483 #[serde(
9484 rename = "autoResolutionMs",
9485 default,
9486 skip_serializing_if = "Option::is_none"
9487 )]
9488 pub auto_resolution_ms: Option<i64>,
9489 #[serde(rename = "isBlocking", default)]
9490 pub is_blocking: bool,
9491 #[serde(rename = "itemId", default)]
9492 pub item_id: String,
9493 #[serde(default)]
9494 pub questions: Vec<ToolRequestUserInputQuestion>,
9495 #[serde(rename = "threadId", default)]
9496 pub thread_id: String,
9497 #[serde(rename = "turnId", default)]
9498 pub turn_id: String,
9499}
9500
9501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9502#[serde(rename_all = "camelCase")]
9503pub struct ToolRequestUserInputQuestion {
9504 #[serde(default)]
9505 pub header: String,
9506 #[serde(default)]
9507 pub id: String,
9508 #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
9509 pub is_other: Option<bool>,
9510 #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
9511 pub is_secret: Option<bool>,
9512 #[serde(default, skip_serializing_if = "Option::is_none")]
9513 pub options: Option<Vec<ToolRequestUserInputOption>>,
9514 #[serde(default)]
9515 pub question: String,
9516}
9517
9518#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9519#[serde(rename_all = "camelCase")]
9520pub struct ToolRequestUserInputResponse {
9521 #[serde(default)]
9522 pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
9523}
9524
9525#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9526#[serde(rename_all = "camelCase")]
9527pub struct ToolsV2 {
9528 #[serde(default, skip_serializing_if = "Option::is_none")]
9529 pub web_search: Option<WebSearchToolConfig>,
9530}
9531
9532#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9533#[serde(rename_all = "camelCase")]
9534pub struct Turn {
9535 #[serde(
9536 rename = "completedAt",
9537 default,
9538 skip_serializing_if = "Option::is_none"
9539 )]
9540 pub completed_at: Option<i64>,
9541 #[serde(
9542 rename = "durationMs",
9543 default,
9544 skip_serializing_if = "Option::is_none"
9545 )]
9546 pub duration_ms: Option<i64>,
9547 #[serde(default, skip_serializing_if = "Option::is_none")]
9548 pub error: Option<TurnError>,
9549 #[serde(default)]
9550 pub id: String,
9551 #[serde(default)]
9552 pub items: Vec<ThreadItem>,
9553 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9554 pub items_view: Option<Value>,
9555 #[serde(
9559 rename = "rootTurnId",
9560 default,
9561 skip_serializing_if = "Option::is_none"
9562 )]
9563 pub root_turn_id: Option<String>,
9564 #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
9565 pub started_at: Option<i64>,
9566 #[serde()]
9567 pub status: TurnStatus,
9568}
9569
9570#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9571#[serde(rename_all = "camelCase")]
9572pub struct TurnCompletedNotification {
9573 #[serde(rename = "threadId", default)]
9574 pub thread_id: String,
9575 #[serde()]
9576 pub turn: Turn,
9577}
9578
9579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9580#[serde(rename_all = "camelCase")]
9581pub struct TurnDiffUpdatedNotification {
9582 #[serde(default)]
9583 pub diff: String,
9584 #[serde(rename = "threadId", default)]
9585 pub thread_id: String,
9586 #[serde(rename = "turnId", default)]
9587 pub turn_id: String,
9588}
9589
9590#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9591#[serde(rename_all = "camelCase")]
9592pub struct TurnError {
9593 #[serde(
9594 rename = "additionalDetails",
9595 default,
9596 skip_serializing_if = "Option::is_none"
9597 )]
9598 pub additional_details: Option<String>,
9599 #[serde(
9600 rename = "codexErrorInfo",
9601 default,
9602 skip_serializing_if = "Option::is_none"
9603 )]
9604 pub codex_error_info: Option<CodexErrorInfo>,
9605 #[serde(default)]
9606 pub message: String,
9607 #[serde(default, skip_serializing_if = "Option::is_none")]
9610 pub misalignment: Option<MisalignmentErrorDetails>,
9611}
9612
9613#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9614#[serde(rename_all = "camelCase")]
9615pub struct TurnInterruptParams {
9616 #[serde(rename = "threadId", default)]
9617 pub thread_id: String,
9618 #[serde(rename = "turnId", default)]
9619 pub turn_id: String,
9620}
9621
9622#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9623#[serde(rename_all = "camelCase")]
9624pub struct TurnInterruptResponse {
9625 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9626 pub extra: serde_json::Map<String, Value>,
9627}
9628
9629#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
9630pub enum TurnItemsView {
9631 #[serde(rename = "notLoaded")]
9632 NotLoaded,
9633 #[serde(rename = "summary")]
9634 Summary,
9635 #[serde(rename = "full")]
9636 Full,
9637}
9638
9639#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9640#[serde(rename_all = "camelCase")]
9641pub struct TurnModerationMetadataNotification {
9642 #[serde(default)]
9643 pub metadata: Value,
9644 #[serde(rename = "threadId", default)]
9645 pub thread_id: String,
9646 #[serde(rename = "turnId", default)]
9647 pub turn_id: String,
9648}
9649
9650#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9651#[serde(rename_all = "camelCase")]
9652pub struct TurnPlanStep {
9653 #[serde()]
9654 pub status: TurnPlanStepStatus,
9655 #[serde(default)]
9656 pub step: String,
9657}
9658
9659#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9660pub enum TurnPlanStepStatus {
9661 #[serde(rename = "pending")]
9662 Pending,
9663 #[serde(rename = "inProgress")]
9664 InProgress,
9665 #[serde(rename = "completed")]
9666 Completed,
9667}
9668
9669#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9670#[serde(rename_all = "camelCase")]
9671pub struct TurnPlanUpdatedNotification {
9672 #[serde(default, skip_serializing_if = "Option::is_none")]
9673 pub explanation: Option<String>,
9674 #[serde(default)]
9675 pub plan: Vec<TurnPlanStep>,
9676 #[serde(rename = "threadId", default)]
9677 pub thread_id: String,
9678 #[serde(rename = "turnId", default)]
9679 pub turn_id: String,
9680}
9681
9682#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9683#[serde(rename_all = "camelCase")]
9684pub struct TurnStartParams {
9685 #[serde(
9686 rename = "approvalPolicy",
9687 default,
9688 skip_serializing_if = "Option::is_none"
9689 )]
9690 pub approval_policy: Option<AskForApproval>,
9691 #[serde(
9692 rename = "approvalsReviewer",
9693 default,
9694 skip_serializing_if = "Option::is_none"
9695 )]
9696 pub approvals_reviewer: Option<ApprovalsReviewer>,
9697 #[serde(
9698 rename = "clientUserMessageId",
9699 default,
9700 skip_serializing_if = "Option::is_none"
9701 )]
9702 pub client_user_message_id: Option<String>,
9703 #[serde(default, skip_serializing_if = "Option::is_none")]
9704 pub cwd: Option<String>,
9705 #[serde(
9708 rename = "disabledPluginIds",
9709 default,
9710 skip_serializing_if = "Option::is_none"
9711 )]
9712 pub disabled_plugin_ids: Option<Vec<String>>,
9713 #[serde(default, skip_serializing_if = "Option::is_none")]
9714 pub effort: Option<ReasoningEffort>,
9715 #[serde(default)]
9716 pub input: Vec<UserInput>,
9717 #[serde(default, skip_serializing_if = "Option::is_none")]
9718 pub model: Option<String>,
9719 #[serde(
9720 rename = "outputSchema",
9721 default,
9722 skip_serializing_if = "Option::is_none"
9723 )]
9724 pub output_schema: Option<Value>,
9725 #[serde(
9729 rename = "parentTurnId",
9730 default,
9731 skip_serializing_if = "Option::is_none"
9732 )]
9733 pub parent_turn_id: Option<String>,
9734 #[serde(default, skip_serializing_if = "Option::is_none")]
9735 pub personality: Option<Personality>,
9736 #[serde(
9741 rename = "rootTurnId",
9742 default,
9743 skip_serializing_if = "Option::is_none"
9744 )]
9745 pub root_turn_id: Option<String>,
9746 #[serde(
9747 rename = "sandboxPolicy",
9748 default,
9749 skip_serializing_if = "Option::is_none"
9750 )]
9751 pub sandbox_policy: Option<SandboxPolicy>,
9752 #[serde(
9753 rename = "serviceTier",
9754 default,
9755 skip_serializing_if = "Option::is_none"
9756 )]
9757 pub service_tier: Option<String>,
9758 #[serde(
9761 rename = "serviceTierForTurn",
9762 default,
9763 skip_serializing_if = "Option::is_none"
9764 )]
9765 pub service_tier_for_turn: Option<String>,
9766 #[serde(default, skip_serializing_if = "Option::is_none")]
9767 pub summary: Option<ReasoningSummary>,
9768 #[serde(rename = "threadId", default)]
9769 pub thread_id: String,
9770 #[serde(
9773 rename = "toolOutput",
9774 default,
9775 skip_serializing_if = "Option::is_none"
9776 )]
9777 pub tool_output: Option<TurnToolOutput>,
9778 #[serde(
9781 rename = "turnTrigger",
9782 default,
9783 skip_serializing_if = "Option::is_none"
9784 )]
9785 pub turn_trigger: Option<String>,
9786}
9787
9788#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9789#[serde(rename_all = "camelCase")]
9790pub struct TurnStartResponse {
9791 #[serde()]
9792 pub turn: Turn,
9793}
9794
9795#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9796#[serde(rename_all = "camelCase")]
9797pub struct TurnStartedNotification {
9798 #[serde(rename = "threadId", default)]
9799 pub thread_id: String,
9800 #[serde()]
9801 pub turn: Turn,
9802}
9803
9804#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9805pub enum TurnStatus {
9806 #[serde(rename = "completed")]
9807 Completed,
9808 #[serde(rename = "interrupted")]
9809 Interrupted,
9810 #[serde(rename = "failed")]
9811 Failed,
9812 #[serde(rename = "inProgress")]
9813 InProgress,
9814}
9815
9816#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9819#[serde(rename_all = "camelCase")]
9820pub struct TurnToolOutput {
9821 #[serde(default)]
9822 pub name: String,
9823 #[serde(default, skip_serializing_if = "Option::is_none")]
9824 pub namespace: Option<String>,
9825 #[serde()]
9826 pub output: FunctionCallOutputBody,
9827 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9830 pub retain: bool,
9831}
9832
9833#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9834#[serde(rename_all = "camelCase")]
9835pub struct TurnSteerParams {
9836 #[serde(
9837 rename = "clientUserMessageId",
9838 default,
9839 skip_serializing_if = "Option::is_none"
9840 )]
9841 pub client_user_message_id: Option<String>,
9842 #[serde(rename = "expectedTurnId", default)]
9843 pub expected_turn_id: String,
9844 #[serde(default)]
9845 pub input: Vec<UserInput>,
9846 #[serde(rename = "threadId", default)]
9847 pub thread_id: String,
9848}
9849
9850#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9851#[serde(rename_all = "camelCase")]
9852pub struct TurnSteerResponse {
9853 #[serde(rename = "turnId", default)]
9854 pub turn_id: String,
9855}
9856
9857#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9858#[serde(tag = "type", rename_all = "camelCase")]
9859pub enum UserInput {
9860 Text {
9861 text: String,
9862 #[serde(default, skip_serializing_if = "Option::is_none")]
9863 text_elements: Option<Vec<TextElement>>,
9864 },
9865 Image {
9866 #[serde(default, skip_serializing_if = "Option::is_none")]
9867 detail: Option<ImageDetail>,
9868 #[serde(flatten)]
9869 image: UserInputImageReference,
9870 },
9871 #[serde(rename = "localImage")]
9872 LocalImage {
9873 #[serde(default, skip_serializing_if = "Option::is_none")]
9874 detail: Option<ImageDetail>,
9875 path: String,
9876 },
9877 Audio {
9878 url: String,
9879 },
9880 #[serde(rename = "localAudio")]
9881 LocalAudio {
9882 path: String,
9883 },
9884 Skill {
9885 name: String,
9886 path: String,
9887 },
9888 Mention {
9889 name: String,
9890 path: String,
9891 },
9892}
9893
9894#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9900#[serde(untagged)]
9901pub enum UserInputImageReference {
9902 Inline {
9903 url: String,
9904 },
9905 File {
9906 #[serde(rename = "fileId")]
9907 file_id: String,
9908 },
9909}
9910
9911#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9912pub enum Verbosity {
9913 #[serde(rename = "low")]
9914 Low,
9915 #[serde(rename = "medium")]
9916 Medium,
9917 #[serde(rename = "high")]
9918 High,
9919}
9920
9921#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9922#[serde(rename_all = "camelCase")]
9923pub struct WarningNotification {
9924 #[serde(default)]
9925 pub message: String,
9926 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
9927 pub thread_id: Option<String>,
9928}
9929
9930#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9931#[serde(tag = "type", rename_all = "camelCase")]
9932pub enum WebSearchAction {
9933 Search {
9934 #[serde(default, skip_serializing_if = "Option::is_none")]
9935 queries: Option<Vec<String>>,
9936 #[serde(default, skip_serializing_if = "Option::is_none")]
9937 query: Option<String>,
9938 },
9939 #[serde(rename = "openPage")]
9940 OpenPage {
9941 #[serde(default, skip_serializing_if = "Option::is_none")]
9942 url: Option<String>,
9943 },
9944 #[serde(rename = "findInPage")]
9945 FindInPage {
9946 #[serde(default, skip_serializing_if = "Option::is_none")]
9947 pattern: Option<String>,
9948 #[serde(default, skip_serializing_if = "Option::is_none")]
9949 url: Option<String>,
9950 },
9951 Other,
9952}
9953
9954#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9955pub enum WebSearchContextSize {
9956 #[serde(rename = "low")]
9957 Low,
9958 #[serde(rename = "medium")]
9959 Medium,
9960 #[serde(rename = "high")]
9961 High,
9962}
9963
9964#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9965#[serde(rename_all = "camelCase")]
9966pub struct WebSearchLocation {
9967 #[serde(default, skip_serializing_if = "Option::is_none")]
9968 pub city: Option<String>,
9969 #[serde(default, skip_serializing_if = "Option::is_none")]
9970 pub country: Option<String>,
9971 #[serde(default, skip_serializing_if = "Option::is_none")]
9972 pub region: Option<String>,
9973 #[serde(default, skip_serializing_if = "Option::is_none")]
9974 pub timezone: Option<String>,
9975}
9976
9977#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9978pub enum WebSearchMode {
9979 #[serde(rename = "disabled")]
9980 Disabled,
9981 #[serde(rename = "cached")]
9982 Cached,
9983 #[serde(rename = "indexed")]
9984 Indexed,
9985 #[serde(rename = "live")]
9986 Live,
9987}
9988
9989#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9990#[serde(rename_all = "camelCase")]
9991pub struct WebSearchToolConfig {
9992 #[serde(default, skip_serializing_if = "Option::is_none")]
9993 pub allowed_domains: Option<Vec<String>>,
9994 #[serde(default, skip_serializing_if = "Option::is_none")]
9995 pub context_size: Option<WebSearchContextSize>,
9996 #[serde(default, skip_serializing_if = "Option::is_none")]
9997 pub location: Option<WebSearchLocation>,
9998}
9999
10000#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10001pub enum WindowsSandboxReadiness {
10002 #[serde(rename = "ready")]
10003 Ready,
10004 #[serde(rename = "notConfigured")]
10005 NotConfigured,
10006 #[serde(rename = "updateRequired")]
10007 UpdateRequired,
10008}
10009
10010#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10011#[serde(rename_all = "camelCase")]
10012pub struct WindowsSandboxReadinessResponse {
10013 #[serde()]
10014 pub status: WindowsSandboxReadiness,
10015}
10016
10017#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10018#[serde(rename_all = "camelCase")]
10019pub struct WindowsSandboxSetupCompletedNotification {
10020 #[serde(default, skip_serializing_if = "Option::is_none")]
10021 pub error: Option<String>,
10022 #[serde()]
10023 pub mode: WindowsSandboxSetupMode,
10024 #[serde(default)]
10025 pub success: bool,
10026}
10027
10028#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10029pub enum WindowsSandboxSetupMode {
10030 #[serde(rename = "elevated")]
10031 Elevated,
10032 #[serde(rename = "unelevated")]
10033 Unelevated,
10034}
10035
10036#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10040pub enum WindowsSandboxImplementation {
10041 #[serde(rename = "elevated")]
10042 Elevated,
10043 #[serde(rename = "unelevated")]
10044 Unelevated,
10045 #[serde(rename = "mxc")]
10046 Mxc,
10047}
10048
10049#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10050#[serde(rename_all = "camelCase")]
10051pub struct WindowsSandboxSetupStartParams {
10052 #[serde(default, skip_serializing_if = "Option::is_none")]
10053 pub cwd: Option<AbsolutePathBuf>,
10054 #[serde()]
10055 pub mode: WindowsSandboxSetupMode,
10056}
10057
10058#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10059#[serde(rename_all = "camelCase")]
10060pub struct WindowsSandboxSetupStartResponse {
10061 #[serde(default)]
10062 pub started: bool,
10063}
10064
10065#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10066#[serde(rename_all = "camelCase")]
10067pub struct WindowsWorldWritableWarningNotification {
10068 #[serde(rename = "extraCount", default)]
10069 pub extra_count: i64,
10070 #[serde(rename = "failedScan", default)]
10071 pub failed_scan: bool,
10072 #[serde(rename = "samplePaths", default)]
10073 pub sample_paths: Vec<String>,
10074}
10075
10076#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10077#[serde(rename_all = "camelCase")]
10078pub struct WorkspaceMessage {
10079 #[serde(
10080 rename = "archivedAt",
10081 default,
10082 skip_serializing_if = "Option::is_none"
10083 )]
10084 pub archived_at: Option<i64>,
10085 #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
10086 pub created_at: Option<i64>,
10087 #[serde(rename = "messageBody", default)]
10088 pub message_body: String,
10089 #[serde(rename = "messageId", default)]
10090 pub message_id: String,
10091 #[serde(rename = "messageType")]
10092 pub message_type: WorkspaceMessageType,
10093}
10094
10095#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10096pub enum WorkspaceMessageType {
10097 #[serde(rename = "headline")]
10098 Headline,
10099 #[serde(rename = "announcement")]
10100 Announcement,
10101 #[serde(rename = "unknown")]
10102 Unknown,
10103}
10104
10105#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10106pub enum WriteStatus {
10107 #[serde(rename = "ok")]
10108 Ok,
10109 #[serde(rename = "okOverridden")]
10110 OkOverridden,
10111}