use anyhow::{Context as _, Result, anyhow};use collections::{BTreeMap, HashMap};use credentials_provider::CredentialsProvider; use fs::Fs;use futures::Stream;use futures::{FutureExt, StreamExt, future::BoxFuture};use gpui::{AnyView, App, AsyncApp, Context, Entity, Subscription, Task, Window};use http_client::HttpClient;use language_model::{ AuthenticateError, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, LanguageModelToolResultContent, LanguageModelToolUse, MessageContent, RateLimiter, Role, StopReason, TokenUsage,};use menu;use open_ai::{ImageUrl, Model, ResponseStreamEvent, stream_completion};use schemars::JsonSchema;use serde::{Deserialize, Serialize};use settings::{Settings, SettingsStore, update_settings_file};use std::pin::Pin;use std::str::FromStr as _;use std::sync::Arc;use strum::IntoEnumIterator; use ui::{ElevationIndex, List, Tooltip, prelude::*};use ui_input::SingleLineInput;use util::ResultExt; use crate::OpenAiSettingsContent;use crate::{AllLanguageModelSettings, ui::InstructionListItem}; const PROVIDER_ID: &str = "openai";const PROVIDER_NAME: &str = "OpenAI"; #[derive(Default, Clone, Debug, PartialEq)]pub struct OpenAiSettings { pub api_url: String, pub available_models: Vec<AvailableModel>,} #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]pub struct AvailableModel { pub name: String, pub display_name: Option<String>, pub max_tokens: u64, pub max_output_tokens: Option<u64>, pub max_completion_tokens: Option<u64>,} pub struct OpenAiLanguageModelProvider { http_client: Arc<dyn HttpClient>, state: gpui::Entity<State>,} pub struct State { api_key: Option<String>, api_key_from_env: bool, _subscription: Subscription,} const OPENAI_API_KEY_VAR: &str = "OPENAI_API_KEY"; impl State { // fn is_authenticated(&self) -> bool { self.api_key.is_some() } fn reset_api_key(&self, cx: &mut Context<Self>) -> Task<Result<()>> { let credentials_provider = <dyn CredentialsProvider>::global(cx); let api_url = AllLanguageModelSettings::get_global(cx) .openai .api_url .clone(); cx.spawn(async move |this, cx| { credentials_provider .delete_credentials(&api_url, &cx) .await .log_err(); this.update(cx, |this, cx| { this.api_key = None; this.api_key_from_env = false; cx.notify(); }) }) } fn set_api_key(&mut self, api_key: String, cx: &mut Context<Self>) -> Task<Result<()>> { let credentials_provider = <dyn CredentialsProvider>::global(cx); let api_url = AllLanguageModelSettings::get_global(cx) .openai .api_url .clone(); cx.spawn(async move |this, cx| { credentials_provider .write_credentials(&api_url, "Bearer", api_key.as_bytes(), &cx) .await .log_err(); this.update(cx, |this, cx| { this.api_key = Some(api_key); cx.notify(); }) }) } fn authenticate(&self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> { if self.is_authenticated() { return Task::ready(Ok(())); } let credentials_provider = <dyn CredentialsProvider>::global(cx); let api_url = AllLanguageModelSettings::get_global(cx) .openai .api_url .clone(); cx.spawn(async move |this, cx| { let (api_key, from_env) = if let Ok(api_key) = std::env::var(OPENAI_API_KEY_VAR) { (api_key, true) } else { let (_, api_key) = credentials_provider .read_credentials(&api_url, &cx) .await? .ok_or(AuthenticateError::CredentialsNotFound)?; ( String::from_utf8(api_key).context("invalid {PROVIDER_NAME} API key")?, false, ) }; this.update(cx, |this, cx| { this.api_key = Some(api_key); this.api_key_from_env = from_env; cx.notify(); })?; Ok(()) }) }} impl OpenAiLanguageModelProvider { pub fn new(http_client: Arc<dyn HttpClient>, cx: &mut App) -> Self { let state = cx.new(|cx| State { api_key: None, api_key_from_env: false, _subscription: cx.observe_global::<SettingsStore>(|_this: &mut State, cx| { cx.notify(); }), }); 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), }) }} impl LanguageModelProviderState for OpenAiLanguageModelProvider { type ObservableEntity = State; fn observable_entity(&self) -> Option<gpui::Entity<Self::ObservableEntity>> { Some(self.state.clone()) }} impl LanguageModelProvider for OpenAiLanguageModelProvider { fn id(&self) -> LanguageModelProviderId { LanguageModelProviderId(PROVIDER_ID.into()) } fn name(&self) -> LanguageModelProviderName { LanguageModelProviderName(PROVIDER_NAME.into()) } fn icon(&self) -> IconName { 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 &AllLanguageModelSettings::get_global(cx) .openai .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, }, ); } 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, 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.reset_api_key(cx)) }} pub struct OpenAiLanguageModel { id: LanguageModelId, model: open_ai::Model, state: gpui::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 Ok((api_key, api_url)) = cx.read_entity(&self.state, |state, cx| { let settings = &AllLanguageModelSettings::get_global(cx).openai; (state.api_key.clone(), settings.api_url.clone()) }) else { return futures::future::ready(Err(anyhow!("App state dropped"))).boxed(); }; let future = self.request_limiter.stream(async move { let api_key = api_key.context("Missing OpenAI API Key")?; let request = stream_completion(http_client.as_ref(), &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 { LanguageModelProviderId(PROVIDER_ID.into()) } fn provider_name(&self) -> LanguageModelProviderName { LanguageModelProviderName(PROVIDER_NAME.into()) } fn supports_tools(&self) -> bool { true } fn supports_images(&self) -> bool { false } fn supports_tool_choice(&self, choice: LanguageModelToolChoice) -> bool { match choice { LanguageModelToolChoice::Auto => true, LanguageModelToolChoice::Any => true, LanguageModelToolChoice::None => 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, >, > { let request = into_open_ai( request, self.model.id(), self.model.supports_parallel_tool_calls(), self.max_output_tokens(), ); let completions = self.stream_completion(request, cx); async move { let mapper = OpenAiEventMapper::new(); Ok(mapper.map_stream(completions.await?).boxed()) } .boxed() }} pub fn into_open_ai( request: LanguageModelRequest, model_id: &str, supports_parallel_tool_calls: bool, max_output_tokens: Option<u64>,) -> 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, .. } => { add_message_content_part( open_ai::MessagePart::Text { 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(), }); } } } } open_ai::Request { model: model_id.into(), messages, stream, stop: request.stop, temperature: request.temperature.unwrap_or(1.0), max_completion_tokens: max_output_tokens, parallel_tool_calls: if supports_parallel_tool_calls && !request.tools.is_empty() { // Disable parallel tool calls, as the Agent currently expects a maximum of one per turn. Some(false) } else { None }, tools: request .tools .into_iter() .map(|tool| open_ai::ToolDefinition::Function { function: open_ai::FunctionDefinition { name: tool.name, description: Some(tool.description), parameters: Some(tool.input_schema), }, }) .collect(), tool_choice: request.tool_choice.map(|choice| match choice { LanguageModelToolChoice::Auto => open_ai::ToolChoice::Auto, LanguageModelToolChoice::Any => open_ai::ToolChoice::Required, LanguageModelToolChoice::None => open_ai::ToolChoice::None, }), }} fn add_message_content_part( new_part: open_ai::MessagePart, role: Role, messages: &mut Vec<open_ai::RequestMessage>,) { match (role, messages.last_mut()) { (Role::User, Some(open_ai::RequestMessage::User { content })) | ( Role::Assistant, Some(open_ai::RequestMessage::Assistant { content: Some(content), .. }), ) | (Role::System, Some(open_ai::RequestMessage::System { content, .. })) => { content.push_part(new_part); } _ => { messages.push(match role { Role::User => open_ai::RequestMessage::User { content: open_ai::MessageContent::from(vec![new_part]), }, Role::Assistant => open_ai::RequestMessage::Assistant { content: Some(open_ai::MessageContent::from(vec![new_part])), tool_calls: Vec::new(), },Lines 1–500 of 1013. Load more
use anyhow::{Context as _, Result, anyhow}; use collections::{BTreeMap, HashMap}; use credentials_provider::CredentialsProvider; use fs::Fs; use futures::Stream; use futures::{FutureExt, StreamExt, future::BoxFuture}; use gpui::{AnyView, App, AsyncApp, Context, Entity, Subscription, Task, Window}; use http_client::HttpClient; use language_model::{ AuthenticateError, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, LanguageModelToolResultContent, LanguageModelToolUse, MessageContent, RateLimiter, Role, StopReason, TokenUsage, }; use menu; use open_ai::{ImageUrl, Model, ResponseStreamEvent, stream_completion}; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use settings::{Settings, SettingsStore, update_settings_file}; use std::pin::Pin; use std::str::FromStr as _; use std::sync::Arc; use strum::IntoEnumIterator; use ui::{ElevationIndex, List, Tooltip, prelude::*}; use ui_input::SingleLineInput; use util::ResultExt; use crate::OpenAiSettingsContent; use crate::{AllLanguageModelSettings, ui::InstructionListItem}; const PROVIDER_ID: &str = "openai"; const PROVIDER_NAME: &str = "OpenAI"; #[derive(Default, Clone, Debug, PartialEq)] pub struct OpenAiSettings { pub api_url: String, pub available_models: Vec<AvailableModel>, } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)] pub struct AvailableModel { pub name: String, pub display_name: Option<String>, pub max_tokens: u64, pub max_output_tokens: Option<u64>, pub max_completion_tokens: Option<u64>, } pub struct OpenAiLanguageModelProvider { http_client: Arc<dyn HttpClient>, state: gpui::Entity<State>, } pub struct State { api_key: Option<String>, api_key_from_env: bool, _subscription: Subscription, } const OPENAI_API_KEY_VAR: &str = "OPENAI_API_KEY"; impl State { // fn is_authenticated(&self) -> bool { self.api_key.is_some() } fn reset_api_key(&self, cx: &mut Context<Self>) -> Task<Result<()>> { let credentials_provider = <dyn CredentialsProvider>::global(cx); let api_url = AllLanguageModelSettings::get_global(cx) .openai .api_url .clone(); cx.spawn(async move |this, cx| { credentials_provider .delete_credentials(&api_url, &cx) .await .log_err(); this.update(cx, |this, cx| { this.api_key = None; this.api_key_from_env = false; cx.notify(); }) }) } fn set_api_key(&mut self, api_key: String, cx: &mut Context<Self>) -> Task<Result<()>> { let credentials_provider = <dyn CredentialsProvider>::global(cx); let api_url = AllLanguageModelSettings::get_global(cx) .openai .api_url .clone(); cx.spawn(async move |this, cx| { credentials_provider .write_credentials(&api_url, "Bearer", api_key.as_bytes(), &cx) .await .log_err(); this.update(cx, |this, cx| { this.api_key = Some(api_key); cx.notify(); }) }) } fn authenticate(&self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> { if self.is_authenticated() { return Task::ready(Ok(())); } let credentials_provider = <dyn CredentialsProvider>::global(cx); let api_url = AllLanguageModelSettings::get_global(cx) .openai .api_url .clone(); cx.spawn(async move |this, cx| { let (api_key, from_env) = if let Ok(api_key) = std::env::var(OPENAI_API_KEY_VAR) { (api_key, true) } else { let (_, api_key) = credentials_provider .read_credentials(&api_url, &cx) .await? .ok_or(AuthenticateError::CredentialsNotFound)?; ( String::from_utf8(api_key).context("invalid {PROVIDER_NAME} API key")?, false, ) }; this.update(cx, |this, cx| { this.api_key = Some(api_key); this.api_key_from_env = from_env; cx.notify(); })?; Ok(()) }) } } impl OpenAiLanguageModelProvider { pub fn new(http_client: Arc<dyn HttpClient>, cx: &mut App) -> Self { let state = cx.new(|cx| State { api_key: None, api_key_from_env: false, _subscription: cx.observe_global::<SettingsStore>(|_this: &mut State, cx| { cx.notify(); }), }); 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), }) } } impl LanguageModelProviderState for OpenAiLanguageModelProvider { type ObservableEntity = State; fn observable_entity(&self) -> Option<gpui::Entity<Self::ObservableEntity>> { Some(self.state.clone()) } } impl LanguageModelProvider for OpenAiLanguageModelProvider { fn id(&self) -> LanguageModelProviderId { LanguageModelProviderId(PROVIDER_ID.into()) } fn name(&self) -> LanguageModelProviderName { LanguageModelProviderName(PROVIDER_NAME.into()) } fn icon(&self) -> IconName { 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 &AllLanguageModelSettings::get_global(cx) .openai .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, }, ); } 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, 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.reset_api_key(cx)) } } pub struct OpenAiLanguageModel { id: LanguageModelId, model: open_ai::Model, state: gpui::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 Ok((api_key, api_url)) = cx.read_entity(&self.state, |state, cx| { let settings = &AllLanguageModelSettings::get_global(cx).openai; (state.api_key.clone(), settings.api_url.clone()) }) else { return futures::future::ready(Err(anyhow!("App state dropped"))).boxed(); }; let future = self.request_limiter.stream(async move { let api_key = api_key.context("Missing OpenAI API Key")?; let request = stream_completion(http_client.as_ref(), &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 { LanguageModelProviderId(PROVIDER_ID.into()) } fn provider_name(&self) -> LanguageModelProviderName { LanguageModelProviderName(PROVIDER_NAME.into()) } fn supports_tools(&self) -> bool { true } fn supports_images(&self) -> bool { false } fn supports_tool_choice(&self, choice: LanguageModelToolChoice) -> bool { match choice { LanguageModelToolChoice::Auto => true, LanguageModelToolChoice::Any => true, LanguageModelToolChoice::None => 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, >, > { let request = into_open_ai( request, self.model.id(), self.model.supports_parallel_tool_calls(), self.max_output_tokens(), ); let completions = self.stream_completion(request, cx); async move { let mapper = OpenAiEventMapper::new(); Ok(mapper.map_stream(completions.await?).boxed()) } .boxed() } } pub fn into_open_ai( request: LanguageModelRequest, model_id: &str, supports_parallel_tool_calls: bool, max_output_tokens: Option<u64>, ) -> 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, .. } => { add_message_content_part( open_ai::MessagePart::Text { 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(), }); } } } } open_ai::Request { model: model_id.into(), messages, stream, stop: request.stop, temperature: request.temperature.unwrap_or(1.0), max_completion_tokens: max_output_tokens, parallel_tool_calls: if supports_parallel_tool_calls && !request.tools.is_empty() { // Disable parallel tool calls, as the Agent currently expects a maximum of one per turn. Some(false) } else { None }, tools: request .tools .into_iter() .map(|tool| open_ai::ToolDefinition::Function { function: open_ai::FunctionDefinition { name: tool.name, description: Some(tool.description), parameters: Some(tool.input_schema), }, }) .collect(), tool_choice: request.tool_choice.map(|choice| match choice { LanguageModelToolChoice::Auto => open_ai::ToolChoice::Auto, LanguageModelToolChoice::Any => open_ai::ToolChoice::Required, LanguageModelToolChoice::None => open_ai::ToolChoice::None, }), } } fn add_message_content_part( new_part: open_ai::MessagePart, role: Role, messages: &mut Vec<open_ai::RequestMessage>, ) { match (role, messages.last_mut()) { (Role::User, Some(open_ai::RequestMessage::User { content })) | ( Role::Assistant, Some(open_ai::RequestMessage::Assistant { content: Some(content), .. }), ) | (Role::System, Some(open_ai::RequestMessage::System { content, .. })) => { content.push_part(new_part); } _ => { messages.push(match role { Role::User => open_ai::RequestMessage::User { content: open_ai::MessageContent::from(vec![new_part]), }, Role::Assistant => open_ai::RequestMessage::Assistant { content: Some(open_ai::MessageContent::from(vec![new_part])), tool_calls: Vec::new(), },