pycoze 0.1.79__tar.gz → 0.1.81__tar.gz

{pycoze-0.1.79 → pycoze-0.1.81}/PKG-INFO

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

pycoze-0.1.81/pycoze/bot/agent/agent.py

@@ -0,0 +1,89 @@
+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 langchain_core.agents import AgentFinish
+
+
+async def run_agent(agent, inputs: list):
+    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
+                        ):
+                            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
+
+    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字，可以随便说点其他的",
+    )
+
+    inputs = [HumanMessage(content="计算根号7+根号88")]
+    print(asyncio.run(run_agent(agent, inputs)))

pycoze-0.1.81/pycoze/bot/agent/agent_types/__init__.py

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

{pycoze-0.1.79 → pycoze-0.1.81}/pycoze/bot/agent/assistant.py

@@ -1,35 +1,34 @@
-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
-        )
+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,
+    ) -> None:
+
+        agent_executor = create_openai_func_call_agent_executor(
+            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-0.1.79 → pycoze-0.1.81}/pycoze/bot/bot.py

@@ -5,6 +5,7 @@ import asyncio
 from langchain_core.messages import HumanMessage
 from pycoze import utils
 from pycoze.access.tool_for_bot import import_tools
+from langchain_core.utils.function_calling import convert_to_openai_tool
 
 params = utils.arg.read_params_file()
 llm_file = params["appPath"] + "/JsonStorage/llm.json"
@@ -36,7 +37,7 @@ def agent_chat(bot_setting_file, history):
             model=cfg["model"],
             temperature=(
                 role_setting["temperature"] * 2
-                if cfg["model"].startswith("deepseek")
+                if cfg["model"].startswith("deepseek") or cfg["model"].startswith("yi-")
                 else role_setting["temperature"]
             ),
             stop_sequences=[
@@ -45,17 +46,23 @@ def agent_chat(bot_setting_file, history):
             ],  # 停用deepseek的工具调用标记，不然会虚构工具调用过程和结果
         )
     prompt = role_setting["prompt"]
-    if cfg["model"].startswith("deepseek") and len(tools) > 0:
+    if (
+        cfg["model"].startswith("deepseek")
+        or cfg["model"].startswith("yi-")
+        and len(tools) > 0
+    ):
         prompt += """
 如果需要调用工具，请使用以正确的json格式进行结尾（务必保证json格式正确，不要出现反斜杠未转义等问题）：
 ```json
 {"name": 函数名, "parameters": 参数词典}
 ```
 """
+        if cfg["model"].startswith("yi-"):
+            prompt += "\nAvailable functions:\n"
+            for t in tools:
+                prompt += f"\n```json\n{json.dumps(convert_to_openai_tool(t))}\n```"
     agent = Runnable(
-        agent_execution_mode=(
-            "ReAct" if cfg["model"] in ["command-r", "yi-lightning"] else "FuncCall"
-        ),  # 'FuncCall' or 'ReAct'，大模型支持FuncCall的话就用FuncCall
+        agent_execution_mode="FuncCall",
         tools=tools,
         llm=chat,
         assistant_message=prompt,

{pycoze-0.1.79 → pycoze-0.1.81}/pycoze.egg-info/PKG-INFO

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

{pycoze-0.1.79 → pycoze-0.1.81}/pycoze.egg-info/SOURCES.txt

@@ -20,8 +20,6 @@ pycoze/bot/agent/assistant.py
 pycoze/bot/agent/chat.py
 pycoze/bot/agent/agent_types/__init__.py
 pycoze/bot/agent/agent_types/openai_func_call_agent.py
-pycoze/bot/agent/agent_types/react_agent.py
-pycoze/bot/agent/agent_types/react_prompt.py
 pycoze/ui/__init__.py
 pycoze/ui/base.py
 pycoze/ui/color.py

{pycoze-0.1.79 → pycoze-0.1.81}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="pycoze",
-    version="0.1.79",
+    version="0.1.81",
     packages=find_packages(),
     install_requires=[],
     author="Yuan Jie Xiong",

pycoze-0.1.79/pycoze/bot/agent/agent.py

@@ -1,111 +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 langchain_core.agents import AgentFinish
-
-
-async def run_agent(agent, inputs: list):
-    if agent.agent_execution_mode == "FuncCall":
-        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
-                            ):
-                                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)
-    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"\n[调用工具:{use_tools}]\n\n")
-        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-0.1.79/pycoze/bot/agent/agent_types/__init__.py

@@ -1,5 +0,0 @@
-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-0.1.79/pycoze/bot/agent/agent_types/react_agent.py

@@ -1,170 +0,0 @@
-# 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.runnable 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-0.1.79/pycoze/bot/agent/agent_types/react_prompt.py

@@ -1,91 +0,0 @@
-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),
-    ],
-)