AstrBot 3.5.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

astrbot/core/provider/sources/dashscope_source.py

@@ -1,203 +0,0 @@
-import re
-import asyncio
-import functools
-from typing import List
-from .. import Provider, Personality
-from ..entities import LLMResponse
-from ..func_tool_manager import FuncCall
-from astrbot.core.db import BaseDatabase
-from ..register import register_provider_adapter
-from astrbot.core.message.message_event_result import MessageChain
-from .openai_source import ProviderOpenAIOfficial
-from astrbot.core import logger, sp
-from dashscope import Application
-
-
-@register_provider_adapter("dashscope", "Dashscope APP 适配器。")
-class ProviderDashscope(ProviderOpenAIOfficial):
-    def __init__(
-        self,
-        provider_config: dict,
-        provider_settings: dict,
-        db_helper: BaseDatabase,
-        persistant_history=False,
-        default_persona: Personality = None,
-    ) -> None:
-        Provider.__init__(
-            self,
-            provider_config,
-            provider_settings,
-            persistant_history,
-            db_helper,
-            default_persona,
-        )
-        self.api_key = provider_config.get("dashscope_api_key", "")
-        if not self.api_key:
-            raise Exception("阿里云百炼 API Key 不能为空。")
-        self.app_id = provider_config.get("dashscope_app_id", "")
-        if not self.app_id:
-            raise Exception("阿里云百炼 APP ID 不能为空。")
-        self.dashscope_app_type = provider_config.get("dashscope_app_type", "")
-        if not self.dashscope_app_type:
-            raise Exception("阿里云百炼 APP 类型不能为空。")
-        self.model_name = "dashscope"
-        self.variables: dict = provider_config.get("variables", {})
-        self.rag_options: dict = provider_config.get("rag_options", {})
-        self.output_reference = self.rag_options.get("output_reference", False)
-        self.rag_options = self.rag_options.copy()
-        self.rag_options.pop("output_reference", None)
-
-        self.timeout = provider_config.get("timeout", 120)
-        if isinstance(self.timeout, str):
-            self.timeout = int(self.timeout)
-
-    def has_rag_options(self):
-        """判断是否有 RAG 选项
-
-        Returns:
-            bool: 是否有 RAG 选项
-        """
-        if self.rag_options and (
-            len(self.rag_options.get("pipeline_ids", [])) > 0
-            or len(self.rag_options.get("file_ids", [])) > 0
-        ):
-            return True
-        return False
-
-    async def text_chat(
-        self,
-        prompt: str,
-        session_id: str = None,
-        image_urls: List[str] = [],
-        func_tool: FuncCall = None,
-        contexts: List = None,
-        system_prompt: str = None,
-        **kwargs,
-    ) -> LLMResponse:
-        # 获得会话变量
-        payload_vars = self.variables.copy()
-        # 动态变量
-        session_vars = sp.get("session_variables", {})
-        session_var = session_vars.get(session_id, {})
-        payload_vars.update(session_var)
-
-        if (
-            self.dashscope_app_type in ["agent", "dialog-workflow"]
-            and not self.has_rag_options()
-        ):
-            # 支持多轮对话的
-            new_record = {"role": "user", "content": prompt}
-            if image_urls:
-                logger.warning("阿里云百炼暂不支持图片输入，将自动忽略图片内容。")
-            contexts_no_img = await self._remove_image_from_context(contexts)
-            context_query = [*contexts_no_img, new_record]
-            if system_prompt:
-                context_query.insert(0, {"role": "system", "content": system_prompt})
-            for part in context_query:
-                if "_no_save" in part:
-                    del part["_no_save"]
-            # 调用阿里云百炼 API
-            payload = {
-                "app_id": self.app_id,
-                "api_key": self.api_key,
-                "messages": context_query,
-                "biz_params": payload_vars or None,
-            }
-            partial = functools.partial(
-                Application.call,
-                **payload,
-            )
-            response = await asyncio.get_event_loop().run_in_executor(None, partial)
-        else:
-            # 不支持多轮对话的
-            # 调用阿里云百炼 API
-            payload = {
-                "app_id": self.app_id,
-                "prompt": prompt,
-                "api_key": self.api_key,
-                "biz_params": payload_vars or None,
-            }
-            if self.rag_options:
-                payload["rag_options"] = self.rag_options
-            partial = functools.partial(
-                Application.call,
-                **payload,
-            )
-            response = await asyncio.get_event_loop().run_in_executor(None, partial)
-
-        logger.debug(f"dashscope resp: {response}")
-
-        if response.status_code != 200:
-            logger.error(
-                f"阿里云百炼请求失败: request_id={response.request_id}, code={response.status_code}, message={response.message}, 请参考文档：https://help.aliyun.com/zh/model-studio/developer-reference/error-code"
-            )
-            return LLMResponse(
-                role="err",
-                result_chain=MessageChain().message(
-                    f"阿里云百炼请求失败: message={response.message} code={response.status_code}"
-                ),
-            )
-
-        output_text = response.output.get("text", "")
-        # RAG 引用脚标格式化
-        output_text = re.sub(r"<ref>\[(\d+)\]</ref>", r"[\1]", output_text)
-        if self.output_reference and response.output.get("doc_references", None):
-            ref_str = ""
-            for ref in response.output.get("doc_references", []):
-                ref_title = (
-                    ref.get("title", "")
-                    if ref.get("title")
-                    else ref.get("doc_name", "")
-                )
-                ref_str += f"{ref['index_id']}. {ref_title}\n"
-            output_text += f"\n\n回答来源:\n{ref_str}"
-
-        llm_response = LLMResponse("assistant")
-        llm_response.result_chain = MessageChain().message(output_text)
-
-        return llm_response
-
-    async def text_chat_stream(
-        self,
-        prompt,
-        session_id=None,
-        image_urls=...,
-        func_tool=None,
-        contexts=...,
-        system_prompt=None,
-        tool_calls_result=None,
-        **kwargs,
-    ):
-        # raise NotImplementedError("This method is not implemented yet.")
-        # 调用 text_chat 模拟流式
-        llm_response = await self.text_chat(
-            prompt=prompt,
-            session_id=session_id,
-            image_urls=image_urls,
-            func_tool=func_tool,
-            contexts=contexts,
-            system_prompt=system_prompt,
-            tool_calls_result=tool_calls_result,
-        )
-        llm_response.is_chunk = True
-        yield llm_response
-        llm_response.is_chunk = False
-        yield llm_response
-
-    async def forget(self, session_id):
-        return True
-
-    async def get_current_key(self):
-        return self.api_key
-
-    async def set_key(self, key):
-        raise Exception("阿里云百炼 适配器不支持设置 API Key。")
-
-    async def get_models(self):
-        return [self.get_model()]
-
-    async def get_human_readable_context(self, session_id, page, page_size):
-        raise Exception("暂不支持获得 阿里云百炼 的历史消息记录。")
-
-    async def terminate(self):
-        pass

