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