1mod model;
2mod rate_limiter;
3mod registry;
4mod request;
5mod role;
6mod telemetry;
7
8#[cfg(any(test, feature = "test-support"))]
9pub mod fake_provider;
10
11use anthropic::{AnthropicError, parse_prompt_too_long};
12use anyhow::{Result, anyhow};
13use client::Client;
14use cloud_llm_client::{CompletionMode, CompletionRequestStatus};
15use futures::FutureExt;
16use futures::{StreamExt, future::BoxFuture, stream::BoxStream};
17use gpui::{AnyView, App, AsyncApp, SharedString, Task, Window};
18use http_client::{StatusCode, http};
19use icons::IconName;
20use open_router::OpenRouterError;
21use parking_lot::Mutex;
22use schemars::JsonSchema;
23use serde::{Deserialize, Serialize, de::DeserializeOwned};
24pub use settings::LanguageModelCacheConfiguration;
25use std::ops::{Add, Sub};
26use std::str::FromStr;
27use std::sync::Arc;
28use std::time::Duration;
29use std::{fmt, io};
30use thiserror::Error;
31use util::serde::is_default;
32
33pub use crate::model::*;
34pub use crate::rate_limiter::*;
35pub use crate::registry::*;
36pub use crate::request::*;
37pub use crate::role::*;
38pub use crate::telemetry::*;
39
40pub const ANTHROPIC_PROVIDER_ID: LanguageModelProviderId =
41 LanguageModelProviderId::new("anthropic");
42pub const ANTHROPIC_PROVIDER_NAME: LanguageModelProviderName =
43 LanguageModelProviderName::new("Anthropic");
44
45pub const GOOGLE_PROVIDER_ID: LanguageModelProviderId = LanguageModelProviderId::new("google");
46pub const GOOGLE_PROVIDER_NAME: LanguageModelProviderName =
47 LanguageModelProviderName::new("Google AI");
48
49pub const OPEN_AI_PROVIDER_ID: LanguageModelProviderId = LanguageModelProviderId::new("openai");
50pub const OPEN_AI_PROVIDER_NAME: LanguageModelProviderName =
51 LanguageModelProviderName::new("OpenAI");
52
53pub const X_AI_PROVIDER_ID: LanguageModelProviderId = LanguageModelProviderId::new("x_ai");
54pub const X_AI_PROVIDER_NAME: LanguageModelProviderName = LanguageModelProviderName::new("xAI");
55
56pub const ZED_CLOUD_PROVIDER_ID: LanguageModelProviderId = LanguageModelProviderId::new("zed.dev");
57pub const ZED_CLOUD_PROVIDER_NAME: LanguageModelProviderName =
58 LanguageModelProviderName::new("Zed");
59
60pub fn init(client: Arc<Client>, cx: &mut App) {
61 init_settings(cx);
62 RefreshLlmTokenListener::register(client, cx);
63}
64
65pub fn init_settings(cx: &mut App) {
66 registry::init(cx);
67}
68
69/// A completion event from a language model.
70#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
71pub enum LanguageModelCompletionEvent {
72 StatusUpdate(CompletionRequestStatus),
73 Stop(StopReason),
74 Text(String),
75 Thinking {
76 text: String,
77 signature: Option<String>,
78 },
79 RedactedThinking {
80 data: String,
81 },
82 ToolUse(LanguageModelToolUse),
83 ToolUseJsonParseError {
84 id: LanguageModelToolUseId,
85 tool_name: Arc<str>,
86 raw_input: Arc<str>,
87 json_parse_error: String,
88 },
89 StartMessage {
90 message_id: String,
91 },
92 UsageUpdate(TokenUsage),
93}
94
95#[derive(Error, Debug)]
96pub enum LanguageModelCompletionError {
97 #[error("prompt too large for context window")]
98 PromptTooLarge { tokens: Option<u64> },
99 #[error("missing {provider} API key")]
100 NoApiKey { provider: LanguageModelProviderName },
101 #[error("{provider}'s API rate limit exceeded")]
102 RateLimitExceeded {
103 provider: LanguageModelProviderName,
104 retry_after: Option<Duration>,
105 },
106 #[error("{provider}'s API servers are overloaded right now")]
107 ServerOverloaded {
108 provider: LanguageModelProviderName,
109 retry_after: Option<Duration>,
110 },
111 #[error("{provider}'s API server reported an internal server error: {message}")]
112 ApiInternalServerError {
113 provider: LanguageModelProviderName,
114 message: String,
115 },
116 #[error("{message}")]
117 UpstreamProviderError {
118 message: String,
119 status: StatusCode,
120 retry_after: Option<Duration>,
121 },
122 #[error("HTTP response error from {provider}'s API: status {status_code} - {message:?}")]
123 HttpResponseError {
124 provider: LanguageModelProviderName,
125 status_code: StatusCode,
126 message: String,
127 },
128
129 // Client errors
130 #[error("invalid request format to {provider}'s API: {message}")]
131 BadRequestFormat {
132 provider: LanguageModelProviderName,
133 message: String,
134 },
135 #[error("authentication error with {provider}'s API: {message}")]
136 AuthenticationError {
137 provider: LanguageModelProviderName,
138 message: String,
139 },
140 #[error("permission error with {provider}'s API: {message}")]
141 PermissionError {
142 provider: LanguageModelProviderName,
143 message: String,
144 },
145 #[error("language model provider API endpoint not found")]
146 ApiEndpointNotFound { provider: LanguageModelProviderName },
147 #[error("I/O error reading response from {provider}'s API")]
148 ApiReadResponseError {
149 provider: LanguageModelProviderName,
150 #[source]
151 error: io::Error,
152 },
153 #[error("error serializing request to {provider} API")]
154 SerializeRequest {
155 provider: LanguageModelProviderName,
156 #[source]
157 error: serde_json::Error,
158 },
159 #[error("error building request body to {provider} API")]
160 BuildRequestBody {
161 provider: LanguageModelProviderName,
162 #[source]
163 error: http::Error,
164 },
165 #[error("error sending HTTP request to {provider} API")]
166 HttpSend {
167 provider: LanguageModelProviderName,
168 #[source]
169 error: anyhow::Error,
170 },
171 #[error("error deserializing {provider} API response")]
172 DeserializeResponse {
173 provider: LanguageModelProviderName,
174 #[source]
175 error: serde_json::Error,
176 },
177
178 // TODO: Ideally this would be removed in favor of having a comprehensive list of errors.
179 #[error(transparent)]
180 Other(#[from] anyhow::Error),
181}
182
183impl LanguageModelCompletionError {
184 fn parse_upstream_error_json(message: &str) -> Option<(StatusCode, String)> {
185 let error_json = serde_json::from_str::<serde_json::Value>(message).ok()?;
186 let upstream_status = error_json
187 .get("upstream_status")
188 .and_then(|v| v.as_u64())
189 .and_then(|status| u16::try_from(status).ok())
190 .and_then(|status| StatusCode::from_u16(status).ok())?;
191 let inner_message = error_json
192 .get("message")
193 .and_then(|v| v.as_str())
194 .unwrap_or(message)
195 .to_string();
196 Some((upstream_status, inner_message))
197 }
198
199 pub fn from_cloud_failure(
200 upstream_provider: LanguageModelProviderName,
201 code: String,
202 message: String,
203 retry_after: Option<Duration>,
204 ) -> Self {
205 if let Some(tokens) = parse_prompt_too_long(&message) {
206 // TODO: currently Anthropic PAYLOAD_TOO_LARGE response may cause INTERNAL_SERVER_ERROR
207 // to be reported. This is a temporary workaround to handle this in the case where the
208 // token limit has been exceeded.
209 Self::PromptTooLarge {
210 tokens: Some(tokens),
211 }
212 } else if code == "upstream_http_error" {
213 if let Some((upstream_status, inner_message)) =
214 Self::parse_upstream_error_json(&message)
215 {
216 return Self::from_http_status(
217 upstream_provider,
218 upstream_status,
219 inner_message,
220 retry_after,
221 );
222 }
223 anyhow!("completion request failed, code: {code}, message: {message}").into()
224 } else if let Some(status_code) = code
225 .strip_prefix("upstream_http_")
226 .and_then(|code| StatusCode::from_str(code).ok())
227 {
228 Self::from_http_status(upstream_provider, status_code, message, retry_after)
229 } else if let Some(status_code) = code
230 .strip_prefix("http_")
231 .and_then(|code| StatusCode::from_str(code).ok())
232 {
233 Self::from_http_status(ZED_CLOUD_PROVIDER_NAME, status_code, message, retry_after)
234 } else {
235 anyhow!("completion request failed, code: {code}, message: {message}").into()
236 }
237 }
238
239 pub fn from_http_status(
240 provider: LanguageModelProviderName,
241 status_code: StatusCode,
242 message: String,
243 retry_after: Option<Duration>,
244 ) -> Self {
245 match status_code {
246 StatusCode::BAD_REQUEST => Self::BadRequestFormat { provider, message },
247 StatusCode::UNAUTHORIZED => Self::AuthenticationError { provider, message },
248 StatusCode::FORBIDDEN => Self::PermissionError { provider, message },
249 StatusCode::NOT_FOUND => Self::ApiEndpointNotFound { provider },
250 StatusCode::PAYLOAD_TOO_LARGE => Self::PromptTooLarge {
251 tokens: parse_prompt_too_long(&message),
252 },
253 StatusCode::TOO_MANY_REQUESTS => Self::RateLimitExceeded {
254 provider,
255 retry_after,
256 },
257 StatusCode::INTERNAL_SERVER_ERROR => Self::ApiInternalServerError { provider, message },
258 StatusCode::SERVICE_UNAVAILABLE => Self::ServerOverloaded {
259 provider,
260 retry_after,
261 },
262 _ if status_code.as_u16() == 529 => Self::ServerOverloaded {
263 provider,
264 retry_after,
265 },
266 _ => Self::HttpResponseError {
267 provider,
268 status_code,
269 message,
270 },
271 }
272 }
273}
274
275impl From<AnthropicError> for LanguageModelCompletionError {
276 fn from(error: AnthropicError) -> Self {
277 let provider = ANTHROPIC_PROVIDER_NAME;
278 match error {
279 AnthropicError::SerializeRequest(error) => Self::SerializeRequest { provider, error },
280 AnthropicError::BuildRequestBody(error) => Self::BuildRequestBody { provider, error },
281 AnthropicError::HttpSend(error) => Self::HttpSend { provider, error },
282 AnthropicError::DeserializeResponse(error) => {
283 Self::DeserializeResponse { provider, error }
284 }
285 AnthropicError::ReadResponse(error) => Self::ApiReadResponseError { provider, error },
286 AnthropicError::HttpResponseError {
287 status_code,
288 message,
289 } => Self::HttpResponseError {
290 provider,
291 status_code,
292 message,
293 },
294 AnthropicError::RateLimit { retry_after } => Self::RateLimitExceeded {
295 provider,
296 retry_after: Some(retry_after),
297 },
298 AnthropicError::ServerOverloaded { retry_after } => Self::ServerOverloaded {
299 provider,
300 retry_after,
301 },
302 AnthropicError::ApiError(api_error) => api_error.into(),
303 }
304 }
305}
306
307impl From<anthropic::ApiError> for LanguageModelCompletionError {
308 fn from(error: anthropic::ApiError) -> Self {
309 use anthropic::ApiErrorCode::*;
310 let provider = ANTHROPIC_PROVIDER_NAME;
311 match error.code() {
312 Some(code) => match code {
313 InvalidRequestError => Self::BadRequestFormat {
314 provider,
315 message: error.message,
316 },
317 AuthenticationError => Self::AuthenticationError {
318 provider,
319 message: error.message,
320 },
321 PermissionError => Self::PermissionError {
322 provider,
323 message: error.message,
324 },
325 NotFoundError => Self::ApiEndpointNotFound { provider },
326 RequestTooLarge => Self::PromptTooLarge {
327 tokens: parse_prompt_too_long(&error.message),
328 },
329 RateLimitError => Self::RateLimitExceeded {
330 provider,
331 retry_after: None,
332 },
333 ApiError => Self::ApiInternalServerError {
334 provider,
335 message: error.message,
336 },
337 OverloadedError => Self::ServerOverloaded {
338 provider,
339 retry_after: None,
340 },
341 },
342 None => Self::Other(error.into()),
343 }
344 }
345}
346
347impl From<OpenRouterError> for LanguageModelCompletionError {
348 fn from(error: OpenRouterError) -> Self {
349 let provider = LanguageModelProviderName::new("OpenRouter");
350 match error {
351 OpenRouterError::SerializeRequest(error) => Self::SerializeRequest { provider, error },
352 OpenRouterError::BuildRequestBody(error) => Self::BuildRequestBody { provider, error },
353 OpenRouterError::HttpSend(error) => Self::HttpSend { provider, error },
354 OpenRouterError::DeserializeResponse(error) => {
355 Self::DeserializeResponse { provider, error }
356 }
357 OpenRouterError::ReadResponse(error) => Self::ApiReadResponseError { provider, error },
358 OpenRouterError::RateLimit { retry_after } => Self::RateLimitExceeded {
359 provider,
360 retry_after: Some(retry_after),
361 },
362 OpenRouterError::ServerOverloaded { retry_after } => Self::ServerOverloaded {
363 provider,
364 retry_after,
365 },
366 OpenRouterError::ApiError(api_error) => api_error.into(),
367 }
368 }
369}
370
371impl From<open_router::ApiError> for LanguageModelCompletionError {
372 fn from(error: open_router::ApiError) -> Self {
373 use open_router::ApiErrorCode::*;
374 let provider = LanguageModelProviderName::new("OpenRouter");
375 match error.code {
376 InvalidRequestError => Self::BadRequestFormat {
377 provider,
378 message: error.message,
379 },
380 AuthenticationError => Self::AuthenticationError {
381 provider,
382 message: error.message,
383 },
384 PaymentRequiredError => Self::AuthenticationError {
385 provider,
386 message: format!("Payment required: {}", error.message),
387 },
388 PermissionError => Self::PermissionError {
389 provider,
390 message: error.message,
391 },
392 RequestTimedOut => Self::HttpResponseError {
393 provider,
394 status_code: StatusCode::REQUEST_TIMEOUT,
395 message: error.message,
396 },
397 RateLimitError => Self::RateLimitExceeded {
398 provider,
399 retry_after: None,
400 },
401 ApiError => Self::ApiInternalServerError {
402 provider,
403 message: error.message,
404 },
405 OverloadedError => Self::ServerOverloaded {
406 provider,
407 retry_after: None,
408 },
409 }
410 }
411}
412
413/// Indicates the format used to define the input schema for a language model tool.
414#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
415pub enum LanguageModelToolSchemaFormat {
416 /// A JSON schema, see https://json-schema.org
417 JsonSchema,
418 /// A subset of an OpenAPI 3.0 schema object supported by Google AI, see https://ai.google.dev/api/caching#Schema
419 JsonSchemaSubset,
420}
421
422#[derive(Debug, PartialEq, Clone, Copy, Serialize, Deserialize)]
423#[serde(rename_all = "snake_case")]
424pub enum StopReason {
425 EndTurn,
426 MaxTokens,
427 ToolUse,
428 Refusal,
429}
430
431#[derive(Debug, PartialEq, Clone, Copy, Serialize, Deserialize, Default)]
432pub struct TokenUsage {
433 #[serde(default, skip_serializing_if = "is_default")]
434 pub input_tokens: u64,
435 #[serde(default, skip_serializing_if = "is_default")]
436 pub output_tokens: u64,
437 #[serde(default, skip_serializing_if = "is_default")]
438 pub cache_creation_input_tokens: u64,
439 #[serde(default, skip_serializing_if = "is_default")]
440 pub cache_read_input_tokens: u64,
441}
442
443impl TokenUsage {
444 pub fn total_tokens(&self) -> u64 {
445 self.input_tokens
446 + self.output_tokens
447 + self.cache_read_input_tokens
448 + self.cache_creation_input_tokens
449 }
450}
451
452impl Add<TokenUsage> for TokenUsage {
453 type Output = Self;
454
455 fn add(self, other: Self) -> Self {
456 Self {
457 input_tokens: self.input_tokens + other.input_tokens,
458 output_tokens: self.output_tokens + other.output_tokens,
459 cache_creation_input_tokens: self.cache_creation_input_tokens
460 + other.cache_creation_input_tokens,
461 cache_read_input_tokens: self.cache_read_input_tokens + other.cache_read_input_tokens,
462 }
463 }
464}
465
466impl Sub<TokenUsage> for TokenUsage {
467 type Output = Self;
468
469 fn sub(self, other: Self) -> Self {
470 Self {
471 input_tokens: self.input_tokens - other.input_tokens,
472 output_tokens: self.output_tokens - other.output_tokens,
473 cache_creation_input_tokens: self.cache_creation_input_tokens
474 - other.cache_creation_input_tokens,
475 cache_read_input_tokens: self.cache_read_input_tokens - other.cache_read_input_tokens,
476 }
477 }
478}
479
480#[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
481pub struct LanguageModelToolUseId(Arc<str>);
482
483impl fmt::Display for LanguageModelToolUseId {
484 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
485 write!(f, "{}", self.0)
486 }
487}
488
489impl<T> From<T> for LanguageModelToolUseId
490where
491 T: Into<Arc<str>>,
492{
493 fn from(value: T) -> Self {
494 Self(value.into())
495 }
496}
497
498#[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
499pub struct LanguageModelToolUse {
500 pub id: LanguageModelToolUseId,
501 pub name: Arc<str>,
502 pub raw_input: String,
503 pub input: serde_json::Value,
504 pub is_input_complete: bool,
505}
506
507pub struct LanguageModelTextStream {
508 pub message_id: Option<String>,
509 pub stream: BoxStream<'static, Result<String, LanguageModelCompletionError>>,
510 // Has complete token usage after the stream has finished
511 pub last_token_usage: Arc<Mutex<TokenUsage>>,
512}
513
514impl Default for LanguageModelTextStream {
515 fn default() -> Self {
516 Self {
517 message_id: None,
518 stream: Box::pin(futures::stream::empty()),
519 last_token_usage: Arc::new(Mutex::new(TokenUsage::default())),
520 }
521 }
522}
523
524pub trait LanguageModel: Send + Sync {
525 fn id(&self) -> LanguageModelId;
526 fn name(&self) -> LanguageModelName;
527 fn provider_id(&self) -> LanguageModelProviderId;
528 fn provider_name(&self) -> LanguageModelProviderName;
529 fn upstream_provider_id(&self) -> LanguageModelProviderId {
530 self.provider_id()
531 }
532 fn upstream_provider_name(&self) -> LanguageModelProviderName {
533 self.provider_name()
534 }
535
536 fn telemetry_id(&self) -> String;
537
538 fn api_key(&self, _cx: &App) -> Option<String> {
539 None
540 }
541
542 /// Whether this model supports images
543 fn supports_images(&self) -> bool;
544
545 /// Whether this model supports tools.
546 fn supports_tools(&self) -> bool;
547
548 /// Whether this model supports choosing which tool to use.
549 fn supports_tool_choice(&self, choice: LanguageModelToolChoice) -> bool;
550
551 /// Returns whether this model supports "burn mode";
552 fn supports_burn_mode(&self) -> bool {
553 false
554 }
555
556 fn tool_input_format(&self) -> LanguageModelToolSchemaFormat {
557 LanguageModelToolSchemaFormat::JsonSchema
558 }
559
560 fn max_token_count(&self) -> u64;
561 /// Returns the maximum token count for this model in burn mode (If `supports_burn_mode` is `false` this returns `None`)
562 fn max_token_count_in_burn_mode(&self) -> Option<u64> {
563 None
564 }
565 fn max_output_tokens(&self) -> Option<u64> {
566 None
567 }
568
569 fn count_tokens(
570 &self,
571 request: LanguageModelRequest,
572 cx: &App,
573 ) -> BoxFuture<'static, Result<u64>>;
574
575 fn stream_completion(
576 &self,
577 request: LanguageModelRequest,
578 cx: &AsyncApp,
579 ) -> BoxFuture<
580 'static,
581 Result<
582 BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
583 LanguageModelCompletionError,
584 >,
585 >;
586
587 fn stream_completion_text(
588 &self,
589 request: LanguageModelRequest,
590 cx: &AsyncApp,
591 ) -> BoxFuture<'static, Result<LanguageModelTextStream, LanguageModelCompletionError>> {
592 let future = self.stream_completion(request, cx);
593
594 async move {
595 let events = future.await?;
596 let mut events = events.fuse();
597 let mut message_id = None;
598 let mut first_item_text = None;
599 let last_token_usage = Arc::new(Mutex::new(TokenUsage::default()));
600
601 if let Some(first_event) = events.next().await {
602 match first_event {
603 Ok(LanguageModelCompletionEvent::StartMessage { message_id: id }) => {
604 message_id = Some(id);
605 }
606 Ok(LanguageModelCompletionEvent::Text(text)) => {
607 first_item_text = Some(text);
608 }
609 _ => (),
610 }
611 }
612
613 let stream = futures::stream::iter(first_item_text.map(Ok))
614 .chain(events.filter_map({
615 let last_token_usage = last_token_usage.clone();
616 move |result| {
617 let last_token_usage = last_token_usage.clone();
618 async move {
619 match result {
620 Ok(LanguageModelCompletionEvent::StatusUpdate { .. }) => None,
621 Ok(LanguageModelCompletionEvent::StartMessage { .. }) => None,
622 Ok(LanguageModelCompletionEvent::Text(text)) => Some(Ok(text)),
623 Ok(LanguageModelCompletionEvent::Thinking { .. }) => None,
624 Ok(LanguageModelCompletionEvent::RedactedThinking { .. }) => None,
625 Ok(LanguageModelCompletionEvent::Stop(_)) => None,
626 Ok(LanguageModelCompletionEvent::ToolUse(_)) => None,
627 Ok(LanguageModelCompletionEvent::ToolUseJsonParseError {
628 ..
629 }) => None,
630 Ok(LanguageModelCompletionEvent::UsageUpdate(token_usage)) => {
631 *last_token_usage.lock() = token_usage;
632 None
633 }
634 Err(err) => Some(Err(err)),
635 }
636 }
637 }
638 }))
639 .boxed();
640
641 Ok(LanguageModelTextStream {
642 message_id,
643 stream,
644 last_token_usage,
645 })
646 }
647 .boxed()
648 }
649
650 fn cache_configuration(&self) -> Option<LanguageModelCacheConfiguration> {
651 None
652 }
653
654 #[cfg(any(test, feature = "test-support"))]
655 fn as_fake(&self) -> &fake_provider::FakeLanguageModel {
656 unimplemented!()
657 }
658}
659
660pub trait LanguageModelExt: LanguageModel {
661 fn max_token_count_for_mode(&self, mode: CompletionMode) -> u64 {
662 match mode {
663 CompletionMode::Normal => self.max_token_count(),
664 CompletionMode::Max => self
665 .max_token_count_in_burn_mode()
666 .unwrap_or_else(|| self.max_token_count()),
667 }
668 }
669}
670impl LanguageModelExt for dyn LanguageModel {}
671
672pub trait LanguageModelTool: 'static + DeserializeOwned + JsonSchema {
673 fn name() -> String;
674 fn description() -> String;
675}
676
677/// An error that occurred when trying to authenticate the language model provider.
678#[derive(Debug, Error)]
679pub enum AuthenticateError {
680 #[error("connection refused")]
681 ConnectionRefused,
682 #[error("credentials not found")]
683 CredentialsNotFound,
684 #[error(transparent)]
685 Other(#[from] anyhow::Error),
686}
687
688pub trait LanguageModelProvider: 'static {
689 fn id(&self) -> LanguageModelProviderId;
690 fn name(&self) -> LanguageModelProviderName;
691 fn icon(&self) -> IconName {
692 IconName::ZedAssistant
693 }
694 fn default_model(&self, cx: &App) -> Option<Arc<dyn LanguageModel>>;
695 fn default_fast_model(&self, cx: &App) -> Option<Arc<dyn LanguageModel>>;
696 fn provided_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>>;
697 fn recommended_models(&self, _cx: &App) -> Vec<Arc<dyn LanguageModel>> {
698 Vec::new()
699 }
700 fn is_authenticated(&self, cx: &App) -> bool;
701 fn authenticate(&self, cx: &mut App) -> Task<Result<(), AuthenticateError>>;
702 fn configuration_view(
703 &self,
704 target_agent: ConfigurationViewTargetAgent,
705 window: &mut Window,
706 cx: &mut App,
707 ) -> AnyView;
708 fn reset_credentials(&self, cx: &mut App) -> Task<Result<()>>;
709}
710
711#[derive(Default, Clone)]
712pub enum ConfigurationViewTargetAgent {
713 #[default]
714 ZedAgent,
715 Other(SharedString),
716}
717
718#[derive(PartialEq, Eq)]
719pub enum LanguageModelProviderTosView {
720 /// When there are some past interactions in the Agent Panel.
721 ThreadEmptyState,
722 /// When there are no past interactions in the Agent Panel.
723 ThreadFreshStart,
724 TextThreadPopup,
725 Configuration,
726}
727
728pub trait LanguageModelProviderState: 'static {
729 type ObservableEntity;
730
731 fn observable_entity(&self) -> Option<gpui::Entity<Self::ObservableEntity>>;
732
733 fn subscribe<T: 'static>(
734 &self,
735 cx: &mut gpui::Context<T>,
736 callback: impl Fn(&mut T, &mut gpui::Context<T>) + 'static,
737 ) -> Option<gpui::Subscription> {
738 let entity = self.observable_entity()?;
739 Some(cx.observe(&entity, move |this, _, cx| {
740 callback(this, cx);
741 }))
742 }
743}
744
745#[derive(Clone, Eq, PartialEq, Hash, Debug, Ord, PartialOrd, Serialize, Deserialize)]
746pub struct LanguageModelId(pub SharedString);
747
748#[derive(Clone, Eq, PartialEq, Hash, Debug, Ord, PartialOrd)]
749pub struct LanguageModelName(pub SharedString);
750
751#[derive(Clone, Eq, PartialEq, Hash, Debug, Ord, PartialOrd)]
752pub struct LanguageModelProviderId(pub SharedString);
753
754#[derive(Clone, Eq, PartialEq, Hash, Debug, Ord, PartialOrd)]
755pub struct LanguageModelProviderName(pub SharedString);
756
757impl LanguageModelProviderId {
758 pub const fn new(id: &'static str) -> Self {
759 Self(SharedString::new_static(id))
760 }
761}
762
763impl LanguageModelProviderName {
764 pub const fn new(id: &'static str) -> Self {
765 Self(SharedString::new_static(id))
766 }
767}
768
769impl fmt::Display for LanguageModelProviderId {
770 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
771 write!(f, "{}", self.0)
772 }
773}
774
775impl fmt::Display for LanguageModelProviderName {
776 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
777 write!(f, "{}", self.0)
778 }
779}
780
781impl From<String> for LanguageModelId {
782 fn from(value: String) -> Self {
783 Self(SharedString::from(value))
784 }
785}
786
787impl From<String> for LanguageModelName {
788 fn from(value: String) -> Self {
789 Self(SharedString::from(value))
790 }
791}
792
793impl From<String> for LanguageModelProviderId {
794 fn from(value: String) -> Self {
795 Self(SharedString::from(value))
796 }
797}
798
799impl From<String> for LanguageModelProviderName {
800 fn from(value: String) -> Self {
801 Self(SharedString::from(value))
802 }
803}
804
805impl From<Arc<str>> for LanguageModelProviderId {
806 fn from(value: Arc<str>) -> Self {
807 Self(SharedString::from(value))
808 }
809}
810
811impl From<Arc<str>> for LanguageModelProviderName {
812 fn from(value: Arc<str>) -> Self {
813 Self(SharedString::from(value))
814 }
815}
816
817#[cfg(test)]
818mod tests {
819 use super::*;
820
821 #[test]
822 fn test_from_cloud_failure_with_upstream_http_error() {
823 let error = LanguageModelCompletionError::from_cloud_failure(
824 String::from("anthropic").into(),
825 "upstream_http_error".to_string(),
826 r#"{"code":"upstream_http_error","message":"Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers. reset reason: connection timeout","upstream_status":503}"#.to_string(),
827 None,
828 );
829
830 match error {
831 LanguageModelCompletionError::ServerOverloaded { provider, .. } => {
832 assert_eq!(provider.0, "anthropic");
833 }
834 _ => panic!(
835 "Expected ServerOverloaded error for 503 status, got: {:?}",
836 error
837 ),
838 }
839
840 let error = LanguageModelCompletionError::from_cloud_failure(
841 String::from("anthropic").into(),
842 "upstream_http_error".to_string(),
843 r#"{"code":"upstream_http_error","message":"Internal server error","upstream_status":500}"#.to_string(),
844 None,
845 );
846
847 match error {
848 LanguageModelCompletionError::ApiInternalServerError { provider, message } => {
849 assert_eq!(provider.0, "anthropic");
850 assert_eq!(message, "Internal server error");
851 }
852 _ => panic!(
853 "Expected ApiInternalServerError for 500 status, got: {:?}",
854 error
855 ),
856 }
857 }
858
859 #[test]
860 fn test_from_cloud_failure_with_standard_format() {
861 let error = LanguageModelCompletionError::from_cloud_failure(
862 String::from("anthropic").into(),
863 "upstream_http_503".to_string(),
864 "Service unavailable".to_string(),
865 None,
866 );
867
868 match error {
869 LanguageModelCompletionError::ServerOverloaded { provider, .. } => {
870 assert_eq!(provider.0, "anthropic");
871 }
872 _ => panic!("Expected ServerOverloaded error for upstream_http_503"),
873 }
874 }
875
876 #[test]
877 fn test_upstream_http_error_connection_timeout() {
878 let error = LanguageModelCompletionError::from_cloud_failure(
879 String::from("anthropic").into(),
880 "upstream_http_error".to_string(),
881 r#"{"code":"upstream_http_error","message":"Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers. reset reason: connection timeout","upstream_status":503}"#.to_string(),
882 None,
883 );
884
885 match error {
886 LanguageModelCompletionError::ServerOverloaded { provider, .. } => {
887 assert_eq!(provider.0, "anthropic");
888 }
889 _ => panic!(
890 "Expected ServerOverloaded error for connection timeout with 503 status, got: {:?}",
891 error
892 ),
893 }
894
895 let error = LanguageModelCompletionError::from_cloud_failure(
896 String::from("anthropic").into(),
897 "upstream_http_error".to_string(),
898 r#"{"code":"upstream_http_error","message":"Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers. reset reason: connection timeout","upstream_status":500}"#.to_string(),
899 None,
900 );
901
902 match error {
903 LanguageModelCompletionError::ApiInternalServerError { provider, message } => {
904 assert_eq!(provider.0, "anthropic");
905 assert_eq!(
906 message,
907 "Received an error from the Anthropic API: upstream connect error or disconnect/reset before headers. reset reason: connection timeout"
908 );
909 }
910 _ => panic!(
911 "Expected ApiInternalServerError for connection timeout with 500 status, got: {:?}",
912 error
913 ),
914 }
915 }
916}