AstrBot 3.5.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

astrbot/core/provider/sources/gemini_source.py

@@ -3,7 +3,6 @@ import base64
 import json
 import logging
 import random
-from typing import Dict, List, Optional
 from collections.abc import AsyncGenerator
 
 from google import genai
@@ -12,11 +11,10 @@ from google.genai.errors import APIError
 
 import astrbot.core.message.components as Comp
 from astrbot import logger
-from astrbot.api.provider import Personality, Provider
-from astrbot.core.db import BaseDatabase
+from astrbot.api.provider import Provider
 from astrbot.core.message.message_event_result import MessageChain
 from astrbot.core.provider.entities import LLMResponse
-from astrbot.core.provider.func_tool_manager import FuncCall
+from astrbot.core.provider.func_tool_manager import ToolSet
 from astrbot.core.utils.io import download_image_by_url
 
 from ..register import register_provider_adapter
@@ -33,7 +31,8 @@ logging.getLogger("google_genai.types").addFilter(SuppressNonTextPartsWarning())
 
 
 @register_provider_adapter(
-    "googlegenai_chat_completion", "Google Gemini Chat Completion 提供商适配器"
+    "googlegenai_chat_completion",
+    "Google Gemini Chat Completion 提供商适配器",
 )
 class ProviderGoogleGenAI(Provider):
     CATEGORY_MAPPING = {
@@ -52,24 +51,18 @@ class ProviderGoogleGenAI(Provider):
 
     def __init__(
         self,
-        provider_config: dict,
-        provider_settings: dict,
-        db_helper: BaseDatabase,
-        persistant_history=True,
-        default_persona: Personality = None,
+        provider_config,
+        provider_settings,
     ) -> None:
         super().__init__(
             provider_config,
             provider_settings,
-            persistant_history,
-            db_helper,
-            default_persona,
         )
-        self.api_keys: List = provider_config.get("key", [])
-        self.chosen_api_key: str = self.api_keys[0] if len(self.api_keys) > 0 else None
+        self.api_keys: list = super().get_keys()
+        self.chosen_api_key: str = self.api_keys[0] if len(self.api_keys) > 0 else ""
         self.timeout: int = int(provider_config.get("timeout", 180))
 
-        self.api_base: Optional[str] = provider_config.get("api_base", None)
+        self.api_base: str | None = provider_config.get("api_base", None)
         if self.api_base and self.api_base.endswith("/"):
             self.api_base = self.api_base[:-1]
 
@@ -92,41 +85,43 @@ class ProviderGoogleGenAI(Provider):
         user_safety_config = self.provider_config.get("gm_safety_settings", {})
         self.safety_settings = [
             types.SafetySetting(
-                category=harm_category, threshold=self.THRESHOLD_MAPPING[threshold_str]
+                category=harm_category,
+                threshold=self.THRESHOLD_MAPPING[threshold_str],
             )
             for config_key, harm_category in self.CATEGORY_MAPPING.items()
             if (threshold_str := user_safety_config.get(config_key))
             and threshold_str in self.THRESHOLD_MAPPING
         ]
 
-    async def _handle_api_error(self, e: APIError, keys: List[str]) -> bool:
+    async def _handle_api_error(self, e: APIError, keys: list[str]) -> bool:
         """处理API错误，返回是否需要重试"""
+        if e.message is None:
+            e.message = ""
+
         if e.code == 429 or "API key not valid" in e.message:
             keys.remove(self.chosen_api_key)
             if len(keys) > 0:
                 self.set_key(random.choice(keys))
                 logger.info(
-                    f"检测到 Key 异常({e.message})，正在尝试更换 API Key 重试... 当前 Key: {self.chosen_api_key[:12]}..."
+                    f"检测到 Key 异常({e.message})，正在尝试更换 API Key 重试... 当前 Key: {self.chosen_api_key[:12]}...",
                 )
                 await asyncio.sleep(1)
                 return True
-            else:
-                logger.error(
-                    f"检测到 Key 异常({e.message})，且已没有可用的 Key。 当前 Key: {self.chosen_api_key[:12]}..."
-                )
-                raise Exception("达到了 Gemini 速率限制, 请稍后再试...")
-        else:
             logger.error(
-                f"发生了错误(gemini_source)。Provider 配置如下: {self.provider_config}"
+                f"检测到 Key 异常({e.message})，且已没有可用的 Key。 当前 Key: {self.chosen_api_key[:12]}...",
             )
-            raise e
+            raise Exception("达到了 Gemini 速率限制, 请稍后再试...")
+        logger.error(
+            f"发生了错误(gemini_source)。Provider 配置如下: {self.provider_config}",
+        )
+        raise e
 
     async def _prepare_query_config(
         self,
         payloads: dict,
-        tools: Optional[FuncCall] = None,
-        system_instruction: Optional[str] = None,
-        modalities: Optional[List[str]] = None,
+        tools: ToolSet | None = None,
+        system_instruction: str | None = None,
+        modalities: list[str] | None = None,
         temperature: float = 0.7,
     ) -> types.GenerateContentConfig:
         """准备查询配置"""
@@ -141,24 +136,66 @@ class ProviderGoogleGenAI(Provider):
             logger.warning("流式输出不支持图片模态，已自动降级为文本模态")
             modalities = ["Text"]
 
-        tool_list = None
+        tool_list = []
+        model_name = self.get_model()
         native_coderunner = self.provider_config.get("gm_native_coderunner", False)
         native_search = self.provider_config.get("gm_native_search", False)
+        url_context = self.provider_config.get("gm_url_context", False)
+
+        if "gemini-2.5" in model_name:
+            if native_coderunner:
+                tool_list.append(types.Tool(code_execution=types.ToolCodeExecution()))
+                if native_search:
+                    logger.warning("代码执行工具与搜索工具互斥，已忽略搜索工具")
+                if url_context:
+                    logger.warning(
+                        "代码执行工具与URL上下文工具互斥，已忽略URL上下文工具",
+                    )
+            else:
+                if native_search:
+                    tool_list.append(types.Tool(google_search=types.GoogleSearch()))
 
-        if native_coderunner:
-            tool_list = [types.Tool(code_execution=types.ToolCodeExecution())]
-            if native_search:
-                logger.warning("已启用代码执行工具，搜索工具将被忽略")
-            if tools:
-                logger.warning("已启用代码执行工具，函数工具将被忽略")
-        elif native_search:
-            tool_list = [types.Tool(google_search=types.GoogleSearch())]
-            if tools:
-                logger.warning("已启用搜索工具，函数工具将被忽略")
+                if url_context:
+                    if hasattr(types, "UrlContext"):
+                        tool_list.append(types.Tool(url_context=types.UrlContext()))
+                    else:
+                        logger.warning(
+                            "当前 SDK 版本不支持 URL 上下文工具，已忽略该设置，请升级 google-genai 包",
+                        )
+
+        elif "gemini-2.0-lite" in model_name:
+            if native_coderunner or native_search or url_context:
+                logger.warning(
+                    "gemini-2.0-lite 不支持代码执行、搜索工具和URL上下文，将忽略这些设置",
+                )
+            tool_list = None
+
+        else:
+            if native_coderunner:
+                tool_list.append(types.Tool(code_execution=types.ToolCodeExecution()))
+                if native_search:
+                    logger.warning("代码执行工具与搜索工具互斥，已忽略搜索工具")
+            elif native_search:
+                tool_list.append(types.Tool(google_search=types.GoogleSearch()))
+
+            if url_context and not native_coderunner:
+                if hasattr(types, "UrlContext"):
+                    tool_list.append(types.Tool(url_context=types.UrlContext()))
+                else:
+                    logger.warning(
+                        "当前 SDK 版本不支持 URL 上下文工具，已忽略该设置，请升级 google-genai 包",
+                    )
+
+        if not tool_list:
+            tool_list = None
+
+        if tools and tool_list:
+            logger.warning("已启用原生工具，函数工具将被忽略")
         elif tools and (func_desc := tools.get_func_desc_google_genai_style()):
             tool_list = [
-                types.Tool(function_declarations=func_desc["function_declarations"])
+                types.Tool(function_declarations=func_desc["function_declarations"]),
             ]
+
         return types.GenerateContentConfig(
             system_instruction=system_instruction,
             temperature=temperature,
@@ -178,24 +215,28 @@ class ProviderGoogleGenAI(Provider):
             response_modalities=modalities,
             tools=tool_list,
             safety_settings=self.safety_settings if self.safety_settings else None,
-            thinking_config=types.ThinkingConfig(
-                thinking_budget=min(
-                    int(
-                        self.provider_config.get("gm_thinking_config", {}).get(
-                            "budget", 0
-                        )
+            thinking_config=(
+                types.ThinkingConfig(
+                    thinking_budget=min(
+                        int(
+                            self.provider_config.get("gm_thinking_config", {}).get(
+                                "budget",
+                                0,
+                            ),
+                        ),
+                        24576,
                     ),
-                    24576,
-                ),
-            )
-            if "gemini-2.5-flash" in self.get_model()
-            else None,
+                )
+                if "gemini-2.5-flash" in self.get_model()
+                and hasattr(types.ThinkingConfig, "thinking_budget")
+                else None
+            ),
             automatic_function_calling=types.AutomaticFunctionCallingConfig(
-                disable=True
+                disable=True,
             ),
         )
 
-    def _prepare_conversation(self, payloads: Dict) -> List[types.Content]:
+    def _prepare_conversation(self, payloads: dict) -> list[types.Content]:
         """准备 Gemini SDK 的 Content 列表"""
 
         def create_text_part(text: str) -> types.Part:
@@ -220,12 +261,12 @@ class ProviderGoogleGenAI(Provider):
             else:
                 contents.append(content_cls(parts=part))
 
-        gemini_contents: List[types.Content] = []
+        gemini_contents: list[types.Content] = []
         native_tool_enabled = any(
             [
                 self.provider_config.get("gm_native_coderunner", False),
                 self.provider_config.get("gm_native_search", False),
-            ]
+            ],
         )
         for message in payloads["messages"]:
             role, content = message["role"], message.get("content")
@@ -233,9 +274,11 @@ class ProviderGoogleGenAI(Provider):
             if role == "user":
                 if isinstance(content, list):
                     parts = [
-                        types.Part.from_text(text=item["text"] or " ")
-                        if item["type"] == "text"
-                        else process_image_url(item["image_url"])
+                        (
+                            types.Part.from_text(text=item["text"] or " ")
+                            if item["type"] == "text"
+                            else process_image_url(item["image_url"])
+                        )
                         for item in content
                     ]
                 else:
@@ -247,19 +290,30 @@ class ProviderGoogleGenAI(Provider):
                     parts = [types.Part.from_text(text=content)]
                     append_or_extend(gemini_contents, parts, types.ModelContent)
                 elif not native_tool_enabled and "tool_calls" in message:
-                    parts = [
-                        types.Part.from_function_call(
+                    parts = []
+                    for tool in message["tool_calls"]:
+                        part = types.Part.from_function_call(
                             name=tool["function"]["name"],
                             args=json.loads(tool["function"]["arguments"]),
                         )
-                        for tool in message["tool_calls"]
-                    ]
+                        # we should set thought_signature back to part if exists
+                        # for more info about thought_signature, see:
+                        # https://ai.google.dev/gemini-api/docs/thought-signatures
+                        if "extra_content" in tool and tool["extra_content"]:
+                            ts_bs64 = (
+                                tool["extra_content"]
+                                .get("google", {})
+                                .get("thought_signature")
+                            )
+                            if ts_bs64:
+                                part.thought_signature = base64.b64decode(ts_bs64)
+                        parts.append(part)
                     append_or_extend(gemini_contents, parts, types.ModelContent)
                 else:
                     logger.warning("assistant 角色的消息内容为空，已添加空格占位")
                     if native_tool_enabled and "tool_calls" in message:
                         logger.warning(
-                            "检测到启用Gemini原生工具，且上下文中存在函数调用，建议使用 /reset 重置上下文"
+                            "检测到启用Gemini原生工具，且上下文中存在函数调用，建议使用 /reset 重置上下文",
                         )
                     parts = [types.Part.from_text(text=" ")]
                     append_or_extend(gemini_contents, parts, types.ModelContent)
@@ -272,7 +326,7 @@ class ProviderGoogleGenAI(Provider):
                             "name": message["tool_call_id"],
                             "content": message["content"],
                         },
-                    )
+                    ),
                 ]
                 append_or_extend(gemini_contents, parts, types.UserContent)
 
