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

pycoze/reference/lib.py

@@ -1,9 +1,42 @@
 import os
 import sys
 import importlib
-import types
+import functools
+import inspect
+import asyncio
+import nest_asyncio
 
+# 应用 nest_asyncio 补丁，以允许在已经运行的事件循环中再次运行事件循环
+nest_asyncio.apply() 
 
+def call_func(func, args=None, kwargs=None):
+    if args is None:
+        args = ()
+    if kwargs is None:
+        kwargs = {}
+
+    if inspect.isgeneratorfunction(func):
+        return list(func(*args, **kwargs))
+    elif inspect.iscoroutinefunction(func):
+        coro = func(*args, **kwargs) if inspect.iscoroutinefunction(func) else func
+        try:
+            # 尝试获取当前运行的事件循环
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            # 如果没有运行的事件循环，使用 asyncio.run()
+            return asyncio.run(coro)
+        else:
+            # 如果事件循环已经在运行，直接调度协程并等待结果
+            async def run_coro():
+                return await coro
+            # 在当前事件循环中调度任务并等待完成
+            future = asyncio.ensure_future(run_coro())
+            while not future.done():
+                loop.run_until_complete(asyncio.sleep(0.1))  # 避免阻塞
+            return future.result()
+    else:
+        return func(*args, **kwargs)
+    
 class ChangeDirectoryAndPath:
     """Context manager to change the current working directory and sys.path."""
 
@@ -18,7 +51,8 @@ class ChangeDirectoryAndPath:
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
-        sys.path.remove(self.module_path)
+        if self.module_path in sys.path:
+            sys.path.remove(self.module_path)
         os.chdir(self.old_path)
         
 
@@ -56,16 +90,16 @@ def wrapped_func(func, module_path):
         except:
             print(f"called unknown")
         with ChangeDirectoryAndPath(module_path):
-            result = func(*args, **kwargs)
-        try:
-            if isinstance(result, types.GeneratorType):
-                result = list(result)
-            print(f"{func.__name__} 调用完毕,结果为:", result)
-        except:
-            pass
-        return result
-    _wrapped.__name__ = func.__name__
-    _wrapped.__doc__ =  func.__doc__ 
-    return _wrapped
+            try:
+                result = call_func(func, args, kwargs)
+            except Exception as e:
+                print(f"调用 {func.__name__} 时发生错误: {str(e)}")
+                raise
+        
+        print(f"{func.__name__} 调用完毕,结果为:", result)
 
+        return result
+    
+    wrapped_function = functools.wraps(func)(_wrapped)
+    return wrapped_function
 

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

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

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

@@ -11,19 +11,16 @@ 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=ts2Qr7IZGyTFlnIccG8m04H7c8Yr1xtjPgzmjeQUzo4,3351
+pycoze/bot/chat_base.py,sha256=H6zLxblMbyDLsf5T13YYCoEfLl__axw67PbfM0vnYbg,9242
+pycoze/bot/lib.py,sha256=smigeWuhl8esHE-Y5l_9bpjJkEJ5OqrxTyPcO8JIubM,7224
+pycoze/bot/message.py,sha256=Zq-_k8HztBMOUIs3hbOvWvwHBNopn4UJJBliCROIGcc,718
+pycoze/bot/prompt.md,sha256=XHP8EdtzmnlMbM0xTe5GKnjAIFq7KauUARiNly2atz4,15777
+pycoze/bot/tools.py,sha256=j8l0sXEPn_yjTllHcmYEr_auVDuOicXdDco4bhZVIIA,9694
 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=ixiexCA6XWAda_G2ZVDSbFqTJmbkTvYLN47-nc5zyFU,3530
 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 +33,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.334.dist-info/LICENSE,sha256=QStd_Qsd0-kAam_-sOesCIp_uKrGWeoKwt9M49NVkNU,1090
+pycoze-0.1.334.dist-info/METADATA,sha256=3ILPNMNEHtM9bWi3C9mmZvzCxaa0kxmz3_QGewzOUbk,854
+pycoze-0.1.334.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+pycoze-0.1.334.dist-info/top_level.txt,sha256=76dPeDhKvOCleL3ZC5gl1-y4vdS1tT_U1hxWVAn7sFo,7
+pycoze-0.1.334.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,
-        )

pycoze/bot/agent_chat.py

