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