@@ -281,58 +335,94 @@ class ProviderGoogleGenAI(Provider):
 
         return gemini_contents
 
-    @staticmethod
+    def _extract_reasoning_content(self, candidate: types.Candidate) -> str:
+        """Extract reasoning content from candidate parts"""
+        if not candidate.content or not candidate.content.parts:
+            return ""
+
+        thought_buf: list[str] = [
+            (p.text or "") for p in candidate.content.parts if p.thought
+        ]
+        return "".join(thought_buf).strip()
+
     def _process_content_parts(
-        result: types.GenerateContentResponse, llm_response: LLMResponse
+        self,
+        candidate: types.Candidate,
+        llm_response: LLMResponse,
     ) -> MessageChain:
         """处理内容部分并构建消息链"""
-        finish_reason = result.candidates[0].finish_reason
-        result_parts: Optional[types.Part] = result.candidates[0].content.parts
+        if not candidate.content:
+            logger.warning(f"收到的 candidate.content 为空: {candidate}")
+            raise Exception("API 返回的 candidate.content 为空。")
+
+        finish_reason = candidate.finish_reason
+        result_parts: list[types.Part] | None = candidate.content.parts
 
         if finish_reason == types.FinishReason.SAFETY:
-            raise Exception("模型生成内容未通过用户定义的内容安全检查")
+            raise Exception("模型生成内容未通过 Gemini 平台的安全检查")
 
         if finish_reason in {
             types.FinishReason.PROHIBITED_CONTENT,
             types.FinishReason.SPII,
             types.FinishReason.BLOCKLIST,
         }:
