chore: bump deps for nextjs, react and copilotkit

Signed-off-by: Tyler Slaton <tyler@copilotkit.ai>

Author: tylerslaton

agent/.python-version

@@ -0,0 +1 @@
+3.12

agent/langgraph.json

@@ -1,36 +1,37 @@
-"""
-This serves the "sample_agent" agent. This is an example of self-hosting an agent
-through our FastAPI integration. However, you can also host in LangGraph platform.
-"""
-
 import os
+import warnings
 from dotenv import load_dotenv
-load_dotenv() # pylint: disable=wrong-import-position
-
 from fastapi import FastAPI
 import uvicorn
+from src.agent import graph
 from copilotkit import LangGraphAGUIAgent
-from sample_agent.agent import graph
 from ag_ui_langgraph import add_langgraph_fastapi_endpoint
 
+_ = load_dotenv()
 app = FastAPI()
 
 add_langgraph_fastapi_endpoint(
     app=app,
     agent=LangGraphAGUIAgent(
         name="sample_agent",
         description="An example agent to use as a starting point for your own agent.",
-        graph=graph
+        graph=graph,
     ),
-    path="/"
+    path="/",
 )
 
+
 def main():
     """Run the uvicorn server."""
     port = int(os.getenv("PORT", "8123"))
     uvicorn.run(
-        "sample_agent.demo:app",
+        "main:app",
         host="0.0.0.0",
         port=port,
         reload=True,
     )
+
+
+warnings.filterwarnings("ignore", category=UserWarning, module="pydantic")
+if __name__ == "__main__":
+    main()

agent/sample_agent/demo.py agent/main.pyagent/sample_agent/demo.py renamed to agent/main.py

@@ -1,27 +1,18 @@
-[tool.poetry]
+[project]
 name = "agent"
 version = "0.1.0"
 description = ""
-authors = ["CopilotKit"]
 readme = "README.md"
-packages = [{include = "sample_agent"}]
-package-mode = false
-
-[tool.poetry.dependencies]
-python = ">=3.10,<3.13"
-copilotkit = "0.1.55"
-langchain = "0.3.26"
-langchain-openai = "0.3.28"
-langgraph = "0.4.10"
-langsmith = "0.4.4"
-openai = "^1.68.2"
-fastapi = "^0.115.5"
-uvicorn = "^0.29.0"
-python-dotenv = "^1.0.0"
-
-[tool.poetry.scripts]
-demo = "sample_agent.demo:main"
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
+requires-python = ">=3.10,<3.13"
+dependencies = [
+    "copilotkit==0.1.70a0",
+    "langchain==1.0.1",
+    "langchain-openai==1.0.1",
+    "langgraph==1.0.1",
+    "openai==1.109.1",
+    "fastapi==0.115.12",
+    "uvicorn>=0.38.0",
+    "python-dotenv>=1.0.0",
+    "ag-ui-langgraph==0.0.18",
+    "pydantic>=2.0.0,<3.0.0",
+]

agent/poetry.lock

@@ -3,75 +3,65 @@
 It defines the workflow graph, state, tools, nodes and edges.
 """
 
+from importlib.resources import Resource
 from typing import Any, List
-from typing_extensions import Literal
-from langchain_openai import ChatOpenAI
+
+from copilotkit import CopilotKitState
+from langchain.tools import tool
 from langchain_core.messages import SystemMessage
 from langchain_core.runnables import RunnableConfig
-from langchain.tools import tool
-from langgraph.graph import StateGraph, END
-from langgraph.types import Command
-from langgraph.graph import MessagesState
-from langgraph.prebuilt import ToolNode
+from langchain_openai import ChatOpenAI
 from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import StateGraph
+from langgraph.prebuilt import ToolNode
+from langgraph.types import Command
+from typing_extensions import Literal
+
+from src.util import should_route_to_tool_node
 
-class AgentState(MessagesState):
+
+class AgentState(CopilotKitState):
     """
     Here we define the state of the agent
 
     In this instance, we're inheriting from CopilotKitState, which will bring in
     the CopilotKitState fields. We're also adding a custom field, `language`,
     which will be used to set the language of the agent.
     """
-    proverbs: List[str] = []
+
+    proverbs: List[str]
     tools: List[Any]
     # your_custom_agent_state: str = ""
 
+
 @tool
 def get_weather(location: str):
     """
     Get the weather for a given location.
     """
     return f"The weather for {location} is 70 degrees."
 
-# @tool
-# def your_tool_here(your_arg: str):
-#     """Your tool description here."""
-#     print(f"Your tool logic here")
-#     return "Your tool response here."
 
-tools = [
-    get_weather
-    # your_tool_here
-]
+tools = [get_weather]
 
-async def chat_node(state: AgentState, config: RunnableConfig) -> Command[Literal["tool_node", "__end__"]]:
+
+async def chat_node(
+    state: AgentState, config: RunnableConfig
+) -> Command[Literal["tool_node", "__end__"]]:
     """
