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