-            raise Exception("模型生成内容违反Gemini平台政策")
+            raise Exception("模型生成内容违反 Gemini 平台政策")
 
         # 防止旧版本SDK不存在IMAGE_SAFETY
         if hasattr(types.FinishReason, "IMAGE_SAFETY"):
             if finish_reason == types.FinishReason.IMAGE_SAFETY:
-                raise Exception("模型生成内容违反Gemini平台政策")
+                raise Exception("模型生成内容违反 Gemini 平台政策")
 
         if not result_parts:
-            logger.debug(result.candidates)
-            raise Exception("API 返回的内容为空。")
+            logger.warning(f"收到的 candidate.content.parts 为空: {candidate}")
+            raise Exception("API 返回的 candidate.content.parts 为空。")
+
+        # 提取 reasoning content
+        reasoning = self._extract_reasoning_content(candidate)
+        if reasoning:
+            llm_response.reasoning_content = reasoning
 
         chain = []
         part: types.Part
 
         # 暂时这样Fallback
         if all(
-            part.inline_data and part.inline_data.mime_type.startswith("image/")
+            part.inline_data
+            and part.inline_data.mime_type
+            and part.inline_data.mime_type.startswith("image/")
             for part in result_parts
         ):
             chain.append(Comp.Plain("这是图片"))
         for part in result_parts:
             if part.text:
                 chain.append(Comp.Plain(part.text))
