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