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