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

astrbot/core/provider/provider.py

@@ -1,17 +1,18 @@
 import abc
 import asyncio
-from typing import List
-from typing import AsyncGenerator
+from collections.abc import AsyncGenerator
+from dataclasses import dataclass
+
+from astrbot.core.agent.message import Message
 from astrbot.core.agent.tool import ToolSet
+from astrbot.core.db.po import Personality
 from astrbot.core.provider.entities import (
     LLMResponse,
-    ToolCallsResult,
     ProviderType,
     RerankResult,
+    ToolCallsResult,
 )
 from astrbot.core.provider.register import provider_cls_map
-from astrbot.core.db.po import Personality
-from dataclasses import dataclass
 
 
 @dataclass
@@ -23,24 +24,28 @@ class ProviderMeta:
 
 
 class AbstractProvider(abc.ABC):
+    """Provider Abstract Class"""
+
     def __init__(self, provider_config: dict) -> None:
         super().__init__()
         self.model_name = ""
         self.provider_config = provider_config
 
     def set_model(self, model_name: str):
-        """设置当前使用的模型名称"""
+        """Set the current model name"""
         self.model_name = model_name
 
     def get_model(self) -> str:
-        """获得当前使用的模型名称"""
+        """Get the current model name"""
         return self.model_name
 
     def meta(self) -> ProviderMeta:
-        """获取 Provider 的元数据"""
+        """Get the provider metadata"""
         provider_type_name = self.provider_config["type"]
         meta_data = provider_cls_map.get(provider_type_name)
         provider_type = meta_data.provider_type if meta_data else None
