AstrBot 4.12.3__tar.gz → 4.12.4__tar.gz

{astrbot-4.12.3 → astrbot-4.12.4}/.gitignore

@@ -50,3 +50,7 @@ venv/*
 pytest.ini
 AGENTS.md
 IFLOW.md
+
+# genie_tts data
+CharacterModels/
+GenieData/

{astrbot-4.12.3 → astrbot-4.12.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AstrBot
-Version: 4.12.3
+Version: 4.12.4
 Summary: Easy-to-use multi-platform LLM chatbot and development framework
 License-File: LICENSE
 Keywords: Astrbot,Astrbot Module,Astrbot Plugin

{astrbot-4.12.3 → astrbot-4.12.4}/astrbot/builtin_stars/builtin_commands/commands/__init__.py

@@ -11,7 +11,6 @@ from .provider import ProviderCommands
 from .setunset import SetUnsetCommands
 from .sid import SIDCommand
 from .t2i import T2ICommand
-from .tool import ToolCommands
 from .tts import TTSCommand
 
 __all__ = [
@@ -27,5 +26,4 @@ __all__ = [
     "SetUnsetCommands",
     "T2ICommand",
     "TTSCommand",
-    "ToolCommands",
 ]

{astrbot-4.12.3 → astrbot-4.12.4}/astrbot/builtin_stars/builtin_commands/commands/persona.py

@@ -1,13 +1,55 @@
 import builtins
+from typing import TYPE_CHECKING
 
 from astrbot.api import sp, star
 from astrbot.api.event import AstrMessageEvent, MessageEventResult
 
+if TYPE_CHECKING:
+    from astrbot.core.db.po import Persona
+
 
 class PersonaCommands:
     def __init__(self, context: star.Context):
         self.context = context
 
+    def _build_tree_output(
+        self,
+        folder_tree: list[dict],
+        all_personas: list["Persona"],
+        depth: int = 0,
+    ) -> list[str]:
+        """递归构建树状输出，使用短线条表示层级"""
+        lines: list[str] = []
+        # 使用短线条作为缩进前缀，每层只用 "│" 加一个空格
+        prefix = "│ " * depth
+
+        for folder in folder_tree:
+            # 输出文件夹
+            lines.append(f"{prefix}├ 📁 {folder['name']}/")
+
+            # 获取该文件夹下的人格
+            folder_personas = [
+                p for p in all_personas if p.folder_id == folder["folder_id"]
+            ]
+            child_prefix = "│ " * (depth + 1)
+
+            # 输出该文件夹下的人格
+            for persona in folder_personas:
+                lines.append(f"{child_prefix}├ 👤 {persona.persona_id}")
+
+            # 递归处理子文件夹
+            children = folder.get("children", [])
+            if children:
+                lines.extend(
+                    self._build_tree_output(
+                        children,
+                        all_personas,
+                        depth + 1,
+                    )
+                )
+
+        return lines
+
     async def persona(self, message: AstrMessageEvent):
         l = message.message_str.split(" ")  # noqa: E741
         umo = message.unified_msg_origin
@@ -69,12 +111,32 @@ class PersonaCommands:
                 .use_t2i(False),
             )
         elif l[1] == "list":
-            parts = ["人格列表：\n"]
-            for persona in self.context.provider_manager.personas:
-                parts.append(f"- {persona['name']}\n")
-            parts.append("\n\n*输入 `/persona view 人格名` 查看人格详细信息")
-            msg = "".join(parts)
-            message.set_result(MessageEventResult().message(msg))
+            # 获取文件夹树和所有人格
+            folder_tree = await self.context.persona_manager.get_folder_tree()
+            all_personas = self.context.persona_manager.personas
+
+            lines = ["📂 人格列表：\n"]
+
+            # 构建树状输出
+            tree_lines = self._build_tree_output(folder_tree, all_personas)
+            lines.extend(tree_lines)
+
+            # 输出根目录下的人格（没有文件夹的）
+            root_personas = [p for p in all_personas if p.folder_id is None]
+            if root_personas:
+                if tree_lines:  # 如果有文件夹内容，加个空行
+                    lines.append("")
+                for persona in root_personas:
+                    lines.append(f"👤 {persona.persona_id}")
+
+            # 统计信息
+            total_count = len(all_personas)
+            lines.append(f"\n共 {total_count} 个人格")
+            lines.append("\n*使用 `/persona <人格名>` 设置人格")
+            lines.append("*使用 `/persona view <人格名>` 查看详细信息")
+
+            msg = "\n".join(lines)
+            message.set_result(MessageEventResult().message(msg).use_t2i(False))
         elif l[1] == "view":
             if len(l) == 2:
                 message.set_result(MessageEventResult().message("请输入人格情景名"))

{astrbot-4.12.3 → astrbot-4.12.4}/astrbot/builtin_stars/builtin_commands/main.py

@@ -13,7 +13,6 @@ from .commands import (
     SetUnsetCommands,
     SIDCommand,
     T2ICommand,
-    ToolCommands,
     TTSCommand,
 )
 
@@ -24,7 +23,6 @@ class Main(star.Star):
 
         self.help_c = HelpCommand(self.context)
         self.llm_c = LLMCommands(self.context)
-        self.tool_c = ToolCommands(self.context)
         self.plugin_c = PluginCommands(self.context)
         self.admin_c = AdminCommands(self.context)
         self.conversation_c = ConversationCommands(self.context)
@@ -47,30 +45,6 @@ class Main(star.Star):
         """开启/关闭 LLM"""
         await self.llm_c.llm(event)
 
-    @filter.command_group("tool")
-    def tool(self):
-        """函数工具管理"""
-
-    @tool.command("ls")
-    async def tool_ls(self, event: AstrMessageEvent):
-        """查看函数工具列表"""
-        await self.tool_c.tool_ls(event)
-
-    @tool.command("on")
-    async def tool_on(self, event: AstrMessageEvent, tool_name: str):
-        """启用一个函数工具"""
-        await self.tool_c.tool_on(event, tool_name)
-
-    @tool.command("off")
-    async def tool_off(self, event: AstrMessageEvent, tool_name: str):
-        """停用一个函数工具"""
-        await self.tool_c.tool_off(event, tool_name)
-
-    @tool.command("off_all")
-    async def tool_all_off(self, event: AstrMessageEvent):
-        """停用所有函数工具"""
-        await self.tool_c.tool_all_off(event)
-
     @filter.command_group("plugin")
     def plugin(self):
         """插件管理"""

astrbot-4.12.4/astrbot/cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "4.12.4"

{astrbot-4.12.3 → astrbot-4.12.4}/astrbot/core/astr_agent_hooks.py

@@ -56,8 +56,10 @@ class MainAgentHooks(BaseAgentRunHooks[AstrAgentContext]):
         )
 
         # special handle web_search_tavily
+        platform_name = run_context.context.event.get_platform_name()
         if (
-            tool.name == "web_search_tavily"
+            platform_name == "webchat"
+            and tool.name == "web_search_tavily"
             and len(run_context.messages) > 0
             and tool_result
             and len(tool_result.content)

astrbot-4.12.4/astrbot/core/astr_agent_run_util.py

@@ -0,0 +1,375 @@
+import asyncio
+import re
+import time
+import traceback
+from collections.abc import AsyncGenerator
+
+from astrbot.core import logger
+from astrbot.core.agent.message import Message
+from astrbot.core.agent.runners.tool_loop_agent_runner import ToolLoopAgentRunner
+from astrbot.core.astr_agent_context import AstrAgentContext
+from astrbot.core.message.components import BaseMessageComponent, Json, Plain
+from astrbot.core.message.message_event_result import (
+    MessageChain,
+    MessageEventResult,
+    ResultContentType,
+)
+from astrbot.core.provider.entities import LLMResponse
+from astrbot.core.provider.provider import TTSProvider
+
+AgentRunner = ToolLoopAgentRunner[AstrAgentContext]
+
+
+async def run_agent(
+    agent_runner: AgentRunner,
+    max_step: int = 30,
+    show_tool_use: bool = True,
+    stream_to_general: bool = False,
+    show_reasoning: bool = False,
+) -> AsyncGenerator[MessageChain | None, None]:
+    step_idx = 0
+    astr_event = agent_runner.run_context.context.event
+    while step_idx < max_step + 1:
+        step_idx += 1
+
+        if step_idx == max_step + 1:
+            logger.warning(
+                f"Agent reached max steps ({max_step}), forcing a final response."
+            )
+            if not agent_runner.done():
+                # 拔掉所有工具
+                if agent_runner.req:
+                    agent_runner.req.func_tool = None
+                # 注入提示词
+                agent_runner.run_context.messages.append(
+                    Message(
+                        role="user",
+                        content="工具调用次数已达到上限，请停止使用工具，并根据已经收集到的信息，对你的任务和发现进行总结，然后直接回复用户。",
+                    )
+                )
+
+        try:
+            async for resp in agent_runner.step():
+                if astr_event.is_stopped():
+                    return
+                if resp.type == "tool_call_result":
+                    msg_chain = resp.data["chain"]
+                    if msg_chain.type == "tool_direct_result":
+                        # tool_direct_result 用于标记 llm tool 需要直接发送给用户的内容
+                        await astr_event.send(msg_chain)
+                        continue
+                    if astr_event.get_platform_id() == "webchat":
+                        await astr_event.send(msg_chain)
+                    # 对于其他情况，暂时先不处理
+                    continue
+                elif resp.type == "tool_call":
+                    if agent_runner.streaming:
+                        # 用来标记流式响应需要分节
+                        yield MessageChain(chain=[], type="break")
+
+                    if astr_event.get_platform_name() == "webchat":
+                        await astr_event.send(resp.data["chain"])
+                    elif show_tool_use:
+                        json_comp = resp.data["chain"].chain[0]
+                        if isinstance(json_comp, Json):
+                            m = f"🔨 调用工具: {json_comp.data.get('name')}"
+                        else:
+                            m = "🔨 调用工具..."
+                        chain = MessageChain(type="tool_call").message(m)
+                        await astr_event.send(chain)
+                    continue
+
+                if stream_to_general and resp.type == "streaming_delta":
+                    continue
+
+                if stream_to_general or not agent_runner.streaming:
+                    content_typ = (
+                        ResultContentType.LLM_RESULT
+                        if resp.type == "llm_result"
+                        else ResultContentType.GENERAL_RESULT
+                    )
+                    astr_event.set_result(
+                        MessageEventResult(
+                            chain=resp.data["chain"].chain,
+                            result_content_type=content_typ,
+                        ),
+                    )
+                    yield
+                    astr_event.clear_result()
+                elif resp.type == "streaming_delta":
+                    chain = resp.data["chain"]
+                    if chain.type == "reasoning" and not show_reasoning:
+                        # display the reasoning content only when configured
+                        continue
+                    yield resp.data["chain"]  # MessageChain
+            if agent_runner.done():
+                # send agent stats to webchat
+                if astr_event.get_platform_name() == "webchat":
+                    await astr_event.send(
+                        MessageChain(
+                            type="agent_stats",
+                            chain=[Json(data=agent_runner.stats.to_dict())],
+                        )
+                    )
+
+                break
+
+        except Exception as e:
+            logger.error(traceback.format_exc())
+
+            err_msg = f"\n\nAstrBot 请求失败。\n错误类型: {type(e).__name__}\n错误信息: {e!s}\n\n请在平台日志查看和分享错误详情。\n"
+
+            error_llm_response = LLMResponse(
+                role="err",
+                completion_text=err_msg,
+            )
+            try:
+                await agent_runner.agent_hooks.on_agent_done(
+                    agent_runner.run_context, error_llm_response
+                )
+            except Exception:
+                logger.exception("Error in on_agent_done hook")
+
+            if agent_runner.streaming:
+                yield MessageChain().message(err_msg)
+            else:
+                astr_event.set_result(MessageEventResult().message(err_msg))
+            return
+
+
+async def run_live_agent(
+    agent_runner: AgentRunner,
+    tts_provider: TTSProvider | None = None,
+    max_step: int = 30,
+    show_tool_use: bool = True,
+    show_reasoning: bool = False,
+) -> AsyncGenerator[MessageChain | None, None]:
+    """Live Mode 的 Agent 运行器，支持流式 TTS
+
+    Args:
+        agent_runner: Agent 运行器
+        tts_provider: TTS Provider 实例
+        max_step: 最大步数
+        show_tool_use: 是否显示工具使用
+        show_reasoning: 是否显示推理过程
+
+    Yields:
+        MessageChain: 包含文本或音频数据的消息链
+    """
+    # 如果没有 TTS Provider，直接发送文本
+    if not tts_provider:
+        async for chain in run_agent(
+            agent_runner,
+            max_step=max_step,
+            show_tool_use=show_tool_use,
+            stream_to_general=False,
+            show_reasoning=show_reasoning,
+        ):
+            yield chain
+        return
+
+    support_stream = tts_provider.support_stream()
+    if support_stream:
+        logger.info("[Live Agent] 使用流式 TTS（原生支持 get_audio_stream）")
+    else:
+        logger.info(
+            f"[Live Agent] 使用 TTS（{tts_provider.meta().type} "
+            "使用 get_audio，将按句子分块生成音频）"
+        )
+
+    # 统计数据初始化
+    tts_start_time = time.time()
+    tts_first_frame_time = 0.0
+    first_chunk_received = False
+
+    # 创建队列
+    text_queue: asyncio.Queue[str | None] = asyncio.Queue()
+    # audio_queue stored bytes or (text, bytes)
+    audio_queue: asyncio.Queue[bytes | tuple[str, bytes] | None] = asyncio.Queue()
+
+    # 1. 启动 Agent Feeder 任务：负责运行 Agent 并将文本分句喂给 text_queue
+    feeder_task = asyncio.create_task(
+        _run_agent_feeder(
+            agent_runner, text_queue, max_step, show_tool_use, show_reasoning
+        )
+    )
+
+    # 2. 启动 TTS 任务：负责从 text_queue 读取文本并生成音频到 audio_queue
+    if support_stream:
+        tts_task = asyncio.create_task(
+            _safe_tts_stream_wrapper(tts_provider, text_queue, audio_queue)
+        )
+    else:
+        tts_task = asyncio.create_task(
+            _simulated_stream_tts(tts_provider, text_queue, audio_queue)
+        )
+
+    # 3. 主循环：从 audio_queue 读取音频并 yield
+    try:
+        while True:
+            queue_item = await audio_queue.get()
+
+            if queue_item is None:
+                break
+
+            text = None
+            if isinstance(queue_item, tuple):
+                text, audio_data = queue_item
+            else:
+                audio_data = queue_item
+
+            if not first_chunk_received:
+                # 记录首帧延迟（从开始处理到收到第一个音频块）
+                tts_first_frame_time = time.time() - tts_start_time
+                first_chunk_received = True
+
+            # 将音频数据封装为 MessageChain
+            import base64
+
+            audio_b64 = base64.b64encode(audio_data).decode("utf-8")
+            comps: list[BaseMessageComponent] = [Plain(audio_b64)]
+            if text:
+                comps.append(Json(data={"text": text}))
+            chain = MessageChain(chain=comps, type="audio_chunk")
+            yield chain
+
+    except Exception as e:
+        logger.error(f"[Live Agent] 运行时发生错误: {e}", exc_info=True)
+    finally:
+        # 清理任务
+        if not feeder_task.done():
+            feeder_task.cancel()
+        if not tts_task.done():
+            tts_task.cancel()
+
+        # 确保队列被消费
+        pass
+
+    tts_end_time = time.time()
+
+    # 发送 TTS 统计信息
+    try:
+        astr_event = agent_runner.run_context.context.event
+        if astr_event.get_platform_name() == "webchat":
+            tts_duration = tts_end_time - tts_start_time
+            await astr_event.send(
+                MessageChain(
+                    type="tts_stats",
+                    chain=[
+                        Json(
+                            data={
+                                "tts_total_time": tts_duration,
+                                "tts_first_frame_time": tts_first_frame_time,
+                                "tts": tts_provider.meta().type,
+                                "chat_model": agent_runner.provider.get_model(),
+                            }
+                        )
+                    ],
+                )
+            )
+    except Exception as e:
+        logger.error(f"发送 TTS 统计信息失败: {e}")
+
+
+async def _run_agent_feeder(
+    agent_runner: AgentRunner,
+    text_queue: asyncio.Queue,
+    max_step: int,
+    show_tool_use: bool,
+    show_reasoning: bool,
+):
+    """运行 Agent 并将文本输出分句放入队列"""
+    buffer = ""
+    try:
+        async for chain in run_agent(
+            agent_runner,
+            max_step=max_step,
+            show_tool_use=show_tool_use,
+            stream_to_general=False,
+            show_reasoning=show_reasoning,
+        ):
+            if chain is None:
+                continue
+
+            # 提取文本
+            text = chain.get_plain_text()
+            if text:
+                buffer += text
+
+                # 分句逻辑：匹配标点符号
+                # r"([.。!！?？\n]+)" 会保留分隔符
+                parts = re.split(r"([.。!！?？\n]+)", buffer)
+
+                if len(parts) > 1:
+                    # 处理完整的句子
+                    # range step 2 因为 split 后是 [text, delim, text, delim, ...]
+                    temp_buffer = ""
+                    for i in range(0, len(parts) - 1, 2):
+                        sentence = parts[i]
+                        delim = parts[i + 1]
+                        full_sentence = sentence + delim
+                        temp_buffer += full_sentence
+
+                        if len(temp_buffer) >= 10:
+                            if temp_buffer.strip():
+                                logger.info(f"[Live Agent Feeder] 分句: {temp_buffer}")
+                                await text_queue.put(temp_buffer)
+                            temp_buffer = ""
+
+                    # 更新 buffer 为剩余部分
+                    buffer = temp_buffer + parts[-1]
+
+        # 处理剩余 buffer
+        if buffer.strip():
+            await text_queue.put(buffer)
+
+    except Exception as e:
+        logger.error(f"[Live Agent Feeder] Error: {e}", exc_info=True)
+    finally:
+        # 发送结束信号
+        await text_queue.put(None)
+
+
+async def _safe_tts_stream_wrapper(
+    tts_provider: TTSProvider,
+    text_queue: asyncio.Queue[str | None],
+    audio_queue: "asyncio.Queue[bytes | tuple[str, bytes] | None]",
+):
+    """包装原生流式 TTS 确保异常处理和队列关闭"""
+    try:
+        await tts_provider.get_audio_stream(text_queue, audio_queue)
+    except Exception as e:
+        logger.error(f"[Live TTS Stream] Error: {e}", exc_info=True)
+    finally:
+        await audio_queue.put(None)
+
+
+async def _simulated_stream_tts(
+    tts_provider: TTSProvider,
+    text_queue: asyncio.Queue[str | None],
+    audio_queue: "asyncio.Queue[bytes | tuple[str, bytes] | None]",
+):
+    """模拟流式 TTS 分句生成音频"""
+    try:
+        while True:
+            text = await text_queue.get()
+            if text is None:
+                break
+
+            try:
+                audio_path = await tts_provider.get_audio(text)
+
+                if audio_path:
+                    with open(audio_path, "rb") as f:
+                        audio_data = f.read()
+                    await audio_queue.put((text, audio_data))
+            except Exception as e:
+                logger.error(
+                    f"[Live TTS Simulated] Error processing text '{text[:20]}...': {e}"
+                )
+                # 继续处理下一句
+
+    except Exception as e:
+        logger.error(f"[Live TTS Simulated] Critical Error: {e}", exc_info=True)
+    finally:
+        await audio_queue.put(None)

{astrbot-4.12.3 → astrbot-4.12.4}/astrbot/core/config/default.py

@@ -5,7 +5,7 @@ from typing import Any, TypedDict
 
 from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 
-VERSION = "4.12.3"
+VERSION = "4.12.4"
 DB_PATH = os.path.join(get_astrbot_data_path(), "data_v4.db")
 
 WEBHOOK_SUPPORTED_PLATFORMS = [
@@ -321,6 +321,7 @@ CONFIG_METADATA_2 = {
                         "enable": False,
                         "client_id": "",
                         "client_secret": "",
+                        "card_template_id": "",
                     },
                     "Telegram": {
                         "id": "telegram",
@@ -582,6 +583,11 @@ CONFIG_METADATA_2 = {
                         "type": "string",
                         "hint": "可选：填写 Misskey 网盘中目标文件夹的 ID，上传的文件将放置到该文件夹内。留空则使用账号网盘根目录。",
                     },
+                    "card_template_id": {
+                        "description": "卡片模板 ID",
+                        "type": "string",
+                        "hint": "可选。钉钉互动卡片模板 ID。启用后将使用互动卡片进行流式回复。",
+                    },
                     "telegram_command_register": {
                         "description": "Telegram 命令注册",
                         "type": "bool",
@@ -1179,6 +1185,19 @@ CONFIG_METADATA_2 = {
                         "openai-tts-voice": "alloy",
                         "timeout": "20",
                     },
+                    "Genie TTS": {
+                        "id": "genie_tts",
+                        "provider": "genie_tts",
+                        "type": "genie_tts",
+                        "provider_type": "text_to_speech",
+                        "enable": False,
+                        "genie_character_name": "mika",
+                        "genie_onnx_model_dir": "CharacterModels/v2ProPlus/mika/tts_models",
+                        "genie_language": "Japanese",
+                        "genie_refer_audio_path": "",
+                        "genie_refer_text": "",
+                        "timeout": 20,
+                    },
                     "Edge TTS": {
                         "id": "edge_tts",
                         "provider": "microsoft",
@@ -1395,6 +1414,16 @@ CONFIG_METADATA_2 = {
                     },
                 },
                 "items": {
+                    "genie_onnx_model_dir": {
+                        "description": "ONNX Model Directory",
+                        "type": "string",
+                        "hint": "The directory path containing the ONNX model files",
+                    },
+                    "genie_language": {
+                        "description": "Language",
+                        "type": "string",
+                        "options": ["Japanese", "English", "Chinese"],
+                    },
                     "provider_source_id": {
                         "invisible": True,
                         "type": "string",