AstrBot 4.5.0__py3-none-any.whl → 4.5.2__py3-none-any.whl

astrbot/core/provider/sources/minimax_tts_api_source.py

@@ -1,17 +1,22 @@
 import json
 import os
 import uuid
+from collections.abc import AsyncIterator
+
 import aiohttp
-from typing import Dict, List, Union, AsyncIterator
-from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+
 from astrbot.api import logger
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+
 from ..entities import ProviderType
 from ..provider import TTSProvider
 from ..register import register_provider_adapter
 
 
 @register_provider_adapter(
-    "minimax_tts_api", "MiniMax TTS API", provider_type=ProviderType.TEXT_TO_SPEECH
+    "minimax_tts_api",
+    "MiniMax TTS API",
+    provider_type=ProviderType.TEXT_TO_SPEECH,
 )
 class ProviderMiniMaxTTSAPI(TTSProvider):
     def __init__(
@@ -22,19 +27,21 @@ class ProviderMiniMaxTTSAPI(TTSProvider):
         super().__init__(provider_config, provider_settings)
         self.chosen_api_key: str = provider_config.get("api_key", "")
         self.api_base: str = provider_config.get(
-            "api_base", "https://api.minimax.chat/v1/t2a_v2"
+            "api_base",
+            "https://api.minimax.chat/v1/t2a_v2",
         )
         self.group_id: str = provider_config.get("minimax-group-id", "")
         self.set_model(provider_config.get("model", ""))
         self.lang_boost: str = provider_config.get("minimax-langboost", "auto")
         self.is_timber_weight: bool = provider_config.get(
-            "minimax-is-timber-weight", False
+            "minimax-is-timber-weight",
+            False,
         )
-        self.timber_weight: List[Dict[str, Union[str, int]]] = json.loads(
+        self.timber_weight: list[dict[str, str | int]] = json.loads(
             provider_config.get(
                 "minimax-timber-weight",
                 '[{"voice_id": "Chinese (Mandarin)_Warm_Girl", "weight": 1}]',
-            )
+            ),
         )
 
         self.voice_setting: dict = {
@@ -47,7 +54,8 @@ class ProviderMiniMaxTTSAPI(TTSProvider):
             "emotion": provider_config.get("minimax-voice-emotion", "neutral"),
             "latex_read": provider_config.get("minimax-voice-latex", False),
             "english_normalization": provider_config.get(
-                "minimax-voice-english-normalization", False
+                "minimax-voice-english-normalization",
+                False,
             ),
         }
 
@@ -66,7 +74,7 @@ class ProviderMiniMaxTTSAPI(TTSProvider):
 
     def _build_tts_stream_body(self, text: str):
         """构建流式请求体"""
-        dict_body: Dict[str, object] = {
+        dict_body: dict[str, object] = {
             "model": self.model_name,
             "text": text,
             "stream": True,
@@ -82,44 +90,46 @@ class ProviderMiniMaxTTSAPI(TTSProvider):
     async def _call_tts_stream(self, text: str) -> AsyncIterator[bytes]:
         """进行流式请求"""
         try:
-            async with aiohttp.ClientSession() as session:
-                async with session.post(
+            async with (
+                aiohttp.ClientSession() as session,
+                session.post(
                     self.concat_base_url,
                     headers=self.headers,
                     data=self._build_tts_stream_body(text),
                     timeout=aiohttp.ClientTimeout(total=60),
-                ) as response:
-                    response.raise_for_status()
-
-                    buffer = b""
-                    while True:
-                        chunk = await response.content.read(8192)
-                        if not chunk:
-                            break
-
-                        buffer += chunk
-
-                        while b"\n\n" in buffer:
-                            try:
-                                message, buffer = buffer.split(b"\n\n", 1)
-                                if message.startswith(b"data: "):
-                                    try:
-                                        data = json.loads(message[6:])
-                                        if "extra_info" in data:
-                                            continue
-                                        audio = data.get("data", {}).get("audio")
-                                        if audio is not None:
-                                            yield audio
-                                    except json.JSONDecodeError:
-                                        logger.warning(
-                                            "Failed to parse JSON data from SSE message"
-                                        )
+                ) as response,
+            ):
+                response.raise_for_status()
+
+                buffer = b""
+                while True:
+                    chunk = await response.content.read(8192)
+                    if not chunk:
+                        break
+
+                    buffer += chunk
+
+                    while b"\n\n" in buffer:
+                        try:
+                            message, buffer = buffer.split(b"\n\n", 1)
+                            if message.startswith(b"data: "):
+                                try:
+                                    data = json.loads(message[6:])
+                                    if "extra_info" in data:
                                         continue
-                            except ValueError:
-                                buffer = buffer[-1024:]
+                                    audio = data.get("data", {}).get("audio")
+                                    if audio is not None:
+                                        yield audio
+                                except json.JSONDecodeError:
+                                    logger.warning(
+                                        "Failed to parse JSON data from SSE message",
+                                    )
+                                    continue
+                        except ValueError:
+                            buffer = buffer[-1024:]
 
         except aiohttp.ClientError as e:
-            raise Exception(f"MiniMax TTS API请求失败: {str(e)}")
+            raise Exception(f"MiniMax TTS API请求失败: {e!s}")
 
     async def _audio_play(self, audio_stream: AsyncIterator[str]) -> bytes:
         """解码数据流到 audio 比特流"""

astrbot/core/provider/sources/openai_embedding_source.py

@@ -1,7 +1,8 @@
 from openai import AsyncOpenAI
+
+from ..entities import ProviderType
 from ..provider import EmbeddingProvider
 from ..register import register_provider_adapter
-from ..entities import ProviderType
 
 
 @register_provider_adapter(
@@ -17,23 +18,20 @@ class OpenAIEmbeddingProvider(EmbeddingProvider):
         self.client = AsyncOpenAI(
             api_key=provider_config.get("embedding_api_key"),
             base_url=provider_config.get(
-                "embedding_api_base", "https://api.openai.com/v1"
+                "embedding_api_base",
+                "https://api.openai.com/v1",
             ),
             timeout=int(provider_config.get("timeout", 20)),
         )
         self.model = provider_config.get("embedding_model", "text-embedding-3-small")
 
     async def get_embedding(self, text: str) -> list[float]:
-        """
-        获取文本的嵌入
-        """
+        """获取文本的嵌入"""
         embedding = await self.client.embeddings.create(input=text, model=self.model)
         return embedding.data[0].embedding
 
     async def get_embeddings(self, texts: list[str]) -> list[list[float]]:
-        """
-        批量获取文本的嵌入
-        """
+        """批量获取文本的嵌入"""
         embeddings = await self.client.embeddings.create(input=texts, model=self.model)
         return [item.embedding for item in embeddings.data]
 

astrbot/core/provider/sources/openai_source.py

@@ -1,29 +1,31 @@
+import asyncio
 import base64
+import inspect
 import json
 import os
-import inspect
 import random
-import asyncio
-import astrbot.core.message.components as Comp
-
-from openai import AsyncOpenAI, AsyncAzureOpenAI
-from openai.types.chat.chat_completion import ChatCompletion
+from collections.abc import AsyncGenerator
 
+from openai import AsyncAzureOpenAI, AsyncOpenAI
 from openai._exceptions import NotFoundError, UnprocessableEntityError
 from openai.lib.streaming.chat._completions import ChatCompletionStreamState
-from astrbot.core.utils.io import download_image_by_url
-from astrbot.core.message.message_event_result import MessageChain
+from openai.types.chat.chat_completion import ChatCompletion
 
-from astrbot.api.provider import Provider
+import astrbot.core.message.components as Comp
 from astrbot import logger
-from astrbot.core.provider.func_tool_manager import ToolSet
-from typing import List, AsyncGenerator
-from ..register import register_provider_adapter
+from astrbot.api.provider import Provider
+from astrbot.core.agent.message import Message
+from astrbot.core.agent.tool import ToolSet
+from astrbot.core.message.message_event_result import MessageChain
 from astrbot.core.provider.entities import LLMResponse, ToolCallsResult
+from astrbot.core.utils.io import download_image_by_url
+
+from ..register import register_provider_adapter
 
 
 @register_provider_adapter(
-    "openai_chat_completion", "OpenAI API Chat Completion 提供商适配器"
+    "openai_chat_completion",
+    "OpenAI API Chat Completion 提供商适配器",
 )
 class ProviderOpenAIOfficial(Provider):
     def __init__(
@@ -38,7 +40,7 @@ class ProviderOpenAIOfficial(Provider):
             default_persona,
         )
         self.chosen_api_key = None
-        self.api_keys: List = super().get_keys()
+        self.api_keys: list = super().get_keys()
         self.chosen_api_key = self.api_keys[0] if len(self.api_keys) > 0 else None
         self.timeout = provider_config.get("timeout", 120)
         if isinstance(self.timeout, str):
@@ -61,13 +63,35 @@ class ProviderOpenAIOfficial(Provider):
             )
 
         self.default_params = inspect.signature(
-            self.client.chat.completions.create
+            self.client.chat.completions.create,
         ).parameters.keys()
 
         model_config = provider_config.get("model_config", {})
         model = model_config.get("model", "unknown")
         self.set_model(model)
 
+    def _maybe_inject_xai_search(self, payloads: dict, **kwargs):
+        """当开启 xAI 原生搜索时，向请求体注入 Live Search 参数。
+
+        - 仅在 provider_config.xai_native_search 为 True 时生效
+        - 默认注入 {"mode": "auto"}
+        - 允许通过 kwargs 使用 xai_search_mode 覆盖（on/auto/off）
+        """
+        if not bool(self.provider_config.get("xai_native_search", False)):
+            return
+
+        mode = kwargs.get("xai_search_mode", "auto")
+        mode = str(mode).lower()
+        if mode not in ("auto", "on", "off"):
+            mode = "auto"
+
+        # off 时不注入，保持与未开启一致
+        if mode == "off":
+            return
+
+        # OpenAI SDK 不识别的字段会在 _query/_query_stream 中放入 extra_body
+        payloads["search_parameters"] = {"mode": mode}
+
     async def get_models(self):
         try:
             models_str = []
@@ -79,12 +103,12 @@ class ProviderOpenAIOfficial(Provider):
         except NotFoundError as e:
             raise Exception(f"获取模型列表失败：{e}")
 
-    async def _query(self, payloads: dict, tools: ToolSet) -> LLMResponse:
+    async def _query(self, payloads: dict, tools: ToolSet | None) -> LLMResponse:
         if tools:
             model = payloads.get("model", "").lower()
             omit_empty_param_field = "gemini" in model
             tool_list = tools.get_func_desc_openai_style(
-                omit_empty_parameter_field=omit_empty_param_field
+                omit_empty_parameter_field=omit_empty_param_field,
             )
             if tool_list:
                 payloads["tools"] = tool_list
@@ -92,7 +116,7 @@ class ProviderOpenAIOfficial(Provider):
         # 不在默认参数中的参数放在 extra_body 中
         extra_body = {}
         to_del = []
-        for key in payloads.keys():
+        for key in payloads:
             if key not in self.default_params:
                 extra_body[key] = payloads[key]
                 to_del.append(key)
@@ -111,12 +135,14 @@ class ProviderOpenAIOfficial(Provider):
             del payloads["tools"]
 
         completion = await self.client.chat.completions.create(
-            **payloads, stream=False, extra_body=extra_body
+            **payloads,
+            stream=False,
+            extra_body=extra_body,
         )
 
         if not isinstance(completion, ChatCompletion):
             raise Exception(
-                f"API 返回的 completion 类型错误：{type(completion)}: {completion}。"
+                f"API 返回的 completion 类型错误：{type(completion)}: {completion}。",
             )
 
         logger.debug(f"completion: {completion}")
@@ -126,14 +152,16 @@ class ProviderOpenAIOfficial(Provider):
         return llm_response
 
     async def _query_stream(
-        self, payloads: dict, tools: ToolSet
+        self,
+        payloads: dict,
+        tools: ToolSet | None,
     ) -> AsyncGenerator[LLMResponse, None]:
         """流式查询API，逐步返回结果"""
         if tools:
             model = payloads.get("model", "").lower()
             omit_empty_param_field = "gemini" in model
             tool_list = tools.get_func_desc_openai_style(
-                omit_empty_parameter_field=omit_empty_param_field
+                omit_empty_parameter_field=omit_empty_param_field,
             )
             if tool_list:
                 payloads["tools"] = tool_list
@@ -147,7 +175,7 @@ class ProviderOpenAIOfficial(Provider):
             extra_body.update(custom_extra_body)
 
         to_del = []
-        for key in payloads.keys():
+        for key in payloads:
             if key not in self.default_params:
                 extra_body[key] = payloads[key]
                 to_del.append(key)
@@ -155,7 +183,9 @@ class ProviderOpenAIOfficial(Provider):
             del payloads[key]
 
         stream = await self.client.chat.completions.create(
-            **payloads, stream=True, extra_body=extra_body
+            **payloads,
+            stream=True,
+            extra_body=extra_body,
         )
 
         llm_response = LLMResponse("assistant", is_chunk=True)
@@ -174,7 +204,7 @@ class ProviderOpenAIOfficial(Provider):
             if delta.content:
                 completion_text = delta.content
                 llm_response.result_chain = MessageChain(
-                    chain=[Comp.Plain(completion_text)]
+                    chain=[Comp.Plain(completion_text)],
                 )
                 yield llm_response
 
@@ -183,7 +213,9 @@ class ProviderOpenAIOfficial(Provider):
 
         yield llm_response
 
-    async def parse_openai_completion(self, completion: ChatCompletion, tools: ToolSet):
+    async def parse_openai_completion(
+        self, completion: ChatCompletion, tools: ToolSet | None
+    ) -> LLMResponse:
         """解析 OpenAI 的 ChatCompletion 响应"""
         llm_response = LLMResponse("assistant")
 
@@ -196,7 +228,7 @@ class ProviderOpenAIOfficial(Provider):
             completion_text = str(choice.message.content).strip()
             llm_response.result_chain = MessageChain().message(completion_text)
 
-        if choice.message.tool_calls:
+        if choice.message.tool_calls and tools is not None:
             # tools call (function calling)
             args_ls = []
             func_name_ls = []
@@ -225,7 +257,7 @@ class ProviderOpenAIOfficial(Provider):
 
         if choice.finish_reason == "content_filter":
             raise Exception(
-                "API 返回的 completion 由于内容安全过滤被拒绝(非 AstrBot)。"
+                "API 返回的 completion 由于内容安全过滤被拒绝(非 AstrBot)。",
             )
 
         if llm_response.completion_text is None and not llm_response.tools_call_args:
@@ -238,9 +270,9 @@ class ProviderOpenAIOfficial(Provider):
 
     async def _prepare_chat_payload(
         self,
-        prompt: str,
+        prompt: str | None,
         image_urls: list[str] | None = None,
-        contexts: list | None = None,
+        contexts: list[dict] | list[Message] | None = None,
         system_prompt: str | None = None,
         tool_calls_result: ToolCallsResult | list[ToolCallsResult] | None = None,
         model: str | None = None,
@@ -249,8 +281,12 @@ class ProviderOpenAIOfficial(Provider):
         """准备聊天所需的有效载荷和上下文"""
         if contexts is None:
             contexts = []
-        new_record = await self.assemble_context(prompt, image_urls)
-        context_query = [*contexts, new_record]
+        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})
 
@@ -271,6 +307,9 @@ class ProviderOpenAIOfficial(Provider):
 
         payloads = {"messages": context_query, **model_config}
 
+        # xAI 原生搜索参数（最小侵入地在此处注入）
+        self._maybe_inject_xai_search(payloads, **kwargs)
+
         return payloads, context_query
 
     async def _handle_api_error(
@@ -278,16 +317,16 @@ class ProviderOpenAIOfficial(Provider):
         e: Exception,
         payloads: dict,
         context_query: list,
-        func_tool: ToolSet,
+        func_tool: ToolSet | None,
         chosen_key: str,
-        available_api_keys: List[str],
+        available_api_keys: list[str],
         retry_cnt: int,
         max_retries: int,
     ) -> tuple:
         """处理API错误并尝试恢复"""
         if "429" in str(e):
             logger.warning(
-                f"API 调用过于频繁，尝试使用其他 Key 重试。当前 Key: {chosen_key[:12]}"
+                f"API 调用过于频繁，尝试使用其他 Key 重试。当前 Key: {chosen_key[:12]}",
             )
             # 最后一次不等待
             if retry_cnt < max_retries - 1:
@@ -303,11 +342,10 @@ class ProviderOpenAIOfficial(Provider):
                     context_query,
                     func_tool,
                 )
-            else:
-                raise e
-        elif "maximum context length" in str(e):
+            raise e
+        if "maximum context length" in str(e):
             logger.warning(
-                f"上下文长度超过限制。尝试弹出最早的记录然后重试。当前记录条数: {len(context_query)}"
+                f"上下文长度超过限制。尝试弹出最早的记录然后重试。当前记录条数: {len(context_query)}",
             )
             await self.pop_record(context_query)
             payloads["messages"] = context_query
@@ -319,7 +357,7 @@ class ProviderOpenAIOfficial(Provider):
                 context_query,
                 func_tool,
             )
