pycoze 0.1.0__py3-none-any.whl → 0.1.3__py3-none-any.whl

pycoze/__init__.py

@@ -1,2 +1,2 @@
-def hello():
-    return "Hello, World!"
+from . import bot
+from . import utils

pycoze/bot/__init__.py

@@ -0,0 +1 @@
+from .bot import chat

pycoze/bot/agent/__init__.py

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

pycoze/bot/agent/agent.py

@@ -0,0 +1,67 @@
+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
+from langchain_core.agents import AgentFinish
+
+
+
+async def run_agent(agent, inputs: list):
+    if agent.agent_execution_mode == 'FuncCall':
+        content_list = []
+        async for event in agent.astream_events(inputs, version="v2"):
+            kind = event["event"]
+            if kind == "on_chat_model_stream":
+                content = event["data"]["chunk"].content
+                if content:
+                    content_list.append(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"]]
+                    msg = input_list[-1]
+                    if isinstance(msg, AIMessage) and not isinstance(msg, AIMessageChunk):
+                        if "tool_calls" in msg.additional_kwargs:
+                            tools = [t["function"]["name"] for t in msg.additional_kwargs["tool_calls"]]
+                            tools_str = ",".join(tools)
+                            info("assistant", f"(调用工具:{tools_str})")
+                            
+        return "".join(content_list)
+    else:
+        assert agent.agent_execution_mode == 'ReAct'
+        inputs_msg = {'input': inputs[-1].content,'chat_history': inputs[:-1]}
+        use_tools = []
+        async for event in agent.astream_events(inputs_msg, version="v2"):
+            kind = event["event"]
+            result = None
+            if kind == "on_chain_end":
+                if 'data' in event:
+                    if 'output' in event['data']:
+                        output = event['data']['output']
+                        if 'agent_outcome' in output and "input" in output:
+                            outcome = output['agent_outcome']
+                            if isinstance(outcome, AgentFinish):
+                                result = outcome.return_values['output']
+            elif kind == "on_tool_start":
+                use_tools.append(event['name'])
+                info("assistant", f"(调用工具:{use_tools})")
+        return result
+
+
+if __name__ == "__main__":
+    from langchain_experimental.tools import PythonREPLTool
+    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', # 'FuncCall' or 'ReAct'，大模型支持FuncCall的话就用FuncCall
+                                               tools=[python_tool],
+                                               llm=chat,
+                                               assistant_message="请以女友的口吻回答，输出不小于100字，可以随便说点其他的",)
+
+    inputs = [HumanMessage(content="计算根号7+根号88")]
+    print(asyncio.run(run_agent(agent, inputs)))

pycoze/bot/agent/agent_types/__init__.py

@@ -0,0 +1,10 @@
+from .openai_func_call_agent import (
+    create_openai_func_call_agent_executor
+)
+from .react_agent import create_react_agent_executor
+
+
+__all__ = [
+    create_openai_func_call_agent_executor,
+    create_react_agent_executor
+]

pycoze/bot/agent/agent_types/openai_func_call_agent.py

