AstrBot 4.3.5__py3-none-any.whl → 4.5.1__py3-none-any.whl

astrbot/core/provider/sources/dify_source.py

@@ -1,9 +1,7 @@
 import astrbot.core.message.components as Comp
 import os
-from typing import List
 from .. import Provider
 from ..entities import LLMResponse
-from ..func_tool_manager import FuncCall
 from ..register import register_provider_adapter
 from astrbot.core.utils.dify_api_client import DifyAPIClient
 from astrbot.core.utils.io import download_image_by_url, download_file
@@ -55,11 +53,11 @@ class ProviderDify(Provider):
     async def text_chat(
         self,
         prompt: str,
-        session_id: str = None,
-        image_urls: List[str] = None,
-        func_tool: FuncCall = None,
-        contexts: List = None,
-        system_prompt: str = None,
+        session_id=None,
+        image_urls=None,
+        func_tool=None,
+        contexts=None,
+        system_prompt=None,
         tool_calls_result=None,
         model=None,
         **kwargs,
@@ -223,7 +221,7 @@ class ProviderDify(Provider):
             # Chat
             return MessageChain(chain=[Comp.Plain(chunk)])
 
-        async def parse_file(item: dict) -> Comp:
+        async def parse_file(item: dict):
             match item["type"]:
                 case "image":
                     return Comp.Image(file=item["url"], url=item["url"])

astrbot/core/provider/sources/gemini_embedding_source.py

@@ -32,7 +32,6 @@ class GeminiEmbeddingProvider(EmbeddingProvider):
         self.model = provider_config.get(
             "embedding_model", "gemini-embedding-exp-03-07"
         )
-        self.dimension = provider_config.get("embedding_dimensions", 768)
 
     async def get_embedding(self, text: str) -> list[float]:
         """
@@ -60,4 +59,4 @@ class GeminiEmbeddingProvider(EmbeddingProvider):
 
     def get_dim(self) -> int:
         """获取向量的维度"""
-        return self.dimension
+        return self.provider_config.get("embedding_dimensions", 768)

astrbot/core/provider/sources/openai_embedding_source.py

@@ -22,7 +22,6 @@ class OpenAIEmbeddingProvider(EmbeddingProvider):
             timeout=int(provider_config.get("timeout", 20)),
         )
         self.model = provider_config.get("embedding_model", "text-embedding-3-small")
-        self.dimension = provider_config.get("embedding_dimensions", 1024)
 
     async def get_embedding(self, text: str) -> list[float]:
         """
@@ -40,4 +39,4 @@ class OpenAIEmbeddingProvider(EmbeddingProvider):
 
     def get_dim(self) -> int:
         """获取向量的维度"""
-        return self.dimension
+        return self.provider_config.get("embedding_dimensions", 1024)

astrbot/core/provider/sources/openai_source.py

@@ -16,7 +16,7 @@ from astrbot.core.message.message_event_result import MessageChain
 
 from astrbot.api.provider import Provider
 from astrbot import logger
-from astrbot.core.provider.func_tool_manager import FuncCall
+from astrbot.core.provider.func_tool_manager import ToolSet
 from typing import List, AsyncGenerator
 from ..register import register_provider_adapter
 from astrbot.core.provider.entities import LLMResponse, ToolCallsResult
@@ -49,7 +49,7 @@ class ProviderOpenAIOfficial(Provider):
             self.client = AsyncAzureOpenAI(
                 api_key=self.chosen_api_key,
                 api_version=provider_config.get("api_version", None),
-                base_url=provider_config.get("api_base", None),
+                base_url=provider_config.get("api_base", ""),
                 timeout=self.timeout,
             )
         else:
@@ -68,6 +68,28 @@ class ProviderOpenAIOfficial(Provider):
         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,7 +101,7 @@ class ProviderOpenAIOfficial(Provider):
         except NotFoundError as e:
             raise Exception(f"获取模型列表失败：{e}")
 
-    async def _query(self, payloads: dict, tools: FuncCall) -> LLMResponse:
+    async def _query(self, payloads: dict, tools: ToolSet) -> LLMResponse:
         if tools:
             model = payloads.get("model", "").lower()
             omit_empty_param_field = "gemini" in model
@@ -126,7 +148,7 @@ class ProviderOpenAIOfficial(Provider):
         return llm_response
 
     async def _query_stream(
-        self, payloads: dict, tools: FuncCall
+        self, payloads: dict, tools: ToolSet
     ) -> AsyncGenerator[LLMResponse, None]:
         """流式查询API，逐步返回结果"""
         if tools:
@@ -183,9 +205,7 @@ class ProviderOpenAIOfficial(Provider):
 
         yield llm_response
 
-    async def parse_openai_completion(
-        self, completion: ChatCompletion, tools: FuncCall
-    ):
+    async def parse_openai_completion(self, completion: ChatCompletion, tools: ToolSet):
         """解析 OpenAI 的 ChatCompletion 响应"""
         llm_response = LLMResponse("assistant")
 
@@ -208,7 +228,10 @@ class ProviderOpenAIOfficial(Provider):
                     # workaround for #1359
                     tool_call = json.loads(tool_call)
                 for tool in tools.func_list:
-                    if tool.name == tool_call.function.name:
+                    if (
+                        tool_call.type == "function"
+                        and tool.name == tool_call.function.name
+                    ):
                         # workaround for #1454
                         if isinstance(tool_call.function.arguments, str):
                             args = json.loads(tool_call.function.arguments)
@@ -270,6 +293,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(
@@ -277,7 +303,7 @@ class ProviderOpenAIOfficial(Provider):
         e: Exception,
         payloads: dict,
         context_query: list,
-        func_tool: FuncCall,
+        func_tool: ToolSet,
         chosen_key: str,
         available_api_keys: List[str],
         retry_cnt: int,
@@ -420,7 +446,7 @@ class ProviderOpenAIOfficial(Provider):
                 if success:
                     break
 
-        if retry_cnt == max_retries - 1:
+        if retry_cnt == max_retries - 1 or llm_response is None:
             logger.error(f"API 调用失败，重试 {max_retries} 次仍然失败。")
             if last_exception is None:
                 raise Exception("未知错误")
@@ -430,10 +456,10 @@ class ProviderOpenAIOfficial(Provider):
     async def text_chat_stream(
         self,
         prompt: str,
-        session_id: str = None,
-        image_urls: List[str] = [],
-        func_tool: FuncCall = None,
-        contexts=[],
+        session_id=None,
+        image_urls=None,
+        func_tool=None,
+        contexts=None,
         system_prompt=None,
         tool_calls_result=None,
         model=None,
@@ -526,7 +552,9 @@ class ProviderOpenAIOfficial(Provider):
     def set_key(self, key):
         self.client.api_key = key
 
-    async def assemble_context(self, text: str, image_urls: List[str] = None) -> dict:
+    async def assemble_context(
+        self, text: str, image_urls: List[str] | None = None
+    ) -> dict:
         """组装成符合 OpenAI 格式的 role 为 user 的消息段"""
         if image_urls:
             user_content = {

astrbot/core/provider/sources/openai_tts_api_source.py

@@ -30,7 +30,7 @@ class ProviderOpenAITTSAPI(TTSProvider):
             timeout=timeout,
         )
 
-        self.set_model(provider_config.get("model", None))
+        self.set_model(provider_config.get("model", ""))
 
     async def get_audio(self, text: str) -> str:
         temp_dir = os.path.join(get_astrbot_data_path(), "temp")

astrbot/core/provider/sources/xinference_rerank_source.py

@@ -0,0 +1,108 @@
+from xinference_client.client.restful.async_restful_client import (
+    AsyncClient as Client,
+)
+from astrbot import logger
+from ..provider import RerankProvider
+from ..register import register_provider_adapter
+from ..entities import ProviderType, RerankResult
+
+
+@register_provider_adapter(
+    "xinference_rerank",
+    "Xinference Rerank 适配器",
+    provider_type=ProviderType.RERANK,
+)
+class XinferenceRerankProvider(RerankProvider):
+    def __init__(self, provider_config: dict, provider_settings: dict) -> None:
+        super().__init__(provider_config, provider_settings)
+        self.provider_config = provider_config
+        self.provider_settings = provider_settings
+        self.base_url = provider_config.get("rerank_api_base", "http://127.0.0.1:8000")
+        self.base_url = self.base_url.rstrip("/")
+        self.timeout = provider_config.get("timeout", 20)
+        self.model_name = provider_config.get("rerank_model", "BAAI/bge-reranker-base")
+        self.api_key = provider_config.get("rerank_api_key")
+        self.launch_model_if_not_running = provider_config.get(
+            "launch_model_if_not_running", False
+        )
+        self.client = None
+        self.model = None
+        self.model_uid = None
+
+    async def initialize(self):
+        if self.api_key:
+            logger.info("Xinference Rerank: Using API key for authentication.")
+            self.client = Client(self.base_url, api_key=self.api_key)
+        else:
+            logger.info("Xinference Rerank: No API key provided.")
+            self.client = Client(self.base_url)
+
+        try:
+            running_models = await self.client.list_models()
+            for uid, model_spec in running_models.items():
+                if model_spec.get("model_name") == self.model_name:
+                    logger.info(
+                        f"Model '{self.model_name}' is already running with UID: {uid}"
+                    )
+                    self.model_uid = uid
+                    break
+
+            if self.model_uid is None:
+                if self.launch_model_if_not_running:
+                    logger.info(f"Launching {self.model_name} model...")
+                    self.model_uid = await self.client.launch_model(
+                        model_name=self.model_name, model_type="rerank"
+                    )
+                    logger.info("Model launched.")
+                else:
+                    logger.warning(
+                        f"Model '{self.model_name}' is not running and auto-launch is disabled. Provider will not be available."
+                    )
+                    return
+
+            if self.model_uid:
+                self.model = await self.client.get_model(self.model_uid)
+
+        except Exception as e:
+            logger.error(f"Failed to initialize Xinference model: {e}")
+            logger.debug(
+                f"Xinference initialization failed with exception: {e}", exc_info=True
+            )
+            self.model = None
+
+    async def rerank(
+        self, query: str, documents: list[str], top_n: int | None = None
+    ) -> list[RerankResult]:
+        if not self.model:
+            logger.error("Xinference rerank model is not initialized.")
+            return []
+        try:
+            response = await self.model.rerank(documents, query, top_n)
+            results = response.get("results", [])
+            logger.debug(f"Rerank API response: {response}")
+
+            if not results:
+                logger.warning(
+                    f"Rerank API returned an empty list. Original response: {response}"
+                )
+
+            return [
+                RerankResult(
+                    index=result["index"],
+                    relevance_score=result["relevance_score"],
+                )
+                for result in results
+            ]
+        except Exception as e:
+            logger.error(f"Xinference rerank failed: {e}")
+            logger.debug(f"Xinference rerank failed with exception: {e}", exc_info=True)
+            return []
+
+    async def terminate(self) -> None:
+        """关闭客户端会话"""
+        if self.client:
+            logger.info("Closing Xinference rerank client...")
+            try:
+                await self.client.close()
+            except Exception as e:
+                logger.error(f"Failed to close Xinference client: {e}", exc_info=True)

astrbot/core/provider/sources/xinference_stt_provider.py

@@ -0,0 +1,187 @@
+import uuid
+import os
+import aiohttp
+from xinference_client.client.restful.async_restful_client import (
+    AsyncClient as Client,
+)
+from ..provider import STTProvider
+from ..entities import ProviderType
+from ..register import register_provider_adapter
+from astrbot.core import logger
+from astrbot.core.utils.tencent_record_helper import tencent_silk_to_wav
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+
+
+@register_provider_adapter(
+    "xinference_stt",
+    "Xinference STT",
+    provider_type=ProviderType.SPEECH_TO_TEXT,
+)
+class ProviderXinferenceSTT(STTProvider):
+    def __init__(self, provider_config: dict, provider_settings: dict) -> None:
+        super().__init__(provider_config, provider_settings)
+        self.provider_config = provider_config
+        self.provider_settings = provider_settings
+        self.base_url = provider_config.get("api_base", "http://127.0.0.1:9997")
+        self.base_url = self.base_url.rstrip("/")
+        self.timeout = provider_config.get("timeout", 180)
+        self.model_name = provider_config.get("model", "whisper-large-v3")
+        self.api_key = provider_config.get("api_key")
+        self.launch_model_if_not_running = provider_config.get(
+            "launch_model_if_not_running", False
+        )
+        self.client = None
+        self.model_uid = None
+
+    async def initialize(self):
+        if self.api_key:
+            logger.info("Xinference STT: Using API key for authentication.")
+            self.client = Client(self.base_url, api_key=self.api_key)
+        else:
+            logger.info("Xinference STT: No API key provided.")
+            self.client = Client(self.base_url)
+
+        try:
+            running_models = await self.client.list_models()
+            for uid, model_spec in running_models.items():
+                if model_spec.get("model_name") == self.model_name:
+                    logger.info(
+                        f"Model '{self.model_name}' is already running with UID: {uid}"
+                    )
+                    self.model_uid = uid
+                    break
+
+            if self.model_uid is None:
+                if self.launch_model_if_not_running:
+                    logger.info(f"Launching {self.model_name} model...")
+                    self.model_uid = await self.client.launch_model(
+                        model_name=self.model_name, model_type="audio"
+                    )
+                    logger.info("Model launched.")
+                else:
+                    logger.warning(
+                        f"Model '{self.model_name}' is not running and auto-launch is disabled. Provider will not be available."
+                    )
+                    return
+
+        except Exception as e:
+            logger.error(f"Failed to initialize Xinference model: {e}")
+            logger.debug(
+                f"Xinference initialization failed with exception: {e}", exc_info=True
+            )
+
+    async def get_text(self, audio_url: str) -> str:
+        if not self.model_uid or self.client is None or self.client.session is None:
+            logger.error("Xinference STT model is not initialized.")
+            return ""
+
+        audio_bytes = None
+        temp_files = []
+        is_tencent = False
+
+        try:
+            # 1. Get audio bytes
+            if audio_url.startswith("http"):
+                if "multimedia.nt.qq.com.cn" in audio_url:
+                    is_tencent = True
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(audio_url, timeout=self.timeout) as resp:
+                        if resp.status == 200:
+                            audio_bytes = await resp.read()
+                        else:
+                            logger.error(
+                                f"Failed to download audio from {audio_url}, status: {resp.status}"
+                            )
+                            return ""
+            else:
+                if os.path.exists(audio_url):
+                    with open(audio_url, "rb") as f:
+                        audio_bytes = f.read()
+                else:
+                    logger.error(f"File not found: {audio_url}")
+                    return ""
+
+            if not audio_bytes:
+                logger.error("Audio bytes are empty.")
+                return ""
+
+            # 2. Check for conversion
+            needs_conversion = False
+            if (
+                audio_url.endswith((".amr", ".silk"))
+                or is_tencent
+                or b"SILK" in audio_bytes[:8]
+            ):
+                needs_conversion = True
+
+            # 3. Perform conversion if needed
+            if needs_conversion:
+                logger.info("Audio requires conversion, using temporary files...")
+                temp_dir = os.path.join(get_astrbot_data_path(), "temp")
+                os.makedirs(temp_dir, exist_ok=True)
+
+                input_path = os.path.join(temp_dir, str(uuid.uuid4()))
+                output_path = os.path.join(temp_dir, str(uuid.uuid4()) + ".wav")
+                temp_files.extend([input_path, output_path])
+
+                with open(input_path, "wb") as f:
+                    f.write(audio_bytes)
+
+                logger.info("Converting silk/amr file to wav ...")
+                await tencent_silk_to_wav(input_path, output_path)
+
+                with open(output_path, "rb") as f:
+                    audio_bytes = f.read()
+
+            # 4. Transcribe
+            # 官方asyncCLient的客户端似乎实现有点问题，这里直接用aiohttp实现openai标准兼容请求，提交issue等待官方修复后再改回来
+            url = f"{self.base_url}/v1/audio/transcriptions"
+            headers = {
+                "accept": "application/json",
+            }
+            if self.client and self.client._headers:
+                headers.update(self.client._headers)
+
+            data = aiohttp.FormData()
+            data.add_field("model", self.model_uid)
+            data.add_field(
+                "file", audio_bytes, filename="audio.wav", content_type="audio/wav"
+            )
+
+            async with self.client.session.post(
+                url, data=data, headers=headers, timeout=self.timeout
+            ) as resp:
+                if resp.status == 200:
+                    result = await resp.json()
+                    text = result.get("text", "")
+                    logger.debug(f"Xinference STT result: {text}")
+                    return text
+                else:
+                    error_text = await resp.text()
+                    logger.error(
+                        f"Xinference STT transcription failed with status {resp.status}: {error_text}"
+                    )
+                    return ""
+
+        except Exception as e:
+            logger.error(f"Xinference STT failed: {e}")
+            logger.debug(f"Xinference STT failed with exception: {e}", exc_info=True)
+            return ""
+        finally:
+            # 5. Cleanup
+            for temp_file in temp_files:
+                try:
+                    if os.path.exists(temp_file):
+                        os.remove(temp_file)
+                        logger.debug(f"Removed temporary file: {temp_file}")
+                except Exception as e:
+                    logger.error(f"Failed to remove temporary file {temp_file}: {e}")
+
+    async def terminate(self) -> None:
+        """关闭客户端会话"""
+        if self.client:
+            logger.info("Closing Xinference STT client...")
+            try:
+                await self.client.close()
+            except Exception as e:
+                logger.error(f"Failed to close Xinference client: {e}", exc_info=True)

astrbot/core/star/context.py

@@ -1,5 +1,4 @@
 from asyncio import Queue
-from typing import List, Union
 
 from astrbot.core.provider.provider import (
     Provider,
@@ -11,7 +10,7 @@ from astrbot.core.provider.provider import (
 from astrbot.core.provider.entities import ProviderType
 from astrbot.core.db import BaseDatabase
 from astrbot.core.config.astrbot_config import AstrBotConfig
-from astrbot.core.provider.func_tool_manager import FunctionToolManager
+from astrbot.core.provider.func_tool_manager import FunctionToolManager, FunctionTool
 from astrbot.core.platform.astr_message_event import MessageSesion
 from astrbot.core.message.message_event_result import MessageChain
 from astrbot.core.provider.manager import ProviderManager
@@ -19,12 +18,14 @@ from astrbot.core.platform import Platform
 from astrbot.core.platform.manager import PlatformManager
 from astrbot.core.platform_message_history_mgr import PlatformMessageHistoryManager
 from astrbot.core.astrbot_config_mgr import AstrBotConfigManager
+from astrbot.core.knowledge_base.kb_mgr import KnowledgeBaseManager
 from astrbot.core.persona_mgr import PersonaManager
 from .star import star_registry, StarMetadata, star_map
 from .star_handler import star_handlers_registry, StarHandlerMetadata, EventType
 from .filter.command import CommandFilter
 from .filter.regex import RegexFilter
-from typing import Awaitable, Any, Callable
+from typing import Any
+from collections.abc import Awaitable, Callable
 from astrbot.core.conversation_mgr import ConversationManager
 from astrbot.core.star.filter.platform_adapter_type import (
     PlatformAdapterType,
@@ -41,7 +42,7 @@ class Context:
     registered_web_apis: list = []
 
     # back compatibility
-    _register_tasks: List[Awaitable] = []
+    _register_tasks: list[Awaitable] = []
     _star_manager = None
 
     def __init__(
@@ -55,6 +56,7 @@ class Context:
         message_history_manager: PlatformMessageHistoryManager,
         persona_manager: PersonaManager,
         astrbot_config_mgr: AstrBotConfigManager,
+        knowledge_base_manager: KnowledgeBaseManager,
     ):
         self._event_queue = event_queue
         """事件队列。消息平台通过事件队列传递消息事件。"""
@@ -68,6 +70,7 @@ class Context:
         self.message_history_manager = message_history_manager
         self.persona_manager = persona_manager
         self.astrbot_config_mgr = astrbot_config_mgr
+        self.kb_manager = knowledge_base_manager
 
     def get_registered_star(self, star_name: str) -> StarMetadata | None:
         """根据插件名获取插件的 Metadata"""
@@ -75,7 +78,7 @@ class Context:
             if star.name == star_name:
                 return star
 
-    def get_all_stars(self) -> List[StarMetadata]:
+    def get_all_stars(self) -> list[StarMetadata]:
         """获取当前载入的所有插件 Metadata 的列表"""
         return star_registry
 
@@ -113,19 +116,19 @@ class Context:
         prov = self.provider_manager.inst_map.get(provider_id)
         return prov
 
-    def get_all_providers(self) -> List[Provider]:
+    def get_all_providers(self) -> list[Provider]:
         """获取所有用于文本生成任务的 LLM Provider(Chat_Completion 类型)。"""
         return self.provider_manager.provider_insts
 
-    def get_all_tts_providers(self) -> List[TTSProvider]:
+    def get_all_tts_providers(self) -> list[TTSProvider]:
         """获取所有用于 TTS 任务的 Provider。"""
         return self.provider_manager.tts_provider_insts
 
-    def get_all_stt_providers(self) -> List[STTProvider]:
+    def get_all_stt_providers(self) -> list[STTProvider]:
         """获取所有用于 STT 任务的 Provider。"""
         return self.provider_manager.stt_provider_insts
 
-    def get_all_embedding_providers(self) -> List[EmbeddingProvider]:
+    def get_all_embedding_providers(self) -> list[EmbeddingProvider]:
         """获取所有用于 Embedding 任务的 Provider。"""
         return self.provider_manager.embedding_provider_insts
 
@@ -193,9 +196,7 @@ class Context:
         return self._event_queue
 
     @deprecated(version="4.0.0", reason="Use get_platform_inst instead")
-    def get_platform(
-        self, platform_type: Union[PlatformAdapterType, str]
-    ) -> Platform | None:
+    def get_platform(self, platform_type: PlatformAdapterType | str) -> Platform | None:
         """
         获取指定类型的平台适配器。
 
@@ -228,7 +229,7 @@ class Context:
                 return platform
 
     async def send_message(
-        self, session: Union[str, MessageSesion], message_chain: MessageChain
+        self, session: str | MessageSesion, message_chain: MessageChain
     ) -> bool:
         """
         根据 session(unified_msg_origin) 主动发送消息。
@@ -255,6 +256,11 @@ class Context:
                 return True
         return False
 
+    def add_llm_tools(self, *tools: FunctionTool) -> None:
+        """添加 LLM 工具。"""
+        for tool in tools:
+            self.provider_manager.llm_tools.func_list.append(tool)
+
     """
     以下的方法已经不推荐使用。请从 AstrBot 文档查看更好的注册方式。
     """

astrbot/core/star/star.py

@@ -56,6 +56,12 @@ class StarMetadata:
     star_handler_full_names: list[str] = field(default_factory=list)
     """注册的 Handler 的全名列表"""
 
+    display_name: str | None = None
+    """用于展示的插件名称"""
+
+    logo_path: str | None = None
+    """插件 Logo 的路径"""
+
     def __str__(self) -> str:
         return f"Plugin {self.name} ({self.version}) by {self.author}: {self.desc}"