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