@@ -0,0 +1,113 @@
+# 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
+from langgraph.graph import END
+from langgraph.graph.message import MessageGraph
+from langgraph.prebuilt import ToolExecutor, ToolInvocation
+from typing import Any
+
+
+def create_openai_func_call_agent_executor(tools: list[BaseTool], llm: LanguageModelLike,
+                                        system_message: str, **kwargs):
+
+    async def _get_messages(messages):
+        msgs = []
+        for m in messages:
+            if isinstance(m, ToolMessage):
+                _dict = m.dict()
+                _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:
+        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 not last_message.tool_calls:
+            return "end"
+        # Otherwise if there is, we continue
+        else:
+            return "continue"
+
+    # 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 last_message.additional_kwargs['tool_calls']:
+            function = tool_call['function']
+            function_name = 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 = [
+            ToolMessage(
+                tool_call_id=tool_call['id'],
+                content=response,
+                additional_kwargs={'name': tool_call['function']['name']},
+            )
+            for tool_call, response in zip(last_message.additional_kwargs['tool_calls'], responses)
+        ]
+        return tool_messages
+
+    workflow = MessageGraph()
+
+    # Define the two nodes we will cycle between
+    workflow.add_node('agent', agent)
+    workflow.add_node('action', call_tool)
+
+    # Set the entrypoint as `agent`
+    # This means that this node is the first one called
+    workflow.set_entry_point('agent')
+
+    # We now add a conditional edge
+    workflow.add_conditional_edges(
+        # First, we define the start node. We use `agent`.
+        # This means these are the edges taken after the `agent` node is called.
+        'agent',
+        # Next, we pass in the function that will determine which node is called next.
+        should_continue,
+        # Finally we pass in a mapping.
+        # The keys are strings, and the values are other nodes.
+        # END is a special node marking that the graph should finish.
+        # What will happen is we will call `should_continue`, and then the output of that
+        # will be matched against the keys in this mapping.
+        # Based on which one it matches, that node will then be called.
+        {
+            # If `tools`, then we call the tool node.
+            'continue': 'action',
+            # Otherwise we finish.
+            'end': END,
+        },
+    )
+
+    # We now add a normal edge from `tools` to `agent`.
+    # This means that after `tools` is called, `agent` node is called next.
+    workflow.add_edge('action', 'agent')
+
+    # Finally, we compile it!
+    # This compiles it into a LangChain Runnable,
+    # meaning you can use it as you would any other runnable
+    return workflow.compile()

pycoze/bot/agent/agent_types/react_agent.py

