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