-            elif part.function_call:
+            elif (
+                part.function_call
+                and part.function_call.name is not None
+                and part.function_call.args is not None
+            ):
                 llm_response.role = "tool"
                 llm_response.tools_call_name.append(part.function_call.name)
                 llm_response.tools_call_args.append(part.function_call.args)
-                # gemini 返回的 function_call.id 可能为 None
-                llm_response.tools_call_ids.append(
-                    part.function_call.id or part.function_call.name
-                )
-            elif part.inline_data and part.inline_data.mime_type.startswith("image/"):
+                # function_call.id might be None, use name as fallback
+                tool_call_id = part.function_call.id or part.function_call.name
+                llm_response.tools_call_ids.append(tool_call_id)
+                # extra_content
+                if part.thought_signature:
+                    ts_bs64 = base64.b64encode(part.thought_signature).decode("utf-8")
+                    llm_response.tools_call_extra_content[tool_call_id] = {
+                        "google": {"thought_signature": ts_bs64}
+                    }
+            elif (
+                part.inline_data
+                and part.inline_data.mime_type
+                and part.inline_data.mime_type.startswith("image/")
+                and part.inline_data.data
+            ):
                 chain.append(Comp.Image.fromBytes(part.inline_data.data))
         return MessageChain(chain=chain)
 
