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