AstrBot 4.5.8__py3-none-any.whl → 4.6.1__py3-none-any.whl

astrbot/core/provider/sources/bailian_rerank_source.py

@@ -0,0 +1,236 @@
+import os
+
+import aiohttp
+
+from astrbot import logger
+
+from ..entities import ProviderType, RerankResult
+from ..provider import RerankProvider
+from ..register import register_provider_adapter
+
+
+class BailianRerankError(Exception):
+    """百炼重排序服务异常基类"""
+
+    pass
+
+
+class BailianAPIError(BailianRerankError):
+    """百炼API返回错误"""
+
+    pass
+
+
+class BailianNetworkError(BailianRerankError):
+    """百炼网络请求错误"""
+
+    pass
+
+
+@register_provider_adapter(
+    "bailian_rerank", "阿里云百炼文本排序适配器", provider_type=ProviderType.RERANK
+)
+class BailianRerankProvider(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
+
+        # API配置
+        self.api_key = provider_config.get("rerank_api_key") or os.getenv(
+            "DASHSCOPE_API_KEY", ""
+        )
+        if not self.api_key:
+            raise ValueError("阿里云百炼 API Key 不能为空。")
+
+        self.model = provider_config.get("rerank_model", "qwen3-rerank")
+        self.timeout = provider_config.get("timeout", 30)
+        self.return_documents = provider_config.get("return_documents", False)
+        self.instruct = provider_config.get("instruct", "")
+
+        self.base_url = provider_config.get(
+            "rerank_api_base",
+            "https://dashscope.aliyuncs.com/api/v1/services/rerank/text-rerank/text-rerank",
+        )
+
+        # 设置HTTP客户端
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        self.client = aiohttp.ClientSession(
+            headers=headers, timeout=aiohttp.ClientTimeout(total=self.timeout)
+        )
+
+        # 设置模型名称
+        self.set_model(self.model)
+
+        logger.info(f"AstrBot 百炼 Rerank 初始化完成。模型: {self.model}")
+
+    def _build_payload(
+        self, query: str, documents: list[str], top_n: int | None
+    ) -> dict:
+        """构建请求载荷
+
+        Args:
+            query: 查询文本
+            documents: 文档列表
+            top_n: 返回前N个结果，如果为None则返回所有结果
+
+        Returns:
+            请求载荷字典
+        """
+        base = {"model": self.model, "input": {"query": query, "documents": documents}}
+
+        params = {
+            k: v
+            for k, v in [
+                ("top_n", top_n if top_n is not None and top_n > 0 else None),
+                ("return_documents", True if self.return_documents else None),
+                (
+                    "instruct",
+                    self.instruct
+                    if self.instruct and self.model == "qwen3-rerank"
+                    else None,
+                ),
+            ]
+            if v is not None
+        }
+
+        if params:
+            base["parameters"] = params
+
+        return base
+
+    def _parse_results(self, data: dict) -> list[RerankResult]:
+        """解析API响应结果
+
+        Args:
+            data: API响应数据
+
+        Returns:
+            重排序结果列表
+
+        Raises:
+            BailianAPIError: API返回错误
+            KeyError: 结果缺少必要字段
+        """
+        # 检查响应状态
+        if data.get("code", "200") != "200":
+            raise BailianAPIError(
+                f"百炼 API 错误: {data.get('code')} – {data.get('message', '')}"
+            )
+
+        results = data.get("output", {}).get("results", [])
+        if not results:
+            logger.warning(f"百炼 Rerank 返回空结果: {data}")
+            return []
+
+        # 转换为RerankResult对象，使用.get()避免KeyError
+        rerank_results = []
+        for idx, result in enumerate(results):
+            try:
+                index = result.get("index", idx)
+                relevance_score = result.get("relevance_score", 0.0)
+
+                if relevance_score is None:
+                    logger.warning(f"结果 {idx} 缺少 relevance_score，使用默认值 0.0")
+                    relevance_score = 0.0
+
+                rerank_result = RerankResult(
+                    index=index, relevance_score=relevance_score
+                )
+                rerank_results.append(rerank_result)
+            except Exception as e:
+                logger.warning(f"解析结果 {idx} 时出错: {e}, result={result}")
+                continue
+
+        return rerank_results
+
+    def _log_usage(self, data: dict) -> None:
+        """记录使用量信息
+
+        Args:
+            data: API响应数据
+        """
+        tokens = data.get("usage", {}).get("total_tokens", 0)
+        if tokens > 0:
+            logger.debug(f"百炼 Rerank 消耗 Token: {tokens}")
+
+    async def rerank(
+        self,
+        query: str,
+        documents: list[str],
+        top_n: int | None = None,
+    ) -> list[RerankResult]:
+        """
+        对文档进行重排序
+
+        Args:
+            query: 查询文本
+            documents: 待排序的文档列表
+            top_n: 返回前N个结果，如果为None则使用配置中的默认值
+
+        Returns:
+            重排序结果列表
+        """
+        if not documents:
+            logger.warning("文档列表为空，返回空结果")
+            return []
+
+        if not query.strip():
+            logger.warning("查询文本为空，返回空结果")
+            return []
+
+        # 检查限制
+        if len(documents) > 500:
+            logger.warning(
+                f"文档数量({len(documents)})超过限制(500)，将截断前500个文档"
+            )
+            documents = documents[:500]
+
+        try:
+            # 构建请求载荷，如果top_n为None则返回所有重排序结果
+            payload = self._build_payload(query, documents, top_n)
+
+            logger.debug(
+                f"百炼 Rerank 请求: query='{query[:50]}...', 文档数量={len(documents)}"
+            )
+
+            # 发送请求
+            async with self.client.post(self.base_url, json=payload) as response:
+                response.raise_for_status()
+                response_data = await response.json()
+
+                # 解析结果并记录使用量
+                results = self._parse_results(response_data)
+                self._log_usage(response_data)
+
+                logger.debug(f"百炼 Rerank 成功返回 {len(results)} 个结果")
+
+                return results
+
+        except aiohttp.ClientError as e:
+            error_msg = f"网络请求失败: {e}"
+            logger.error(f"百炼 Rerank 网络请求失败: {e}")
+            raise BailianNetworkError(error_msg) from e
+        except BailianRerankError:
+            raise
+        except Exception as e:
+            error_msg = f"重排序失败: {e}"
+            logger.error(f"百炼 Rerank 处理失败: {e}")
+            raise BailianRerankError(error_msg) from e
+
+    async def terminate(self) -> None:
+        """关闭HTTP客户端会话."""
+        if self.client:
+            logger.info("关闭 百炼 Rerank 客户端会话")
+            try:
+                await self.client.close()
+            except Exception as e:
+                logger.error(f"关闭 百炼 Rerank 客户端时出错: {e}")
+            finally:
+                self.client = None

astrbot/core/provider/sources/gemini_source.py

@@ -290,13 +290,24 @@ class ProviderGoogleGenAI(Provider):
                     parts = [types.Part.from_text(text=content)]
                     append_or_extend(gemini_contents, parts, types.ModelContent)
                 elif not native_tool_enabled and "tool_calls" in message:
-                    parts = [
-                        types.Part.from_function_call(
+                    parts = []
+                    for tool in message["tool_calls"]:
+                        part = types.Part.from_function_call(
                             name=tool["function"]["name"],
                             args=json.loads(tool["function"]["arguments"]),
                         )
-                        for tool in message["tool_calls"]
-                    ]
+                        # we should set thought_signature back to part if exists
+                        # for more info about thought_signature, see:
+                        # https://ai.google.dev/gemini-api/docs/thought-signatures
+                        if "extra_content" in tool and tool["extra_content"]:
+                            ts_bs64 = (
+                                tool["extra_content"]
+                                .get("google", {})
+                                .get("thought_signature")
+                            )
+                            if ts_bs64:
+                                part.thought_signature = base64.b64decode(ts_bs64)
+                        parts.append(part)
                     append_or_extend(gemini_contents, parts, types.ModelContent)
                 else:
                     logger.warning("assistant 角色的消息内容为空，已添加空格占位")
@@ -393,10 +404,15 @@ class ProviderGoogleGenAI(Provider):
                 llm_response.role = "tool"
                 llm_response.tools_call_name.append(part.function_call.name)
                 llm_response.tools_call_args.append(part.function_call.args)
-                # gemini 返回的 function_call.id 可能为 None
-                llm_response.tools_call_ids.append(
-                    part.function_call.id or part.function_call.name,
-                )
+                # function_call.id might be None, use name as fallback
+                tool_call_id = part.function_call.id or part.function_call.name
+                llm_response.tools_call_ids.append(tool_call_id)
+                # extra_content
+                if part.thought_signature:
+                    ts_bs64 = base64.b64encode(part.thought_signature).decode("utf-8")
+                    llm_response.tools_call_extra_content[tool_call_id] = {
+                        "google": {"thought_signature": ts_bs64}
+                    }
             elif (
                 part.inline_data
                 and part.inline_data.mime_type
@@ -435,6 +451,7 @@ class ProviderGoogleGenAI(Provider):
                     contents=conversation,
                     config=config,
                 )
+                logger.debug(f"genai result: {result}")
 
                 if not result.candidates:
                     logger.error(f"请求失败, 返回的 candidates 为空: {result}")

astrbot/core/provider/sources/openai_source.py

@@ -8,7 +8,7 @@ import re
 from collections.abc import AsyncGenerator
 
 from openai import AsyncAzureOpenAI, AsyncOpenAI
-from openai._exceptions import NotFoundError, UnprocessableEntityError
+from openai._exceptions import NotFoundError
 from openai.lib.streaming.chat._completions import ChatCompletionStreamState
 from openai.types.chat.chat_completion import ChatCompletion
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
@@ -279,6 +279,7 @@ class ProviderOpenAIOfficial(Provider):
             args_ls = []
             func_name_ls = []
             tool_call_ids = []
+            tool_call_extra_content_dict = {}
             for tool_call in choice.message.tool_calls:
                 if isinstance(tool_call, str):
                     # workaround for #1359
@@ -296,11 +297,16 @@ class ProviderOpenAIOfficial(Provider):
                         args_ls.append(args)
                         func_name_ls.append(tool_call.function.name)
                         tool_call_ids.append(tool_call.id)
+
+                        # gemini-2.5 / gemini-3 series extra_content handling
+                        extra_content = getattr(tool_call, "extra_content", None)
+                        if extra_content is not None:
+                            tool_call_extra_content_dict[tool_call.id] = extra_content
             llm_response.role = "tool"
             llm_response.tools_call_args = args_ls
             llm_response.tools_call_name = func_name_ls
             llm_response.tools_call_ids = tool_call_ids
-
+            llm_response.tools_call_extra_content = tool_call_extra_content_dict
         # specially handle finish reason
         if choice.finish_reason == "content_filter":
             raise Exception(
@@ -353,7 +359,7 @@ class ProviderOpenAIOfficial(Provider):
 
         payloads = {"messages": context_query, **model_config}
 
-        # xAI 原生搜索参数（最小侵入地在此处注入）
+        # xAI origin search tool inject
         self._maybe_inject_xai_search(payloads, **kwargs)
 
         return payloads, context_query
@@ -475,12 +481,6 @@ class ProviderOpenAIOfficial(Provider):
                 self.client.api_key = chosen_key
                 llm_response = await self._query(payloads, func_tool)
                 break
-            except UnprocessableEntityError as e:
-                logger.warning(f"不可处理的实体错误：{e}，尝试删除图片。")
-                # 尝试删除所有 image
-                new_contexts = await self._remove_image_from_context(context_query)
-                payloads["messages"] = new_contexts
-                context_query = new_contexts
             except Exception as e:
                 last_exception = e
                 (
@@ -545,12 +545,6 @@ class ProviderOpenAIOfficial(Provider):
                 async for response in self._query_stream(payloads, func_tool):
                     yield response
                 break
-            except UnprocessableEntityError as e:
-                logger.warning(f"不可处理的实体错误：{e}，尝试删除图片。")
-                # 尝试删除所有 image
-                new_contexts = await self._remove_image_from_context(context_query)
-                payloads["messages"] = new_contexts
-                context_query = new_contexts
             except Exception as e:
                 last_exception = e
                 (
@@ -646,4 +640,3 @@ class ProviderOpenAIOfficial(Provider):
         with open(image_url, "rb") as f:
             image_bs64 = base64.b64encode(f.read()).decode("utf-8")
             return "data:image/jpeg;base64," + image_bs64
-        return ""

astrbot/dashboard/routes/chat.py

@@ -10,7 +10,6 @@ from quart import g, make_response, request
 from astrbot.core import logger
 from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
 from astrbot.core.db import BaseDatabase
-from astrbot.core.platform.astr_message_event import MessageSession
 from astrbot.core.platform.sources.webchat.webchat_queue_mgr import webchat_queue_mgr
 from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 
@@ -36,11 +35,14 @@ class ChatRoute(Route):
         super().__init__(context)
         self.routes = {
             "/chat/send": ("POST", self.chat),
-            "/chat/new_conversation": ("GET", self.new_conversation),
-            "/chat/conversations": ("GET", self.get_conversations),
-            "/chat/get_conversation": ("GET", self.get_conversation),
-            "/chat/delete_conversation": ("GET", self.delete_conversation),
-            "/chat/rename_conversation": ("POST", self.rename_conversation),
+            "/chat/new_session": ("GET", self.new_session),
+            "/chat/sessions": ("GET", self.get_sessions),
+            "/chat/get_session": ("GET", self.get_session),
+            "/chat/delete_session": ("GET", self.delete_webchat_session),
+            "/chat/update_session_display_name": (
+                "POST",
+                self.update_session_display_name,
+            ),
             "/chat/get_file": ("GET", self.get_file),
             "/chat/post_image": ("POST", self.post_image),
             "/chat/post_file": ("POST", self.post_file),
@@ -53,6 +55,7 @@ class ChatRoute(Route):
         self.supported_imgs = ["jpg", "jpeg", "png", "gif", "webp"]
         self.conv_mgr = core_lifecycle.conversation_manager
         self.platform_history_mgr = core_lifecycle.platform_message_history_manager
+        self.db = db
 
         self.running_convs: dict[str, bool] = {}
 
@@ -116,11 +119,14 @@ class ChatRoute(Route):
         if "message" not in post_data and "image_url" not in post_data:
             return Response().error("Missing key: message or image_url").__dict__
 
-        if "conversation_id" not in post_data:
-            return Response().error("Missing key: conversation_id").__dict__
+        if "session_id" not in post_data and "conversation_id" not in post_data:
+            return (
+                Response().error("Missing key: session_id or conversation_id").__dict__
+            )
 
         message = post_data["message"]
-        conversation_id = post_data["conversation_id"]
+        # conversation_id = post_data["conversation_id"]
+        session_id = post_data.get("session_id", post_data.get("conversation_id"))
         image_url = post_data.get("image_url")
         audio_url = post_data.get("audio_url")
         selected_provider = post_data.get("selected_provider")
@@ -133,11 +139,11 @@ class ChatRoute(Route):
                 .error("Message and image_url and audio_url are empty")
                 .__dict__
             )
-        if not conversation_id:
-            return Response().error("conversation_id is empty").__dict__
+        if not session_id:
+            return Response().error("session_id is empty").__dict__
 
         # 追加用户消息
-        webchat_conv_id = await self._get_webchat_conv_id_from_conv_id(conversation_id)
+        webchat_conv_id = session_id
 
         # 获取会话特定的队列
         back_queue = webchat_queue_mgr.get_or_create_back_queue(webchat_conv_id)
@@ -245,88 +251,110 @@ class ChatRoute(Route):
         response.timeout = None  # fix SSE auto disconnect issue
         return response
 
-    async def _get_webchat_conv_id_from_conv_id(self, conversation_id: str) -> str:
-        """从对话 ID 中提取 WebChat 会话 ID
-
-        NOTE: 关于这里为什么要单独做一个 WebChat 的 Conversation ID 出来，这个是为了向前兼容。
-        """
-        conversation = await self.conv_mgr.get_conversation(
-            unified_msg_origin="webchat",
-            conversation_id=conversation_id,
-        )
-        if not conversation:
-            raise ValueError(f"Conversation with ID {conversation_id} not found.")
-        conv_user_id = conversation.user_id
-        webchat_session_id = MessageSession.from_str(conv_user_id).session_id
-        if "!" not in webchat_session_id:
-            raise ValueError(f"Invalid conv user ID: {conv_user_id}")
-        return webchat_session_id.split("!")[-1]
-
-    async def delete_conversation(self):
-        conversation_id = request.args.get("conversation_id")
-        if not conversation_id:
-            return Response().error("Missing key: conversation_id").__dict__
+    async def delete_webchat_session(self):
+        """Delete a Platform session and all its related data."""
+        session_id = request.args.get("session_id")
+        if not session_id:
+            return Response().error("Missing key: session_id").__dict__
         username = g.get("username", "guest")
 
-        # Clean up queues when deleting conversation
-        webchat_queue_mgr.remove_queues(conversation_id)
-        webchat_conv_id = await self._get_webchat_conv_id_from_conv_id(conversation_id)
-        await self.conv_mgr.delete_conversation(
-            unified_msg_origin=f"webchat:FriendMessage:webchat!{username}!{webchat_conv_id}",
-            conversation_id=conversation_id,
-        )
+        # 验证会话是否存在且属于当前用户
+        session = await self.db.get_platform_session_by_id(session_id)
+        if not session:
+            return Response().error(f"Session {session_id} not found").__dict__
+        if session.creator != username:
+            return Response().error("Permission denied").__dict__
+
+        # 删除该会话下的所有对话
+        unified_msg_origin = f"{session.platform_id}:FriendMessage:{session.platform_id}!{username}!{session_id}"
+        await self.conv_mgr.delete_conversations_by_user_id(unified_msg_origin)
+
+        # 删除消息历史
         await self.platform_history_mgr.delete(
-            platform_id="webchat",
-            user_id=webchat_conv_id,
+            platform_id=session.platform_id,
+            user_id=session_id,
             offset_sec=99999999,
         )
+
+        # 清理队列（仅对 webchat）
+        if session.platform_id == "webchat":
+            webchat_queue_mgr.remove_queues(session_id)
+
+        # 删除会话
+        await self.db.delete_platform_session(session_id)
+
         return Response().ok().__dict__
 
-    async def new_conversation(self):
+    async def new_session(self):
+        """Create a new Platform session (default: webchat)."""
         username = g.get("username", "guest")
-        webchat_conv_id = str(uuid.uuid4())
-        conv_id = await self.conv_mgr.new_conversation(
-            unified_msg_origin=f"webchat:FriendMessage:webchat!{username}!{webchat_conv_id}",
-            platform_id="webchat",
-            content=[],
+
+        # 获取可选的 platform_id 参数，默认为 webchat
+        platform_id = request.args.get("platform_id", "webchat")
+
+        # 创建新会话
+        session = await self.db.create_platform_session(
+            creator=username,
+            platform_id=platform_id,
+            is_group=0,
         )
-        return Response().ok(data={"conversation_id": conv_id}).__dict__
 
-    async def rename_conversation(self):
-        post_data = await request.json
-        if "conversation_id" not in post_data or "title" not in post_data:
-            return Response().error("Missing key: conversation_id or title").__dict__
+        return (
+            Response()
+            .ok(
+                data={
+                    "session_id": session.session_id,
+                    "platform_id": session.platform_id,
+                }
+            )
+            .__dict__
+        )
 
-        conversation_id = post_data["conversation_id"]
-        title = post_data["title"]
+    async def get_sessions(self):
+        """Get all Platform sessions for the current user."""
+        username = g.get("username", "guest")
+
+        # 获取可选的 platform_id 参数
+        platform_id = request.args.get("platform_id")
 
-        await self.conv_mgr.update_conversation(
-            unified_msg_origin="webchat",  # fake
-            conversation_id=conversation_id,
-            title=title,
+        sessions = await self.db.get_platform_sessions_by_creator(
+            creator=username,
+            platform_id=platform_id,
+            page=1,
+            page_size=100,  # 暂时返回前100个
         )
-        return Response().ok(message="重命名成功！").__dict__
 
-    async def get_conversations(self):
-        conversations = await self.conv_mgr.get_conversations(platform_id="webchat")
-        # remove content
-        conversations_ = []
-        for conv in conversations:
-            conv.history = None
-            conversations_.append(conv)
-        return Response().ok(data=conversations_).__dict__
+        # 转换为字典格式，并添加额外信息
+        sessions_data = []
+        for session in sessions:
+            sessions_data.append(
+                {
+                    "session_id": session.session_id,
+                    "platform_id": session.platform_id,
+                    "creator": session.creator,
+                    "display_name": session.display_name,
+                    "is_group": session.is_group,
+                    "created_at": session.created_at.astimezone().isoformat(),
+                    "updated_at": session.updated_at.astimezone().isoformat(),
+                }
+            )
+
+        return Response().ok(data=sessions_data).__dict__
 
-    async def get_conversation(self):
-        conversation_id = request.args.get("conversation_id")
-        if not conversation_id:
-            return Response().error("Missing key: conversation_id").__dict__
+    async def get_session(self):
+        """Get session information and message history by session_id."""
+        session_id = request.args.get("session_id")
+        if not session_id:
+            return Response().error("Missing key: session_id").__dict__
 
-        webchat_conv_id = await self._get_webchat_conv_id_from_conv_id(conversation_id)
+        # 获取会话信息以确定 platform_id
+        session = await self.db.get_platform_session_by_id(session_id)
+        platform_id = session.platform_id if session else "webchat"
 
-        # Get platform message history
+        # Get platform message history using session_id
         history_ls = await self.platform_history_mgr.get(
-            platform_id="webchat",
-            user_id=webchat_conv_id,
+            platform_id=platform_id,
+            user_id=session_id,
             page=1,
             page_size=1000,
         )
@@ -338,8 +366,37 @@ class ChatRoute(Route):
             .ok(
                 data={
                     "history": history_res,
-                    "is_running": self.running_convs.get(webchat_conv_id, False),
+                    "is_running": self.running_convs.get(session_id, False),
                 },
             )
             .__dict__
         )
+
+    async def update_session_display_name(self):
+        """Update a Platform session's display name."""
+        post_data = await request.json
+
+        session_id = post_data.get("session_id")
+        display_name = post_data.get("display_name")
+
+        if not session_id:
+            return Response().error("Missing key: session_id").__dict__
+        if display_name is None:
+            return Response().error("Missing key: display_name").__dict__
+
+        username = g.get("username", "guest")
+
+        # 验证会话是否存在且属于当前用户
+        session = await self.db.get_platform_session_by_id(session_id)
+        if not session:
+            return Response().error(f"Session {session_id} not found").__dict__
+        if session.creator != username:
+            return Response().error("Permission denied").__dict__
+
+        # 更新 display_name
+        await self.db.update_platform_session(
+            session_id=session_id,
+            display_name=display_name,
+        )
+
+        return Response().ok().__dict__