-    async def _query(self, payloads: dict, tools: FuncCall) -> LLMResponse:
+    async def _query(self, payloads: dict, tools: ToolSet | None) -> LLMResponse:
         """非流式请求 Gemini API"""
         system_instruction = next(
             (msg["content"] for msg in payloads["messages"] if msg["role"] == "system"),
@@ -346,33 +436,44 @@ class ProviderGoogleGenAI(Provider):
         conversation = self._prepare_conversation(payloads)
         temperature = payloads.get("temperature", 0.7)
 
-        result: Optional[types.GenerateContentResponse] = None
+        result: types.GenerateContentResponse | None = None
         while True:
             try:
                 config = await self._prepare_query_config(
-                    payloads, tools, system_instruction, modalities, temperature
+                    payloads,
+                    tools,
+                    system_instruction,
+                    modalities,
+                    temperature,
                 )
                 result = await self.client.models.generate_content(
                     model=self.get_model(),
                     contents=conversation,
                     config=config,
                 )
+                logger.debug(f"genai result: {result}")
+
+                if not result.candidates:
+                    logger.error(f"请求失败, 返回的 candidates 为空: {result}")
+                    raise Exception("请求失败, 返回的 candidates 为空。")
 
                 if result.candidates[0].finish_reason == types.FinishReason.RECITATION:
                     if temperature > 2:
                         raise Exception("温度参数已超过最大值2，仍然发生recitation")
                     temperature += 0.2
                     logger.warning(
-                        f"发生了recitation，正在提高温度至{temperature:.1f}重试..."
+                        f"发生了recitation，正在提高温度至{temperature:.1f}重试...",
                     )
                     continue
 
                 break
 
             except APIError as e:
+                if e.message is None:
+                    e.message = ""
                 if "Developer instruction is not enabled" in e.message:
                     logger.warning(
-                        f"{self.get_model()} 不支持 system prompt，已自动去除(影响人格设置)"
+                        f"{self.get_model()} 不支持 system prompt，已自动去除(影响人格设置)",
                     )
                     system_instruction = None
                 elif "Function calling is not enabled" in e.message:
@@ -385,7 +486,7 @@ class ProviderGoogleGenAI(Provider):
                     or "only supports text output" in e.message
                 ):
                     logger.warning(
-                        f"{self.get_model()} 不支持多模态输出，降级为文本模态"
+                        f"{self.get_model()} 不支持多模态输出，降级为文本模态",
                     )
                     modalities = ["Text"]
                 else:
@@ -393,11 +494,17 @@ class ProviderGoogleGenAI(Provider):
                 continue
 
         llm_response = LLMResponse("assistant")
