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)]
8008#[serde(tag = "type", rename_all = "camelCase")]
8009pub enum ThreadItem {
8010 #[serde(rename = "userMessage")]
8011 UserMessage {
8012 #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
8013 client_id: Option<String>,
8014 content: Vec<UserInput>,
8015 id: String,
8016 },
8017 #[serde(rename = "hookPrompt")]
8018 HookPrompt {
8019 fragments: Vec<HookPromptFragment>,
8020 id: String,
8021 },
8022 #[serde(rename = "agentMessage")]
8023 AgentMessage {
8024 #[serde(default, skip_serializing_if = "Option::is_none")]
8025 delivery: Option<AgentMessageDelivery>,
8026 id: String,
8027 #[serde(
8028 rename = "memoryCitation",
8029 default,
8030 skip_serializing_if = "Option::is_none"
8031 )]
8032 memory_citation: Option<MemoryCitation>,
8033 #[serde(default, skip_serializing_if = "Option::is_none")]
8034 phase: Option<MessagePhase>,
8035 #[serde(default, skip_serializing_if = "Option::is_none")]
8036 questions: Option<Vec<AsyncUserInputQuestion>>,
8037 text: String,
8038 },
8039 Plan {
8040 id: String,
8041 text: String,
8042 },
8043 Reasoning {
8044 #[serde(default, skip_serializing_if = "Option::is_none")]
8045 content: Option<Vec<String>>,
8046 id: String,
8047 #[serde(default, skip_serializing_if = "Option::is_none")]
8048 summary: Option<Vec<String>>,
8049 },
8050 #[serde(rename = "commandExecution")]
8051 CommandExecution {
8052 #[serde(
8053 rename = "aggregatedOutput",
8054 default,
8055 skip_serializing_if = "Option::is_none"
8056 )]
8057 aggregated_output: Option<String>,
8058 command: String,
8059 #[serde(rename = "commandActions")]
8060 command_actions: Vec<CommandAction>,
8061 cwd: Value,
8062 #[serde(
8063 rename = "durationMs",
8064 default,
8065 skip_serializing_if = "Option::is_none"
8066 )]
8067 duration_ms: Option<i64>,
8068 #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
8069 exit_code: Option<i64>,
8070 id: String,
8071 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8072 plugin_id: Option<String>,
8073 #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
8074 process_id: Option<String>,
8075 #[serde(
8076 rename = "scriptPath",
8077 default,
8078 skip_serializing_if = "Option::is_none"
8079 )]
8080 script_path: Option<String>,
8081 #[serde(default, skip_serializing_if = "Option::is_none")]
8082 source: Option<Value>,
8083 status: CommandExecutionStatus,
8084 },
8085 #[serde(rename = "fileChange")]
8086 FileChange {
8087 changes: Vec<FileUpdateChange>,
8088 id: String,
8089 status: PatchApplyStatus,
8090 },
8091 #[serde(rename = "mcpToolCall")]
8092 McpToolCall {
8093 #[serde(
8094 rename = "appContext",
8095 default,
8096 skip_serializing_if = "Option::is_none"
8097 )]
8098 app_context: Option<McpToolCallAppContext>,
8099 arguments: Value,
8100 #[serde(
8101 rename = "durationMs",
8102 default,
8103 skip_serializing_if = "Option::is_none"
8104 )]
8105 duration_ms: Option<i64>,
8106 #[serde(default, skip_serializing_if = "Option::is_none")]
8107 error: Option<McpToolCallError>,
8108 id: String,
8109 #[serde(
8112 rename = "mcpAppResourceUri",
8113 default,
8114 skip_serializing_if = "Option::is_none"
8115 )]
8116 mcp_app_resource_uri: Option<String>,
8117 #[serde(rename = "mcpAppUi", default, skip_serializing_if = "Option::is_none")]
8120 mcp_app_ui: Option<McpAppUi>,
8121 #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
8122 plugin_id: Option<String>,
8123 #[serde(
8124 rename = "readOnlyHint",
8125 default,
8126 skip_serializing_if = "Option::is_none"
8127 )]
8128 read_only_hint: Option<bool>,
8129 #[serde(default, skip_serializing_if = "Option::is_none")]
8130 result: Option<McpToolCallResult>,
8131 server: String,
8132 status: McpToolCallStatus,
8133 tool: String,
8134 },
8135 #[serde(rename = "dynamicToolCall")]
8136 DynamicToolCall {
8137 arguments: Value,
8138 #[serde(
8139 rename = "contentItems",
8140 default,
8141 skip_serializing_if = "Option::is_none"
8142 )]
8143 content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
8144 #[serde(
8145 rename = "durationMs",
8146 default,
8147 skip_serializing_if = "Option::is_none"
8148 )]
8149 duration_ms: Option<i64>,
8150 id: String,
8151 #[serde(default, skip_serializing_if = "Option::is_none")]
8152 namespace: Option<String>,
8153 status: DynamicToolCallStatus,
8154 #[serde(default, skip_serializing_if = "Option::is_none")]
8155 success: Option<bool>,
8156 tool: String,
8157 },
8158 #[serde(rename = "collabAgentToolCall")]
8159 CollabAgentToolCall {
8160 #[serde(rename = "agentsStates")]
8161 agents_states: std::collections::BTreeMap<String, CollabAgentState>,
8162 id: String,
8163 #[serde(default, skip_serializing_if = "Option::is_none")]
8164 model: Option<String>,
8165 #[serde(default, skip_serializing_if = "Option::is_none")]
8166 prompt: Option<String>,
8167 #[serde(
8168 rename = "reasoningEffort",
8169 default,
8170 skip_serializing_if = "Option::is_none"
8171 )]
8172 reasoning_effort: Option<ReasoningEffort>,
8173 #[serde(rename = "receiverThreadIds")]
8174 receiver_thread_ids: Vec<String>,
8175 #[serde(rename = "senderThreadId")]
8176 sender_thread_id: String,
8177 status: Value,
8178 tool: Value,
8179 },
8180 #[serde(rename = "subAgentActivity")]
8181 SubAgentActivity {
8182 #[serde(rename = "agentPath")]
8183 agent_path: String,
8184 #[serde(rename = "agentThreadId")]
8185 agent_thread_id: String,
8186 id: String,
8187 kind: SubAgentActivityKind,
8188 #[serde(default, skip_serializing_if = "Option::is_none")]
8191 model: Option<String>,
8192 #[serde(
8194 rename = "reasoningEffort",
8195 default,
8196 skip_serializing_if = "Option::is_none"
8197 )]
8198 reasoning_effort: Option<ReasoningEffort>,
8199 },
8200 #[serde(rename = "webSearch")]
8201 WebSearch {
8202 #[serde(default, skip_serializing_if = "Option::is_none")]
8203 action: Option<WebSearchAction>,
8204 id: String,
8205 query: String,
8206 #[serde(default, skip_serializing_if = "Option::is_none")]
8207 results: Option<Vec<Value>>,
8208 },
8209 #[serde(rename = "imageView")]
8210 ImageView {
8211 id: String,
8212 path: LegacyAppPathString,
8213 },
8214 Sleep {
8215 #[serde(rename = "durationMs")]
8216 duration_ms: i64,
8217 id: String,
8218 },
8219 #[serde(rename = "imageGeneration")]
8220 ImageGeneration {
8221 #[serde(default, skip_serializing_if = "Option::is_none")]
8222 failure: Option<ImageGenerationFailure>,
8223 id: String,
8224 #[serde(flatten)]
8225 image: GeneratedImageRef,
8226 #[serde(
8228 rename = "inputImages",
8229 default,
8230 skip_serializing_if = "Option::is_none"
8231 )]
8232 input_images: Option<Vec<ImageGenerationInputImage>>,
8233 #[serde(
8234 rename = "revisedPrompt",
8235 default,
8236 skip_serializing_if = "Option::is_none"
8237 )]
8238 revised_prompt: Option<String>,
8239 #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
8240 saved_path: Option<AbsolutePathBuf>,
8241 status: String,
8242 #[serde(
8243 rename = "transparentBackground",
8244 default,
8245 skip_serializing_if = "Option::is_none"
8246 )]
8247 transparent_background: Option<bool>,
8248 },
8249 #[serde(rename = "enteredReviewMode")]
8250 EnteredReviewMode {
8251 id: String,
8252 review: String,
8253 },
8254 #[serde(rename = "exitedReviewMode")]
8255 ExitedReviewMode {
8256 id: String,
8257 review: String,
8258 },
8259 #[serde(rename = "contextCompaction")]
8260 ContextCompaction {
8261 id: String,
8262 },
8263 #[serde(rename = "functionCallOutput")]
8264 FunctionCallOutput {
8265 id: String,
8266 name: String,
8267 #[serde(default, skip_serializing_if = "Option::is_none")]
8268 namespace: Option<String>,
8269 output: FunctionCallOutputBody,
8270 },
8271}
8272
8273#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8274#[serde(untagged)]
8275pub enum ThreadListCwdFilter {
8276 Variant0(String),
8277 Variant1(Vec<String>),
8278}
8279
8280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8281#[serde(rename_all = "camelCase")]
8282pub struct ThreadListParams {
8283 #[serde(default, skip_serializing_if = "Option::is_none")]
8284 pub archived: Option<bool>,
8285 #[serde(default, skip_serializing_if = "Option::is_none")]
8286 pub cursor: Option<String>,
8287 #[serde(default, skip_serializing_if = "Option::is_none")]
8288 pub cwd: Option<ThreadListCwdFilter>,
8289 #[serde(
8294 rename = "excludedThreadIds",
8295 default,
8296 skip_serializing_if = "Option::is_none"
8297 )]
8298 pub excluded_thread_ids: Option<Vec<String>>,
8299 #[serde(default, skip_serializing_if = "Option::is_none")]
8300 pub limit: Option<i64>,
8301 #[serde(
8302 rename = "modelProviders",
8303 default,
8304 skip_serializing_if = "Option::is_none"
8305 )]
8306 pub model_providers: Option<Vec<String>>,
8307 #[serde(default, skip_serializing_if = "Option::is_none")]
8311 pub originators: Option<Vec<String>>,
8312 #[serde(
8313 rename = "searchTerm",
8314 default,
8315 skip_serializing_if = "Option::is_none"
8316 )]
8317 pub search_term: Option<String>,
8318 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
8319 pub section_id: Option<String>,
8320 #[serde(
8321 rename = "sortDirection",
8322 default,
8323 skip_serializing_if = "Option::is_none"
8324 )]
8325 pub sort_direction: Option<SortDirection>,
8326 #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
8327 pub sort_key: Option<ThreadSortKey>,
8328 #[serde(
8329 rename = "sourceKinds",
8330 default,
8331 skip_serializing_if = "Option::is_none"
8332 )]
8333 pub source_kinds: Option<Vec<ThreadSourceKind>>,
8334 #[serde(
8335 rename = "useStateDbOnly",
8336 default,
8337 skip_serializing_if = "Option::is_none"
8338 )]
8339 pub use_state_db_only: Option<bool>,
8340}
8341
8342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8343#[serde(rename_all = "camelCase")]
8344pub struct ThreadListResponse {
8345 #[serde(
8346 rename = "backwardsCursor",
8347 default,
8348 skip_serializing_if = "Option::is_none"
8349 )]
8350 pub backwards_cursor: Option<String>,
8351 #[serde(default)]
8352 pub data: Vec<Thread>,
8353 #[serde(
8354 rename = "nextCursor",
8355 default,
8356 skip_serializing_if = "Option::is_none"
8357 )]
8358 pub next_cursor: Option<String>,
8359}
8360
8361#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8362#[serde(rename_all = "camelCase")]
8363pub struct ThreadLoadedListParams {
8364 #[serde(default, skip_serializing_if = "Option::is_none")]
8365 pub cursor: Option<String>,
8366 #[serde(default, skip_serializing_if = "Option::is_none")]
8367 pub limit: Option<i64>,
8368}
8369
8370#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8371#[serde(rename_all = "camelCase")]
8372pub struct ThreadLoadedListResponse {
8373 #[serde(default)]
8374 pub data: Vec<String>,
8375 #[serde(
8376 rename = "nextCursor",
8377 default,
8378 skip_serializing_if = "Option::is_none"
8379 )]
8380 pub next_cursor: Option<String>,
8381}
8382
8383#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8384#[serde(rename_all = "camelCase")]
8385pub struct ThreadMetadataGitInfoUpdateParams {
8386 #[serde(default, skip_serializing_if = "Option::is_none")]
8387 pub branch: Option<String>,
8388 #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
8389 pub origin_url: Option<String>,
8390 #[serde(default, skip_serializing_if = "Option::is_none")]
8391 pub sha: Option<String>,
8392}
8393
8394#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8395#[serde(rename_all = "camelCase")]
8396pub struct ThreadMetadataUpdateParams {
8397 #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
8398 pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
8399 #[serde(rename = "threadId", default)]
8400 pub thread_id: String,
8401}
8402
8403#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8404#[serde(rename_all = "camelCase")]
8405pub struct ThreadMetadataUpdateResponse {
8406 #[serde()]
8407 pub thread: Thread,
8408}
8409
8410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8411#[serde(rename_all = "camelCase")]
8412pub struct ThreadNameUpdatedNotification {
8413 #[serde(rename = "threadId", default)]
8414 pub thread_id: String,
8415 #[serde(
8416 rename = "threadName",
8417 default,
8418 skip_serializing_if = "Option::is_none"
8419 )]
8420 pub thread_name: Option<String>,
8421}
8422
8423#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8424#[serde(rename_all = "camelCase")]
8425pub struct ThreadReadParams {
8426 #[serde(
8427 rename = "includeTurns",
8428 default,
8429 skip_serializing_if = "Option::is_none"
8430 )]
8431 pub include_turns: Option<bool>,
8432 #[serde(rename = "threadId", default)]
8433 pub thread_id: String,
8434}
8435
8436#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8437#[serde(rename_all = "camelCase")]
8438pub struct ThreadReadResponse {
8439 #[serde()]
8440 pub thread: Thread,
8441}
8442
8443#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8446#[serde(rename_all = "camelCase")]
8447pub struct ThreadReadState {
8448 #[serde(
8449 rename = "firstUnread",
8450 default,
8451 skip_serializing_if = "Option::is_none"
8452 )]
8453 pub first_unread: Option<ThreadUnreadPosition>,
8454 #[serde(default)]
8455 pub revision: String,
8456}
8457
8458#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8459#[serde(rename_all = "camelCase")]
8460pub struct ThreadReadStateChangedNotification {
8461 #[serde(rename = "readState")]
8462 pub read_state: ThreadReadState,
8463 #[serde(rename = "threadId", default)]
8464 pub thread_id: String,
8465}
8466
8467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8468#[serde(rename_all = "camelCase")]
8469pub struct ThreadRealtimeAudioChunk {
8470 #[serde(default)]
8471 pub data: String,
8472 #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
8473 pub item_id: Option<String>,
8474 #[serde(rename = "numChannels", default)]
8475 pub num_channels: i64,
8476 #[serde(rename = "sampleRate", default)]
8477 pub sample_rate: i64,
8478 #[serde(
8479 rename = "samplesPerChannel",
8480 default,
8481 skip_serializing_if = "Option::is_none"
8482 )]
8483 pub samples_per_channel: Option<i64>,
8484}
8485
8486#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8487#[serde(rename_all = "camelCase")]
8488pub struct ThreadRealtimeClosedNotification {
8489 #[serde(default, skip_serializing_if = "Option::is_none")]
8490 pub reason: Option<String>,
8491 #[serde(rename = "threadId", default)]
8492 pub thread_id: String,
8493}
8494
8495#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8496#[serde(rename_all = "camelCase")]
8497pub struct ThreadRealtimeErrorNotification {
8498 #[serde(default)]
8499 pub message: String,
8500 #[serde(rename = "threadId", default)]
8501 pub thread_id: String,
8502}
8503
8504#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8505#[serde(rename_all = "camelCase")]
8506pub struct ThreadRealtimeItemAddedNotification {
8507 #[serde(default)]
8508 pub item: Value,
8509 #[serde(rename = "threadId", default)]
8510 pub thread_id: String,
8511}
8512
8513#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8514#[serde(rename_all = "camelCase")]
8515pub struct ThreadRealtimeOutputAudioDeltaNotification {
8516 #[serde()]
8517 pub audio: ThreadRealtimeAudioChunk,
8518 #[serde(rename = "threadId", default)]
8519 pub thread_id: String,
8520}
8521
8522#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8523#[serde(rename_all = "camelCase")]
8524pub struct ThreadRealtimeSdpNotification {
8525 #[serde(default)]
8526 pub sdp: String,
8527 #[serde(rename = "threadId", default)]
8528 pub thread_id: String,
8529}
8530
8531#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8532#[serde(rename_all = "camelCase")]
8533pub struct ThreadRealtimeStartedNotification {
8534 #[serde(
8535 rename = "realtimeSessionId",
8536 default,
8537 skip_serializing_if = "Option::is_none"
8538 )]
8539 pub realtime_session_id: Option<String>,
8540 #[serde(rename = "threadId", default)]
8541 pub thread_id: String,
8542 #[serde()]
8543 pub version: RealtimeConversationVersion,
8544}
8545
8546#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8547#[serde(rename_all = "camelCase")]
8548pub struct ThreadRealtimeTranscriptDeltaNotification {
8549 #[serde(default)]
8550 pub delta: String,
8551 #[serde(default)]
8552 pub role: String,
8553 #[serde(rename = "threadId", default)]
8554 pub thread_id: String,
8555}
8556
8557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8558#[serde(rename_all = "camelCase")]
8559pub struct ThreadRealtimeTranscriptDoneNotification {
8560 #[serde(default)]
8561 pub role: String,
8562 #[serde(default)]
8563 pub text: String,
8564 #[serde(rename = "threadId", default)]
8565 pub thread_id: String,
8566}
8567
8568#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8569#[serde(rename_all = "camelCase")]
8570pub struct ThreadResumeParams {
8571 #[serde(
8572 rename = "approvalPolicy",
8573 default,
8574 skip_serializing_if = "Option::is_none"
8575 )]
8576 pub approval_policy: Option<AskForApproval>,
8577 #[serde(
8578 rename = "approvalsReviewer",
8579 default,
8580 skip_serializing_if = "Option::is_none"
8581 )]
8582 pub approvals_reviewer: Option<ApprovalsReviewer>,
8583 #[serde(
8584 rename = "baseInstructions",
8585 default,
8586 skip_serializing_if = "Option::is_none"
8587 )]
8588 pub base_instructions: Option<String>,
8589 #[serde(default, skip_serializing_if = "Option::is_none")]
8590 pub config: Option<Value>,
8591 #[serde(default, skip_serializing_if = "Option::is_none")]
8592 pub cwd: Option<String>,
8593 #[serde(
8594 rename = "developerInstructions",
8595 default,
8596 skip_serializing_if = "Option::is_none"
8597 )]
8598 pub developer_instructions: Option<String>,
8599 #[serde(default, skip_serializing_if = "Option::is_none")]
8600 pub model: Option<String>,
8601 #[serde(
8602 rename = "modelProvider",
8603 default,
8604 skip_serializing_if = "Option::is_none"
8605 )]
8606 pub model_provider: Option<String>,
8607 #[serde(default, skip_serializing_if = "Option::is_none")]
8608 pub personality: Option<Personality>,
8609 #[serde(default, skip_serializing_if = "Option::is_none")]
8610 pub sandbox: Option<SandboxMode>,
8611 #[serde(
8612 rename = "serviceTier",
8613 default,
8614 skip_serializing_if = "Option::is_none"
8615 )]
8616 pub service_tier: Option<String>,
8617 #[serde(rename = "threadId", default)]
8618 pub thread_id: String,
8619 #[serde(
8620 rename = "excludeTurns",
8621 default,
8622 skip_serializing_if = "Option::is_none"
8623 )]
8624 pub exclude_turns: Option<bool>,
8625}
8626
8627#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8628#[serde(rename_all = "camelCase")]
8629pub struct ThreadResumeResponse {
8630 #[serde(rename = "approvalPolicy")]
8631 pub approval_policy: AskForApproval,
8632 #[serde(rename = "approvalsReviewer", default)]
8633 pub approvals_reviewer: Value,
8634 #[serde(
8637 rename = "collaborationMode",
8638 default,
8639 skip_serializing_if = "Option::is_none"
8640 )]
8641 pub collaboration_mode: Option<CollaborationMode>,
8642 #[serde()]
8643 pub cwd: AbsolutePathBuf,
8644 #[serde(rename = "disabledPluginIds", default)]
8647 pub disabled_plugin_ids: Vec<String>,
8648 #[serde(
8649 rename = "instructionSources",
8650 default,
8651 skip_serializing_if = "Option::is_none"
8652 )]
8653 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
8654 #[serde(
8657 rename = "itemsBackwardsCursor",
8658 default,
8659 skip_serializing_if = "Option::is_none"
8660 )]
8661 pub items_backwards_cursor: Option<String>,
8662 #[serde(default)]
8663 pub model: String,
8664 #[serde(rename = "modelProvider", default)]
8665 pub model_provider: String,
8666 #[serde(
8667 rename = "reasoningEffort",
8668 default,
8669 skip_serializing_if = "Option::is_none"
8670 )]
8671 pub reasoning_effort: Option<ReasoningEffort>,
8672 #[serde(default)]
8673 pub sandbox: Value,
8674 #[serde(
8675 rename = "serviceTier",
8676 default,
8677 skip_serializing_if = "Option::is_none"
8678 )]
8679 pub service_tier: Option<String>,
8680 #[serde()]
8681 pub thread: Thread,
8682 #[serde(
8685 rename = "turnsBackwardsCursor",
8686 default,
8687 skip_serializing_if = "Option::is_none"
8688 )]
8689 pub turns_backwards_cursor: Option<String>,
8690}
8691
8692#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8694pub enum ThreadHistoryMode {
8695 #[serde(rename = "legacy")]
8696 Legacy,
8697 #[serde(rename = "paginated")]
8698 Paginated,
8699}
8700
8701#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8704#[serde(rename_all = "camelCase")]
8705pub struct ThreadItemEntry {
8706 #[serde(
8709 rename = "completedAtMs",
8710 default,
8711 skip_serializing_if = "Option::is_none"
8712 )]
8713 pub completed_at_ms: Option<i64>,
8714 #[serde()]
8715 pub item: ThreadItem,
8716 #[serde(
8719 rename = "startedAtMs",
8720 default,
8721 skip_serializing_if = "Option::is_none"
8722 )]
8723 pub started_at_ms: Option<i64>,
8724 #[serde(rename = "turnId", default)]
8725 pub turn_id: String,
8726}
8727
8728#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8730#[serde(rename_all = "camelCase")]
8731pub struct ThreadItemsListParams {
8732 #[serde(default, skip_serializing_if = "Option::is_none")]
8738 pub cursor: Option<ThreadItemsListCursor>,
8739 #[serde(default, skip_serializing_if = "Option::is_none")]
8740 pub limit: Option<u32>,
8741 #[serde(
8742 rename = "sortDirection",
8743 default,
8744 skip_serializing_if = "Option::is_none"
8745 )]
8746 pub sort_direction: Option<SortDirection>,
8747 #[serde(rename = "threadId", default)]
8748 pub thread_id: String,
8749 #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
8751 pub turn_id: Option<String>,
8752}
8753
8754#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8759#[serde(untagged)]
8760pub enum ThreadItemsListCursor {
8761 Opaque(String),
8762 Anchor(ThreadItemsListAnchor),
8763}
8764
8765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8768#[serde(tag = "type", rename_all = "camelCase")]
8769pub enum ThreadItemsListAnchor {
8770 Item {
8771 #[serde(rename = "itemId")]
8772 item_id: String,
8773 },
8774}
8775
8776#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8778#[serde(rename_all = "camelCase")]
8779pub struct ThreadItemsListResponse {
8780 #[serde(
8781 rename = "backwardsCursor",
8782 default,
8783 skip_serializing_if = "Option::is_none"
8784 )]
8785 pub backwards_cursor: Option<String>,
8786 #[serde(default)]
8787 pub data: Vec<ThreadItemEntry>,
8788 #[serde(
8789 rename = "nextCursor",
8790 default,
8791 skip_serializing_if = "Option::is_none"
8792 )]
8793 pub next_cursor: Option<String>,
8794}
8795
8796#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8800pub struct ThreadRealtimeItem {
8801 #[serde(default)]
8802 pub id: String,
8803 #[serde(rename = "realtimeSessionId", default)]
8804 pub realtime_session_id: String,
8805 #[serde(flatten)]
8806 pub detail: ThreadRealtimeItemDetail,
8807}
8808
8809#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8811#[serde(tag = "type", rename_all = "camelCase")]
8812pub enum ThreadRealtimeItemDetail {
8813 #[serde(rename = "realtimeSessionStarted")]
8814 RealtimeSessionStarted,
8815 #[serde(rename = "transcriptSegment")]
8816 TranscriptSegment {
8817 role: ThreadRealtimeTranscriptRole,
8818 text: String,
8819 },
8820 #[serde(rename = "bemItemPromoted")]
8821 BemItemPromoted {
8822 item_id: String,
8823 presentation: ThreadRealtimeBemItemPresentation,
8824 turn_id: String,
8825 },
8826 #[serde(rename = "realtimeSessionClosed")]
8827 RealtimeSessionClosed {
8828 outcome: ThreadRealtimeSessionOutcome,
8829 },
8830}
8831
8832#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8835#[serde(tag = "type", rename_all = "camelCase")]
8836pub enum ThreadRealtimeBemItemPresentation {
8837 #[serde(rename = "wholeItem")]
8838 WholeItem,
8839 #[serde(rename = "inlineMarkdown")]
8840 InlineMarkdown,
8841 #[serde(rename = "inlineVisualization")]
8842 InlineVisualization { index: u32 },
8843}
8844
8845#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8847#[serde(rename_all = "camelCase")]
8848pub struct ThreadRealtimeItemStartedNotification {
8849 #[serde()]
8850 pub item: ThreadRealtimeItem,
8851 #[serde(rename = "threadId", default)]
8852 pub thread_id: String,
8853}
8854
8855#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8857#[serde(rename_all = "camelCase")]
8858pub struct ThreadRealtimeItemCompletedNotification {
8859 #[serde()]
8860 pub item: ThreadRealtimeItem,
8861 #[serde(rename = "threadId", default)]
8862 pub thread_id: String,
8863}
8864
8865#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8868#[serde(rename_all = "camelCase")]
8869pub struct ThreadRealtimeItemTranscriptDeltaNotification {
8870 #[serde(default)]
8871 pub delta: String,
8872 #[serde(rename = "itemId", default)]
8873 pub item_id: String,
8874 #[serde(rename = "threadId", default)]
8875 pub thread_id: String,
8876}
8877
8878#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8880pub enum ThreadRealtimeSessionOutcome {
8881 #[serde(rename = "ended")]
8882 Ended,
8883 #[serde(rename = "failed")]
8884 Failed,
8885}
8886
8887#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
8889pub enum ThreadRealtimeTranscriptRole {
8890 #[serde(rename = "user")]
8891 User,
8892 #[serde(rename = "assistant")]
8893 Assistant,
8894}
8895
8896#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8900#[serde(rename_all = "camelCase")]
8901pub struct ThreadRevertParams {
8902 #[serde(rename = "beforeTurnId", default)]
8904 pub before_turn_id: String,
8905 #[serde(rename = "threadId", default)]
8906 pub thread_id: String,
8907}
8908
8909#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8912#[serde(rename_all = "camelCase")]
8913pub struct ThreadRevertResponse {
8914 #[serde(
8915 rename = "itemsBackwardsCursor",
8916 default,
8917 skip_serializing_if = "Option::is_none"
8918 )]
8919 pub items_backwards_cursor: Option<String>,
8920 #[serde()]
8921 pub thread: Thread,
8922 #[serde(
8923 rename = "turnsBackwardsCursor",
8924 default,
8925 skip_serializing_if = "Option::is_none"
8926 )]
8927 pub turns_backwards_cursor: Option<String>,
8928}
8929
8930#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8931#[serde(rename_all = "camelCase")]
8932pub struct ThreadSection {
8933 #[serde(default, skip_serializing_if = "Option::is_none")]
8934 pub appearance: Option<ThreadSectionAppearance>,
8935 #[serde(default)]
8936 pub id: String,
8937 #[serde(default)]
8938 pub name: String,
8939}
8940
8941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8942#[serde(rename_all = "camelCase")]
8943pub struct ThreadSectionAppearance {
8944 #[serde(default, skip_serializing_if = "Option::is_none")]
8945 pub color: Option<String>,
8946 #[serde(default, skip_serializing_if = "Option::is_none")]
8947 pub icon: Option<String>,
8948}
8949
8950#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8951#[serde(rename_all = "camelCase")]
8952pub struct ThreadSectionCreateParams {
8953 #[serde(default, skip_serializing_if = "Option::is_none")]
8954 pub appearance: Option<ThreadSectionAppearance>,
8955 #[serde(default)]
8956 pub name: String,
8957}
8958
8959#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8960#[serde(rename_all = "camelCase")]
8961pub struct ThreadSectionCreateResponse {
8962 #[serde()]
8963 pub section: ThreadSection,
8964}
8965
8966#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8967#[serde(rename_all = "camelCase")]
8968pub struct ThreadSectionDeleteParams {
8969 #[serde(rename = "sectionId", default)]
8970 pub section_id: String,
8971}
8972
8973#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8974#[serde(rename_all = "camelCase")]
8975pub struct ThreadSectionDeleteResponse {
8976 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
8977 pub extra: serde_json::Map<String, Value>,
8978}
8979
8980#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8981#[serde(rename_all = "camelCase")]
8982pub struct ThreadSectionListParams {
8983 #[serde(default, skip_serializing_if = "Option::is_none")]
8984 pub cursor: Option<String>,
8985 #[serde(default, skip_serializing_if = "Option::is_none")]
8986 pub limit: Option<i64>,
8987}
8988
8989#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
8990#[serde(rename_all = "camelCase")]
8991pub struct ThreadSectionListResponse {
8992 #[serde(default)]
8993 pub data: Vec<ThreadSection>,
8994 #[serde(
8995 rename = "nextCursor",
8996 default,
8997 skip_serializing_if = "Option::is_none"
8998 )]
8999 pub next_cursor: Option<String>,
9000}
9001
9002#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9003#[serde(rename_all = "camelCase")]
9004pub struct ThreadSectionMoveParams {
9005 #[serde(
9006 rename = "beforeThreadId",
9007 default,
9008 skip_serializing_if = "Option::is_none"
9009 )]
9010 pub before_thread_id: Option<String>,
9011 #[serde(rename = "sectionId", default, skip_serializing_if = "Option::is_none")]
9012 pub section_id: Option<String>,
9013 #[serde(rename = "threadId", default)]
9014 pub thread_id: String,
9015}
9016
9017#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9018#[serde(rename_all = "camelCase")]
9019pub struct ThreadSectionMoveResponse {
9020 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9021 pub extra: serde_json::Map<String, Value>,
9022}
9023
9024#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9025#[serde(rename_all = "camelCase")]
9026pub struct ThreadSectionUpdateParams {
9027 #[serde(default, skip_serializing_if = "Option::is_none")]
9028 pub appearance: Option<ThreadSectionAppearance>,
9029 #[serde(default)]
9030 pub name: String,
9031 #[serde(rename = "sectionId", default)]
9032 pub section_id: String,
9033}
9034
9035#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9036#[serde(rename_all = "camelCase")]
9037pub struct ThreadSectionUpdateResponse {
9038 #[serde()]
9039 pub section: ThreadSection,
9040}
9041
9042#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9043#[serde(rename_all = "camelCase")]
9044pub struct ThreadSetNameParams {
9045 #[serde(default)]
9046 pub name: String,
9047 #[serde(rename = "threadId", default)]
9048 pub thread_id: String,
9049}
9050
9051#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9052#[serde(rename_all = "camelCase")]
9053pub struct ThreadSetNameResponse {
9054 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9055 pub extra: serde_json::Map<String, Value>,
9056}
9057
9058#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9059#[serde(rename_all = "camelCase")]
9060pub struct ThreadSettings {
9061 #[serde(
9062 rename = "activePermissionProfile",
9063 default,
9064 skip_serializing_if = "Option::is_none"
9065 )]
9066 pub active_permission_profile: Option<ActivePermissionProfile>,
9067 #[serde(rename = "approvalPolicy")]
9068 pub approval_policy: AskForApproval,
9069 #[serde(rename = "approvalsReviewer")]
9070 pub approvals_reviewer: ApprovalsReviewer,
9071 #[serde(rename = "collaborationMode")]
9072 pub collaboration_mode: CollaborationMode,
9073 #[serde()]
9074 pub cwd: AbsolutePathBuf,
9075 #[serde(rename = "disabledPluginIds", default)]
9078 pub disabled_plugin_ids: Vec<String>,
9079 #[serde(default, skip_serializing_if = "Option::is_none")]
9080 pub effort: Option<ReasoningEffort>,
9081 #[serde(default)]
9082 pub model: String,
9083 #[serde(rename = "modelProvider", default)]
9084 pub model_provider: String,
9085 #[serde(default, skip_serializing_if = "Option::is_none")]
9086 pub personality: Option<Personality>,
9087 #[serde(rename = "sandboxPolicy")]
9088 pub sandbox_policy: SandboxPolicy,
9089 #[serde(
9090 rename = "serviceTier",
9091 default,
9092 skip_serializing_if = "Option::is_none"
9093 )]
9094 pub service_tier: Option<String>,
9095 #[serde(default, skip_serializing_if = "Option::is_none")]
9096 pub summary: Option<ReasoningSummary>,
9097}
9098
9099#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9100#[serde(rename_all = "camelCase")]
9101pub struct ThreadSettingsUpdatedNotification {
9102 #[serde(rename = "threadId", default)]
9103 pub thread_id: String,
9104 #[serde(rename = "threadSettings")]
9105 pub thread_settings: ThreadSettings,
9106}
9107
9108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9109#[serde(rename_all = "camelCase")]
9110pub struct ThreadShellCommandParams {
9111 #[serde(default)]
9112 pub command: String,
9113 #[serde(rename = "threadId", default)]
9114 pub thread_id: String,
9115 #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
9118 pub timeout_ms: Option<i64>,
9119}
9120
9121#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9122#[serde(rename_all = "camelCase")]
9123pub struct ThreadShellCommandResponse {
9124 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9125 pub extra: serde_json::Map<String, Value>,
9126}
9127
9128#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9129pub enum ThreadSortKey {
9130 #[serde(rename = "created_at")]
9131 Created_at,
9132 #[serde(rename = "updated_at")]
9133 Updated_at,
9134 #[serde(rename = "recency_at")]
9135 Recency_at,
9136 #[serde(rename = "section_position")]
9137 Section_position,
9138}
9139
9140#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
9141#[serde(transparent)]
9142pub struct ThreadSource(pub String);
9143
9144#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9145pub enum ThreadSourceKind {
9146 #[serde(rename = "cli")]
9147 Cli,
9148 #[serde(rename = "vscode")]
9149 Vscode,
9150 #[serde(rename = "exec")]
9151 Exec,
9152 #[serde(rename = "appServer")]
9153 AppServer,
9154 #[serde(rename = "subAgent")]
9155 SubAgent,
9156 #[serde(rename = "subAgentReview")]
9157 SubAgentReview,
9158 #[serde(rename = "subAgentCompact")]
9159 SubAgentCompact,
9160 #[serde(rename = "subAgentThreadSpawn")]
9161 SubAgentThreadSpawn,
9162 #[serde(rename = "subAgentOther")]
9163 SubAgentOther,
9164 #[serde(rename = "unknown")]
9165 Unknown,
9166}
9167
9168#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9169#[serde(rename_all = "camelCase")]
9170pub struct ThreadStartParams {
9171 #[serde(
9172 rename = "approvalPolicy",
9173 default,
9174 skip_serializing_if = "Option::is_none"
9175 )]
9176 pub approval_policy: Option<AskForApproval>,
9177 #[serde(
9178 rename = "approvalsReviewer",
9179 default,
9180 skip_serializing_if = "Option::is_none"
9181 )]
9182 pub approvals_reviewer: Option<ApprovalsReviewer>,
9183 #[serde(
9184 rename = "baseInstructions",
9185 default,
9186 skip_serializing_if = "Option::is_none"
9187 )]
9188 pub base_instructions: Option<String>,
9189 #[serde(default, skip_serializing_if = "Option::is_none")]
9190 pub config: Option<Value>,
9191 #[serde(default, skip_serializing_if = "Option::is_none")]
9192 pub cwd: Option<String>,
9193 #[serde(
9194 rename = "developerInstructions",
9195 default,
9196 skip_serializing_if = "Option::is_none"
9197 )]
9198 pub developer_instructions: Option<String>,
9199 #[serde(default, skip_serializing_if = "Option::is_none")]
9200 pub ephemeral: Option<bool>,
9201 #[serde(default, skip_serializing_if = "Option::is_none")]
9202 pub model: Option<String>,
9203 #[serde(
9204 rename = "modelProvider",
9205 default,
9206 skip_serializing_if = "Option::is_none"
9207 )]
9208 pub model_provider: Option<String>,
9209 #[serde(default, skip_serializing_if = "Option::is_none")]
9210 pub personality: Option<Personality>,
9211 #[serde(default, skip_serializing_if = "Option::is_none")]
9212 pub sandbox: Option<SandboxMode>,
9213 #[serde(
9214 rename = "serviceName",
9215 default,
9216 skip_serializing_if = "Option::is_none"
9217 )]
9218 pub service_name: Option<String>,
9219 #[serde(
9220 rename = "serviceTier",
9221 default,
9222 skip_serializing_if = "Option::is_none"
9223 )]
9224 pub service_tier: Option<String>,
9225 #[serde(
9226 rename = "sessionStartSource",
9227 default,
9228 skip_serializing_if = "Option::is_none"
9229 )]
9230 pub session_start_source: Option<ThreadStartSource>,
9231 #[serde(
9232 rename = "threadSource",
9233 default,
9234 skip_serializing_if = "Option::is_none"
9235 )]
9236 pub thread_source: Option<ThreadSource>,
9237}
9238
9239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9240#[serde(rename_all = "camelCase")]
9241pub struct ThreadStartResponse {
9242 #[serde(rename = "approvalPolicy")]
9243 pub approval_policy: AskForApproval,
9244 #[serde(rename = "approvalsReviewer", default)]
9245 pub approvals_reviewer: Value,
9246 #[serde()]
9247 pub cwd: AbsolutePathBuf,
9248 #[serde(rename = "disabledPluginIds", default)]
9251 pub disabled_plugin_ids: Vec<String>,
9252 #[serde(
9253 rename = "instructionSources",
9254 default,
9255 skip_serializing_if = "Option::is_none"
9256 )]
9257 pub instruction_sources: Option<Vec<LegacyAppPathString>>,
9258 #[serde(default)]
9259 pub model: String,
9260 #[serde(rename = "modelProvider", default)]
9261 pub model_provider: String,
9262 #[serde(
9263 rename = "reasoningEffort",
9264 default,
9265 skip_serializing_if = "Option::is_none"
9266 )]
9267 pub reasoning_effort: Option<ReasoningEffort>,
9268 #[serde(default)]
9269 pub sandbox: Value,
9270 #[serde(
9271 rename = "serviceTier",
9272 default,
9273 skip_serializing_if = "Option::is_none"
9274 )]
9275 pub service_tier: Option<String>,
9276 #[serde()]
9277 pub thread: Thread,
9278}
9279
9280#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9281pub enum ThreadStartSource {
9282 #[serde(rename = "startup")]
9283 Startup,
9284 #[serde(rename = "clear")]
9285 Clear,
9286}
9287
9288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9289#[serde(rename_all = "camelCase")]
9290pub struct ThreadStartedNotification {
9291 #[serde()]
9292 pub thread: Thread,
9293}
9294
9295#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9296#[serde(tag = "type", rename_all = "camelCase")]
9297pub enum ThreadStatus {
9298 #[serde(rename = "notLoaded")]
9299 NotLoaded,
9300 Idle,
9301 #[serde(rename = "systemError")]
9302 SystemError,
9303 Active {
9304 #[serde(rename = "activeFlags")]
9305 active_flags: Vec<ThreadActiveFlag>,
9306 },
9307}
9308
9309#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9310#[serde(rename_all = "camelCase")]
9311pub struct ThreadStatusChangedNotification {
9312 #[serde()]
9313 pub status: ThreadStatus,
9314 #[serde(rename = "threadId", default)]
9315 pub thread_id: String,
9316}
9317
9318#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9319#[serde(rename_all = "camelCase")]
9320pub struct ThreadTokenUsage {
9321 #[serde()]
9322 pub last: TokenUsageBreakdown,
9323 #[serde(
9324 rename = "modelContextWindow",
9325 default,
9326 skip_serializing_if = "Option::is_none"
9327 )]
9328 pub model_context_window: Option<i64>,
9329 #[serde()]
9330 pub total: TokenUsageBreakdown,
9331}
9332
9333#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9334#[serde(rename_all = "camelCase")]
9335pub struct ThreadTokenUsageUpdatedNotification {
9336 #[serde(rename = "threadId", default)]
9337 pub thread_id: String,
9338 #[serde(rename = "tokenUsage")]
9339 pub token_usage: ThreadTokenUsage,
9340 #[serde(rename = "turnId", default)]
9341 pub turn_id: String,
9342}
9343
9344#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9345#[serde(rename_all = "camelCase")]
9346pub struct ThreadUnarchiveParams {
9347 #[serde(rename = "threadId", default)]
9348 pub thread_id: String,
9349}
9350
9351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9352#[serde(rename_all = "camelCase")]
9353pub struct ThreadUnarchiveResponse {
9354 #[serde()]
9355 pub thread: Thread,
9356}
9357
9358#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9359#[serde(rename_all = "camelCase")]
9360pub struct ThreadUnarchivedNotification {
9361 #[serde(rename = "threadId", default)]
9362 pub thread_id: String,
9363}
9364
9365#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9366#[serde(tag = "type", rename_all = "camelCase")]
9367pub enum ThreadUnreadPosition {
9368 #[serde(rename = "threadStart")]
9370 ThreadStart,
9371 Turn {
9373 #[serde(rename = "turnId")]
9374 turn_id: String,
9375 },
9376}
9377
9378#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9383#[serde(tag = "type", rename_all = "camelCase")]
9384#[allow(clippy::large_enum_variant)] pub enum ThreadTimelineEntry {
9386 Item {
9387 item: ThreadItem,
9388 position: u64,
9389 #[serde(rename = "turnId")]
9390 turn_id: String,
9391 },
9392 Realtime {
9393 item: ThreadRealtimeItem,
9394 position: u64,
9395 },
9396 TurnStarted {
9397 position: u64,
9398 #[serde(default, skip_serializing_if = "Option::is_none")]
9399 started_at: Option<i64>,
9400 turn_id: String,
9401 },
9402 TurnCompleted {
9403 #[serde(default, skip_serializing_if = "Option::is_none")]
9404 completed_at: Option<i64>,
9405 #[serde(default, skip_serializing_if = "Option::is_none")]
9406 duration_ms: Option<i64>,
9407 #[serde(default, skip_serializing_if = "Option::is_none")]
9408 error: Option<TurnError>,
9409 position: u64,
9410 #[serde(default, skip_serializing_if = "Option::is_none")]
9411 started_at: Option<i64>,
9412 status: TurnStatus,
9413 turn_id: String,
9414 },
9415}
9416
9417#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9419#[serde(rename_all = "camelCase")]
9420pub struct ThreadTurnsListParams {
9421 #[serde(default, skip_serializing_if = "Option::is_none")]
9422 pub cursor: Option<String>,
9423 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9425 pub items_view: Option<TurnItemsView>,
9426 #[serde(default, skip_serializing_if = "Option::is_none")]
9427 pub limit: Option<u32>,
9428 #[serde(
9429 rename = "sortDirection",
9430 default,
9431 skip_serializing_if = "Option::is_none"
9432 )]
9433 pub sort_direction: Option<SortDirection>,
9434 #[serde(rename = "threadId", default)]
9435 pub thread_id: String,
9436}
9437
9438#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9440#[serde(rename_all = "camelCase")]
9441pub struct ThreadTurnsListResponse {
9442 #[serde(
9443 rename = "backwardsCursor",
9444 default,
9445 skip_serializing_if = "Option::is_none"
9446 )]
9447 pub backwards_cursor: Option<String>,
9448 #[serde(default)]
9449 pub data: Vec<Turn>,
9450 #[serde(
9451 rename = "nextCursor",
9452 default,
9453 skip_serializing_if = "Option::is_none"
9454 )]
9455 pub next_cursor: Option<String>,
9456}
9457
9458#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9459#[serde(rename_all = "camelCase")]
9460pub struct ThreadUnsubscribeParams {
9461 #[serde(rename = "threadId", default)]
9462 pub thread_id: String,
9463}
9464
9465#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9466#[serde(rename_all = "camelCase")]
9467pub struct ThreadUnsubscribeResponse {
9468 #[serde()]
9469 pub status: ThreadUnsubscribeStatus,
9470}
9471
9472#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9473pub enum ThreadUnsubscribeStatus {
9474 #[serde(rename = "notLoaded")]
9475 NotLoaded,
9476 #[serde(rename = "notSubscribed")]
9477 NotSubscribed,
9478 #[serde(rename = "unsubscribed")]
9479 Unsubscribed,
9480}
9481
9482#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9483#[serde(rename_all = "camelCase")]
9484pub struct TokenUsageBreakdown {
9485 #[serde(
9486 rename = "cacheWriteInputTokens",
9487 default,
9488 skip_serializing_if = "Option::is_none"
9489 )]
9490 pub cache_write_input_tokens: Option<i64>,
9491 #[serde(rename = "cachedInputTokens", default)]
9492 pub cached_input_tokens: i64,
9493 #[serde(rename = "inputTokens", default)]
9494 pub input_tokens: i64,
9495 #[serde(rename = "outputTokens", default)]
9496 pub output_tokens: i64,
9497 #[serde(rename = "reasoningOutputTokens", default)]
9498 pub reasoning_output_tokens: i64,
9499 #[serde(rename = "totalTokens", default)]
9500 pub total_tokens: i64,
9501}
9502
9503#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9504#[serde(rename_all = "camelCase")]
9505pub struct Tool {
9506 #[serde(default, skip_serializing_if = "Option::is_none")]
9507 pub _meta: Option<Value>,
9508 #[serde(default, skip_serializing_if = "Option::is_none")]
9509 pub annotations: Option<Value>,
9510 #[serde(default, skip_serializing_if = "Option::is_none")]
9511 pub description: Option<String>,
9512 #[serde(default, skip_serializing_if = "Option::is_none")]
9513 pub icons: Option<Vec<Value>>,
9514 #[serde(rename = "inputSchema", default)]
9515 pub input_schema: Value,
9516 #[serde(default)]
9517 pub name: String,
9518 #[serde(
9519 rename = "outputSchema",
9520 default,
9521 skip_serializing_if = "Option::is_none"
9522 )]
9523 pub output_schema: Option<Value>,
9524 #[serde(default, skip_serializing_if = "Option::is_none")]
9525 pub title: Option<String>,
9526}
9527
9528#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9529#[serde(rename_all = "camelCase")]
9530pub struct ToolRequestUserInputAnswer {
9531 #[serde(default)]
9532 pub answers: Vec<String>,
9533}
9534
9535#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9536#[serde(rename_all = "camelCase")]
9537pub struct ToolRequestUserInputOption {
9538 #[serde(default)]
9539 pub description: String,
9540 #[serde(default)]
9541 pub label: String,
9542}
9543
9544#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9545#[serde(rename_all = "camelCase")]
9546pub struct ToolRequestUserInputParams {
9547 #[serde(
9548 rename = "autoResolutionMs",
9549 default,
9550 skip_serializing_if = "Option::is_none"
9551 )]
9552 pub auto_resolution_ms: Option<i64>,
9553 #[serde(rename = "isBlocking", default)]
9554 pub is_blocking: bool,
9555 #[serde(rename = "itemId", default)]
9556 pub item_id: String,
9557 #[serde(default)]
9558 pub questions: Vec<ToolRequestUserInputQuestion>,
9559 #[serde(rename = "threadId", default)]
9560 pub thread_id: String,
9561 #[serde(rename = "turnId", default)]
9562 pub turn_id: String,
9563}
9564
9565#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9566#[serde(rename_all = "camelCase")]
9567pub struct ToolRequestUserInputQuestion {
9568 #[serde(default)]
9569 pub header: String,
9570 #[serde(default)]
9571 pub id: String,
9572 #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
9573 pub is_other: Option<bool>,
9574 #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
9575 pub is_secret: Option<bool>,
9576 #[serde(default, skip_serializing_if = "Option::is_none")]
9577 pub options: Option<Vec<ToolRequestUserInputOption>>,
9578 #[serde(default)]
9579 pub question: String,
9580}
9581
9582#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9583#[serde(rename_all = "camelCase")]
9584pub struct ToolRequestUserInputResponse {
9585 #[serde(default)]
9586 pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
9587}
9588
9589#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9590#[serde(rename_all = "camelCase")]
9591pub struct ToolsV2 {
9592 #[serde(default, skip_serializing_if = "Option::is_none")]
9593 pub web_search: Option<WebSearchToolConfig>,
9594}
9595
9596#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9597#[serde(rename_all = "camelCase")]
9598pub struct Turn {
9599 #[serde(
9600 rename = "completedAt",
9601 default,
9602 skip_serializing_if = "Option::is_none"
9603 )]
9604 pub completed_at: Option<i64>,
9605 #[serde(
9606 rename = "durationMs",
9607 default,
9608 skip_serializing_if = "Option::is_none"
9609 )]
9610 pub duration_ms: Option<i64>,
9611 #[serde(default, skip_serializing_if = "Option::is_none")]
9612 pub error: Option<TurnError>,
9613 #[serde(default)]
9614 pub id: String,
9615 #[serde(default)]
9616 pub items: Vec<ThreadItem>,
9617 #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
9618 pub items_view: Option<Value>,
9619 #[serde(
9623 rename = "rootTurnId",
9624 default,
9625 skip_serializing_if = "Option::is_none"
9626 )]
9627 pub root_turn_id: Option<String>,
9628 #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
9629 pub started_at: Option<i64>,
9630 #[serde()]
9631 pub status: TurnStatus,
9632}
9633
9634#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9635#[serde(rename_all = "camelCase")]
9636pub struct TurnCompletedNotification {
9637 #[serde(rename = "threadId", default)]
9638 pub thread_id: String,
9639 #[serde()]
9640 pub turn: Turn,
9641}
9642
9643#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9644#[serde(rename_all = "camelCase")]
9645pub struct TurnDiffUpdatedNotification {
9646 #[serde(default)]
9647 pub diff: String,
9648 #[serde(rename = "threadId", default)]
9649 pub thread_id: String,
9650 #[serde(rename = "turnId", default)]
9651 pub turn_id: String,
9652}
9653
9654#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9655#[serde(rename_all = "camelCase")]
9656pub struct TurnError {
9657 #[serde(
9658 rename = "additionalDetails",
9659 default,
9660 skip_serializing_if = "Option::is_none"
9661 )]
9662 pub additional_details: Option<String>,
9663 #[serde(
9664 rename = "codexErrorInfo",
9665 default,
9666 skip_serializing_if = "Option::is_none"
9667 )]
9668 pub codex_error_info: Option<CodexErrorInfo>,
9669 #[serde(default)]
9670 pub message: String,
9671 #[serde(default, skip_serializing_if = "Option::is_none")]
9674 pub misalignment: Option<MisalignmentErrorDetails>,
9675}
9676
9677#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9678#[serde(rename_all = "camelCase")]
9679pub struct TurnInterruptParams {
9680 #[serde(rename = "threadId", default)]
9681 pub thread_id: String,
9682 #[serde(rename = "turnId", default)]
9683 pub turn_id: String,
9684}
9685
9686#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9687#[serde(rename_all = "camelCase")]
9688pub struct TurnInterruptResponse {
9689 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
9690 pub extra: serde_json::Map<String, Value>,
9691}
9692
9693#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
9694pub enum TurnItemsView {
9695 #[serde(rename = "notLoaded")]
9696 NotLoaded,
9697 #[serde(rename = "summary")]
9698 Summary,
9699 #[serde(rename = "full")]
9700 Full,
9701}
9702
9703#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9704#[serde(rename_all = "camelCase")]
9705pub struct TurnModerationMetadataNotification {
9706 #[serde(default)]
9707 pub metadata: Value,
9708 #[serde(rename = "threadId", default)]
9709 pub thread_id: String,
9710 #[serde(rename = "turnId", default)]
9711 pub turn_id: String,
9712}
9713
9714#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9715#[serde(rename_all = "camelCase")]
9716pub struct TurnPlanStep {
9717 #[serde()]
9718 pub status: TurnPlanStepStatus,
9719 #[serde(default)]
9720 pub step: String,
9721}
9722
9723#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9724pub enum TurnPlanStepStatus {
9725 #[serde(rename = "pending")]
9726 Pending,
9727 #[serde(rename = "inProgress")]
9728 InProgress,
9729 #[serde(rename = "completed")]
9730 Completed,
9731}
9732
9733#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9734#[serde(rename_all = "camelCase")]
9735pub struct TurnPlanUpdatedNotification {
9736 #[serde(default, skip_serializing_if = "Option::is_none")]
9737 pub explanation: Option<String>,
9738 #[serde(default)]
9739 pub plan: Vec<TurnPlanStep>,
9740 #[serde(rename = "threadId", default)]
9741 pub thread_id: String,
9742 #[serde(rename = "turnId", default)]
9743 pub turn_id: String,
9744}
9745
9746#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9747#[serde(rename_all = "camelCase")]
9748pub struct TurnStartParams {
9749 #[serde(
9750 rename = "approvalPolicy",
9751 default,
9752 skip_serializing_if = "Option::is_none"
9753 )]
9754 pub approval_policy: Option<AskForApproval>,
9755 #[serde(
9756 rename = "approvalsReviewer",
9757 default,
9758 skip_serializing_if = "Option::is_none"
9759 )]
9760 pub approvals_reviewer: Option<ApprovalsReviewer>,
9761 #[serde(
9762 rename = "clientUserMessageId",
9763 default,
9764 skip_serializing_if = "Option::is_none"
9765 )]
9766 pub client_user_message_id: Option<String>,
9767 #[serde(default, skip_serializing_if = "Option::is_none")]
9768 pub cwd: Option<String>,
9769 #[serde(
9772 rename = "disabledPluginIds",
9773 default,
9774 skip_serializing_if = "Option::is_none"
9775 )]
9776 pub disabled_plugin_ids: Option<Vec<String>>,
9777 #[serde(default, skip_serializing_if = "Option::is_none")]
9778 pub effort: Option<ReasoningEffort>,
9779 #[serde(default)]
9780 pub input: Vec<UserInput>,
9781 #[serde(default, skip_serializing_if = "Option::is_none")]
9782 pub model: Option<String>,
9783 #[serde(
9784 rename = "outputSchema",
9785 default,
9786 skip_serializing_if = "Option::is_none"
9787 )]
9788 pub output_schema: Option<Value>,
9789 #[serde(
9793 rename = "parentTurnId",
9794 default,
9795 skip_serializing_if = "Option::is_none"
9796 )]
9797 pub parent_turn_id: Option<String>,
9798 #[serde(default, skip_serializing_if = "Option::is_none")]
9799 pub personality: Option<Personality>,
9800 #[serde(
9805 rename = "rootTurnId",
9806 default,
9807 skip_serializing_if = "Option::is_none"
9808 )]
9809 pub root_turn_id: Option<String>,
9810 #[serde(
9811 rename = "sandboxPolicy",
9812 default,
9813 skip_serializing_if = "Option::is_none"
9814 )]
9815 pub sandbox_policy: Option<SandboxPolicy>,
9816 #[serde(
9817 rename = "serviceTier",
9818 default,
9819 skip_serializing_if = "Option::is_none"
9820 )]
9821 pub service_tier: Option<String>,
9822 #[serde(
9825 rename = "serviceTierForTurn",
9826 default,
9827 skip_serializing_if = "Option::is_none"
9828 )]
9829 pub service_tier_for_turn: Option<String>,
9830 #[serde(default, skip_serializing_if = "Option::is_none")]
9831 pub summary: Option<ReasoningSummary>,
9832 #[serde(rename = "threadId", default)]
9833 pub thread_id: String,
9834 #[serde(
9837 rename = "toolOutput",
9838 default,
9839 skip_serializing_if = "Option::is_none"
9840 )]
9841 pub tool_output: Option<TurnToolOutput>,
9842 #[serde(
9845 rename = "turnTrigger",
9846 default,
9847 skip_serializing_if = "Option::is_none"
9848 )]
9849 pub turn_trigger: Option<String>,
9850}
9851
9852#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9853#[serde(rename_all = "camelCase")]
9854pub struct TurnStartResponse {
9855 #[serde()]
9856 pub turn: Turn,
9857}
9858
9859#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9860#[serde(rename_all = "camelCase")]
9861pub struct TurnStartedNotification {
9862 #[serde(rename = "threadId", default)]
9863 pub thread_id: String,
9864 #[serde()]
9865 pub turn: Turn,
9866}
9867
9868#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9869pub enum TurnStatus {
9870 #[serde(rename = "completed")]
9871 Completed,
9872 #[serde(rename = "interrupted")]
9873 Interrupted,
9874 #[serde(rename = "failed")]
9875 Failed,
9876 #[serde(rename = "inProgress")]
9877 InProgress,
9878}
9879
9880#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9883#[serde(rename_all = "camelCase")]
9884pub struct TurnToolOutput {
9885 #[serde(default)]
9886 pub name: String,
9887 #[serde(default, skip_serializing_if = "Option::is_none")]
9888 pub namespace: Option<String>,
9889 #[serde()]
9890 pub output: FunctionCallOutputBody,
9891 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
9894 pub retain: bool,
9895}
9896
9897#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9898#[serde(rename_all = "camelCase")]
9899pub struct TurnSteerParams {
9900 #[serde(
9901 rename = "clientUserMessageId",
9902 default,
9903 skip_serializing_if = "Option::is_none"
9904 )]
9905 pub client_user_message_id: Option<String>,
9906 #[serde(rename = "expectedTurnId", default)]
9907 pub expected_turn_id: String,
9908 #[serde(default)]
9909 pub input: Vec<UserInput>,
9910 #[serde(rename = "threadId", default)]
9911 pub thread_id: String,
9912}
9913
9914#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9915#[serde(rename_all = "camelCase")]
9916pub struct TurnSteerResponse {
9917 #[serde(rename = "turnId", default)]
9918 pub turn_id: String,
9919}
9920
9921#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9922#[serde(tag = "type", rename_all = "camelCase")]
9923pub enum UserInput {
9924 Text {
9925 text: String,
9926 #[serde(default, skip_serializing_if = "Option::is_none")]
9927 text_elements: Option<Vec<TextElement>>,
9928 },
9929 Image {
9930 #[serde(default, skip_serializing_if = "Option::is_none")]
9931 detail: Option<ImageDetail>,
9932 #[serde(flatten)]
9933 image: UserInputImageReference,
9934 },
9935 #[serde(rename = "localImage")]
9936 LocalImage {
9937 #[serde(default, skip_serializing_if = "Option::is_none")]
9938 detail: Option<ImageDetail>,
9939 path: String,
9940 },
9941 Audio {
9942 url: String,
9943 },
9944 #[serde(rename = "localAudio")]
9945 LocalAudio {
9946 path: String,
9947 },
9948 Skill {
9949 name: String,
9950 path: String,
9951 },
9952 Mention {
9953 name: String,
9954 path: String,
9955 },
9956}
9957
9958#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9964#[serde(untagged)]
9965pub enum UserInputImageReference {
9966 Inline {
9967 url: String,
9968 },
9969 File {
9970 #[serde(rename = "fileId")]
9971 file_id: String,
9972 },
9973}
9974
9975#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9976pub enum Verbosity {
9977 #[serde(rename = "low")]
9978 Low,
9979 #[serde(rename = "medium")]
9980 Medium,
9981 #[serde(rename = "high")]
9982 High,
9983}
9984
9985#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
9986#[serde(rename_all = "camelCase")]
9987pub struct WarningNotification {
9988 #[serde(default)]
9989 pub message: String,
9990 #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
9991 pub thread_id: Option<String>,
9992}
9993
9994#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9995#[serde(tag = "type", rename_all = "camelCase")]
9996pub enum WebSearchAction {
9997 Search {
9998 #[serde(default, skip_serializing_if = "Option::is_none")]
9999 queries: Option<Vec<String>>,
10000 #[serde(default, skip_serializing_if = "Option::is_none")]
10001 query: Option<String>,
10002 },
10003 #[serde(rename = "openPage")]
10004 OpenPage {
10005 #[serde(default, skip_serializing_if = "Option::is_none")]
10006 url: Option<String>,
10007 },
10008 #[serde(rename = "findInPage")]
10009 FindInPage {
10010 #[serde(default, skip_serializing_if = "Option::is_none")]
10011 pattern: Option<String>,
10012 #[serde(default, skip_serializing_if = "Option::is_none")]
10013 url: Option<String>,
10014 },
10015 Other,
10016}
10017
10018#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10019pub enum WebSearchContextSize {
10020 #[serde(rename = "low")]
10021 Low,
10022 #[serde(rename = "medium")]
10023 Medium,
10024 #[serde(rename = "high")]
10025 High,
10026}
10027
10028#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10029#[serde(rename_all = "camelCase")]
10030pub struct WebSearchLocation {
10031 #[serde(default, skip_serializing_if = "Option::is_none")]
10032 pub city: Option<String>,
10033 #[serde(default, skip_serializing_if = "Option::is_none")]
10034 pub country: Option<String>,
10035 #[serde(default, skip_serializing_if = "Option::is_none")]
10036 pub region: Option<String>,
10037 #[serde(default, skip_serializing_if = "Option::is_none")]
10038 pub timezone: Option<String>,
10039}
10040
10041#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10042pub enum WebSearchMode {
10043 #[serde(rename = "disabled")]
10044 Disabled,
10045 #[serde(rename = "cached")]
10046 Cached,
10047 #[serde(rename = "indexed")]
10048 Indexed,
10049 #[serde(rename = "live")]
10050 Live,
10051}
10052
10053#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10054#[serde(rename_all = "camelCase")]
10055pub struct WebSearchToolConfig {
10056 #[serde(default, skip_serializing_if = "Option::is_none")]
10057 pub allowed_domains: Option<Vec<String>>,
10058 #[serde(default, skip_serializing_if = "Option::is_none")]
10059 pub context_size: Option<WebSearchContextSize>,
10060 #[serde(default, skip_serializing_if = "Option::is_none")]
10061 pub location: Option<WebSearchLocation>,
10062}
10063
10064#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10065pub enum WindowsSandboxReadiness {
10066 #[serde(rename = "ready")]
10067 Ready,
10068 #[serde(rename = "notConfigured")]
10069 NotConfigured,
10070 #[serde(rename = "updateRequired")]
10071 UpdateRequired,
10072}
10073
10074#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10075#[serde(rename_all = "camelCase")]
10076pub struct WindowsSandboxReadinessResponse {
10077 #[serde()]
10078 pub status: WindowsSandboxReadiness,
10079}
10080
10081#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10082#[serde(rename_all = "camelCase")]
10083pub struct WindowsSandboxSetupCompletedNotification {
10084 #[serde(default, skip_serializing_if = "Option::is_none")]
10085 pub error: Option<String>,
10086 #[serde()]
10087 pub mode: WindowsSandboxSetupMode,
10088 #[serde(default)]
10089 pub success: bool,
10090}
10091
10092#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10093pub enum WindowsSandboxSetupMode {
10094 #[serde(rename = "elevated")]
10095 Elevated,
10096 #[serde(rename = "unelevated")]
10097 Unelevated,
10098}
10099
10100#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10104pub enum WindowsSandboxImplementation {
10105 #[serde(rename = "elevated")]
10106 Elevated,
10107 #[serde(rename = "unelevated")]
10108 Unelevated,
10109 #[serde(rename = "mxc")]
10110 Mxc,
10111}
10112
10113#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10114#[serde(rename_all = "camelCase")]
10115pub struct WindowsSandboxSetupStartParams {
10116 #[serde(default, skip_serializing_if = "Option::is_none")]
10117 pub cwd: Option<AbsolutePathBuf>,
10118 #[serde()]
10119 pub mode: WindowsSandboxSetupMode,
10120}
10121
10122#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10123#[serde(rename_all = "camelCase")]
10124pub struct WindowsSandboxSetupStartResponse {
10125 #[serde(default)]
10126 pub started: bool,
10127}
10128
10129#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
10130#[serde(rename_all = "camelCase")]
10131pub struct WindowsWorldWritableWarningNotification {
10132 #[serde(rename = "extraCount", default)]
10133 pub extra_count: i64,
10134 #[serde(rename = "failedScan", default)]
10135 pub failed_scan: bool,
10136 #[serde(rename = "samplePaths", default)]
10137 pub sample_paths: Vec<String>,
10138}
10139
10140#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10141#[serde(rename_all = "camelCase")]
10142pub struct WorkspaceMessage {
10143 #[serde(
10144 rename = "archivedAt",
10145 default,
10146 skip_serializing_if = "Option::is_none"
10147 )]
10148 pub archived_at: Option<i64>,
10149 #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
10150 pub created_at: Option<i64>,
10151 #[serde(rename = "messageBody", default)]
10152 pub message_body: String,
10153 #[serde(rename = "messageId", default)]
10154 pub message_id: String,
10155 #[serde(rename = "messageType")]
10156 pub message_type: WorkspaceMessageType,
10157}
10158
10159#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10160pub enum WorkspaceMessageType {
10161 #[serde(rename = "headline")]
10162 Headline,
10163 #[serde(rename = "announcement")]
10164 Announcement,
10165 #[serde(rename = "unknown")]
10166 Unknown,
10167}
10168
10169#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
10170pub enum WriteStatus {
10171 #[serde(rename = "ok")]
10172 Ok,
10173 #[serde(rename = "okOverridden")]
10174 OkOverridden,
10175}