+        if provider_type is None:
+            raise ValueError(f"Cannot find provider type: {provider_type_name}")
         return ProviderMeta(
             id=self.provider_config["id"],
             model=self.get_model(),
@@ -50,6 +55,8 @@ class AbstractProvider(abc.ABC):
 
 
 class Provider(AbstractProvider):
+    """Chat Provider"""
+
     def __init__(
         self,
         provider_config: dict,
@@ -65,99 +72,114 @@ class Provider(AbstractProvider):
 
     @abc.abstractmethod
     def get_current_key(self) -> str:
-        raise NotImplementedError()
+        raise NotImplementedError
 
-    def get_keys(self) -> List[str]:
+    def get_keys(self) -> list[str]:
         """获得提供商 Key"""
         keys = self.provider_config.get("key", [""])
         return keys or [""]
 
     @abc.abstractmethod
     def set_key(self, key: str):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @abc.abstractmethod
-    async def get_models(self) -> List[str]:
+    async def get_models(self) -> list[str]:
         """获得支持的模型列表"""
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @abc.abstractmethod
     async def text_chat(
         self,
-        prompt: str,
-        session_id: str = None,
-        image_urls: list[str] = None,
-        func_tool: ToolSet = None,
-        contexts: list = None,
-        system_prompt: str = None,
-        tool_calls_result: ToolCallsResult | list[ToolCallsResult] = None,
+        prompt: str | None = None,
+        session_id: str | None = None,
+        image_urls: list[str] | None = None,
+        func_tool: ToolSet | None = None,
+        contexts: list[Message] | list[dict] | None = None,
+        system_prompt: str | None = None,
+        tool_calls_result: ToolCallsResult | list[ToolCallsResult] | None = None,
         model: str | None = None,
         **kwargs,
     ) -> LLMResponse:
         """获得 LLM 的文本对话结果。会使用当前的模型进行对话。
 
         Args:
-            prompt: 提示词
+            prompt: 提示词，和 contexts 二选一使用，如果都指定，则会将 prompt（以及可能的 image_urls） 作为最新的一条记录添加到 contexts 中
             session_id: 会话 ID(此属性已经被废弃)
             image_urls: 图片 URL 列表
-            tools: Function-calling 工具
-            contexts: 上下文
+            tools: tool set
+            contexts: 上下文，和 prompt 二选一使用
             tool_calls_result: 回传给 LLM 的工具调用结果。参考: https://platform.openai.com/docs/guides/function-calling
             kwargs: 其他参数
 
         Notes:
             - 如果传入了 image_urls，将会在对话时附上图片。如果模型不支持图片输入，将会抛出错误。
             - 如果传入了 tools，将会使用 tools 进行 Function-calling。如果模型不支持 Function-calling，将会抛出错误。
+
         """
         ...
 
     async def text_chat_stream(
         self,
-        prompt: str,
-        session_id: str = None,
-        image_urls: list[str] = None,
-        func_tool: ToolSet = None,
-        contexts: list = None,
-        system_prompt: str = None,
-        tool_calls_result: ToolCallsResult | list[ToolCallsResult] = None,
+        prompt: str | None = None,
+        session_id: str | None = None,
+        image_urls: list[str] | None = None,
+        func_tool: ToolSet | None = None,
+        contexts: list[Message] | list[dict] | None = None,
+        system_prompt: str | None = None,
+        tool_calls_result: ToolCallsResult | list[ToolCallsResult] | None = None,
         model: str | None = None,
         **kwargs,
     ) -> AsyncGenerator[LLMResponse, None]:
         """获得 LLM 的流式文本对话结果。会使用当前的模型进行对话。在生成的最后会返回一次完整的结果。
 
         Args:
-            prompt: 提示词
+            prompt: 提示词，和 contexts 二选一使用，如果都指定，则会将 prompt（以及可能的 image_urls） 作为最新的一条记录添加到 contexts 中
             session_id: 会话 ID(此属性已经被废弃)
             image_urls: 图片 URL 列表
-            tools: Function-calling 工具
-            contexts: 上下文
+            tools: tool set
+            contexts: 上下文，和 prompt 二选一使用
             tool_calls_result: 回传给 LLM 的工具调用结果。参考: https://platform.openai.com/docs/guides/function-calling
             kwargs: 其他参数
 
         Notes:
             - 如果传入了 image_urls，将会在对话时附上图片。如果模型不支持图片输入，将会抛出错误。
             - 如果传入了 tools，将会使用 tools 进行 Function-calling。如果模型不支持 Function-calling，将会抛出错误。
+
         """
         ...
 
-    async def pop_record(self, context: List):
-        """
-        弹出 context 第一条非系统提示词对话记录
-        """
+    async def pop_record(self, context: list):
+        """弹出 context 第一条非系统提示词对话记录"""
         poped = 0
         indexs_to_pop = []
         for idx, record in enumerate(context):
             if record["role"] == "system":
                 continue
-            else:
-                indexs_to_pop.append(idx)
-                poped += 1
-                if poped == 2:
-                    break
+            indexs_to_pop.append(idx)
+            poped += 1
+            if poped == 2:
+                break
 
         for idx in reversed(indexs_to_pop):
             context.pop(idx)
 
+    def _ensure_message_to_dicts(
+        self,
+        messages: list[dict] | list[Message] | None,
+    ) -> list[dict]:
+        """Convert a list of Message objects to a list of dictionaries."""
+        if not messages:
+            return []
+        dicts: list[dict] = []
+        for message in messages:
+            if isinstance(message, Message):
+                dicts.append(message.model_dump())
+            else:
+                dicts.append(message)
+
+        return dicts
+
 
 class STTProvider(AbstractProvider):
     def __init__(self, provider_config: dict, provider_settings: dict) -> None:
@@ -168,7 +190,7 @@ class STTProvider(AbstractProvider):
     @abc.abstractmethod
     async def get_text(self, audio_url: str) -> str:
         """获取音频的文本"""
-        raise NotImplementedError()
+        raise NotImplementedError
 
 
 class TTSProvider(AbstractProvider):
@@ -180,7 +202,7 @@ class TTSProvider(AbstractProvider):
     @abc.abstractmethod
     async def get_audio(self, text: str) -> str:
         """获取文本的音频，返回音频文件路径"""
-        raise NotImplementedError()
+        raise NotImplementedError
 
 
 class EmbeddingProvider(AbstractProvider):
@@ -223,6 +245,7 @@ class EmbeddingProvider(AbstractProvider):
 
         Returns:
             向量列表
+
         """
         semaphore = asyncio.Semaphore(tasks_limit)
         all_embeddings: list[list[float]] = []
@@ -246,7 +269,7 @@ class EmbeddingProvider(AbstractProvider):
                             # 最后一次重试失败，记录失败的批次
                             failed_batches.append((batch_idx, batch_texts))
                             raise Exception(
-                                f"批次 {batch_idx} 处理失败，已重试 {max_retries} 次: {str(e)}"
+                                f"批次 {batch_idx} 处理失败，已重试 {max_retries} 次: {e!s}",
                             )
                         # 等待一段时间后重试，使用指数退避
                         await asyncio.sleep(2**attempt)
@@ -279,7 +302,10 @@ class RerankProvider(AbstractProvider):
 
     @abc.abstractmethod
     async def rerank(
-        self, query: str, documents: list[str], top_n: int | None = None
+        self,
+        query: str,
+        documents: list[str],
+        top_n: int | None = None,
     ) -> list[RerankResult]:
         """获取查询和文档的重排序分数"""
         ...

astrbot/core/provider/register.py

@@ -1,11 +1,11 @@
-from typing import List, Dict
-from .entities import ProviderMetaData, ProviderType
 from astrbot.core import logger
+
+from .entities import ProviderMetaData, ProviderType
 from .func_tool_manager import FuncCall
 
-provider_registry: List[ProviderMetaData] = []
+provider_registry: list[ProviderMetaData] = []
 """维护了通过装饰器注册的 Provider"""
-provider_cls_map: Dict[str, ProviderMetaData] = {}
+provider_cls_map: dict[str, ProviderMetaData] = {}
 """维护了 Provider 类型名称和 ProviderMetadata 的映射"""
 
 llm_tools = FuncCall()
@@ -15,15 +15,15 @@ def register_provider_adapter(
     provider_type_name: str,
     desc: str,
     provider_type: ProviderType = ProviderType.CHAT_COMPLETION,
-    default_config_tmpl: dict = None,
-    provider_display_name: str = None,
+    default_config_tmpl: dict | None = None,
+    provider_display_name: str | None = None,
 ):
     """用于注册平台适配器的带参装饰器"""
 
     def decorator(cls):
         if provider_type_name in provider_cls_map:
             raise ValueError(
-                f"检测到大模型提供商适配器 {provider_type_name} 已经注册，可能发生了大模型提供商适配器类型命名冲突。"
+                f"检测到大模型提供商适配器 {provider_type_name} 已经注册，可能发生了大模型提供商适配器类型命名冲突。",
             )
 
         # 添加必备选项

astrbot/core/provider/sources/anthropic_source.py

@@ -1,23 +1,24 @@
-import json
-import anthropic
 import base64
-from typing import List
+import json
+from collections.abc import AsyncGenerator
 from mimetypes import guess_type
 
+import anthropic
 from anthropic import AsyncAnthropic
 from anthropic.types import Message
 
-from astrbot.core.utils.io import download_image_by_url
-from astrbot.api.provider import Provider
 from astrbot import logger
+from astrbot.api.provider import Provider
+from astrbot.core.provider.entities import LLMResponse
 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
-from astrbot.core.provider.entities import LLMResponse
-from typing import AsyncGenerator
 
 
 @register_provider_adapter(
-    "anthropic_chat_completion", "Anthropic Claude API 提供商适配器"
+    "anthropic_chat_completion",
+    "Anthropic Claude API 提供商适配器",
 )
 class ProviderAnthropic(Provider):
     def __init__(
@@ -33,7 +34,7 @@ class ProviderAnthropic(Provider):
         )
 
         self.chosen_api_key: str = ""
-        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 ""
         self.base_url = provider_config.get("api_base", "https://api.anthropic.com")
         self.timeout = provider_config.get("timeout", 120)
@@ -41,7 +42,9 @@ class ProviderAnthropic(Provider):
             self.timeout = int(self.timeout)
 
         self.client = AsyncAnthropic(
-            api_key=self.chosen_api_key, timeout=self.timeout, base_url=self.base_url
+            api_key=self.chosen_api_key,
+            timeout=self.timeout,
+            base_url=self.base_url,
         )
 
         self.set_model(provider_config["model_config"]["model"])
@@ -54,6 +57,7 @@ class ProviderAnthropic(Provider):
         Returns:
             system_prompt: 系统提示内容
             new_messages: 处理后的消息列表，去除系统提示
+
         """
         system_prompt = ""
         new_messages = []
@@ -73,18 +77,19 @@ class ProviderAnthropic(Provider):
                                 "input": (
                                     json.loads(tool_call["function"]["arguments"])
                                     if isinstance(
-                                        tool_call["function"]["arguments"], str
+                                        tool_call["function"]["arguments"],
+                                        str,
                                     )
                                     else tool_call["function"]["arguments"]
                                 ),
                                 "id": tool_call["id"],
-                            }
+                            },
                         )
                 new_messages.append(
                     {
                         "role": "assistant",
                         "content": blocks,
-                    }
+                    },
                 )
             elif message["role"] == "tool":
                 new_messages.append(
@@ -95,9 +100,9 @@ class ProviderAnthropic(Provider):
                                 "type": "tool_result",
                                 "tool_use_id": message["tool_call_id"],
                                 "content": message["content"],
-                            }
+                            },
                         ],