-        llm_response.result_chain = self._process_content_parts(result, llm_response)
+        llm_response.raw_completion = result
+        llm_response.result_chain = self._process_content_parts(
+            result.candidates[0],
+            llm_response,
+        )
         return llm_response
 
     async def _query_stream(
-        self, payloads: dict, tools: FuncCall
+        self,
+        payloads: dict,
+        tools: ToolSet | None,
     ) -> AsyncGenerator[LLMResponse, None]:
         """流式请求 Gemini API"""
         system_instruction = next(
@@ -411,7 +518,9 @@ class ProviderGoogleGenAI(Provider):
         while True:
             try:
                 config = await self._prepare_query_config(
-                    payloads, tools, system_instruction
+                    payloads,
+                    tools,
+                    system_instruction,
                 )
                 result = await self.client.models.generate_content_stream(
                     model=self.get_model(),
@@ -420,9 +529,11 @@ class ProviderGoogleGenAI(Provider):
                 )
                 break
             except APIError as e:
+                if e.message is None:
+                    e.message = ""
                 if "Developer instruction is not enabled" in e.message:
                     logger.warning(
-                        f"{self.get_model()} 不支持 system prompt，已自动去除(影响人格设置)"
+                        f"{self.get_model()} 不支持 system prompt，已自动去除(影响人格设置)",
                     )
                     system_instruction = None
                 elif "Function calling is not enabled" in e.message:
@@ -432,47 +543,98 @@ class ProviderGoogleGenAI(Provider):
                     raise
                 continue
 
+        # Accumulate the complete response text for the final response
+        accumulated_text = ""
+        accumulated_reasoning = ""
+        final_response = None
+
         async for chunk in result:
             llm_response = LLMResponse("assistant", is_chunk=True)
 
+            if not chunk.candidates:
+                logger.warning(f"收到的 chunk 中 candidates 为空: {chunk}")
+                continue
+            if not chunk.candidates[0].content:
+                logger.warning(f"收到的 chunk 中 content 为空: {chunk}")
+                continue
+
             if chunk.candidates[0].content.parts and any(
                 part.function_call for part in chunk.candidates[0].content.parts
             ):
                 llm_response = LLMResponse("assistant", is_chunk=False)
+                llm_response.raw_completion = chunk
                 llm_response.result_chain = self._process_content_parts(
-                    chunk, llm_response
+                    chunk.candidates[0],
+                    llm_response,
                 )
                 yield llm_response
-                break
+                return
 
+            _f = False
+
+            # 提取 reasoning content
+            reasoning = self._extract_reasoning_content(chunk.candidates[0])
+            if reasoning:
+                _f = True
+                accumulated_reasoning += reasoning
+                llm_response.reasoning_content = reasoning
             if chunk.text:
+                _f = True
+                accumulated_text += chunk.text
                 llm_response.result_chain = MessageChain(chain=[Comp.Plain(chunk.text)])
+            if _f:
                 yield llm_response
 
             if chunk.candidates[0].finish_reason:
-                llm_response = LLMResponse("assistant", is_chunk=False)
-                if not chunk.candidates[0].content.parts:
-                    llm_response.result_chain = MessageChain(chain=[Comp.Plain(" ")])
-                else:
-                    llm_response.result_chain = self._process_content_parts(
-                        chunk, llm_response
+                # Process the final chunk for potential tool calls or other content
+                if chunk.candidates[0].content.parts:
+                    final_response = LLMResponse("assistant", is_chunk=False)
+                    final_response.raw_completion = chunk
+                    final_response.result_chain = self._process_content_parts(
+                        chunk.candidates[0],
+                        final_response,
                     )
-                yield llm_response
                 break
 
+        # Yield final complete response with accumulated text
+        if not final_response:
+            final_response = LLMResponse("assistant", is_chunk=False)
+
+        # Set the complete accumulated reasoning in the final response
+        if accumulated_reasoning:
+            final_response.reasoning_content = accumulated_reasoning
+
+        # Set the complete accumulated text in the final response
+        if accumulated_text:
+            final_response.result_chain = MessageChain(
+                chain=[Comp.Plain(accumulated_text)],
+            )
+        elif not final_response.result_chain:
+            # If no text was accumulated and no final response was set, provide empty space
+            final_response.result_chain = MessageChain(chain=[Comp.Plain(" ")])
+
+        yield final_response
+
     async def text_chat(
         self,
-        prompt: str,
-        session_id: str = None,
-        image_urls: List[str] = None,
-        func_tool: FuncCall = None,
-        contexts=[],
+        prompt=None,
+        session_id=None,
+        image_urls=None,
+        func_tool=None,
+        contexts=None,
         system_prompt=None,
         tool_calls_result=None,
+        model=None,
         **kwargs,
     ) -> LLMResponse:
-        new_record = await self.assemble_context(prompt, image_urls)
-        context_query = [*contexts, new_record]
+        if contexts is None:
+            contexts = []
+        new_record = None
+        if prompt is not None:
+            new_record = await self.assemble_context(prompt, image_urls)
+        context_query = self._ensure_message_to_dicts(contexts)
+        if new_record:
+            context_query.append(new_record)
         if system_prompt:
             context_query.insert(0, {"role": "system", "content": system_prompt})
 
@@ -482,10 +644,14 @@ class ProviderGoogleGenAI(Provider):
 
         # tool calls result
         if tool_calls_result:
-            context_query.extend(tool_calls_result.to_openai_messages())
+            if not isinstance(tool_calls_result, list):
+                context_query.extend(tool_calls_result.to_openai_messages())
+            else:
+                for tcr in tool_calls_result:
+                    context_query.extend(tcr.to_openai_messages())
 
         model_config = self.provider_config.get("model_config", {})
-        model_config["model"] = self.get_model()
+        model_config["model"] = model or self.get_model()
 
         payloads = {"messages": context_query, **model_config}
 
@@ -500,19 +666,28 @@ class ProviderGoogleGenAI(Provider):
                     continue
                 break
 
+        raise Exception("请求失败。")
+
     async def text_chat_stream(
         self,
-        prompt: str,
-        session_id: str = None,
-        image_urls: List[str] = [],
-        func_tool: FuncCall = None,
-        contexts=[],
+        prompt=None,
+        session_id=None,
+        image_urls=None,
+        func_tool=None,
+        contexts=None,
         system_prompt=None,
         tool_calls_result=None,
+        model=None,
         **kwargs,
     ) -> AsyncGenerator[LLMResponse, None]:
-        new_record = await self.assemble_context(prompt, image_urls)
-        context_query = [*contexts, new_record]
+        if contexts is None:
+            contexts = []
+        new_record = None
+        if prompt is not None:
+            new_record = await self.assemble_context(prompt, image_urls)
+        context_query = self._ensure_message_to_dicts(contexts)
+        if new_record:
+            context_query.append(new_record)
         if system_prompt:
             context_query.insert(0, {"role": "system", "content": system_prompt})
 
@@ -522,10 +697,14 @@ class ProviderGoogleGenAI(Provider):
 
         # tool calls result
         if tool_calls_result:
-            context_query.extend(tool_calls_result.to_openai_messages())
+            if not isinstance(tool_calls_result, list):
+                context_query.extend(tool_calls_result.to_openai_messages())
+            else:
+                for tcr in tool_calls_result:
+                    context_query.extend(tcr.to_openai_messages())
 
         model_config = self.provider_config.get("model_config", {})
-        model_config["model"] = self.get_model()
+        model_config["model"] = model or self.get_model()
 
         payloads = {"messages": context_query, **model_config}
 
@@ -548,7 +727,9 @@ class ProviderGoogleGenAI(Provider):
             return [
                 m.name.replace("models/", "")
                 for m in models
-                if "generateContent" in m.supported_actions
+                if m.supported_actions
+                and "generateContent" in m.supported_actions
+                and m.name
             ]
         except APIError as e:
             raise Exception(f"获取模型列表失败: {e.message}")
@@ -556,17 +737,15 @@ class ProviderGoogleGenAI(Provider):
     def get_current_key(self) -> str:
         return self.chosen_api_key
 
-    def get_keys(self) -> List[str]:
+    def get_keys(self) -> list[str]:
         return self.api_keys
 
     def set_key(self, key):
         self.chosen_api_key = key
         self._init_client()
 
-    async def assemble_context(self, text: str, image_urls: List[str] = None):
-        """
-        组装上下文。
-        """
+    async def assemble_context(self, text: str, image_urls: list[str] | None = None):
+        """组装上下文。"""
         if image_urls:
             user_content = {
                 "role": "user",
@@ -585,22 +764,21 @@ class ProviderGoogleGenAI(Provider):
                     logger.warning(f"图片 {image_url} 得到的结果为空，将忽略。")
                     continue
                 user_content["content"].append(
-                    {"type": "image_url", "image_url": {"url": image_data}}
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": image_data},
+                    },
                 )
             return user_content
-        else:
-            return {"role": "user", "content": text}
+        return {"role": "user", "content": text}
 
     async def encode_image_bs64(self, image_url: str) -> str:
-        """
-        将图片转换为 base64
-        """
+        """将图片转换为 base64"""
         if image_url.startswith("base64://"):
             return image_url.replace("base64://", "data:image/jpeg;base64,")
         with open(image_url, "rb") as f:
             image_bs64 = base64.b64encode(f.read()).decode("utf-8")
             return "data:image/jpeg;base64," + image_bs64
-        return ""
 
     async def terminate(self):
         logger.info("Google GenAI 适配器已终止。")