-        elif "The model is not a VLM" in str(e):  # siliconcloud
+        if "The model is not a VLM" in str(e):  # siliconcloud
             # 尝试删除所有 image
             new_contexts = await self._remove_image_from_context(context_query)
             payloads["messages"] = new_contexts
@@ -332,36 +370,34 @@ class ProviderOpenAIOfficial(Provider):
                 context_query,
                 func_tool,
             )
-        elif (
+        if (
             "Function calling is not enabled" in str(e)
             or ("tool" in str(e).lower() and "support" in str(e).lower())
             or ("function" in str(e).lower() and "support" in str(e).lower())
         ):
             # openai, ollama, gemini openai, siliconcloud 的错误提示与 code 不统一，只能通过字符串匹配
             logger.info(
-                f"{self.get_model()} 不支持函数工具调用，已自动去除，不影响使用。"
+                f"{self.get_model()} 不支持函数工具调用，已自动去除，不影响使用。",
             )
-            if "tools" in payloads:
-                del payloads["tools"]
+            payloads.pop("tools", None)
             return False, chosen_key, available_api_keys, payloads, context_query, None
-        else:
-            logger.error(f"发生了错误。Provider 配置如下: {self.provider_config}")
+        logger.error(f"发生了错误。Provider 配置如下: {self.provider_config}")
 
-            if "tool" in str(e).lower() and "support" in str(e).lower():
-                logger.error("疑似该模型不支持函数调用工具调用。请输入 /tool off_all")
+        if "tool" in str(e).lower() and "support" in str(e).lower():
+            logger.error("疑似该模型不支持函数调用工具调用。请输入 /tool off_all")
 
-            if "Connection error." in str(e):
-                proxy = os.environ.get("http_proxy", None)
-                if proxy:
-                    logger.error(
-                        f"可能为代理原因，请检查代理是否正常。当前代理: {proxy}"
-                    )
+        if "Connection error." in str(e):
+            proxy = os.environ.get("http_proxy", None)
+            if proxy:
+                logger.error(
+                    f"可能为代理原因，请检查代理是否正常。当前代理: {proxy}",
+                )
 
-            raise e
+        raise e
 
     async def text_chat(
         self,
-        prompt,
+        prompt=None,
         session_id=None,
         image_urls=None,
         func_tool=None,
@@ -430,7 +466,7 @@ class ProviderOpenAIOfficial(Provider):
 
     async def text_chat_stream(
         self,
-        prompt: str,
+        prompt=None,
         session_id=None,
         image_urls=None,
         func_tool=None,
@@ -497,10 +533,8 @@ class ProviderOpenAIOfficial(Provider):
                 raise Exception("未知错误")
             raise last_exception
 
-    async def _remove_image_from_context(self, contexts: List):
-        """
-        从上下文中删除所有带有 image 的记录
-        """
+    async def _remove_image_from_context(self, contexts: list):
+        """从上下文中删除所有带有 image 的记录"""
         new_contexts = []
 
         for context in contexts:
@@ -521,14 +555,16 @@ class ProviderOpenAIOfficial(Provider):
     def get_current_key(self) -> str:
         return self.client.api_key
 
-    def get_keys(self) -> List[str]:
+    def get_keys(self) -> list[str]:
         return self.api_keys
 
     def set_key(self, key):
         self.client.api_key = key
 
     async def assemble_context(
-        self, text: str, image_urls: List[str] | None = None
+        self,
+        text: str,
+        image_urls: list[str] | None = None,
     ) -> dict:
         """组装成符合 OpenAI 格式的 role 为 user 的消息段"""
         if image_urls:
@@ -552,16 +588,13 @@ class ProviderOpenAIOfficial(Provider):
                     {
                         "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:

astrbot/core/provider/sources/openai_tts_api_source.py

@@ -1,14 +1,19 @@
 import os
 import uuid
-from openai import AsyncOpenAI, NOT_GIVEN
-from ..provider import TTSProvider
+
+from openai import NOT_GIVEN, AsyncOpenAI
+
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+
 from ..entities import ProviderType
+from ..provider import TTSProvider
 from ..register import register_provider_adapter
-from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 
 
 @register_provider_adapter(
-    "openai_tts_api", "OpenAI TTS API", provider_type=ProviderType.TEXT_TO_SPEECH
+    "openai_tts_api",
+    "OpenAI TTS API",
+    provider_type=ProviderType.TEXT_TO_SPEECH,
 )
 class ProviderOpenAITTSAPI(TTSProvider):
     def __init__(
@@ -26,7 +31,7 @@ class ProviderOpenAITTSAPI(TTSProvider):
 
         self.client = AsyncOpenAI(
             api_key=self.chosen_api_key,
-            base_url=provider_config.get("api_base", None),
+            base_url=provider_config.get("api_base"),
             timeout=timeout,
         )
 
@@ -36,7 +41,10 @@ class ProviderOpenAITTSAPI(TTSProvider):
         temp_dir = os.path.join(get_astrbot_data_path(), "temp")
         path = os.path.join(temp_dir, f"openai_tts_api_{uuid.uuid4()}.wav")
         async with self.client.audio.speech.with_streaming_response.create(
-            model=self.model_name, voice=self.voice, response_format="wav", input=text
+            model=self.model_name,
+            voice=self.voice,
+            response_format="wav",
+            input=text,
         ) as response:
             with open(path, "wb") as f:
                 async for chunk in response.iter_bytes(chunk_size=1024):