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