-                    }
+                    },
                 )
             else:
                 new_messages.append(message)
@@ -135,7 +140,9 @@ class ProviderAnthropic(Provider):
         return llm_response
 
     async def _query_stream(
-        self, payloads: dict, tools: ToolSet | None
+        self,
+        payloads: dict,
+        tools: ToolSet | None,
     ) -> AsyncGenerator[LLMResponse, None]:
         if tools:
             if tool_list := tools.get_func_desc_anthropic_style():
@@ -154,7 +161,9 @@ class ProviderAnthropic(Provider):
                     if event.content_block.type == "text":
                         # 文本块开始
                         yield LLMResponse(
-                            role="assistant", completion_text="", is_chunk=True
+                            role="assistant",
+                            completion_text="",
+                            is_chunk=True,
                         )
                     elif event.content_block.type == "tool_use":
                         # 工具使用块开始，初始化缓冲区
@@ -198,7 +207,7 @@ class ProviderAnthropic(Provider):
                                     "id": tool_info["id"],
                                     "name": tool_info["name"],
                                     "input": tool_info["input"],
-                                }
+                                },
                             )
 
                             yield LLMResponse(
@@ -218,7 +227,9 @@ class ProviderAnthropic(Provider):
 
         # 返回最终的完整结果
         final_response = LLMResponse(
-            role="assistant", completion_text=final_text, is_chunk=False
+            role="assistant",
+            completion_text=final_text,
+            is_chunk=False,
         )
 
         if final_tool_calls:
@@ -232,7 +243,7 @@ class ProviderAnthropic(Provider):
 
     async def text_chat(
         self,
-        prompt,
+        prompt=None,
         session_id=None,
         image_urls=None,
         func_tool=None,
@@ -244,8 +255,13 @@ class ProviderAnthropic(Provider):
     ) -> LLMResponse:
         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})
 
