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