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. Load more
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(), }); }