@@ -0,0 +1,170 @@
+# https://github.com/langchain-ai/langgraph/blob/ea071935fef240d631305df12b6d83e9c363cef3/libs/langgraph/langgraph/prebuilt/agent_executor.py
+import operator
+from typing import Annotated, Sequence, TypedDict, Union
+from langchain.tools import BaseTool
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.messages import BaseMessage
+from langchain_core.language_models import LanguageModelLike
+from langgraph.graph import END, StateGraph
+from langgraph.graph.state import CompiledStateGraph
+from langgraph.prebuilt.tool_executor import ToolExecutor
+from langgraph.utils import RunnableCallable
+from langchain.agents import create_structured_chat_agent
+from .react_prompt import react_agent_prompt
+
+
+def create_react_agent_executor(
+    tools: list[BaseTool], 
+    llm: LanguageModelLike,
+    system_message: str, 
+    **kwargs # ignore
+):
+    prompt = react_agent_prompt.partial(assistant_message=system_message)
+    agent = create_structured_chat_agent(llm, tools, prompt)
+    agent_executer = create_agent_executor(agent, tools)
+    return agent_executer
+
+
+def _get_agent_state(input_schema=None):
+    if input_schema is None:
+
+        class AgentState(TypedDict):
+            # The input string
+            input: str
+            # The list of previous messages in the conversation
+            chat_history: Sequence[BaseMessage]
+            # The outcome of a given call to the agent
+            # Needs `None` as a valid type, since this is what this will start as
+            agent_outcome: Union[AgentAction, AgentFinish, None]
+            # List of actions and corresponding observations
+            # Here we annotate this with `operator.add` to indicate that operations to
+            # this state should be ADDED to the existing values (not overwrite it)
+            intermediate_steps: Annotated[list[tuple[AgentAction, str]], operator.add]
+
+    else:
+
+        class AgentState(input_schema):
+            # The outcome of a given call to the agent
+            # Needs `None` as a valid type, since this is what this will start as
+            agent_outcome: Union[AgentAction, AgentFinish, None]
+            # List of actions and corresponding observations
+            # Here we annotate this with `operator.add` to indicate that operations to
+            # this state should be ADDED to the existing values (not overwrite it)
+            intermediate_steps: Annotated[list[tuple[AgentAction, str]], operator.add]
+
+    return AgentState
+
+
+def create_agent_executor(
+    agent_runnable, tools, input_schema=None
+) -> CompiledStateGraph:
+    """This is a helper function for creating a graph that works with LangChain Agents.
+
+    Args:
+        agent_runnable (RunnableLike): The agent runnable.
+        tools (list): A list of tools to be used by the agent.
+        input_schema (dict, optional): The input schema for the agent. Defaults to None.
+
+    Returns:
+        The `CompiledStateGraph` object.
+    """
+
+    if isinstance(tools, ToolExecutor):
+        tool_executor = tools
+    else:
+        tool_executor = ToolExecutor(tools)
+
+    state = _get_agent_state(input_schema)
+
+    # Define logic that will be used to determine which conditional edge to go down
+
+    def should_continue(data):
+        # If the agent outcome is an AgentFinish, then we return `exit` string
+        # This will be used when setting up the graph to define the flow
+        if isinstance(data["agent_outcome"], AgentFinish):
+            return "end"
+        # Otherwise, an AgentAction is returned
+        # Here we return `continue` string
+        # This will be used when setting up the graph to define the flow
+        else:
+            return "continue"
+
+    def run_agent(data, config):
+        agent_outcome = agent_runnable.invoke(data, config)
+        return {"agent_outcome": agent_outcome}
+
+    async def arun_agent(data, config):
+        agent_outcome = await agent_runnable.ainvoke(data, config)
+        return {"agent_outcome": agent_outcome}
+
+    # Define the function to execute tools
+    def execute_tools(data, config):
+        # Get the most recent agent_outcome - this is the key added in the `agent` above
+        agent_action = data["agent_outcome"]
+        if not isinstance(agent_action, list):
+            agent_action = [agent_action]
+        output = tool_executor.batch(agent_action, config, return_exceptions=True)
+        return {
+            "intermediate_steps": [
+                (action, str(out)) for action, out in zip(agent_action, output)
+            ]
+        }
+
+    async def aexecute_tools(data, config):
+        # Get the most recent agent_outcome - this is the key added in the `agent` above
+        agent_action = data["agent_outcome"]
+        if not isinstance(agent_action, list):
+            agent_action = [agent_action]
+        output = await tool_executor.abatch(
+            agent_action, config, return_exceptions=True
+        )
+        return {
+            "intermediate_steps": [
+                (action, str(out)) for action, out in zip(agent_action, output)
+            ]
+        }
+
+    # Define a new graph
+    workflow = StateGraph(state)
+
+    # Define the two nodes we will cycle between
+    workflow.add_node("agent", RunnableCallable(run_agent, arun_agent))
+    workflow.add_node("tools", RunnableCallable(execute_tools, aexecute_tools))
+
+    # Set the entrypoint as `agent`
+    # This means that this node is the first one called
+    workflow.set_entry_point("agent")
+
+    # We now add a conditional edge
+    workflow.add_conditional_edges(
+        # First, we define the start node. We use `agent`.
+        # This means these are the edges taken after the `agent` node is called.
+        "agent",
+        # Next, we pass in the function that will determine which node is called next.
+        should_continue,
+        # Finally we pass in a mapping.
+        # The keys are strings, and the values are other nodes.
+        # END is a special node marking that the graph should finish.
+        # What will happen is we will call `should_continue`, and then the output of that
+        # will be matched against the keys in this mapping.
+        # Based on which one it matches, that node will then be called.
+        {
+            # If `tools`, then we call the tool node.
+            "continue": "tools",
+            # Otherwise we finish.
+            "end": END,
+        },
+    )
+
+    # We now add a normal edge from `tools` to `agent`.
+    # This means that after `tools` is called, `agent` node is called next.
+    workflow.add_edge("tools", "agent")
+
+    # Finally, we compile it!
+    # This compiles it into a LangChain Runnable,
+    # meaning you can use it as you would any other runnable
+    return workflow.compile()
+
+
+if __name__ == "__main__":
+    pass

pycoze/bot/agent/agent_types/react_prompt.py