-    Standard chat node based on the ReAct design pattern. It handles:
-    - The model to use (and binds in CopilotKit actions and the tools defined above)
-    - The system prompt
-    - Getting a response from the model
-    - Handling tool calls
-
-    For more about the ReAct design pattern, see:
-    https://www.perplexity.ai/search/react-agents-NcXLQhreS0WDzpVaS4m9Cg
+    Standard chat node based on the ReAct design pattern.
     """
 
     # 1. Define the model
     model = ChatOpenAI(model="gpt-4o")
 
     # 2. Bind the tools to the model
+    fe_tools = state.get("tools", [])
     model_with_tools = model.bind_tools(
         [
-            *state.get("tools", []), # bind tools defined by ag-ui
-            get_weather,
-            # your_tool_here
-        ],
-
-        # 2.1 Disable parallel tool calls to avoid race conditions,
-        #     enable this for faster performance if you want to manage
-        #     the complexity of running tool calls in parallel.
-        parallel_tool_calls=False,
+            *fe_tools,
+            *tools,
+        ]
     )
 
     # 3. Define the system message by which the chat model will be run
@@ -80,18 +70,21 @@ async def chat_node(state: AgentState, config: RunnableConfig) -> Command[Litera
     )
 
     # 4. Run the model to generate a response
-    response = await model_with_tools.ainvoke([
-        system_message,
-        *state["messages"],
-    ], config)
+    response = await model_with_tools.ainvoke(
+        [
+            system_message,
+            *state["messages"],
+        ],
+        config,
+    )
+
+    tool_calls = response.tool_calls
+    if tool_calls and should_route_to_tool_node(tool_calls, fe_tools):
+        return Command(goto="tool_node", update={"messages": response})
 
     # 5. We've handled all tool calls, so we can end the graph.
-    return Command(
-        goto=END,
-        update={
-            "messages": response
-        }
-    )
+    return Command(goto="__end__", update={"messages": response})
+
 
 # Define the workflow graph
 workflow = StateGraph(AgentState)

agent/pyproject.toml

@@ -0,0 +1,32 @@
+from langchain_core.messages import ToolCall
+
+
+def should_route_to_tool_node(tool_calls: list[ToolCall], fe_tools: list[ToolCall]):
+    """
+    Returns True if none of the tool calls are frontend tools.
+
+    Args:
+        tool_calls: List of tool calls from the model response
+        fe_tools: List of frontend tool names
+
+    Returns:
+        bool: True if all tool calls are backend tools, False if any are frontend tools
+    """
+    if not tool_calls:
+        return False
+
+    # Get the set of frontend tool names for faster lookup
+    fe_tool_names = {tool.get("name") for tool in fe_tools}
+
+    # Check if any tool call is a frontend tool
+    for tool_call in tool_calls:
+        tool_name = (
+            tool_call.get("name")
+            if isinstance(tool_call, dict)
+            else getattr(tool_call, "name", None)
+        )
+        if tool_name in fe_tool_names:
+            return False
+
+    # None of the tool calls are frontend tools
+    return True