AstrBot 4.12.2__py3-none-any.whl → 4.12.4__py3-none-any.whl

astrbot/core/platform/sources/dingtalk/dingtalk_adapter.py

@@ -39,7 +39,7 @@ class MyEventHandler(dingtalk_stream.EventHandler):
 
 
 @register_platform_adapter(
-    "dingtalk", "钉钉机器人官方 API 适配器", support_streaming_message=False
+    "dingtalk", "钉钉机器人官方 API 适配器", support_streaming_message=True
 )
 class DingtalkPlatformAdapter(Platform):
     def __init__(
@@ -75,6 +75,8 @@ class DingtalkPlatformAdapter(Platform):
         )
         self.client_ = client  # 用于 websockets 的 client
         self._shutdown_event: threading.Event | None = None
+        self.card_template_id = platform_config.get("card_template_id")
+        self.card_instance_id_dict = {}
 
     def _id_to_sid(self, dingtalk_id: str | None) -> str:
         if not dingtalk_id:
@@ -96,9 +98,65 @@ class DingtalkPlatformAdapter(Platform):
             name="dingtalk",
             description="钉钉机器人官方 API 适配器",
             id=cast(str, self.config.get("id")),
-            support_streaming_message=False,
+            support_streaming_message=True,
         )
 
+    async def create_message_card(
+        self, message_id: str, incoming_message: dingtalk_stream.ChatbotMessage
+    ):
+        if not self.card_template_id:
+            return False
+
+        card_instance = dingtalk_stream.AICardReplier(self.client_, incoming_message)
+        card_data = {"content": ""}  # Initial content empty
+
+        try:
+            card_instance_id = await card_instance.async_create_and_deliver_card(
+                self.card_template_id,
+                card_data,
+            )
+            self.card_instance_id_dict[message_id] = (card_instance, card_instance_id)
+            return True
+        except Exception as e:
+            logger.error(f"创建钉钉卡片失败: {e}")
+            return False
+
+    async def send_card_message(self, message_id: str, content: str, is_final: bool):
+        if message_id not in self.card_instance_id_dict:
+            return
+
+        card_instance, card_instance_id = self.card_instance_id_dict[message_id]
+        content_key = "content"
+
+        try:
+            # 钉钉卡片流式更新
+
+            await card_instance.async_streaming(
+                card_instance_id,
+                content_key=content_key,
+                content_value=content,
+                append=False,
+                finished=is_final,
+                failed=False,
+            )
+        except Exception as e:
+            logger.error(f"发送钉钉卡片消息失败: {e}")
+            # Try to report failure
+            try:
+                await card_instance.async_streaming(
+                    card_instance_id,
+                    content_key=content_key,
+                    content_value=content,  # Keep existing content
+                    append=False,
+                    finished=True,
+                    failed=True,
+                )
+            except Exception:
+                pass
+
+        if is_final:
+            self.card_instance_id_dict.pop(message_id, None)
+
     async def convert_msg(
         self,
         message: dingtalk_stream.ChatbotMessage,
@@ -224,6 +282,7 @@ class DingtalkPlatformAdapter(Platform):
             platform_meta=self.meta(),
             session_id=abm.session_id,
             client=self.client,
+            adapter=self,
         )
 
         self._event_queue.put_nowait(event)

astrbot/core/platform/sources/dingtalk/dingtalk_event.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import cast
+from typing import Any, cast
 
 import dingtalk_stream
 
@@ -16,9 +16,11 @@ class DingtalkMessageEvent(AstrMessageEvent):
         platform_meta,
         session_id,
         client: dingtalk_stream.ChatbotHandler,
+        adapter: "Any" = None,
     ):
         super().__init__(message_str, message_obj, platform_meta, session_id)
         self.client = client
