pycoze 0.1.307__py3-none-any.whl → 0.1.309__py3-none-any.whl

pycoze/bot/tools.py

@@ -0,0 +1,279 @@
+import os
+import re
+import subprocess
+import fnmatch
+from typing import Dict
+from .message import info
+from .lib import get_formatted_filelist_str, read_local_file, resolve_relative_path
+from pycoze import ai
+from pycoze.api import window, web
+import traceback
+
+
+class InvalidToolError(Exception):
+    """无效工具错误"""
+
+    pass
+
+
+class Tool:
+    """工具基类"""
+
+    def __init__(self, params: Dict[str, str], cwd: str):
+        self.params = params
+        self.cwd = cwd
+
+    def validate(self) -> bool:
+        """验证参数是否有效"""
+        raise NotImplementedError
+
+    def execute(self) -> str:
+        """执行工具并返回结果"""
+        raise NotImplementedError
+
+
+class ExecuteCommandTool(Tool):
+    """执行命令工具"""
+
+    def validate(self) -> bool:
+        return "command" in self.params and "requires_approval" in self.params
+
+    def execute(self) -> str:
+        try:
+            if self.params["requires_approval"]:
+                approve = window.confirm(
+                    "confirm",
+                    f"Do you want to execute the command{self.params['command']}? ",
+                )
+                if approve.strip().lower().startswith("n"):
+                    return "User does not wish to run the command."
+            result = subprocess.run(
+                self.params["command"],
+                shell=True,
+                capture_output=True,
+                text=True,
+                cwd=self.cwd
+            )
+            if result.returncode != 0:
+                raise subprocess.CalledProcessError(
+                    result.returncode,
+                    self.params["command"],
+                    result.stdout,
+                    result.stderr,
+                )
+            return result.stdout + result.stderr
+        except subprocess.CalledProcessError as e:
+            return f"命令执行失败: {e.stderr}"
+        except Exception as e:
+            return f"执行命令时发生错误: {str(e)}"
+
+
+class ReadFileTool(Tool):
+    """读取文件工具"""
+
+    def validate(self) -> bool:
+        return "path" in self.params and os.path.exists(resolve_relative_path(self.cwd, self.params["path"]))
+
+    def execute(self) -> str:
+        path = resolve_relative_path(self.cwd, self.params["path"])
+        content = read_local_file(path)
+        return f"Successfully read the file, the content of the file [[{path}]] is:\n{content}\n\n\n"
+
+
+class ReadMultipleFilesTool(Tool):
+    """读取多个文件工具"""
+
+    def validate(self) -> bool:
+        return "paths_list" in self.params
+
+    def execute(self) -> str:
+        return_str = ""
+        for path in self.params["paths_list"]:
+            if os.path.exists(path):
+                path = resolve_relative_path(self.cwd, path)
+                content = read_local_file(path)
+                return_str += f"The content of the file [[{path}]] is:\n{content}\n\n\n"
+            else:
+                return_str += f"File {path}  does not exist.\n\n\n"
+        if return_str == "":
+            return_str = "No files were read"
+        return "Result of reading multiple files:" + return_str
+
+
+class WriteFileTool(Tool):
+    """写入或覆盖文件工具"""
+
+    def validate(self) -> bool:
+        return "path" in self.params and "content" in self.params
+
+    def execute(self) -> str:
+        path = resolve_relative_path(self.cwd, self.params["path"])
+        # 确保路径是绝对路径
+        if not os.path.isabs(path):
+            path = os.path.join(os.getcwd(), path)
+        # 创建目录并写入或覆盖文件
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(self.params["content"])
+        return f"File [[{path}]] written successfully."
+
+
+class ReplaceInFileTool(Tool):
+    """替换文件部分内容工具"""
+
+    def validate(self) -> bool:
+        return "path" in self.params and "diff" in self.params
+
+    def execute(self) -> str:
+        path = resolve_relative_path(self.cwd, self.params["path"])
+        with open(path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        # 处理差异内容
+        diff_content = self.params["diff"]
+        for diff_block in diff_content.split("<<<<<<< SEARCH")[1:]:
+            search, replace = diff_block.split("=======")
+            search = search.strip()
+            replace = replace.split(">>>>>>> REPLACE")[0].strip()
+            content = content.replace(search, replace, 1)
+
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+        return f"The content of the file {path}  has been replaced successfully."
+
+
+class SearchFilesTool(Tool):
+    """搜索文件工具"""
+
+    def validate(self) -> bool:
+        return "path" in self.params and "regex" in self.params
+
+    def execute(self) -> str:
+        path = resolve_relative_path(self.cwd, self.params["path"])
+        results = []
+        for root, _, files in os.walk(path):
+            for file in files:
+                if "file_pattern" in self.params:
+                    if not fnmatch.fnmatch(file, self.params["file_pattern"]):
+                        continue
+
+                file_path = os.path.join(root, file)
+                with open(file_path, "r", encoding="utf-8") as f:
+                    content = f.read()
+                    matches = re.finditer(self.params["regex"], content)
+                    for match in matches:
+                        results.append(f"{file_path}: {match.group()}")
+
+        return "\n".join(results) if results else "No matching content found."
+
+
+class ListFilesTool(Tool):
+    """列出文件工具"""
+
+    def validate(self) -> bool:
+        return "path" in self.params
+
+    def execute(self) -> str:
+        recursive = str(self.params.get("recursive", "false")).lower() == "true"
+        path = resolve_relative_path(self.cwd, self.params["path"])
+        return (
+            "Listing files completed successfully, result is:\n"
+            + get_formatted_filelist_str(path, recursive, 200)
+            + "\n\n\n"
+        )
+
+
+class WebAccessTool(Tool):
+    """访问网页工具"""
+
+    def validate(self) -> bool:
+        return "url" in self.params and "question" in self.params
+
+    def execute(self) -> str:
+        url = self.params["url"]
+        question = self.params["question"]
+        try:
+            content = web.get_simplified_webpage(url)[: 32 * 1024]
+            result = ai.chat(
+                [{
+                    "role": "user",
+                    "content": f"""Please answer user question based on web page content. The user's question is:
+{question}
+Web page content is:
+{content}"""
+                }],
+            )
+            return f"Web page access completed, result is: {result}"
+        except Exception as e:
+            print("WebAccessTool Exception", e)
+            return f"Failed to access web page: {str(e)}"
+
+
+class AskFollowUpQuestionTool(Tool):
+    """询问后续问题工具"""
+
+    def validate(self) -> bool:
+        return 'question' in self.params
+
+    def execute(self) -> str:
+        info("assistant", self.params['question'])
+        return f"Asked user: {self.params['question']}, Waiting for user replied.\n\n"
+
+
+class AttemptTaskCompletionTool(Tool):
+    """完成所有任务工具"""
+
+    def validate(self) -> bool:
+        return 'result' in self.params
+
+    def execute(self) -> str:
+        result = self.params['result']
+        info("assistant", 'Completed:' + result + "\n")
+        if 'command' in self.params:
+            result = subprocess.run(self.params['command'], shell=True, capture_output=True, text=True, cwd=self.cwd)
+            return f"Task completed: {result}, executed command: {self.params['command']}, execution result: {result.stdout + result.stderr}"
+        else:
+            return f"Task completed: {result}"
+
+
+class ToolExecutor:
+    """工具执行器"""
+
+    TOOL_MAP = {
+        "execute_command": ExecuteCommandTool,
+        "read_file": ReadFileTool,
+        "read_multiple_files": ReadMultipleFilesTool,
+        "write_or_overwrite_file": WriteFileTool,
+        "replace_part_of_a_file": ReplaceInFileTool,
+        "search_files": SearchFilesTool,
+        "list_files": ListFilesTool,
+        "access_webpage": WebAccessTool,
+        'ask_follow_up_question': AskFollowUpQuestionTool,
+        'complete_all_tasks': AttemptTaskCompletionTool,
+    }
+
+    @classmethod
+    def execute_tool(cls, cwd:str, tool_request, abilities) -> str:
+        """执行工具"""
+        try:
+            tool_name = list(tool_request.keys())[0]
+            params = tool_request[tool_name]
+            if not tool_name:
+                return "Error: Tool type is empty"
+            if tool_name in cls.TOOL_MAP:
+                tool_class = cls.TOOL_MAP[tool_name]
+            elif tool_name in [a.__name__ for a in abilities]:
+                func = [a for a in abilities if a.__name__ == tool_name][0]
+                try:
+                    result = func(**params)
+                except Exception as e:
+                    return traceback.format_exc()
+                return str(result)
+            else:
+                return f"Unknown tool: {tool_name}, the first key of output json ({tool_name}) will be recognized as a tool, so do not output other json except for executing tools."
+            tool = tool_class(params, cwd)
+            if not tool.validate():
+                return "Tool parameter validation failed."
+            return tool.execute()
+        except Exception as e:
+            return f"Tool execution failed:  {str(e)}"

pycoze/reference/lib.py

@@ -2,6 +2,7 @@ import os
 import sys
 import importlib
 import types
+import functools
 
 
 class ChangeDirectoryAndPath:
@@ -64,8 +65,8 @@ def wrapped_func(func, module_path):
         except:
             pass
         return result
-    _wrapped.__name__ = func.__name__
-    _wrapped.__doc__ =  func.__doc__ 
-    return _wrapped
+    
+    wrapped_function = functools.wraps(func)(_wrapped)
+    return wrapped_function
 
 

{pycoze-0.1.307.dist-info → pycoze-0.1.309.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pycoze
-Version: 0.1.307
+Version: 0.1.309
 Summary: Package for pycoze only!
 Author: Yuan Jie Xiong
 Author-email: aiqqqqqqq@qq.com

{pycoze-0.1.307.dist-info → pycoze-0.1.309.dist-info}/RECORD

@@ -11,19 +11,15 @@ pycoze/api/lib/tab.py,sha256=lD2Uvylzi-zsHj-27YI1mS4ggbIGtCi3vypvGvY48gM,2619
 pycoze/api/lib/view.py,sha256=_PIpTfeuTPPlMDKshMGsqFQYMq7ZiO4Hg5XwHwDoU60,7357
 pycoze/api/lib/web.py,sha256=GWgtiTJOolKOX2drXcwuyqTcbo5FQVxa1NuBGcNyjyc,223
 pycoze/api/lib/window.py,sha256=bTkQCzQZ7i3pYXB70bUSTBNJ9C4TW_X3yMae1VkquGk,1944
-pycoze/bot/__init__.py,sha256=JxnRoCCqx_LFyVb3pLu0qYCsH8ZLuAaMXAtvVUuCHuE,78
-pycoze/bot/agent_chat.py,sha256=Wqv0xMb9SFqf-G0__uXyFz6579u_QUe0EqbhP9IS3yc,4160
-pycoze/bot/bot.py,sha256=_qmUTZ09FmRLifHrW5stDZWGVK6yuMEMBC3fmeYJnqk,844
-pycoze/bot/agent/__init__.py,sha256=3wE8_FFQS8j2BY-g9Cr-onV0POEvDRZaw_NCzpqrNus,265
-pycoze/bot/agent/agent.py,sha256=qkLIRgSMNT1VD_UD0e6kYUuOTOqylQiYSCay6HZ12LA,3653
-pycoze/bot/agent/assistant.py,sha256=5LIgPIVVzx6uIOWT5S_XDDyPPjPHRBBNpIU3GiOkVHc,1186
-pycoze/bot/agent/chat.py,sha256=9wZ24CPdSbSnPCWmCQJle05U5VlDGgZhZ9z1mezLst0,816
-pycoze/bot/agent/agent_types/__init__.py,sha256=zmU2Kmrv5mCdfg-QlPn2H6pWxbGeq8s7YTqLhpzJC6k,179
-pycoze/bot/agent/agent_types/const.py,sha256=BfUKPrhAHREoMLHuFNG2bCIEkC1-f7K0LEqNg4RwiRE,70
-pycoze/bot/agent/agent_types/openai_func_call_agent.py,sha256=3qOyrddujtJ50W9SbH5bapbVTwjgE_LC2TnYJWUH9yc,6649
+pycoze/bot/__init__.py,sha256=rL3Q-ycczRpSFfKn84fg3QBl5k22WpyeIU5qOEjEby8,79
+pycoze/bot/chat.py,sha256=cYMXFe0hgN0CTcI5BiUtte2eTZwgYLKq1vBDQ-eqB5c,3246
+pycoze/bot/chat_base.py,sha256=6I_ZfHun9w95Aysz5zGa5E62Dd0YJIYMkd-_Bl4AjJA,9031
+pycoze/bot/lib.py,sha256=2QyOOlPR8K0_KDJNT96X35SMdn5SF26vYiYzZMw5484,6855
+pycoze/bot/message.py,sha256=Zq-_k8HztBMOUIs3hbOvWvwHBNopn4UJJBliCROIGcc,718
+pycoze/bot/tools.py,sha256=vjRksWfE3IJv405IaDAhdqIsIaB156FUP8HBbcroQRc,9601
 pycoze/reference/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pycoze/reference/bot.py,sha256=pxHVYo0G3P3YZ--vBYbMEiEyBoxxPwaO5dMTf9WFMSc,2014
-pycoze/reference/lib.py,sha256=dAzNuGztXt4k8BKau-6-nt8dOEAnjfBSBhC4Jq48wL4,2181
+pycoze/reference/lib.py,sha256=6jvowP2LqjyV21ppRhmtxHxnQJHCbHmlpbj9btV2RQ4,2191
 pycoze/reference/tool.py,sha256=h7G3KSoZYWq5IJu6E0-shIQ3XiJeJsgSM85GxEnhF98,1107
 pycoze/reference/workflow.py,sha256=whQtw_FAxvlSbjow1oNFLdytPjjRs_pDBbQmNjaX6zc,1340
 pycoze/ui/__init__.py,sha256=uaXet23wUk64TcZjpBX8qOx4aUhwA_ucrmcxy7Q4Qr4,929
@@ -36,8 +32,8 @@ pycoze/utils/arg.py,sha256=jop1tBfe5hYkHW1NSpCeaZBEznkgguBscj_7M2dWfrs,503
 pycoze/utils/env.py,sha256=5pWlXfM1F5ZU9hhv1rHlDEanjEW5wf0nbyez9bNRqqA,559
 pycoze/utils/socket.py,sha256=bZbFFRH4mfThzRqt55BAAGQ6eICx_ja4x8UGGrUdAm8,2428
 pycoze/utils/text_or_file.py,sha256=gpxZVWt2DW6YiEg_MnMuwg36VNf3TX383QD_1oZNB0Y,551
-pycoze-0.1.307.dist-info/LICENSE,sha256=QStd_Qsd0-kAam_-sOesCIp_uKrGWeoKwt9M49NVkNU,1090
-pycoze-0.1.307.dist-info/METADATA,sha256=WVS9Be_q7xfwuRHRanJWI0SnbTYj7QglPs124yEJd6U,854
-pycoze-0.1.307.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-pycoze-0.1.307.dist-info/top_level.txt,sha256=76dPeDhKvOCleL3ZC5gl1-y4vdS1tT_U1hxWVAn7sFo,7
-pycoze-0.1.307.dist-info/RECORD,,
+pycoze-0.1.309.dist-info/LICENSE,sha256=QStd_Qsd0-kAam_-sOesCIp_uKrGWeoKwt9M49NVkNU,1090
+pycoze-0.1.309.dist-info/METADATA,sha256=Q4lw_smH95fa-wbcASknh_-AkBOhHnvYn1MOxRzAu6w,854
+pycoze-0.1.309.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+pycoze-0.1.309.dist-info/top_level.txt,sha256=76dPeDhKvOCleL3ZC5gl1-y4vdS1tT_U1hxWVAn7sFo,7
+pycoze-0.1.309.dist-info/RECORD,,

pycoze/bot/agent/__init__.py

@@ -1,5 +0,0 @@
-from .agent import run_agent
-from .assistant import Runnable
-from .chat import INPUT_MESSAGE, INTERRUPT_MESSAGE,  CHAT_DATA, clear_chat_data, output, info
-
-__all__ = [run_agent, Runnable, INPUT_MESSAGE, INTERRUPT_MESSAGE,  CHAT_DATA, clear_chat_data, output, info]

pycoze/bot/agent/agent.py

@@ -1,95 +0,0 @@
-import asyncio
-import json
-from langchain_openai import ChatOpenAI
-from .chat import info
-from .assistant import Runnable
-from langchain_core.messages import (
-    HumanMessage,
-    AIMessage,
-    AIMessageChunk,
-    SystemMessage,
-)
-from .agent_types.const import HumanToolString
-
-
-async def run_agent(agent, inputs: list, tool_compatibility_mode: bool):
-    exist_ids = set()
-    content_list = []
-    async for event in agent.astream_events(inputs, version="v2"):
-        kind = event["event"]
-        if kind == "on_chain_end":
-            if "data" in event:
-                if (
-                    "output" in event["data"]
-                    and event["data"]["output"] == "end"
-                    and "input" in event["data"]
-                    and isinstance(event["data"]["input"], list)
-                ):
-                    input_list = event["data"]["input"]
-                    for msg in input_list:
-                        if isinstance(msg, HumanMessage) or isinstance(
-                            msg, SystemMessage
-                        ):
-                            if (
-                                not tool_compatibility_mode
-                                or not msg.content.startswith(HumanToolString)
-                            ):
-                                content_list = []  # 防止内容重复
-                        if isinstance(msg, AIMessage) and not isinstance(
-                            msg, AIMessageChunk
-                        ):
-                            content = msg.content
-                            if content:
-                                content_list.append(content)
-        elif kind == "on_chat_model_stream":
-            content = event["data"]["chunk"].content
-            if content:
-                info("assistant", content)
-        elif kind == "on_chain_start":
-            data = event["data"]
-            if "input" in data:
-                input_list = (
-                    data["input"]
-                    if isinstance(data["input"], list)
-                    else [data["input"]]
-                )
-                if len(input_list) == 0:
-                    continue
-                msg = input_list[-1]
-                if isinstance(msg, AIMessage) and not isinstance(msg, AIMessageChunk):
-                    if "tool_calls" in msg.additional_kwargs:
-                        tool_calls = msg.additional_kwargs["tool_calls"]
-                        for t in tool_calls:
-                            if t["id"] in exist_ids:
-                                continue
-                            exist_ids.add(t["id"])
-                            tool = t["function"]["name"]
-                            info("assistant", f"\n[调用工具:{tool}]\n\n")
-
-    return "\n".join(content_list)
-
-
-if __name__ == "__main__":
-    from langchain_experimental.tools import PythonREPLTool
-    import threading
-
-    llm_file = r"C:\Users\aiqqq\AppData\Roaming\pycoze\JsonStorage\llm.json"
-    with open(llm_file, "r", encoding="utf-8") as f:
-        cfg = json.load(f)
-        chat = ChatOpenAI(
-            api_key=cfg["apiKey"],
-            base_url=cfg["baseURL"],
-            model=cfg["model"],
-            temperature=0,
-        )
-    python_tool = PythonREPLTool()
-    agent = Runnable(
-        agent_execution_mode="FuncCall",
-        tools=[python_tool],
-        llm=chat,
-        assistant_message="请以女友的口吻回答，输出不小于100字，可以随便说点其他的",
-        tool_compatibility_mode=False,
-    )
-
-    inputs = [HumanMessage(content="计算根号7+根号88")]
-    print(asyncio.run(run_agent(agent, inputs, True, threading.Event())))

pycoze/bot/agent/agent_types/__init__.py

@@ -1,4 +0,0 @@
-from .openai_func_call_agent import create_openai_func_call_agent_executor
-from .const import HumanToolString
-
-__all__ = [create_openai_func_call_agent_executor, HumanToolString]

pycoze/bot/agent/agent_types/const.py

@@ -1 +0,0 @@
-HumanToolString = 'The tool call is done, the result is as follows:\n'

pycoze/bot/agent/agent_types/openai_func_call_agent.py

@@ -1,181 +0,0 @@
-# reference：https://github.com/maxtheman/opengpts/blob/d3425b1ba80aec48953a327ecd9a61b80efb0e69/backend/app/agent_types/openai_agent.py
-import json
-from langchain.tools import BaseTool
-from langchain_core.utils.function_calling import convert_to_openai_tool
-from langchain_core.language_models.base import LanguageModelLike
-from langchain_core.messages import SystemMessage, ToolMessage, HumanMessage
-from langgraph.graph import END
-from langgraph.graph.message import MessageGraph
-from langgraph.prebuilt import ToolExecutor, ToolInvocation
-import re
-import json
-import random
-from .const import HumanToolString
-
-
-def get_all_markdown_json(content):
-    # Find all markdown json blocks
-    markdown_json_blocks = re.findall(r"```json(.*?)```", content, re.DOTALL)
-    json_list = []
-
-    for block in markdown_json_blocks:
-        try:
-            # Remove any leading/trailing whitespace and parse the JSON
-            json_data = json.loads(block.strip())
-            json_list.append(json_data)
-        except json.JSONDecodeError:
-            # If the block is not valid JSON, skip it
-            continue
-
-    return json_list
-
-
-def get_tools(last_message):
-    if "tool_calls" in last_message.additional_kwargs:
-        return last_message.additional_kwargs["tool_calls"]
-    else:
-        tool_calls = []
-        if '"name"' in last_message.content and '"parameters":' in last_message.content:
-            print("name 和 paremeters 模式")
-            all_json = get_all_markdown_json(last_message.content)
-            tool_calls = []
-            for tool_call in all_json:
-                if "name" not in tool_call or "parameters" not in tool_call:
-                    return "end"
-                tool_call["arguments"] = json.dumps(tool_call["parameters"])
-                tool_call.pop("parameters")
-                tool_calls.append(
-                    {
-                        "function": tool_call,
-                        "id": random.randint(0, 1000000),
-                    }
-                )
-        if "<｜tool▁sep｜>" in last_message.content:
-            print("deepseek的bug: <｜tool▁sep｜> 模式")
-            name = (
-                last_message.content.split("<｜tool▁sep｜>")[1].split("```")[0].strip()
-            )
-            all_json = get_all_markdown_json(last_message.content)
-            tool_calls = []
-            for argument in all_json:
-                tool_calls.append(
-                    {
-                        "function": {
-                            "name": name,
-                            "arguments": json.dumps(argument),
-                        },
-                        "id": random.randint(0, 1000000),
-                    }
-                )
-
-        return tool_calls
-
-
-def create_openai_func_call_agent_executor(
-    tools: list[BaseTool],
-    llm: LanguageModelLike,
-    system_message: str,
-    tool_compatibility_mode: str,
-    **kwargs
-):
-
-    async def _get_messages(messages):
-        msgs = []
-        for m in messages:
-            if isinstance(m, ToolMessage):
-                _dict = m.model_dump()
-                _dict["content"] = str(_dict["content"])
-                m_c = ToolMessage(**_dict)
-                msgs.append(m_c)
-            else:
-                msgs.append(m)
-
-        return [SystemMessage(content=system_message)] + msgs
-
-    if tools and not tool_compatibility_mode:
-        llm_with_tools = llm.bind(tools=[convert_to_openai_tool(t) for t in tools])
-    else:
-        llm_with_tools = llm
-    agent = _get_messages | llm_with_tools
-    tool_executor = ToolExecutor(tools)
-
-    # Define the function that determines whether to continue or not
-    def should_continue(messages):
-        # If there is no FuncCall, then we finish
-        last_message = messages[-1]
-        if last_message.content.strip().endswith("```"):
-            last_message.content = last_message.content + "\n\n"  # 避免影响阅读
-        tools = get_tools(last_message)
-        if last_message.tool_calls or tools:
-            return "continue"
-        return "end"
-
-    # Define the function to execute tools
-    async def call_tool(messages):
-        actions: list[ToolInvocation] = []
-        # Based on the continue condition
-        # we know the last message involves a FuncCall
-        last_message = messages[-1]
-        for tool_call in get_tools(last_message):
-            function = tool_call["function"]
-            function_name = function["name"]
-            if function_name == "a_delay_function":
-                return [
-                    ToolMessage(
-                        tool_call_id=tool_call["id"],
-                        content="a_delay_function只是一个占位符，请忽略重新调用工具",
-                        additional_kwargs={"name": tool_call["function"]["name"]},
-                    )
-                ]
-
-            _tool_input = json.loads(function["arguments"] or "{}")
-            # We construct an ToolInvocation from the function_call
-            actions.append(
-                ToolInvocation(
-                    tool=function_name,
-                    tool_input=_tool_input,
-                )
-            )
-        # We call the tool_executor and get back a response
-        responses = await tool_executor.abatch(actions, **kwargs)
-        # We use the response to create a ToolMessage
-        tool_messages = []
-        for tool_call, response in zip(get_tools(last_message), responses):
-            if not isinstance(response, (str, int, float, bool, list, tuple)):
-                response = repr(
-                    response
-                )  # 不支持其他类型，包括dict也不支持，因此需要转换为字符串
-
-            message = ToolMessage(
-                tool_call_id=tool_call["id"],
-                content=response,
-                additional_kwargs={"name": tool_call["function"]["name"]},
-            )
-            tool_messages.append(message)
-        if tool_compatibility_mode:
-            # HumanMessage
-            tool_msgs_str = repr(tool_messages)
-            tool_messages = [HumanMessage(content=HumanToolString + tool_msgs_str)]
-        return tool_messages
-
-    workflow = MessageGraph()
-
-    # Define the two nodes we will cycle between
-    workflow.add_node("agent", agent)
-    workflow.add_node("call_tool", call_tool)
-
-    workflow.set_entry_point("agent")
-
-    workflow.add_conditional_edges(
-        "agent",
-        should_continue,
-        {
-            "continue": "call_tool",
-            "end": END,
-        },
-    )
-
-    # 调用完工具后，再次调用agent
-    workflow.add_edge("call_tool", "agent")
-
-    return workflow.compile()

pycoze/bot/agent/assistant.py

@@ -1,35 +0,0 @@
-from typing import Sequence
-from langchain.tools import BaseTool
-from langchain_core.language_models.base import LanguageModelLike
-from langchain_core.runnables import RunnableBinding
-from .agent_types import create_openai_func_call_agent_executor
-
-
-class Runnable(RunnableBinding):
-    agent_execution_mode: str
-    tools: Sequence[BaseTool]
-    llm: LanguageModelLike
-    assistant_message: str
-
-    def __init__(
-        self,
-        *,
-        agent_execution_mode: str,
-        tools: Sequence[BaseTool],
-        llm: LanguageModelLike,
-        assistant_message: str,
-        tool_compatibility_mode: bool
-    ) -> None:
-
-        agent_executor = create_openai_func_call_agent_executor(
-            tools, llm, assistant_message, tool_compatibility_mode
-        )
-        agent_executor = agent_executor.with_config({"recursion_limit": 50})
-        super().__init__(
-            tools=tools if not tool_compatibility_mode else [],
-            llm=llm,
-            agent_execution_mode=agent_execution_mode,
-            assistant_message=assistant_message,
-            bound=agent_executor,
-            return_intermediate_steps=True,
-        )