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