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