@@ -0,0 +1,67 @@
+from typing import List, Union
+from langchain_core.prompts.chat import (
+    ChatPromptTemplate,
+    HumanMessagePromptTemplate,
+    SystemMessagePromptTemplate,
+    MessagesPlaceholder
+)
+from langchain_core.messages import FunctionMessage, SystemMessage, ToolMessage, AIMessage, HumanMessage, ChatMessage
+
+
+system_temp = """
+{assistant_message}
+
+Respond to the human as helpfully and accurately as possible. You have access to the following tools:
+
+{tools}
+
+Use a json blob to specify a tool by providing an action key (tool name) and an action_input key (tool input).
+
+Valid "action" values: "Final Answer" or {tool_names}
+
+Provide only ONE action per $JSON_BLOB, as shown:
+
+```
+{{{{
+  "action": $TOOL_NAME,
+  "action_input": $INPUT
+}}}}
+```
+
+Follow this format:
+
+Question: input question to answer
+Thought: consider previous and subsequent steps
+Action:
+```
+$JSON_BLOB
+```
+Observation: action result
+... (repeat Thought/Action/Observation N times)
+Thought: I know what to respond
+Action:
+```
+{{{{
+  "action": "Final Answer",
+  "action_input": "Final response to human"
+}}}}
+
+Begin! Reminder to ALWAYS respond with a valid json blob of a single action. Use tools if necessary. Respond directly if appropriate. Format is Action:```$JSON_BLOB```then Observation
+"""
+
+human_temp = """Question: {input}
+
+Thought: {agent_scratchpad}
+(reminder to respond in a JSON blob no matter what)"""
+
+
+react_agent_prompt = ChatPromptTemplate(
+    input_variables=['agent_scratchpad', 'input', 'tool_names', 'tools', 'assistant_message'], 
+    optional_variables=['chat_history'], 
+    input_types={'chat_history': List[Union[AIMessage, HumanMessage, ChatMessage, SystemMessage, FunctionMessage, ToolMessage]]}, 
+    messages=[
+        SystemMessagePromptTemplate.from_template(system_temp),
+        MessagesPlaceholder(variable_name='chat_history', optional=True), 
+        HumanMessagePromptTemplate.from_template(human_temp)
+    ]
+)

pycoze/bot/agent/assistant.py

@@ -0,0 +1,35 @@
+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, create_react_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,
+    ) -> None:
+        
+        if agent_execution_mode == "FuncCall":
+            agent_executor_object = create_openai_func_call_agent_executor
+        else:
+            agent_executor_object = create_react_agent_executor
+        agent_executor = agent_executor_object(tools, llm, assistant_message)
+        agent_executor = agent_executor.with_config({"recursion_limit": 50})
+        super().__init__(
+            tools=tools,
+            llm=llm,
+            agent_execution_mode=agent_execution_mode,
+            assistant_message=assistant_message,
+            bound=agent_executor, return_intermediate_steps=True
+        )

pycoze/bot/agent/chat.py

@@ -0,0 +1,28 @@
+import json
+from langchain_core.messages import HumanMessage, AIMessage
+
+
+INPUT_MESSAGE = "INPUT_MESSAGE=>"
+_OUTPUT_MESSAGE = "OUTPUT_MESSAGE=>"
+_INFOMATION_MESSAGE = "INFOMATION_MESSAGE=>"
+_LOG = "LOG=>"
+
+
+
+def log(content, *args, end='\n', **kwargs):
+    print(_LOG + content, *args, end=end, **kwargs)
+
+
+def output(role, content, history):
+    print(_OUTPUT_MESSAGE + json.dumps({"role": role, "content": content}))
+    if role == "assistant":
+        history.append(AIMessage(content=content))
+        
+    elif role == "user":
+        history.append(HumanMessage(content=content))
+    else:
+        raise ValueError("Invalid role")
+    return history
+
+def info(role, content):
+     print(_INFOMATION_MESSAGE + json.dumps({"role": role, "content": content}))

pycoze/bot/base.py

