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