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)]
2869#[serde(rename_all = "camelCase")]
2870pub struct GatewayOAuthLoginResponse {}
2871
2872#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2875#[serde(rename_all = "camelCase")]
2876pub struct GatewayOAuthReadResponse {
2877 #[serde(default, skip_serializing_if = "Option::is_none")]
2878 pub error: Option<String>,
2879 #[serde(rename = "providerId", default)]
2880 pub provider_id: String,
2881 #[serde(rename = "providerName", default)]
2882 pub provider_name: String,
2883 #[serde(default)]
2886 pub required: bool,
2887 #[serde(default, skip_serializing_if = "Option::is_none")]
2889 pub status: Option<GatewayOAuthStatus>,
2890}
2891
2892#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
2893pub enum GatewayOAuthStatus {
2894 #[serde(rename = "notReady")]
2895 NotReady,
2896 #[serde(rename = "started")]
2897 Started,
2898 #[serde(rename = "succeeded")]
2899 Succeeded,
2900 #[serde(rename = "failed")]
2901 Failed,
2902}
2903
2904#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2905#[serde(rename_all = "camelCase")]
2906pub struct GetAccountParams {
2907 #[serde(
2908 rename = "refreshToken",
2909 default,
2910 skip_serializing_if = "Option::is_none"
2911 )]
2912 pub refresh_token: Option<bool>,
2913}
2914
2915#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
2919#[serde(rename_all = "camelCase")]
2920pub struct GetAccountRateLimitsParams {
2921 #[serde(
2925 rename = "excludeResetCreditDetails",
2926 default,
2927 skip_serializing_if = "std::ops::Not::not"
2928 )]
2929 pub exclude_reset_credit_details: bool,
2930 #[serde(
2934 rename = "supportsLunaReserve",
2935 default,
2936 skip_serializing_if = "std::ops::Not::not"
2937 )]
2938 pub supports_luna_reserve: bool,
2939}
2940
2941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2942#[serde(rename_all = "camelCase")]
2943pub struct GetAccountRateLimitsResponse {
2944 #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
2945 pub account_id: Option<String>,
2946 #[serde(
2950 rename = "ordinaryUsageAllowed",
2951 default,
2952 skip_serializing_if = "Option::is_none"
2953 )]
2954 pub ordinary_usage_allowed: Option<bool>,
2955 #[serde(
2956 rename = "rateLimitResetCredits",
2957 default,
2958 skip_serializing_if = "Option::is_none"
2959 )]
2960 pub rate_limit_reset_credits: Option<RateLimitResetCreditsSummary>,
2961 #[serde(
2962 rename = "rateLimitUpsell",
2963 default,
2964 skip_serializing_if = "Option::is_none"
2965 )]
2966 pub rate_limit_upsell: Option<Value>,
2967 #[serde(rename = "rateLimits", default)]
2968 pub rate_limits: Value,
2969 #[serde(
2970 rename = "rateLimitsByLimitId",
2971 default,
2972 skip_serializing_if = "Option::is_none"
2973 )]
2974 pub rate_limits_by_limit_id: Option<std::collections::BTreeMap<String, RateLimitSnapshot>>,
2975}
2976
2977#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
2978#[serde(rename_all = "camelCase")]
2979pub struct GetAccountResponse {
2980 #[serde(default, skip_serializing_if = "Option::is_none")]
2981 pub account: Option<Account>,
2982 #[serde(rename = "requiresOpenaiAuth", default)]
2983 pub requires_openai_auth: bool,
2984}
2985
2986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2987#[serde(rename_all = "camelCase")]
2988pub struct GetAccountTokenUsageResponse {
2989 #[serde(
2990 rename = "dailyUsageBuckets",
2991 default,
2992 skip_serializing_if = "Option::is_none"
2993 )]
2994 pub daily_usage_buckets: Option<Vec<AccountTokenUsageDailyBucket>>,
2995 #[serde()]
2996 pub summary: AccountTokenUsageSummary,
2997 #[serde(
2998 rename = "threadUsage",
2999 default,
3000 skip_serializing_if = "Option::is_none"
3001 )]
3002 pub thread_usage: Option<ThreadUsage>,
3003}
3004
3005#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3006#[serde(rename_all = "camelCase")]
3007pub struct GetAccountTokenUsageParams {
3008 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3009 pub thread_id: Option<String>,
3010}
3011
3012#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3013#[serde(rename_all = "camelCase")]
3014pub struct ThreadUsage {
3015 #[serde(rename = "estimatedUsageCreditsMicros", default)]
3016 pub estimated_usage_credits_micros: i64,
3017 #[serde(
3018 rename = "estimatedUsageUsdMicros",
3019 default,
3020 skip_serializing_if = "Option::is_none"
3021 )]
3022 pub estimated_usage_usd_micros: Option<i64>,
3023 #[serde(
3026 rename = "nativeUsageUsdMicros",
3027 default,
3028 skip_serializing_if = "Option::is_none"
3029 )]
3030 pub native_usage_usd_micros: Option<i64>,
3031 #[serde(default)]
3032 pub groups: Vec<ThreadUsageBreakdownGroup>,
3033 #[serde(rename = "threadId", default)]
3034 pub thread_id: String,
3035}
3036
3037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3038#[serde(rename_all = "camelCase")]
3039pub struct ThreadUsageBreakdownGroup {
3040 #[serde(
3041 rename = "cachedInputTokens",
3042 default,
3043 skip_serializing_if = "Option::is_none"
3044 )]
3045 pub cached_input_tokens: Option<i64>,
3046 #[serde(rename = "estimatedUsageCreditsMicros", default)]
3047 pub estimated_usage_credits_micros: i64,
3048 #[serde(
3049 rename = "inputTokens",
3050 default,
3051 skip_serializing_if = "Option::is_none"
3052 )]
3053 pub input_tokens: Option<i64>,
3054 #[serde(default, skip_serializing_if = "Option::is_none")]
3055 pub model: Option<String>,
3056 #[serde(
3057 rename = "netNewInputTokens",
3058 default,
3059 skip_serializing_if = "Option::is_none"
3060 )]
3061 pub net_new_input_tokens: Option<i64>,
3062 #[serde(
3063 rename = "outputTokens",
3064 default,
3065 skip_serializing_if = "Option::is_none"
3066 )]
3067 pub output_tokens: Option<i64>,
3068 #[serde(
3069 rename = "reasoningEffort",
3070 default,
3071 skip_serializing_if = "Option::is_none"
3072 )]
3073 pub reasoning_effort: Option<String>,
3074 #[serde(default, skip_serializing_if = "Option::is_none")]
3075 pub speed: Option<String>,
3076 #[serde(
3077 rename = "totalTokens",
3078 default,
3079 skip_serializing_if = "Option::is_none"
3080 )]
3081 pub total_tokens: Option<i64>,
3082}
3083
3084#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3089#[serde(untagged)]
3090pub enum GeneratedImageRef {
3091 File {
3092 #[serde(rename = "fileId")]
3093 file_id: String,
3094 },
3095 Inline {
3096 result: String,
3097 },
3098}
3099
3100#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3102pub struct ImageGenerationInputImage {
3103 pub path: AbsolutePathBuf,
3104 pub sha256: String,
3106}
3107
3108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3109#[serde(tag = "type", rename_all = "camelCase")]
3110pub enum ImageGenerationFailure {
3111 #[serde(rename = "usageLimitExceeded")]
3112 UsageLimitExceeded {
3113 #[serde(rename = "limitId")]
3114 limit_id: String,
3115 #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
3116 resets_at: Option<i64>,
3117 },
3118}
3119
3120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3121#[serde(rename_all = "lowercase")]
3122pub enum McpServerOauthClientRegistration {
3123 Auto,
3124 Cimd,
3125 Dcr,
3126}
3127
3128#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3129#[serde(rename_all = "camelCase")]
3130pub struct GetWorkspaceMessagesResponse {
3131 #[serde(rename = "featureEnabled", default)]
3132 pub feature_enabled: bool,
3133 #[serde(default)]
3134 pub messages: Vec<WorkspaceMessage>,
3135}
3136
3137#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3138#[serde(rename_all = "camelCase")]
3139pub struct GitInfo {
3140 #[serde(default, skip_serializing_if = "Option::is_none")]
3141 pub branch: Option<String>,
3142 #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
3143 pub origin_url: Option<String>,
3144 #[serde(default, skip_serializing_if = "Option::is_none")]
3145 pub sha: Option<String>,
3146}
3147
3148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3149#[serde(rename_all = "camelCase")]
3150pub struct GrantedPermissionProfile {
3151 #[serde(
3152 rename = "fileSystem",
3153 default,
3154 skip_serializing_if = "Option::is_none"
3155 )]
3156 pub file_system: Option<AdditionalFileSystemPermissions>,
3157 #[serde(default, skip_serializing_if = "Option::is_none")]
3158 pub network: Option<AdditionalNetworkPermissions>,
3159}
3160
3161#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3162#[serde(rename_all = "camelCase")]
3163pub struct GuardianApprovalReview {
3164 #[serde(default, skip_serializing_if = "Option::is_none")]
3165 pub rationale: Option<String>,
3166 #[serde(rename = "riskLevel", default, skip_serializing_if = "Option::is_none")]
3167 pub risk_level: Option<GuardianRiskLevel>,
3168 #[serde()]
3169 pub status: GuardianApprovalReviewStatus,
3170 #[serde(
3171 rename = "userAuthorization",
3172 default,
3173 skip_serializing_if = "Option::is_none"
3174 )]
3175 pub user_authorization: Option<GuardianUserAuthorization>,
3176}
3177
3178#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3179#[serde(tag = "type", rename_all = "camelCase")]
3180pub enum GuardianApprovalReviewAction {
3181 Command {
3182 command: String,
3183 cwd: LegacyAppPathString,
3184 source: GuardianCommandSource,
3185 },
3186 Execve {
3187 argv: Vec<String>,
3188 cwd: AbsolutePathBuf,
3189 program: String,
3190 source: GuardianCommandSource,
3191 },
3192 #[serde(rename = "writeStdin")]
3193 WriteStdin {
3194 #[serde(rename = "approvalId")]
3195 approval_id: String,
3196 cwd: LegacyAppPathString,
3197 #[serde(rename = "processId")]
3198 process_id: String,
3199 stdin: String,
3200 },
3201 #[serde(rename = "applyPatch")]
3202 ApplyPatch {
3203 cwd: LegacyAppPathString,
3204 files: Vec<LegacyAppPathString>,
3205 },
3206 #[serde(rename = "networkAccess")]
3207 NetworkAccess {
3208 host: String,
3209 port: i64,
3210 protocol: NetworkApprovalProtocol,
3211 target: String,
3212 },
3213 #[serde(rename = "mcpToolCall")]
3214 McpToolCall {
3215 #[serde(
3216 rename = "connectorId",
3217 default,
3218 skip_serializing_if = "Option::is_none"
3219 )]
3220 connector_id: Option<String>,
3221 #[serde(
3222 rename = "connectorName",
3223 default,
3224 skip_serializing_if = "Option::is_none"
3225 )]
3226 connector_name: Option<String>,
3227 server: String,
3228 #[serde(rename = "toolName")]
3229 tool_name: String,
3230 #[serde(rename = "toolTitle", default, skip_serializing_if = "Option::is_none")]
3231 tool_title: Option<String>,
3232 },
3233 #[serde(rename = "requestPermissions")]
3234 RequestPermissions {
3235 permissions: RequestPermissionProfile,
3236 #[serde(default, skip_serializing_if = "Option::is_none")]
3237 reason: Option<String>,
3238 },
3239}
3240
3241#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3242pub enum GuardianApprovalReviewStatus {
3243 #[serde(rename = "inProgress")]
3244 InProgress,
3245 #[serde(rename = "approved")]
3246 Approved,
3247 #[serde(rename = "denied")]
3248 Denied,
3249 #[serde(rename = "timedOut")]
3250 TimedOut,
3251 #[serde(rename = "aborted")]
3252 Aborted,
3253}
3254
3255#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3256pub enum GuardianCommandSource {
3257 #[serde(rename = "shell")]
3258 Shell,
3259 #[serde(rename = "unifiedExec")]
3260 UnifiedExec,
3261}
3262
3263#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3264pub enum GuardianRiskLevel {
3265 #[serde(rename = "low")]
3266 Low,
3267 #[serde(rename = "medium")]
3268 Medium,
3269 #[serde(rename = "high")]
3270 High,
3271 #[serde(rename = "critical")]
3272 Critical,
3273}
3274
3275#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3276pub enum GuardianUserAuthorization {
3277 #[serde(rename = "unknown")]
3278 Unknown,
3279 #[serde(rename = "low")]
3280 Low,
3281 #[serde(rename = "medium")]
3282 Medium,
3283 #[serde(rename = "high")]
3284 High,
3285}
3286
3287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3288#[serde(rename_all = "camelCase")]
3289pub struct GuardianWarningNotification {
3290 #[serde(default)]
3291 pub message: String,
3292 #[serde(rename = "threadId", default)]
3293 pub thread_id: String,
3294}
3295
3296#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3297#[serde(rename_all = "camelCase")]
3298pub struct HookCompletedNotification {
3299 #[serde()]
3300 pub run: HookRunSummary,
3301 #[serde(rename = "threadId", default)]
3302 pub thread_id: String,
3303 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
3304 pub turn_id: Option<String>,
3305}
3306
3307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3308#[serde(rename_all = "camelCase")]
3309pub struct HookErrorInfo {
3310 #[serde(default)]
3311 pub message: String,
3312 #[serde(default)]
3313 pub path: String,
3314}
3315
3316#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3317pub enum HookEventName {
3318 #[serde(rename = "preModelRequest")]
3319 PreModelRequest,
3320 #[serde(rename = "postModelRequest")]
3321 PostModelRequest,
3322 #[serde(rename = "preToolUse")]
3323 PreToolUse,
3324 #[serde(rename = "permissionRequest")]
3325 PermissionRequest,
3326 #[serde(rename = "postToolUse")]
3327 PostToolUse,
3328 #[serde(rename = "preCompact")]
3329 PreCompact,
3330 #[serde(rename = "postCompact")]
3331 PostCompact,
3332 #[serde(rename = "sessionStart")]
3333 SessionStart,
3334 #[serde(rename = "sessionEnd")]
3335 SessionEnd,
3336 #[serde(rename = "userPromptSubmit")]
3337 UserPromptSubmit,
3338 #[serde(rename = "subagentStart")]
3339 SubagentStart,
3340 #[serde(rename = "subagentStop")]
3341 SubagentStop,
3342 #[serde(rename = "stop")]
3343 Stop,
3344 #[serde(rename = "interrupt")]
3345 Interrupt,
3346}
3347
3348#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3349pub enum HookExecutionMode {
3350 #[serde(rename = "sync")]
3351 Sync,
3352 #[serde(rename = "async")]
3353 Async,
3354}
3355
3356#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3357pub enum HookHandlerType {
3358 #[serde(rename = "command")]
3359 Command,
3360 #[serde(rename = "mcpTool")]
3361 McpTool,
3362 #[serde(rename = "prompt")]
3363 Prompt,
3364 #[serde(rename = "agent")]
3365 Agent,
3366}
3367
3368#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3369#[serde(rename_all = "camelCase")]
3370pub struct HookMetadata {
3371 #[serde(
3372 rename = "additionalContextLimit",
3373 default,
3374 skip_serializing_if = "Option::is_none"
3375 )]
3376 pub additional_context_limit: Option<i64>,
3377 #[serde(rename = "async", default, skip_serializing_if = "Option::is_none")]
3378 pub is_async: Option<bool>,
3379 #[serde(default, skip_serializing_if = "Option::is_none")]
3380 pub command: Option<String>,
3381 #[serde(rename = "currentHash", default)]
3382 pub current_hash: String,
3383 #[serde(default, skip_serializing_if = "Option::is_none")]
3385 pub server: Option<String>,
3386 #[serde(default, skip_serializing_if = "Option::is_none")]
3388 pub tool: Option<String>,
3389 #[serde(rename = "displayOrder", default)]
3390 pub display_order: i64,
3391 #[serde(default)]
3392 pub enabled: bool,
3393 #[serde(
3395 rename = "environmentId",
3396 default,
3397 skip_serializing_if = "Option::is_none"
3398 )]
3399 pub environment_id: Option<String>,
3400 #[serde(rename = "eventName")]
3401 pub event_name: HookEventName,
3402 #[serde(
3403 rename = "executionMode",
3404 default,
3405 skip_serializing_if = "Option::is_none"
3406 )]
3407 pub execution_mode: Option<Value>,
3408 #[serde(rename = "handlerType")]
3409 pub handler_type: HookHandlerType,
3410 #[serde(rename = "isManaged", default)]
3411 pub is_managed: bool,
3412 #[serde(default)]
3413 pub key: String,
3414 #[serde(default, skip_serializing_if = "Option::is_none")]
3415 pub matcher: Option<String>,
3416 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
3417 pub plugin_id: Option<String>,
3418 #[serde()]
3419 pub source: HookSource,
3420 #[serde(rename = "sourcePath")]
3421 pub source_path: AbsolutePathBuf,
3422 #[serde(
3423 rename = "statusMessage",
3424 default,
3425 skip_serializing_if = "Option::is_none"
3426 )]
3427 pub status_message: Option<String>,
3428 #[serde(rename = "timeoutSec", default)]
3429 pub timeout_sec: i64,
3430 #[serde(rename = "trustStatus")]
3431 pub trust_status: HookTrustStatus,
3432}
3433
3434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3435#[serde(rename_all = "camelCase")]
3436pub struct HookMigration {
3437 #[serde(default)]
3438 pub name: String,
3439}
3440
3441#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3442#[serde(rename_all = "camelCase")]
3443pub struct HookOutputEntry {
3444 #[serde()]
3445 pub kind: HookOutputEntryKind,
3446 #[serde(default)]
3447 pub text: String,
3448}
3449
3450#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3451pub enum HookOutputEntryKind {
3452 #[serde(rename = "warning")]
3453 Warning,
3454 #[serde(rename = "stop")]
3455 Stop,
3456 #[serde(rename = "feedback")]
3457 Feedback,
3458 #[serde(rename = "context")]
3459 Context,
3460 #[serde(rename = "error")]
3461 Error,
3462}
3463
3464#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3465#[serde(rename_all = "camelCase")]
3466pub struct HookPromptFragment {
3467 #[serde(rename = "hookRunId", default)]
3468 pub hook_run_id: String,
3469 #[serde(default)]
3470 pub text: String,
3471}
3472
3473#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3474pub enum HookRunStatus {
3475 #[serde(rename = "running")]
3476 Running,
3477 #[serde(rename = "completed")]
3478 Completed,
3479 #[serde(rename = "failed")]
3480 Failed,
3481 #[serde(rename = "blocked")]
3482 Blocked,
3483 #[serde(rename = "stopped")]
3484 Stopped,
3485}
3486
3487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3488#[serde(rename_all = "camelCase")]
3489pub struct HookRunSummary {
3490 #[serde(
3491 rename = "completedAt",
3492 default,
3493 skip_serializing_if = "Option::is_none"
3494 )]
3495 pub completed_at: Option<i64>,
3496 #[serde(rename = "displayOrder", default)]
3497 pub display_order: i64,
3498 #[serde(
3499 rename = "durationMs",
3500 default,
3501 skip_serializing_if = "Option::is_none"
3502 )]
3503 pub duration_ms: Option<i64>,
3504 #[serde(default)]
3505 pub entries: Vec<HookOutputEntry>,
3506 #[serde(rename = "eventName")]
3507 pub event_name: HookEventName,
3508 #[serde(rename = "executionMode")]
3509 pub execution_mode: HookExecutionMode,
3510 #[serde(rename = "handlerType")]
3511 pub handler_type: HookHandlerType,
3512 #[serde(default)]
3513 pub id: String,
3514 #[serde()]
3515 pub scope: HookScope,
3516 #[serde(default, skip_serializing_if = "Option::is_none")]
3517 pub source: Option<Value>,
3518 #[serde(rename = "sourcePath")]
3519 pub source_path: LegacyAppPathString,
3520 #[serde(rename = "startedAt", default)]
3521 pub started_at: i64,
3522 #[serde()]
3523 pub status: HookRunStatus,
3524 #[serde(
3525 rename = "statusMessage",
3526 default,
3527 skip_serializing_if = "Option::is_none"
3528 )]
3529 pub status_message: Option<String>,
3530}
3531
3532#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3533pub enum HookScope {
3534 #[serde(rename = "thread")]
3535 Thread,
3536 #[serde(rename = "turn")]
3537 Turn,
3538}
3539
3540#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3541pub enum HookSource {
3542 #[serde(rename = "system")]
3543 System,
3544 #[serde(rename = "user")]
3545 User,
3546 #[serde(rename = "project")]
3547 Project,
3548 #[serde(rename = "mdm")]
3549 Mdm,
3550 #[serde(rename = "sessionFlags")]
3551 SessionFlags,
3552 #[serde(rename = "plugin")]
3553 Plugin,
3554 #[serde(rename = "cloudRequirements")]
3555 CloudRequirements,
3556 #[serde(rename = "cloudManagedConfig")]
3557 CloudManagedConfig,
3558 #[serde(rename = "legacyManagedConfigFile")]
3559 LegacyManagedConfigFile,
3560 #[serde(rename = "legacyManagedConfigMdm")]
3561 LegacyManagedConfigMdm,
3562 #[serde(rename = "unknown")]
3563 Unknown,
3564}
3565
3566#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3567#[serde(rename_all = "camelCase")]
3568pub struct HookStartedNotification {
3569 #[serde()]
3570 pub run: HookRunSummary,
3571 #[serde(rename = "threadId", default)]
3572 pub thread_id: String,
3573 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
3574 pub turn_id: Option<String>,
3575}
3576
3577#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3578pub enum HookTrustStatus {
3579 #[serde(rename = "managed")]
3580 Managed,
3581 #[serde(rename = "untrusted")]
3582 Untrusted,
3583 #[serde(rename = "trusted")]
3584 Trusted,
3585 #[serde(rename = "modified")]
3586 Modified,
3587}
3588
3589#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3590#[serde(rename_all = "camelCase")]
3591pub struct HooksListEntry {
3592 #[serde(default)]
3593 pub cwd: String,
3594 #[serde(default)]
3595 pub errors: Vec<HookErrorInfo>,
3596 #[serde(default)]
3597 pub hooks: Vec<HookMetadata>,
3598 #[serde(default)]
3599 pub warnings: Vec<String>,
3600}
3601
3602#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3603#[serde(rename_all = "camelCase")]
3604pub struct HooksListParams {
3605 #[serde(default, skip_serializing_if = "Option::is_none")]
3607 pub cwds: Option<Vec<String>>,
3608 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3610 pub thread_id: Option<String>,
3611}
3612
3613#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3614#[serde(rename_all = "camelCase")]
3615pub struct HooksListResponse {
3616 #[serde(default)]
3617 pub data: Vec<HooksListEntry>,
3618}
3619
3620#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3621pub enum ImageDetail {
3622 #[serde(rename = "auto")]
3623 Auto,
3624 #[serde(rename = "low")]
3625 Low,
3626 #[serde(rename = "high")]
3627 High,
3628 #[serde(rename = "original")]
3629 Original,
3630}
3631
3632#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3633#[serde(rename_all = "camelCase")]
3634pub struct InitializeCapabilities {
3635 #[serde(
3636 rename = "experimentalApi",
3637 default,
3638 skip_serializing_if = "Option::is_none"
3639 )]
3640 pub experimental_api: Option<bool>,
3641 #[serde(
3645 rename = "explicitGatewayOauth",
3646 default,
3647 skip_serializing_if = "Option::is_none"
3648 )]
3649 pub explicit_gateway_oauth: Option<bool>,
3650 #[serde(default, skip_serializing_if = "Option::is_none")]
3651 pub extensions: Option<Value>,
3652 #[serde(
3653 rename = "mcpServerOpenaiFormElicitation",
3654 default,
3655 skip_serializing_if = "Option::is_none"
3656 )]
3657 pub mcp_server_openai_form_elicitation: Option<bool>,
3658 #[serde(
3659 rename = "optOutNotificationMethods",
3660 default,
3661 skip_serializing_if = "Option::is_none"
3662 )]
3663 pub opt_out_notification_methods: Option<Vec<String>>,
3664 #[serde(
3665 rename = "requestAttestation",
3666 default,
3667 skip_serializing_if = "Option::is_none"
3668 )]
3669 pub request_attestation: Option<bool>,
3670 #[serde(
3674 rename = "requiredHumanApproval",
3675 default,
3676 skip_serializing_if = "Option::is_none"
3677 )]
3678 pub required_human_approval: Option<bool>,
3679}
3680
3681#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3682#[serde(rename_all = "camelCase")]
3683pub struct InitializeParams {
3684 #[serde(default, skip_serializing_if = "Option::is_none")]
3685 pub capabilities: Option<InitializeCapabilities>,
3686 #[serde(rename = "clientInfo")]
3687 pub client_info: ClientInfo,
3688}
3689
3690#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3691#[serde(rename_all = "camelCase")]
3692pub struct InitializeResponse {
3693 #[serde(rename = "codexHome", default)]
3694 pub codex_home: Value,
3695 #[serde(rename = "platformFamily", default)]
3696 pub platform_family: String,
3697 #[serde(rename = "platformOs", default)]
3698 pub platform_os: String,
3699 #[serde(rename = "userAgent", default)]
3700 pub user_agent: String,
3701}
3702
3703#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
3704pub enum InputModality {
3705 #[serde(rename = "text")]
3706 Text,
3707 #[serde(rename = "image")]
3708 Image,
3709 #[serde(rename = "audio")]
3710 Audio,
3711}
3712
3713#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3714#[serde(rename_all = "camelCase")]
3715pub struct InstalledApp {
3716 #[serde(default)]
3717 pub callable: bool,
3718 #[serde(default)]
3719 pub enabled: bool,
3720 #[serde(default)]
3721 pub id: String,
3722 #[serde(
3723 rename = "runtimeName",
3724 default,
3725 skip_serializing_if = "Option::is_none"
3726 )]
3727 pub runtime_name: Option<String>,
3728}
3729
3730#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3731#[serde(rename_all = "camelCase")]
3732pub struct ItemCompletedNotification {
3733 #[serde(rename = "completedAtMs", default)]
3734 pub completed_at_ms: i64,
3735 #[serde(
3739 rename = "contentTokenCount",
3740 default,
3741 skip_serializing_if = "Option::is_none"
3742 )]
3743 pub content_token_count: Option<i64>,
3744 #[serde()]
3745 pub item: ThreadItem,
3746 #[serde(rename = "threadId", default)]
3747 pub thread_id: String,
3748 #[serde(rename = "turnId", default)]
3749 pub turn_id: String,
3750}
3751
3752#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3753#[serde(rename_all = "camelCase")]
3754pub struct ItemGuardianApprovalReviewCompletedNotification {
3755 #[serde()]
3756 pub action: GuardianApprovalReviewAction,
3757 #[serde(rename = "completedAtMs", default)]
3758 pub completed_at_ms: i64,
3759 #[serde(rename = "decisionSource")]
3760 pub decision_source: AutoReviewDecisionSource,
3761 #[serde()]
3762 pub review: GuardianApprovalReview,
3763 #[serde(rename = "reviewId", default)]
3764 pub review_id: String,
3765 #[serde(rename = "startedAtMs", default)]
3766 pub started_at_ms: i64,
3767 #[serde(
3768 rename = "targetItemId",
3769 default,
3770 skip_serializing_if = "Option::is_none"
3771 )]
3772 pub target_item_id: Option<String>,
3773 #[serde(rename = "threadId", default)]
3774 pub thread_id: String,
3775 #[serde(rename = "turnId", default)]
3776 pub turn_id: String,
3777}
3778
3779#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3780#[serde(rename_all = "camelCase")]
3781pub struct ItemGuardianApprovalReviewStartedNotification {
3782 #[serde()]
3783 pub action: GuardianApprovalReviewAction,
3784 #[serde()]
3785 pub review: GuardianApprovalReview,
3786 #[serde(rename = "reviewId", default)]
3787 pub review_id: String,
3788 #[serde(rename = "startedAtMs", default)]
3789 pub started_at_ms: i64,
3790 #[serde(
3791 rename = "targetItemId",
3792 default,
3793 skip_serializing_if = "Option::is_none"
3794 )]
3795 pub target_item_id: Option<String>,
3796 #[serde(rename = "threadId", default)]
3797 pub thread_id: String,
3798 #[serde(rename = "turnId", default)]
3799 pub turn_id: String,
3800}
3801
3802#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3803#[serde(rename_all = "camelCase")]
3804pub struct ItemStartedNotification {
3805 #[serde()]
3806 pub item: ThreadItem,
3807 #[serde(rename = "startedAtMs", default)]
3808 pub started_at_ms: i64,
3809 #[serde(rename = "threadId", default)]
3810 pub thread_id: String,
3811 #[serde(rename = "turnId", default)]
3812 pub turn_id: String,
3813}
3814
3815#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3816#[serde(rename_all = "camelCase")]
3817pub struct JSONRPCResponse {
3818 #[serde()]
3819 pub id: RequestId,
3820 #[serde(default)]
3821 pub result: Value,
3822}
3823
3824#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
3825#[serde(transparent)]
3826pub struct LegacyAppPathString(pub String);
3827
3828#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3829#[serde(rename_all = "camelCase")]
3830pub struct ListMcpServerStatusParams {
3831 #[serde(default, skip_serializing_if = "Option::is_none")]
3832 pub cursor: Option<String>,
3833 #[serde(default, skip_serializing_if = "Option::is_none")]
3834 pub detail: Option<McpServerStatusDetail>,
3835 #[serde(default, skip_serializing_if = "Option::is_none")]
3836 pub limit: Option<i64>,
3837 #[serde(
3840 rename = "serverName",
3841 default,
3842 skip_serializing_if = "Option::is_none"
3843 )]
3844 pub server_name: Option<String>,
3845 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
3846 pub thread_id: Option<String>,
3847}
3848
3849#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3850#[serde(rename_all = "camelCase")]
3851pub struct ListMcpServerStatusResponse {
3852 #[serde(default)]
3853 pub data: Vec<McpServerStatus>,
3854 #[serde(
3855 rename = "nextCursor",
3856 default,
3857 skip_serializing_if = "Option::is_none"
3858 )]
3859 pub next_cursor: Option<String>,
3860}
3861
3862#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3863#[serde(tag = "type", rename_all = "camelCase")]
3864pub enum LoginAccountParams {
3865 #[serde(rename = "apiKey")]
3866 ApiKey {
3867 #[serde(rename = "apiKey")]
3868 api_key: String,
3869 },
3870 Chatgpt {
3871 #[serde(rename = "appBrand", default, skip_serializing_if = "Option::is_none")]
3872 app_brand: Option<LoginAppBrand>,
3873 #[serde(
3874 rename = "codexStreamlinedLogin",
3875 default,
3876 skip_serializing_if = "Option::is_none"
3877 )]
3878 codex_streamlined_login: Option<bool>,
3879 #[serde(
3880 rename = "useHostedLoginSuccessPage",
3881 default,
3882 skip_serializing_if = "Option::is_none"
3883 )]
3884 use_hosted_login_success_page: Option<bool>,
3885 },
3886 #[serde(rename = "chatgptDeviceCode")]
3887 ChatgptDeviceCode,
3888 #[serde(rename = "chatgptAuthTokens")]
3889 ChatgptAuthTokens {
3890 #[serde(rename = "accessToken")]
3891 access_token: String,
3892 #[serde(rename = "chatgptAccountId")]
3893 chatgpt_account_id: String,
3894 #[serde(
3895 rename = "chatgptPlanType",
3896 default,
3897 skip_serializing_if = "Option::is_none"
3898 )]
3899 chatgpt_plan_type: Option<String>,
3900 },
3901 #[serde(rename = "amazonBedrock")]
3902 AmazonBedrock {
3903 #[serde(rename = "apiKey")]
3904 api_key: String,
3905 region: String,
3906 },
3907 #[serde(rename = "amazonBedrockAccessKeys")]
3908 AmazonBedrockAccessKeys {
3909 #[serde(rename = "accessKeyId")]
3910 access_key_id: String,
3911 region: String,
3912 #[serde(rename = "secretAccessKey")]
3913 secret_access_key: String,
3914 #[serde(
3915 rename = "sessionToken",
3916 default,
3917 skip_serializing_if = "Option::is_none"
3918 )]
3919 session_token: Option<String>,
3920 },
3921}
3922
3923#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3924#[serde(tag = "type", rename_all = "camelCase")]
3925pub enum LoginAccountResponse {
3926 #[serde(rename = "apiKey")]
3927 ApiKey,
3928 Chatgpt {
3929 #[serde(rename = "authUrl")]
3930 auth_url: String,
3931 #[serde(rename = "loginId")]
3932 login_id: String,
3933 },
3934 #[serde(rename = "chatgptDeviceCode")]
3935 ChatgptDeviceCode {
3936 #[serde(rename = "loginId")]
3937 login_id: String,
3938 #[serde(rename = "userCode")]
3939 user_code: String,
3940 #[serde(rename = "verificationUrl")]
3941 verification_url: String,
3942 },
3943 #[serde(rename = "chatgptAuthTokens")]
3944 ChatgptAuthTokens,
3945 #[serde(rename = "amazonBedrock")]
3946 AmazonBedrock,
3947}
3948
3949#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3950pub enum LoginAppBrand {
3951 #[serde(rename = "codex")]
3952 Codex,
3953 #[serde(rename = "chatgpt")]
3954 Chatgpt,
3955}
3956
3957#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3958#[serde(rename_all = "camelCase")]
3959pub struct LogoutAccountResponse {
3960 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
3961 pub extra: serde_json::Map<String, Value>,
3962}
3963
3964#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3965#[serde(rename_all = "camelCase")]
3966pub struct MarketplaceAddParams {
3967 #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
3968 pub ref_name: Option<String>,
3969 #[serde(default)]
3970 pub source: String,
3971 #[serde(
3972 rename = "sparsePaths",
3973 default,
3974 skip_serializing_if = "Option::is_none"
3975 )]
3976 pub sparse_paths: Option<Vec<String>>,
3977}
3978
3979#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3980#[serde(rename_all = "camelCase")]
3981pub struct MarketplaceAddResponse {
3982 #[serde(rename = "alreadyAdded", default)]
3983 pub already_added: bool,
3984 #[serde(rename = "installedRoot")]
3985 pub installed_root: AbsolutePathBuf,
3986 #[serde(rename = "marketplaceName", default)]
3987 pub marketplace_name: String,
3988}
3989
3990#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
3991#[serde(rename_all = "camelCase")]
3992pub struct MarketplaceInterface {
3993 #[serde(
3994 rename = "displayName",
3995 default,
3996 skip_serializing_if = "Option::is_none"
3997 )]
3998 pub display_name: Option<String>,
3999}
4000
4001#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4002#[serde(rename_all = "camelCase")]
4003pub struct MarketplaceLoadErrorInfo {
4004 #[serde(rename = "marketplacePath")]
4005 pub marketplace_path: AbsolutePathBuf,
4006 #[serde(default)]
4007 pub message: String,
4008}
4009
4010#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4011#[serde(rename_all = "camelCase")]
4012pub struct MarketplaceRemoveParams {
4013 #[serde(rename = "marketplaceName", default)]
4014 pub marketplace_name: String,
4015}
4016
4017#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4018#[serde(rename_all = "camelCase")]
4019pub struct MarketplaceRemoveResponse {
4020 #[serde(
4021 rename = "installedRoot",
4022 default,
4023 skip_serializing_if = "Option::is_none"
4024 )]
4025 pub installed_root: Option<AbsolutePathBuf>,
4026 #[serde(rename = "marketplaceName", default)]
4027 pub marketplace_name: String,
4028}
4029
4030#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4031#[serde(rename_all = "camelCase")]
4032pub struct MarketplaceUpgradeErrorInfo {
4033 #[serde(rename = "marketplaceName", default)]
4034 pub marketplace_name: String,
4035 #[serde(default)]
4036 pub message: String,
4037}
4038
4039#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4040#[serde(rename_all = "camelCase")]
4041pub struct MarketplaceUpgradeParams {
4042 #[serde(
4043 rename = "marketplaceName",
4044 default,
4045 skip_serializing_if = "Option::is_none"
4046 )]
4047 pub marketplace_name: Option<String>,
4048}
4049
4050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4051#[serde(rename_all = "camelCase")]
4052pub struct MarketplaceUpgradeResponse {
4053 #[serde(default)]
4054 pub errors: Vec<MarketplaceUpgradeErrorInfo>,
4055 #[serde(rename = "selectedMarketplaces", default)]
4056 pub selected_marketplaces: Vec<String>,
4057 #[serde(rename = "upgradedRoots", default)]
4058 pub upgraded_roots: Vec<AbsolutePathBuf>,
4059}
4060
4061#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4062pub enum McpAuthStatus {
4063 #[serde(rename = "unknown")]
4064 Unknown,
4065 #[serde(rename = "unsupported")]
4066 Unsupported,
4067 #[serde(rename = "notLoggedIn")]
4068 NotLoggedIn,
4069 #[serde(rename = "bearerToken")]
4070 BearerToken,
4071 #[serde(rename = "oAuth")]
4072 OAuth,
4073}
4074
4075#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4076pub enum McpElicitationArrayType {
4077 #[serde(rename = "array")]
4078 Array,
4079}
4080
4081#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4082#[serde(rename_all = "camelCase")]
4083pub struct McpElicitationBooleanSchema {
4084 #[serde(default, skip_serializing_if = "Option::is_none")]
4085 pub default: Option<bool>,
4086 #[serde(default, skip_serializing_if = "Option::is_none")]
4087 pub description: Option<String>,
4088 #[serde(default, skip_serializing_if = "Option::is_none")]
4089 pub title: Option<String>,
4090 #[serde(rename = "type")]
4091 pub type_: McpElicitationBooleanType,
4092}
4093
4094#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4095pub enum McpElicitationBooleanType {
4096 #[serde(rename = "boolean")]
4097 Boolean,
4098}
4099
4100#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4101#[serde(rename_all = "camelCase")]
4102pub struct McpElicitationConstOption {
4103 #[serde(rename = "const", default)]
4104 pub const_: String,
4105 #[serde(default)]
4106 pub title: String,
4107}
4108
4109#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4110#[serde(untagged)]
4111pub enum McpElicitationEnumSchema {
4112 McpElicitationSingleSelectEnumSchema(McpElicitationSingleSelectEnumSchema),
4113 McpElicitationMultiSelectEnumSchema(McpElicitationMultiSelectEnumSchema),
4114 McpElicitationLegacyTitledEnumSchema(McpElicitationLegacyTitledEnumSchema),
4115}
4116
4117#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4118#[serde(rename_all = "camelCase")]
4119pub struct McpElicitationLegacyTitledEnumSchema {
4120 #[serde(default, skip_serializing_if = "Option::is_none")]
4121 pub default: Option<String>,
4122 #[serde(default, skip_serializing_if = "Option::is_none")]
4123 pub description: Option<String>,
4124 #[serde(rename = "enum", default)]
4125 pub enum_: Vec<String>,
4126 #[serde(rename = "enumNames", default, skip_serializing_if = "Option::is_none")]
4127 pub enum_names: Option<Vec<String>>,
4128 #[serde(default, skip_serializing_if = "Option::is_none")]
4129 pub title: Option<String>,
4130 #[serde(rename = "type")]
4131 pub type_: McpElicitationStringType,
4132}
4133
4134#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4135#[serde(untagged)]
4136pub enum McpElicitationMultiSelectEnumSchema {
4137 McpElicitationUntitledMultiSelectEnumSchema(McpElicitationUntitledMultiSelectEnumSchema),
4138 McpElicitationTitledMultiSelectEnumSchema(McpElicitationTitledMultiSelectEnumSchema),
4139}
4140
4141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4142#[serde(rename_all = "camelCase")]
4143pub struct McpElicitationNumberSchema {
4144 #[serde(default, skip_serializing_if = "Option::is_none")]
4145 pub default: Option<f64>,
4146 #[serde(default, skip_serializing_if = "Option::is_none")]
4147 pub description: Option<String>,
4148 #[serde(default, skip_serializing_if = "Option::is_none")]
4149 pub maximum: Option<f64>,
4150 #[serde(default, skip_serializing_if = "Option::is_none")]
4151 pub minimum: Option<f64>,
4152 #[serde(default, skip_serializing_if = "Option::is_none")]
4153 pub title: Option<String>,
4154 #[serde(rename = "type")]
4155 pub type_: McpElicitationNumberType,
4156}
4157
4158#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4159pub enum McpElicitationNumberType {
4160 #[serde(rename = "number")]
4161 Number,
4162 #[serde(rename = "integer")]
4163 Integer,
4164}
4165
4166#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4167pub enum McpElicitationObjectType {
4168 #[serde(rename = "object")]
4169 Object,
4170}
4171
4172#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4173#[serde(untagged)]
4174pub enum McpElicitationPrimitiveSchema {
4175 McpElicitationEnumSchema(McpElicitationEnumSchema),
4176 McpElicitationStringSchema(McpElicitationStringSchema),
4177 McpElicitationNumberSchema(McpElicitationNumberSchema),
4178 McpElicitationBooleanSchema(McpElicitationBooleanSchema),
4179}
4180
4181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4182#[serde(rename_all = "camelCase")]
4183pub struct McpElicitationSchema {
4184 #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
4185 pub schema: Option<String>,
4186 #[serde(default)]
4187 pub properties: std::collections::BTreeMap<String, McpElicitationPrimitiveSchema>,
4188 #[serde(default, skip_serializing_if = "Option::is_none")]
4189 pub required: Option<Vec<String>>,
4190 #[serde(rename = "type")]
4191 pub type_: McpElicitationObjectType,
4192}
4193
4194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4195#[serde(untagged)]
4196pub enum McpElicitationSingleSelectEnumSchema {
4197 McpElicitationUntitledSingleSelectEnumSchema(McpElicitationUntitledSingleSelectEnumSchema),
4198 McpElicitationTitledSingleSelectEnumSchema(McpElicitationTitledSingleSelectEnumSchema),
4199}
4200
4201#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4202pub enum McpElicitationStringFormat {
4203 #[serde(rename = "email")]
4204 Email,
4205 #[serde(rename = "uri")]
4206 Uri,
4207 #[serde(rename = "date")]
4208 Date,
4209 #[serde(rename = "date-time")]
4210 Date_time,
4211}
4212
4213#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4214#[serde(rename_all = "camelCase")]
4215pub struct McpElicitationStringSchema {
4216 #[serde(default, skip_serializing_if = "Option::is_none")]
4217 pub default: Option<String>,
4218 #[serde(default, skip_serializing_if = "Option::is_none")]
4219 pub description: Option<String>,
4220 #[serde(default, skip_serializing_if = "Option::is_none")]
4221 pub format: Option<McpElicitationStringFormat>,
4222 #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
4223 pub max_length: Option<i64>,
4224 #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
4225 pub min_length: Option<i64>,
4226 #[serde(default, skip_serializing_if = "Option::is_none")]
4227 pub title: Option<String>,
4228 #[serde(rename = "type")]
4229 pub type_: McpElicitationStringType,
4230}
4231
4232#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4233pub enum McpElicitationStringType {
4234 #[serde(rename = "string")]
4235 String,
4236}
4237
4238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4239#[serde(rename_all = "camelCase")]
4240pub struct McpElicitationTitledEnumItems {
4241 #[serde(rename = "anyOf", default)]
4242 pub any_of: Vec<McpElicitationConstOption>,
4243}
4244
4245#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4246#[serde(rename_all = "camelCase")]
4247pub struct McpElicitationTitledMultiSelectEnumSchema {
4248 #[serde(default, skip_serializing_if = "Option::is_none")]
4249 pub default: Option<Vec<String>>,
4250 #[serde(default, skip_serializing_if = "Option::is_none")]
4251 pub description: Option<String>,
4252 #[serde()]
4253 pub items: McpElicitationTitledEnumItems,
4254 #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4255 pub max_items: Option<i64>,
4256 #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4257 pub min_items: Option<i64>,
4258 #[serde(default, skip_serializing_if = "Option::is_none")]
4259 pub title: Option<String>,
4260 #[serde(rename = "type")]
4261 pub type_: McpElicitationArrayType,
4262}
4263
4264#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4265#[serde(rename_all = "camelCase")]
4266pub struct McpElicitationTitledSingleSelectEnumSchema {
4267 #[serde(default, skip_serializing_if = "Option::is_none")]
4268 pub default: Option<String>,
4269 #[serde(default, skip_serializing_if = "Option::is_none")]
4270 pub description: Option<String>,
4271 #[serde(rename = "oneOf", default)]
4272 pub one_of: Vec<McpElicitationConstOption>,
4273 #[serde(default, skip_serializing_if = "Option::is_none")]
4274 pub title: Option<String>,
4275 #[serde(rename = "type")]
4276 pub type_: McpElicitationStringType,
4277}
4278
4279#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4280#[serde(rename_all = "camelCase")]
4281pub struct McpElicitationUntitledEnumItems {
4282 #[serde(rename = "enum", default)]
4283 pub enum_: Vec<String>,
4284 #[serde(rename = "type")]
4285 pub type_: McpElicitationStringType,
4286}
4287
4288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4289#[serde(rename_all = "camelCase")]
4290pub struct McpElicitationUntitledMultiSelectEnumSchema {
4291 #[serde(default, skip_serializing_if = "Option::is_none")]
4292 pub default: Option<Vec<String>>,
4293 #[serde(default, skip_serializing_if = "Option::is_none")]
4294 pub description: Option<String>,
4295 #[serde()]
4296 pub items: McpElicitationUntitledEnumItems,
4297 #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
4298 pub max_items: Option<i64>,
4299 #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
4300 pub min_items: Option<i64>,
4301 #[serde(default, skip_serializing_if = "Option::is_none")]
4302 pub title: Option<String>,
4303 #[serde(rename = "type")]
4304 pub type_: McpElicitationArrayType,
4305}
4306
4307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4308#[serde(rename_all = "camelCase")]
4309pub struct McpElicitationUntitledSingleSelectEnumSchema {
4310 #[serde(default, skip_serializing_if = "Option::is_none")]
4311 pub default: Option<String>,
4312 #[serde(default, skip_serializing_if = "Option::is_none")]
4313 pub description: Option<String>,
4314 #[serde(rename = "enum", default)]
4315 pub enum_: Vec<String>,
4316 #[serde(default, skip_serializing_if = "Option::is_none")]
4317 pub title: Option<String>,
4318 #[serde(rename = "type")]
4319 pub type_: McpElicitationStringType,
4320}
4321
4322#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4323#[serde(rename_all = "camelCase")]
4324pub struct McpResourceReadParams {
4325 #[serde(rename = "_meta", default, skip_serializing_if = "Option::is_none")]
4327 pub meta: Option<serde_json::Map<String, Value>>,
4328 #[serde(
4329 rename = "connectorId",
4330 default,
4331 skip_serializing_if = "Option::is_none"
4332 )]
4333 pub connector_id: Option<String>,
4334 #[serde(
4336 rename = "originCallId",
4337 default,
4338 skip_serializing_if = "Option::is_none"
4339 )]
4340 pub origin_call_id: Option<String>,
4341 #[serde(default)]
4342 pub server: String,
4343 #[serde(default, skip_serializing_if = "Option::is_none")]
4345 pub target: Option<McpResourceReadTarget>,
4346 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4347 pub thread_id: Option<String>,
4348 #[serde(default)]
4349 pub uri: String,
4350}
4351
4352#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4354#[serde(rename_all = "camelCase")]
4355pub struct McpResourceReadTarget {
4356 #[serde(rename = "connectorId", default)]
4357 pub connector_id: String,
4358 #[serde(rename = "linkId", default)]
4361 pub link_id: Option<String>,
4362}
4363
4364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4365#[serde(rename_all = "camelCase")]
4366pub struct McpResourceReadResponse {
4367 #[serde(default)]
4368 pub contents: Vec<ResourceContent>,
4369 #[serde(
4372 rename = "originCallId",
4373 default,
4374 skip_serializing_if = "Option::is_none"
4375 )]
4376 pub origin_call_id: Option<String>,
4377}
4378
4379#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4380pub enum McpServerElicitationAction {
4381 #[serde(rename = "accept")]
4382 Accept,
4383 #[serde(rename = "decline")]
4384 Decline,
4385 #[serde(rename = "cancel")]
4386 Cancel,
4387}
4388
4389#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4390#[serde(tag = "mode", rename_all = "camelCase")]
4391pub enum McpServerElicitationRequestParams {
4392 Form {
4393 #[serde(default, skip_serializing_if = "Option::is_none")]
4394 _meta: Option<Value>,
4395 message: String,
4396 #[serde(rename = "requestedSchema")]
4397 requested_schema: McpElicitationSchema,
4398 },
4399 #[serde(rename = "openai/form")]
4400 OpenaiForm {
4401 #[serde(default, skip_serializing_if = "Option::is_none")]
4402 _meta: Option<Value>,
4403 message: String,
4404 #[serde(rename = "requestedSchema")]
4405 requested_schema: Value,
4406 },
4407 #[serde(rename = "openaiForm")]
4408 OpenAiElicitationForm {
4409 #[serde(default, skip_serializing_if = "Option::is_none")]
4410 _meta: Option<Value>,
4411 message: String,
4412 #[serde(rename = "requestedSchema")]
4413 requested_schema: Value,
4414 },
4415 Url {
4416 #[serde(default, skip_serializing_if = "Option::is_none")]
4417 _meta: Option<Value>,
4418 #[serde(rename = "elicitationId")]
4419 elicitation_id: String,
4420 message: String,
4421 url: String,
4422 },
4423}
4424
4425#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4426#[serde(rename_all = "camelCase")]
4427pub struct McpServerElicitationRequestResponse {
4428 #[serde(default, skip_serializing_if = "Option::is_none")]
4429 pub _meta: Option<Value>,
4430 #[serde()]
4431 pub action: McpServerElicitationAction,
4432 #[serde(default, skip_serializing_if = "Option::is_none")]
4433 pub content: Option<Value>,
4434}
4435
4436#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4437#[serde(rename_all = "camelCase")]
4438pub struct McpServerInfo {
4439 #[serde(default, skip_serializing_if = "Option::is_none")]
4440 pub description: Option<String>,
4441 #[serde(default, skip_serializing_if = "Option::is_none")]
4442 pub icons: Option<Vec<Value>>,
4443 #[serde(default)]
4444 pub name: String,
4445 #[serde(default, skip_serializing_if = "Option::is_none")]
4446 pub title: Option<String>,
4447 #[serde(default)]
4448 pub version: String,
4449 #[serde(
4450 rename = "websiteUrl",
4451 default,
4452 skip_serializing_if = "Option::is_none"
4453 )]
4454 pub website_url: Option<String>,
4455}
4456
4457#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4458#[serde(rename_all = "camelCase")]
4459pub struct McpServerMigration {
4460 #[serde(default)]
4461 pub name: String,
4462}
4463
4464#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4465#[serde(rename_all = "camelCase")]
4466pub struct McpServerOauthLoginCompletedNotification {
4467 #[serde(default, skip_serializing_if = "Option::is_none")]
4468 pub error: Option<String>,
4469 #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4471 pub login_id: Option<String>,
4472 #[serde(default)]
4473 pub name: String,
4474 #[serde(default)]
4475 pub success: bool,
4476 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4477 pub thread_id: Option<String>,
4478}
4479
4480#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4481#[serde(rename_all = "camelCase")]
4482pub struct McpServerOauthLoginParams {
4483 #[serde(
4484 rename = "clientRegistration",
4485 default,
4486 skip_serializing_if = "Option::is_none"
4487 )]
4488 pub client_registration: Option<McpServerOauthClientRegistration>,
4489 #[serde(default)]
4490 pub name: String,
4491 #[serde(default, skip_serializing_if = "Option::is_none")]
4492 pub scopes: Option<Vec<String>>,
4493 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4494 pub thread_id: Option<String>,
4495 #[serde(
4496 rename = "timeoutSecs",
4497 default,
4498 skip_serializing_if = "Option::is_none"
4499 )]
4500 pub timeout_secs: Option<i64>,
4501}
4502
4503#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4504#[serde(rename_all = "camelCase")]
4505pub struct McpServerOauthLoginResponse {
4506 #[serde(rename = "authorizationUrl", default)]
4507 pub authorization_url: String,
4508 #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
4512 pub login_id: Option<String>,
4513}
4514
4515#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4516#[serde(rename_all = "camelCase")]
4517pub struct McpServerRefreshResponse {
4518 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4519 pub extra: serde_json::Map<String, Value>,
4520}
4521
4522#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4523pub enum McpServerStartupFailureReason {
4524 #[serde(rename = "reauthenticationRequired")]
4525 ReauthenticationRequired,
4526}
4527
4528#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4529pub enum McpServerStartupState {
4530 #[serde(rename = "starting")]
4531 Starting,
4532 #[serde(rename = "ready")]
4533 Ready,
4534 #[serde(rename = "failed")]
4535 Failed,
4536 #[serde(rename = "cancelled")]
4537 Cancelled,
4538}
4539
4540#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4541#[serde(rename_all = "camelCase")]
4542pub struct McpServerStatus {
4543 #[serde(rename = "authStatus")]
4544 pub auth_status: McpAuthStatus,
4545 #[serde(
4549 rename = "httpOrigin",
4550 default,
4551 skip_serializing_if = "Option::is_none"
4552 )]
4553 pub http_origin: Option<String>,
4554 #[serde(
4556 rename = "runtimeStatus",
4557 default,
4558 skip_serializing_if = "Option::is_none"
4559 )]
4560 pub runtime_status: Option<McpServerConnectionStatus>,
4561 #[serde(default)]
4562 pub name: String,
4563 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
4564 pub plugin_id: Option<String>,
4565 #[serde(rename = "resourceTemplates", default)]
4566 pub resource_templates: Vec<ResourceTemplate>,
4567 #[serde(default)]
4568 pub resources: Vec<Resource>,
4569 #[serde(
4572 rename = "serverCapabilities",
4573 default,
4574 skip_serializing_if = "Option::is_none"
4575 )]
4576 pub server_capabilities: Option<Value>,
4577 #[serde(
4578 rename = "serverInfo",
4579 default,
4580 skip_serializing_if = "Option::is_none"
4581 )]
4582 pub server_info: Option<McpServerInfo>,
4583 #[serde(
4586 rename = "toolListMeta",
4587 default,
4588 skip_serializing_if = "Option::is_none"
4589 )]
4590 pub tool_list_meta: Option<Value>,
4591 #[serde(default)]
4592 pub tools: std::collections::BTreeMap<String, Tool>,
4593 #[serde(
4596 rename = "toolsError",
4597 default,
4598 skip_serializing_if = "Option::is_none"
4599 )]
4600 pub tools_error: Option<String>,
4601}
4602
4603#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4604pub enum McpServerStatusDetail {
4605 #[serde(rename = "full")]
4606 Full,
4607 #[serde(rename = "toolsAndAuthOnly")]
4608 ToolsAndAuthOnly,
4609}
4610
4611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4612#[serde(rename_all = "camelCase")]
4613pub struct McpServerStatusUpdatedNotification {
4614 #[serde(default, skip_serializing_if = "Option::is_none")]
4615 pub error: Option<String>,
4616 #[serde(
4617 rename = "failureReason",
4618 default,
4619 skip_serializing_if = "Option::is_none"
4620 )]
4621 pub failure_reason: Option<McpServerStartupFailureReason>,
4622 #[serde(default)]
4623 pub name: String,
4624 #[serde()]
4625 pub status: McpServerStartupState,
4626 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
4627 pub thread_id: Option<String>,
4628}
4629
4630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4631#[serde(rename_all = "camelCase")]
4632pub struct McpServerToolCallParams {
4633 #[serde(default, skip_serializing_if = "Option::is_none")]
4634 pub _meta: Option<Value>,
4635 #[serde(default, skip_serializing_if = "Option::is_none")]
4636 pub arguments: Option<Value>,
4637 #[serde(default)]
4638 pub server: String,
4639 #[serde(rename = "threadId", default)]
4640 pub thread_id: String,
4641 #[serde(default)]
4642 pub tool: String,
4643}
4644
4645#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4646#[serde(rename_all = "camelCase")]
4647pub struct McpServerToolCallResponse {
4648 #[serde(default, skip_serializing_if = "Option::is_none")]
4649 pub _meta: Option<Value>,
4650 #[serde(default)]
4651 pub content: Vec<Value>,
4652 #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
4653 pub is_error: Option<bool>,
4654 #[serde(
4655 rename = "structuredContent",
4656 default,
4657 skip_serializing_if = "Option::is_none"
4658 )]
4659 pub structured_content: Option<Value>,
4660}
4661
4662#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
4665#[serde(rename_all = "camelCase")]
4666pub struct McpAppUi {
4667 #[serde(rename = "resourceUri")]
4668 pub resource_uri: String,
4669 #[serde(rename = "preferredModelDisplayMode")]
4670 pub preferred_model_display_mode: McpAppDisplayMode,
4671}
4672
4673#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4674pub enum McpAppDisplayMode {
4675 #[serde(rename = "inline")]
4676 Inline,
4677 #[serde(rename = "fullscreen")]
4678 Fullscreen,
4679}
4680
4681#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4682#[serde(rename_all = "camelCase")]
4683pub struct McpToolCallAppContext {
4684 #[serde(
4685 rename = "actionName",
4686 default,
4687 skip_serializing_if = "Option::is_none"
4688 )]
4689 pub action_name: Option<String>,
4690 #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
4691 pub app_name: Option<String>,
4692 #[serde(rename = "connectorId", default)]
4693 pub connector_id: String,
4694 #[serde(rename = "linkId", default, skip_serializing_if = "Option::is_none")]
4695 pub link_id: Option<String>,
4696 #[serde(
4697 rename = "resourceUri",
4698 default,
4699 skip_serializing_if = "Option::is_none"
4700 )]
4701 pub resource_uri: Option<String>,
4702}
4703
4704#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4705#[serde(rename_all = "camelCase")]
4706pub struct McpToolCallError {
4707 #[serde(default)]
4708 pub message: String,
4709}
4710
4711#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4712#[serde(rename_all = "camelCase")]
4713pub struct McpToolCallProgressNotification {
4714 #[serde(rename = "itemId", default)]
4715 pub item_id: String,
4716 #[serde(default)]
4717 pub message: String,
4718 #[serde(rename = "threadId", default)]
4719 pub thread_id: String,
4720 #[serde(rename = "turnId", default)]
4721 pub turn_id: String,
4722}
4723
4724#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4725#[serde(rename_all = "camelCase")]
4726pub struct McpToolCallResult {
4727 #[serde(default, skip_serializing_if = "Option::is_none")]
4728 pub _meta: Option<Value>,
4729 #[serde(default)]
4730 pub content: Vec<Value>,
4731 #[serde(
4732 rename = "structuredContent",
4733 default,
4734 skip_serializing_if = "Option::is_none"
4735 )]
4736 pub structured_content: Option<Value>,
4737}
4738
4739#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4740pub enum McpToolCallStatus {
4741 #[serde(rename = "inProgress")]
4742 InProgress,
4743 #[serde(rename = "completed")]
4744 Completed,
4745 #[serde(rename = "failed")]
4746 Failed,
4747}
4748
4749#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4750#[serde(rename_all = "camelCase")]
4751pub struct MemoryCitation {
4752 #[serde(default)]
4753 pub entries: Vec<MemoryCitationEntry>,
4754 #[serde(rename = "threadIds", default)]
4755 pub thread_ids: Vec<String>,
4756}
4757
4758#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4759#[serde(rename_all = "camelCase")]
4760pub struct MemoryCitationEntry {
4761 #[serde(rename = "lineEnd", default)]
4762 pub line_end: i64,
4763 #[serde(rename = "lineStart", default)]
4764 pub line_start: i64,
4765 #[serde(default)]
4766 pub note: String,
4767 #[serde(default)]
4768 pub path: String,
4769}
4770
4771#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4772pub enum MergeStrategy {
4773 #[serde(rename = "replace")]
4774 Replace,
4775 #[serde(rename = "upsert")]
4776 Upsert,
4777}
4778
4779#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
4780pub enum MessagePhase {
4781 #[serde(rename = "commentary")]
4782 Commentary,
4783 #[serde(rename = "partial_answer")]
4786 PartialAnswer,
4787 #[serde(rename = "final_answer")]
4788 FinalAnswer,
4789}
4790
4791#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4792#[serde(rename_all = "camelCase")]
4793pub struct MigrationDetails {
4794 #[serde(default, skip_serializing_if = "Option::is_none")]
4795 pub commands: Option<Vec<CommandMigration>>,
4796 #[serde(default, skip_serializing_if = "Option::is_none")]
4797 pub hooks: Option<Vec<HookMigration>>,
4798 #[serde(
4799 rename = "mcpServers",
4800 default,
4801 skip_serializing_if = "Option::is_none"
4802 )]
4803 pub mcp_servers: Option<Vec<McpServerMigration>>,
4804 #[serde(default, skip_serializing_if = "Option::is_none")]
4805 pub memory: Option<Vec<String>>,
4806 #[serde(default, skip_serializing_if = "Option::is_none")]
4807 pub plugins: Option<Vec<PluginsMigration>>,
4808 #[serde(default, skip_serializing_if = "Option::is_none")]
4809 pub sessions: Option<Vec<SessionMigration>>,
4810 #[serde(default, skip_serializing_if = "Option::is_none")]
4811 pub skills: Option<Vec<SkillMigration>>,
4812 #[serde(default, skip_serializing_if = "Option::is_none")]
4813 pub subagents: Option<Vec<SubagentMigration>>,
4814}
4815
4816#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4819#[serde(rename_all = "camelCase")]
4820pub struct MisalignmentErrorDetails {
4821 #[serde(
4822 rename = "detailedExplanation",
4823 default,
4824 skip_serializing_if = "Option::is_none"
4825 )]
4826 pub detailed_explanation: Option<String>,
4827 #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
4829 pub error_type: Option<String>,
4830 #[serde(
4833 rename = "reviewTarget",
4834 default,
4835 skip_serializing_if = "Option::is_none"
4836 )]
4837 pub review_target: Option<String>,
4838 #[serde(default, skip_serializing_if = "Option::is_none")]
4841 pub steer: Option<MisalignmentSteer>,
4842}
4843
4844#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4846#[serde(rename_all = "camelCase")]
4847pub struct MisalignmentSteer {
4848 #[serde(default)]
4849 pub message: String,
4850}
4851
4852#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4853pub enum ModeKind {
4854 #[serde(rename = "plan")]
4855 Plan,
4856 #[serde(rename = "default")]
4857 Default,
4858}
4859
4860#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4861#[serde(rename_all = "camelCase")]
4862pub struct Model {
4863 #[serde(
4864 rename = "additionalSpeedTiers",
4865 default,
4866 skip_serializing_if = "Option::is_none"
4867 )]
4868 pub additional_speed_tiers: Option<Vec<String>>,
4869 #[serde(
4870 rename = "availabilityNux",
4871 default,
4872 skip_serializing_if = "Option::is_none"
4873 )]
4874 pub availability_nux: Option<ModelAvailabilityNux>,
4875 #[serde(
4877 rename = "availableAccessPrograms",
4878 default,
4879 skip_serializing_if = "Option::is_none"
4880 )]
4881 pub available_access_programs: Option<ModelAccessPrograms>,
4882 #[serde(rename = "defaultReasoningEffort")]
4883 pub default_reasoning_effort: ReasoningEffort,
4884 #[serde(
4885 rename = "defaultServiceTier",
4886 default,
4887 skip_serializing_if = "Option::is_none"
4888 )]
4889 pub default_service_tier: Option<String>,
4890 #[serde(default)]
4891 pub description: String,
4892 #[serde(rename = "displayName", default)]
4893 pub display_name: String,
4894 #[serde(default)]
4895 pub hidden: bool,
4896 #[serde(default)]
4897 pub id: String,
4898 #[serde(
4899 rename = "inputModalities",
4900 default,
4901 skip_serializing_if = "Option::is_none"
4902 )]
4903 pub input_modalities: Option<Vec<InputModality>>,
4904 #[serde(rename = "isDefault", default)]
4905 pub is_default: bool,
4906 #[serde(default)]
4907 pub model: String,
4908 #[serde(
4909 rename = "modelSpecialty",
4910 default,
4911 skip_serializing_if = "Option::is_none"
4912 )]
4913 pub model_specialty: Option<String>,
4914 #[serde(
4915 rename = "multiAgentVersion",
4916 default,
4917 skip_serializing_if = "Option::is_none"
4918 )]
4919 pub multi_agent_version: Option<MultiAgentVersion>,
4920 #[serde(
4921 rename = "serviceTiers",
4922 default,
4923 skip_serializing_if = "Option::is_none"
4924 )]
4925 pub service_tiers: Option<Vec<ModelServiceTier>>,
4926 #[serde(rename = "supportedReasoningEfforts", default)]
4927 pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
4928 #[serde(
4931 rename = "supportsPersonality",
4932 default,
4933 skip_serializing_if = "Option::is_none"
4934 )]
4935 pub supports_personality: Option<bool>,
4936 #[serde(default, skip_serializing_if = "Option::is_none")]
4937 pub upgrade: Option<String>,
4938 #[serde(
4939 rename = "upgradeInfo",
4940 default,
4941 skip_serializing_if = "Option::is_none"
4942 )]
4943 pub upgrade_info: Option<ModelUpgradeInfo>,
4944}
4945
4946#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4948#[serde(rename_all = "camelCase")]
4949pub struct ModelAccessPrograms {
4950 #[serde(default)]
4952 pub cyber: Vec<CyberAccessProgram>,
4953}
4954
4955#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4956#[serde(rename_all = "camelCase")]
4957pub struct ModelAvailabilityNux {
4958 #[serde(default)]
4959 pub message: String,
4960}
4961
4962#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4963#[serde(rename_all = "camelCase")]
4964pub struct ModelListParams {
4965 #[serde(default, skip_serializing_if = "Option::is_none")]
4966 pub cursor: Option<String>,
4967 #[serde(
4968 rename = "includeHidden",
4969 default,
4970 skip_serializing_if = "Option::is_none"
4971 )]
4972 pub include_hidden: Option<bool>,
4973 #[serde(default, skip_serializing_if = "Option::is_none")]
4974 pub limit: Option<i64>,
4975}
4976
4977#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4978#[serde(rename_all = "camelCase")]
4979pub struct ModelListResponse {
4980 #[serde(default)]
4981 pub data: Vec<Model>,
4982 #[serde(
4983 rename = "nextCursor",
4984 default,
4985 skip_serializing_if = "Option::is_none"
4986 )]
4987 pub next_cursor: Option<String>,
4988}
4989
4990#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4991#[serde(rename_all = "camelCase")]
4992pub struct ModelProviderCapabilitiesReadParams {
4993 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4994 pub extra: serde_json::Map<String, Value>,
4995}
4996
4997#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
4998#[serde(rename_all = "camelCase")]
4999pub struct ModelProviderCapabilitiesReadResponse {
5000 #[serde(rename = "imageGeneration", default)]
5001 pub image_generation: bool,
5002 #[serde(rename = "webSearch", default)]
5003 pub web_search: bool,
5004}
5005
5006#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5008#[serde(rename_all = "camelCase")]
5009pub struct ModelProviderListParams {
5010 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5011 pub extra: serde_json::Map<String, Value>,
5012}
5013
5014#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5016#[serde(rename_all = "camelCase")]
5017pub struct ModelProviderListResponse {
5018 pub data: Vec<ModelProviderSummary>,
5019 #[serde(rename = "defaultProviderId")]
5020 pub default_provider_id: String,
5021 #[serde(rename = "canChangeDefault")]
5022 pub can_change_default: bool,
5023}
5024
5025#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5027#[serde(rename_all = "camelCase")]
5028pub struct ModelProviderSummary {
5029 pub id: String,
5030 pub name: String,
5031 #[serde(rename = "canEdit")]
5033 pub can_edit: bool,
5034 #[serde(rename = "baseUrl", default)]
5036 pub base_url: Option<String>,
5037 pub settings: ProviderSettings,
5038}
5039
5040#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5042#[serde(tag = "type", rename_all = "camelCase")]
5043pub enum ProviderSettings {
5044 #[serde(rename = "openai")]
5045 OpenAi,
5046 #[serde(rename = "customGateway")]
5047 CustomGateway { auth: GatewayAuth },
5048 #[serde(rename = "bedrock")]
5049 Bedrock {
5050 #[serde(default)]
5051 profile: Option<String>,
5052 #[serde(default)]
5053 region: Option<String>,
5054 },
5055 #[serde(rename = "gcp")]
5056 Gcp {
5057 #[serde(rename = "projectId", default)]
5058 project_id: Option<String>,
5059 #[serde(default)]
5060 location: Option<String>,
5061 #[serde(rename = "credentialFile", default)]
5063 credential_file: Option<String>,
5064 },
5065}
5066
5067#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5069#[serde(tag = "mode", rename_all = "camelCase")]
5070pub enum GatewayAuth {
5071 #[serde(rename = "none")]
5072 None,
5073 #[serde(rename = "environmentVariable")]
5074 EnvironmentVariable {
5075 #[serde(rename = "envKey")]
5076 env_key: String,
5077 },
5078 #[serde(rename = "externallyConfigured")]
5080 ExternallyConfigured {
5081 #[serde(rename = "envKey", default)]
5082 env_key: Option<String>,
5083 },
5084}
5085
5086#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5088#[serde(rename_all = "camelCase")]
5089pub struct ModelProviderConfigWriteParams {
5090 pub settings: ProviderSettingsPatch,
5091}
5092
5093#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5095#[serde(rename_all = "camelCase")]
5096pub struct ModelProviderConfigWriteResponse {
5097 pub provider: ModelProviderSummary,
5098}
5099
5100#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5105#[serde(tag = "type", rename_all = "camelCase")]
5106pub enum ProviderSettingsPatch {
5107 #[serde(rename = "customGateway")]
5108 CustomGateway {
5109 #[serde(
5111 rename = "providerId",
5112 default,
5113 skip_serializing_if = "Option::is_none"
5114 )]
5115 provider_id: Option<String>,
5116 #[serde(
5118 default,
5119 deserialize_with = "deserialize_patch_name",
5120 skip_serializing_if = "Option::is_none"
5121 )]
5122 name: Option<String>,
5123 #[serde(
5124 rename = "baseUrl",
5125 default,
5126 deserialize_with = "deserialize_patch_field",
5127 skip_serializing_if = "Option::is_none"
5128 )]
5129 base_url: Option<Option<String>>,
5130 #[serde(
5131 rename = "envKey",
5132 default,
5133 deserialize_with = "deserialize_patch_field",
5134 skip_serializing_if = "Option::is_none"
5135 )]
5136 env_key: Option<Option<String>>,
5137 },
5138 #[serde(rename = "bedrock")]
5140 Bedrock {
5141 #[serde(rename = "providerId")]
5142 provider_id: BedrockProviderId,
5143 #[serde(
5144 default,
5145 deserialize_with = "deserialize_patch_field",
5146 skip_serializing_if = "Option::is_none"
5147 )]
5148 profile: Option<Option<String>>,
5149 #[serde(
5150 default,
5151 deserialize_with = "deserialize_patch_field",
5152 skip_serializing_if = "Option::is_none"
5153 )]
5154 region: Option<Option<String>>,
5155 },
5156 #[serde(rename = "gcp")]
5158 Gcp {
5159 #[serde(rename = "providerId")]
5160 provider_id: GcpProviderId,
5161 #[serde(
5162 rename = "projectId",
5163 default,
5164 deserialize_with = "deserialize_patch_field",
5165 skip_serializing_if = "Option::is_none"
5166 )]
5167 project_id: Option<Option<String>>,
5168 #[serde(
5169 default,
5170 deserialize_with = "deserialize_patch_field",
5171 skip_serializing_if = "Option::is_none"
5172 )]
5173 location: Option<Option<String>>,
5174 #[serde(
5175 rename = "credentialFile",
5176 default,
5177 deserialize_with = "deserialize_patch_field",
5178 skip_serializing_if = "Option::is_none"
5179 )]
5180 credential_file: Option<Option<String>>,
5181 },
5182}
5183
5184fn deserialize_patch_field<'de, D>(deserializer: D) -> Result<Option<Option<String>>, D::Error>
5186where
5187 D: serde::Deserializer<'de>,
5188{
5189 Option::<String>::deserialize(deserializer).map(Some)
5190}
5191
5192fn deserialize_patch_name<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
5194where
5195 D: serde::Deserializer<'de>,
5196{
5197 String::deserialize(deserializer).map(Some)
5198}
5199
5200#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
5202pub enum BedrockProviderId {
5203 #[serde(rename = "amazon-bedrock")]
5204 AmazonBedrock,
5205 #[serde(rename = "amazon-bedrock-runtime")]
5206 AmazonBedrockRuntime,
5207}
5208
5209#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
5211pub enum GcpProviderId {
5212 #[serde(rename = "gcp")]
5213 Gcp,
5214}
5215
5216#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
5221#[serde(tag = "type", rename_all = "camelCase")]
5222pub enum ModelProviderError {
5223 #[serde(rename = "modelProviderMismatch")]
5224 ModelProviderMismatch {
5225 #[serde(rename = "modelProvider")]
5226 model_provider: String,
5227 #[serde(rename = "currentModelProvider")]
5228 current_model_provider: String,
5229 },
5230 #[serde(rename = "modelProviderNotConfigured")]
5231 ModelProviderNotConfigured {
5232 #[serde(rename = "modelProvider")]
5233 model_provider: String,
5234 },
5235 #[serde(rename = "modelProviderPolicyConflict")]
5236 ModelProviderPolicyConflict {
5237 #[serde(rename = "modelProvider")]
5238 model_provider: String,
5239 #[serde(rename = "requiredModelProvider")]
5240 required_model_provider: String,
5241 },
5242}
5243
5244#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5245pub enum ModelRerouteReason {
5246 #[serde(rename = "highRiskCyberActivity")]
5247 HighRiskCyberActivity,
5248}
5249
5250#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5251#[serde(rename_all = "camelCase")]
5252pub struct ModelReroutedNotification {
5253 #[serde(rename = "fromModel", default)]
5254 pub from_model: String,
5255 #[serde()]
5256 pub reason: ModelRerouteReason,
5257 #[serde(rename = "threadId", default)]
5258 pub thread_id: String,
5259 #[serde(rename = "toModel", default)]
5260 pub to_model: String,
5261 #[serde(rename = "turnId", default)]
5262 pub turn_id: String,
5263}
5264
5265#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5266#[serde(rename_all = "camelCase")]
5267pub struct ModelSafetyBufferingUpdatedNotification {
5268 #[serde(
5269 rename = "fasterModel",
5270 default,
5271 skip_serializing_if = "Option::is_none"
5272 )]
5273 pub faster_model: Option<String>,
5274 #[serde(default)]
5275 pub model: String,
5276 #[serde(default)]
5277 pub reasons: Vec<String>,
5278 #[serde(rename = "showBufferingUi", default)]
5279 pub show_buffering_ui: bool,
5280 #[serde(rename = "threadId", default)]
5281 pub thread_id: String,
5282 #[serde(rename = "turnId", default)]
5283 pub turn_id: String,
5284 #[serde(rename = "useCases", default)]
5285 pub use_cases: Vec<String>,
5286}
5287
5288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5289#[serde(rename_all = "camelCase")]
5290pub struct ModelServiceTier {
5291 #[serde(default)]
5292 pub description: String,
5293 #[serde(default)]
5294 pub id: String,
5295 #[serde(default)]
5296 pub name: String,
5297}
5298
5299#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5300#[serde(rename_all = "camelCase")]
5301pub struct ModelUpgradeInfo {
5302 #[serde(
5303 rename = "migrationMarkdown",
5304 default,
5305 skip_serializing_if = "Option::is_none"
5306 )]
5307 pub migration_markdown: Option<String>,
5308 #[serde(default)]
5309 pub model: String,
5310 #[serde(
5313 rename = "retirementAt",
5314 default,
5315 skip_serializing_if = "Option::is_none"
5316 )]
5317 pub retirement_at: Option<i64>,
5318 #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
5319 pub model_link: Option<String>,
5320 #[serde(
5321 rename = "upgradeCopy",
5322 default,
5323 skip_serializing_if = "Option::is_none"
5324 )]
5325 pub upgrade_copy: Option<String>,
5326}
5327
5328#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5329pub enum ModelVerification {
5330 #[serde(rename = "trustedAccessForCyber")]
5331 TrustedAccessForCyber,
5332}
5333
5334#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5335#[serde(rename_all = "camelCase")]
5336pub struct ModelVerificationNotification {
5337 #[serde(rename = "threadId", default)]
5338 pub thread_id: String,
5339 #[serde(rename = "turnId", default)]
5340 pub turn_id: String,
5341 #[serde(default)]
5342 pub verifications: Vec<ModelVerification>,
5343}
5344
5345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5346#[serde(rename_all = "camelCase")]
5347pub struct ModelsRequirements {
5348 #[serde(rename = "newThread", default, skip_serializing_if = "Option::is_none")]
5349 pub new_thread: Option<NewThreadModelDefaults>,
5350}
5351
5352#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5353pub enum MultiAgentVersion {
5354 #[serde(rename = "disabled")]
5355 Disabled,
5356 #[serde(rename = "v1")]
5357 V1,
5358 #[serde(rename = "v2")]
5359 V2,
5360}
5361
5362#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5363pub enum NetworkAccess {
5364 #[serde(rename = "restricted")]
5365 Restricted,
5366 #[serde(rename = "enabled")]
5367 Enabled,
5368}
5369
5370#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5371#[serde(rename_all = "camelCase")]
5372pub struct NetworkApprovalContext {
5373 #[serde(default)]
5374 pub host: String,
5375 #[serde()]
5376 pub protocol: NetworkApprovalProtocol,
5377}
5378
5379#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5380pub enum NetworkApprovalProtocol {
5381 #[serde(rename = "http")]
5382 Http,
5383 #[serde(rename = "https")]
5384 Https,
5385 #[serde(rename = "socks5Tcp")]
5386 Socks5Tcp,
5387 #[serde(rename = "socks5Udp")]
5388 Socks5Udp,
5389}
5390
5391#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5392#[serde(rename_all = "camelCase")]
5393pub struct NetworkPolicyAmendment {
5394 #[serde()]
5395 pub action: NetworkPolicyRuleAction,
5396 #[serde(default)]
5397 pub host: String,
5398}
5399
5400#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5401pub enum NetworkPolicyRuleAction {
5402 #[serde(rename = "allow")]
5403 Allow,
5404 #[serde(rename = "deny")]
5405 Deny,
5406}
5407
5408#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5409#[serde(rename_all = "camelCase")]
5410pub struct NewThreadModelDefaults {
5411 #[serde(default, skip_serializing_if = "Option::is_none")]
5412 pub model: Option<String>,
5413 #[serde(
5414 rename = "modelReasoningEffort",
5415 default,
5416 skip_serializing_if = "Option::is_none"
5417 )]
5418 pub model_reasoning_effort: Option<ReasoningEffort>,
5419 #[serde(
5420 rename = "serviceTier",
5421 default,
5422 skip_serializing_if = "Option::is_none"
5423 )]
5424 pub service_tier: Option<String>,
5425}
5426
5427#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5428pub enum NonSteerableTurnKind {
5429 #[serde(rename = "review")]
5430 Review,
5431 #[serde(rename = "compact")]
5432 Compact,
5433}
5434
5435#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5437#[serde(rename_all = "kebab-case")]
5438pub enum OtelExporter {
5439 None,
5440 Statsig,
5441 OtlpHttp {
5442 endpoint: String,
5443 headers: std::collections::BTreeMap<String, String>,
5445 protocol: OtelHttpProtocol,
5446 #[serde(default, skip_serializing_if = "Option::is_none")]
5447 tls: Option<OtelTlsConfig>,
5448 },
5449 OtlpGrpc {
5450 endpoint: String,
5451 headers: std::collections::BTreeMap<String, String>,
5453 #[serde(default, skip_serializing_if = "Option::is_none")]
5454 tls: Option<OtelTlsConfig>,
5455 },
5456}
5457
5458#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5459#[serde(rename_all = "kebab-case")]
5460pub enum OtelHttpProtocol {
5461 Binary,
5462 Json,
5463}
5464
5465#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5468#[serde(rename_all = "snake_case")]
5469pub struct OtelRequirements {
5470 #[serde(default, skip_serializing_if = "Option::is_none")]
5471 pub tool_result: Option<OtelToolResultLogConfig>,
5472 #[serde(default, skip_serializing_if = "Option::is_none")]
5473 pub log_sse_deltas: Option<bool>,
5474 #[serde(default, skip_serializing_if = "Option::is_none")]
5475 pub log_user_prompt: Option<bool>,
5476 #[serde(default, skip_serializing_if = "Option::is_none")]
5477 pub log_agent_responses: Option<bool>,
5478 #[serde(default, skip_serializing_if = "Option::is_none")]
5479 pub log_guardian_assessments: Option<bool>,
5480 #[serde(default, skip_serializing_if = "Option::is_none")]
5481 pub environment: Option<String>,
5482 #[serde(default, skip_serializing_if = "Option::is_none")]
5483 pub exporter: Option<OtelExporter>,
5484 #[serde(default, skip_serializing_if = "Option::is_none")]
5485 pub trace_exporter: Option<OtelExporter>,
5486 #[serde(default, skip_serializing_if = "Option::is_none")]
5487 pub metrics_exporter: Option<OtelExporter>,
5488 #[serde(default, skip_serializing_if = "Option::is_none")]
5489 pub span_attributes: Option<std::collections::BTreeMap<String, String>>,
5490 #[serde(default, skip_serializing_if = "Option::is_none")]
5491 pub tracestate:
5492 Option<std::collections::BTreeMap<String, std::collections::BTreeMap<String, String>>>,
5493}
5494
5495#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
5496#[serde(rename_all = "kebab-case")]
5497pub struct OtelTlsConfig {
5498 #[serde(default, skip_serializing_if = "Option::is_none")]
5499 pub ca_certificate: Option<String>,
5500 #[serde(default, skip_serializing_if = "Option::is_none")]
5501 pub client_certificate: Option<String>,
5502 #[serde(default, skip_serializing_if = "Option::is_none")]
5503 pub client_private_key: Option<String>,
5504}
5505
5506#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
5507#[serde(rename_all = "snake_case")]
5508pub struct OtelToolResultLogConfig {
5509 pub max_bytes: u64,
5510}
5511
5512#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5513#[serde(rename_all = "camelCase")]
5514pub struct OverriddenMetadata {
5515 #[serde(rename = "effectiveValue", default)]
5516 pub effective_value: Value,
5517 #[serde(default)]
5518 pub message: String,
5519 #[serde(rename = "overridingLayer")]
5520 pub overriding_layer: ConfigLayerMetadata,
5521}
5522
5523#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5524#[serde(tag = "type", rename_all = "camelCase")]
5525pub enum ParsedCommand {
5526 Read {
5527 cmd: String,
5528 name: String,
5529 path: String,
5530 },
5531 List_files {
5532 cmd: String,
5533 #[serde(default, skip_serializing_if = "Option::is_none")]
5534 path: Option<String>,
5535 },
5536 Search {
5537 cmd: String,
5538 #[serde(default, skip_serializing_if = "Option::is_none")]
5539 path: Option<String>,
5540 #[serde(default, skip_serializing_if = "Option::is_none")]
5541 query: Option<String>,
5542 },
5543 Unknown {
5544 cmd: String,
5545 },
5546}
5547
5548#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5549pub enum PatchApplyStatus {
5550 #[serde(rename = "inProgress")]
5551 InProgress,
5552 #[serde(rename = "completed")]
5553 Completed,
5554 #[serde(rename = "failed")]
5555 Failed,
5556 #[serde(rename = "declined")]
5557 Declined,
5558}
5559
5560#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5561#[serde(tag = "type", rename_all = "camelCase")]
5562pub enum PatchChangeKind {
5563 Add,
5564 Delete,
5565 Update {
5566 #[serde(default, skip_serializing_if = "Option::is_none")]
5567 move_path: Option<String>,
5568 },
5569}
5570
5571#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5572pub enum PermissionGrantScope {
5573 #[serde(rename = "turn")]
5574 Turn,
5575 #[serde(rename = "session")]
5576 Session,
5577}
5578
5579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5580#[serde(rename_all = "camelCase")]
5581pub struct PermissionProfileListParams {
5582 #[serde(default, skip_serializing_if = "Option::is_none")]
5583 pub cursor: Option<String>,
5584 #[serde(default, skip_serializing_if = "Option::is_none")]
5585 pub cwd: Option<String>,
5586 #[serde(default, skip_serializing_if = "Option::is_none")]
5587 pub limit: Option<i64>,
5588}
5589
5590#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5591#[serde(rename_all = "camelCase")]
5592pub struct PermissionProfileListResponse {
5593 #[serde(default)]
5594 pub data: Vec<PermissionProfileSummary>,
5595 #[serde(
5596 rename = "nextCursor",
5597 default,
5598 skip_serializing_if = "Option::is_none"
5599 )]
5600 pub next_cursor: Option<String>,
5601}
5602
5603#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5604#[serde(rename_all = "camelCase")]
5605pub struct PermissionProfileSummary {
5606 #[serde(default)]
5607 pub allowed: bool,
5608 #[serde(default, skip_serializing_if = "Option::is_none")]
5609 pub description: Option<String>,
5610 #[serde(default)]
5611 pub id: String,
5612}
5613
5614#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5615#[serde(rename_all = "camelCase")]
5616pub struct PermissionsRequestApprovalParams {
5617 #[serde()]
5618 pub cwd: LegacyAppPathString,
5619 #[serde(
5620 rename = "environmentId",
5621 default,
5622 skip_serializing_if = "Option::is_none"
5623 )]
5624 pub environment_id: Option<String>,
5625 #[serde(rename = "itemId", default)]
5626 pub item_id: String,
5627 #[serde()]
5628 pub permissions: RequestPermissionProfile,
5629 #[serde(default, skip_serializing_if = "Option::is_none")]
5630 pub reason: Option<String>,
5631 #[serde(rename = "startedAtMs", default)]
5632 pub started_at_ms: i64,
5633 #[serde(rename = "threadId", default)]
5634 pub thread_id: String,
5635 #[serde(rename = "turnId", default)]
5636 pub turn_id: String,
5637}
5638
5639#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5640#[serde(rename_all = "camelCase")]
5641pub struct PermissionsRequestApprovalResponse {
5642 #[serde()]
5643 pub permissions: GrantedPermissionProfile,
5644 #[serde(default, skip_serializing_if = "Option::is_none")]
5645 pub scope: Option<Value>,
5646 #[serde(
5647 rename = "strictAutoReview",
5648 default,
5649 skip_serializing_if = "Option::is_none"
5650 )]
5651 pub strict_auto_review: Option<bool>,
5652}
5653
5654#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5659pub enum Personality {
5660 #[serde(rename = "none")]
5661 None,
5662 #[serde(rename = "friendly")]
5663 Friendly,
5664 #[serde(rename = "pragmatic")]
5665 Pragmatic,
5666}
5667
5668#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5669#[serde(rename_all = "camelCase")]
5670pub struct PlanDeltaNotification {
5671 #[serde(default)]
5672 pub delta: String,
5673 #[serde(rename = "itemId", default)]
5674 pub item_id: String,
5675 #[serde(rename = "threadId", default)]
5676 pub thread_id: String,
5677 #[serde(rename = "turnId", default)]
5678 pub turn_id: String,
5679}
5680
5681#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5682pub enum PlanType {
5683 #[serde(rename = "free")]
5684 Free,
5685 #[serde(rename = "go")]
5686 Go,
5687 #[serde(rename = "plus")]
5688 Plus,
5689 #[serde(rename = "pro")]
5690 Pro,
5691 #[serde(rename = "prolite")]
5692 Prolite,
5693 #[serde(rename = "promax")]
5694 Promax,
5695 #[serde(rename = "edu_plus")]
5696 Edu_plus,
5697 #[serde(rename = "edu_pro")]
5698 Edu_pro,
5699 #[serde(rename = "team")]
5700 Team,
5701 #[serde(rename = "self_serve_business_prolite")]
5702 Self_serve_business_prolite,
5703 #[serde(rename = "self_serve_business_usage_based")]
5704 Self_serve_business_usage_based,
5705 #[serde(rename = "business")]
5706 Business,
5707 #[serde(rename = "ent26")]
5708 Ent26,
5709 #[serde(rename = "enterprise_cbp_automation")]
5710 Enterprise_cbp_automation,
5711 #[serde(rename = "enterprise_cbp_usage_based")]
5712 Enterprise_cbp_usage_based,
5713 #[serde(rename = "enterprise")]
5714 Enterprise,
5715 #[serde(rename = "edu")]
5716 Edu,
5717 #[serde(rename = "sci")]
5718 Sci,
5719 #[serde(rename = "sci_plus")]
5720 Sci_plus,
5721 #[serde(rename = "unknown")]
5722 Unknown,
5723}
5724
5725#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5726pub enum PluginAuthPolicy {
5727 #[serde(rename = "ON_INSTALL")]
5728 ON_INSTALL,
5729 #[serde(rename = "ON_USE")]
5730 ON_USE,
5731}
5732
5733#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
5734pub enum PluginAvailability {
5735 #[serde(rename = "DISABLED_BY_ADMIN")]
5736 DISABLEDBYADMIN,
5737 AVAILABLE,
5738}
5739
5740#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5741#[serde(rename_all = "camelCase")]
5742pub struct PluginDetail {
5743 #[serde(rename = "appTemplates", default)]
5744 pub app_templates: Vec<AppTemplateSummary>,
5745 #[serde(default)]
5746 pub apps: Vec<AppSummary>,
5747 #[serde(default, skip_serializing_if = "Option::is_none")]
5748 pub description: Option<String>,
5749 #[serde(default)]
5750 pub hooks: Vec<PluginHookSummary>,
5751 #[serde(rename = "marketplaceName", default)]
5752 pub marketplace_name: String,
5753 #[serde(
5754 rename = "marketplacePath",
5755 default,
5756 skip_serializing_if = "Option::is_none"
5757 )]
5758 pub marketplace_path: Option<AbsolutePathBuf>,
5759 #[serde(rename = "mcpServers", default)]
5760 pub mcp_servers: Vec<String>,
5761 #[serde(
5763 rename = "onboardingSkill",
5764 default,
5765 skip_serializing_if = "Option::is_none"
5766 )]
5767 pub onboarding_skill: Option<SkillSummary>,
5768 #[serde(
5769 rename = "scheduledTasks",
5770 default,
5771 skip_serializing_if = "Option::is_none"
5772 )]
5773 pub scheduled_tasks: Option<Vec<ScheduledTaskSummary>>,
5774 #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
5775 pub share_url: Option<String>,
5776 #[serde(default)]
5777 pub skills: Vec<SkillSummary>,
5778 #[serde()]
5779 pub summary: PluginSummary,
5780}
5781
5782#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5783pub enum PluginDisabledReason {
5784 #[serde(rename = "disabled_by_admin")]
5785 Disabled_by_admin,
5786 #[serde(rename = "plan_not_eligible")]
5787 Plan_not_eligible,
5788 #[serde(rename = "required_app_unavailable")]
5789 Required_app_unavailable,
5790 #[serde(rename = "unknown")]
5791 Unknown,
5792}
5793
5794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5795#[serde(rename_all = "camelCase")]
5796pub struct PluginHookSummary {
5797 #[serde(rename = "eventName")]
5798 pub event_name: HookEventName,
5799 #[serde(default)]
5800 pub key: String,
5801}
5802
5803#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5804#[serde(rename_all = "camelCase")]
5805pub struct PluginInstallParams {
5806 #[serde(
5807 rename = "installAttemptId",
5808 default,
5809 skip_serializing_if = "Option::is_none"
5810 )]
5811 pub install_attempt_id: Option<String>,
5812 #[serde(
5813 rename = "marketplacePath",
5814 default,
5815 skip_serializing_if = "Option::is_none"
5816 )]
5817 pub marketplace_path: Option<AbsolutePathBuf>,
5818 #[serde(rename = "pluginName", default)]
5819 pub plugin_name: String,
5820 #[serde(
5821 rename = "remoteMarketplaceName",
5822 default,
5823 skip_serializing_if = "Option::is_none"
5824 )]
5825 pub remote_marketplace_name: Option<String>,
5826}
5827
5828#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5829pub enum PluginInstallPolicy {
5830 #[serde(rename = "NOT_AVAILABLE")]
5831 NOT_AVAILABLE,
5832 #[serde(rename = "AVAILABLE")]
5833 AVAILABLE,
5834 #[serde(rename = "INSTALLED_BY_DEFAULT")]
5835 INSTALLED_BY_DEFAULT,
5836}
5837
5838#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5839pub enum PluginInstallPolicySource {
5840 #[serde(rename = "WORKSPACE_SETTING")]
5841 WORKSPACE_SETTING,
5842 #[serde(rename = "IMPLICIT_CANONICAL_APP")]
5843 IMPLICIT_CANONICAL_APP,
5844}
5845
5846#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5847#[serde(rename_all = "camelCase")]
5848pub struct PluginInstallResponse {
5849 #[serde(rename = "appsNeedingAuth", default)]
5850 pub apps_needing_auth: Vec<AppSummary>,
5851 #[serde(rename = "authPolicy")]
5852 pub auth_policy: PluginAuthPolicy,
5853}
5854
5855#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5856#[serde(rename_all = "camelCase")]
5857pub struct PluginInstalledParams {
5858 #[serde(default, skip_serializing_if = "Option::is_none")]
5859 pub cwds: Option<Vec<AbsolutePathBuf>>,
5860 #[serde(
5861 rename = "installSuggestionPluginNames",
5862 default,
5863 skip_serializing_if = "Option::is_none"
5864 )]
5865 pub install_suggestion_plugin_names: Option<Vec<String>>,
5866}
5867
5868#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5869#[serde(rename_all = "camelCase")]
5870pub struct PluginInstalledResponse {
5871 #[serde(
5872 rename = "marketplaceLoadErrors",
5873 default,
5874 skip_serializing_if = "Option::is_none"
5875 )]
5876 pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
5877 #[serde(default)]
5878 pub marketplaces: Vec<PluginMarketplaceEntry>,
5879}
5880
5881#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5882#[serde(rename_all = "camelCase")]
5883pub struct PluginInterface {
5884 #[serde(
5885 rename = "brandColor",
5886 default,
5887 skip_serializing_if = "Option::is_none"
5888 )]
5889 pub brand_color: Option<String>,
5890 #[serde(default)]
5891 pub capabilities: Vec<String>,
5892 #[serde(default, skip_serializing_if = "Option::is_none")]
5893 pub category: Option<String>,
5894 #[serde(
5895 rename = "composerIcon",
5896 default,
5897 skip_serializing_if = "Option::is_none"
5898 )]
5899 pub composer_icon: Option<AbsolutePathBuf>,
5900 #[serde(
5901 rename = "composerIconUrl",
5902 default,
5903 skip_serializing_if = "Option::is_none"
5904 )]
5905 pub composer_icon_url: Option<String>,
5906 #[serde(
5907 rename = "defaultPrompt",
5908 default,
5909 skip_serializing_if = "Option::is_none"
5910 )]
5911 pub default_prompt: Option<Vec<String>>,
5912 #[serde(
5913 rename = "developerName",
5914 default,
5915 skip_serializing_if = "Option::is_none"
5916 )]
5917 pub developer_name: Option<String>,
5918 #[serde(
5919 rename = "displayName",
5920 default,
5921 skip_serializing_if = "Option::is_none"
5922 )]
5923 pub display_name: Option<String>,
5924 #[serde(default, skip_serializing_if = "Option::is_none")]
5925 pub logo: Option<AbsolutePathBuf>,
5926 #[serde(rename = "logoDark", default, skip_serializing_if = "Option::is_none")]
5927 pub logo_dark: Option<AbsolutePathBuf>,
5928 #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
5929 pub logo_url: Option<String>,
5930 #[serde(
5931 rename = "logoUrlDark",
5932 default,
5933 skip_serializing_if = "Option::is_none"
5934 )]
5935 pub logo_url_dark: Option<String>,
5936 #[serde(
5937 rename = "longDescription",
5938 default,
5939 skip_serializing_if = "Option::is_none"
5940 )]
5941 pub long_description: Option<String>,
5942 #[serde(
5943 rename = "privacyPolicyUrl",
5944 default,
5945 skip_serializing_if = "Option::is_none"
5946 )]
5947 pub privacy_policy_url: Option<String>,
5948 #[serde(rename = "screenshotUrls", default)]
5949 pub screenshot_urls: Vec<String>,
5950 #[serde(default)]
5951 pub screenshots: Vec<AbsolutePathBuf>,
5952 #[serde(
5953 rename = "shortDescription",
5954 default,
5955 skip_serializing_if = "Option::is_none"
5956 )]
5957 pub short_description: Option<String>,
5958 #[serde(
5959 rename = "termsOfServiceUrl",
5960 default,
5961 skip_serializing_if = "Option::is_none"
5962 )]
5963 pub terms_of_service_url: Option<String>,
5964 #[serde(
5965 rename = "websiteUrl",
5966 default,
5967 skip_serializing_if = "Option::is_none"
5968 )]
5969 pub website_url: Option<String>,
5970}
5971
5972#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5973pub enum PluginListMarketplaceKind {
5974 #[serde(rename = "local")]
5975 Local,
5976 #[serde(rename = "vertical")]
5977 Vertical,
5978 #[serde(rename = "workspace-directory")]
5979 Workspace_directory,
5980 #[serde(rename = "shared-with-me")]
5981 Shared_with_me,
5982 #[serde(rename = "created-by-me-remote")]
5983 Created_by_me_remote,
5984}
5985
5986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
5987#[serde(rename_all = "camelCase")]
5988pub struct PluginListParams {
5989 #[serde(default, skip_serializing_if = "Option::is_none")]
5990 pub cwds: Option<Vec<AbsolutePathBuf>>,
5991 #[serde(
5992 rename = "forceRefetch",
5993 default,
5994 skip_serializing_if = "Option::is_none"
5995 )]
5996 pub force_refetch: Option<bool>,
5997 #[serde(
5998 rename = "marketplaceKinds",
5999 default,
6000 skip_serializing_if = "Option::is_none"
6001 )]
6002 pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
6003}
6004
6005#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6006#[serde(rename_all = "camelCase")]
6007pub struct PluginListResponse {
6008 #[serde(
6009 rename = "featuredPluginIds",
6010 default,
6011 skip_serializing_if = "Option::is_none"
6012 )]
6013 pub featured_plugin_ids: Option<Vec<String>>,
6014 #[serde(
6015 rename = "marketplaceLoadErrors",
6016 default,
6017 skip_serializing_if = "Option::is_none"
6018 )]
6019 pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
6020 #[serde(default)]
6021 pub marketplaces: Vec<PluginMarketplaceEntry>,
6022}
6023
6024#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6025#[serde(rename_all = "camelCase")]
6026pub struct PluginMarketplaceEntry {
6027 #[serde(default, skip_serializing_if = "Option::is_none")]
6028 pub interface: Option<MarketplaceInterface>,
6029 #[serde(default)]
6030 pub name: String,
6031 #[serde(default, skip_serializing_if = "Option::is_none")]
6032 pub path: Option<AbsolutePathBuf>,
6033 #[serde(default)]
6034 pub plugins: Vec<PluginSummary>,
6035}
6036
6037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6038#[serde(rename_all = "camelCase")]
6039pub struct PluginReadParams {
6040 #[serde(
6041 rename = "marketplacePath",
6042 default,
6043 skip_serializing_if = "Option::is_none"
6044 )]
6045 pub marketplace_path: Option<AbsolutePathBuf>,
6046 #[serde(rename = "pluginName", default)]
6047 pub plugin_name: String,
6048 #[serde(
6049 rename = "remoteMarketplaceName",
6050 default,
6051 skip_serializing_if = "Option::is_none"
6052 )]
6053 pub remote_marketplace_name: Option<String>,
6054}
6055
6056#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6057#[serde(rename_all = "camelCase")]
6058pub struct PluginReadResponse {
6059 #[serde()]
6060 pub plugin: PluginDetail,
6061}
6062
6063#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6069#[serde(rename_all = "camelCase")]
6070pub struct PluginReconcileChangedPlugin {
6071 #[serde(rename = "hasApps", default)]
6072 pub has_apps: bool,
6073 #[serde(rename = "hasHooks", default)]
6074 pub has_hooks: bool,
6075 #[serde(rename = "hasMcps", default)]
6076 pub has_mcps: bool,
6077 #[serde(rename = "hasSkills", default)]
6080 pub has_skills: bool,
6081 #[serde(default)]
6083 pub id: String,
6084}
6085
6086#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6087#[serde(rename_all = "camelCase")]
6088pub struct PluginReconcileParams {
6089 #[serde(default, skip_serializing_if = "Option::is_none")]
6092 pub reason: Option<String>,
6093}
6094
6095#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6099#[serde(rename_all = "camelCase")]
6100pub struct PluginReconcileResponse {
6101 #[serde(rename = "changedPlugins", default)]
6106 pub changed_plugins: Vec<PluginReconcileChangedPlugin>,
6107 #[serde(rename = "failedMaterializationRemotePluginIds", default)]
6110 pub failed_materialization_remote_plugin_ids: Vec<String>,
6111 #[serde(rename = "failedRemotePluginIds", default)]
6113 pub failed_remote_plugin_ids: Vec<String>,
6114}
6115
6116#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6117#[serde(rename_all = "camelCase")]
6118pub struct PluginShareCheckoutParams {
6119 #[serde(rename = "remotePluginId", default)]
6120 pub remote_plugin_id: String,
6121}
6122
6123#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6124#[serde(rename_all = "camelCase")]
6125pub struct PluginShareCheckoutResponse {
6126 #[serde(rename = "marketplaceName", default)]
6127 pub marketplace_name: String,
6128 #[serde(rename = "marketplacePath")]
6129 pub marketplace_path: AbsolutePathBuf,
6130 #[serde(rename = "pluginId", default)]
6131 pub plugin_id: String,
6132 #[serde(rename = "pluginName", default)]
6133 pub plugin_name: String,
6134 #[serde(rename = "pluginPath")]
6135 pub plugin_path: AbsolutePathBuf,
6136 #[serde(rename = "remotePluginId", default)]
6137 pub remote_plugin_id: String,
6138 #[serde(
6139 rename = "remoteVersion",
6140 default,
6141 skip_serializing_if = "Option::is_none"
6142 )]
6143 pub remote_version: Option<String>,
6144}
6145
6146#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6147#[serde(rename_all = "camelCase")]
6148pub struct PluginShareContext {
6149 #[serde(
6150 rename = "canPublishToWorkspace",
6151 default,
6152 skip_serializing_if = "Option::is_none"
6153 )]
6154 pub can_publish_to_workspace: Option<bool>,
6155 #[serde(
6156 rename = "creatorAccountUserId",
6157 default,
6158 skip_serializing_if = "Option::is_none"
6159 )]
6160 pub creator_account_user_id: Option<String>,
6161 #[serde(
6162 rename = "creatorName",
6163 default,
6164 skip_serializing_if = "Option::is_none"
6165 )]
6166 pub creator_name: Option<String>,
6167 #[serde(default, skip_serializing_if = "Option::is_none")]
6168 pub discoverability: Option<PluginShareDiscoverability>,
6169 #[serde(rename = "remotePluginId", default)]
6170 pub remote_plugin_id: String,
6171 #[serde(
6172 rename = "remoteVersion",
6173 default,
6174 skip_serializing_if = "Option::is_none"
6175 )]
6176 pub remote_version: Option<String>,
6177 #[serde(
6178 rename = "sharePrincipals",
6179 default,
6180 skip_serializing_if = "Option::is_none"
6181 )]
6182 pub share_principals: Option<Vec<PluginSharePrincipal>>,
6183 #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
6184 pub share_url: Option<String>,
6185}
6186
6187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6188#[serde(rename_all = "camelCase")]
6189pub struct PluginShareDeleteParams {
6190 #[serde(rename = "remotePluginId", default)]
6191 pub remote_plugin_id: String,
6192}
6193
6194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6195#[serde(rename_all = "camelCase")]
6196pub struct PluginShareDeleteResponse {
6197 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6198 pub extra: serde_json::Map<String, Value>,
6199}
6200
6201#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6202pub enum PluginShareDiscoverability {
6203 #[serde(rename = "LISTED")]
6204 LISTED,
6205 #[serde(rename = "UNLISTED")]
6206 UNLISTED,
6207 #[serde(rename = "PRIVATE")]
6208 PRIVATE,
6209}
6210
6211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6212#[serde(rename_all = "camelCase")]
6213pub struct PluginShareListItem {
6214 #[serde(
6215 rename = "localPluginPath",
6216 default,
6217 skip_serializing_if = "Option::is_none"
6218 )]
6219 pub local_plugin_path: Option<AbsolutePathBuf>,
6220 #[serde()]
6221 pub plugin: PluginSummary,
6222}
6223
6224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6225#[serde(rename_all = "camelCase")]
6226pub struct PluginShareListParams {
6227 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6228 pub extra: serde_json::Map<String, Value>,
6229}
6230
6231#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6232#[serde(rename_all = "camelCase")]
6233pub struct PluginShareListResponse {
6234 #[serde(default)]
6235 pub data: Vec<PluginShareListItem>,
6236}
6237
6238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6239#[serde(rename_all = "camelCase")]
6240pub struct PluginSharePrincipal {
6241 #[serde(default)]
6242 pub name: String,
6243 #[serde(rename = "principalId", default)]
6244 pub principal_id: String,
6245 #[serde(rename = "principalType")]
6246 pub principal_type: PluginSharePrincipalType,
6247 #[serde()]
6248 pub role: PluginSharePrincipalRole,
6249}
6250
6251#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6252pub enum PluginSharePrincipalRole {
6253 #[serde(rename = "reader")]
6254 Reader,
6255 #[serde(rename = "editor")]
6256 Editor,
6257 #[serde(rename = "owner")]
6258 Owner,
6259}
6260
6261#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6262pub enum PluginSharePrincipalType {
6263 #[serde(rename = "user")]
6264 User,
6265 #[serde(rename = "group")]
6266 Group,
6267 #[serde(rename = "workspace")]
6268 Workspace,
6269}
6270
6271#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6272#[serde(rename_all = "camelCase")]
6273pub struct PluginShareSaveParams {
6274 #[serde(default, skip_serializing_if = "Option::is_none")]
6275 pub discoverability: Option<PluginShareDiscoverability>,
6276 #[serde(rename = "pluginPath")]
6277 pub plugin_path: AbsolutePathBuf,
6278 #[serde(
6279 rename = "remotePluginId",
6280 default,
6281 skip_serializing_if = "Option::is_none"
6282 )]
6283 pub remote_plugin_id: Option<String>,
6284 #[serde(
6285 rename = "shareTargets",
6286 default,
6287 skip_serializing_if = "Option::is_none"
6288 )]
6289 pub share_targets: Option<Vec<PluginShareTarget>>,
6290}
6291
6292#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6293#[serde(rename_all = "camelCase")]
6294pub struct PluginShareSaveResponse {
6295 #[serde(
6296 rename = "canPublishToWorkspace",
6297 default,
6298 skip_serializing_if = "Option::is_none"
6299 )]
6300 pub can_publish_to_workspace: Option<bool>,
6301 #[serde(rename = "remotePluginId", default)]
6302 pub remote_plugin_id: String,
6303 #[serde(rename = "shareUrl", default)]
6304 pub share_url: String,
6305}
6306
6307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6308#[serde(rename_all = "camelCase")]
6309pub struct PluginShareTarget {
6310 #[serde(rename = "principalId", default)]
6311 pub principal_id: String,
6312 #[serde(rename = "principalType")]
6313 pub principal_type: PluginSharePrincipalType,
6314 #[serde()]
6315 pub role: PluginShareTargetRole,
6316}
6317
6318#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6319pub enum PluginShareTargetRole {
6320 #[serde(rename = "reader")]
6321 Reader,
6322 #[serde(rename = "editor")]
6323 Editor,
6324}
6325
6326#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6327pub enum PluginShareUpdateDiscoverability {
6328 #[serde(rename = "UNLISTED")]
6329 UNLISTED,
6330 #[serde(rename = "PRIVATE")]
6331 PRIVATE,
6332 #[serde(rename = "LISTED")]
6333 LISTED,
6334}
6335
6336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6337#[serde(rename_all = "camelCase")]
6338pub struct PluginShareUpdateTargetsParams {
6339 #[serde()]
6340 pub discoverability: PluginShareUpdateDiscoverability,
6341 #[serde(rename = "remotePluginId", default)]
6342 pub remote_plugin_id: String,
6343 #[serde(rename = "shareTargets", default)]
6344 pub share_targets: Vec<PluginShareTarget>,
6345}
6346
6347#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6348#[serde(rename_all = "camelCase")]
6349pub struct PluginShareUpdateTargetsResponse {
6350 #[serde()]
6351 pub discoverability: PluginShareDiscoverability,
6352 #[serde(default)]
6353 pub principals: Vec<PluginSharePrincipal>,
6354}
6355
6356#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6357#[serde(rename_all = "camelCase")]
6358pub struct PluginSkillReadParams {
6359 #[serde(rename = "remoteMarketplaceName", default)]
6360 pub remote_marketplace_name: String,
6361 #[serde(rename = "remotePluginId", default)]
6362 pub remote_plugin_id: String,
6363 #[serde(rename = "skillName", default)]
6364 pub skill_name: String,
6365}
6366
6367#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6368#[serde(rename_all = "camelCase")]
6369pub struct PluginSkillReadResponse {
6370 #[serde(default, skip_serializing_if = "Option::is_none")]
6371 pub contents: Option<String>,
6372}
6373
6374#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6375#[serde(tag = "type", rename_all = "camelCase")]
6376pub enum PluginSource {
6377 Local {
6378 path: AbsolutePathBuf,
6379 },
6380 Git {
6381 #[serde(default, skip_serializing_if = "Option::is_none")]
6382 path: Option<String>,
6383 #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
6384 ref_name: Option<String>,
6385 #[serde(default, skip_serializing_if = "Option::is_none")]
6386 sha: Option<String>,
6387 url: String,
6388 },
6389 Npm {
6390 package: String,
6391 #[serde(default, skip_serializing_if = "Option::is_none")]
6392 registry: Option<String>,
6393 #[serde(default, skip_serializing_if = "Option::is_none")]
6394 version: Option<String>,
6395 },
6396 Remote,
6397}
6398
6399#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6400#[serde(rename_all = "camelCase")]
6401pub struct PluginSummary {
6402 #[serde(rename = "authPolicy")]
6403 pub auth_policy: PluginAuthPolicy,
6404 #[serde(default, skip_serializing_if = "Option::is_none")]
6405 pub availability: Option<Value>,
6406 #[serde(
6407 rename = "disabledReason",
6408 default,
6409 skip_serializing_if = "Option::is_none"
6410 )]
6411 pub disabled_reason: Option<PluginDisabledReason>,
6412 #[serde(
6413 rename = "eligiblePlanTypes",
6414 default,
6415 skip_serializing_if = "Option::is_none"
6416 )]
6417 pub eligible_plan_types: Option<Vec<String>>,
6418 #[serde(default)]
6419 pub enabled: bool,
6420 #[serde(default)]
6421 pub id: String,
6422 #[serde(rename = "installPolicy")]
6423 pub install_policy: PluginInstallPolicy,
6424 #[serde(
6425 rename = "installPolicySource",
6426 default,
6427 skip_serializing_if = "Option::is_none"
6428 )]
6429 pub install_policy_source: Option<PluginInstallPolicySource>,
6430 #[serde(default)]
6431 pub installed: bool,
6432 #[serde(
6433 rename = "installedAt",
6434 default,
6435 skip_serializing_if = "Option::is_none"
6436 )]
6437 pub installed_at: Option<i64>,
6438 #[serde(default, skip_serializing_if = "Option::is_none")]
6439 pub interface: Option<PluginInterface>,
6440 #[serde(default, skip_serializing_if = "Option::is_none")]
6441 pub keywords: Option<Vec<String>>,
6442 #[serde(
6443 rename = "localVersion",
6444 default,
6445 skip_serializing_if = "Option::is_none"
6446 )]
6447 pub local_version: Option<String>,
6448 #[serde(
6449 rename = "mustShowInstallationInterstitial",
6450 default,
6451 skip_serializing_if = "Option::is_none"
6452 )]
6453 pub must_show_installation_interstitial: Option<bool>,
6454 #[serde(default)]
6455 pub name: String,
6456 #[serde(
6457 rename = "remotePluginId",
6458 default,
6459 skip_serializing_if = "Option::is_none"
6460 )]
6461 pub remote_plugin_id: Option<String>,
6462 #[serde(
6463 rename = "shareContext",
6464 default,
6465 skip_serializing_if = "Option::is_none"
6466 )]
6467 pub share_context: Option<PluginShareContext>,
6468 #[serde()]
6469 pub source: PluginSource,
6470 #[serde(default, skip_serializing_if = "Option::is_none")]
6471 pub version: Option<String>,
6472}
6473
6474#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6475#[serde(rename_all = "camelCase")]
6476pub struct PluginUninstallParams {
6477 #[serde(rename = "pluginId", default)]
6478 pub plugin_id: String,
6479}
6480
6481#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6482#[serde(rename_all = "camelCase")]
6483pub struct PluginUninstallResponse {
6484 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
6485 pub extra: serde_json::Map<String, Value>,
6486}
6487
6488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6489#[serde(rename_all = "camelCase")]
6490pub struct PluginsMigration {
6491 #[serde(rename = "marketplaceName", default)]
6492 pub marketplace_name: String,
6493 #[serde(rename = "pluginNames", default)]
6494 pub plugin_names: Vec<String>,
6495}
6496
6497#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6498#[serde(rename_all = "camelCase")]
6499pub struct ProcessExitedNotification {
6500 #[serde(rename = "exitCode", default)]
6501 pub exit_code: i64,
6502 #[serde(
6506 rename = "outputDrainTimedOut",
6507 default,
6508 skip_serializing_if = "Option::is_none"
6509 )]
6510 pub output_drain_timed_out: Option<bool>,
6511 #[serde(rename = "processHandle", default)]
6512 pub process_handle: String,
6513 #[serde(default)]
6514 pub stderr: String,
6515 #[serde(rename = "stderrCapReached", default)]
6516 pub stderr_cap_reached: bool,
6517 #[serde(default)]
6518 pub stdout: String,
6519 #[serde(rename = "stdoutCapReached", default)]
6520 pub stdout_cap_reached: bool,
6521}
6522
6523#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6524#[serde(rename_all = "camelCase")]
6525pub struct ProcessOutputDeltaNotification {
6526 #[serde(rename = "capReached", default)]
6527 pub cap_reached: bool,
6528 #[serde(rename = "deltaBase64", default)]
6529 pub delta_base64: String,
6530 #[serde(rename = "processHandle", default)]
6531 pub process_handle: String,
6532 #[serde(default)]
6533 pub stream: Value,
6534}
6535
6536#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6537pub enum ProcessOutputStream {
6538 #[serde(rename = "stdout")]
6539 Stdout,
6540 #[serde(rename = "stderr")]
6541 Stderr,
6542}
6543
6544#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6545pub enum RateLimitReachedType {
6546 #[serde(rename = "rate_limit_reached")]
6547 Rate_limit_reached,
6548 #[serde(rename = "workspace_owner_credits_depleted")]
6549 Workspace_owner_credits_depleted,
6550 #[serde(rename = "workspace_member_credits_depleted")]
6551 Workspace_member_credits_depleted,
6552 #[serde(rename = "workspace_owner_usage_limit_reached")]
6553 Workspace_owner_usage_limit_reached,
6554 #[serde(rename = "workspace_member_usage_limit_reached")]
6555 Workspace_member_usage_limit_reached,
6556}
6557
6558#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6559#[serde(rename_all = "camelCase")]
6560pub struct RateLimitResetCredit {
6561 #[serde(default, skip_serializing_if = "Option::is_none")]
6562 pub description: Option<String>,
6563 #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
6564 pub expires_at: Option<i64>,
6565 #[serde(rename = "grantedAt", default)]
6566 pub granted_at: i64,
6567 #[serde(default)]
6568 pub id: String,
6569 #[serde(rename = "resetType")]
6570 pub reset_type: RateLimitResetType,
6571 #[serde()]
6572 pub status: RateLimitResetCreditStatus,
6573 #[serde(default, skip_serializing_if = "Option::is_none")]
6574 pub title: Option<String>,
6575}
6576
6577#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6578pub enum RateLimitResetCreditStatus {
6579 #[serde(rename = "available")]
6580 Available,
6581 #[serde(rename = "redeeming")]
6582 Redeeming,
6583 #[serde(rename = "redeemed")]
6584 Redeemed,
6585 #[serde(rename = "unknown")]
6586 Unknown,
6587}
6588
6589#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6590#[serde(rename_all = "camelCase")]
6591pub struct RateLimitResetCreditsSummary {
6592 #[serde(rename = "availableCount", default)]
6593 pub available_count: i64,
6594 #[serde(default, skip_serializing_if = "Option::is_none")]
6595 pub credits: Option<Vec<RateLimitResetCredit>>,
6596}
6597
6598#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6599pub enum RateLimitResetType {
6600 #[serde(rename = "codexRateLimits")]
6601 CodexRateLimits,
6602 #[serde(rename = "unknown")]
6603 Unknown,
6604}
6605
6606#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6607#[serde(rename_all = "camelCase")]
6608pub struct RateLimitSnapshot {
6609 #[serde(default, skip_serializing_if = "Option::is_none")]
6610 pub credits: Option<CreditsSnapshot>,
6611 #[serde(
6612 rename = "individualLimit",
6613 default,
6614 skip_serializing_if = "Option::is_none"
6615 )]
6616 pub individual_limit: Option<SpendControlLimitSnapshot>,
6617 #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
6618 pub limit_id: Option<String>,
6619 #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
6620 pub limit_name: Option<String>,
6621 #[serde(
6624 rename = "normalModelSlug",
6625 default,
6626 skip_serializing_if = "Option::is_none"
6627 )]
6628 pub normal_model_slug: Option<String>,
6629 #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
6630 pub plan_type: Option<PlanType>,
6631 #[serde(default, skip_serializing_if = "Option::is_none")]
6632 pub primary: Option<RateLimitWindow>,
6633 #[serde(
6634 rename = "rateLimitReachedType",
6635 default,
6636 skip_serializing_if = "Option::is_none"
6637 )]
6638 pub rate_limit_reached_type: Option<RateLimitReachedType>,
6639 #[serde(default, skip_serializing_if = "Option::is_none")]
6640 pub secondary: Option<RateLimitWindow>,
6641 #[serde(
6642 rename = "spendControlReached",
6643 default,
6644 skip_serializing_if = "Option::is_none"
6645 )]
6646 pub spend_control_reached: Option<bool>,
6647}
6648
6649#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6650#[serde(rename_all = "camelCase")]
6651pub struct RateLimitWindow {
6652 #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
6653 pub resets_at: Option<i64>,
6654 #[serde(rename = "usedPercent", default)]
6655 pub used_percent: i64,
6656 #[serde(
6657 rename = "windowDurationMins",
6658 default,
6659 skip_serializing_if = "Option::is_none"
6660 )]
6661 pub window_duration_mins: Option<i64>,
6662}
6663
6664#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6665pub enum RealtimeConversationVersion {
6666 #[serde(rename = "v1")]
6667 V1,
6668 #[serde(rename = "v2")]
6669 V2,
6670 #[serde(rename = "v3")]
6671 V3,
6672}
6673
6674#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
6676#[serde(transparent)]
6677pub struct ReasoningEffort(pub String);
6678
6679#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6680#[serde(rename_all = "camelCase")]
6681pub struct ReasoningEffortOption {
6682 #[serde(default)]
6683 pub description: String,
6684 #[serde(rename = "reasoningEffort")]
6685 pub reasoning_effort: ReasoningEffort,
6686}
6687
6688#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
6689pub enum ReasoningSummary {
6690 #[serde(rename = "auto")]
6691 Auto,
6692 #[serde(rename = "concise")]
6693 Concise,
6694 #[serde(rename = "detailed")]
6695 Detailed,
6696 #[serde(rename = "none")]
6697 None,
6698}
6699
6700#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6701#[serde(rename_all = "camelCase")]
6702pub struct ReasoningSummaryPartAddedNotification {
6703 #[serde(rename = "itemId", default)]
6704 pub item_id: String,
6705 #[serde(rename = "summaryIndex", default)]
6706 pub summary_index: i64,
6707 #[serde(rename = "threadId", default)]
6708 pub thread_id: String,
6709 #[serde(rename = "turnId", default)]
6710 pub turn_id: String,
6711}
6712
6713#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6714#[serde(rename_all = "camelCase")]
6715pub struct ReasoningSummaryTextDeltaNotification {
6716 #[serde(default)]
6717 pub delta: String,
6718 #[serde(rename = "itemId", default)]
6719 pub item_id: String,
6720 #[serde(rename = "summaryIndex", default)]
6721 pub summary_index: i64,
6722 #[serde(rename = "threadId", default)]
6723 pub thread_id: String,
6724 #[serde(rename = "turnId", default)]
6725 pub turn_id: String,
6726}
6727
6728#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6729#[serde(rename_all = "camelCase")]
6730pub struct ReasoningTextDeltaNotification {
6731 #[serde(rename = "contentIndex", default)]
6732 pub content_index: i64,
6733 #[serde(default)]
6734 pub delta: String,
6735 #[serde(rename = "itemId", default)]
6736 pub item_id: String,
6737 #[serde(rename = "threadId", default)]
6738 pub thread_id: String,
6739 #[serde(rename = "turnId", default)]
6740 pub turn_id: String,
6741}
6742
6743#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6744pub enum RemoteControlConnectionStatus {
6745 #[serde(rename = "disabled")]
6746 Disabled,
6747 #[serde(rename = "connecting")]
6748 Connecting,
6749 #[serde(rename = "connected")]
6750 Connected,
6751 #[serde(rename = "errored")]
6752 Errored,
6753}
6754
6755#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6756#[serde(rename_all = "camelCase")]
6757pub struct RemoteControlStatusChangedNotification {
6758 #[serde(
6759 rename = "environmentId",
6760 default,
6761 skip_serializing_if = "Option::is_none"
6762 )]
6763 pub environment_id: Option<String>,
6764 #[serde(rename = "installationId", default)]
6765 pub installation_id: String,
6766 #[serde(rename = "serverName", default)]
6767 pub server_name: String,
6768 #[serde()]
6769 pub status: RemoteControlConnectionStatus,
6770}
6771
6772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6773#[serde(untagged)]
6774pub enum RequestId {
6775 Variant0(String),
6776 Variant1(i64),
6777}
6778
6779#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6780#[serde(rename_all = "camelCase")]
6781pub struct RequestPermissionProfile {
6782 #[serde(
6783 rename = "fileSystem",
6784 default,
6785 skip_serializing_if = "Option::is_none"
6786 )]
6787 pub file_system: Option<AdditionalFileSystemPermissions>,
6788 #[serde(default, skip_serializing_if = "Option::is_none")]
6789 pub network: Option<AdditionalNetworkPermissions>,
6790}
6791
6792#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6793pub enum ResidencyRequirement {
6794 #[serde(rename = "us")]
6795 Us,
6796}
6797
6798#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6799#[serde(rename_all = "camelCase")]
6800pub struct Resource {
6801 #[serde(default, skip_serializing_if = "Option::is_none")]
6802 pub _meta: Option<Value>,
6803 #[serde(default, skip_serializing_if = "Option::is_none")]
6804 pub annotations: Option<Value>,
6805 #[serde(default, skip_serializing_if = "Option::is_none")]
6806 pub description: Option<String>,
6807 #[serde(default, skip_serializing_if = "Option::is_none")]
6808 pub icons: Option<Vec<Value>>,
6809 #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6810 pub mime_type: Option<String>,
6811 #[serde(default)]
6812 pub name: String,
6813 #[serde(default, skip_serializing_if = "Option::is_none")]
6814 pub size: Option<i64>,
6815 #[serde(default, skip_serializing_if = "Option::is_none")]
6816 pub title: Option<String>,
6817 #[serde(default)]
6818 pub uri: String,
6819}
6820
6821#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6822#[serde(untagged)]
6823pub enum ResourceContent {
6824 Variant0(Value),
6825 Variant1(Value),
6826}
6827
6828#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6829#[serde(rename_all = "camelCase")]
6830pub struct ResourceTemplate {
6831 #[serde(default, skip_serializing_if = "Option::is_none")]
6832 pub annotations: Option<Value>,
6833 #[serde(default, skip_serializing_if = "Option::is_none")]
6834 pub description: Option<String>,
6835 #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
6836 pub mime_type: Option<String>,
6837 #[serde(default)]
6838 pub name: String,
6839 #[serde(default, skip_serializing_if = "Option::is_none")]
6840 pub title: Option<String>,
6841 #[serde(rename = "uriTemplate", default)]
6842 pub uri_template: String,
6843}
6844
6845#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
6847#[serde(rename_all = "camelCase")]
6848pub struct ResponseUsageMetadata {
6849 #[serde(default, skip_serializing_if = "Option::is_none")]
6850 pub amount: Option<String>,
6851 #[serde(default, skip_serializing_if = "Option::is_none")]
6852 pub metadata: Option<Value>,
6853}
6854
6855#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
6856pub enum ReviewDecision {
6857 #[serde(rename = "approved")]
6858 Approved,
6859 #[serde(rename = "approved_execpolicy_amendment")]
6860 ApprovedExecpolicyAmendment {
6861 proposed_execpolicy_amendment: Vec<String>,
6862 },
6863 #[serde(rename = "approved_for_session")]
6864 ApprovedForSession,
6865 #[serde(rename = "approved_mcp_policy_amendment")]
6866 ApprovedMcpPolicyAmendment,
6867 #[serde(rename = "network_policy_amendment")]
6868 NetworkPolicyAmendment {
6869 network_policy_amendment: NetworkPolicyAmendment,
6870 },
6871 #[serde(rename = "denied")]
6872 Denied { rejection: String },
6873 #[serde(rename = "timed_out")]
6874 TimedOut,
6875 #[serde(rename = "abort")]
6876 Abort,
6877}
6878
6879#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6880pub enum ReviewDelivery {
6881 #[serde(rename = "inline")]
6882 Inline,
6883}
6884
6885#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6886#[serde(rename_all = "camelCase")]
6887pub struct ReviewStartParams {
6888 #[serde(default, skip_serializing_if = "Option::is_none")]
6892 pub delivery: Option<ReviewDelivery>,
6893 #[serde()]
6894 pub target: ReviewTarget,
6895 #[serde(rename = "threadId", default)]
6896 pub thread_id: String,
6897}
6898
6899#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6900#[serde(rename_all = "camelCase")]
6901pub struct ReviewStartResponse {
6902 #[serde(rename = "reviewThreadId", default)]
6904 pub review_thread_id: String,
6905 #[serde()]
6906 pub turn: Turn,
6907}
6908
6909#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6910#[serde(tag = "type", rename_all = "camelCase")]
6911pub enum ReviewTarget {
6912 #[serde(rename = "uncommittedChanges")]
6913 UncommittedChanges,
6914 #[serde(rename = "baseBranch")]
6915 BaseBranch {
6916 branch: String,
6917 },
6918 Commit {
6919 sha: String,
6920 #[serde(default, skip_serializing_if = "Option::is_none")]
6921 title: Option<String>,
6922 },
6923 Custom {
6924 instructions: String,
6925 },
6926}
6927
6928#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6930pub enum AgentMessageDelivery {
6931 #[serde(rename = "async")]
6932 Async,
6933}
6934
6935#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6937pub enum CliAuthCredentialsStoreMode {
6938 #[serde(rename = "file")]
6939 File,
6940 #[serde(rename = "keyring")]
6941 Keyring,
6942 #[serde(rename = "auto")]
6943 Auto,
6944 #[serde(rename = "ephemeral")]
6945 Ephemeral,
6946}
6947
6948#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6950pub struct Project {
6951 #[serde(rename = "createdAt", default)]
6952 pub created_at: i64,
6953 #[serde(default)]
6954 pub id: String,
6955 #[serde(default)]
6956 pub metadata: std::collections::HashMap<String, String>,
6957 #[serde(default)]
6958 pub name: String,
6959 #[serde(default)]
6960 pub position: i64,
6961 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
6964 pub recency_at: Option<i64>,
6965 #[serde(default)]
6966 pub roots: Vec<ProjectRoot>,
6967 #[serde(rename = "updatedAt", default)]
6968 pub updated_at: i64,
6969}
6970
6971#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
6973pub enum ProjectSortKey {
6974 #[serde(rename = "position")]
6975 Position,
6976 #[serde(rename = "recencyAt")]
6977 RecencyAt,
6978}
6979
6980#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6981pub enum ProjectChangeType {
6982 #[serde(rename = "created")]
6983 Created,
6984 #[serde(rename = "updated")]
6985 Updated,
6986 #[serde(rename = "deleted")]
6987 Deleted,
6988}
6989
6990#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6992pub struct ProjectChangedNotification {
6993 #[serde(rename = "changeType")]
6994 pub change_type: ProjectChangeType,
6995 #[serde(rename = "projectId", default)]
6996 pub project_id: String,
6997}
6998
6999#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7000pub struct ProjectRoot {
7001 pub path: AbsolutePathBuf,
7002}
7003
7004#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7006pub struct QueuedSubmission {
7007 #[serde(rename = "clientUserMessageId", default)]
7008 pub client_user_message_id: String,
7009 #[serde(default)]
7010 pub id: String,
7011 #[serde(default)]
7012 pub input: Vec<UserInput>,
7013}
7014
7015#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7017pub struct StrictReviewRequiredNotification {
7018 #[serde(rename = "startedAtMs", default)]
7020 pub started_at_ms: i64,
7021 #[serde(rename = "threadId", default)]
7022 pub thread_id: String,
7023 #[serde(rename = "turnId", default)]
7024 pub turn_id: String,
7025}
7026
7027#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7029pub struct ThreadProjectUpdatedNotification {
7030 #[serde(rename = "projectId", default)]
7031 pub project_id: Option<String>,
7032 #[serde(rename = "threadId", default)]
7033 pub thread_id: String,
7034}
7035
7036#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7038pub struct ThreadQueueChangedNotification {
7039 #[serde(rename = "threadId", default)]
7040 pub thread_id: String,
7041}
7042
7043#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7045pub struct ThreadRevertedNotification {
7046 #[serde(rename = "threadId", default)]
7047 pub thread_id: String,
7048}
7049
7050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7053#[serde(rename_all = "camelCase")]
7054pub struct ThreadPredictionUpdatedNotification {
7055 pub result: ThreadPredictionResult,
7056 #[serde(rename = "sourceTurnId", default)]
7057 pub source_turn_id: String,
7058 #[serde(rename = "threadId", default)]
7059 pub thread_id: String,
7060}
7061
7062#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7064#[serde(tag = "type", rename_all = "camelCase")]
7065pub enum ThreadPredictionResult {
7066 Completed {
7067 #[serde(default, skip_serializing_if = "Option::is_none")]
7068 text: Option<String>,
7069 },
7070 Failed,
7071}
7072
7073#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7075#[serde(rename_all = "camelCase")]
7076pub struct InAppBrowserRequirements {
7077 #[serde(
7078 rename = "allowExternalBrowserSettingsImport",
7079 default,
7080 skip_serializing_if = "Option::is_none"
7081 )]
7082 pub allow_external_browser_settings_import: Option<bool>,
7083}
7084
7085#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7087pub struct McpServerEventNotification {
7088 #[serde(default)]
7089 pub method: String,
7090 #[serde(default)]
7091 pub params: Value,
7092}
7093
7094#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7097pub struct McpServerEventStreamNotification {
7098 pub notification: McpServerEventNotification,
7099 #[serde(rename = "subscriptionId", default)]
7100 pub subscription_id: String,
7101}
7102
7103#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7106pub enum AllowDenyRequirement {
7107 #[serde(rename = "allow")]
7108 Allow,
7109 #[serde(rename = "deny")]
7110 Deny,
7111}
7112
7113#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7115pub enum BrowserUseAccessApprovalLifetime {
7116 #[serde(rename = "turn")]
7117 Turn,
7118 #[serde(rename = "thread")]
7119 Thread,
7120}
7121
7122#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7124pub enum McpServerConnectionStatus {
7125 #[serde(rename = "notStarted")]
7126 NotStarted,
7127 #[serde(rename = "starting")]
7128 Starting,
7129 #[serde(rename = "connected")]
7130 Connected,
7131 #[serde(rename = "authenticationRequired")]
7132 AuthenticationRequired,
7133 #[serde(rename = "failed")]
7134 Failed,
7135 #[serde(rename = "cancelled")]
7136 Cancelled,
7137 #[serde(rename = "disabled")]
7138 Disabled,
7139}
7140
7141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7143#[serde(rename_all = "camelCase")]
7144pub struct BrowserUseOriginPolicy {
7145 #[serde(default, skip_serializing_if = "Option::is_none")]
7146 pub access: Option<AllowDenyRequirement>,
7147 #[serde(
7148 rename = "accessApprovalLifetime",
7149 default,
7150 skip_serializing_if = "Option::is_none"
7151 )]
7152 pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetime>,
7153 #[serde(
7154 rename = "autoReview",
7155 default,
7156 skip_serializing_if = "Option::is_none"
7157 )]
7158 pub auto_review: Option<AllowDenyRequirement>,
7159 #[serde(default, skip_serializing_if = "Option::is_none")]
7160 pub downloads: Option<AllowDenyRequirement>,
7161 #[serde(
7162 rename = "fullCdpAccess",
7163 default,
7164 skip_serializing_if = "Option::is_none"
7165 )]
7166 pub full_cdp_access: Option<AllowDenyRequirement>,
7167 #[serde(
7168 rename = "persistentApproval",
7169 default,
7170 skip_serializing_if = "Option::is_none"
7171 )]
7172 pub persistent_approval: Option<bool>,
7173 #[serde(default, skip_serializing_if = "Option::is_none")]
7174 pub uploads: Option<AllowDenyRequirement>,
7175}
7176
7177#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7179pub struct BrowserUseOriginPolicyConfig {
7180 #[serde(default, skip_serializing_if = "Option::is_none")]
7181 pub access: Option<AllowDenyRequirement>,
7182 #[serde(default, skip_serializing_if = "Option::is_none")]
7183 pub downloads: Option<AllowDenyRequirement>,
7184 #[serde(default, skip_serializing_if = "Option::is_none")]
7185 pub full_cdp_access: Option<AllowDenyRequirement>,
7186 #[serde(default, skip_serializing_if = "Option::is_none")]
7187 pub uploads: Option<AllowDenyRequirement>,
7188}
7189
7190#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7192pub struct BrowserUseConfig {
7193 #[serde(default, skip_serializing_if = "Option::is_none")]
7194 pub allow_history_access: Option<bool>,
7195 #[serde(default, skip_serializing_if = "Option::is_none")]
7196 pub default_origin_policy: Option<BrowserUseOriginPolicyConfig>,
7197 #[serde(default, skip_serializing_if = "Option::is_none")]
7198 pub origins: Option<std::collections::HashMap<String, BrowserUseOriginPolicyConfig>>,
7199}
7200
7201#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7203pub struct ComputerUseConfig {
7204 #[serde(default, skip_serializing_if = "Option::is_none")]
7205 pub default_app_access: Option<AllowDenyRequirement>,
7206 #[serde(default, skip_serializing_if = "Option::is_none")]
7207 pub macos: Option<ComputerUseMacosConfig>,
7208 #[serde(default, skip_serializing_if = "Option::is_none")]
7209 pub windows: Option<ComputerUseWindowsConfig>,
7210}
7211
7212#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7213pub struct ComputerUseMacosConfig {
7214 #[serde(default, skip_serializing_if = "Option::is_none")]
7215 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7216}
7217
7218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7219pub struct ComputerUseWindowsConfig {
7220 #[serde(default, skip_serializing_if = "Option::is_none")]
7221 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7222 #[serde(default, skip_serializing_if = "Option::is_none")]
7223 pub exes: Option<Vec<ComputerUseWindowsExeConfig>>,
7224}
7225
7226#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7227pub struct ComputerUseWindowsExeConfig {
7228 pub access: AllowDenyRequirement,
7229 #[serde(default, skip_serializing_if = "Option::is_none")]
7230 pub binary_name: Option<String>,
7231 #[serde(default)]
7232 pub product_name: String,
7233 #[serde(default)]
7234 pub publisher_name: String,
7235}
7236
7237#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7239#[serde(rename_all = "camelCase")]
7240pub struct ComputerUseMacosRequirements {
7241 #[serde(rename = "bundleIds", default, skip_serializing_if = "Option::is_none")]
7242 pub bundle_ids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7243}
7244
7245#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7246#[serde(rename_all = "camelCase")]
7247pub struct ComputerUseWindowsRequirements {
7248 #[serde(default, skip_serializing_if = "Option::is_none")]
7249 pub aumids: Option<std::collections::HashMap<String, AllowDenyRequirement>>,
7250 #[serde(default, skip_serializing_if = "Option::is_none")]
7251 pub exes: Option<Vec<ComputerUseWindowsExeRequirement>>,
7252}
7253
7254#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7255#[serde(rename_all = "camelCase")]
7256pub struct ComputerUseWindowsExeRequirement {
7257 pub access: AllowDenyRequirement,
7258 #[serde(
7259 rename = "binaryName",
7260 default,
7261 skip_serializing_if = "Option::is_none"
7262 )]
7263 pub binary_name: Option<String>,
7264 #[serde(rename = "productName", default)]
7265 pub product_name: String,
7266 #[serde(rename = "publisherName", default)]
7267 pub publisher_name: String,
7268}
7269
7270#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7271pub enum SandboxMode {
7272 #[serde(rename = "read-only")]
7273 Read_only,
7274 #[serde(rename = "workspace-write")]
7275 Workspace_write,
7276 #[serde(rename = "danger-full-access")]
7277 Danger_full_access,
7278}
7279
7280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7281#[serde(tag = "type", rename_all = "camelCase")]
7282pub enum SandboxPolicy {
7283 #[serde(rename = "dangerFullAccess")]
7284 DangerFullAccess,
7285 #[serde(rename = "readOnly")]
7286 ReadOnly {
7287 #[serde(
7288 rename = "networkAccess",
7289 default,
7290 skip_serializing_if = "Option::is_none"
7291 )]
7292 network_access: Option<bool>,
7293 },
7294 #[serde(rename = "externalSandbox")]
7295 ExternalSandbox {
7296 #[serde(
7297 rename = "networkAccess",
7298 default,
7299 skip_serializing_if = "Option::is_none"
7300 )]
7301 network_access: Option<Value>,
7302 },
7303 #[serde(rename = "workspaceWrite")]
7304 WorkspaceWrite {
7305 #[serde(
7306 rename = "excludeSlashTmp",
7307 default,
7308 skip_serializing_if = "Option::is_none"
7309 )]
7310 exclude_slash_tmp: Option<bool>,
7311 #[serde(
7312 rename = "excludeTmpdirEnvVar",
7313 default,
7314 skip_serializing_if = "Option::is_none"
7315 )]
7316 exclude_tmpdir_env_var: Option<bool>,
7317 #[serde(
7318 rename = "networkAccess",
7319 default,
7320 skip_serializing_if = "Option::is_none"
7321 )]
7322 network_access: Option<bool>,
7323 #[serde(
7324 rename = "writableRoots",
7325 default,
7326 skip_serializing_if = "Option::is_none"
7327 )]
7328 writable_roots: Option<Vec<AbsolutePathBuf>>,
7329 },
7330}
7331
7332#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7333#[serde(rename_all = "snake_case")]
7334pub struct SandboxWorkspaceWrite {
7335 #[serde(default, skip_serializing_if = "Option::is_none")]
7336 pub exclude_slash_tmp: Option<bool>,
7337 #[serde(default, skip_serializing_if = "Option::is_none")]
7338 pub exclude_tmpdir_env_var: Option<bool>,
7339 #[serde(default, skip_serializing_if = "Option::is_none")]
7340 pub network_access: Option<bool>,
7341 #[serde(default, skip_serializing_if = "Option::is_none")]
7342 pub writable_roots: Option<Vec<String>>,
7343}
7344
7345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7346#[serde(tag = "type", rename_all = "camelCase")]
7347pub enum ScheduledTaskSchedule {
7348 Hourly {
7349 #[serde(default, skip_serializing_if = "Option::is_none")]
7350 days: Option<Vec<ScheduledTaskWeekday>>,
7351 #[serde(rename = "intervalHours")]
7352 interval_hours: i64,
7353 },
7354 Daily {
7355 time: String,
7356 },
7357 Weekdays {
7358 time: String,
7359 },
7360 Weekly {
7361 days: Vec<ScheduledTaskWeekday>,
7362 time: String,
7363 },
7364}
7365
7366#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7367#[serde(rename_all = "camelCase")]
7368pub struct ScheduledTaskSummary {
7369 #[serde(default)]
7370 pub key: String,
7371 #[serde(default)]
7372 pub name: String,
7373 #[serde(default)]
7374 pub prompt: String,
7375 #[serde()]
7376 pub schedule: ScheduledTaskSchedule,
7377}
7378
7379#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7380pub enum ScheduledTaskWeekday {
7381 #[serde(rename = "MO")]
7382 MO,
7383 #[serde(rename = "TU")]
7384 TU,
7385 #[serde(rename = "WE")]
7386 WE,
7387 #[serde(rename = "TH")]
7388 TH,
7389 #[serde(rename = "FR")]
7390 FR,
7391 #[serde(rename = "SA")]
7392 SA,
7393 #[serde(rename = "SU")]
7394 SU,
7395}
7396
7397#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7398#[serde(rename_all = "camelCase")]
7399pub struct SendAddCreditsNudgeEmailParams {
7400 #[serde(rename = "creditType")]
7401 pub credit_type: AddCreditsNudgeCreditType,
7402}
7403
7404#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7405#[serde(rename_all = "camelCase")]
7406pub struct SendAddCreditsNudgeEmailResponse {
7407 #[serde()]
7408 pub status: AddCreditsNudgeEmailStatus,
7409}
7410
7411#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7412#[serde(rename_all = "camelCase")]
7413pub struct ServerRequestResolvedNotification {
7414 #[serde(rename = "requestId")]
7415 pub request_id: RequestId,
7416 #[serde(rename = "threadId", default)]
7417 pub thread_id: String,
7418}
7419
7420#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7421#[serde(rename_all = "camelCase")]
7422pub struct SessionMigration {
7423 #[serde(default)]
7424 pub cwd: String,
7425 #[serde(default)]
7426 pub path: String,
7427 #[serde(default, skip_serializing_if = "Option::is_none")]
7428 pub title: Option<String>,
7429}
7430
7431#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7432pub enum SessionSource {
7433 #[serde(rename = "cli")]
7434 Cli,
7435 #[serde(rename = "vscode")]
7436 Vscode,
7437 #[serde(rename = "exec")]
7438 Exec,
7439 #[serde(rename = "appServer")]
7440 AppServer,
7441 #[serde(rename = "unknown")]
7442 Unknown,
7443 #[serde(rename = "custom")]
7444 Custom(String),
7445 #[serde(rename = "subAgent")]
7446 SubAgent(SubAgentSource),
7447}
7448
7449#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7450#[serde(rename_all = "camelCase")]
7451pub struct Settings {
7452 #[serde(default, skip_serializing_if = "Option::is_none")]
7453 pub developer_instructions: Option<String>,
7454 #[serde(default)]
7455 pub model: String,
7456 #[serde(default, skip_serializing_if = "Option::is_none")]
7457 pub reasoning_effort: Option<ReasoningEffort>,
7458}
7459
7460#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7461#[serde(rename_all = "camelCase")]
7462pub struct SkillDependencies {
7463 #[serde(default)]
7464 pub tools: Vec<SkillToolDependency>,
7465}
7466
7467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7468#[serde(rename_all = "camelCase")]
7469pub struct SkillErrorInfo {
7470 #[serde(default)]
7471 pub message: String,
7472 #[serde(default)]
7473 pub path: String,
7474}
7475
7476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7477#[serde(rename_all = "camelCase")]
7478pub struct SkillInterface {
7479 #[serde(
7480 rename = "brandColor",
7481 default,
7482 skip_serializing_if = "Option::is_none"
7483 )]
7484 pub brand_color: Option<String>,
7485 #[serde(
7486 rename = "defaultPrompt",
7487 default,
7488 skip_serializing_if = "Option::is_none"
7489 )]
7490 pub default_prompt: Option<String>,
7491 #[serde(
7492 rename = "displayName",
7493 default,
7494 skip_serializing_if = "Option::is_none"
7495 )]
7496 pub display_name: Option<String>,
7497 #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
7498 pub icon_large: Option<AbsolutePathBuf>,
7499 #[serde(
7500 rename = "iconLargeUrl",
7501 default,
7502 skip_serializing_if = "Option::is_none"
7503 )]
7504 pub icon_large_url: Option<String>,
7505 #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
7506 pub icon_small: Option<AbsolutePathBuf>,
7507 #[serde(
7508 rename = "iconSmallUrl",
7509 default,
7510 skip_serializing_if = "Option::is_none"
7511 )]
7512 pub icon_small_url: Option<String>,
7513 #[serde(
7514 rename = "shortDescription",
7515 default,
7516 skip_serializing_if = "Option::is_none"
7517 )]
7518 pub short_description: Option<String>,
7519}
7520
7521#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7522#[serde(rename_all = "camelCase")]
7523pub struct SkillMetadata {
7524 #[serde(default, skip_serializing_if = "Option::is_none")]
7525 pub dependencies: Option<SkillDependencies>,
7526 #[serde(default)]
7527 pub description: String,
7528 #[serde(default)]
7529 pub enabled: bool,
7530 #[serde(default, skip_serializing_if = "Option::is_none")]
7531 pub interface: Option<SkillInterface>,
7532 #[serde(default)]
7533 pub name: String,
7534 #[serde()]
7535 pub path: LegacyAppPathString,
7536 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
7537 pub plugin_id: Option<String>,
7538 #[serde()]
7539 pub scope: SkillScope,
7540 #[serde(
7541 rename = "shortDescription",
7542 default,
7543 skip_serializing_if = "Option::is_none"
7544 )]
7545 pub short_description: Option<String>,
7546}
7547
7548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7549#[serde(rename_all = "camelCase")]
7550pub struct SkillMigration {
7551 #[serde(default)]
7552 pub name: String,
7553}
7554
7555#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7556pub enum SkillScope {
7557 #[serde(rename = "user")]
7558 User,
7559 #[serde(rename = "repo")]
7560 Repo,
7561 #[serde(rename = "system")]
7562 System,
7563 #[serde(rename = "admin")]
7564 Admin,
7565}
7566
7567#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7568#[serde(rename_all = "camelCase")]
7569pub struct SkillSummary {
7570 #[serde(default)]
7571 pub description: String,
7572 #[serde(default)]
7573 pub enabled: bool,
7574 #[serde(default, skip_serializing_if = "Option::is_none")]
7575 pub interface: Option<SkillInterface>,
7576 #[serde(default)]
7577 pub name: String,
7578 #[serde(default, skip_serializing_if = "Option::is_none")]
7579 pub path: Option<LegacyAppPathString>,
7580 #[serde(
7581 rename = "shortDescription",
7582 default,
7583 skip_serializing_if = "Option::is_none"
7584 )]
7585 pub short_description: Option<String>,
7586}
7587
7588#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7589#[serde(rename_all = "camelCase")]
7590pub struct SkillToolDependency {
7591 #[serde(default, skip_serializing_if = "Option::is_none")]
7592 pub command: Option<String>,
7593 #[serde(default, skip_serializing_if = "Option::is_none")]
7594 pub description: Option<String>,
7595 #[serde(default, skip_serializing_if = "Option::is_none")]
7596 pub transport: Option<String>,
7597 #[serde(rename = "type", default)]
7598 pub type_: String,
7599 #[serde(default, skip_serializing_if = "Option::is_none")]
7600 pub url: Option<String>,
7601 #[serde(default)]
7602 pub value: String,
7603}
7604
7605#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7606#[serde(rename_all = "camelCase")]
7607pub struct SkillsChangedNotification {
7608 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7609 pub extra: serde_json::Map<String, Value>,
7610}
7611
7612#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7613#[serde(rename_all = "camelCase")]
7614pub struct SkillsConfigWriteParams {
7615 #[serde(default)]
7616 pub enabled: bool,
7617 #[serde(default, skip_serializing_if = "Option::is_none")]
7618 pub name: Option<String>,
7619 #[serde(default, skip_serializing_if = "Option::is_none")]
7620 pub path: Option<AbsolutePathBuf>,
7621}
7622
7623#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7624#[serde(rename_all = "camelCase")]
7625pub struct SkillsConfigWriteResponse {
7626 #[serde(rename = "effectiveEnabled", default)]
7627 pub effective_enabled: bool,
7628}
7629
7630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7631#[serde(rename_all = "camelCase")]
7632pub struct SkillsExtraRootsSetParams {
7633 #[serde(rename = "extraRoots", default)]
7634 pub extra_roots: Vec<AbsolutePathBuf>,
7635}
7636
7637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7638#[serde(rename_all = "camelCase")]
7639pub struct SkillsExtraRootsSetResponse {
7640 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7641 pub extra: serde_json::Map<String, Value>,
7642}
7643
7644#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7645#[serde(rename_all = "camelCase")]
7646pub struct SkillsListEntry {
7647 #[serde(default)]
7648 pub cwd: String,
7649 #[serde(default)]
7650 pub errors: Vec<SkillErrorInfo>,
7651 #[serde(default)]
7652 pub skills: Vec<SkillMetadata>,
7653}
7654
7655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7656#[serde(rename_all = "camelCase")]
7657pub struct SkillsListParams {
7658 #[serde(default, skip_serializing_if = "Option::is_none")]
7659 pub cwds: Option<Vec<String>>,
7660 #[serde(
7661 rename = "forceReload",
7662 default,
7663 skip_serializing_if = "Option::is_none"
7664 )]
7665 pub force_reload: Option<bool>,
7666}
7667
7668#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7669#[serde(rename_all = "camelCase")]
7670pub struct SkillsListResponse {
7671 #[serde(default)]
7672 pub data: Vec<SkillsListEntry>,
7673}
7674
7675#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7676pub enum SortDirection {
7677 #[serde(rename = "asc")]
7678 Asc,
7679 #[serde(rename = "desc")]
7680 Desc,
7681}
7682
7683#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7684#[serde(rename_all = "camelCase")]
7685pub struct SpendControlLimitSnapshot {
7686 #[serde(default)]
7687 pub limit: String,
7688 #[serde(rename = "remainingPercent", default)]
7689 pub remaining_percent: i64,
7690 #[serde(rename = "resetsAt", default)]
7691 pub resets_at: i64,
7692 #[serde(default)]
7693 pub used: String,
7694}
7695
7696#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7697pub enum SubAgentActivityKind {
7698 #[serde(rename = "started")]
7699 Started,
7700 #[serde(rename = "interacted")]
7701 Interacted,
7702 #[serde(rename = "interrupted")]
7703 Interrupted,
7704 #[serde(rename = "completed")]
7705 Completed,
7706}
7707
7708#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
7709pub enum SubAgentSource {
7710 #[serde(rename = "review")]
7711 Review,
7712 #[serde(rename = "compact")]
7713 Compact,
7714 #[serde(rename = "memory_consolidation")]
7715 MemoryConsolidation,
7716 #[serde(rename = "thread_spawn")]
7717 ThreadSpawn {
7718 #[serde(default, skip_serializing_if = "Option::is_none")]
7719 agent_nickname: Option<String>,
7720 #[serde(default, skip_serializing_if = "Option::is_none")]
7721 agent_path: Option<AgentPath>,
7722 #[serde(default, skip_serializing_if = "Option::is_none")]
7723 agent_role: Option<String>,
7724 depth: i64,
7725 parent_thread_id: ThreadId,
7726 },
7727 #[serde(rename = "other")]
7728 Other(String),
7729}
7730
7731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7732#[serde(rename_all = "camelCase")]
7733pub struct SubagentMigration {
7734 #[serde(default)]
7735 pub name: String,
7736}
7737
7738#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7739#[serde(rename_all = "camelCase")]
7740pub struct TerminalInteractionNotification {
7741 #[serde(rename = "itemId", default)]
7742 pub item_id: String,
7743 #[serde(rename = "processId", default)]
7744 pub process_id: String,
7745 #[serde(default)]
7746 pub stdin: String,
7747 #[serde(rename = "threadId", default)]
7748 pub thread_id: String,
7749 #[serde(rename = "turnId", default)]
7750 pub turn_id: String,
7751}
7752
7753#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7754#[serde(rename_all = "camelCase")]
7755pub struct TextElement {
7756 #[serde(rename = "byteRange", default)]
7757 pub byte_range: Value,
7758 #[serde(default, skip_serializing_if = "Option::is_none")]
7759 pub placeholder: Option<String>,
7760}
7761
7762#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7763#[serde(rename_all = "camelCase")]
7764pub struct TextPosition {
7765 #[serde(default)]
7766 pub column: i64,
7767 #[serde(default)]
7768 pub line: i64,
7769}
7770
7771#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7772#[serde(rename_all = "camelCase")]
7773pub struct TextRange {
7774 #[serde()]
7775 pub end: TextPosition,
7776 #[serde()]
7777 pub start: TextPosition,
7778}
7779
7780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7781#[serde(rename_all = "camelCase")]
7782pub struct Thread {
7783 #[serde(
7784 rename = "agentNickname",
7785 default,
7786 skip_serializing_if = "Option::is_none"
7787 )]
7788 pub agent_nickname: Option<String>,
7789 #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
7790 pub agent_role: Option<String>,
7791 #[serde(rename = "cliVersion", default)]
7792 pub cli_version: String,
7793 #[serde(rename = "createdAt", default)]
7794 pub created_at: i64,
7795 #[serde(default)]
7796 pub cwd: Value,
7797 #[serde(default)]
7798 pub ephemeral: bool,
7799 #[serde(
7800 rename = "forkedFromId",
7801 default,
7802 skip_serializing_if = "Option::is_none"
7803 )]
7804 pub forked_from_id: Option<String>,
7805 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
7806 pub git_info: Option<GitInfo>,
7807 #[serde(
7810 rename = "historyMode",
7811 default,
7812 skip_serializing_if = "Option::is_none"
7813 )]
7814 pub history_mode: Option<ThreadHistoryMode>,
7815 #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
7818 pub project_id: Option<String>,
7819 #[serde(default)]
7820 pub id: String,
7821 #[serde(default, skip_serializing_if = "Option::is_none")]
7824 pub model: Option<String>,
7825 #[serde(rename = "modelProvider", default)]
7826 pub model_provider: String,
7827 #[serde(default, skip_serializing_if = "Option::is_none")]
7828 pub name: Option<String>,
7829 #[serde(default, skip_serializing_if = "Option::is_none")]
7833 pub originator: Option<String>,
7834 #[serde(
7835 rename = "parentThreadId",
7836 default,
7837 skip_serializing_if = "Option::is_none"
7838 )]
7839 pub parent_thread_id: Option<String>,
7840 #[serde(default, skip_serializing_if = "Option::is_none")]
7841 pub path: Option<String>,
7842 #[serde(default)]
7843 pub preview: String,
7844 #[serde(
7848 rename = "reasoningEffort",
7849 default,
7850 skip_serializing_if = "Option::is_none"
7851 )]
7852 pub reasoning_effort: Option<ReasoningEffort>,
7853 #[serde(rename = "recencyAt", default, skip_serializing_if = "Option::is_none")]
7854 pub recency_at: Option<i64>,
7855 #[serde(default, skip_serializing_if = "Option::is_none")]
7856 pub section: Option<ThreadSection>,
7857 #[serde(
7858 rename = "sectionEnteredAt",
7859 default,
7860 skip_serializing_if = "Option::is_none"
7861 )]
7862 pub section_entered_at: Option<i64>,
7863 #[serde(rename = "sessionId", default)]
7864 pub session_id: String,
7865 #[serde(default)]
7866 pub source: Value,
7867 #[serde(default)]
7868 pub status: Value,
7869 #[serde(
7870 rename = "threadSource",
7871 default,
7872 skip_serializing_if = "Option::is_none"
7873 )]
7874 pub thread_source: Option<ThreadSource>,
7875 #[serde(default)]
7876 pub turns: Vec<Turn>,
7877 #[serde(rename = "updatedAt", default)]
7878 pub updated_at: i64,
7879}
7880
7881#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7882pub enum ThreadActiveFlag {
7883 #[serde(rename = "waitingOnApproval")]
7884 WaitingOnApproval,
7885 #[serde(rename = "waitingOnUserInput")]
7886 WaitingOnUserInput,
7887}
7888
7889#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7890#[serde(rename_all = "camelCase")]
7891pub struct ThreadApproveGuardianDeniedActionParams {
7892 #[serde(default)]
7893 pub event: Value,
7894 #[serde(rename = "threadId", default)]
7895 pub thread_id: String,
7896}
7897
7898#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7899#[serde(rename_all = "camelCase")]
7900pub struct ThreadApproveGuardianDeniedActionResponse {
7901 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7902 pub extra: serde_json::Map<String, Value>,
7903}
7904
7905#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7906#[serde(rename_all = "camelCase")]
7907pub struct ThreadArchiveParams {
7908 #[serde(rename = "threadId", default)]
7909 pub thread_id: String,
7910}
7911
7912#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7913#[serde(rename_all = "camelCase")]
7914pub struct ThreadArchiveResponse {
7915 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
7916 pub extra: serde_json::Map<String, Value>,
7917}
7918
7919#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7920#[serde(rename_all = "camelCase")]
7921pub struct ThreadArchivedNotification {
7922 #[serde(rename = "threadId", default)]
7923 pub thread_id: String,
7924}
7925
7926#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7928#[serde(rename_all = "camelCase")]
7929pub struct ThreadAttachment {
7930 #[serde(rename = "attachmentType", default)]
7931 pub attachment_type: String,
7932 #[serde(rename = "createdAt", default)]
7933 pub created_at: i64,
7934 #[serde(default)]
7935 pub id: String,
7936 #[serde(rename = "identityKey", default)]
7937 pub identity_key: String,
7938 #[serde(default)]
7939 pub payload: Value,
7940}
7941
7942#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7944pub enum ThreadAttachmentAddOutcome {
7945 #[serde(rename = "created")]
7946 Created,
7947 #[serde(rename = "existing")]
7948 Existing,
7949}
7950
7951#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7953#[serde(rename_all = "camelCase")]
7954pub struct ThreadAttachmentAddParams {
7955 #[serde(rename = "attachmentType", default)]
7956 pub attachment_type: String,
7957 #[serde(rename = "identityKey", default)]
7958 pub identity_key: String,
7959 #[serde(default)]
7960 pub payload: Value,
7961 #[serde(rename = "threadId", default)]
7962 pub thread_id: String,
7963}
7964
7965#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7967#[serde(rename_all = "camelCase")]
7968pub struct ThreadAttachmentAddResponse {
7969 pub attachment: ThreadAttachment,
7970 pub outcome: ThreadAttachmentAddOutcome,
7971}
7972
7973#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7975#[serde(rename_all = "camelCase")]
7976pub struct ThreadAttachmentListParams {
7977 #[serde(default, skip_serializing_if = "Option::is_none")]
7978 pub cursor: Option<String>,
7979 #[serde(default, skip_serializing_if = "Option::is_none")]
7980 pub limit: Option<i64>,
7981 #[serde(rename = "threadId", default)]
7982 pub thread_id: String,
7983}
7984
7985#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
7987#[serde(rename_all = "camelCase")]
7988pub struct ThreadAttachmentListResponse {
7989 #[serde(default)]
7990 pub data: Vec<ThreadAttachment>,
7991 #[serde(
7992 rename = "nextCursor",
7993 default,
7994 skip_serializing_if = "Option::is_none"
7995 )]
7996 pub next_cursor: Option<String>,
7997}
7998
7999#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8001pub enum ThreadAttachmentOperation {
8002 #[serde(rename = "created")]
8003 Created,
8004 #[serde(rename = "deleted")]
8005 Deleted,
8006}
8007
8008#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8010#[serde(rename_all = "camelCase")]
8011pub struct ThreadAttachmentOwner {
8012 #[serde(default)]
8014 pub archived: bool,
8015 #[serde(rename = "threadId", default)]
8016 pub thread_id: String,
8017}
8018
8019#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8021#[serde(rename_all = "camelCase")]
8022pub struct ThreadAttachmentOwnerListParams {
8023 #[serde(default, skip_serializing_if = "Option::is_none")]
8025 pub archived: Option<bool>,
8026 #[serde(rename = "attachmentType", default)]
8027 pub attachment_type: String,
8028 #[serde(default, skip_serializing_if = "Option::is_none")]
8029 pub cursor: Option<String>,
8030 #[serde(rename = "identityKey", default)]
8031 pub identity_key: String,
8032 #[serde(default, skip_serializing_if = "Option::is_none")]
8033 pub limit: Option<i64>,
8034}
8035
8036#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8038#[serde(rename_all = "camelCase")]
8039pub struct ThreadAttachmentOwnerListResponse {
8040 #[serde(default)]
8041 pub data: Vec<ThreadAttachmentOwner>,
8042 #[serde(
8043 rename = "nextCursor",
8044 default,
8045 skip_serializing_if = "Option::is_none"
8046 )]
8047 pub next_cursor: Option<String>,
8048}
8049
8050#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8052#[serde(rename_all = "camelCase")]
8053pub struct ThreadAttachmentRemoveParams {
8054 #[serde(rename = "attachmentType", default)]
8055 pub attachment_type: String,
8056 #[serde(rename = "identityKey", default)]
8057 pub identity_key: String,
8058 #[serde(rename = "threadId", default)]
8059 pub thread_id: String,
8060}
8061
8062#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8064#[serde(rename_all = "camelCase")]
8065pub struct ThreadAttachmentRemoveResponse {
8066 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8067 pub extra: serde_json::Map<String, Value>,
8068}
8069
8070#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8072#[serde(rename_all = "camelCase")]
8073pub struct ThreadAttachmentUpdatedNotification {
8074 #[serde(rename = "attachmentId", default)]
8075 pub attachment_id: String,
8076 #[serde(rename = "attachmentType", default)]
8077 pub attachment_type: String,
8078 #[serde(rename = "identityKey", default)]
8079 pub identity_key: String,
8080 pub operation: ThreadAttachmentOperation,
8081 #[serde(rename = "threadId", default)]
8082 pub thread_id: String,
8083}
8084
8085#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8086#[serde(rename_all = "camelCase")]
8087pub struct ThreadClosedNotification {
8088 #[serde(rename = "threadId", default)]
8089 pub thread_id: String,
8090}
8091
8092#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8093#[serde(rename_all = "camelCase")]
8094pub struct ThreadCompactStartParams {
8095 #[serde(rename = "threadId", default)]
8096 pub thread_id: String,
8097}
8098
8099#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8100#[serde(rename_all = "camelCase")]
8101pub struct ThreadCompactStartResponse {
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, Default)]
8107#[serde(rename_all = "camelCase")]
8108pub struct ThreadDeleteParams {
8109 #[serde(rename = "threadId", default)]
8110 pub thread_id: String,
8111}
8112
8113#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8114#[serde(rename_all = "camelCase")]
8115pub struct ThreadDeleteResponse {
8116 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8117 pub extra: serde_json::Map<String, Value>,
8118}
8119
8120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8121#[serde(rename_all = "camelCase")]
8122pub struct ThreadDeletedNotification {
8123 #[serde(rename = "threadId", default)]
8124 pub thread_id: String,
8125}
8126
8127#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8128#[serde(rename_all = "camelCase")]
8129pub struct ThreadForkParams {
8130 #[serde(
8131 rename = "approvalPolicy",
8132 default,
8133 skip_serializing_if = "Option::is_none"
8134 )]
8135 pub approval_policy: Option<AskForApproval>,
8136 #[serde(
8137 rename = "approvalsReviewer",
8138 default,
8139 skip_serializing_if = "Option::is_none"
8140 )]
8141 pub approvals_reviewer: Option<ApprovalsReviewer>,
8142 #[serde(
8143 rename = "baseInstructions",
8144 default,
8145 skip_serializing_if = "Option::is_none"
8146 )]
8147 pub base_instructions: Option<String>,
8148 #[serde(default, skip_serializing_if = "Option::is_none")]
8149 pub config: Option<Value>,
8150 #[serde(default, skip_serializing_if = "Option::is_none")]
8151 pub cwd: Option<String>,
8152 #[serde(
8153 rename = "developerInstructions",
8154 default,
8155 skip_serializing_if = "Option::is_none"
8156 )]
8157 pub developer_instructions: Option<String>,
8158 #[serde(default, skip_serializing_if = "Option::is_none")]
8159 pub ephemeral: Option<bool>,
8160 #[serde(
8161 rename = "excludeTurns",
8162 default,
8163 skip_serializing_if = "Option::is_none"
8164 )]
8165 pub exclude_turns: Option<bool>,
8166 #[serde(
8167 rename = "lastTurnId",
8168 default,
8169 skip_serializing_if = "Option::is_none"
8170 )]
8171 pub last_turn_id: Option<String>,
8172 #[serde(default, skip_serializing_if = "Option::is_none")]
8173 pub model: Option<String>,
8174 #[serde(
8175 rename = "modelProvider",
8176 default,
8177 skip_serializing_if = "Option::is_none"
8178 )]
8179 pub model_provider: Option<String>,
8180 #[serde(default, skip_serializing_if = "Option::is_none")]
8181 pub sandbox: Option<SandboxMode>,
8182 #[serde(
8183 rename = "serviceTier",
8184 default,
8185 skip_serializing_if = "Option::is_none"
8186 )]
8187 pub service_tier: Option<String>,
8188 #[serde(rename = "threadId", default)]
8189 pub thread_id: String,
8190 #[serde(
8191 rename = "threadSource",
8192 default,
8193 skip_serializing_if = "Option::is_none"
8194 )]
8195 pub thread_source: Option<ThreadSource>,
8196}
8197
8198#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8199#[serde(rename_all = "camelCase")]
8200pub struct ThreadForkResponse {
8201 #[serde(rename = "approvalPolicy")]
8202 pub approval_policy: AskForApproval,
8203 #[serde(rename = "approvalsReviewer", default)]
8204 pub approvals_reviewer: Value,
8205 #[serde()]
8206 pub cwd: AbsolutePathBuf,
8207 #[serde(rename = "disabledPluginIds", default)]
8210 pub disabled_plugin_ids: Vec<String>,
8211 #[serde(
8212 rename = "instructionSources",
8213 default,
8214 skip_serializing_if = "Option::is_none"
8215 )]
8216 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8217 #[serde(default)]
8218 pub model: String,
8219 #[serde(rename = "modelProvider", default)]
8220 pub model_provider: String,
8221 #[serde(
8222 rename = "reasoningEffort",
8223 default,
8224 skip_serializing_if = "Option::is_none"
8225 )]
8226 pub reasoning_effort: Option<ReasoningEffort>,
8227 #[serde(default)]
8228 pub sandbox: Value,
8229 #[serde(
8230 rename = "serviceTier",
8231 default,
8232 skip_serializing_if = "Option::is_none"
8233 )]
8234 pub service_tier: Option<String>,
8235 #[serde()]
8236 pub thread: Thread,
8237}
8238
8239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8240#[serde(rename_all = "camelCase")]
8241pub struct ThreadGoal {
8242 #[serde(rename = "createdAt", default)]
8243 pub created_at: i64,
8244 #[serde(default)]
8245 pub objective: String,
8246 #[serde()]
8247 pub status: ThreadGoalStatus,
8248 #[serde(rename = "threadId", default)]
8249 pub thread_id: String,
8250 #[serde(rename = "timeUsedSeconds", default)]
8251 pub time_used_seconds: i64,
8252 #[serde(
8253 rename = "tokenBudget",
8254 default,
8255 skip_serializing_if = "Option::is_none"
8256 )]
8257 pub token_budget: Option<i64>,
8258 #[serde(rename = "tokensUsed", default)]
8259 pub tokens_used: i64,
8260 #[serde(rename = "updatedAt", default)]
8261 pub updated_at: i64,
8262}
8263
8264#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8265#[serde(rename_all = "camelCase")]
8266pub struct ThreadGoalClearParams {
8267 #[serde(default, skip_serializing_if = "Option::is_none")]
8269 pub origin: Option<ThreadGoalMutationOrigin>,
8270 #[serde(rename = "threadId", default)]
8271 pub thread_id: String,
8272}
8273
8274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8275#[serde(rename_all = "camelCase")]
8276pub struct ThreadGoalClearResponse {
8277 #[serde(default)]
8278 pub cleared: bool,
8279}
8280
8281#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8282#[serde(rename_all = "camelCase")]
8283pub struct ThreadGoalClearedNotification {
8284 #[serde(rename = "threadId", default)]
8285 pub thread_id: String,
8286}
8287
8288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8289#[serde(rename_all = "camelCase")]
8290pub struct ThreadGoalGetParams {
8291 #[serde(rename = "threadId", default)]
8292 pub thread_id: String,
8293}
8294
8295#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8296#[serde(rename_all = "camelCase")]
8297pub struct ThreadGoalGetResponse {
8298 #[serde(default, skip_serializing_if = "Option::is_none")]
8299 pub goal: Option<ThreadGoal>,
8300}
8301
8302#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8304pub enum ThreadGoalMutationOrigin {
8305 #[serde(rename = "user")]
8306 User,
8307 #[serde(rename = "automatic")]
8308 Automatic,
8309}
8310
8311#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8312#[serde(rename_all = "camelCase")]
8313pub struct ThreadGoalSetParams {
8314 #[serde(default, skip_serializing_if = "Option::is_none")]
8315 pub objective: Option<String>,
8316 #[serde(default, skip_serializing_if = "Option::is_none")]
8318 pub origin: Option<ThreadGoalMutationOrigin>,
8319 #[serde(default, skip_serializing_if = "Option::is_none")]
8320 pub status: Option<ThreadGoalStatus>,
8321 #[serde(rename = "threadId", default)]
8322 pub thread_id: String,
8323 #[serde(
8324 rename = "tokenBudget",
8325 default,
8326 skip_serializing_if = "Option::is_none"
8327 )]
8328 pub token_budget: Option<i64>,
8329}
8330
8331#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8332#[serde(rename_all = "camelCase")]
8333pub struct ThreadGoalSetResponse {
8334 #[serde()]
8335 pub goal: ThreadGoal,
8336}
8337
8338#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8339pub enum ThreadGoalStatus {
8340 #[serde(rename = "active")]
8341 Active,
8342 #[serde(rename = "paused")]
8343 Paused,
8344 #[serde(rename = "blocked")]
8345 Blocked,
8346 #[serde(rename = "usageLimited")]
8347 UsageLimited,
8348 #[serde(rename = "budgetLimited")]
8349 BudgetLimited,
8350 #[serde(rename = "complete")]
8351 Complete,
8352}
8353
8354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8355#[serde(rename_all = "camelCase")]
8356pub struct ThreadGoalUpdatedNotification {
8357 #[serde()]
8358 pub goal: ThreadGoal,
8359 #[serde(rename = "threadId", default)]
8360 pub thread_id: String,
8361 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8362 pub turn_id: Option<String>,
8363}
8364
8365#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
8366#[serde(transparent)]
8367pub struct ThreadId(pub String);
8368
8369#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8370#[serde(rename_all = "camelCase")]
8371pub struct ThreadInjectItemsParams {
8372 #[serde(default)]
8373 pub items: Vec<Value>,
8374 #[serde(rename = "threadId", default)]
8375 pub thread_id: String,
8376}
8377
8378#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8379#[serde(rename_all = "camelCase")]
8380pub struct ThreadInjectItemsResponse {
8381 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8382 pub extra: serde_json::Map<String, Value>,
8383}
8384
8385#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8387#[serde(rename_all = "camelCase")]
8388pub struct ThreadItem {
8389 #[serde(flatten)]
8390 pub payload: ThreadItemPayload,
8391 #[serde(
8393 rename = "startedAtMs",
8394 default,
8395 skip_serializing_if = "Option::is_none"
8396 )]
8397 pub started_at_ms: Option<i64>,
8398 #[serde(
8400 rename = "completedAtMs",
8401 default,
8402 skip_serializing_if = "Option::is_none"
8403 )]
8404 pub completed_at_ms: Option<i64>,
8405}
8406
8407impl ThreadItem {
8408 pub fn untimed(payload: ThreadItemPayload) -> Self {
8410 Self {
8411 payload,
8412 started_at_ms: None,
8413 completed_at_ms: None,
8414 }
8415 }
8416}
8417
8418impl From<ThreadItemPayload> for ThreadItem {
8419 fn from(payload: ThreadItemPayload) -> Self {
8420 Self::untimed(payload)
8421 }
8422}
8423
8424#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8426#[serde(tag = "type", rename_all = "camelCase")]
8427pub enum ThreadItemPayload {
8428 #[serde(rename = "userMessage")]
8429 UserMessage {
8430 #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
8431 client_id: Option<String>,
8432 content: Vec<UserInput>,
8433 id: String,
8434 },
8435 #[serde(rename = "hookPrompt")]
8436 HookPrompt {
8437 fragments: Vec<HookPromptFragment>,
8438 id: String,
8439 },
8440 #[serde(rename = "agentMessage")]
8441 AgentMessage {
8442 #[serde(default, skip_serializing_if = "Option::is_none")]
8443 delivery: Option<AgentMessageDelivery>,
8444 id: String,
8445 #[serde(
8446 rename = "memoryCitation",
8447 default,
8448 skip_serializing_if = "Option::is_none"
8449 )]
8450 memory_citation: Option<MemoryCitation>,
8451 #[serde(default, skip_serializing_if = "Option::is_none")]
8452 phase: Option<MessagePhase>,
8453 #[serde(default, skip_serializing_if = "Option::is_none")]
8454 questions: Option<Vec<AsyncUserInputQuestion>>,
8455 text: String,
8456 },
8457 Plan {
8458 id: String,
8459 text: String,
8460 },
8461 Reasoning {
8462 #[serde(default, skip_serializing_if = "Option::is_none")]
8463 content: Option<Vec<String>>,
8464 id: String,
8465 #[serde(default, skip_serializing_if = "Option::is_none")]
8466 summary: Option<Vec<String>>,
8467 },
8468 #[serde(rename = "commandExecution")]
8469 CommandExecution {
8470 #[serde(
8471 rename = "aggregatedOutput",
8472 default,
8473 skip_serializing_if = "Option::is_none"
8474 )]
8475 aggregated_output: Option<String>,
8476 command: String,
8477 #[serde(rename = "commandActions")]
8478 command_actions: Vec<CommandAction>,
8479 cwd: Value,
8480 #[serde(
8481 rename = "durationMs",
8482 default,
8483 skip_serializing_if = "Option::is_none"
8484 )]
8485 duration_ms: Option<i64>,
8486 #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
8487 exit_code: Option<i64>,
8488 id: String,
8489 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8490 plugin_id: Option<String>,
8491 #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
8492 process_id: Option<String>,
8493 #[serde(
8494 rename = "scriptPath",
8495 default,
8496 skip_serializing_if = "Option::is_none"
8497 )]
8498 script_path: Option<String>,
8499 #[serde(default, skip_serializing_if = "Option::is_none")]
8500 source: Option<Value>,
8501 status: CommandExecutionStatus,
8502 },
8503 #[serde(rename = "fileChange")]
8504 FileChange {
8505 changes: Vec<FileUpdateChange>,
8506 id: String,
8507 status: PatchApplyStatus,
8508 },
8509 #[serde(rename = "mcpToolCall")]
8510 McpToolCall {
8511 #[serde(
8512 rename = "appContext",
8513 default,
8514 skip_serializing_if = "Option::is_none"
8515 )]
8516 app_context: Option<McpToolCallAppContext>,
8517 arguments: Value,
8518 #[serde(
8519 rename = "durationMs",
8520 default,
8521 skip_serializing_if = "Option::is_none"
8522 )]
8523 duration_ms: Option<i64>,
8524 #[serde(default, skip_serializing_if = "Option::is_none")]
8525 error: Option<McpToolCallError>,
8526 id: String,
8527 #[serde(
8530 rename = "mcpAppResourceUri",
8531 default,
8532 skip_serializing_if = "Option::is_none"
8533 )]
8534 mcp_app_resource_uri: Option<String>,
8535 #[serde(rename = "mcpAppUi", default, skip_serializing_if = "Option::is_none")]
8538 mcp_app_ui: Option<McpAppUi>,
8539 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8540 plugin_id: Option<String>,
8541 #[serde(
8542 rename = "readOnlyHint",
8543 default,
8544 skip_serializing_if = "Option::is_none"
8545 )]
8546 read_only_hint: Option<bool>,
8547 #[serde(default, skip_serializing_if = "Option::is_none")]
8548 result: Option<McpToolCallResult>,
8549 server: String,
8550 status: McpToolCallStatus,
8551 tool: String,
8552 },
8553 #[serde(rename = "dynamicToolCall")]
8554 DynamicToolCall {
8555 arguments: Value,
8556 #[serde(
8557 rename = "contentItems",
8558 default,
8559 skip_serializing_if = "Option::is_none"
8560 )]
8561 content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
8562 #[serde(
8563 rename = "durationMs",
8564 default,
8565 skip_serializing_if = "Option::is_none"
8566 )]
8567 duration_ms: Option<i64>,
8568 id: String,
8569 #[serde(default, skip_serializing_if = "Option::is_none")]
8570 namespace: Option<String>,
8571 status: DynamicToolCallStatus,
8572 #[serde(default, skip_serializing_if = "Option::is_none")]
8573 success: Option<bool>,
8574 tool: String,
8575 },
8576 #[serde(rename = "collabAgentToolCall")]
8577 CollabAgentToolCall {
8578 #[serde(rename = "agentsStates")]
8579 agents_states: std::collections::BTreeMap<String, CollabAgentState>,
8580 id: String,
8581 #[serde(default, skip_serializing_if = "Option::is_none")]
8582 model: Option<String>,
8583 #[serde(default, skip_serializing_if = "Option::is_none")]
8584 prompt: Option<String>,
8585 #[serde(
8586 rename = "reasoningEffort",
8587 default,
8588 skip_serializing_if = "Option::is_none"
8589 )]
8590 reasoning_effort: Option<ReasoningEffort>,
8591 #[serde(rename = "receiverThreadIds")]
8592 receiver_thread_ids: Vec<String>,
8593 #[serde(rename = "senderThreadId")]
8594 sender_thread_id: String,
8595 status: Value,
8596 tool: Value,
8597 },
8598 #[serde(rename = "subAgentActivity")]
8599 SubAgentActivity {
8600 #[serde(rename = "agentPath")]
8601 agent_path: String,
8602 #[serde(rename = "agentThreadId")]
8603 agent_thread_id: String,
8604 id: String,
8605 kind: SubAgentActivityKind,
8606 #[serde(default, skip_serializing_if = "Option::is_none")]
8609 model: Option<String>,
8610 #[serde(
8612 rename = "reasoningEffort",
8613 default,
8614 skip_serializing_if = "Option::is_none"
8615 )]
8616 reasoning_effort: Option<ReasoningEffort>,
8617 },
8618 #[serde(rename = "webSearch")]
8619 WebSearch {
8620 #[serde(default, skip_serializing_if = "Option::is_none")]
8621 action: Option<WebSearchAction>,
8622 id: String,
8623 query: String,
8624 #[serde(default, skip_serializing_if = "Option::is_none")]
8625 results: Option<Vec<Value>>,
8626 },
8627 #[serde(rename = "imageView")]
8628 ImageView {
8629 id: String,
8630 path: LegacyAppPathString,
8631 },
8632 Sleep {
8633 #[serde(rename = "durationMs")]
8634 duration_ms: i64,
8635 id: String,
8636 },
8637 #[serde(rename = "imageGeneration")]
8638 ImageGeneration {
8639 #[serde(default, skip_serializing_if = "Option::is_none")]
8640 failure: Option<ImageGenerationFailure>,
8641 #[serde(
8643 rename = "generationId",
8644 default,
8645 skip_serializing_if = "Option::is_none"
8646 )]
8647 generation_id: Option<String>,
8648 id: String,
8649 #[serde(flatten)]
8650 image: GeneratedImageRef,
8651 #[serde(
8653 rename = "inputImages",
8654 default,
8655 skip_serializing_if = "Option::is_none"
8656 )]
8657 input_images: Option<Vec<ImageGenerationInputImage>>,
8658 #[serde(
8659 rename = "revisedPrompt",
8660 default,
8661 skip_serializing_if = "Option::is_none"
8662 )]
8663 revised_prompt: Option<String>,
8664 #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
8665 saved_path: Option<AbsolutePathBuf>,
8666 status: String,
8667 #[serde(
8668 rename = "transparentBackground",
8669 default,
8670 skip_serializing_if = "Option::is_none"
8671 )]
8672 transparent_background: Option<bool>,
8673 },
8674 #[serde(rename = "enteredReviewMode")]
8675 EnteredReviewMode {
8676 id: String,
8677 review: String,
8678 },
8679 #[serde(rename = "exitedReviewMode")]
8680 ExitedReviewMode {
8681 id: String,
8682 review: String,
8683 },
8684 #[serde(rename = "contextCompaction")]
8685 ContextCompaction {
8686 id: String,
8687 },
8688 #[serde(rename = "functionCallOutput")]
8689 FunctionCallOutput {
8690 id: String,
8691 name: String,
8692 #[serde(default, skip_serializing_if = "Option::is_none")]
8693 namespace: Option<String>,
8694 output: FunctionCallOutputBody,
8695 },
8696}
8697
8698#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8699#[serde(untagged)]
8700pub enum ThreadListCwdFilter {
8701 Variant0(String),
8702 Variant1(Vec<String>),
8703}
8704
8705#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8706#[serde(rename_all = "camelCase")]
8707pub struct ThreadListParams {
8708 #[serde(default, skip_serializing_if = "Option::is_none")]
8709 pub archived: Option<bool>,
8710 #[serde(
8713 rename = "currentAccountOnly",
8714 default,
8715 skip_serializing_if = "Option::is_none"
8716 )]
8717 pub current_account_only: Option<bool>,
8718 #[serde(default, skip_serializing_if = "Option::is_none")]
8719 pub cursor: Option<String>,
8720 #[serde(default, skip_serializing_if = "Option::is_none")]
8721 pub cwd: Option<ThreadListCwdFilter>,
8722 #[serde(
8727 rename = "excludedThreadIds",
8728 default,
8729 skip_serializing_if = "Option::is_none"
8730 )]
8731 pub excluded_thread_ids: Option<Vec<String>>,
8732 #[serde(default, skip_serializing_if = "Option::is_none")]
8733 pub limit: Option<i64>,
8734 #[serde(
8735 rename = "modelProviders",
8736 default,
8737 skip_serializing_if = "Option::is_none"
8738 )]
8739 pub model_providers: Option<Vec<String>>,
8740 #[serde(default, skip_serializing_if = "Option::is_none")]
8744 pub originators: Option<Vec<String>>,
8745 #[serde(
8746 rename = "searchTerm",
8747 default,
8748 skip_serializing_if = "Option::is_none"
8749 )]
8750 pub search_term: Option<String>,
8751 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8752 pub section_id: Option<String>,
8753 #[serde(
8754 rename = "sortDirection",
8755 default,
8756 skip_serializing_if = "Option::is_none"
8757 )]
8758 pub sort_direction: Option<SortDirection>,
8759 #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
8760 pub sort_key: Option<ThreadSortKey>,
8761 #[serde(
8762 rename = "sourceKinds",
8763 default,
8764 skip_serializing_if = "Option::is_none"
8765 )]
8766 pub source_kinds: Option<Vec<ThreadSourceKind>>,
8767 #[serde(
8768 rename = "useStateDbOnly",
8769 default,
8770 skip_serializing_if = "Option::is_none"
8771 )]
8772 pub use_state_db_only: Option<bool>,
8773}
8774
8775#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8776#[serde(rename_all = "camelCase")]
8777pub struct ThreadListResponse {
8778 #[serde(
8779 rename = "backwardsCursor",
8780 default,
8781 skip_serializing_if = "Option::is_none"
8782 )]
8783 pub backwards_cursor: Option<String>,
8784 #[serde(default)]
8785 pub data: Vec<Thread>,
8786 #[serde(
8787 rename = "nextCursor",
8788 default,
8789 skip_serializing_if = "Option::is_none"
8790 )]
8791 pub next_cursor: Option<String>,
8792}
8793
8794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8795#[serde(rename_all = "camelCase")]
8796pub struct ThreadLoadedListParams {
8797 #[serde(default, skip_serializing_if = "Option::is_none")]
8798 pub cursor: Option<String>,
8799 #[serde(default, skip_serializing_if = "Option::is_none")]
8800 pub limit: Option<i64>,
8801}
8802
8803#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8804#[serde(rename_all = "camelCase")]
8805pub struct ThreadLoadedListResponse {
8806 #[serde(default)]
8807 pub data: Vec<String>,
8808 #[serde(
8809 rename = "nextCursor",
8810 default,
8811 skip_serializing_if = "Option::is_none"
8812 )]
8813 pub next_cursor: Option<String>,
8814}
8815
8816#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8817#[serde(rename_all = "camelCase")]
8818pub struct ThreadMetadataGitInfoUpdateParams {
8819 #[serde(default, skip_serializing_if = "Option::is_none")]
8820 pub branch: Option<String>,
8821 #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
8822 pub origin_url: Option<String>,
8823 #[serde(default, skip_serializing_if = "Option::is_none")]
8824 pub sha: Option<String>,
8825}
8826
8827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8828#[serde(rename_all = "camelCase")]
8829pub struct ThreadMetadataUpdateParams {
8830 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
8831 pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
8832 #[serde(rename = "threadId", default)]
8833 pub thread_id: String,
8834}
8835
8836#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8837#[serde(rename_all = "camelCase")]
8838pub struct ThreadMetadataUpdateResponse {
8839 #[serde()]
8840 pub thread: Thread,
8841}
8842
8843#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8844#[serde(rename_all = "camelCase")]
8845pub struct ThreadNameUpdatedNotification {
8846 #[serde(rename = "threadId", default)]
8847 pub thread_id: String,
8848 #[serde(
8849 rename = "threadName",
8850 default,
8851 skip_serializing_if = "Option::is_none"
8852 )]
8853 pub thread_name: Option<String>,
8854}
8855
8856#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8857#[serde(rename_all = "camelCase")]
8858pub struct ThreadReadParams {
8859 #[serde(
8860 rename = "includeTurns",
8861 default,
8862 skip_serializing_if = "Option::is_none"
8863 )]
8864 pub include_turns: Option<bool>,
8865 #[serde(rename = "threadId", default)]
8866 pub thread_id: String,
8867}
8868
8869#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8870#[serde(rename_all = "camelCase")]
8871pub struct ThreadReadResponse {
8872 #[serde()]
8873 pub thread: Thread,
8874}
8875
8876#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8879#[serde(rename_all = "camelCase")]
8880pub struct ThreadReadState {
8881 #[serde(
8882 rename = "firstUnread",
8883 default,
8884 skip_serializing_if = "Option::is_none"
8885 )]
8886 pub first_unread: Option<ThreadUnreadPosition>,
8887 #[serde(default)]
8888 pub revision: String,
8889}
8890
8891#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8892#[serde(rename_all = "camelCase")]
8893pub struct ThreadReadStateChangedNotification {
8894 #[serde(rename = "readState")]
8895 pub read_state: ThreadReadState,
8896 #[serde(rename = "threadId", default)]
8897 pub thread_id: String,
8898}
8899
8900#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
8902#[serde(rename_all = "camelCase")]
8903pub struct ThreadSectionChangedNotification {
8904 #[serde(rename = "threadId")]
8905 pub thread_id: String,
8906 #[serde(rename = "sectionId")]
8909 pub section_id: Option<String>,
8910}
8911
8912#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8913#[serde(rename_all = "camelCase")]
8914pub struct ThreadRealtimeAudioChunk {
8915 #[serde(default)]
8916 pub data: String,
8917 #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
8918 pub item_id: Option<String>,
8919 #[serde(rename = "numChannels", default)]
8920 pub num_channels: i64,
8921 #[serde(rename = "sampleRate", default)]
8922 pub sample_rate: i64,
8923 #[serde(
8924 rename = "samplesPerChannel",
8925 default,
8926 skip_serializing_if = "Option::is_none"
8927 )]
8928 pub samples_per_channel: Option<i64>,
8929}
8930
8931#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8932#[serde(rename_all = "camelCase")]
8933pub struct ThreadRealtimeClosedNotification {
8934 #[serde(default, skip_serializing_if = "Option::is_none")]
8935 pub reason: Option<String>,
8936 #[serde(rename = "threadId", default)]
8937 pub thread_id: String,
8938}
8939
8940#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8941#[serde(rename_all = "camelCase")]
8942pub struct ThreadRealtimeErrorNotification {
8943 #[serde(default)]
8944 pub message: String,
8945 #[serde(rename = "threadId", default)]
8946 pub thread_id: String,
8947}
8948
8949#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8950#[serde(rename_all = "camelCase")]
8951pub struct ThreadRealtimeItemAddedNotification {
8952 #[serde(default)]
8953 pub item: Value,
8954 #[serde(rename = "threadId", default)]
8955 pub thread_id: String,
8956}
8957
8958#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8959#[serde(rename_all = "camelCase")]
8960pub struct ThreadRealtimeOutputAudioDeltaNotification {
8961 #[serde()]
8962 pub audio: ThreadRealtimeAudioChunk,
8963 #[serde(rename = "threadId", default)]
8964 pub thread_id: String,
8965}
8966
8967#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8968#[serde(rename_all = "camelCase")]
8969pub struct ThreadRealtimeSdpNotification {
8970 #[serde(default)]
8971 pub sdp: String,
8972 #[serde(rename = "threadId", default)]
8973 pub thread_id: String,
8974}
8975
8976#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8977#[serde(rename_all = "camelCase")]
8978pub struct ThreadRealtimeStartedNotification {
8979 #[serde(
8980 rename = "realtimeSessionId",
8981 default,
8982 skip_serializing_if = "Option::is_none"
8983 )]
8984 pub realtime_session_id: Option<String>,
8985 #[serde(rename = "threadId", default)]
8986 pub thread_id: String,
8987 #[serde()]
8988 pub version: RealtimeConversationVersion,
8989}
8990
8991#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8992#[serde(rename_all = "camelCase")]
8993pub struct ThreadRealtimeTranscriptDeltaNotification {
8994 #[serde(default)]
8995 pub delta: String,
8996 #[serde(default)]
8997 pub role: String,
8998 #[serde(rename = "threadId", default)]
8999 pub thread_id: String,
9000}
9001
9002#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9003#[serde(rename_all = "camelCase")]
9004pub struct ThreadRealtimeTranscriptDoneNotification {
9005 #[serde(default)]
9006 pub role: String,
9007 #[serde(default)]
9008 pub text: String,
9009 #[serde(rename = "threadId", default)]
9010 pub thread_id: String,
9011}
9012
9013#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9014#[serde(rename_all = "camelCase")]
9015pub struct ThreadResumeParams {
9016 #[serde(
9017 rename = "approvalPolicy",
9018 default,
9019 skip_serializing_if = "Option::is_none"
9020 )]
9021 pub approval_policy: Option<AskForApproval>,
9022 #[serde(
9023 rename = "approvalsReviewer",
9024 default,
9025 skip_serializing_if = "Option::is_none"
9026 )]
9027 pub approvals_reviewer: Option<ApprovalsReviewer>,
9028 #[serde(
9029 rename = "baseInstructions",
9030 default,
9031 skip_serializing_if = "Option::is_none"
9032 )]
9033 pub base_instructions: Option<String>,
9034 #[serde(default, skip_serializing_if = "Option::is_none")]
9035 pub config: Option<Value>,
9036 #[serde(default, skip_serializing_if = "Option::is_none")]
9037 pub cwd: Option<String>,
9038 #[serde(
9039 rename = "developerInstructions",
9040 default,
9041 skip_serializing_if = "Option::is_none"
9042 )]
9043 pub developer_instructions: Option<String>,
9044 #[serde(default, skip_serializing_if = "Option::is_none")]
9045 pub model: Option<String>,
9046 #[serde(
9047 rename = "modelProvider",
9048 default,
9049 skip_serializing_if = "Option::is_none"
9050 )]
9051 pub model_provider: Option<String>,
9052 #[serde(default, skip_serializing_if = "Option::is_none")]
9053 pub personality: Option<Personality>,
9054 #[serde(default, skip_serializing_if = "Option::is_none")]
9055 pub sandbox: Option<SandboxMode>,
9056 #[serde(
9057 rename = "serviceTier",
9058 default,
9059 skip_serializing_if = "Option::is_none"
9060 )]
9061 pub service_tier: Option<String>,
9062 #[serde(rename = "threadId", default)]
9063 pub thread_id: String,
9064 #[serde(
9065 rename = "excludeTurns",
9066 default,
9067 skip_serializing_if = "Option::is_none"
9068 )]
9069 pub exclude_turns: Option<bool>,
9070}
9071
9072#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9073#[serde(rename_all = "camelCase")]
9074pub struct ThreadResumeResponse {
9075 #[serde(rename = "approvalPolicy")]
9076 pub approval_policy: AskForApproval,
9077 #[serde(rename = "approvalsReviewer", default)]
9078 pub approvals_reviewer: Value,
9079 #[serde(
9082 rename = "collaborationMode",
9083 default,
9084 skip_serializing_if = "Option::is_none"
9085 )]
9086 pub collaboration_mode: Option<CollaborationMode>,
9087 #[serde()]
9088 pub cwd: AbsolutePathBuf,
9089 #[serde(rename = "disabledPluginIds", default)]
9092 pub disabled_plugin_ids: Vec<String>,
9093 #[serde(
9094 rename = "instructionSources",
9095 default,
9096 skip_serializing_if = "Option::is_none"
9097 )]
9098 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9099 #[serde(
9102 rename = "itemsBackwardsCursor",
9103 default,
9104 skip_serializing_if = "Option::is_none"
9105 )]
9106 pub items_backwards_cursor: Option<String>,
9107 #[serde(default)]
9108 pub model: String,
9109 #[serde(rename = "modelProvider", default)]
9110 pub model_provider: String,
9111 #[serde(
9112 rename = "reasoningEffort",
9113 default,
9114 skip_serializing_if = "Option::is_none"
9115 )]
9116 pub reasoning_effort: Option<ReasoningEffort>,
9117 #[serde(default)]
9118 pub sandbox: Value,
9119 #[serde(
9120 rename = "serviceTier",
9121 default,
9122 skip_serializing_if = "Option::is_none"
9123 )]
9124 pub service_tier: Option<String>,
9125 #[serde()]
9126 pub thread: Thread,
9127 #[serde(
9130 rename = "turnsBackwardsCursor",
9131 default,
9132 skip_serializing_if = "Option::is_none"
9133 )]
9134 pub turns_backwards_cursor: Option<String>,
9135}
9136
9137#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9139pub enum ThreadHistoryMode {
9140 #[serde(rename = "legacy")]
9141 Legacy,
9142 #[serde(rename = "paginated")]
9143 Paginated,
9144}
9145
9146#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9149#[serde(rename_all = "camelCase")]
9150pub struct ThreadItemEntry {
9151 #[serde(
9154 rename = "completedAtMs",
9155 default,
9156 skip_serializing_if = "Option::is_none"
9157 )]
9158 pub completed_at_ms: Option<i64>,
9159 #[serde()]
9160 pub item: ThreadItem,
9161 #[serde(
9166 rename = "outputDeferred",
9167 default,
9168 skip_serializing_if = "std::ops::Not::not"
9169 )]
9170 pub output_deferred: bool,
9171 #[serde(
9174 rename = "startedAtMs",
9175 default,
9176 skip_serializing_if = "Option::is_none"
9177 )]
9178 pub started_at_ms: Option<i64>,
9179 #[serde(rename = "turnId", default)]
9180 pub turn_id: String,
9181}
9182
9183#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9185#[serde(rename_all = "camelCase")]
9186pub struct ThreadItemsListParams {
9187 #[serde(default, skip_serializing_if = "Option::is_none")]
9193 pub cursor: Option<ThreadItemsListCursor>,
9194 #[serde(
9197 rename = "deferOutput",
9198 default,
9199 skip_serializing_if = "Option::is_none"
9200 )]
9201 pub defer_output: Option<ThreadItemOutputDeferral>,
9202 #[serde(default, skip_serializing_if = "Option::is_none")]
9203 pub limit: Option<u32>,
9204 #[serde(
9205 rename = "sortDirection",
9206 default,
9207 skip_serializing_if = "Option::is_none"
9208 )]
9209 pub sort_direction: Option<SortDirection>,
9210 #[serde(rename = "threadId", default)]
9211 pub thread_id: String,
9212 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
9214 pub turn_id: Option<String>,
9215}
9216
9217#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
9222#[serde(rename_all = "camelCase")]
9223pub struct ThreadItemOutputDeferral {
9224 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9227 pub command_execution: bool,
9228}
9229
9230#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9235#[serde(untagged)]
9236pub enum ThreadItemsListCursor {
9237 Opaque(String),
9238 Anchor(ThreadItemsListAnchor),
9239}
9240
9241#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9244#[serde(tag = "type", rename_all = "camelCase")]
9245pub enum ThreadItemsListAnchor {
9246 Item {
9247 #[serde(rename = "itemId")]
9248 item_id: String,
9249 },
9250}
9251
9252#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9254#[serde(rename_all = "camelCase")]
9255pub struct ThreadItemsListResponse {
9256 #[serde(
9257 rename = "backwardsCursor",
9258 default,
9259 skip_serializing_if = "Option::is_none"
9260 )]
9261 pub backwards_cursor: Option<String>,
9262 #[serde(default)]
9263 pub data: Vec<ThreadItemEntry>,
9264 #[serde(
9265 rename = "nextCursor",
9266 default,
9267 skip_serializing_if = "Option::is_none"
9268 )]
9269 pub next_cursor: Option<String>,
9270}
9271
9272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9276pub struct ThreadRealtimeItem {
9277 #[serde(default)]
9278 pub id: String,
9279 #[serde(rename = "realtimeSessionId", default)]
9280 pub realtime_session_id: String,
9281 #[serde(flatten)]
9282 pub detail: ThreadRealtimeItemDetail,
9283}
9284
9285#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9287#[serde(tag = "type", rename_all = "camelCase")]
9288pub enum ThreadRealtimeItemDetail {
9289 #[serde(rename = "realtimeSessionStarted")]
9290 RealtimeSessionStarted,
9291 #[serde(rename = "transcriptSegment")]
9292 TranscriptSegment {
9293 role: ThreadRealtimeTranscriptRole,
9294 text: String,
9295 },
9296 #[serde(rename = "bemItemPromoted")]
9297 BemItemPromoted {
9298 item_id: String,
9299 presentation: ThreadRealtimeBemItemPresentation,
9300 turn_id: String,
9301 },
9302 #[serde(rename = "realtimeSessionClosed")]
9303 RealtimeSessionClosed {
9304 outcome: ThreadRealtimeSessionOutcome,
9305 },
9306}
9307
9308#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9311#[serde(tag = "type", rename_all = "camelCase")]
9312pub enum ThreadRealtimeBemItemPresentation {
9313 #[serde(rename = "wholeItem")]
9314 WholeItem,
9315 #[serde(rename = "inlineMarkdown")]
9316 InlineMarkdown,
9317 #[serde(rename = "inlineVisualization")]
9318 InlineVisualization { index: u32 },
9319}
9320
9321#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9323#[serde(rename_all = "camelCase")]
9324pub struct ThreadRealtimeItemStartedNotification {
9325 #[serde()]
9326 pub item: ThreadRealtimeItem,
9327 #[serde(rename = "threadId", default)]
9328 pub thread_id: String,
9329}
9330
9331#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9333#[serde(rename_all = "camelCase")]
9334pub struct ThreadRealtimeItemCompletedNotification {
9335 #[serde()]
9336 pub item: ThreadRealtimeItem,
9337 #[serde(rename = "threadId", default)]
9338 pub thread_id: String,
9339}
9340
9341#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9344#[serde(rename_all = "camelCase")]
9345pub struct ThreadRealtimeItemTranscriptDeltaNotification {
9346 #[serde(default)]
9347 pub delta: String,
9348 #[serde(rename = "itemId", default)]
9349 pub item_id: String,
9350 #[serde(rename = "threadId", default)]
9351 pub thread_id: String,
9352}
9353
9354#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9356pub enum ThreadRealtimeSessionOutcome {
9357 #[serde(rename = "ended")]
9358 Ended,
9359 #[serde(rename = "failed")]
9360 Failed,
9361}
9362
9363#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9365pub enum ThreadRealtimeTranscriptRole {
9366 #[serde(rename = "user")]
9367 User,
9368 #[serde(rename = "assistant")]
9369 Assistant,
9370}
9371
9372#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9376#[serde(rename_all = "camelCase")]
9377pub struct ThreadRevertParams {
9378 #[serde(rename = "beforeTurnId", default)]
9380 pub before_turn_id: String,
9381 #[serde(rename = "threadId", default)]
9382 pub thread_id: String,
9383}
9384
9385#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9388#[serde(rename_all = "camelCase")]
9389pub struct ThreadRevertResponse {
9390 #[serde(
9391 rename = "itemsBackwardsCursor",
9392 default,
9393 skip_serializing_if = "Option::is_none"
9394 )]
9395 pub items_backwards_cursor: Option<String>,
9396 #[serde()]
9397 pub thread: Thread,
9398 #[serde(
9399 rename = "turnsBackwardsCursor",
9400 default,
9401 skip_serializing_if = "Option::is_none"
9402 )]
9403 pub turns_backwards_cursor: Option<String>,
9404}
9405
9406#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9407#[serde(rename_all = "camelCase")]
9408pub struct ThreadSection {
9409 #[serde(default, skip_serializing_if = "Option::is_none")]
9410 pub appearance: Option<ThreadSectionAppearance>,
9411 #[serde(default)]
9412 pub id: String,
9413 #[serde(default)]
9414 pub name: String,
9415}
9416
9417#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9418#[serde(rename_all = "camelCase")]
9419pub struct ThreadSectionAppearance {
9420 #[serde(default, skip_serializing_if = "Option::is_none")]
9421 pub color: Option<String>,
9422 #[serde(default, skip_serializing_if = "Option::is_none")]
9423 pub icon: Option<String>,
9424}
9425
9426#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9427#[serde(rename_all = "camelCase")]
9428pub struct ThreadSectionCreateParams {
9429 #[serde(default, skip_serializing_if = "Option::is_none")]
9430 pub appearance: Option<ThreadSectionAppearance>,
9431 #[serde(default)]
9432 pub name: String,
9433}
9434
9435#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9436#[serde(rename_all = "camelCase")]
9437pub struct ThreadSectionCreateResponse {
9438 #[serde()]
9439 pub section: ThreadSection,
9440}
9441
9442#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9443#[serde(rename_all = "camelCase")]
9444pub struct ThreadSectionDeleteParams {
9445 #[serde(rename = "sectionId", default)]
9446 pub section_id: String,
9447}
9448
9449#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9450#[serde(rename_all = "camelCase")]
9451pub struct ThreadSectionDeleteResponse {
9452 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9453 pub extra: serde_json::Map<String, Value>,
9454}
9455
9456#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9457#[serde(rename_all = "camelCase")]
9458pub struct ThreadSectionListParams {
9459 #[serde(default, skip_serializing_if = "Option::is_none")]
9460 pub cursor: Option<String>,
9461 #[serde(default, skip_serializing_if = "Option::is_none")]
9462 pub limit: Option<i64>,
9463}
9464
9465#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9466#[serde(rename_all = "camelCase")]
9467pub struct ThreadSectionListResponse {
9468 #[serde(default)]
9469 pub data: Vec<ThreadSection>,
9470 #[serde(
9471 rename = "nextCursor",
9472 default,
9473 skip_serializing_if = "Option::is_none"
9474 )]
9475 pub next_cursor: Option<String>,
9476}
9477
9478#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9479#[serde(rename_all = "camelCase")]
9480pub struct ThreadSectionMoveParams {
9481 #[serde(
9482 rename = "beforeThreadId",
9483 default,
9484 skip_serializing_if = "Option::is_none"
9485 )]
9486 pub before_thread_id: Option<String>,
9487 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
9488 pub section_id: Option<String>,
9489 #[serde(rename = "threadId", default)]
9490 pub thread_id: String,
9491}
9492
9493#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9494#[serde(rename_all = "camelCase")]
9495pub struct ThreadSectionMoveResponse {
9496 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9497 pub extra: serde_json::Map<String, Value>,
9498}
9499
9500#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9501#[serde(rename_all = "camelCase")]
9502pub struct ThreadSectionUpdateParams {
9503 #[serde(default, skip_serializing_if = "Option::is_none")]
9504 pub appearance: Option<ThreadSectionAppearance>,
9505 #[serde(default)]
9506 pub name: String,
9507 #[serde(rename = "sectionId", default)]
9508 pub section_id: String,
9509}
9510
9511#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9512#[serde(rename_all = "camelCase")]
9513pub struct ThreadSectionUpdateResponse {
9514 #[serde()]
9515 pub section: ThreadSection,
9516}
9517
9518#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9519#[serde(rename_all = "camelCase")]
9520pub struct ThreadSetNameParams {
9521 #[serde(default)]
9522 pub name: String,
9523 #[serde(rename = "threadId", default)]
9524 pub thread_id: String,
9525}
9526
9527#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9528#[serde(rename_all = "camelCase")]
9529pub struct ThreadSetNameResponse {
9530 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9531 pub extra: serde_json::Map<String, Value>,
9532}
9533
9534#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9535#[serde(rename_all = "camelCase")]
9536pub struct ThreadSettings {
9537 #[serde(
9538 rename = "activePermissionProfile",
9539 default,
9540 skip_serializing_if = "Option::is_none"
9541 )]
9542 pub active_permission_profile: Option<ActivePermissionProfile>,
9543 #[serde(rename = "approvalPolicy")]
9544 pub approval_policy: AskForApproval,
9545 #[serde(rename = "approvalsReviewer")]
9546 pub approvals_reviewer: ApprovalsReviewer,
9547 #[serde(rename = "collaborationMode")]
9548 pub collaboration_mode: CollaborationMode,
9549 #[serde()]
9550 pub cwd: AbsolutePathBuf,
9551 #[serde(rename = "disabledPluginIds", default)]
9554 pub disabled_plugin_ids: Vec<String>,
9555 #[serde(default, skip_serializing_if = "Option::is_none")]
9556 pub effort: Option<ReasoningEffort>,
9557 #[serde(default)]
9558 pub model: String,
9559 #[serde(rename = "modelProvider", default)]
9560 pub model_provider: String,
9561 #[serde(default, skip_serializing_if = "Option::is_none")]
9562 pub personality: Option<Personality>,
9563 #[serde(rename = "sandboxPolicy")]
9564 pub sandbox_policy: SandboxPolicy,
9565 #[serde(
9566 rename = "serviceTier",
9567 default,
9568 skip_serializing_if = "Option::is_none"
9569 )]
9570 pub service_tier: Option<String>,
9571 #[serde(default, skip_serializing_if = "Option::is_none")]
9572 pub summary: Option<ReasoningSummary>,
9573}
9574
9575#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9576#[serde(rename_all = "camelCase")]
9577pub struct ThreadSettingsUpdatedNotification {
9578 #[serde(rename = "threadId", default)]
9579 pub thread_id: String,
9580 #[serde(rename = "threadSettings")]
9581 pub thread_settings: ThreadSettings,
9582}
9583
9584#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9585#[serde(rename_all = "camelCase")]
9586pub struct ThreadShellCommandParams {
9587 #[serde(default)]
9588 pub command: String,
9589 #[serde(rename = "threadId", default)]
9590 pub thread_id: String,
9591 #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
9594 pub timeout_ms: Option<i64>,
9595}
9596
9597#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9598#[serde(rename_all = "camelCase")]
9599pub struct ThreadShellCommandResponse {
9600 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9601 pub extra: serde_json::Map<String, Value>,
9602}
9603
9604#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9605pub enum ThreadSortKey {
9606 #[serde(rename = "created_at")]
9607 Created_at,
9608 #[serde(rename = "updated_at")]
9609 Updated_at,
9610 #[serde(rename = "recency_at")]
9611 Recency_at,
9612 #[serde(rename = "section_position")]
9613 Section_position,
9614}
9615
9616#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
9617#[serde(transparent)]
9618pub struct ThreadSource(pub String);
9619
9620#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9621pub enum ThreadSourceKind {
9622 #[serde(rename = "cli")]
9623 Cli,
9624 #[serde(rename = "vscode")]
9625 Vscode,
9626 #[serde(rename = "exec")]
9627 Exec,
9628 #[serde(rename = "appServer")]
9629 AppServer,
9630 #[serde(rename = "subAgent")]
9631 SubAgent,
9632 #[serde(rename = "subAgentReview")]
9633 SubAgentReview,
9634 #[serde(rename = "subAgentCompact")]
9635 SubAgentCompact,
9636 #[serde(rename = "subAgentThreadSpawn")]
9637 SubAgentThreadSpawn,
9638 #[serde(rename = "subAgentOther")]
9639 SubAgentOther,
9640 #[serde(rename = "unknown")]
9641 Unknown,
9642}
9643
9644#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9645#[serde(rename_all = "camelCase")]
9646pub struct ThreadStartParams {
9647 #[serde(
9648 rename = "approvalPolicy",
9649 default,
9650 skip_serializing_if = "Option::is_none"
9651 )]
9652 pub approval_policy: Option<AskForApproval>,
9653 #[serde(
9654 rename = "approvalsReviewer",
9655 default,
9656 skip_serializing_if = "Option::is_none"
9657 )]
9658 pub approvals_reviewer: Option<ApprovalsReviewer>,
9659 #[serde(
9660 rename = "baseInstructions",
9661 default,
9662 skip_serializing_if = "Option::is_none"
9663 )]
9664 pub base_instructions: Option<String>,
9665 #[serde(default, skip_serializing_if = "Option::is_none")]
9666 pub config: Option<Value>,
9667 #[serde(default, skip_serializing_if = "Option::is_none")]
9668 pub cwd: Option<String>,
9669 #[serde(
9670 rename = "developerInstructions",
9671 default,
9672 skip_serializing_if = "Option::is_none"
9673 )]
9674 pub developer_instructions: Option<String>,
9675 #[serde(default, skip_serializing_if = "Option::is_none")]
9676 pub ephemeral: Option<bool>,
9677 #[serde(default, skip_serializing_if = "Option::is_none")]
9678 pub model: Option<String>,
9679 #[serde(
9680 rename = "modelProvider",
9681 default,
9682 skip_serializing_if = "Option::is_none"
9683 )]
9684 pub model_provider: Option<String>,
9685 #[serde(default, skip_serializing_if = "Option::is_none")]
9686 pub personality: Option<Personality>,
9687 #[serde(default, skip_serializing_if = "Option::is_none")]
9688 pub sandbox: Option<SandboxMode>,
9689 #[serde(
9690 rename = "serviceName",
9691 default,
9692 skip_serializing_if = "Option::is_none"
9693 )]
9694 pub service_name: Option<String>,
9695 #[serde(
9696 rename = "serviceTier",
9697 default,
9698 skip_serializing_if = "Option::is_none"
9699 )]
9700 pub service_tier: Option<String>,
9701 #[serde(
9702 rename = "sessionStartSource",
9703 default,
9704 skip_serializing_if = "Option::is_none"
9705 )]
9706 pub session_start_source: Option<ThreadStartSource>,
9707 #[serde(
9708 rename = "threadSource",
9709 default,
9710 skip_serializing_if = "Option::is_none"
9711 )]
9712 pub thread_source: Option<ThreadSource>,
9713}
9714
9715#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9716#[serde(rename_all = "camelCase")]
9717pub struct ThreadStartResponse {
9718 #[serde(rename = "approvalPolicy")]
9719 pub approval_policy: AskForApproval,
9720 #[serde(rename = "approvalsReviewer", default)]
9721 pub approvals_reviewer: Value,
9722 #[serde()]
9723 pub cwd: AbsolutePathBuf,
9724 #[serde(rename = "disabledPluginIds", default)]
9727 pub disabled_plugin_ids: Vec<String>,
9728 #[serde(
9729 rename = "instructionSources",
9730 default,
9731 skip_serializing_if = "Option::is_none"
9732 )]
9733 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9734 #[serde(default)]
9735 pub model: String,
9736 #[serde(rename = "modelProvider", default)]
9737 pub model_provider: String,
9738 #[serde(
9739 rename = "reasoningEffort",
9740 default,
9741 skip_serializing_if = "Option::is_none"
9742 )]
9743 pub reasoning_effort: Option<ReasoningEffort>,
9744 #[serde(default)]
9745 pub sandbox: Value,
9746 #[serde(
9747 rename = "serviceTier",
9748 default,
9749 skip_serializing_if = "Option::is_none"
9750 )]
9751 pub service_tier: Option<String>,
9752 #[serde()]
9753 pub thread: Thread,
9754}
9755
9756#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9757pub enum ThreadStartSource {
9758 #[serde(rename = "startup")]
9759 Startup,
9760 #[serde(rename = "clear")]
9761 Clear,
9762}
9763
9764#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9765#[serde(rename_all = "camelCase")]
9766pub struct ThreadStartedNotification {
9767 #[serde()]
9768 pub thread: Thread,
9769}
9770
9771#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9772#[serde(tag = "type", rename_all = "camelCase")]
9773pub enum ThreadStatus {
9774 #[serde(rename = "notLoaded")]
9775 NotLoaded,
9776 Idle,
9777 #[serde(rename = "systemError")]
9778 SystemError,
9779 Active {
9780 #[serde(rename = "activeFlags")]
9781 active_flags: Vec<ThreadActiveFlag>,
9782 },
9783}
9784
9785#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9786#[serde(rename_all = "camelCase")]
9787pub struct ThreadStatusChangedNotification {
9788 #[serde()]
9789 pub status: ThreadStatus,
9790 #[serde(rename = "threadId", default)]
9791 pub thread_id: String,
9792}
9793
9794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9795#[serde(rename_all = "camelCase")]
9796pub struct ThreadTokenUsage {
9797 #[serde()]
9798 pub last: TokenUsageBreakdown,
9799 #[serde(
9800 rename = "modelContextWindow",
9801 default,
9802 skip_serializing_if = "Option::is_none"
9803 )]
9804 pub model_context_window: Option<i64>,
9805 #[serde()]
9806 pub total: TokenUsageBreakdown,
9807}
9808
9809#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9810#[serde(rename_all = "camelCase")]
9811pub struct ThreadTokenUsageUpdatedNotification {
9812 #[serde(rename = "threadId", default)]
9813 pub thread_id: String,
9814 #[serde(rename = "tokenUsage")]
9815 pub token_usage: ThreadTokenUsage,
9816 #[serde(rename = "turnId", default)]
9817 pub turn_id: String,
9818}
9819
9820#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9821#[serde(rename_all = "camelCase")]
9822pub struct ThreadUnarchiveParams {
9823 #[serde(rename = "threadId", default)]
9824 pub thread_id: String,
9825}
9826
9827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9828#[serde(rename_all = "camelCase")]
9829pub struct ThreadUnarchiveResponse {
9830 #[serde()]
9831 pub thread: Thread,
9832}
9833
9834#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9835#[serde(rename_all = "camelCase")]
9836pub struct ThreadUnarchivedNotification {
9837 #[serde(rename = "threadId", default)]
9838 pub thread_id: String,
9839}
9840
9841#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9842#[serde(tag = "type", rename_all = "camelCase")]
9843pub enum ThreadUnreadPosition {
9844 #[serde(rename = "threadStart")]
9846 ThreadStart,
9847 Turn {
9849 #[serde(rename = "turnId")]
9850 turn_id: String,
9851 },
9852}
9853
9854#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9859#[serde(tag = "type", rename_all = "camelCase")]
9860#[allow(clippy::large_enum_variant)] pub enum ThreadTimelineEntry {
9862 Item {
9863 item: ThreadItem,
9864 position: u64,
9865 #[serde(rename = "turnId")]
9866 turn_id: String,
9867 },
9868 Realtime {
9869 item: ThreadRealtimeItem,
9870 position: u64,
9871 },
9872 TurnStarted {
9873 position: u64,
9874 #[serde(default, skip_serializing_if = "Option::is_none")]
9875 started_at: Option<i64>,
9876 turn_id: String,
9877 },
9878 TurnCompleted {
9879 #[serde(default, skip_serializing_if = "Option::is_none")]
9880 completed_at: Option<i64>,
9881 #[serde(default, skip_serializing_if = "Option::is_none")]
9882 duration_ms: Option<i64>,
9883 #[serde(default, skip_serializing_if = "Option::is_none")]
9884 error: Option<TurnError>,
9885 position: u64,
9886 #[serde(default, skip_serializing_if = "Option::is_none")]
9887 started_at: Option<i64>,
9888 status: TurnStatus,
9889 turn_id: String,
9890 },
9891}
9892
9893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9895#[serde(rename_all = "camelCase")]
9896pub struct ThreadTurnsListParams {
9897 #[serde(default, skip_serializing_if = "Option::is_none")]
9898 pub cursor: Option<String>,
9899 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9901 pub items_view: Option<TurnItemsView>,
9902 #[serde(default, skip_serializing_if = "Option::is_none")]
9903 pub limit: Option<u32>,
9904 #[serde(
9905 rename = "sortDirection",
9906 default,
9907 skip_serializing_if = "Option::is_none"
9908 )]
9909 pub sort_direction: Option<SortDirection>,
9910 #[serde(rename = "threadId", default)]
9911 pub thread_id: String,
9912}
9913
9914#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9916#[serde(rename_all = "camelCase")]
9917pub struct ThreadTurnsListResponse {
9918 #[serde(
9919 rename = "backwardsCursor",
9920 default,
9921 skip_serializing_if = "Option::is_none"
9922 )]
9923 pub backwards_cursor: Option<String>,
9924 #[serde(default)]
9925 pub data: Vec<Turn>,
9926 #[serde(
9927 rename = "nextCursor",
9928 default,
9929 skip_serializing_if = "Option::is_none"
9930 )]
9931 pub next_cursor: Option<String>,
9932}
9933
9934#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9935#[serde(rename_all = "camelCase")]
9936pub struct ThreadUnsubscribeParams {
9937 #[serde(rename = "threadId", default)]
9938 pub thread_id: String,
9939}
9940
9941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9942#[serde(rename_all = "camelCase")]
9943pub struct ThreadUnsubscribeResponse {
9944 #[serde()]
9945 pub status: ThreadUnsubscribeStatus,
9946}
9947
9948#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9949pub enum ThreadUnsubscribeStatus {
9950 #[serde(rename = "notLoaded")]
9951 NotLoaded,
9952 #[serde(rename = "notSubscribed")]
9953 NotSubscribed,
9954 #[serde(rename = "unsubscribed")]
9955 Unsubscribed,
9956}
9957
9958#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9959#[serde(rename_all = "camelCase")]
9960pub struct TokenUsageBreakdown {
9961 #[serde(
9962 rename = "cacheWriteInputTokens",
9963 default,
9964 skip_serializing_if = "Option::is_none"
9965 )]
9966 pub cache_write_input_tokens: Option<i64>,
9967 #[serde(rename = "cachedInputTokens", default)]
9968 pub cached_input_tokens: i64,
9969 #[serde(rename = "inputTokens", default)]
9970 pub input_tokens: i64,
9971 #[serde(rename = "outputTokens", default)]
9972 pub output_tokens: i64,
9973 #[serde(rename = "reasoningOutputTokens", default)]
9974 pub reasoning_output_tokens: i64,
9975 #[serde(rename = "totalTokens", default)]
9976 pub total_tokens: i64,
9977}
9978
9979#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9980#[serde(rename_all = "camelCase")]
9981pub struct Tool {
9982 #[serde(default, skip_serializing_if = "Option::is_none")]
9983 pub _meta: Option<Value>,
9984 #[serde(default, skip_serializing_if = "Option::is_none")]
9985 pub annotations: Option<Value>,
9986 #[serde(default, skip_serializing_if = "Option::is_none")]
9987 pub description: Option<String>,
9988 #[serde(default, skip_serializing_if = "Option::is_none")]
9989 pub icons: Option<Vec<Value>>,
9990 #[serde(rename = "inputSchema", default)]
9991 pub input_schema: Value,
9992 #[serde(default)]
9993 pub name: String,
9994 #[serde(
9995 rename = "outputSchema",
9996 default,
9997 skip_serializing_if = "Option::is_none"
9998 )]
9999 pub output_schema: Option<Value>,
10000 #[serde(default, skip_serializing_if = "Option::is_none")]
10001 pub title: Option<String>,
10002}
10003
10004#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10005#[serde(rename_all = "camelCase")]
10006pub struct ToolRequestUserInputAnswer {
10007 #[serde(default)]
10008 pub answers: Vec<String>,
10009}
10010
10011#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10012#[serde(rename_all = "camelCase")]
10013pub struct ToolRequestUserInputOption {
10014 #[serde(default)]
10015 pub description: String,
10016 #[serde(default)]
10017 pub label: String,
10018}
10019
10020#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10021#[serde(rename_all = "camelCase")]
10022pub struct ToolRequestUserInputParams {
10023 #[serde(
10024 rename = "autoResolutionMs",
10025 default,
10026 skip_serializing_if = "Option::is_none"
10027 )]
10028 pub auto_resolution_ms: Option<i64>,
10029 #[serde(rename = "isBlocking", default)]
10030 pub is_blocking: bool,
10031 #[serde(rename = "itemId", default)]
10032 pub item_id: String,
10033 #[serde(default)]
10034 pub questions: Vec<ToolRequestUserInputQuestion>,
10035 #[serde(rename = "threadId", default)]
10036 pub thread_id: String,
10037 #[serde(rename = "turnId", default)]
10038 pub turn_id: String,
10039}
10040
10041#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10042#[serde(rename_all = "camelCase")]
10043pub struct ToolRequestUserInputQuestion {
10044 #[serde(default)]
10045 pub header: String,
10046 #[serde(default)]
10047 pub id: String,
10048 #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
10049 pub is_other: Option<bool>,
10050 #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
10051 pub is_secret: Option<bool>,
10052 #[serde(default, skip_serializing_if = "Option::is_none")]
10053 pub options: Option<Vec<ToolRequestUserInputOption>>,
10054 #[serde(default)]
10055 pub question: String,
10056}
10057
10058#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10059#[serde(rename_all = "camelCase")]
10060pub struct ToolRequestUserInputResponse {
10061 #[serde(default)]
10062 pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
10063}
10064
10065#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10066#[serde(rename_all = "camelCase")]
10067pub struct ToolsV2 {
10068 #[serde(default, skip_serializing_if = "Option::is_none")]
10069 pub web_search: Option<WebSearchToolConfig>,
10070}
10071
10072#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10073#[serde(rename_all = "camelCase")]
10074pub struct Turn {
10075 #[serde(
10076 rename = "completedAt",
10077 default,
10078 skip_serializing_if = "Option::is_none"
10079 )]
10080 pub completed_at: Option<i64>,
10081 #[serde(
10082 rename = "durationMs",
10083 default,
10084 skip_serializing_if = "Option::is_none"
10085 )]
10086 pub duration_ms: Option<i64>,
10087 #[serde(default, skip_serializing_if = "Option::is_none")]
10088 pub error: Option<TurnError>,
10089 #[serde(default)]
10090 pub id: String,
10091 #[serde(default)]
10092 pub items: Vec<ThreadItem>,
10093 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
10094 pub items_view: Option<Value>,
10095 #[serde(
10099 rename = "rootTurnId",
10100 default,
10101 skip_serializing_if = "Option::is_none"
10102 )]
10103 pub root_turn_id: Option<String>,
10104 #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
10105 pub started_at: Option<i64>,
10106 #[serde()]
10107 pub status: TurnStatus,
10108}
10109
10110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10111#[serde(rename_all = "camelCase")]
10112pub struct TurnCompletedNotification {
10113 #[serde(rename = "threadId", default)]
10114 pub thread_id: String,
10115 #[serde()]
10116 pub turn: Turn,
10117}
10118
10119#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10120#[serde(rename_all = "camelCase")]
10121pub struct TurnDiffUpdatedNotification {
10122 #[serde(default)]
10123 pub diff: String,
10124 #[serde(rename = "threadId", default)]
10125 pub thread_id: String,
10126 #[serde(rename = "turnId", default)]
10127 pub turn_id: String,
10128}
10129
10130#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10131#[serde(rename_all = "camelCase")]
10132pub struct TurnError {
10133 #[serde(
10134 rename = "additionalDetails",
10135 default,
10136 skip_serializing_if = "Option::is_none"
10137 )]
10138 pub additional_details: Option<String>,
10139 #[serde(
10140 rename = "codexErrorInfo",
10141 default,
10142 skip_serializing_if = "Option::is_none"
10143 )]
10144 pub codex_error_info: Option<CodexErrorInfo>,
10145 #[serde(default)]
10146 pub message: String,
10147 #[serde(default, skip_serializing_if = "Option::is_none")]
10150 pub misalignment: Option<MisalignmentErrorDetails>,
10151}
10152
10153#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10154#[serde(rename_all = "camelCase")]
10155pub struct TurnInterruptParams {
10156 #[serde(rename = "threadId", default)]
10157 pub thread_id: String,
10158 #[serde(rename = "turnId", default)]
10159 pub turn_id: String,
10160}
10161
10162#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10163#[serde(rename_all = "camelCase")]
10164pub struct TurnInterruptResponse {
10165 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
10166 pub extra: serde_json::Map<String, Value>,
10167}
10168
10169#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
10170pub enum TurnItemsView {
10171 #[serde(rename = "notLoaded")]
10172 NotLoaded,
10173 #[serde(rename = "summary")]
10174 Summary,
10175 #[serde(rename = "full")]
10176 Full,
10177}
10178
10179#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10180#[serde(rename_all = "camelCase")]
10181pub struct TurnModerationMetadataNotification {
10182 #[serde(default)]
10183 pub metadata: Value,
10184 #[serde(rename = "threadId", default)]
10185 pub thread_id: String,
10186 #[serde(rename = "turnId", default)]
10187 pub turn_id: String,
10188}
10189
10190#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10191#[serde(rename_all = "camelCase")]
10192pub struct TurnPlanStep {
10193 #[serde()]
10194 pub status: TurnPlanStepStatus,
10195 #[serde(default)]
10196 pub step: String,
10197}
10198
10199#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10200pub enum TurnPlanStepStatus {
10201 #[serde(rename = "pending")]
10202 Pending,
10203 #[serde(rename = "inProgress")]
10204 InProgress,
10205 #[serde(rename = "completed")]
10206 Completed,
10207}
10208
10209#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10210#[serde(rename_all = "camelCase")]
10211pub struct TurnPlanUpdatedNotification {
10212 #[serde(default, skip_serializing_if = "Option::is_none")]
10213 pub explanation: Option<String>,
10214 #[serde(default)]
10215 pub plan: Vec<TurnPlanStep>,
10216 #[serde(rename = "threadId", default)]
10217 pub thread_id: String,
10218 #[serde(rename = "turnId", default)]
10219 pub turn_id: String,
10220}
10221
10222#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10223#[serde(rename_all = "camelCase")]
10224pub struct TurnStartParams {
10225 #[serde(
10226 rename = "approvalPolicy",
10227 default,
10228 skip_serializing_if = "Option::is_none"
10229 )]
10230 pub approval_policy: Option<AskForApproval>,
10231 #[serde(
10232 rename = "approvalsReviewer",
10233 default,
10234 skip_serializing_if = "Option::is_none"
10235 )]
10236 pub approvals_reviewer: Option<ApprovalsReviewer>,
10237 #[serde(
10238 rename = "clientUserMessageId",
10239 default,
10240 skip_serializing_if = "Option::is_none"
10241 )]
10242 pub client_user_message_id: Option<String>,
10243 #[serde(default, skip_serializing_if = "Option::is_none")]
10244 pub cwd: Option<String>,
10245 #[serde(
10248 rename = "disabledPluginIds",
10249 default,
10250 skip_serializing_if = "Option::is_none"
10251 )]
10252 pub disabled_plugin_ids: Option<Vec<String>>,
10253 #[serde(default, skip_serializing_if = "Option::is_none")]
10254 pub effort: Option<ReasoningEffort>,
10255 #[serde(default)]
10256 pub input: Vec<UserInput>,
10257 #[serde(default, skip_serializing_if = "Option::is_none")]
10258 pub model: Option<String>,
10259 #[serde(
10260 rename = "outputSchema",
10261 default,
10262 skip_serializing_if = "Option::is_none"
10263 )]
10264 pub output_schema: Option<Value>,
10265 #[serde(
10269 rename = "parentTurnId",
10270 default,
10271 skip_serializing_if = "Option::is_none"
10272 )]
10273 pub parent_turn_id: Option<String>,
10274 #[serde(default, skip_serializing_if = "Option::is_none")]
10275 pub personality: Option<Personality>,
10276 #[serde(
10281 rename = "rootTurnId",
10282 default,
10283 skip_serializing_if = "Option::is_none"
10284 )]
10285 pub root_turn_id: Option<String>,
10286 #[serde(
10287 rename = "sandboxPolicy",
10288 default,
10289 skip_serializing_if = "Option::is_none"
10290 )]
10291 pub sandbox_policy: Option<SandboxPolicy>,
10292 #[serde(
10293 rename = "serviceTier",
10294 default,
10295 skip_serializing_if = "Option::is_none"
10296 )]
10297 pub service_tier: Option<String>,
10298 #[serde(
10301 rename = "serviceTierForTurn",
10302 default,
10303 skip_serializing_if = "Option::is_none"
10304 )]
10305 pub service_tier_for_turn: Option<String>,
10306 #[serde(default, skip_serializing_if = "Option::is_none")]
10307 pub summary: Option<ReasoningSummary>,
10308 #[serde(rename = "threadId", default)]
10309 pub thread_id: String,
10310 #[serde(
10313 rename = "toolOutput",
10314 default,
10315 skip_serializing_if = "Option::is_none"
10316 )]
10317 pub tool_output: Option<TurnToolOutput>,
10318 #[serde(
10321 rename = "turnTrigger",
10322 default,
10323 skip_serializing_if = "Option::is_none"
10324 )]
10325 pub turn_trigger: Option<String>,
10326}
10327
10328#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10329#[serde(rename_all = "camelCase")]
10330pub struct TurnStartResponse {
10331 #[serde()]
10332 pub turn: Turn,
10333}
10334
10335#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10336#[serde(rename_all = "camelCase")]
10337pub struct TurnStartedNotification {
10338 #[serde(rename = "threadId", default)]
10339 pub thread_id: String,
10340 #[serde()]
10341 pub turn: Turn,
10342}
10343
10344#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10345pub enum TurnStatus {
10346 #[serde(rename = "completed")]
10347 Completed,
10348 #[serde(rename = "interrupted")]
10349 Interrupted,
10350 #[serde(rename = "failed")]
10351 Failed,
10352 #[serde(rename = "inProgress")]
10353 InProgress,
10354}
10355
10356#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10359#[serde(rename_all = "camelCase")]
10360pub struct TurnToolOutput {
10361 #[serde(default)]
10362 pub name: String,
10363 #[serde(default, skip_serializing_if = "Option::is_none")]
10364 pub namespace: Option<String>,
10365 #[serde()]
10366 pub output: FunctionCallOutputBody,
10367 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
10370 pub retain: bool,
10371}
10372
10373#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10374#[serde(rename_all = "camelCase")]
10375pub struct TurnSteerParams {
10376 #[serde(
10377 rename = "clientUserMessageId",
10378 default,
10379 skip_serializing_if = "Option::is_none"
10380 )]
10381 pub client_user_message_id: Option<String>,
10382 #[serde(rename = "expectedTurnId", default)]
10383 pub expected_turn_id: String,
10384 #[serde(default)]
10385 pub input: Vec<UserInput>,
10386 #[serde(rename = "threadId", default)]
10387 pub thread_id: String,
10388}
10389
10390#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10391#[serde(rename_all = "camelCase")]
10392pub struct TurnSteerResponse {
10393 #[serde(rename = "turnId", default)]
10394 pub turn_id: String,
10395}
10396
10397#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10398#[serde(tag = "type", rename_all = "camelCase")]
10399pub enum UserInput {
10400 Text {
10401 text: String,
10402 #[serde(default, skip_serializing_if = "Option::is_none")]
10403 text_elements: Option<Vec<TextElement>>,
10404 },
10405 Image {
10406 #[serde(default, skip_serializing_if = "Option::is_none")]
10407 detail: Option<ImageDetail>,
10408 #[serde(flatten)]
10409 image: UserInputImageReference,
10410 },
10411 #[serde(rename = "localImage")]
10412 LocalImage {
10413 #[serde(default, skip_serializing_if = "Option::is_none")]
10414 detail: Option<ImageDetail>,
10415 path: String,
10416 },
10417 Audio {
10418 #[serde(flatten)]
10419 audio: UserInputAudioReference,
10420 },
10421 #[serde(rename = "localAudio")]
10422 LocalAudio {
10423 path: String,
10424 },
10425 Skill {
10426 name: String,
10427 path: String,
10428 },
10429 Mention {
10430 name: String,
10431 path: String,
10432 },
10433}
10434
10435#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10441#[serde(untagged)]
10442pub enum UserInputImageReference {
10443 Inline {
10444 url: String,
10445 },
10446 File {
10447 #[serde(rename = "fileId")]
10448 file_id: String,
10449 },
10450}
10451
10452#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10457#[serde(untagged)]
10458pub enum UserInputAudioReference {
10459 Inline {
10460 url: String,
10461 },
10462 File {
10463 #[serde(rename = "fileId")]
10464 file_id: String,
10465 },
10466}
10467
10468#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10469pub enum Verbosity {
10470 #[serde(rename = "low")]
10471 Low,
10472 #[serde(rename = "medium")]
10473 Medium,
10474 #[serde(rename = "high")]
10475 High,
10476}
10477
10478#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10479#[serde(rename_all = "camelCase")]
10480pub struct WarningNotification {
10481 #[serde(default)]
10482 pub message: String,
10483 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
10484 pub thread_id: Option<String>,
10485}
10486
10487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10488#[serde(tag = "type", rename_all = "camelCase")]
10489pub enum WebSearchAction {
10490 Search {
10491 #[serde(default, skip_serializing_if = "Option::is_none")]
10492 queries: Option<Vec<String>>,
10493 #[serde(default, skip_serializing_if = "Option::is_none")]
10494 query: Option<String>,
10495 },
10496 #[serde(rename = "openPage")]
10497 OpenPage {
10498 #[serde(default, skip_serializing_if = "Option::is_none")]
10499 url: Option<String>,
10500 },
10501 #[serde(rename = "findInPage")]
10502 FindInPage {
10503 #[serde(default, skip_serializing_if = "Option::is_none")]
10504 pattern: Option<String>,
10505 #[serde(default, skip_serializing_if = "Option::is_none")]
10506 url: Option<String>,
10507 },
10508 Other,
10509}
10510
10511#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10512pub enum WebSearchContextSize {
10513 #[serde(rename = "low")]
10514 Low,
10515 #[serde(rename = "medium")]
10516 Medium,
10517 #[serde(rename = "high")]
10518 High,
10519}
10520
10521#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10522#[serde(rename_all = "camelCase")]
10523pub struct WebSearchLocation {
10524 #[serde(default, skip_serializing_if = "Option::is_none")]
10525 pub city: Option<String>,
10526 #[serde(default, skip_serializing_if = "Option::is_none")]
10527 pub country: Option<String>,
10528 #[serde(default, skip_serializing_if = "Option::is_none")]
10529 pub region: Option<String>,
10530 #[serde(default, skip_serializing_if = "Option::is_none")]
10531 pub timezone: Option<String>,
10532}
10533
10534#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10535pub enum WebSearchMode {
10536 #[serde(rename = "disabled")]
10537 Disabled,
10538 #[serde(rename = "cached")]
10539 Cached,
10540 #[serde(rename = "indexed")]
10541 Indexed,
10542 #[serde(rename = "live")]
10543 Live,
10544}
10545
10546#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10549pub enum WebSearchProvider {
10550 #[serde(rename = "standalone")]
10551 Standalone,
10552 #[serde(rename = "search_mcp")]
10553 SearchMcp,
10554}
10555
10556#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10557#[serde(rename_all = "camelCase")]
10558pub struct WebSearchToolConfig {
10559 #[serde(default, skip_serializing_if = "Option::is_none")]
10560 pub allowed_domains: Option<Vec<String>>,
10561 #[serde(default, skip_serializing_if = "Option::is_none")]
10562 pub context_size: Option<WebSearchContextSize>,
10563 #[serde(default, skip_serializing_if = "Option::is_none")]
10564 pub location: Option<WebSearchLocation>,
10565}
10566
10567#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10568pub enum WindowsSandboxReadiness {
10569 #[serde(rename = "ready")]
10570 Ready,
10571 #[serde(rename = "notConfigured")]
10572 NotConfigured,
10573 #[serde(rename = "updateRequired")]
10574 UpdateRequired,
10575}
10576
10577#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10578#[serde(rename_all = "camelCase")]
10579pub struct WindowsSandboxReadinessResponse {
10580 #[serde()]
10581 pub status: WindowsSandboxReadiness,
10582}
10583
10584#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10585#[serde(rename_all = "camelCase")]
10586pub struct WindowsSandboxSetupCompletedNotification {
10587 #[serde(default, skip_serializing_if = "Option::is_none")]
10588 pub error: Option<String>,
10589 #[serde()]
10590 pub mode: WindowsSandboxSetupMode,
10591 #[serde(default)]
10592 pub success: bool,
10593}
10594
10595#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10596pub enum WindowsSandboxSetupMode {
10597 #[serde(rename = "elevated")]
10598 Elevated,
10599 #[serde(rename = "unelevated")]
10600 Unelevated,
10601}
10602
10603#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10607pub enum WindowsSandboxImplementation {
10608 #[serde(rename = "elevated")]
10609 Elevated,
10610 #[serde(rename = "unelevated")]
10611 Unelevated,
10612 #[serde(rename = "mxc")]
10613 Mxc,
10614}
10615
10616#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10617#[serde(rename_all = "camelCase")]
10618pub struct WindowsSandboxSetupStartParams {
10619 #[serde(default, skip_serializing_if = "Option::is_none")]
10620 pub cwd: Option<AbsolutePathBuf>,
10621 #[serde()]
10622 pub mode: WindowsSandboxSetupMode,
10623}
10624
10625#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10626#[serde(rename_all = "camelCase")]
10627pub struct WindowsSandboxSetupStartResponse {
10628 #[serde(default)]
10629 pub started: bool,
10630}
10631
10632#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10633#[serde(rename_all = "camelCase")]
10634pub struct WindowsWorldWritableWarningNotification {
10635 #[serde(rename = "extraCount", default)]
10636 pub extra_count: i64,
10637 #[serde(rename = "failedScan", default)]
10638 pub failed_scan: bool,
10639 #[serde(rename = "samplePaths", default)]
10640 pub sample_paths: Vec<String>,
10641}
10642
10643#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10644#[serde(rename_all = "camelCase")]
10645pub struct WorkspaceMessage {
10646 #[serde(
10647 rename = "archivedAt",
10648 default,
10649 skip_serializing_if = "Option::is_none"
10650 )]
10651 pub archived_at: Option<i64>,
10652 #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
10653 pub created_at: Option<i64>,
10654 #[serde(rename = "messageBody", default)]
10655 pub message_body: String,
10656 #[serde(rename = "messageId", default)]
10657 pub message_id: String,
10658 #[serde(rename = "messageType")]
10659 pub message_type: WorkspaceMessageType,
10660}
10661
10662#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10663pub enum WorkspaceMessageType {
10664 #[serde(rename = "headline")]
10665 Headline,
10666 #[serde(rename = "announcement")]
10667 Announcement,
10668 #[serde(rename = "unknown")]
10669 Unknown,
10670}
10671
10672#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10673pub enum WriteStatus {
10674 #[serde(rename = "ok")]
10675 Ok,
10676 #[serde(rename = "okOverridden")]
10677 OkOverridden,
10678}