@@ -0,0 +1,79 @@
+import sys
+import os
+import argparse
+import importlib
+from langchain.agents import tool as _tool
+import types
+import langchain_core
+
+def wrapped_tool(tool, module_path):
+    old_tool_fun = tool.func
+    def _wrapped_tool(*args, **kwargs):
+        print(f"调用了{tool.name}")
+        old_path = os.getcwd()
+        try:
+            sys.path.insert(0, module_path)  # 插入到第一个位置
+            os.chdir(module_path)
+            result = old_tool_fun(*args, **kwargs)
+        finally:
+            sys.path.remove(module_path)
+            os.chdir(old_path)
+        print(f"{tool.name}调用完毕,结果为:", result)
+        return result
+    return _wrapped_tool
+
+
+def import_tools(tool_id):
+    tool_path = "../../tool"
+    old_path = os.getcwd()
+    module_path = os.path.join(tool_path, tool_id)
+    module_path = os.path.normpath(os.path.abspath(module_path))
+    
+    if not os.path.exists(module_path):
+        return []
+    
+    # 保存当前的 sys.modules 状态
+    original_modules = sys.modules.copy()
+    
+    try:
+        sys.path.insert(0, module_path)  # 插入到第一个位置
+        os.chdir(module_path)
+        module = importlib.import_module("tool")
+        export_tools = getattr(module, "export_tools")
+        temp_list = []
+        for tool in export_tools:
+            assert isinstance(tool, langchain_core.tools.StructuredTool) or isinstance(tool, types.FunctionType), f"Tool is not a StructuredTool or function: {tool}"
+            if isinstance(tool, types.FunctionType) and not isinstance(tool, langchain_core.tools.StructuredTool):
+                temp_list.append(_tool(tool))
+        export_tools = temp_list
+                
+    except Exception as e:
+        sys.path.remove(module_path)
+        os.chdir(old_path)
+        return []
+    
+    # 卸载模块并恢复 sys.modules 状态
+    importlib.invalidate_caches()
+    for key in list(sys.modules.keys()):
+        if key not in original_modules:
+            del sys.modules[key]
+    
+    sys.path.remove(module_path)
+    os.chdir(old_path)
+    
+    for tool in export_tools:
+        tool.func = wrapped_tool(tool, module_path)
+    
+    return export_tools
+
+
+def read_arg(param: str, is_path=False):
+    parser = argparse.ArgumentParser()
+    parser.add_argument(param, nargs='?', help=f'Parameter {param}')
+    args = parser.parse_args()
+    value = getattr(args, param.lstrip('-'))
+    # 如果是路径并且有引号，去掉引号
+    if is_path and value and value.startswith('"') and value.endswith('"'):
+        value = value[1:-1]
+
+    return value

pycoze/bot/bot.py

@@ -0,0 +1,50 @@
+import json
+from langchain_openai import ChatOpenAI
+from .base import import_tools
+from .agent import run_agent, Runnable, INPUT_MESSAGE, output
+import asyncio
+from langchain_core.messages import HumanMessage
+
+
+def load_role_setting(bot_setting_file:str):
+    with open(bot_setting_file, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+def load_tools(bot_setting_file:str):
+    with open(bot_setting_file, "r", encoding="utf-8") as f:
+        role_setting = json.load(f)
+        
+    tools = []
+    for tool_id in role_setting["tools"]:
+        tools.extend(import_tools(tool_id))
+    return tools
+
+
+
+
+def chat(bot_setting_file:str, llm_file:str):
+    history = []
+
+    while True:
+        message = input()
+        role_setting = load_role_setting(bot_setting_file)
+        tools = load_tools(bot_setting_file)
+        if not message.startswith(INPUT_MESSAGE):
+            raise ValueError("Invalid message")
+        message = json.loads(message[len(INPUT_MESSAGE):])["content"]
+        print("user:", message)
+        
+        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=role_setting["temperature"])
+
+
+        agent = Runnable(agent_execution_mode='FuncCall', # 'FuncCall' or 'ReAct'，大模型支持FuncCall的话就用FuncCall
+                                                tools=tools,
+                                                llm=chat,
+                                                assistant_message=role_setting["prompt"],)
+
+        history += [HumanMessage(content=message)]
+        result = asyncio.run(run_agent(agent, history))
+        output("assistant", result, history)
+

pycoze/utils/__init__.py

@@ -0,0 +1 @@
+from .arg import read_arg

pycoze/utils/arg.py

@@ -0,0 +1,13 @@
+import argparse
+
+
+def read_arg(param: str, is_path=False):
+    parser = argparse.ArgumentParser()
+    parser.add_argument(param, nargs='?', help=f'Parameter {param}')
+    args = parser.parse_args()
+    value = getattr(args, param.lstrip('-'))
+    # 如果是路径并且有引号，去掉引号
+    if is_path and value and value.startswith('"') and value.endswith('"'):
+        value = value[1:-1]
+
+    return value

