2307 lines · 81.8 KB · Rust
RawDownload
use anyhow::{Result, anyhow};use collections::{BTreeMap, HashMap};use futures::Stream;use futures::{FutureExt, StreamExt, future::BoxFuture};use gpui::{AnyView, App, AsyncApp, Context, Entity, SharedString, Task, Window};use http_client::HttpClient;use language_model::{    ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel, LanguageModelCompletionError,    LanguageModelCompletionEvent, LanguageModelId, LanguageModelImage, LanguageModelName,    LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName,    LanguageModelProviderState, LanguageModelRequest, LanguageModelRequestMessage,    LanguageModelToolChoice, LanguageModelToolResult, LanguageModelToolResultContent,    LanguageModelToolUse, LanguageModelToolUseId, MessageContent, RateLimiter, Role, StopReason,    TokenUsage, env_var,};use menu;use open_ai::responses::{    ResponseFunctionCallItem, ResponseFunctionCallOutputItem, ResponseInputContent,    ResponseInputItem, ResponseMessageItem,};use open_ai::{    ImageUrl, Model, OPEN_AI_API_URL, ReasoningEffort, ResponseStreamEvent,    responses::{        Request as ResponseRequest, ResponseOutputItem, ResponseSummary as ResponsesSummary,        ResponseUsage as ResponsesUsage, StreamEvent as ResponsesStreamEvent, stream_response,    },    stream_completion,};use settings::{OpenAiAvailableModel as AvailableModel, Settings, SettingsStore};use std::pin::Pin;use std::sync::{Arc, LazyLock};use strum::IntoEnumIterator;use ui::{ButtonLink, ConfiguredApiCard, List, ListBulletItem, prelude::*};use ui_input::InputField;use util::ResultExt; use crate::provider::util::parse_tool_arguments; const PROVIDER_ID: LanguageModelProviderId = language_model::OPEN_AI_PROVIDER_ID;const PROVIDER_NAME: LanguageModelProviderName = language_model::OPEN_AI_PROVIDER_NAME; const API_KEY_ENV_VAR_NAME: &str = "OPENAI_API_KEY";static API_KEY_ENV_VAR: LazyLock<EnvVar> = env_var!(API_KEY_ENV_VAR_NAME); #[derive(Default, Clone, Debug, PartialEq)]pub struct OpenAiSettings {    pub api_url: String,    pub available_models: Vec<AvailableModel>,} pub struct OpenAiLanguageModelProvider {    http_client: Arc<dyn HttpClient>,    state: Entity<State>,} pub struct State {    api_key_state: ApiKeyState,} impl State {    fn is_authenticated(&self) -> bool {        self.api_key_state.has_key()    }     fn set_api_key(&mut self, api_key: Option<String>, cx: &mut Context<Self>) -> Task<Result<()>> {        let api_url = OpenAiLanguageModelProvider::api_url(cx);        self.api_key_state            .store(api_url, api_key, |this| &mut this.api_key_state, cx)    }     fn authenticate(&mut self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {        let api_url = OpenAiLanguageModelProvider::api_url(cx);        self.api_key_state            .load_if_needed(api_url, |this| &mut this.api_key_state, cx)    }} impl OpenAiLanguageModelProvider {    pub fn new(http_client: Arc<dyn HttpClient>, cx: &mut App) -> Self {        let state = cx.new(|cx| {            cx.observe_global::<SettingsStore>(|this: &mut State, cx| {                let api_url = Self::api_url(cx);                this.api_key_state                    .handle_url_change(api_url, |this| &mut this.api_key_state, cx);                cx.notify();            })            .detach();            State {                api_key_state: ApiKeyState::new(Self::api_url(cx), (*API_KEY_ENV_VAR).clone()),            }        });         Self { http_client, state }    }     fn create_language_model(&self, model: open_ai::Model) -> Arc<dyn LanguageModel> {        Arc::new(OpenAiLanguageModel {            id: LanguageModelId::from(model.id().to_string()),            model,            state: self.state.clone(),            http_client: self.http_client.clone(),            request_limiter: RateLimiter::new(4),        })    }     fn settings(cx: &App) -> &OpenAiSettings {        &crate::AllLanguageModelSettings::get_global(cx).openai    }     fn api_url(cx: &App) -> SharedString {        let api_url = &Self::settings(cx).api_url;        if api_url.is_empty() {            open_ai::OPEN_AI_API_URL.into()        } else {            SharedString::new(api_url.as_str())        }    }} impl LanguageModelProviderState for OpenAiLanguageModelProvider {    type ObservableEntity = State;     fn observable_entity(&self) -> Option<Entity<Self::ObservableEntity>> {        Some(self.state.clone())    }} impl LanguageModelProvider for OpenAiLanguageModelProvider {    fn id(&self) -> LanguageModelProviderId {        PROVIDER_ID    }     fn name(&self) -> LanguageModelProviderName {        PROVIDER_NAME    }     fn icon(&self) -> IconOrSvg {        IconOrSvg::Icon(IconName::AiOpenAi)    }     fn default_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> {        Some(self.create_language_model(open_ai::Model::default()))    }     fn default_fast_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> {        Some(self.create_language_model(open_ai::Model::default_fast()))    }     fn provided_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>> {        let mut models = BTreeMap::default();         // Add base models from open_ai::Model::iter()        for model in open_ai::Model::iter() {            if !matches!(model, open_ai::Model::Custom { .. }) {                models.insert(model.id().to_string(), model);            }        }         // Override with available models from settings        for model in &OpenAiLanguageModelProvider::settings(cx).available_models {            models.insert(                model.name.clone(),                open_ai::Model::Custom {                    name: model.name.clone(),                    display_name: model.display_name.clone(),                    max_tokens: model.max_tokens,                    max_output_tokens: model.max_output_tokens,                    max_completion_tokens: model.max_completion_tokens,                    reasoning_effort: model.reasoning_effort.clone(),                    supports_chat_completions: model.capabilities.chat_completions,                },            );        }         models            .into_values()            .map(|model| self.create_language_model(model))            .collect()    }     fn is_authenticated(&self, cx: &App) -> bool {        self.state.read(cx).is_authenticated()    }     fn authenticate(&self, cx: &mut App) -> Task<Result<(), AuthenticateError>> {        self.state.update(cx, |state, cx| state.authenticate(cx))    }     fn configuration_view(        &self,        _target_agent: language_model::ConfigurationViewTargetAgent,        window: &mut Window,        cx: &mut App,    ) -> AnyView {        cx.new(|cx| ConfigurationView::new(self.state.clone(), window, cx))            .into()    }     fn reset_credentials(&self, cx: &mut App) -> Task<Result<()>> {        self.state            .update(cx, |state, cx| state.set_api_key(None, cx))    }} pub struct OpenAiLanguageModel {    id: LanguageModelId,    model: open_ai::Model,    state: Entity<State>,    http_client: Arc<dyn HttpClient>,    request_limiter: RateLimiter,} impl OpenAiLanguageModel {    fn stream_completion(        &self,        request: open_ai::Request,        cx: &AsyncApp,    ) -> BoxFuture<'static, Result<futures::stream::BoxStream<'static, Result<ResponseStreamEvent>>>>    {        let http_client = self.http_client.clone();         let (api_key, api_url) = self.state.read_with(cx, |state, cx| {            let api_url = OpenAiLanguageModelProvider::api_url(cx);            (state.api_key_state.key(&api_url), api_url)        });         let future = self.request_limiter.stream(async move {            let provider = PROVIDER_NAME;            let Some(api_key) = api_key else {                return Err(LanguageModelCompletionError::NoApiKey { provider });            };            let request = stream_completion(                http_client.as_ref(),                provider.0.as_str(),                &api_url,                &api_key,                request,            );            let response = request.await?;            Ok(response)        });         async move { Ok(future.await?.boxed()) }.boxed()    }     fn stream_response(        &self,        request: ResponseRequest,        cx: &AsyncApp,    ) -> BoxFuture<'static, Result<futures::stream::BoxStream<'static, Result<ResponsesStreamEvent>>>>    {        let http_client = self.http_client.clone();         let (api_key, api_url) = self.state.read_with(cx, |state, cx| {            let api_url = OpenAiLanguageModelProvider::api_url(cx);            (state.api_key_state.key(&api_url), api_url)        });         let provider = PROVIDER_NAME;        let future = self.request_limiter.stream(async move {            let Some(api_key) = api_key else {                return Err(LanguageModelCompletionError::NoApiKey { provider });            };            let request = stream_response(                http_client.as_ref(),                provider.0.as_str(),                &api_url,                &api_key,                request,            );            let response = request.await?;            Ok(response)        });         async move { Ok(future.await?.boxed()) }.boxed()    }} impl LanguageModel for OpenAiLanguageModel {    fn id(&self) -> LanguageModelId {        self.id.clone()    }     fn name(&self) -> LanguageModelName {        LanguageModelName::from(self.model.display_name().to_string())    }     fn provider_id(&self) -> LanguageModelProviderId {        PROVIDER_ID    }     fn provider_name(&self) -> LanguageModelProviderName {        PROVIDER_NAME    }     fn supports_tools(&self) -> bool {        true    }     fn supports_images(&self) -> bool {        use open_ai::Model;        match &self.model {            Model::FourOmniMini            | Model::FourPointOneNano            | Model::Five            | Model::FiveCodex            | Model::FiveMini            | Model::FiveNano            | Model::FivePointOne            | Model::FivePointTwo            | Model::FivePointTwoCodex            | Model::FivePointThreeCodex            | Model::FivePointFour            | Model::FivePointFourPro            | Model::O1            | Model::O3 => true,            Model::ThreePointFiveTurbo            | Model::Four            | Model::FourTurbo            | Model::O3Mini            | Model::Custom { .. } => false,        }    }     fn supports_tool_choice(&self, choice: LanguageModelToolChoice) -> bool {        match choice {            LanguageModelToolChoice::Auto => true,            LanguageModelToolChoice::Any => true,            LanguageModelToolChoice::None => true,        }    }     fn supports_streaming_tools(&self) -> bool {        true    }     fn supports_thinking(&self) -> bool {        self.model.reasoning_effort().is_some()    }     fn supports_split_token_display(&self) -> bool {        true    }     fn telemetry_id(&self) -> String {        format!("openai/{}", self.model.id())    }     fn max_token_count(&self) -> u64 {        self.model.max_token_count()    }     fn max_output_tokens(&self) -> Option<u64> {        self.model.max_output_tokens()    }     fn count_tokens(        &self,        request: LanguageModelRequest,        cx: &App,    ) -> BoxFuture<'static, Result<u64>> {        count_open_ai_tokens(request, self.model.clone(), cx)    }     fn stream_completion(        &self,        request: LanguageModelRequest,        cx: &AsyncApp,    ) -> BoxFuture<        'static,        Result<            futures::stream::BoxStream<                'static,                Result<LanguageModelCompletionEvent, LanguageModelCompletionError>,            >,            LanguageModelCompletionError,        >,    > {        if self.model.supports_chat_completions() {            let request = into_open_ai(                request,                self.model.id(),                self.model.supports_parallel_tool_calls(),                self.model.supports_prompt_cache_key(),                self.max_output_tokens(),                self.model.reasoning_effort(),            );            let completions = self.stream_completion(request, cx);            async move {                let mapper = OpenAiEventMapper::new();                Ok(mapper.map_stream(completions.await?).boxed())            }            .boxed()        } else {            let request = into_open_ai_response(                request,                self.model.id(),                self.model.supports_parallel_tool_calls(),                self.model.supports_prompt_cache_key(),                self.max_output_tokens(),                self.model.reasoning_effort(),            );            let completions = self.stream_response(request, cx);            async move {                let mapper = OpenAiResponseEventMapper::new();                Ok(mapper.map_stream(completions.await?).boxed())            }            .boxed()        }    }} pub fn into_open_ai(    request: LanguageModelRequest,    model_id: &str,    supports_parallel_tool_calls: bool,    supports_prompt_cache_key: bool,    max_output_tokens: Option<u64>,    reasoning_effort: Option<ReasoningEffort>,) -> open_ai::Request {    let stream = !model_id.starts_with("o1-");     let mut messages = Vec::new();    for message in request.messages {        for content in message.content {            match content {                MessageContent::Text(text) | MessageContent::Thinking { text, .. } => {                    let should_add = if message.role == Role::User {                        // Including whitespace-only user messages can cause error with OpenAI compatible APIs                        // See https://github.com/zed-industries/zed/issues/40097                        !text.trim().is_empty()                    } else {                        !text.is_empty()                    };                    if should_add {                        add_message_content_part(                            open_ai::MessagePart::Text { text },                            message.role,                            &mut messages,                        );                    }                }                MessageContent::RedactedThinking(_) => {}                MessageContent::Image(image) => {                    add_message_content_part(                        open_ai::MessagePart::Image {                            image_url: ImageUrl {                                url: image.to_base64_url(),                                detail: None,                            },                        },                        message.role,                        &mut messages,                    );                }                MessageContent::ToolUse(tool_use) => {                    let tool_call = open_ai::ToolCall {                        id: tool_use.id.to_string(),                        content: open_ai::ToolCallContent::Function {                            function: open_ai::FunctionContent {                                name: tool_use.name.to_string(),                                arguments: serde_json::to_string(&tool_use.input)                                    .unwrap_or_default(),                            },                        },                    };                     if let Some(open_ai::RequestMessage::Assistant { tool_calls, .. }) =                        messages.last_mut()                    {                        tool_calls.push(tool_call);                    } else {                        messages.push(open_ai::RequestMessage::Assistant {                            content: None,                            tool_calls: vec![tool_call],                        });                    }                }                MessageContent::ToolResult(tool_result) => {                    let content = match &tool_result.content {                        LanguageModelToolResultContent::Text(text) => {                            vec![open_ai::MessagePart::Text {                                text: text.to_string(),                            }]                        }                        LanguageModelToolResultContent::Image(image) => {                            vec![open_ai::MessagePart::Image {                                image_url: ImageUrl {                                    url: image.to_base64_url(),                                    detail: None,                                },                            }]                        }                    };                     messages.push(open_ai::RequestMessage::Tool {                        content: content.into(),                        tool_call_id: tool_result.tool_use_id.to_string(),                    });                }

Lines 1–500 of 2307.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t