@@ -295,8 +311,12 @@ class ProviderAnthropic(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})
 
@@ -326,7 +346,7 @@ class ProviderAnthropic(Provider):
         async for llm_response in self._query_stream(payloads, func_tool):
             yield llm_response
 
-    async def assemble_context(self, text: str, image_urls: List[str] | None = None):
+    async def assemble_context(self, text: str, image_urls: list[str] | None = None):
         """组装上下文，支持文本和图片"""
         if not image_urls:
             return {"role": "user", "content": text}
@@ -365,15 +385,13 @@ class ProviderAnthropic(Provider):
                             else image_data
                         ),
                     },
-                }
+                },
             )
 
         return {"role": "user", "content": content}
 
     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:
@@ -384,7 +402,7 @@ class ProviderAnthropic(Provider):
     def get_current_key(self) -> str:
         return self.chosen_api_key
 
-    async def get_models(self) -> List[str]:
+    async def get_models(self) -> list[str]:
         models_str = []
         models = await self.client.models.list()
         models = sorted(models.data, key=lambda x: x.id)

astrbot/core/provider/sources/azure_tts_source.py

@@ -1,15 +1,15 @@
-import uuid
-import time
+import asyncio
+import hashlib
 import json
 import re
-import hashlib
-import random
-import asyncio
+import secrets
+import time
+import uuid
 from pathlib import Path
