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