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