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