use anyhow::{Context as _, Result};use collections::BTreeMap;use futures::{FutureExt, Stream, StreamExt, future::BoxFuture};use google_ai::{ FunctionDeclaration, GenerateContentResponse, GoogleModelMode, Part, SystemInstruction, ThinkingConfig, UsageMetadata,};use gpui::{AnyView, App, AsyncApp, Context, Entity, SharedString, Task, Window};use http_client::HttpClient;use language_model::{ AuthenticateError, ConfigurationViewTargetAgent, EnvVar, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelToolChoice, LanguageModelToolSchemaFormat, LanguageModelToolUse, LanguageModelToolUseId, MessageContent, StopReason,};use language_model::{ IconOrSvg, LanguageModel, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, RateLimiter, Role,};use schemars::JsonSchema;use serde::{Deserialize, Serialize};pub use settings::GoogleAvailableModel as AvailableModel;use settings::{Settings, SettingsStore};use std::pin::Pin;use std::sync::{ Arc, LazyLock, atomic::{self, AtomicU64},};use strum::IntoEnumIterator;use ui::{ButtonLink, ConfiguredApiCard, List, ListBulletItem, prelude::*};use ui_input::InputField;use util::ResultExt; use language_model::ApiKeyState; const PROVIDER_ID: LanguageModelProviderId = language_model::GOOGLE_PROVIDER_ID;const PROVIDER_NAME: LanguageModelProviderName = language_model::GOOGLE_PROVIDER_NAME; #[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>, },} pub struct GoogleLanguageModelProvider { http_client: Arc<dyn HttpClient>, state: Entity<State>,} pub struct State { api_key_state: ApiKeyState,} const GEMINI_API_KEY_VAR_NAME: &str = "GEMINI_API_KEY";const GOOGLE_AI_API_KEY_VAR_NAME: &str = "GOOGLE_AI_API_KEY"; static API_KEY_ENV_VAR: LazyLock<EnvVar> = LazyLock::new(|| { // Try GEMINI_API_KEY first as primary, fallback to GOOGLE_AI_API_KEY EnvVar::new(GEMINI_API_KEY_VAR_NAME.into()).or(EnvVar::new(GOOGLE_AI_API_KEY_VAR_NAME.into()))}); 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 = GoogleLanguageModelProvider::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 = GoogleLanguageModelProvider::api_url(cx); self.api_key_state .load_if_needed(api_url, |this| &mut this.api_key_state, cx) }} impl GoogleLanguageModelProvider { 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: 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), }) } fn settings(cx: &App) -> &GoogleSettings { &crate::AllLanguageModelSettings::get_global(cx).google } fn api_url(cx: &App) -> SharedString { let api_url = &Self::settings(cx).api_url; if api_url.is_empty() { google_ai::API_URL.into() } else { SharedString::new(api_url.as_str()) } }} impl LanguageModelProviderState for GoogleLanguageModelProvider { type ObservableEntity = State; fn observable_entity(&self) -> Option<Entity<Self::ObservableEntity>> { Some(self.state.clone()) }} impl LanguageModelProvider for GoogleLanguageModelProvider { fn id(&self) -> LanguageModelProviderId { PROVIDER_ID } fn name(&self) -> LanguageModelProviderName { PROVIDER_NAME } fn icon(&self) -> IconOrSvg { IconOrSvg::Icon(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 &GoogleLanguageModelProvider::settings(cx).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(), }, ); } 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, target_agent: language_model::ConfigurationViewTargetAgent, window: &mut Window, cx: &mut App, ) -> AnyView { cx.new(|cx| ConfigurationView::new(self.state.clone(), target_agent, 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 GoogleLanguageModel { id: LanguageModelId, model: google_ai::Model, state: 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 (api_key, api_url) = self.state.read_with(cx, |state, cx| { let api_url = GoogleLanguageModelProvider::api_url(cx); (state.api_key_state.key(&api_url), api_url) }); 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 { PROVIDER_ID } fn provider_name(&self) -> LanguageModelProviderName { PROVIDER_NAME } fn supports_tools(&self) -> bool { self.model.supports_tools() } fn supports_images(&self) -> bool { self.model.supports_images() } fn supports_thinking(&self) -> bool { matches!(self.model.mode(), GoogleModelMode::Thinking { .. }) } 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, self.model.mode()); let http_client = self.http_client.clone(); let api_url = GoogleLanguageModelProvider::api_url(cx); let api_key = self.state.read(cx).api_key_state.key(&api_url); async move { let Some(api_key) = api_key else { return Err(LanguageModelCompletionError::NoApiKey { provider: PROVIDER_NAME, } .into()); }; 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(LanguageModelCompletionError::from)?; 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) => { // Normalize empty string signatures to None let thought_signature = tool_use.thought_signature.filter(|s| !s.is_empty()); vec![Part::FunctionCallPart(google_ai::FunctionCallPart { function_call: google_ai::FunctionCall { name: tool_use.name.to_string(), args: tool_use.input, }, thought_signature, })] } 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![ 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": "Tool responded with an image" }), }, }), Part::InlineDataPart(google_ai::InlineDataPart { inline_data: google_ai::GenerativeContentBlob { mime_type: "image/png".to_string(), data: image.source.to_string(), }, }), ] } } } }) .collect() } let system_instructions = if request .messages .first() .is_some_and(|msg| matches!(msg.role, Role::System)) { let message = request.messages.remove(0); Some(SystemInstruction { parts: map_content(message.content), }) } else { None }; google_ai::GenerateContentRequest { model: google_ai::ModelName { model_id }, system_instruction: system_instructions, contents: request .messages .into_iter() .filter_map(|message| { let parts = map_content(message.content); if parts.is_empty() { None } else { Some(google_ai::Content { parts, role: match message.role { Role::User => google_ai::Role::User, Role::Assistant => google_ai::Role::Model, Role::System => google_ai::Role::User, // Google AI doesn't have a system role }, }) } })Lines 1–500 of 1299. Load more
use anyhow::{Context as _, Result}; use collections::BTreeMap; use futures::{FutureExt, Stream, StreamExt, future::BoxFuture}; use google_ai::{ FunctionDeclaration, GenerateContentResponse, GoogleModelMode, Part, SystemInstruction, ThinkingConfig, UsageMetadata, }; use gpui::{AnyView, App, AsyncApp, Context, Entity, SharedString, Task, Window}; use http_client::HttpClient; use language_model::{ AuthenticateError, ConfigurationViewTargetAgent, EnvVar, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelToolChoice, LanguageModelToolSchemaFormat, LanguageModelToolUse, LanguageModelToolUseId, MessageContent, StopReason, }; use language_model::{ IconOrSvg, LanguageModel, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, RateLimiter, Role, }; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; pub use settings::GoogleAvailableModel as AvailableModel; use settings::{Settings, SettingsStore}; use std::pin::Pin; use std::sync::{ Arc, LazyLock, atomic::{self, AtomicU64}, }; use strum::IntoEnumIterator; use ui::{ButtonLink, ConfiguredApiCard, List, ListBulletItem, prelude::*}; use ui_input::InputField; use util::ResultExt; use language_model::ApiKeyState; const PROVIDER_ID: LanguageModelProviderId = language_model::GOOGLE_PROVIDER_ID; const PROVIDER_NAME: LanguageModelProviderName = language_model::GOOGLE_PROVIDER_NAME; #[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>, }, } pub struct GoogleLanguageModelProvider { http_client: Arc<dyn HttpClient>, state: Entity<State>, } pub struct State { api_key_state: ApiKeyState, } const GEMINI_API_KEY_VAR_NAME: &str = "GEMINI_API_KEY"; const GOOGLE_AI_API_KEY_VAR_NAME: &str = "GOOGLE_AI_API_KEY"; static API_KEY_ENV_VAR: LazyLock<EnvVar> = LazyLock::new(|| { // Try GEMINI_API_KEY first as primary, fallback to GOOGLE_AI_API_KEY EnvVar::new(GEMINI_API_KEY_VAR_NAME.into()).or(EnvVar::new(GOOGLE_AI_API_KEY_VAR_NAME.into())) }); 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 = GoogleLanguageModelProvider::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 = GoogleLanguageModelProvider::api_url(cx); self.api_key_state .load_if_needed(api_url, |this| &mut this.api_key_state, cx) } } impl GoogleLanguageModelProvider { 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: 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), }) } fn settings(cx: &App) -> &GoogleSettings { &crate::AllLanguageModelSettings::get_global(cx).google } fn api_url(cx: &App) -> SharedString { let api_url = &Self::settings(cx).api_url; if api_url.is_empty() { google_ai::API_URL.into() } else { SharedString::new(api_url.as_str()) } } } impl LanguageModelProviderState for GoogleLanguageModelProvider { type ObservableEntity = State; fn observable_entity(&self) -> Option<Entity<Self::ObservableEntity>> { Some(self.state.clone()) } } impl LanguageModelProvider for GoogleLanguageModelProvider { fn id(&self) -> LanguageModelProviderId { PROVIDER_ID } fn name(&self) -> LanguageModelProviderName { PROVIDER_NAME } fn icon(&self) -> IconOrSvg { IconOrSvg::Icon(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 &GoogleLanguageModelProvider::settings(cx).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(), }, ); } 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, target_agent: language_model::ConfigurationViewTargetAgent, window: &mut Window, cx: &mut App, ) -> AnyView { cx.new(|cx| ConfigurationView::new(self.state.clone(), target_agent, 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 GoogleLanguageModel { id: LanguageModelId, model: google_ai::Model, state: 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 (api_key, api_url) = self.state.read_with(cx, |state, cx| { let api_url = GoogleLanguageModelProvider::api_url(cx); (state.api_key_state.key(&api_url), api_url) }); 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 { PROVIDER_ID } fn provider_name(&self) -> LanguageModelProviderName { PROVIDER_NAME } fn supports_tools(&self) -> bool { self.model.supports_tools() } fn supports_images(&self) -> bool { self.model.supports_images() } fn supports_thinking(&self) -> bool { matches!(self.model.mode(), GoogleModelMode::Thinking { .. }) } 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, self.model.mode()); let http_client = self.http_client.clone(); let api_url = GoogleLanguageModelProvider::api_url(cx); let api_key = self.state.read(cx).api_key_state.key(&api_url); async move { let Some(api_key) = api_key else { return Err(LanguageModelCompletionError::NoApiKey { provider: PROVIDER_NAME, } .into()); }; 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(LanguageModelCompletionError::from)?; 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) => { // Normalize empty string signatures to None let thought_signature = tool_use.thought_signature.filter(|s| !s.is_empty()); vec![Part::FunctionCallPart(google_ai::FunctionCallPart { function_call: google_ai::FunctionCall { name: tool_use.name.to_string(), args: tool_use.input, }, thought_signature, })] } 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![ 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": "Tool responded with an image" }), }, }), Part::InlineDataPart(google_ai::InlineDataPart { inline_data: google_ai::GenerativeContentBlob { mime_type: "image/png".to_string(), data: image.source.to_string(), }, }), ] } } } }) .collect() } let system_instructions = if request .messages .first() .is_some_and(|msg| matches!(msg.role, Role::System)) { let message = request.messages.remove(0); Some(SystemInstruction { parts: map_content(message.content), }) } else { None }; google_ai::GenerateContentRequest { model: google_ai::ModelName { model_id }, system_instruction: system_instructions, contents: request .messages .into_iter() .filter_map(|message| { let parts = map_content(message.content); if parts.is_empty() { None } else { Some(google_ai::Content { parts, role: match message.role { Role::User => google_ai::Role::User, Role::Assistant => google_ai::Role::Model, Role::System => google_ai::Role::User, // Google AI doesn't have a system role }, }) } })