@@ -1,110 +0,0 @@
-import json
-from langchain_openai import ChatOpenAI
-from .agent import run_agent, Runnable,CHAT_DATA, clear_chat_data
-import asyncio
-from pycoze import utils
-from pycoze.reference.bot import ref_bot
-from pycoze.reference.tool import ref_tools
-from pycoze.reference.workflow import ref_workflow
-from langchain_core.utils.function_calling import convert_to_openai_tool
-import os
-
-cfg = utils.read_json_file("llm.json")
-
-def load_bot_setting(bot_setting_file: str):
-    with open(bot_setting_file, "r", encoding="utf-8") as f:
-        return json.load(f)
-
-
-def load_abilities(bot_setting_file: str):
-    with open(bot_setting_file, "r", encoding="utf-8") as f:
-        bot_setting = json.load(f)
-
-    abilities = []
-    for bot_id in bot_setting["bots"]:
-        bot = ref_bot(bot_id, as_agent_tool=True)
-        if bot:
-            abilities.append(bot)
-    for tool_id in bot_setting["tools"]:
-        abilities.extend(ref_tools(tool_id, as_agent_tool=True))
-    for workflow_id in bot_setting["workflows"]:
-        workflow = ref_workflow(workflow_id, as_agent_tool=True)
-        if workflow:
-            abilities.append(workflow)
-    return abilities
-
-
-async def check_interrupt_file(interval, interrupt_file,agent_task):
-    while True:
-        await asyncio.sleep(interval)
-        if os.path.exists(interrupt_file):
-            os.remove(interrupt_file)
-            agent_task.cancel()
-            break
-
-async def run_with_interrupt_check(agent, history, tool_compatibility_mode, interrupt_file, check_interval=1):
-    clear_chat_data()
-    try:
-        agent_task = asyncio.create_task(run_agent(agent, history, tool_compatibility_mode))
-        check_task = asyncio.create_task(check_interrupt_file(check_interval, interrupt_file, agent_task))
-        result = await agent_task
-        return result
-    except asyncio.CancelledError:
-        return CHAT_DATA['info']
-    except Exception as e:
-        import traceback
-        print(traceback.format_exc())
-        return None  # 返回 None 或者处理异常后的结果
-    finally:
-        if not agent_task.done():
-            agent_task.cancel()
-        # 确保即使发生异常也会取消检查任务
-        if not check_task.done():
-            check_task.cancel()
-            try:
-                await check_task
-            except asyncio.CancelledError:
-                pass  # 忽略取消错误
-
-async def agent_chat(bot_setting_file, history):
-    bot_setting = load_bot_setting(bot_setting_file)
-    abilities = load_abilities(bot_setting_file)
-
-    chat = ChatOpenAI(
-        api_key=cfg["apiKey"],
-        base_url=cfg["baseURL"],
-        model=cfg["model"],
-        temperature=bot_setting["temperature"],
-        stop_sequences=[
-            "tool▁calls▁end",
-            "tool▁call▁end",
-        ],  # 不然会虚构工具调用过程和结果
-    )
-    prompt = bot_setting["prompt"]
-    if cfg["toolCompatibilityMode"] and len(abilities) > 0:
-        prompt += """
-作为一个AI，你如果不确定结果，请务必使用工具查询。
-你可以通过下面的方式使用工具，并耐心等待工具返回结果。
-如果你需要调用工具，请使用以正确markdown中的json代码格式进行结尾（务必保证json格式正确，不要出现反斜杠未转义等问题）：
-```json
-{"name": 函数名, "parameters": 参数词典}
-```
-"""
-        prompt += "\nAvailable functions:\n"
-        for t in abilities:
-            prompt += f"\n```json\n{json.dumps(convert_to_openai_tool(t))}\n```"
-    agent = Runnable(
-        agent_execution_mode="FuncCall",
-        tools=abilities,
-        llm=chat,
-        assistant_message=prompt,
-        tool_compatibility_mode=cfg["toolCompatibilityMode"],
-    )
-    params = utils.params
-    if "interruptFile" in params:
-        interrupt_file_path = params["interruptFile"]
-        result = await run_with_interrupt_check(agent, history, cfg["toolCompatibilityMode"], interrupt_file_path)
-    else:
-        result = await run_agent(agent, history, cfg["toolCompatibilityMode"])
-    return result
-

pycoze/bot/bot.py

@@ -1,23 +0,0 @@
-from langchain_core.messages import HumanMessage, AIMessage
-import json
-from .agent import INPUT_MESSAGE, output, CHAT_DATA, clear_chat_data
-from .agent_chat import agent_chat
-import asyncio
-
-
-def chat(bot_setting_file: str):
-    history = []
-    while True:
-        input_text = input()
-        if not input_text.startswith(INPUT_MESSAGE):
-            raise ValueError("Invalid message")
-        message = json.loads(input_text[len(INPUT_MESSAGE) :])
-        history.append(HumanMessage(message["content"]))
-        result = asyncio.run(agent_chat(bot_setting_file, history))
-        output("assistant", result)
-        history.append(AIMessage(result))
-
-
-def get_chat_response(bot_setting_file: str, input_text: str):
-    result = asyncio.run(agent_chat(bot_setting_file, [HumanMessage(input_text)]))
-    return result