{pycoze-0.1.0.dist-info → pycoze-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycoze
-Version: 0.1.0
+Version: 0.1.3
 Summary: Package for pycoze only!
 Author: Yuan Jie Xiong
 Author-email: aiqqqqqqq@qq.com
@@ -19,5 +19,8 @@ Package for pycoze only!
 
 <!-- For author only -->
 <!-- pip install twine -->
+
+<!-- 递增版本 -->
+<!-- 删除build和dist文件夹 -->
 <!-- python setup.py sdist bdist_wheel -->
 <!-- twine upload dist/* -->

pycoze-0.1.3.dist-info/RECORD

@@ -0,0 +1,20 @@
+pycoze/__init__.py,sha256=j4jAxl28vO2mAfdZV_p8w01K5XMRxU9IaU_S4oHM7ZE,38
+pycoze/module.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pycoze/bot/__init__.py,sha256=pciDtfcIXda7iFt9uI5Fpm0JKpGBhdXHmJv4966WTVU,21
+pycoze/bot/base.py,sha256=7sz_OeAqdFSmWsnReaxUku5QU6YEJ3VUFa2BZcVx-uM,2644
+pycoze/bot/bot.py,sha256=h1mEJibPcFV10hRo0idFJC947fCsvCVpOAq0ZBP3Z1g,1802
+pycoze/bot/agent/__init__.py,sha256=IaYqQCJ3uBor92JdOxI_EY4HtYOHgej8lijr3UrN1Vc,161
+pycoze/bot/agent/agent.py,sha256=8vww4POYkXLa5MlKQ5hL6ZIZs5q-Y7FS6SznATrrpjE,3324
+pycoze/bot/agent/assistant.py,sha256=QLeWaPi415P9jruYOm8qcIbC94cXXAhJYmLTkyC9NTQ,1267
+pycoze/bot/agent/chat.py,sha256=C2X0meUcIPbn5FCxvhkhxozldPG7qdb2jVR-WnPqqnQ,791
+pycoze/bot/agent/agent_types/__init__.py,sha256=PoYsSeQld0kdROjejN3BNjC9NsgKNekjNy4FqtWRJqM,227
+pycoze/bot/agent/agent_types/openai_func_call_agent.py,sha256=YkpiMxrLl7aMYZJsOtZraTT2UE0IZrQsfikGRCHx4jM,4467
+pycoze/bot/agent/agent_types/react_agent.py,sha256=LwzIovswxPuc08A0imQwK3DIykhlZXK5eCWXcIAuNgM,6741
+pycoze/bot/agent/agent_types/react_prompt.py,sha256=PdzL3SFb0Ee0dbK4HGqG09bRISrru4bhOj45CXBtqI0,1919
+pycoze/utils/__init__.py,sha256=I69FoCUXvVnlACQzYXoVcR76QyuVAILo9Rv-TUbcRZo,25
+pycoze/utils/arg.py,sha256=NKNSYttFk5y2l2ptk4Fiuk0SHrowYpbvl-xuggYAr4Q,430
+pycoze-0.1.3.dist-info/LICENSE,sha256=QStd_Qsd0-kAam_-sOesCIp_uKrGWeoKwt9M49NVkNU,1090
+pycoze-0.1.3.dist-info/METADATA,sha256=z3r6ghb1WEsMv7FOCqE7XJ-lD9Gq5Ev3_tNA-mrLAgE,618
+pycoze-0.1.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+pycoze-0.1.3.dist-info/top_level.txt,sha256=76dPeDhKvOCleL3ZC5gl1-y4vdS1tT_U1hxWVAn7sFo,7
+pycoze-0.1.3.dist-info/RECORD,,

pycoze-0.1.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-pycoze/__init__.py,sha256=xhKLVAxqUncda3aCjV2ugkU6nLXvpiKty8n2g_u469g,40
-pycoze/module.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pycoze-0.1.0.dist-info/LICENSE,sha256=QStd_Qsd0-kAam_-sOesCIp_uKrGWeoKwt9M49NVkNU,1090
-pycoze-0.1.0.dist-info/METADATA,sha256=scJMwzRvKme7IxVxxJ2C3R5-jb1lbJfloQixR_IXSeo,555
-pycoze-0.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-pycoze-0.1.0.dist-info/top_level.txt,sha256=76dPeDhKvOCleL3ZC5gl1-y4vdS1tT_U1hxWVAn7sFo,7
-pycoze-0.1.0.dist-info/RECORD,,