use anyhow::{Context as _, Result, anyhow};use collections::BTreeMap;use credentials_provider::CredentialsProvider;use editor::{Editor, EditorElement, EditorStyle};use futures::{FutureExt, Stream, StreamExt, future::BoxFuture};use google_ai::{ FunctionDeclaration, GenerateContentResponse, GoogleModelMode, Part, SystemInstruction, ThinkingConfig, UsageMetadata,};use gpui::{ AnyView, App, AsyncApp, Context, Entity, FontStyle, Subscription, Task, TextStyle, WhiteSpace,};use http_client::HttpClient;use language_model::{ AuthenticateError, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelToolChoice, LanguageModelToolSchemaFormat, LanguageModelToolUse, LanguageModelToolUseId, MessageContent, StopReason,};use language_model::{ LanguageModel, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, RateLimiter, Role,};use schemars::JsonSchema;use serde::{Deserialize, Serialize};use settings::{Settings, SettingsStore};use std::pin::Pin;use std::sync::{ Arc, atomic::{self, AtomicU64},};use strum::IntoEnumIterator;use theme::ThemeSettings;use ui::{Icon, IconName, List, Tooltip, prelude::*};use util::ResultExt; use crate::AllLanguageModelSettings;use crate::ui::InstructionListItem; const PROVIDER_ID: &str = "google";const PROVIDER_NAME: &str = "Google AI"; #[derive(Default, Clone, Debug, PartialEq)]pub struct GoogleSettings { pub api_url: String, pub available_models: Vec<AvailableModel>,} #[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize, JsonSchema)]#[serde(tag = "type", rename_all = "lowercase")]pub enum ModelMode { #[default] Default, Thinking { /// The maximum number of tokens to use for reasoning. Must be lower than the model's `max_output_tokens`. budget_tokens: Option<u32>, },} impl From<ModelMode> for GoogleModelMode { fn from(value: ModelMode) -> Self { match value { ModelMode::Default => GoogleModelMode::Default, ModelMode::Thinking { budget_tokens } => GoogleModelMode::Thinking { budget_tokens }, } }} impl From<GoogleModelMode> for ModelMode { fn from(value: GoogleModelMode) -> Self { match value { GoogleModelMode::Default => ModelMode::Default, GoogleModelMode::Thinking { budget_tokens } => ModelMode::Thinking { budget_tokens }, } }} #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]pub struct AvailableModel { name: String, display_name: Option<String>, max_tokens: u64, mode: Option<ModelMode>,} pub struct GoogleLanguageModelProvider { http_client: Arc<dyn HttpClient>, state: gpui::Entity<State>,} pub struct State { api_key: Option<String>, api_key_from_env: bool, _subscription: Subscription,} const GOOGLE_AI_API_KEY_VAR: &str = "GOOGLE_AI_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) .google .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) .google .api_url .clone(); cx.spawn(async move |this, cx| { credentials_provider .write_credentials(&api_url, "Bearer", api_key.as_bytes(), &cx) .await?; 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) .google .api_url .clone(); cx.spawn(async move |this, cx| { let (api_key, from_env) = if let Ok(api_key) = std::env::var(GOOGLE_AI_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 GoogleLanguageModelProvider { 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>(|_, cx| { cx.notify(); }), }); Self { http_client, state } } fn create_language_model(&self, model: google_ai::Model) -> Arc<dyn LanguageModel> { Arc::new(GoogleLanguageModel { 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 GoogleLanguageModelProvider { type ObservableEntity = State; fn observable_entity(&self) -> Option<gpui::Entity<Self::ObservableEntity>> { Some(self.state.clone()) }} impl LanguageModelProvider for GoogleLanguageModelProvider { fn id(&self) -> LanguageModelProviderId { LanguageModelProviderId(PROVIDER_ID.into()) } fn name(&self) -> LanguageModelProviderName { LanguageModelProviderName(PROVIDER_NAME.into()) } fn icon(&self) -> IconName { IconName::AiGoogle } fn default_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> { Some(self.create_language_model(google_ai::Model::default())) } fn default_fast_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> { Some(self.create_language_model(google_ai::Model::default_fast())) } fn provided_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>> { let mut models = BTreeMap::default(); // Add base models from google_ai::Model::iter() for model in google_ai::Model::iter() { if !matches!(model, google_ai::Model::Custom { .. }) { models.insert(model.id().to_string(), model); } } // Override with available models from settings for model in &AllLanguageModelSettings::get_global(cx) .google .available_models { models.insert( model.name.clone(), google_ai::Model::Custom { name: model.name.clone(), display_name: model.display_name.clone(), max_tokens: model.max_tokens, mode: model.mode.unwrap_or_default().into(), }, ); } models .into_values() .map(|model| { Arc::new(GoogleLanguageModel { id: LanguageModelId::from(model.id().to_string()), model, state: self.state.clone(), http_client: self.http_client.clone(), request_limiter: RateLimiter::new(4), }) as Arc<dyn LanguageModel> }) .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 GoogleLanguageModel { id: LanguageModelId, model: google_ai::Model, state: gpui::Entity<State>, http_client: Arc<dyn HttpClient>, request_limiter: RateLimiter,} impl GoogleLanguageModel { fn stream_completion( &self, request: google_ai::GenerateContentRequest, cx: &AsyncApp, ) -> BoxFuture< 'static, Result<futures::stream::BoxStream<'static, Result<GenerateContentResponse>>>, > { 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).google; (state.api_key.clone(), settings.api_url.clone()) }) else { return futures::future::ready(Err(anyhow!("App state dropped"))).boxed(); }; async move { let api_key = api_key.context("Missing Google API key")?; let request = google_ai::stream_generate_content( http_client.as_ref(), &api_url, &api_key, request, ); request.await.context("failed to stream completion") } .boxed() }} impl LanguageModel for GoogleLanguageModel { 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 { self.model.supports_tools() } fn supports_images(&self) -> bool { self.model.supports_images() } fn supports_tool_choice(&self, choice: LanguageModelToolChoice) -> bool { match choice { LanguageModelToolChoice::Auto | LanguageModelToolChoice::Any | LanguageModelToolChoice::None => true, } } fn tool_input_format(&self) -> LanguageModelToolSchemaFormat { LanguageModelToolSchemaFormat::JsonSchemaSubset } fn telemetry_id(&self) -> String { format!("google/{}", self.model.request_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>> { let model_id = self.model.request_id().to_string(); let request = into_google(request, model_id.clone(), self.model.mode()); let http_client = self.http_client.clone(); let api_key = self.state.read(cx).api_key.clone(); let settings = &AllLanguageModelSettings::get_global(cx).google; let api_url = settings.api_url.clone(); async move { let api_key = api_key.context("Missing Google API key")?; let response = google_ai::count_tokens( http_client.as_ref(), &api_url, &api_key, google_ai::CountTokensRequest { generate_content_request: request, }, ) .await?; Ok(response.total_tokens) } .boxed() } fn stream_completion( &self, request: LanguageModelRequest, cx: &AsyncApp, ) -> BoxFuture< 'static, Result< futures::stream::BoxStream< 'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>, >, LanguageModelCompletionError, >, > { let request = into_google( request, self.model.request_id().to_string(), self.model.mode(), ); let request = self.stream_completion(request, cx); let future = self.request_limiter.stream(async move { let response = request .await .map_err(|err| LanguageModelCompletionError::Other(anyhow!(err)))?; Ok(GoogleEventMapper::new().map_stream(response)) }); async move { Ok(future.await?.boxed()) }.boxed() }} pub fn into_google( mut request: LanguageModelRequest, model_id: String, mode: GoogleModelMode,) -> google_ai::GenerateContentRequest { fn map_content(content: Vec<MessageContent>) -> Vec<Part> { content .into_iter() .flat_map(|content| match content { language_model::MessageContent::Text(text) => { if !text.is_empty() { vec![Part::TextPart(google_ai::TextPart { text })] } else { vec![] } } language_model::MessageContent::Thinking { text: _, signature: Some(signature), } => { if !signature.is_empty() { vec![Part::ThoughtPart(google_ai::ThoughtPart { thought: true, thought_signature: signature, })] } else { vec![] } } language_model::MessageContent::Thinking { .. } => { vec![] } language_model::MessageContent::RedactedThinking(_) => vec![], language_model::MessageContent::Image(image) => { vec![Part::InlineDataPart(google_ai::InlineDataPart { inline_data: google_ai::GenerativeContentBlob { mime_type: "image/png".to_string(), data: image.source.to_string(), }, })] } language_model::MessageContent::ToolUse(tool_use) => { vec![Part::FunctionCallPart(google_ai::FunctionCallPart { function_call: google_ai::FunctionCall { name: tool_use.name.to_string(), args: tool_use.input, }, })] } language_model::MessageContent::ToolResult(tool_result) => { match tool_result.content { language_model::LanguageModelToolResultContent::Text(text) => { vec![Part::FunctionResponsePart( google_ai::FunctionResponsePart { function_response: google_ai::FunctionResponse { name: tool_result.tool_name.to_string(), // The API expects a valid JSON object response: serde_json::json!({ "output": text }), }, }, )] } language_model::LanguageModelToolResultContent::Image(image) => { vec![Lines 1–500 of 947. Load more
use anyhow::{Context as _, Result, anyhow}; use collections::BTreeMap; use credentials_provider::CredentialsProvider; use editor::{Editor, EditorElement, EditorStyle}; use futures::{FutureExt, Stream, StreamExt, future::BoxFuture}; use google_ai::{ FunctionDeclaration, GenerateContentResponse, GoogleModelMode, Part, SystemInstruction, ThinkingConfig, UsageMetadata, }; use gpui::{ AnyView, App, AsyncApp, Context, Entity, FontStyle, Subscription, Task, TextStyle, WhiteSpace, }; use http_client::HttpClient; use language_model::{ AuthenticateError, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelToolChoice, LanguageModelToolSchemaFormat, LanguageModelToolUse, LanguageModelToolUseId, MessageContent, StopReason, }; use language_model::{ LanguageModel, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, RateLimiter, Role, }; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use settings::{Settings, SettingsStore}; use std::pin::Pin; use std::sync::{ Arc, atomic::{self, AtomicU64}, }; use strum::IntoEnumIterator; use theme::ThemeSettings; use ui::{Icon, IconName, List, Tooltip, prelude::*}; use util::ResultExt; use crate::AllLanguageModelSettings; use crate::ui::InstructionListItem; const PROVIDER_ID: &str = "google"; const PROVIDER_NAME: &str = "Google AI"; #[derive(Default, Clone, Debug, PartialEq)] pub struct GoogleSettings { pub api_url: String, pub available_models: Vec<AvailableModel>, } #[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize, JsonSchema)] #[serde(tag = "type", rename_all = "lowercase")] pub enum ModelMode { #[default] Default, Thinking { /// The maximum number of tokens to use for reasoning. Must be lower than the model's `max_output_tokens`. budget_tokens: Option<u32>, }, } impl From<ModelMode> for GoogleModelMode { fn from(value: ModelMode) -> Self { match value { ModelMode::Default => GoogleModelMode::Default, ModelMode::Thinking { budget_tokens } => GoogleModelMode::Thinking { budget_tokens }, } } } impl From<GoogleModelMode> for ModelMode { fn from(value: GoogleModelMode) -> Self { match value { GoogleModelMode::Default => ModelMode::Default, GoogleModelMode::Thinking { budget_tokens } => ModelMode::Thinking { budget_tokens }, } } } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)] pub struct AvailableModel { name: String, display_name: Option<String>, max_tokens: u64, mode: Option<ModelMode>, } pub struct GoogleLanguageModelProvider { http_client: Arc<dyn HttpClient>, state: gpui::Entity<State>, } pub struct State { api_key: Option<String>, api_key_from_env: bool, _subscription: Subscription, } const GOOGLE_AI_API_KEY_VAR: &str = "GOOGLE_AI_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) .google .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) .google .api_url .clone(); cx.spawn(async move |this, cx| { credentials_provider .write_credentials(&api_url, "Bearer", api_key.as_bytes(), &cx) .await?; 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) .google .api_url .clone(); cx.spawn(async move |this, cx| { let (api_key, from_env) = if let Ok(api_key) = std::env::var(GOOGLE_AI_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 GoogleLanguageModelProvider { 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>(|_, cx| { cx.notify(); }), }); Self { http_client, state } } fn create_language_model(&self, model: google_ai::Model) -> Arc<dyn LanguageModel> { Arc::new(GoogleLanguageModel { 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 GoogleLanguageModelProvider { type ObservableEntity = State; fn observable_entity(&self) -> Option<gpui::Entity<Self::ObservableEntity>> { Some(self.state.clone()) } } impl LanguageModelProvider for GoogleLanguageModelProvider { fn id(&self) -> LanguageModelProviderId { LanguageModelProviderId(PROVIDER_ID.into()) } fn name(&self) -> LanguageModelProviderName { LanguageModelProviderName(PROVIDER_NAME.into()) } fn icon(&self) -> IconName { IconName::AiGoogle } fn default_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> { Some(self.create_language_model(google_ai::Model::default())) } fn default_fast_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> { Some(self.create_language_model(google_ai::Model::default_fast())) } fn provided_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>> { let mut models = BTreeMap::default(); // Add base models from google_ai::Model::iter() for model in google_ai::Model::iter() { if !matches!(model, google_ai::Model::Custom { .. }) { models.insert(model.id().to_string(), model); } } // Override with available models from settings for model in &AllLanguageModelSettings::get_global(cx) .google .available_models { models.insert( model.name.clone(), google_ai::Model::Custom { name: model.name.clone(), display_name: model.display_name.clone(), max_tokens: model.max_tokens, mode: model.mode.unwrap_or_default().into(), }, ); } models .into_values() .map(|model| { Arc::new(GoogleLanguageModel { id: LanguageModelId::from(model.id().to_string()), model, state: self.state.clone(), http_client: self.http_client.clone(), request_limiter: RateLimiter::new(4), }) as Arc<dyn LanguageModel> }) .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 GoogleLanguageModel { id: LanguageModelId, model: google_ai::Model, state: gpui::Entity<State>, http_client: Arc<dyn HttpClient>, request_limiter: RateLimiter, } impl GoogleLanguageModel { fn stream_completion( &self, request: google_ai::GenerateContentRequest, cx: &AsyncApp, ) -> BoxFuture< 'static, Result<futures::stream::BoxStream<'static, Result<GenerateContentResponse>>>, > { 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).google; (state.api_key.clone(), settings.api_url.clone()) }) else { return futures::future::ready(Err(anyhow!("App state dropped"))).boxed(); }; async move { let api_key = api_key.context("Missing Google API key")?; let request = google_ai::stream_generate_content( http_client.as_ref(), &api_url, &api_key, request, ); request.await.context("failed to stream completion") } .boxed() } } impl LanguageModel for GoogleLanguageModel { 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 { self.model.supports_tools() } fn supports_images(&self) -> bool { self.model.supports_images() } fn supports_tool_choice(&self, choice: LanguageModelToolChoice) -> bool { match choice { LanguageModelToolChoice::Auto | LanguageModelToolChoice::Any | LanguageModelToolChoice::None => true, } } fn tool_input_format(&self) -> LanguageModelToolSchemaFormat { LanguageModelToolSchemaFormat::JsonSchemaSubset } fn telemetry_id(&self) -> String { format!("google/{}", self.model.request_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>> { let model_id = self.model.request_id().to_string(); let request = into_google(request, model_id.clone(), self.model.mode()); let http_client = self.http_client.clone(); let api_key = self.state.read(cx).api_key.clone(); let settings = &AllLanguageModelSettings::get_global(cx).google; let api_url = settings.api_url.clone(); async move { let api_key = api_key.context("Missing Google API key")?; let response = google_ai::count_tokens( http_client.as_ref(), &api_url, &api_key, google_ai::CountTokensRequest { generate_content_request: request, }, ) .await?; Ok(response.total_tokens) } .boxed() } fn stream_completion( &self, request: LanguageModelRequest, cx: &AsyncApp, ) -> BoxFuture< 'static, Result< futures::stream::BoxStream< 'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>, >, LanguageModelCompletionError, >, > { let request = into_google( request, self.model.request_id().to_string(), self.model.mode(), ); let request = self.stream_completion(request, cx); let future = self.request_limiter.stream(async move { let response = request .await .map_err(|err| LanguageModelCompletionError::Other(anyhow!(err)))?; Ok(GoogleEventMapper::new().map_stream(response)) }); async move { Ok(future.await?.boxed()) }.boxed() } } pub fn into_google( mut request: LanguageModelRequest, model_id: String, mode: GoogleModelMode, ) -> google_ai::GenerateContentRequest { fn map_content(content: Vec<MessageContent>) -> Vec<Part> { content .into_iter() .flat_map(|content| match content { language_model::MessageContent::Text(text) => { if !text.is_empty() { vec![Part::TextPart(google_ai::TextPart { text })] } else { vec![] } } language_model::MessageContent::Thinking { text: _, signature: Some(signature), } => { if !signature.is_empty() { vec![Part::ThoughtPart(google_ai::ThoughtPart { thought: true, thought_signature: signature, })] } else { vec![] } } language_model::MessageContent::Thinking { .. } => { vec![] } language_model::MessageContent::RedactedThinking(_) => vec![], language_model::MessageContent::Image(image) => { vec![Part::InlineDataPart(google_ai::InlineDataPart { inline_data: google_ai::GenerativeContentBlob { mime_type: "image/png".to_string(), data: image.source.to_string(), }, })] } language_model::MessageContent::ToolUse(tool_use) => { vec![Part::FunctionCallPart(google_ai::FunctionCallPart { function_call: google_ai::FunctionCall { name: tool_use.name.to_string(), args: tool_use.input, }, })] } language_model::MessageContent::ToolResult(tool_result) => { match tool_result.content { language_model::LanguageModelToolResultContent::Text(text) => { vec![Part::FunctionResponsePart( google_ai::FunctionResponsePart { function_response: google_ai::FunctionResponse { name: tool_result.tool_name.to_string(), // The API expects a valid JSON object response: serde_json::json!({ "output": text }), }, }, )] } language_model::LanguageModelToolResultContent::Image(image) => { vec![