+        self.adapter = adapter
 
     async def send_with_client(
         self,
@@ -83,14 +85,58 @@ class DingtalkMessageEvent(AstrMessageEvent):
         await super().send(message)
 
     async def send_streaming(self, generator, use_fallback: bool = False):
-        buffer = None
-        async for chain in generator:
+        if not self.adapter or not self.adapter.card_template_id:
+            logger.warning(
+                f"DingTalk streaming is enabled, but 'card_template_id' is not configured for platform '{self.platform_meta.id}'. Falling back to text streaming."
+            )
+            # Fallback to default behavior (buffer and send)
+            buffer = None
+            async for chain in generator:
+                if not buffer:
+                    buffer = chain
+                else:
+                    buffer.chain.extend(chain.chain)
+            if not buffer:
+                return None
+            buffer.squash_plain()
+            await self.send(buffer)
+            return await super().send_streaming(generator, use_fallback)
+
+        # Create card
+        msg_id = self.message_obj.message_id
+        incoming_msg = self.message_obj.raw_message
+        created = await self.adapter.create_message_card(msg_id, incoming_msg)
+
+        if not created:
+            # Fallback to default behavior (buffer and send)
+            buffer = None
+            async for chain in generator:
+                if not buffer:
+                    buffer = chain
+                else:
+                    buffer.chain.extend(chain.chain)
             if not buffer:
-                buffer = chain
-            else:
-                buffer.chain.extend(chain.chain)
-        if not buffer:
-            return None
-        buffer.squash_plain()
-        await self.send(buffer)
-        return await super().send_streaming(generator, use_fallback)
+                return None
+            buffer.squash_plain()
+            await self.send(buffer)
+            return await super().send_streaming(generator, use_fallback)
+
+        full_content = ""
+        seq = 0
+        try:
+            async for chain in generator:
+                for segment in chain.chain:
+                    if isinstance(segment, Comp.Plain):
+                        full_content += segment.text
+
+                seq += 1
+                if seq % 2 == 0:  # Update every 2 chunks to be more responsive than 8
+                    await self.adapter.send_card_message(
+                        msg_id, full_content, is_final=False
+                    )
+
+            await self.adapter.send_card_message(msg_id, full_content, is_final=True)
+        except Exception as e:
+            logger.error(f"DingTalk streaming error: {e}")
+            # Try to ensure final state is sent or cleaned up?
+            await self.adapter.send_card_message(msg_id, full_content, is_final=True)

astrbot/core/platform/sources/webchat/webchat_adapter.py

@@ -235,6 +235,7 @@ class WebChatAdapter(Platform):
         message_event.set_extra(
             "enable_streaming", payload.get("enable_streaming", True)
         )
+        message_event.set_extra("action_type", payload.get("action_type"))
 
         self.commit_event(message_event)
 

astrbot/core/platform/sources/webchat/webchat_event.py

@@ -128,6 +128,30 @@ class WebChatMessageEvent(AstrMessageEvent):
         web_chat_back_queue = webchat_queue_mgr.get_or_create_back_queue(cid)
         message_id = self.message_obj.message_id
         async for chain in generator:
+            # 处理音频流（Live Mode）
+            if chain.type == "audio_chunk":
+                # 音频流数据，直接发送
+                audio_b64 = ""
+                text = None
+
+                if chain.chain and isinstance(chain.chain[0], Plain):
+                    audio_b64 = chain.chain[0].text
+
+                if len(chain.chain) > 1 and isinstance(chain.chain[1], Json):
+                    text = chain.chain[1].data.get("text")
+
+                payload = {
+                    "type": "audio_chunk",
+                    "data": audio_b64,
+                    "streaming": True,
+                    "message_id": message_id,
+                }
+                if text:
+                    payload["text"] = text
+
+                await web_chat_back_queue.put(payload)
+                continue
+
             # if chain.type == "break" and final_data:
             #     # 分割符
             #     await web_chat_back_queue.put(

astrbot/core/provider/manager.py

@@ -322,6 +322,10 @@ class ProviderManager:
                 from .sources.openai_tts_api_source import (
                     ProviderOpenAITTSAPI as ProviderOpenAITTSAPI,
                 )
+            case "genie_tts":
+                from .sources.genie_tts import (
+                    GenieTTSProvider as GenieTTSProvider,
+                )
             case "edge_tts":
                 from .sources.edge_tts_source import (
                     ProviderEdgeTTS as ProviderEdgeTTS,
@@ -422,17 +426,20 @@ class ProviderManager:
         except (ImportError, ModuleNotFoundError) as e:
             logger.critical(
                 f"加载 {provider_config['type']}({provider_config['id']}) 提供商适配器失败：{e}。可能是因为有未安装的依赖。",
+                exc_info=True,
             )
             return
         except Exception as e:
             logger.critical(
                 f"加载 {provider_config['type']}({provider_config['id']}) 提供商适配器失败：{e}。未知原因",
+                exc_info=True,
             )
             return
 
         if provider_config["type"] not in provider_cls_map:
             logger.error(
                 f"未找到适用于 {provider_config['type']}({provider_config['id']}) 的提供商适配器，请检查是否已经安装或者名称填写错误。已跳过。",
+                exc_info=True,
             )
             return
 

astrbot/core/provider/provider.py

@@ -221,11 +221,65 @@ class TTSProvider(AbstractProvider):
         self.provider_config = provider_config
         self.provider_settings = provider_settings
 
+    def support_stream(self) -> bool:
+        """是否支持流式 TTS
+
+        Returns:
+            bool: True 表示支持流式处理，False 表示不支持（默认）
+
+        Notes:
+            子类可以重写此方法返回 True 来启用流式 TTS 支持
+        """
+        return False
+
     @abc.abstractmethod
     async def get_audio(self, text: str) -> str:
         """获取文本的音频，返回音频文件路径"""
         raise NotImplementedError
 
+    async def get_audio_stream(
+        self,
+        text_queue: asyncio.Queue[str | None],
+        audio_queue: "asyncio.Queue[bytes | tuple[str, bytes] | None]",
+    ) -> None:
+        """流式 TTS 处理方法。
+
+        从 text_queue 中读取文本片段，将生成的音频数据（WAV 格式的 in-memory bytes）放入 audio_queue。
+        当 text_queue 收到 None 时，表示文本输入结束，此时应该处理完所有剩余文本并向 audio_queue 发送 None 表示结束。
+
+        Args:
+            text_queue: 输入文本队列，None 表示输入结束
+            audio_queue: 输出音频队列（bytes 或 (text, bytes)），None 表示输出结束
+
+        Notes:
+            - 默认实现会将文本累积后一次性调用 get_audio 生成完整音频
+            - 子类可以重写此方法实现真正的流式 TTS
+            - 音频数据应该是 WAV 格式的 bytes
+        """
+        accumulated_text = ""
+
+        while True:
+            text_part = await text_queue.get()
+
+            if text_part is None:
+                # 输入结束，处理累积的文本
+                if accumulated_text:
+                    try:
+                        # 调用原有的 get_audio 方法获取音频文件路径
+                        audio_path = await self.get_audio(accumulated_text)
+                        # 读取音频文件内容
+                        with open(audio_path, "rb") as f:
+                            audio_data = f.read()
+                        await audio_queue.put((accumulated_text, audio_data))
+                    except Exception:
+                        # 出错时也要发送 None 结束标记
+                        pass
+                # 发送结束标记
+                await audio_queue.put(None)
+                break
+
+            accumulated_text += text_part
+
     async def test(self):
         await self.get_audio("hi")
 

astrbot/core/provider/sources/gemini_embedding_source.py

@@ -68,4 +68,4 @@ class GeminiEmbeddingProvider(EmbeddingProvider):
 
     def get_dim(self) -> int:
         """获取向量的维度"""
-        return self.provider_config.get("embedding_dimensions", 768)
+        return int(self.provider_config.get("embedding_dimensions", 768))

astrbot/core/provider/sources/genie_tts.py

@@ -0,0 +1,128 @@
+import asyncio
+import os
+import uuid
+
+from astrbot.core import logger
+from astrbot.core.provider.entities import ProviderType
+from astrbot.core.provider.provider import TTSProvider
+from astrbot.core.provider.register import register_provider_adapter
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path
+
+try:
+    import genie_tts as genie  # type: ignore
+except ImportError:
+    genie = None
+
+
+@register_provider_adapter(
+    "genie_tts",
+    "Genie TTS",
+    provider_type=ProviderType.TEXT_TO_SPEECH,
+)
+class GenieTTSProvider(TTSProvider):
+    def __init__(
+        self,
+        provider_config: dict,
+        provider_settings: dict,
+    ) -> None:
+        super().__init__(provider_config, provider_settings)
+        if not genie:
+            raise ImportError("Please install genie_tts first.")
+
+        self.character_name = provider_config.get("genie_character_name", "mika")
+        language = provider_config.get("genie_language", "Japanese")
+        model_dir = provider_config.get("genie_onnx_model_dir", "")
+        refer_audio_path = provider_config.get("genie_refer_audio_path", "")
+        refer_text = provider_config.get("genie_refer_text", "")
+
+        try:
+            genie.load_character(
+                character_name=self.character_name,
+                language=language,
+                onnx_model_dir=model_dir,
+            )
+            genie.set_reference_audio(
+                character_name=self.character_name,
+                audio_path=refer_audio_path,
+                audio_text=refer_text,
+                language=language,
+            )
+        except Exception as e:
+            raise RuntimeError(f"Failed to load character {self.character_name}: {e}")
+
+    def support_stream(self) -> bool:
+        return True
+
+    async def get_audio(self, text: str) -> str:
+        temp_dir = os.path.join(get_astrbot_data_path(), "temp")
+        os.makedirs(temp_dir, exist_ok=True)
+        filename = f"genie_tts_{uuid.uuid4()}.wav"
+        path = os.path.join(temp_dir, filename)
+
+        loop = asyncio.get_event_loop()
+
+        def _generate(save_path: str):
+            assert genie is not None
+            genie.tts(
+                character_name=self.character_name,
+                text=text,
+                save_path=save_path,
+            )
+
+        try:
+            await loop.run_in_executor(None, _generate, path)
+
+            if os.path.exists(path):
+                return path
+
+            raise RuntimeError("Genie TTS did not save to file.")
+
+        except Exception as e:
+            raise RuntimeError(f"Genie TTS generation failed: {e}")
+
+    async def get_audio_stream(
+        self,
+        text_queue: asyncio.Queue[str | None],
+        audio_queue: "asyncio.Queue[bytes | tuple[str, bytes] | None]",
+    ) -> None:
+        loop = asyncio.get_event_loop()
+
+        while True:
+            text = await text_queue.get()
+            if text is None:
+                await audio_queue.put(None)
+                break
+
+            try:
+                temp_dir = os.path.join(get_astrbot_data_path(), "temp")
+                os.makedirs(temp_dir, exist_ok=True)
+                filename = f"genie_tts_{uuid.uuid4()}.wav"
+                path = os.path.join(temp_dir, filename)
+
+                def _generate(save_path: str, t: str):
+                    assert genie is not None
+                    genie.tts(
+                        character_name=self.character_name,
+                        text=t,
+                        save_path=save_path,
+                    )
+
+                await loop.run_in_executor(None, _generate, path, text)
+
+                if os.path.exists(path):
+                    with open(path, "rb") as f:
+                        audio_data = f.read()
+
+                    # Put (text, bytes) into queue so frontend can display text
+                    await audio_queue.put((text, audio_data))
+
+                    # Clean up
+                    try:
+                        os.remove(path)
+                    except OSError:
+                        pass
+                else:
+                    logger.error(f"Genie TTS failed to generate audio for: {text}")
+
+            except Exception as e:
+                logger.error(f"Genie TTS stream error: {e}")

astrbot/core/provider/sources/openai_embedding_source.py

@@ -37,4 +37,4 @@ class OpenAIEmbeddingProvider(EmbeddingProvider):
 
     def get_dim(self) -> int:
         """获取向量的维度"""
-        return self.provider_config.get("embedding_dimensions", 1024)
+        return int(self.provider_config.get("embedding_dimensions", 1024))

astrbot/core/star/context.py

@@ -328,28 +328,29 @@ class Context:
         """获取所有用于 Embedding 任务的 Provider。"""
         return self.provider_manager.embedding_provider_insts
 
-    def get_using_provider(self, umo: str | None = None) -> Provider:
+    def get_using_provider(self, umo: str | None = None) -> Provider | None:
         """获取当前使用的用于文本生成任务的 LLM Provider(Chat_Completion 类型)。
 
         Args:
             umo: unified_message_origin 值，如果传入并且用户启用了提供商会话隔离，
-                 则使用该会话偏好的提供商。
+                 则使用该会话偏好的对话模型（提供商）。
 
         Returns:
-            当前使用的文本生成提供者。
+            当前使用的对话模型（提供商），如果未设置则返回 None。
 
         Raises:
-            ValueError: 返回的提供者不是 Provider 类型。
-
-        Note:
-            通过 /provider 指令可以切换提供者。
+            ValueError: 该会话来源配置的的对话模型（提供商）的类型不正确。
         """
         prov = self.provider_manager.get_using_provider(
             provider_type=ProviderType.CHAT_COMPLETION,
             umo=umo,
         )
+        if prov is None:
+            return None
         if not isinstance(prov, Provider):
-            raise ValueError("返回的 Provider 不是 Provider 类型")
+            raise ValueError(
+                f"该会话来源的对话模型（提供商）的类型不正确: {type(prov)}"
+            )
         return prov
 
     def get_using_tts_provider(self, umo: str | None = None) -> TTSProvider | None:

astrbot/core/star/register/star_handler.py

@@ -427,7 +427,7 @@ def register_on_using_llm_tool(**kwargs):
     """
 
     def decorator(awaitable):
-        _ = get_handler_or_create(awaitable, EventType.OnCallingFuncToolEvent, **kwargs)
+        _ = get_handler_or_create(awaitable, EventType.OnUsingLLMToolEvent, **kwargs)
         return awaitable
 
     return decorator
@@ -452,9 +452,7 @@ def register_on_llm_tool_respond(**kwargs):
     """
 
     def decorator(awaitable):
-        _ = get_handler_or_create(
-            awaitable, EventType.OnAfterCallingFuncToolEvent, **kwargs
-        )
+        _ = get_handler_or_create(awaitable, EventType.OnLLMToolRespondEvent, **kwargs)
         return awaitable
 
     return decorator

astrbot/core/star/star_handler.py

@@ -189,7 +189,8 @@ class EventType(enum.Enum):
     OnLLMResponseEvent = enum.auto()  # LLM 响应后
     OnDecoratingResultEvent = enum.auto()  # 发送消息前
     OnCallingFuncToolEvent = enum.auto()  # 调用函数工具
-    OnAfterCallingFuncToolEvent = enum.auto()  # 调用函数工具后
+    OnUsingLLMToolEvent = enum.auto()  # 使用 LLM 工具
+    OnLLMToolRespondEvent = enum.auto()  # 调用函数工具后
     OnAfterMessageSentEvent = enum.auto()  # 发送消息后