AstrBot 4.1.7__tar.gz → 4.2.0__tar.gz

{astrbot-4.1.7 → astrbot-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AstrBot
-Version: 4.1.7
+Version: 4.2.0
 Summary: 易上手的多平台 LLM 聊天机器人及开发框架
 License-File: LICENSE
 Requires-Python: >=3.10

{astrbot-4.1.7 → astrbot-4.2.0}/astrbot/core/config/default.py

@@ -6,7 +6,7 @@ import os
 
 from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 
-VERSION = "4.1.7"
+VERSION = "4.2.0"
 DB_PATH = os.path.join(get_astrbot_data_path(), "data_v4.db")
 
 # 默认配置
@@ -869,6 +869,18 @@ CONFIG_METADATA_2 = {
                         "timeout": 60,
                         "hint": "请确保你在 AstrBot 里设置的 APP 类型和 Dify 里面创建的应用的类型一致！",
                     },
+                    "Coze": {
+                        "id": "coze",
+                        "provider": "coze",
+                        "provider_type": "chat_completion",
+                        "type": "coze",
+                        "enable": True,
+                        "coze_api_key": "",
+                        "bot_id": "",
+                        "coze_api_base": "https://api.coze.cn",
+                        "timeout": 60,
+                        "auto_save_history": True,
+                    },
                     "阿里云百炼应用": {
                         "id": "dashscope",
                         "provider": "dashscope",
@@ -1735,6 +1747,26 @@ CONFIG_METADATA_2 = {
                         "hint": "发送的消息文本内容对应的输入变量名。默认为 astrbot_text_query。",
                         "obvious": True,
                     },
+                    "coze_api_key": {
+                        "description": "Coze API Key",
+                        "type": "string",
+                        "hint": "Coze API 密钥，用于访问 Coze 服务。",
+                    },
+                    "bot_id": {
+                        "description": "Bot ID",
+                        "type": "string",
+                        "hint": "Coze 机器人的 ID，在 Coze 平台上创建机器人后获得。",
+                    },
+                    "coze_api_base": {
+                        "description": "API Base URL",
+                        "type": "string",
+                        "hint": "Coze API 的基础 URL 地址，默认为 https://api.coze.cn",
+                    },
+                    "auto_save_history": {
+                        "description": "由 Coze 管理对话记录",
+                        "type": "bool",
+                        "hint": "启用后，将由 Coze 进行对话历史记录管理, 此时 AstrBot 本地保存的上下文不会生效(仅供浏览), 对 AstrBot 的上下文进行的操作也不会生效。如果为禁用, 则使用 AstrBot 管理上下文。",
+                    },
                 },
             },
             "provider_settings": {

{astrbot-4.1.7 → astrbot-4.2.0}/astrbot/core/conversation_mgr.py

@@ -87,17 +87,25 @@ class ConversationManager:
             unified_msg_origin (str): 统一的消息来源字符串。格式为 platform_name:message_type:session_id
             conversation_id (str): 对话 ID, 是 uuid 格式的字符串
         """
-        f = False
         if not conversation_id:
             conversation_id = self.session_conversations.get(unified_msg_origin)
-            if conversation_id:
-                f = True
         if conversation_id:
             await self.db.delete_conversation(cid=conversation_id)
-            if f:
+            curr_cid = await self.get_curr_conversation_id(unified_msg_origin)
+            if curr_cid == conversation_id:
                 self.session_conversations.pop(unified_msg_origin, None)
                 await sp.session_remove(unified_msg_origin, "sel_conv_id")
 
+    async def delete_conversations_by_user_id(self, unified_msg_origin: str):
+        """删除会话的所有对话
+
+        Args:
+            unified_msg_origin (str): 统一的消息来源字符串。格式为 platform_name:message_type:session_id
+        """
+        await self.db.delete_conversations_by_user_id(user_id=unified_msg_origin)
+        self.session_conversations.pop(unified_msg_origin, None)
+        await sp.session_remove(unified_msg_origin, "sel_conv_id")
+
     async def get_curr_conversation_id(self, unified_msg_origin: str) -> str | None:
         """获取会话当前的对话 ID
 

{astrbot-4.1.7 → astrbot-4.2.0}/astrbot/core/db/__init__.py

@@ -154,6 +154,11 @@ class BaseDatabase(abc.ABC):
         """Delete a conversation by its ID."""
         ...
 
+    @abc.abstractmethod
+    async def delete_conversations_by_user_id(self, user_id: str) -> None:
+        """Delete all conversations for a specific user."""
+        ...
+
     @abc.abstractmethod
     async def insert_platform_message_history(
         self,

{astrbot-4.1.7 → astrbot-4.2.0}/astrbot/core/db/sqlite.py

@@ -249,6 +249,14 @@ class SQLiteDatabase(BaseDatabase):
                     delete(ConversationV2).where(ConversationV2.conversation_id == cid)
                 )
 
+    async def delete_conversations_by_user_id(self, user_id: str) -> None:
+        async with self.get_db() as session:
+            session: AsyncSession
+            async with session.begin():
+                await session.execute(
+                    delete(ConversationV2).where(ConversationV2.user_id == user_id)
+                )
+
     async def insert_platform_message_history(
         self,
         platform_id,

{astrbot-4.1.7 → astrbot-4.2.0}/astrbot/core/pipeline/process_stage/method/llm_request.py

@@ -291,13 +291,6 @@ async def run_agent(
             else:
                 astr_event.set_result(MessageEventResult().message(err_msg))
             return
-        asyncio.create_task(
-            Metric.upload(
-                llm_tick=1,
-                model_name=agent_runner.provider.get_model(),
-                provider_type=agent_runner.provider.meta().type,
-            )
-        )
 
 
 class LLMRequestSubStage(Stage):
@@ -524,6 +517,14 @@ class LLMRequestSubStage(Stage):
         if event.get_platform_name() == "webchat":
             asyncio.create_task(self._handle_webchat(event, req, provider))
 
+        asyncio.create_task(
+            Metric.upload(
+                llm_tick=1,
+                model_name=agent_runner.provider.get_model(),
+                provider_type=agent_runner.provider.meta().type,
+            )
+        )
+
     async def _handle_webchat(
         self, event: AstrMessageEvent, req: ProviderRequest, prov: Provider
     ):
@@ -536,7 +537,23 @@ class LLMRequestSubStage(Stage):
             latest_pair = messages[-2:]
             if not latest_pair:
                 return
-            cleaned_text = "User: " + latest_pair[0].get("content", "").strip()
+            content = latest_pair[0].get("content", "")
+            if isinstance(content, list):
+                # 多模态
+                text_parts = []
+                for item in content:
+                    if isinstance(item, dict):
+                        if item.get("type") == "text":
+                            text_parts.append(item.get("text", ""))
+                        elif item.get("type") == "image":
+                            text_parts.append("[图片]")
+                    elif isinstance(item, str):
+                        text_parts.append(item)
+                cleaned_text = "User: " + " ".join(text_parts).strip()
+            elif isinstance(content, str):
+                cleaned_text = "User: " + content.strip()
+            else:
+                return
             logger.debug(f"WebChat 对话标题生成请求，清理后的文本: {cleaned_text}")
             llm_resp = await prov.text_chat(
                 system_prompt="You are expert in summarizing user's query.",

{astrbot-4.1.7 → astrbot-4.2.0}/astrbot/core/pipeline/session_status_check/stage.py

@@ -11,7 +11,8 @@ class SessionStatusCheckStage(Stage):
     """检查会话是否整体启用"""
 
     async def initialize(self, ctx: PipelineContext) -> None:
-        pass
+        self.ctx = ctx
+        self.conv_mgr = ctx.plugin_manager.context.conversation_manager
 
     async def process(
         self, event: AstrMessageEvent
@@ -19,4 +20,14 @@ class SessionStatusCheckStage(Stage):
         # 检查会话是否整体启用
         if not SessionServiceManager.is_session_enabled(event.unified_msg_origin):
             logger.debug(f"会话 {event.unified_msg_origin} 已被关闭，已终止事件传播。")
+
+            # workaround for #2309
+            conv_id = await self.conv_mgr.get_curr_conversation_id(
+                event.unified_msg_origin
+            )
+            if not conv_id:
+                await self.conv_mgr.new_conversation(
+                    event.unified_msg_origin, platform_id=event.get_platform_id()
+                )
+
             event.stop_event()

{astrbot-4.1.7 → astrbot-4.2.0}/astrbot/core/pipeline/waking_check/stage.py

@@ -5,6 +5,7 @@ from astrbot.core.message.components import At, AtAll, Reply
 from astrbot.core.message.message_event_result import MessageChain, MessageEventResult
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.star.filter.permission import PermissionTypeFilter
+from astrbot.core.star.filter.command_group import CommandGroupFilter
 from astrbot.core.star.session_plugin_manager import SessionPluginManager
 from astrbot.core.star.star import star_map
 from astrbot.core.star.star_handler import EventType, star_handlers_registry
@@ -170,11 +171,15 @@ class WakingCheckStage(Stage):
                 is_wake = True
                 event.is_wake = True
 
-                activated_handlers.append(handler)
-                if "parsed_params" in event.get_extra():
-                    handlers_parsed_params[handler.handler_full_name] = event.get_extra(
-                        "parsed_params"
-                    )
+                is_group_cmd_handler = any(
+                    isinstance(f, CommandGroupFilter) for f in handler.event_filters
+                )
+                if not is_group_cmd_handler:
+                    activated_handlers.append(handler)
+                    if "parsed_params" in event.get_extra(default={}):
+                        handlers_parsed_params[handler.handler_full_name] = (
+                            event.get_extra("parsed_params")
+                        )
 
             event._extras.pop("parsed_params", None)
 

{astrbot-4.1.7 → astrbot-4.2.0}/astrbot/core/platform/astr_message_event.py

@@ -4,7 +4,7 @@ import re
 import hashlib
 import uuid
 
-from typing import List, Union, Optional, AsyncGenerator
+from typing import List, Union, Optional, AsyncGenerator, TypeVar, Any
 
 from astrbot import logger
 from astrbot.core.db.po import Conversation
@@ -26,6 +26,8 @@ from .astrbot_message import AstrBotMessage, Group
 from .platform_metadata import PlatformMetadata
 from .message_session import MessageSession, MessageSesion  # noqa
 
+_VT = TypeVar("_VT")
+
 
 class AstrMessageEvent(abc.ABC):
     def __init__(
@@ -49,7 +51,7 @@ class AstrMessageEvent(abc.ABC):
         """是否唤醒(是否通过 WakingStage)"""
         self.is_at_or_wake_command = False
         """是否是 At 机器人或者带有唤醒词或者是私聊(插件注册的事件监听器会让 is_wake 设为 True, 但是不会让这个属性置为 True)"""
-        self._extras = {}
+        self._extras: dict[str, Any] = {}
         self.session = MessageSesion(
             platform_name=platform_meta.id,
             message_type=message_obj.type,
@@ -57,7 +59,7 @@ class AstrMessageEvent(abc.ABC):
         )
         self.unified_msg_origin = str(self.session)
         """统一的消息来源字符串。格式为 platform_name:message_type:session_id"""
-        self._result: MessageEventResult = None
+        self._result: MessageEventResult | None = None
         """消息事件的结果"""
 
         self._has_send_oper = False
@@ -173,13 +175,15 @@ class AstrMessageEvent(abc.ABC):
         """
         self._extras[key] = value
 
-    def get_extra(self, key=None):
+    def get_extra(
+        self, key: str | None = None, default: _VT = None
+    ) -> dict[str, Any] | _VT:
         """
         获取额外的信息。
         """
         if key is None:
             return self._extras
-        return self._extras.get(key, None)
+        return self._extras.get(key, default)
 
     def clear_extra(self):
         """

{astrbot-4.1.7 → astrbot-4.2.0}/astrbot/core/platform/sources/wecom/wecom_adapter.py

@@ -185,6 +185,7 @@ class WecomPlatformAdapter(Platform):
         return PlatformMetadata(
             "wecom",
             "wecom 适配器",
+            id=self.config.get("id", "wecom"),
         )
 
     @override

{astrbot-4.1.7 → astrbot-4.2.0}/astrbot/core/platform/sources/weixin_official_account/weixin_offacc_adapter.py

@@ -184,6 +184,7 @@ class WeixinOfficialAccountPlatformAdapter(Platform):
         return PlatformMetadata(
             "weixin_official_account",
             "微信公众平台 适配器",
+            id=self.config.get("id", "weixin_official_account"),
         )
 
     @override

{astrbot-4.1.7 → astrbot-4.2.0}/astrbot/core/provider/manager.py

@@ -234,6 +234,8 @@ class ProviderManager:
                     )
                 case "dify":
                     from .sources.dify_source import ProviderDify as ProviderDify
+                case "coze":
+                    from .sources.coze_source import ProviderCoze as ProviderCoze
                 case "dashscope":
                     from .sources.dashscope_source import (
                         ProviderDashscope as ProviderDashscope,

astrbot-4.2.0/astrbot/core/provider/sources/coze_api_client.py

@@ -0,0 +1,314 @@
+import json
+import asyncio
+import aiohttp
+import io
+from typing import Dict, List, Any, AsyncGenerator
+from astrbot.core import logger
+
+
+class CozeAPIClient:
+    def __init__(self, api_key: str, api_base: str = "https://api.coze.cn"):
+        self.api_key = api_key
+        self.api_base = api_base
+        self.session = None
+
+    async def _ensure_session(self):
+        """确保HTTP session存在"""
+        if self.session is None:
+            connector = aiohttp.TCPConnector(
+                ssl=False if self.api_base.startswith("http://") else True,
+                limit=100,
+                limit_per_host=30,
+                keepalive_timeout=30,
+                enable_cleanup_closed=True,
+            )
+            timeout = aiohttp.ClientTimeout(
+                total=120,  # 默认超时时间
+                connect=30,
+                sock_read=120,
+            )
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Accept": "text/event-stream",
+            }
+            self.session = aiohttp.ClientSession(
+                headers=headers, timeout=timeout, connector=connector
+            )
+        return self.session
+
+    async def upload_file(
+        self,
+        file_data: bytes,
+    ) -> str:
+        """上传文件到 Coze 并返回 file_id
+
+        Args:
+            file_data (bytes): 文件的二进制数据
+        Returns:
+            str: 上传成功后返回的 file_id
+        """
+        session = await self._ensure_session()
+        url = f"{self.api_base}/v1/files/upload"
+
+        try:
+            file_io = io.BytesIO(file_data)
+            async with session.post(
+                url,
+                data={
+                    "file": file_io,
+                },
+                timeout=aiohttp.ClientTimeout(total=60),
+            ) as response:
+                if response.status == 401:
+                    raise Exception("Coze API 认证失败，请检查 API Key 是否正确")
+
+                response_text = await response.text()
+                logger.debug(
+                    f"文件上传响应状态: {response.status}, 内容: {response_text}"
+                )
+
+                if response.status != 200:
+                    raise Exception(
+                        f"文件上传失败，状态码: {response.status}, 响应: {response_text}"
+                    )
+
+                try:
+                    result = await response.json()
+                except json.JSONDecodeError:
+                    raise Exception(f"文件上传响应解析失败: {response_text}")
+
+                if result.get("code") != 0:
+                    raise Exception(f"文件上传失败: {result.get('msg', '未知错误')}")
+
+                file_id = result["data"]["id"]
+                logger.debug(f"[Coze] 图片上传成功，file_id: {file_id}")
+                return file_id
+
+        except asyncio.TimeoutError:
+            logger.error("文件上传超时")
+            raise Exception("文件上传超时")
+        except Exception as e:
+            logger.error(f"文件上传失败: {str(e)}")
+            raise Exception(f"文件上传失败: {str(e)}")
+
+    async def download_image(self, image_url: str) -> bytes:
+        """下载图片并返回字节数据
+
+        Args:
+            image_url (str): 图片的URL
+        Returns:
+            bytes: 图片的二进制数据
+        """
+        session = await self._ensure_session()
+
+        try:
+            async with session.get(image_url) as response:
+                if response.status != 200:
+                    raise Exception(f"下载图片失败，状态码: {response.status}")
+
+                image_data = await response.read()
+                return image_data
+
+        except Exception as e:
+            logger.error(f"下载图片失败 {image_url}: {str(e)}")
+            raise Exception(f"下载图片失败: {str(e)}")
+
+    async def chat_messages(
+        self,
+        bot_id: str,
+        user_id: str,
+        additional_messages: List[Dict] | None = None,
+        conversation_id: str | None = None,
+        auto_save_history: bool = True,
+        stream: bool = True,
+        timeout: float = 120,
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """发送聊天消息并返回流式响应
+
+        Args:
+            bot_id: Bot ID
+            user_id: 用户ID
+            additional_messages: 额外消息列表
+            conversation_id: 会话ID
+            auto_save_history: 是否自动保存历史
+            stream: 是否流式响应
+            timeout: 超时时间
+        """
+        session = await self._ensure_session()
+        url = f"{self.api_base}/v3/chat"
+
+        payload = {
+            "bot_id": bot_id,
+            "user_id": user_id,
+            "stream": stream,
+            "auto_save_history": auto_save_history,
+        }
+
+        if additional_messages:
+            payload["additional_messages"] = additional_messages
+
+        params = {}
+        if conversation_id:
+            params["conversation_id"] = conversation_id
+
+        logger.debug(f"Coze chat_messages payload: {payload}, params: {params}")
+
+        try:
+            async with session.post(
+                url,
+                json=payload,
+                params=params,
+                timeout=aiohttp.ClientTimeout(total=timeout),
+            ) as response:
+                if response.status == 401:
+                    raise Exception("Coze API 认证失败，请检查 API Key 是否正确")
+
+                if response.status != 200:
+                    raise Exception(f"Coze API 流式请求失败，状态码: {response.status}")
+
+                # SSE
+                buffer = ""
+                event_type = None
+                event_data = None
+
+                async for chunk in response.content:
+                    if chunk:
+                        buffer += chunk.decode("utf-8", errors="ignore")
+                        lines = buffer.split("\n")
+                        buffer = lines[-1]
+
+                        for line in lines[:-1]:
+                            line = line.strip()
+
+                            if not line:
+                                if event_type and event_data:
+                                    yield {"event": event_type, "data": event_data}
+                                    event_type = None
+                                    event_data = None
+                            elif line.startswith("event:"):
+                                event_type = line[6:].strip()
+                            elif line.startswith("data:"):
+                                data_str = line[5:].strip()
+                                if data_str and data_str != "[DONE]":
+                                    try:
+                                        event_data = json.loads(data_str)
+                                    except json.JSONDecodeError:
+                                        event_data = {"content": data_str}
+
+        except asyncio.TimeoutError:
+            raise Exception(f"Coze API 流式请求超时 ({timeout}秒)")
+        except Exception as e:
+            raise Exception(f"Coze API 流式请求失败: {str(e)}")
+
+    async def clear_context(self, conversation_id: str):
+        """清空会话上下文
+
+        Args:
+            conversation_id: 会话ID
+        Returns:
+            dict: API响应结果
+        """
+        session = await self._ensure_session()
+        url = f"{self.api_base}/v3/conversation/message/clear_context"
+        payload = {"conversation_id": conversation_id}
+
+        try:
+            async with session.post(url, json=payload) as response:
+                response_text = await response.text()
+
+                if response.status == 401:
+                    raise Exception("Coze API 认证失败，请检查 API Key 是否正确")
+
+                if response.status != 200:
+                    raise Exception(f"Coze API 请求失败，状态码: {response.status}")
+
+                try:
+                    return json.loads(response_text)
+                except json.JSONDecodeError:
+                    raise Exception("Coze API 返回非JSON格式")
+
+        except asyncio.TimeoutError:
+            raise Exception("Coze API 请求超时")
+        except aiohttp.ClientError as e:
+            raise Exception(f"Coze API 请求失败: {str(e)}")
+
+    async def get_message_list(
+        self,
+        conversation_id: str,
+        order: str = "desc",
+        limit: int = 10,
+        offset: int = 0,
+    ):
+        """获取消息列表
+
+        Args:
+            conversation_id: 会话ID
+            order: 排序方式 (asc/desc)
+            limit: 限制数量
+            offset: 偏移量
+        Returns:
+            dict: API响应结果
+        """
+        session = await self._ensure_session()
+        url = f"{self.api_base}/v3/conversation/message/list"
+        params = {
+            "conversation_id": conversation_id,
+            "order": order,
+            "limit": limit,
+            "offset": offset,
+        }
+
+        try:
+            async with session.get(url, params=params) as response:
+                response.raise_for_status()
+                return await response.json()
+
+        except Exception as e:
+            logger.error(f"获取Coze消息列表失败: {str(e)}")
+            raise Exception(f"获取Coze消息列表失败: {str(e)}")
+
+    async def close(self):
+        """关闭会话"""
+        if self.session:
+            await self.session.close()
+            self.session = None
+
+
+if __name__ == "__main__":
+    import os
+    import asyncio
+
+    async def test_coze_api_client():
+        api_key = os.getenv("COZE_API_KEY", "")
+        bot_id = os.getenv("COZE_BOT_ID", "")
+        client = CozeAPIClient(api_key=api_key)
+
+        try:
+            with open("README.md", "rb") as f:
+                file_data = f.read()
+            file_id = await client.upload_file(file_data)
+            print(f"Uploaded file_id: {file_id}")
+            async for event in client.chat_messages(
+                bot_id=bot_id,
+                user_id="test_user",
+                additional_messages=[
+                    {
+                        "role": "user",
+                        "content": json.dumps(
+                            [
+                                {"type": "text", "text": "这是什么"},
+                                {"type": "file", "file_id": file_id},
+                            ],
+                            ensure_ascii=False,
+                        ),
+                        "content_type": "object_string",
+                    },
+                ],
+                stream=True,
+            ):
+                print(f"Event: {event}")
+
+        finally:
+            await client.close()
+
+    asyncio.run(test_coze_api_client())