astrbot/core/provider/sources/dify_source.py

@@ -1,281 +0,0 @@
-import astrbot.core.message.components as Comp
-
-from typing import List
-from .. import Provider, Personality
-from ..entities import LLMResponse
-from ..func_tool_manager import FuncCall
-from astrbot.core.db import BaseDatabase
-from ..register import register_provider_adapter
-from astrbot.core.utils.dify_api_client import DifyAPIClient
-from astrbot.core.utils.io import download_image_by_url, download_file
-from astrbot.core import logger, sp
-from astrbot.core.message.message_event_result import MessageChain
-
-
-@register_provider_adapter("dify", "Dify APP 适配器。")
-class ProviderDify(Provider):
-    def __init__(
-        self,
-        provider_config: dict,
-        provider_settings: dict,
-        db_helper: BaseDatabase,
-        persistant_history=False,
-        default_persona: Personality = None,
-    ) -> None:
-        super().__init__(
-            provider_config,
-            provider_settings,
-            persistant_history,
-            db_helper,
-            default_persona,
-        )
-        self.api_key = provider_config.get("dify_api_key", "")
-        if not self.api_key:
-            raise Exception("Dify API Key 不能为空。")
-        api_base = provider_config.get("dify_api_base", "https://api.dify.ai/v1")
-        self.api_type = provider_config.get("dify_api_type", "")
-        if not self.api_type:
-            raise Exception("Dify API 类型不能为空。")
-        self.model_name = "dify"
-        self.workflow_output_key = provider_config.get(
-            "dify_workflow_output_key", "astrbot_wf_output"
-        )
-        self.dify_query_input_key = provider_config.get(
-            "dify_query_input_key", "astrbot_text_query"
-        )
-        if not self.dify_query_input_key:
-            self.dify_query_input_key = "astrbot_text_query"
-        if not self.workflow_output_key:
-            self.workflow_output_key = "astrbot_wf_output"
-        self.variables: dict = provider_config.get("variables", {})
-        self.timeout = provider_config.get("timeout", 120)
-        if isinstance(self.timeout, str):
-            self.timeout = int(self.timeout)
-        self.conversation_ids = {}
-        """记录当前 session id 的对话 ID"""
-
-        self.api_client = DifyAPIClient(self.api_key, api_base)
-
-    async def text_chat(
-        self,
-        prompt: str,
-        session_id: str = None,
-        image_urls: List[str] = [],
-        func_tool: FuncCall = None,
-        contexts: List = None,
-        system_prompt: str = None,
-        **kwargs,
-    ) -> LLMResponse:
-        result = ""
-        conversation_id = self.conversation_ids.get(session_id, "")
-
-        files_payload = []
-        for image_url in image_urls:
-            image_path = (
-                await download_image_by_url(image_url)
-                if image_url.startswith("http")
-                else image_url
-            )
-            file_response = await self.api_client.file_upload(
-                image_path, user=session_id
-            )
-            logger.debug(f"Dify 上传图片响应：{file_response}")
-            if "id" not in file_response:
-                logger.warning(
-                    f"上传图片后得到未知的 Dify 响应：{file_response}，图片将忽略。"
-                )
-                continue
-            files_payload.append(
-                {
-                    "type": "image",
-                    "transfer_method": "local_file",
-                    "upload_file_id": file_response["id"],
-                }
-            )
-
-        # 获得会话变量
-        payload_vars = self.variables.copy()
-        # 动态变量
-        session_vars = sp.get("session_variables", {})
-        session_var = session_vars.get(session_id, {})
-        payload_vars.update(session_var)
-
-        try:
-            match self.api_type:
-                case "chat" | "agent" | "chatflow":
-                    if not prompt:
-                        prompt = "请描述这张图片。"
-
-                    async for chunk in self.api_client.chat_messages(
-                        inputs={
-                            **payload_vars,
-                        },
-                        query=prompt,
-                        user=session_id,
-                        conversation_id=conversation_id,
-                        files=files_payload,
-                        timeout=self.timeout,
-                    ):
-                        logger.debug(f"dify resp chunk: {chunk}")
-                        if (
-                            chunk["event"] == "message"
-                            or chunk["event"] == "agent_message"
-                        ):
-                            result += chunk["answer"]
-                            if not conversation_id:
-                                self.conversation_ids[session_id] = chunk[
-                                    "conversation_id"
-                                ]
-                                conversation_id = chunk["conversation_id"]
-                        elif chunk["event"] == "message_end":
-                            logger.debug("Dify message end")
-                            break
-                        elif chunk["event"] == "error":
-                            logger.error(f"Dify 出现错误：{chunk}")
-                            raise Exception(
-                                f"Dify 出现错误 status: {chunk['status']} message: {chunk['message']}"
-                            )
-
-                case "workflow":
-                    async for chunk in self.api_client.workflow_run(
-                        inputs={
-                            self.dify_query_input_key: prompt,
-                            "astrbot_session_id": session_id,
-                            **payload_vars,
-                        },
-                        user=session_id,
-                        files=files_payload,
-                        timeout=self.timeout,
-                    ):
-                        match chunk["event"]:
-                            case "workflow_started":
-                                logger.info(
-                                    f"Dify 工作流(ID: {chunk['workflow_run_id']})开始运行。"
-                                )
-                            case "node_finished":
-                                logger.debug(
-                                    f"Dify 工作流节点(ID: {chunk['data']['node_id']} Title: {chunk['data'].get('title', '')})运行结束。"
-                                )
-                            case "workflow_finished":
-                                logger.info(
-                                    f"Dify 工作流(ID: {chunk['workflow_run_id']})运行结束"
-                                )
-                                logger.debug(f"Dify 工作流结果：{chunk}")
-                                if chunk["data"]["error"]:
-                                    logger.error(
-                                        f"Dify 工作流出现错误：{chunk['data']['error']}"
-                                    )
-                                    raise Exception(
-                                        f"Dify 工作流出现错误：{chunk['data']['error']}"
-                                    )
-                                if (
-                                    self.workflow_output_key
-                                    not in chunk["data"]["outputs"]
-                                ):
-                                    raise Exception(
-                                        f"Dify 工作流的输出不包含指定的键名：{self.workflow_output_key}"
-                                    )
-                                result = chunk
-                case _:
-                    raise Exception(f"未知的 Dify API 类型：{self.api_type}")
-        except Exception as e:
-            logger.error(f"Dify 请求失败：{str(e)}")
-            return LLMResponse(role="err", completion_text=f"Dify 请求失败：{str(e)}")
-
-        if not result:
-            logger.warning("Dify 请求结果为空，请查看 Debug 日志。")
-
-        chain = await self.parse_dify_result(result)
-
-        return LLMResponse(role="assistant", result_chain=chain)
-
-    async def text_chat_stream(
-        self,
-        prompt,
-        session_id=None,
-        image_urls=...,
-        func_tool=None,
-        contexts=...,
-        system_prompt=None,
-        tool_calls_result=None,
-        **kwargs,
-    ):
-        # raise NotImplementedError("This method is not implemented yet.")
-        # 调用 text_chat 模拟流式
-        llm_response = await self.text_chat(
-            prompt=prompt,
-            session_id=session_id,
-            image_urls=image_urls,
-            func_tool=func_tool,
-            contexts=contexts,
-            system_prompt=system_prompt,
-            tool_calls_result=tool_calls_result,
-        )
-        llm_response.is_chunk = True
-        yield llm_response
-        llm_response.is_chunk = False
-        yield llm_response
-
-    async def parse_dify_result(self, chunk: dict | str) -> MessageChain:
-        if isinstance(chunk, str):
-            # Chat
-            return MessageChain(chain=[Comp.Plain(chunk)])
-
-        async def parse_file(item: dict) -> Comp:
-            match item["type"]:
-                case "image":
-                    return Comp.Image(file=item["url"], url=item["url"])
-                case "audio":
-                    # 仅支持 wav
-                    path = f"data/temp/{item['filename']}.wav"
-                    await download_file(item["url"], path)
-                    return Comp.Image(file=item["url"], url=item["url"])
-                case "video":
-                    return Comp.Video(file=item["url"])
-                case _:
-                    return Comp.File(name=item["filename"], file=item["url"])
-
-        output = chunk["data"]["outputs"][self.workflow_output_key]
-        chains = []
-        if isinstance(output, str):
-            # 纯文本输出
-            chains.append(Comp.Plain(output))
-        elif isinstance(output, list):
-            # 主要适配 Dify 的 HTTP 请求结点的多模态输出
-            for item in output:
-                # handle Array[File]
-                if (
-                    not isinstance(item, dict)
-                    or item.get("dify_model_identity", "") != "__dify__file__"
-                ):
-                    chains.append(Comp.Plain(str(output)))
-                    break
-        else:
-            chains.append(Comp.Plain(str(output)))
-
-        # scan file
-        files = chunk["data"].get("files", [])
-        for item in files:
-            comp = await parse_file(item)
-            chains.append(comp)
-
-        return MessageChain(chain=chains)
-
-    async def forget(self, session_id):
-        self.conversation_ids[session_id] = ""
-        return True
-
-    async def get_current_key(self):
-        return self.api_key
-
-    async def set_key(self, key):
-        raise Exception("Dify 适配器不支持设置 API Key。")
-
-    async def get_models(self):
-        return [self.get_model()]
-
-    async def get_human_readable_context(self, session_id, page, page_size):
-        raise Exception("暂不支持获得 Dify 的历史消息记录。")
-
-    async def terminate(self):
-        await self.api_client.close()

