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