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