astrbot/core/provider/sources/llmtuner_source.py

@@ -1,132 +0,0 @@
-import os
-from llmtuner.chat import ChatModel
-from typing import List
-from .. import Provider
-from ..entities import LLMResponse
-from ..func_tool_manager import FuncCall
-from astrbot.core.db import BaseDatabase
-from ..register import register_provider_adapter
-
-
-@register_provider_adapter(
-    "llm_tuner", "LLMTuner 适配器, 用于装载使用 LlamaFactory 微调后的模型"
-)
-class LLMTunerModelLoader(Provider):
-    def __init__(
-        self,
-        provider_config: dict,
-        provider_settings: dict,
-        db_helper: BaseDatabase,
-        persistant_history=True,
-        default_persona=None,
-    ) -> None:
-        super().__init__(
-            provider_config,
-            provider_settings,
-            persistant_history,
-            db_helper,
-            default_persona,
-        )
-        if not os.path.exists(provider_config["base_model_path"]) or not os.path.exists(
-            provider_config["adapter_model_path"]
-        ):
-            raise FileNotFoundError("模型文件路径不存在。")
-        self.base_model_path = provider_config["base_model_path"]
-        self.adapter_model_path = provider_config["adapter_model_path"]
-        self.model = ChatModel(
-            {
-                "model_name_or_path": self.base_model_path,
-                "adapter_name_or_path": self.adapter_model_path,
-                "template": provider_config["llmtuner_template"],
-                "finetuning_type": provider_config["finetuning_type"],
-                "quantization_bit": provider_config["quantization_bit"],
-            }
-        )
-        self.set_model(
-            os.path.basename(self.base_model_path)
-            + "_"
-            + os.path.basename(self.adapter_model_path)
-        )
-
-    async def assemble_context(self, text: str, image_urls: List[str] = None):
-        """
-        组装上下文。
-        """
-        return {"role": "user", "content": text}
-
-    async def text_chat(
-        self,
-        prompt: str,
-        session_id: str = None,
-        image_urls: List[str] = None,
-        func_tool: FuncCall = None,
-        contexts: List = [],
-        system_prompt: str = None,
-        **kwargs,
-    ) -> LLMResponse:
-        system_prompt = ""
-        new_record = {"role": "user", "content": prompt}
-        query_context = [*contexts, new_record]
-
-        # 提取出系统提示
-        system_idxs = []
-        for idx, context in enumerate(query_context):
-            if context["role"] == "system":
-                system_idxs.append(idx)
-
-            if "_no_save" in context:
-                del context["_no_save"]
-
-        for idx in reversed(system_idxs):
-            system_prompt += " " + query_context.pop(idx)["content"]
-
-        conf = {
-            "messages": query_context,
-            "system": system_prompt,
-        }
-        if func_tool:
-            tool_list = func_tool.get_func_desc_openai_style()
-            if tool_list:
-                conf["tools"] = tool_list
-
-        responses = await self.model.achat(**conf)
-
-        llm_response = LLMResponse("assistant", responses[-1].response_text)
-
-        return llm_response
-
-    async def text_chat_stream(
-        self,
-        prompt,
-        session_id=None,
-        image_urls=...,
-        func_tool=None,
-        contexts=...,
-        system_prompt=None,
-        tool_calls_result=None,
-        **kwargs,
-    ):
-        # raise NotImplementedError("This method is not implemented yet.")
-        # 调用 text_chat 模拟流式
-        llm_response = await self.text_chat(
-            prompt=prompt,
-            session_id=session_id,
-            image_urls=image_urls,
-            func_tool=func_tool,
-            contexts=contexts,
-            system_prompt=system_prompt,
-            tool_calls_result=tool_calls_result,
-        )
-        llm_response.is_chunk = True
-        yield llm_response
-        llm_response.is_chunk = False
-        yield llm_response
-
-    async def get_current_key(self):
-        return "none"
-
-    async def set_key(self, key):
-        pass
-
-    async def get_models(self):
-        return [self.get_model()]

astrbot/core/rag/embedding/openai_source.py

@@ -1,20 +0,0 @@
-from typing import List
-from openai import AsyncOpenAI
-
-
-class SimpleOpenAIEmbedding:
-    def __init__(
-        self,
-        model,
-        api_key,
-        api_base=None,
-    ) -> None:
-        self.client = AsyncOpenAI(api_key=api_key, base_url=api_base)
-        self.model = model
-
-    async def get_embedding(self, text) -> List[float]:
-        """
-        获取文本的嵌入
-        """
-        embedding = await self.client.embeddings.create(input=text, model=self.model)
-        return embedding.data[0].embedding