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