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