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