-from typing import Dict
 from xml.sax.saxutils import escape
 
 from httpx import AsyncClient, Timeout
+
 from astrbot.core.config.default import VERSION
 
 from ..entities import ProviderType
@@ -21,7 +21,7 @@ TEMP_DIR.mkdir(parents=True, exist_ok=True)
 
 
 class OTTSProvider:
-    def __init__(self, config: Dict):
+    def __init__(self, config: dict):
         self.skey = config["OTTS_SKEY"]
         self.api_url = config["OTTS_URL"]
         self.auth_time_url = config["OTTS_AUTH_TIME"]
@@ -54,11 +54,13 @@ class OTTSProvider:
     async def _generate_signature(self) -> str:
         await self._sync_time()
         timestamp = int(time.time()) + self.time_offset
-        nonce = "".join(random.choices("abcdefghijklmnopqrstuvwxyz0123456789", k=10))
+        nonce = "".join(
+            secrets.choice("abcdefghijklmnopqrstuvwxyz0123456789") for _ in range(10)
+        )
         path = re.sub(r"^https?://[^/]+", "", self.api_url) or "/"
         return f"{timestamp}-{nonce}-0-{hashlib.md5(f'{path}-{timestamp}-{nonce}-0-{self.skey}'.encode()).hexdigest()}"
 
-    async def get_audio(self, text: str, voice_params: Dict) -> str:
+    async def get_audio(self, text: str, voice_params: dict) -> str:
         file_path = TEMP_DIR / f"otts-{uuid.uuid4()}.wav"
         signature = await self._generate_signature()
         for attempt in range(self.retry_count):
@@ -86,7 +88,7 @@ class OTTSProvider:
                 return str(file_path.resolve())
             except Exception as e:
                 if attempt == self.retry_count - 1:
-                    raise RuntimeError(f"OTTS请求失败: {str(e)}") from e
+                    raise RuntimeError(f"OTTS请求失败: {e!s}") from e
                 await asyncio.sleep(0.5 * (attempt + 1))
 
 
@@ -94,7 +96,8 @@ class AzureNativeProvider(TTSProvider):
     def __init__(self, provider_config: dict, provider_settings: dict):
         super().__init__(provider_config, provider_settings)
         self.subscription_key = provider_config.get(
-            "azure_tts_subscription_key", ""
+            "azure_tts_subscription_key",
+            "",
         ).strip()
         if not re.fullmatch(r"^[a-zA-Z0-9]{32}$", self.subscription_key):
             raise ValueError("无效的Azure订阅密钥")
@@ -119,7 +122,7 @@ class AzureNativeProvider(TTSProvider):
                 "User-Agent": f"AstrBot/{VERSION}",
                 "Content-Type": "application/ssml+xml",
                 "X-Microsoft-OutputFormat": "riff-48khz-16bit-mono-pcm",
-            }
+            },
         )
         return self
 
@@ -132,7 +135,8 @@ class AzureNativeProvider(TTSProvider):
             f"https://{self.region}.api.cognitive.microsoft.com/sts/v1.0/issuetoken"
         )
         response = await self.client.post(
-            token_url, headers={"Ocp-Apim-Subscription-Key": self.subscription_key}
+            token_url,
+            headers={"Ocp-Apim-Subscription-Key": self.subscription_key},
         )
         response.raise_for_status()
         self.token = response.text