another placeholder

.github/scripts/run_langgraph_cli_test.py

@@ -1,6 +1,4 @@
 import asyncio
-import json
-import os
 import pathlib
 import sys
 import langgraph_cli

.github/workflows/_integration_test.yml

@@ -43,28 +43,43 @@ jobs:
       - name: Build and test service A
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples
+        env:
+          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
         run: |
           # The build-arg isn't used; just testing that we accept other args
-          langgraph build -t langgraph-test-a  --base-image "langchain/langgraph-trial"
-          cp .env.example .envg
+          langgraph build -t langgraph-test-a
+          cp .env.example .env
+          echo $LANGSMITH_API_KEY >> .env
           timeout 60 python ../../../.github/scripts/run_langgraph_cli_test.py -c langgraph.json -t langgraph-test-a
       - name: Build and test service B
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples/graphs
+        env:
+          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
         run: |
-          langgraph build -t langgraph-test-b  --base-image "langchain/langgraph-trial"
+          langgraph build -t langgraph-test-b
+          cp .env.example .env
+          echo $LANGSMITH_API_KEY >> .env
           timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-b
       - name: Build and test service C
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples/graphs_reqs_a
+        env:
+          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
         run: |
-          langgraph build -t langgraph-test-c  --base-image "langchain/langgraph-trial"
+          langgraph build -t langgraph-test-c
+          cp .env.example .env
+          echo $LANGSMITH_API_KEY >> .env
           timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-c
       - name: Build and test service D
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples/graphs_reqs_b
+        env:
+          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
         run: |
-          langgraph build -t langgraph-test-d  --base-image "langchain/langgraph-trial"
+          langgraph build -t langgraph-test-d
+          cp .env.example .env
+          echo $LANGSMITH_API_KEY >> .env
           timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-d
 
       - name: Build JS service

docs/docs/agents/multi-agent.md

@@ -367,13 +367,13 @@ To implement handoffs with `createReactAgent`, you need to:
 
 3.  Define a parent graph that contains individual agents as nodes:
 
-    ```typescript
-    import { StateGraph, MessagesZodState } from "@langchain/langgraph";
-    const multiAgentGraph = new StateGraph(MessagesZodState)
-      .addNode("flight_assistant", flightAssistant)
-      .addNode("hotel_assistant", hotelAssistant)
-      // ...
-    ```
+        ```typescript
+        import { StateGraph, MessagesZodState } from "@langchain/langgraph";
+        const multiAgentGraph = new StateGraph(MessagesZodState)
+          .addNode("flight_assistant", flightAssistant)
+          .addNode("hotel_assistant", hotelAssistant)
+          // ...
+        ```
 
     :::
 
@@ -619,8 +619,7 @@ for await (const chunk of multiAgentGraph.stream({
 3. Name of the agent or node to hand off to.
 4. Take the agent's messages and **add** them to the parent's **state** as part of the handoff. The next agent will see the parent state.
 5. Indicate to LangGraph that we need to navigate to agent node in a **parent** multi-agent graph.
-
-:::
+   :::
 
 !!! Note
 

docs/docs/concepts/mcp.md

@@ -6,14 +6,7 @@
 
 Install the `langchain-mcp-adapters` library to use MCP tools in LangGraph:
 
-:::python
 ```bash
 pip install langchain-mcp-adapters
 ```
-:::
 
-:::js
-```bash
-npm install @langchain/mcp-adapters
-```
-:::

docs/docs/how-tos/multi_agent.md

@@ -22,7 +22,6 @@ To set up communication between the agents in a multi-agent system you can use [
 
 To implement handoffs, you can return `Command` objects from your agent nodes or tools:
 
-:::python
 ```python
 from typing import Annotated
 from langchain_core.tools import tool, InjectedToolCallId
@@ -74,109 +73,25 @@ def create_handoff_tool(*, agent_name: str, description: str | None = None):
         commands = [tools_by_name[tool_call["name"]].invoke(tool_call) for tool_call in tool_calls]
         return commands
     ```
-:::
-
-:::js
-```typescript
-import { tool } from "@langchain/core/tools";
-import { Command, MessagesZodState } from "@langchain/langgraph";
-import { z } from "zod";
-
-function createHandoffTool({
-  agentName,
-  description,
-}: {
-  agentName: string;
-  description?: string;
-}) {
-  const name = `transfer_to_${agentName}`;
-  const toolDescription = description || `Transfer to ${agentName}`;
-
-  return tool(
-    async (_, config) => {
-      // (1)!
-      const state = config.state;
-      const toolCallId = config.toolCall.id;
-
-      const toolMessage = {
-        role: "tool" as const,
-        content: `Successfully transferred to ${agentName}`,
-        name: name,
-        tool_call_id: toolCallId,
-      };
-
-      return new Command({
-        // (3)!
-        goto: agentName,
-        // (4)!
-        update: { messages: [...state.messages, toolMessage] },
-        // (5)!
-        graph: Command.PARENT,
-      });
-    },
-    {
-      name,
-      description: toolDescription,
-      schema: z.object({}),
-    }
-  );
-}
-```
-
-1. Access the [state](../concepts/low_level.md#state) of the agent that is calling the handoff tool through the `config` parameter.
-2. The `Command` primitive allows specifying a state update and a node transition as a single operation, making it useful for implementing handoffs.
-3. Name of the agent or node to hand off to.
-4. Take the agent's messages and **add** them to the parent's **state** as part of the handoff. The next agent will see the parent state.
-5. Indicate to LangGraph that we need to navigate to agent node in a **parent** multi-agent graph.
-
-!!! tip
-
-    If you want to use tools that return `Command`, you can either use prebuilt @[`create_react_agent`][create_react_agent] / @[`ToolNode`][ToolNode] components, or implement your own tool-executing node that collects `Command` objects returned by the tools and returns a list of them, e.g.:
-    
-    ```typescript
-    const callTools = async (state) => {
-      // ...
-      const commands = await Promise.all(
-        toolCalls.map(toolCall => toolsByName[toolCall.name].invoke(toolCall))
-      );
-      return commands;
-    };
-    ```
-:::
 
 !!! Important
 
     This handoff implementation assumes that:
     
-    - each agent receives overall message history (across all agents) in the multi-agent system as its input. If you want more control over agent inputs, see [this section](#control-agent-inputs)
-    - each agent outputs its internal messages history to the overall message history of the multi-agent system. If you want more control over **how agent outputs are added**, wrap the agent in a separate node function:
+      - each agent receives overall message history (across all agents) in the multi-agent system as its input. If you want more control over agent inputs, see [this section](#control-agent-inputs)
+      - each agent outputs its internal messages history to the overall message history of the multi-agent system. If you want more control over **how agent outputs are added**, wrap the agent in a separate node function:
 
-      :::python
-      ```python
-      def call_hotel_assistant(state):
-          # return agent's final response,
-          # excluding inner monologue
-          response = hotel_assistant.invoke(state)
-          # highlight-next-line
-          return {"messages": response["messages"][-1]}
-      ```
-      :::
-
-      :::js
-      ```typescript
-      const callHotelAssistant = async (state) => {
-        // return agent's final response,
-        // excluding inner monologue
-        const response = await hotelAssistant.invoke(state);
-        // highlight-next-line
-        return { messages: [response.messages.at(-1)] };
-      };
-      ```
-      :::
+        ```python
+        def call_hotel_assistant(state):
+            # return agent's final response,
+            # excluding inner monologue
+            response = hotel_assistant.invoke(state)
+            # highlight-next-line
+            return {"messages": response["messages"][-1]}
+        ```
 
 ### Control agent inputs
 
-:::python
 You can use the @[`Send()`][Send] primitive to directly send data to the worker agents during the handoff. For example, you can request that the calling agent populate a task description for the next agent:
 
 ```python
@@ -214,63 +129,6 @@ def create_task_description_handoff_tool(
 
     return handoff_tool
 ```
-:::
-
-:::js
-You can use the @[`Send()`][Send] primitive to directly send data to the worker agents during the handoff. For example, you can request that the calling agent populate a task description for the next agent:
-
-```typescript
-import { tool } from "@langchain/core/tools";
-import { Command, Send, MessagesZodState } from "@langchain/langgraph";
-import { z } from "zod";
-
-function createTaskDescriptionHandoffTool({
-  agentName,
-  description,
-}: {
-  agentName: string;
-  description?: string;
-}) {
-  const name = `transfer_to_${agentName}`;
-  const toolDescription = description || `Ask ${agentName} for help.`;
-
-  return tool(
-    async (
-      { taskDescription },
-      config
-    ) => {
-      const state = config.state;
-      
-      const taskDescriptionMessage = {
-        role: "user" as const,
-        content: taskDescription,
-      };
-      const agentInput = {
-        ...state,
-        messages: [taskDescriptionMessage],
-      };
-      
-      return new Command({
-        // highlight-next-line
-        goto: [new Send(agentName, agentInput)],
-        graph: Command.PARENT,
-      });
-    },
-    {
-      name,
-      description: toolDescription,
-      schema: z.object({
-        taskDescription: z
-          .string()
-          .describe(
-            "Description of what the next agent should do, including all of the relevant context."
-          ),
-      }),
-    }
-  );
-}
-```
-:::
 
 See the multi-agent [supervisor](../tutorials/multi_agent/agent_supervisor.md#4-create-delegation-tasks) example for a full example of using @[`Send()`][Send] in handoffs.
 
@@ -278,7 +136,6 @@ See the multi-agent [supervisor](../tutorials/multi_agent/agent_supervisor.md#4-
 
 You can use handoffs in any agents built with LangGraph. We recommend using the prebuilt [agent](../agents/overview.md) or [`ToolNode`](./tool-calling.md#toolnode), as they natively support handoffs tools returning `Command`. Below is an example of how you can implement a multi-agent system for booking travel using handoffs:
 
-:::python
 ```python
 from langgraph.prebuilt import create_react_agent
 from langgraph.graph import StateGraph, START, MessagesState
@@ -319,65 +176,9 @@ multi_agent_graph = (
     .compile()
 )
 ```
-:::
-
-:::js
-```typescript
-import { createReactAgent } from "@langchain/langgraph/prebuilt";
-import { StateGraph, START, MessagesZodState } from "@langchain/langgraph";
-import { z } from "zod";
-
-function createHandoffTool({
-  agentName,
-  description,
-}: {
-  agentName: string;
-  description?: string;
-}) {
-  // same implementation as above
-  // ...
-  return new Command(/* ... */);
-}
-
-// Handoffs
-const transferToHotelAssistant = createHandoffTool({
-  agentName: "hotel_assistant",
-});
-const transferToFlightAssistant = createHandoffTool({
-  agentName: "flight_assistant",
-});
-
-// Define agents
-const flightAssistant = createReactAgent({
-  llm: model,
-  // highlight-next-line
-  tools: [/* ... */, transferToHotelAssistant],
-  // highlight-next-line
-  name: "flight_assistant",
-});
-
-const hotelAssistant = createReactAgent({
-  llm: model,
-  // highlight-next-line
-  tools: [/* ... */, transferToFlightAssistant],
-  // highlight-next-line
-  name: "hotel_assistant",
-});
-
-// Define multi-agent graph
-const multiAgentGraph = new StateGraph(MessagesZodState)
-  // highlight-next-line
-  .addNode("flight_assistant", flightAssistant)
-  // highlight-next-line
-  .addNode("hotel_assistant", hotelAssistant)
-  .addEdge(START, "flight_assistant")
-  .compile();
-```
-:::
 
 ??? example "Full example: Multi-agent system for booking travel"
 
-    :::python
     ```python
     from typing import Annotated
     from langchain_core.messages import convert_to_messages
@@ -522,183 +323,6 @@ const multiAgentGraph = new StateGraph(MessagesZodState)
     3. Name of the agent or node to hand off to.
     4. Take the agent's messages and **add** them to the parent's **state** as part of the handoff. The next agent will see the parent state.
     5. Indicate to LangGraph that we need to navigate to agent node in a **parent** multi-agent graph.
-    :::
-
-    :::js
-    ```typescript
-    import { tool } from "@langchain/core/tools";
-    import { createReactAgent } from "@langchain/langgraph/prebuilt";
-    import { StateGraph, START, MessagesZodState, Command } from "@langchain/langgraph";
-    import { ChatAnthropic } from "@langchain/anthropic";
-    import { isBaseMessage } from "@langchain/core/messages";
-    import { z } from "zod";
-
-    // We'll use a helper to render the streamed agent outputs nicely
-    const prettyPrintMessages = (update: Record<string, any>) => {
-      // Handle tuple case with namespace
-      if (Array.isArray(update)) {
-        const [ns, updateData] = update;
-        // Skip parent graph updates in the printouts
-        if (ns.length === 0) {
-          return;
-        }
-
-        const graphId = ns[ns.length - 1].split(":")[0];
-        console.log(`Update from subgraph ${graphId}:\n`);
-        update = updateData;
-      }
-
-      for (const [nodeName, updateValue] of Object.entries(update)) {
-        console.log(`Update from node ${nodeName}:\n`);
-
-        const messages = updateValue.messages || [];
-        for (const message of messages) {
-          if (isBaseMessage(message)) {
-            const textContent =
-              typeof message.content === "string"
-                ? message.content
-                : JSON.stringify(message.content);
-            console.log(`${message.getType()}: ${textContent}`);
-          }
-        }
-        console.log("\n");
-      }
-    };
-
-    function createHandoffTool({
-      agentName,
-      description,
-    }: {
-      agentName: string;
-      description?: string;
-    }) {
-      const name = `transfer_to_${agentName}`;
-      const toolDescription = description || `Transfer to ${agentName}`;
-
-      return tool(
-        async (_, config) => {
-          // highlight-next-line
-          const state = config.state; // (1)!
-          const toolCallId = config.toolCall.id;
-
-          const toolMessage = {
-            role: "tool" as const,
-            content: `Successfully transferred to ${agentName}`,
-            name: name,
-            tool_call_id: toolCallId,
-          };
-
-          return new Command({
-            // highlight-next-line
-            goto: agentName, // (3)!
-            // highlight-next-line
-            update: { messages: [...state.messages, toolMessage] }, // (4)!
-            // highlight-next-line
-            graph: Command.PARENT, // (5)!
-          });
-        },
-        {
-          name,
-          description: toolDescription,
-          schema: z.object({}),
-        }
-      );
-    }
-
-    // Handoffs
-    const transferToHotelAssistant = createHandoffTool({
-      agentName: "hotel_assistant",
-      description: "Transfer user to the hotel-booking assistant.",
-    });
-
-    const transferToFlightAssistant = createHandoffTool({
-      agentName: "flight_assistant",
-      description: "Transfer user to the flight-booking assistant.",
-    });
-
-    // Simple agent tools
-    const bookHotel = tool(
-      async ({ hotelName }) => {
-        return `Successfully booked a stay at ${hotelName}.`;
-      },
-      {
-        name: "book_hotel",
-        description: "Book a hotel",
-        schema: z.object({
-          hotelName: z.string(),
-        }),
-      }
-    );
-
-    const bookFlight = tool(
-      async ({ fromAirport, toAirport }) => {
-        return `Successfully booked a flight from ${fromAirport} to ${toAirport}.`;
-      },
-      {
-        name: "book_flight",
-        description: "Book a flight",
-        schema: z.object({
-          fromAirport: z.string(),
-          toAirport: z.string(),
-        }),
-      }
-    );
-
-    const model = new ChatAnthropic({
-      model: "claude-3-5-sonnet-latest",
-    });
-
-    // Define agents
-    const flightAssistant = createReactAgent({
-      llm: model,
-      // highlight-next-line
-      tools: [bookFlight, transferToHotelAssistant],
-      prompt: "You are a flight booking assistant",
-      // highlight-next-line
-      name: "flight_assistant",
-    });
-
-    const hotelAssistant = createReactAgent({
-      llm: model,
-      // highlight-next-line
-      tools: [bookHotel, transferToFlightAssistant],
-      prompt: "You are a hotel booking assistant",
-      // highlight-next-line
-      name: "hotel_assistant",
-    });
-
-    // Define multi-agent graph
-    const multiAgentGraph = new StateGraph(MessagesZodState)
-      .addNode("flight_assistant", flightAssistant)
-      .addNode("hotel_assistant", hotelAssistant)
-      .addEdge(START, "flight_assistant")
-      .compile();
-
-    // Run the multi-agent graph
-    const stream = await multiAgentGraph.stream(
-      {
-        messages: [
-          {
-            role: "user",
-            content: "book a flight from BOS to JFK and a stay at McKittrick Hotel",
-          },
-        ],
-      },
-      // highlight-next-line
-      { subgraphs: true }
-    );
-
-    for await (const chunk of stream) {
-      prettyPrintMessages(chunk);
-    }
-    ```
-
-    1. Access agent's state
-    2. The `Command` primitive allows specifying a state update and a node transition as a single operation, making it useful for implementing handoffs.
-    3. Name of the agent or node to hand off to.
-    4. Take the agent's messages and **add** them to the parent's **state** as part of the handoff. The next agent will see the parent state.
-    5. Indicate to LangGraph that we need to navigate to agent node in a **parent** multi-agent graph.
-    :::
 
 ## Multi-turn conversation
 
@@ -709,7 +333,6 @@ The agents can then be implemented as nodes in a graph that executes agent steps
 1. **Wait for user input** to continue the conversation, or  
 2. **Route to another agent** (or back to itself, such as in a loop) via a [handoff](#handoffs)
 
-:::python
 ```python
 def human(state) -> Command[Literal["agent", "another_agent"]]:
     """A node for collecting user input."""
@@ -737,44 +360,6 @@ def agent(state) -> Command[Literal["agent", "another_agent", "human"]]:
     else:
         return Command(goto="human") # Go to human node
 ```
-:::
-
-:::js
-```typescript
-import { interrupt, Command } from "@langchain/langgraph";
-
-function human(state: MessagesState): Command {
-  const userInput: string = interrupt("Ready for user input.");
-
-  // Determine the active agent
-  const activeAgent = /* ... */;
-
-  return new Command({
-    update: {
-      messages: [{
-        role: "human",
-        content: userInput,
-      }]
-    },
-    goto: activeAgent,
-  });
-}
-
-function agent(state: MessagesState): Command {
-  // The condition for routing/halting can be anything, e.g. LLM tool call / structured output, etc.
-  const goto = getNextAgent(/* ... */); // 'agent' / 'anotherAgent'
-
-  if (goto) {
-    return new Command({
-      goto,
-      update: { myStateKey: "myStateValue" }
-    });
-  }
-
-  return new Command({ goto: "human" });
-}
-```
-:::
 
 ??? example "Full example: multi-agent system for travel recommendations"
 
@@ -785,7 +370,6 @@ function agent(state: MessagesState): Command {
     * travel_advisor: can help with travel destination recommendations. Can ask hotel_advisor for help.
     * hotel_advisor: can help with hotel recommendations. Can ask travel_advisor for help.
 
-    :::python
     ```python
     from langchain_anthropic import ChatAnthropic
     from langgraph.graph import MessagesState, StateGraph, START
@@ -987,267 +571,10 @@ function agent(state: MessagesState): Command {
     
     Would you like more specific information about any of these activities or would you like to know about other options in the area?
     ```
-    :::
-
-    :::js
-    ```typescript
-    import { ChatAnthropic } from "@langchain/anthropic";
-    import { StateGraph, START, MessagesZodState, Command, interrupt, MemorySaver } from "@langchain/langgraph";
-    import { createReactAgent } from "@langchain/langgraph/prebuilt";
-    import { tool } from "@langchain/core/tools";
-    import { z } from "zod";
-
-    const model = new ChatAnthropic({ model: "claude-3-5-sonnet-latest" });
-
-    const MultiAgentState = MessagesZodState.extend({
-      lastActiveAgent: z.string().optional(),
-    });
-
-    // Define travel advisor tools
-    const getTravelRecommendations = tool(
-      async () => {
-        // Placeholder implementation
-        return "Based on current trends, I recommend visiting Japan, Portugal, or New Zealand.";
-      },
-      {
-        name: "get_travel_recommendations",
-        description: "Get current travel destination recommendations",
-        schema: z.object({}),
-      }
-    );
-
-    const makeHandoffTool = (agentName: string) => {
-      return tool(
-        async (_, config) => {
-          const state = config.state;
-          const toolCallId = config.toolCall.id;
-
-          const toolMessage = {
-            role: "tool" as const,
-            content: `Successfully transferred to ${agentName}`,
-            name: `transfer_to_${agentName}`,
-            tool_call_id: toolCallId,
-          };
-
-          return new Command({
-            goto: agentName,
-            update: { messages: [...state.messages, toolMessage] },
-            graph: Command.PARENT,
-          });
-        },
-        {
-          name: `transfer_to_${agentName}`,
-          description: `Transfer to ${agentName}`,
-          schema: z.object({}),
-        }
-      );
-    };
-
-    const travelAdvisorTools = [
-      getTravelRecommendations,
-      makeHandoffTool("hotel_advisor"),
-    ];
-
-    const travelAdvisor = createReactAgent({
-      llm: model,
-      tools: travelAdvisorTools,
-      prompt: [
-        "You are a general travel expert that can recommend travel destinations (e.g. countries, cities, etc). ",
-        "If you need hotel recommendations, ask 'hotel_advisor' for help. ",
-        "You MUST include human-readable response before transferring to another agent."
-      ].join("")
-    });
-
-    const callTravelAdvisor = async (
-      state: z.infer<typeof MultiAgentState>
-    ): Promise<Command> => {
-      const response = await travelAdvisor.invoke(state);
-      const update = { ...response, lastActiveAgent: "travel_advisor" };
-      return new Command({ update, goto: "human" });
-    };
-
-    // Define hotel advisor tools
-    const getHotelRecommendations = tool(
-      async () => {
-        // Placeholder implementation
-        return "I recommend the Ritz-Carlton for luxury stays or boutique hotels for unique experiences.";
-      },
-      {
-        name: "get_hotel_recommendations",
-        description: "Get hotel recommendations for destinations",
-        schema: z.object({}),
-      }
-    );
-
-    const hotelAdvisorTools = [
-      getHotelRecommendations,
-      makeHandoffTool("travel_advisor"),
-    ];
-
-    const hotelAdvisor = createReactAgent({
-      llm: model,
-      tools: hotelAdvisorTools,
-      prompt: [
-        "You are a hotel expert that can provide hotel recommendations for a given destination. ",
-        "If you need help picking travel destinations, ask 'travel_advisor' for help.",
-        "You MUST include human-readable response before transferring to another agent."
-      ].join("")
-    });
-
-    const callHotelAdvisor = async (
-      state: z.infer<typeof MultiAgentState>
-    ): Promise<Command> => {
-      const response = await hotelAdvisor.invoke(state);
-      const update = { ...response, lastActiveAgent: "hotel_advisor" };
-      return new Command({ update, goto: "human" });
-    };
-
-    const humanNode = async (
-      state: z.infer<typeof MultiAgentState>
-    ): Promise<Command> => {
-      const userInput: string = interrupt("Ready for user input.");
-      const activeAgent = state.lastActiveAgent || "travel_advisor";
-
-      return new Command({
-        update: {
-          messages: [
-            {
-              role: "human",
-              content: userInput,
-            }
-          ]
-        },
-        goto: activeAgent,
-      });
-    };
-
-    const builder = new StateGraph(MultiAgentState)
-      .addNode("travel_advisor", callTravelAdvisor)
-      .addNode("hotel_advisor", callHotelAdvisor)
-      .addNode("human", humanNode)
-      .addEdge(START, "travel_advisor");
-
-    const checkpointer = new MemorySaver();
-    const graph = builder.compile({ checkpointer });
-    ```
-    
-    Let's test a multi turn conversation with this application.
-
-    ```typescript
-    import { v4 as uuidv4 } from "uuid";
-    import { Command } from "@langchain/langgraph";
-
-    const threadConfig = { configurable: { thread_id: uuidv4() } };
-
-    const inputs = [
-      // 1st round of conversation
-      {
-        messages: [
-          { role: "user", content: "i wanna go somewhere warm in the caribbean" }
-        ]
-      },
-      // Since we're using `interrupt`, we'll need to resume using the Command primitive.
-      // 2nd round of conversation
-      new Command({
-        resume: "could you recommend a nice hotel in one of the areas and tell me which area it is."
-      }),
-      // 3rd round of conversation
-      new Command({
-        resume: "i like the first one. could you recommend something to do near the hotel?"
-      }),
-    ];
-
-    for (const [idx, userInput] of inputs.entries()) {
-      console.log();
-      console.log(`--- Conversation Turn ${idx + 1} ---`);
-      console.log();
-      console.log(`User: ${JSON.stringify(userInput)}`);
-      console.log();
-      
-      for await (const update of await graph.stream(
-        userInput,
-        { ...threadConfig, streamMode: "updates" }
-      )) {
-        for (const [nodeId, value] of Object.entries(update)) {
-          if (value?.messages?.length) {
-            const lastMessage = value.messages.at(-1);
-            if (lastMessage?.getType?.() === "ai") {
-              console.log(`${nodeId}: ${lastMessage.content}`);
-            }
-          }
-        }
-      }
-    }
-    ```
-    
-    ```
-    --- Conversation Turn 1 ---
-    
-    User: {"messages":[{"role":"user","content":"i wanna go somewhere warm in the caribbean"}]}
-    
-    travel_advisor: Based on the recommendations, Aruba would be an excellent choice for your Caribbean getaway! Aruba is known as "One Happy Island" and offers:
-    - Year-round warm weather with consistent temperatures around 82°F (28°C)
-    - Beautiful white sand beaches like Eagle Beach and Palm Beach
-    - Clear turquoise waters perfect for swimming and snorkeling
-    - Minimal rainfall and location outside the hurricane belt
-    - A blend of Caribbean and Dutch culture
-    - Great dining options and nightlife
-    - Various water sports and activities
-    
-    Would you like me to get some specific hotel recommendations in Aruba for your stay? I can transfer you to our hotel advisor who can help with accommodations.
-    
-    --- Conversation Turn 2 ---
-    
-    User: Command { resume: 'could you recommend a nice hotel in one of the areas and tell me which area it is.' }
-    
-    hotel_advisor: Based on the recommendations, I can suggest two excellent options:
-    
-    1. The Ritz-Carlton, Aruba - Located in Palm Beach
-    - This luxury resort is situated in the vibrant Palm Beach area
-    - Known for its exceptional service and amenities
-    - Perfect if you want to be close to dining, shopping, and entertainment
-    - Features multiple restaurants, a casino, and a world-class spa
-    - Located on a pristine stretch of Palm Beach
-    
-    2. Bucuti & Tara Beach Resort - Located in Eagle Beach
-    - An adults-only boutique resort on Eagle Beach
-    - Known for being more intimate and peaceful
-    - Award-winning for its sustainability practices
-    - Perfect for a romantic getaway or peaceful vacation
-    - Located on one of the most beautiful beaches in the Caribbean
-    
-    Would you like more specific information about either of these properties or their locations?
-    
-    --- Conversation Turn 3 ---
-    
-    User: Command { resume: 'i like the first one. could you recommend something to do near the hotel?' }
-    
-    travel_advisor: Near the Ritz-Carlton in Palm Beach, here are some highly recommended activities:
-    
-    1. Visit the Palm Beach Plaza Mall - Just a short walk from the hotel, featuring shopping, dining, and entertainment
-    2. Try your luck at the Stellaris Casino - It's right in the Ritz-Carlton
-    3. Take a sunset sailing cruise - Many depart from the nearby pier
-    4. Visit the California Lighthouse - A scenic landmark just north of Palm Beach
-    5. Enjoy water sports at Palm Beach:
-       - Jet skiing
-       - Parasailing
-       - Snorkeling
-       - Stand-up paddleboarding
-    
-    Would you like more specific information about any of these activities or would you like to know about other options in the area?
-    ```
-    :::
 
 ## Prebuilt implementations
 
 LangGraph comes with prebuilt implementations of two of the most popular multi-agent architectures:
 
-:::python
 - [supervisor](../agents/multi-agent.md#supervisor) — individual agents are coordinated by a central supervisor agent. The supervisor controls all communication flow and task delegation, making decisions about which agent to invoke based on the current context and task requirements. You can use [`langgraph-supervisor`](https://github.com/langchain-ai/langgraph-supervisor-py) library to create a supervisor multi-agent systems.
-- [swarm](../agents/multi-agent.md#supervisor) — agents dynamically hand off control to one another based on their specializations. The system remembers which agent was last active, ensuring that on subsequent interactions, the conversation resumes with that agent. You can use [`langgraph-swarm`](https://github.com/langchain-ai/langgraph-swarm-py) library to create a swarm multi-agent systems.
-:::
-
-:::js
-- [supervisor](../agents/multi-agent.md#supervisor) — individual agents are coordinated by a central supervisor agent. The supervisor controls all communication flow and task delegation, making decisions about which agent to invoke based on the current context and task requirements. You can use [`langgraph-supervisor`](https://github.com/langchain-ai/langgraph-supervisor-js) library to create a supervisor multi-agent systems.
-- [swarm](../agents/multi-agent.md#supervisor) — agents dynamically hand off control to one another based on their specializations. The system remembers which agent was last active, ensuring that on subsequent interactions, the conversation resumes with that agent. You can use [`langgraph-swarm`](https://github.com/langchain-ai/langgraph-swarm-js) library to create a swarm multi-agent systems.
-:::
+- [swarm](../agents/multi-agent.md#supervisor) — agents dynamically hand off control to one another based on their specializations. The system remembers which agent was last active, ensuring that on subsequent interactions, the conversation resumes with that agent. You can use [`langgraph-swarm`](https://github.com/langchain-ai/langgraph-swarm-py) library to create a swarm multi-agent systems. 

docs/docs/how-tos/subgraph.md

@@ -9,20 +9,11 @@ When adding subgraphs, you need to define how the parent graph and the subgraph
 
 ## Setup
 
-:::python
 ```bash
 pip install -U langgraph
 ```
-:::
-
-:::js
-```bash
-npm install @langchain/langgraph
-```
-:::
 
 !!! tip "Set up LangSmith for LangGraph development"
-
     Sign up for [LangSmith](https://smith.langchain.com) to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started [here](https://docs.smith.langchain.com).
 
 ## Shared state schemas
@@ -31,7 +22,6 @@ A common case is for the parent graph and subgraph to communicate over a shared
 
 If your subgraph shares state keys with the parent graph, you can follow these steps to add it to your graph:
 
-:::python
 1. Define the subgraph workflow (`subgraph_builder` in the example below) and compile it
 2. Pass compiled subgraph to the `.add_node` method when defining the parent graph workflow
 
@@ -59,41 +49,9 @@ builder.add_node("node_1", subgraph)
 builder.add_edge(START, "node_1")
 graph = builder.compile()
 ```
-:::
-
-:::js
-1. Define the subgraph workflow (`subgraphBuilder` in the example below) and compile it
-2. Pass compiled subgraph to the `.addNode` method when defining the parent graph workflow
-
-```typescript
-import { StateGraph, START } from "@langchain/langgraph";
-import { z } from "zod";
-
-const State = z.object({
-  foo: z.string(),
-});
-
-// Subgraph
-const subgraphBuilder = new StateGraph(State)
-  .addNode("subgraphNode1", (state) => {
-    return { foo: "hi! " + state.foo };
-  })
-  .addEdge(START, "subgraphNode1");
-
-const subgraph = subgraphBuilder.compile();
-
-// Parent graph
-const builder = new StateGraph(State)
-  .addNode("node1", subgraph)
-  .addEdge(START, "node1");
-
-const graph = builder.compile();
-```
-:::
 
 ??? example "Full example: shared state schemas"
 
-    :::python
     ```python
     from typing_extensions import TypedDict
     from langgraph.graph.state import StateGraph, START
@@ -143,61 +101,6 @@ const graph = builder.compile();
     {'node_1': {'foo': 'hi! foo'}}
     {'node_2': {'foo': 'hi! foobar'}}
     ```
-    :::
-
-    :::js
-    ```typescript
-    import { StateGraph, START } from "@langchain/langgraph";
-    import { z } from "zod";
-
-    // Define subgraph
-    const SubgraphState = z.object({
-      foo: z.string(),  // (1)! 
-      bar: z.string(),  // (2)!
-    });
-    
-    const subgraphBuilder = new StateGraph(SubgraphState)
-      .addNode("subgraphNode1", (state) => {
-        return { bar: "bar" };
-      })
-      .addNode("subgraphNode2", (state) => {
-        // note that this node is using a state key ('bar') that is only available in the subgraph
-        // and is sending update on the shared state key ('foo')
-        return { foo: state.foo + state.bar };
-      })
-      .addEdge(START, "subgraphNode1")
-      .addEdge("subgraphNode1", "subgraphNode2");
-    
-    const subgraph = subgraphBuilder.compile();
-    
-    // Define parent graph
-    const ParentState = z.object({
-      foo: z.string(),
-    });
-    
-    const builder = new StateGraph(ParentState)
-      .addNode("node1", (state) => {
-        return { foo: "hi! " + state.foo };
-      })
-      .addNode("node2", subgraph)
-      .addEdge(START, "node1")
-      .addEdge("node1", "node2");
-    
-    const graph = builder.compile();
-    
-    for await (const chunk of await graph.stream({ foo: "foo" })) {
-      console.log(chunk);
-    }
-    ```
-
-    3. This key is shared with the parent graph state
-    4. This key is private to the `SubgraphState` and is not visible to the parent graph
-    
-    ```
-    { node1: { foo: 'hi! foo' } }
-    { node2: { foo: 'hi! foobar' } }
-    ```
-    :::
 
 ## Different state schemas
 
@@ -205,7 +108,6 @@ For more complex systems you might want to define subgraphs that have a **comple
 
 If that's the case for your application, you need to define a node **function that invokes the subgraph**. This function needs to transform the input (parent) state to the subgraph state before invoking the subgraph, and transform the results back to the parent state before returning the state update from the node.
 
-:::python
 ```python
 from typing_extensions import TypedDict
 from langgraph.graph.state import StateGraph, START
@@ -240,48 +142,9 @@ graph = builder.compile()
 
 1. Transform the state to the subgraph state
 2. Transform response back to the parent state
-:::
-
-:::js
-```typescript
-import { StateGraph, START } from "@langchain/langgraph";
-import { z } from "zod";
-
-const SubgraphState = z.object({
-  bar: z.string(),
-});
-
-// Subgraph
-const subgraphBuilder = new StateGraph(SubgraphState)
-  .addNode("subgraphNode1", (state) => {
-    return { bar: "hi! " + state.bar };
-  })
-  .addEdge(START, "subgraphNode1");
-
-const subgraph = subgraphBuilder.compile();
-
-// Parent graph
-const State = z.object({
-  foo: z.string(),
-});
-
-const builder = new StateGraph(State)
-  .addNode("node1", async (state) => {
-    const subgraphOutput = await subgraph.invoke({ bar: state.foo }); // (1)!
-    return { foo: subgraphOutput.bar }; // (2)!
-  })
-  .addEdge(START, "node1");
-
-const graph = builder.compile();
-```
-
-1. Transform the state to the subgraph state
-2. Transform response back to the parent state
-:::
 
 ??? example "Full example: different state schemas"
 
-    :::python
     ```python
     from typing_extensions import TypedDict
     from langgraph.graph.state import StateGraph, START
@@ -337,74 +200,11 @@ const graph = builder.compile();
     (('node_2:9c36dd0f-151a-cb42-cbad-fa2f851f9ab7',), {'grandchild_2': {'bar': 'hi! foobaz'}})
     ((), {'node_2': {'foo': 'hi! foobaz'}})
     ```
-    :::
-
-    :::js
-    ```typescript
-    import { StateGraph, START } from "@langchain/langgraph";
-    import { z } from "zod";
-
-    // Define subgraph
-    const SubgraphState = z.object({
-      // note that none of these keys are shared with the parent graph state
-      bar: z.string(),
-      baz: z.string(),
-    });
-    
-    const subgraphBuilder = new StateGraph(SubgraphState)
-      .addNode("subgraphNode1", (state) => {
-        return { baz: "baz" };
-      })
-      .addNode("subgraphNode2", (state) => {
-        return { bar: state.bar + state.baz };
-      })
-      .addEdge(START, "subgraphNode1")
-      .addEdge("subgraphNode1", "subgraphNode2");
-    
-    const subgraph = subgraphBuilder.compile();
-    
-    // Define parent graph
-    const ParentState = z.object({
-      foo: z.string(),
-    });
-    
-    const builder = new StateGraph(ParentState)
-      .addNode("node1", (state) => {
-        return { foo: "hi! " + state.foo };
-      })
-      .addNode("node2", async (state) => {
-        const response = await subgraph.invoke({ bar: state.foo }); // (1)!
-        return { foo: response.bar }; // (2)!
-      })
-      .addEdge(START, "node1")
-      .addEdge("node1", "node2");
-    
-    const graph = builder.compile();
-    
-    for await (const chunk of await graph.stream(
-      { foo: "foo" }, 
-      { subgraphs: true }
-    )) {
-      console.log(chunk);
-    }
-    ```
-
-    3. Transform the state to the subgraph state
-    4. Transform response back to the parent state
-
-    ```
-    [[], { node1: { foo: 'hi! foo' } }]
-    [['node2:9c36dd0f-151a-cb42-cbad-fa2f851f9ab7'], { subgraphNode1: { baz: 'baz' } }]
-    [['node2:9c36dd0f-151a-cb42-cbad-fa2f851f9ab7'], { subgraphNode2: { bar: 'hi! foobaz' } }]
-    [[], { node2: { foo: 'hi! foobaz' } }]
-    ```
-    :::
 
 ??? example "Full example: different state schemas (two levels of subgraphs)"
 
     This is an example with two levels of subgraphs: parent -> child -> grandchild.
 
-    :::python
     ```python
     # Grandchild graph
     from typing_extensions import TypedDict
@@ -488,102 +288,14 @@ const graph = builder.compile();
     ((), {'child': {'my_key': 'hi Bob, how are you today?'}})
     ((), {'parent_2': {'my_key': 'hi Bob, how are you today? bye!'}})
     ```
-    :::
-
-    :::js
-    ```typescript
-    import { StateGraph, START, END } from "@langchain/langgraph";
-    import { z } from "zod";
-
-    // Grandchild graph
-    const GrandChildState = z.object({
-      myGrandchildKey: z.string(),
-    });
-    
-    const grandchild = new StateGraph(GrandChildState)
-      .addNode("grandchild1", (state) => {
-        // NOTE: child or parent keys will not be accessible here
-        return { myGrandchildKey: state.myGrandchildKey + ", how are you" };
-      })
-      .addEdge(START, "grandchild1")
-      .addEdge("grandchild1", END);
-    
-    const grandchildGraph = grandchild.compile();
-    
-    // Child graph
-    const ChildState = z.object({
-      myChildKey: z.string(),
-    });
-    
-    const child = new StateGraph(ChildState)
-      .addNode("child1", async (state) => {
-        // NOTE: parent or grandchild keys won't be accessible here
-        const grandchildGraphInput = { myGrandchildKey: state.myChildKey }; // (1)!
-        const grandchildGraphOutput = await grandchildGraph.invoke(grandchildGraphInput);
-        return { myChildKey: grandchildGraphOutput.myGrandchildKey + " today?" }; // (2)!
-      }) // (3)!
-      .addEdge(START, "child1")
-      .addEdge("child1", END);
-    
-    const childGraph = child.compile();
-    
-    // Parent graph
-    const ParentState = z.object({
-      myKey: z.string(),
-    });
-    
-    const parent = new StateGraph(ParentState)
-      .addNode("parent1", (state) => {
-        // NOTE: child or grandchild keys won't be accessible here
-        return { myKey: "hi " + state.myKey };
-      })
-      .addNode("child", async (state) => {
-        const childGraphInput = { myChildKey: state.myKey }; // (4)!
-        const childGraphOutput = await childGraph.invoke(childGraphInput);
-        return { myKey: childGraphOutput.myChildKey }; // (5)!
-      }) // (6)!
-      .addNode("parent2", (state) => {
-        return { myKey: state.myKey + " bye!" };
-      })
-      .addEdge(START, "parent1")
-      .addEdge("parent1", "child")
-      .addEdge("child", "parent2")
-      .addEdge("parent2", END);
-    
-    const parentGraph = parent.compile();
-    
-    for await (const chunk of await parentGraph.stream(
-      { myKey: "Bob" }, 
-      { subgraphs: true }
-    )) {
-      console.log(chunk);
-    }
-    ```
-
-    7. We're transforming the state from the child state channels (`myChildKey`) to the grandchild state channels (`myGrandchildKey`)
-    8. We're transforming the state from the grandchild state channels (`myGrandchildKey`) back to the child state channels (`myChildKey`)
-    9. We're passing a function here instead of just compiled graph (`grandchildGraph`)
-    10. We're transforming the state from the parent state channels (`myKey`) to the child state channels (`myChildKey`)
-    11. We're transforming the state from the child state channels (`myChildKey`) back to the parent state channels (`myKey`)
-    12. We're passing a function here instead of just a compiled graph (`childGraph`)
-
-    ```
-    [[], { parent1: { myKey: 'hi Bob' } }]
-    [['child:2e26e9ce-602f-862c-aa66-1ea5a4655e3b', 'child1:781bb3b1-3971-84ce-810b-acf819a03f9c'], { grandchild1: { myGrandchildKey: 'hi Bob, how are you' } }]
-    [['child:2e26e9ce-602f-862c-aa66-1ea5a4655e3b'], { child1: { myChildKey: 'hi Bob, how are you today?' } }]
-    [[], { child: { myKey: 'hi Bob, how are you today?' } }]
-    [[], { parent2: { myKey: 'hi Bob, how are you today? bye!' } }]
-    ```
-    :::
 
 ## Add persistence 
 
 You only need to **provide the checkpointer when compiling the parent graph**. LangGraph will automatically propagate the checkpointer to the child subgraphs.
 
-:::python
 ```python
 from langgraph.graph import START, StateGraph
-from langgraph.checkpoint.memory import MemorySaver
+from langgraph.checkpoint.memory import InMemorySaver
 from typing_extensions import TypedDict
 
 class State(TypedDict):
@@ -605,66 +317,20 @@ builder = StateGraph(State)
 builder.add_node("node_1", subgraph)
 builder.add_edge(START, "node_1")
 
-checkpointer = MemorySaver()
+checkpointer = InMemorySaver()
 graph = builder.compile(checkpointer=checkpointer)
 ```    
-:::
 
-:::js
-```typescript
-import { StateGraph, START, MemorySaver } from "@langchain/langgraph";
-import { z } from "zod";
+If you want the subgraph to **have its own memory**, you can compile it `with checkpointer=True`. This is useful in [multi-agent](../concepts/multi_agent.md) systems, if you want agents to keep track of their internal message histories:
 
-const State = z.object({
-  foo: z.string(),
-});
-
-// Subgraph
-const subgraphBuilder = new StateGraph(State)
-  .addNode("subgraphNode1", (state) => {
-    return { foo: state.foo + "bar" };
-  })
-  .addEdge(START, "subgraphNode1");
-
-const subgraph = subgraphBuilder.compile();
-
-// Parent graph
-const builder = new StateGraph(State)
-  .addNode("node1", subgraph)
-  .addEdge(START, "node1");
-
-const checkpointer = new MemorySaver();
-const graph = builder.compile({ checkpointer });
-```    
-:::
-
-If you want the subgraph to **have its own memory**, you can compile it with the appropriate checkpointer option. This is useful in [multi-agent](../concepts/multi_agent.md) systems, if you want agents to keep track of their internal message histories:
-
-:::python
 ```python
 subgraph_builder = StateGraph(...)
 subgraph = subgraph_builder.compile(checkpointer=True)
 ```
-:::
-
-:::js
-```typescript
-const subgraphBuilder = new StateGraph(...)
-const subgraph = subgraphBuilder.compile({ checkpointer: true });
-```
-:::
 
 ## View subgraph state
 
-When you enable [persistence](../concepts/persistence.md), you can [inspect the graph state](../concepts/persistence.md#checkpoints) (checkpoint) via the appropriate method. To view the subgraph state, you can use the subgraphs option.
-
-:::python
-You can inspect the graph state via `graph.get_state(config)`. To view the subgraph state, you can use `graph.get_state(config, subgraphs=True)`.
-:::
-
-:::js
-You can inspect the graph state via `graph.getState(config)`. To view the subgraph state, you can use `graph.getState(config, { subgraphs: true })`.
-:::
+When you enable [persistence](../concepts/persistence.md), you can [inspect the graph state](../concepts/persistence.md#checkpoints) (checkpoint) via `graph.get_state(config)`. To view the subgraph state, you can use `graph.get_state(config, subgraphs=True)`.
 
 !!! important "Available **only** when interrupted"
 
@@ -672,10 +338,9 @@ You can inspect the graph state via `graph.getState(config)`. To view the subgra
 
 ??? example "View interrupted subgraph state"
 
-    :::python
     ```python
     from langgraph.graph import START, StateGraph
-    from langgraph.checkpoint.memory import MemorySaver
+    from langgraph.checkpoint.memory import InMemorySaver
     from langgraph.types import interrupt, Command
     from typing_extensions import TypedDict
     
@@ -700,7 +365,7 @@ You can inspect the graph state via `graph.getState(config)`. To view the subgra
     builder.add_node("node_1", subgraph)
     builder.add_edge(START, "node_1")
     
-    checkpointer = MemorySaver()
+    checkpointer = InMemorySaver()
     graph = builder.compile(checkpointer=checkpointer)
     
     config = {"configurable": {"thread_id": "1"}}
@@ -714,53 +379,11 @@ You can inspect the graph state via `graph.getState(config)`. To view the subgra
     ```
     
     1. This will be available only when the subgraph is interrupted. Once you resume the graph, you won't be able to access the subgraph state.
-    :::
-
-    :::js
-    ```typescript
-    import { StateGraph, START, MemorySaver, interrupt, Command } from "@langchain/langgraph";
-    import { z } from "zod";
-    
-    const State = z.object({
-      foo: z.string(),
-    });
-    
-    // Subgraph
-    const subgraphBuilder = new StateGraph(State)
-      .addNode("subgraphNode1", (state) => {
-        const value = interrupt("Provide value:");
-        return { foo: state.foo + value };
-      })
-      .addEdge(START, "subgraphNode1");
-    
-    const subgraph = subgraphBuilder.compile();
-    
-    // Parent graph
-    const builder = new StateGraph(State)
-      .addNode("node1", subgraph)
-      .addEdge(START, "node1");
-    
-    const checkpointer = new MemorySaver();
-    const graph = builder.compile({ checkpointer });
-    
-    const config = { configurable: { thread_id: "1" } };
-    
-    await graph.invoke({ foo: "" }, config);
-    const parentState = await graph.getState(config);
-    const subgraphState = (await graph.getState(config, { subgraphs: true })).tasks[0].state; // (1)!
-    
-    // resume the subgraph
-    await graph.invoke(new Command({ resume: "bar" }), config);
-    ```
-    
-    2. This will be available only when the subgraph is interrupted. Once you resume the graph, you won't be able to access the subgraph state.
-    :::
 
 ## Stream subgraph outputs
 
-To include outputs from subgraphs in the streamed outputs, you can set the subgraphs option in the stream method of the parent graph. This will stream outputs from both the parent graph and any subgraphs.
+To include outputs from subgraphs in the streamed outputs, you can set `subgraphs=True` in the `.stream()` method of the parent graph. This will stream outputs from both the parent graph and any subgraphs.
 
-:::python
 ```python
 for chunk in graph.stream(
     {"foo": "foo"},
@@ -771,27 +394,9 @@ for chunk in graph.stream(
 ```
 
 1. Set `subgraphs=True` to stream outputs from subgraphs.
-:::
-
-:::js
-```typescript
-for await (const chunk of await graph.stream(
-  { foo: "foo" },
-  {
-    subgraphs: true, // (1)!
-    streamMode: "updates",
-  }
-)) {
-  console.log(chunk);
-}
-```
-
-1. Set `subgraphs: true` to stream outputs from subgraphs.
-:::
 
 ??? example "Stream from subgraphs"
 
-    :::python
     ```python
     from typing_extensions import TypedDict
     from langgraph.graph.state import StateGraph, START
@@ -845,66 +450,4 @@ for await (const chunk of await graph.stream(
     (('node_2:e58e5673-a661-ebb0-70d4-e298a7fc28b7',), {'subgraph_node_1': {'bar': 'bar'}})
     (('node_2:e58e5673-a661-ebb0-70d4-e298a7fc28b7',), {'subgraph_node_2': {'foo': 'hi! foobar'}})
     ((), {'node_2': {'foo': 'hi! foobar'}})
-    ```
-    :::
-
-    :::js
-    ```typescript
-    import { StateGraph, START } from "@langchain/langgraph";
-    import { z } from "zod";
-
-    // Define subgraph
-    const SubgraphState = z.object({
-      foo: z.string(),
-      bar: z.string(),
-    });
-    
-    const subgraphBuilder = new StateGraph(SubgraphState)
-      .addNode("subgraphNode1", (state) => {
-        return { bar: "bar" };
-      })
-      .addNode("subgraphNode2", (state) => {
-        // note that this node is using a state key ('bar') that is only available in the subgraph
-        // and is sending update on the shared state key ('foo')
-        return { foo: state.foo + state.bar };
-      })
-      .addEdge(START, "subgraphNode1")
-      .addEdge("subgraphNode1", "subgraphNode2");
-    
-    const subgraph = subgraphBuilder.compile();
-    
-    // Define parent graph
-    const ParentState = z.object({
-      foo: z.string(),
-    });
-    
-    const builder = new StateGraph(ParentState)
-      .addNode("node1", (state) => {
-        return { foo: "hi! " + state.foo };
-      })
-      .addNode("node2", subgraph)
-      .addEdge(START, "node1")
-      .addEdge("node1", "node2");
-    
-    const graph = builder.compile();
-
-    for await (const chunk of await graph.stream(
-      { foo: "foo" },
-      {
-        streamMode: "updates",
-        subgraphs: true, // (1)!
-      }
-    )) {
-      console.log(chunk);
-    }
-    ```
-  
-    2. Set `subgraphs: true` to stream outputs from subgraphs.
-
-    ```
-    [[], { node1: { foo: 'hi! foo' } }]
-    [['node2:e58e5673-a661-ebb0-70d4-e298a7fc28b7'], { subgraphNode1: { bar: 'bar' } }]
-    [['node2:e58e5673-a661-ebb0-70d4-e298a7fc28b7'], { subgraphNode2: { foo: 'hi! foobar' } }]
-    [[], { node2: { foo: 'hi! foobar' } }]
-    ```
-    :::
+    

libs/checkpoint-postgres/uv.lock

@@ -329,7 +329,6 @@ dev = [
     { name = "pytest-asyncio" },
     { name = "pytest-mock" },
     { name = "pytest-watcher" },
-    { name = "redis" },
     { name = "ruff" },
 ]
 

libs/checkpoint-sqlite/uv.lock

@@ -341,7 +341,6 @@ dev = [
     { name = "pytest-asyncio" },
     { name = "pytest-mock" },
     { name = "pytest-watcher" },
-    { name = "redis" },
     { name = "ruff" },
 ]
 

libs/checkpoint/langgraph/cache/redis/__init__.py

@@ -1,144 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Mapping, Sequence
-from typing import Any
-
-from langgraph.cache.base import BaseCache, FullKey, Namespace, ValueT
-from langgraph.checkpoint.serde.base import SerializerProtocol
-
-
-class RedisCache(BaseCache[ValueT]):
-    """Redis-based cache implementation with TTL support."""
-
-    def __init__(
-        self,
-        redis: Any,
-        *,
-        serde: SerializerProtocol | None = None,
-        prefix: str = "langgraph:cache:",
-    ) -> None:
-        """Initialize the cache with a Redis client.
-
-        Args:
-            redis: Redis client instance (sync or async)
-            serde: Serializer to use for values
-            prefix: Key prefix for all cached values
-        """
-        super().__init__(serde=serde)
-        self.redis = redis
-        self.prefix = prefix
-
-    def _make_key(self, ns: Namespace, key: str) -> str:
-        """Create a Redis key from namespace and key."""
-        ns_str = ":".join(ns) if ns else ""
-        return f"{self.prefix}{ns_str}:{key}" if ns_str else f"{self.prefix}{key}"
-
-    def _parse_key(self, redis_key: str) -> tuple[Namespace, str]:
-        """Parse a Redis key back to namespace and key."""
-        if not redis_key.startswith(self.prefix):
-            raise ValueError(
-                f"Key {redis_key} does not start with prefix {self.prefix}"
-            )
-
-        remaining = redis_key[len(self.prefix) :]
-        if ":" in remaining:
-            parts = remaining.split(":")
-            key = parts[-1]
-            ns_parts = parts[:-1]
-            return (tuple(ns_parts), key)
-        else:
-            return (tuple(), remaining)
-
-    def get(self, keys: Sequence[FullKey]) -> dict[FullKey, ValueT]:
-        """Get the cached values for the given keys."""
-        if not keys:
-            return {}
-
-        # Build Redis keys
-        redis_keys = [self._make_key(ns, key) for ns, key in keys]
-
-        # Get values from Redis using MGET
-        try:
-            raw_values = self.redis.mget(redis_keys)
-        except Exception:
-            # If Redis is unavailable, return empty dict
-            return {}
-
-        values: dict[FullKey, ValueT] = {}
-        for i, raw_value in enumerate(raw_values):
-            if raw_value is not None:
-                try:
-                    # Deserialize the value
-                    encoding, data = raw_value.split(b":", 1)
-                    values[keys[i]] = self.serde.loads_typed((encoding.decode(), data))
-                except Exception:
-                    # Skip corrupted entries
-                    continue
-
-        return values
-
-    async def aget(self, keys: Sequence[FullKey]) -> dict[FullKey, ValueT]:
-        """Asynchronously get the cached values for the given keys."""
-        return self.get(keys)
-
-    def set(self, mapping: Mapping[FullKey, tuple[ValueT, int | None]]) -> None:
-        """Set the cached values for the given keys and TTLs."""
-        if not mapping:
-            return
-
-        # Use pipeline for efficient batch operations
-        pipe = self.redis.pipeline()
-
-        for (ns, key), (value, ttl) in mapping.items():
-            redis_key = self._make_key(ns, key)
-            encoding, data = self.serde.dumps_typed(value)
-
-            # Store as "encoding:data" format
-            serialized_value = f"{encoding}:".encode() + data
-
-            if ttl is not None:
-                pipe.setex(redis_key, ttl, serialized_value)
-            else:
-                pipe.set(redis_key, serialized_value)
-
-        try:
-            pipe.execute()
-        except Exception:
-            # Silently fail if Redis is unavailable
-            pass
-
-    async def aset(self, mapping: Mapping[FullKey, tuple[ValueT, int | None]]) -> None:
-        """Asynchronously set the cached values for the given keys and TTLs."""
-        self.set(mapping)
-
-    def clear(self, namespaces: Sequence[Namespace] | None = None) -> None:
-        """Delete the cached values for the given namespaces.
-        If no namespaces are provided, clear all cached values."""
-        try:
-            if namespaces is None:
-                # Clear all keys with our prefix
-                pattern = f"{self.prefix}*"
-                keys = self.redis.keys(pattern)
-                if keys:
-                    self.redis.delete(*keys)
-            else:
-                # Clear specific namespaces
-                keys_to_delete = []
-                for ns in namespaces:
-                    ns_str = ":".join(ns) if ns else ""
-                    pattern = (
-                        f"{self.prefix}{ns_str}:*" if ns_str else f"{self.prefix}*"
-                    )
-                    keys = self.redis.keys(pattern)
-                    keys_to_delete.extend(keys)
-
-                if keys_to_delete:
-                    self.redis.delete(*keys_to_delete)
-        except Exception:
-            # Silently fail if Redis is unavailable
-            pass
-
-    async def aclear(self, namespaces: Sequence[Namespace] | None = None) -> None:
-        """Asynchronously delete the cached values for the given namespaces.
-        If no namespaces are provided, clear all cached values."""
-        self.clear(namespaces)

libs/checkpoint/langgraph/checkpoint/base/__init__.py

@@ -81,9 +81,6 @@ class Checkpoint(TypedDict):
     This keeps track of the versions of the channels that each node has seen.
     Used to determine which nodes to execute next.
     """
-    updated_channels: list[str] | None
-    """The channels that were updated in this checkpoint.
-    """
 
 
 def copy_checkpoint(checkpoint: Checkpoint) -> Checkpoint:
@@ -95,7 +92,6 @@ def copy_checkpoint(checkpoint: Checkpoint) -> Checkpoint:
         channel_versions=checkpoint["channel_versions"].copy(),
         versions_seen={k: v.copy() for k, v in checkpoint["versions_seen"].items()},
         pending_sends=checkpoint.get("pending_sends", []).copy(),
-        updated_channels=checkpoint.get("updated_channels", None),
     )
 
 
@@ -441,7 +437,6 @@ def empty_checkpoint() -> Checkpoint:
         channel_versions={},
         versions_seen={},
         pending_sends=[],
-        updated_channels=None,
     )
 
 
@@ -475,5 +470,4 @@ def create_checkpoint(
         channel_versions=checkpoint["channel_versions"],
         versions_seen=checkpoint["versions_seen"],
         pending_sends=checkpoint.get("pending_sends", []),
-        updated_channels=None,
     )

libs/checkpoint/langgraph/store/base/batch.py

@@ -64,21 +64,14 @@ class AsyncBatchedBaseStore(BaseStore):
         super().__init__()
         self._loop = asyncio.get_running_loop()
         self._aqueue: asyncio.Queue[tuple[asyncio.Future, Op]] = asyncio.Queue()
-        self._task: asyncio.Task | None = None
-        self._ensure_task()
+        self._task = self._loop.create_task(_run(self._aqueue, weakref.ref(self)))
 
     def __del__(self) -> None:
         try:
-            if self._task:
-                self._task.cancel()
+            self._task.cancel()
         except RuntimeError:
             pass
 
-    def _ensure_task(self) -> None:
-        """Ensure the background processing loop is running."""
-        if self._task is None or self._task.done():
-            self._task = self._loop.create_task(_run(self._aqueue, weakref.ref(self)))
-
     async def aget(
         self,
         namespace: tuple[str, ...],
@@ -86,7 +79,7 @@ class AsyncBatchedBaseStore(BaseStore):
         *,
         refresh_ttl: bool | None = None,
     ) -> Item | None:
-        self._ensure_task()
+        assert not self._task.done()
         fut = self._loop.create_future()
         self._aqueue.put_nowait(
             (
@@ -111,7 +104,7 @@ class AsyncBatchedBaseStore(BaseStore):
         offset: int = 0,
         refresh_ttl: bool | None = None,
     ) -> list[SearchItem]:
-        self._ensure_task()
+        assert not self._task.done()
         fut = self._loop.create_future()
         self._aqueue.put_nowait(
             (
@@ -137,7 +130,7 @@ class AsyncBatchedBaseStore(BaseStore):
         *,
         ttl: float | None | NotProvided = NOT_PROVIDED,
     ) -> None:
-        self._ensure_task()
+        assert not self._task.done()
         _validate_namespace(namespace)
         fut = self._loop.create_future()
         self._aqueue.put_nowait(
@@ -155,7 +148,7 @@ class AsyncBatchedBaseStore(BaseStore):
         namespace: tuple[str, ...],
         key: str,
     ) -> None:
-        self._ensure_task()
+        assert not self._task.done()
         fut = self._loop.create_future()
         self._aqueue.put_nowait((fut, PutOp(namespace, key, None)))
         return await fut
@@ -169,7 +162,7 @@ class AsyncBatchedBaseStore(BaseStore):
         limit: int = 100,
         offset: int = 0,
     ) -> list[tuple[str, ...]]:
-        self._ensure_task()
+        assert not self._task.done()
         fut = self._loop.create_future()
         match_conditions = []
         if prefix:

libs/checkpoint/pyproject.toml

@@ -32,7 +32,6 @@ dev = [
   "numpy",
   "pandas",
   "pandas-stubs>=2.2.2.240807",
-  "redis",
 ]
 
 [tool.hatch.build.targets.wheel]

libs/checkpoint/tests/test_redis_cache.py

@@ -1,313 +0,0 @@
-"""Unit tests for Redis cache implementation."""
-
-import time
-
-import pytest
-import redis
-
-from langgraph.cache.redis import RedisCache
-
-
-class TestRedisCache:
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        """Set up test Redis client and cache."""
-        self.client = redis.Redis(
-            host="localhost", port=6379, db=0, decode_responses=False
-        )
-        try:
-            self.client.ping()
-        except redis.ConnectionError:
-            pytest.skip("Redis server not available")
-
-        self.cache = RedisCache(self.client, prefix="test:cache:")
-
-        # Clean up before each test
-        self.client.flushdb()
-
-    def teardown_method(self):
-        """Clean up after each test."""
-        try:
-            self.client.flushdb()
-        except Exception:
-            pass
-
-    def test_basic_set_and_get(self):
-        """Test basic set and get operations."""
-        keys = [(("graph", "node"), "key1")]
-        values = {keys[0]: ({"result": 42}, None)}
-
-        # Set value
-        self.cache.set(values)
-
-        # Get value
-        result = self.cache.get(keys)
-        assert len(result) == 1
-        assert result[keys[0]] == {"result": 42}
-
-    def test_batch_operations(self):
-        """Test batch set and get operations."""
-        keys = [
-            (("graph", "node1"), "key1"),
-            (("graph", "node2"), "key2"),
-            (("other", "node"), "key3"),
-        ]
-        values = {
-            keys[0]: ({"result": 1}, None),
-            keys[1]: ({"result": 2}, 60),  # With TTL
-            keys[2]: ({"result": 3}, None),
-        }
-
-        # Set values
-        self.cache.set(values)
-
-        # Get all values
-        result = self.cache.get(keys)
-        assert len(result) == 3
-        assert result[keys[0]] == {"result": 1}
-        assert result[keys[1]] == {"result": 2}
-        assert result[keys[2]] == {"result": 3}
-
-    def test_ttl_behavior(self):
-        """Test TTL (time-to-live) functionality."""
-        key = (("graph", "node"), "ttl_key")
-        values = {key: ({"data": "expires_soon"}, 1)}  # 1 second TTL
-
-        # Set with TTL
-        self.cache.set(values)
-
-        # Should be available immediately
-        result = self.cache.get([key])
-        assert len(result) == 1
-        assert result[key] == {"data": "expires_soon"}
-
-        # Wait for expiration
-        time.sleep(1.1)
-
-        # Should be expired
-        result = self.cache.get([key])
-        assert len(result) == 0
-
-    def test_namespace_isolation(self):
-        """Test that different namespaces are isolated."""
-        key1 = (("graph1", "node"), "same_key")
-        key2 = (("graph2", "node"), "same_key")
-
-        values = {key1: ({"graph": 1}, None), key2: ({"graph": 2}, None)}
-
-        self.cache.set(values)
-
-        result = self.cache.get([key1, key2])
-        assert result[key1] == {"graph": 1}
-        assert result[key2] == {"graph": 2}
-
-    def test_clear_all(self):
-        """Test clearing all cached values."""
-        keys = [(("graph", "node1"), "key1"), (("graph", "node2"), "key2")]
-        values = {keys[0]: ({"result": 1}, None), keys[1]: ({"result": 2}, None)}
-
-        self.cache.set(values)
-
-        # Verify data exists
-        result = self.cache.get(keys)
-        assert len(result) == 2
-
-        # Clear all
-        self.cache.clear()
-
-        # Verify data is gone
-        result = self.cache.get(keys)
-        assert len(result) == 0
-
-    def test_clear_by_namespace(self):
-        """Test clearing cached values by namespace."""
-        keys = [
-            (("graph1", "node"), "key1"),
-            (("graph2", "node"), "key2"),
-            (("graph1", "other"), "key3"),
-        ]
-        values = {
-            keys[0]: ({"result": 1}, None),
-            keys[1]: ({"result": 2}, None),
-            keys[2]: ({"result": 3}, None),
-        }
-
-        self.cache.set(values)
-
-        # Clear only graph1 namespace
-        self.cache.clear([("graph1", "node"), ("graph1", "other")])
-
-        # graph1 should be cleared, graph2 should remain
-        result = self.cache.get(keys)
-        assert len(result) == 1
-        assert result[keys[1]] == {"result": 2}
-
-    def test_empty_operations(self):
-        """Test behavior with empty keys/values."""
-        # Empty get
-        result = self.cache.get([])
-        assert result == {}
-
-        # Empty set
-        self.cache.set({})  # Should not raise error
-
-    def test_nonexistent_keys(self):
-        """Test getting keys that don't exist."""
-        keys = [(("graph", "node"), "nonexistent")]
-        result = self.cache.get(keys)
-        assert len(result) == 0
-
-    @pytest.mark.asyncio
-    async def test_async_operations(self):
-        """Test async set and get operations with sync Redis client."""
-        # Create sync Redis client and cache (like main integration tests)
-        client = redis.Redis(
-            host="localhost", port=6379, db=1, decode_responses=False
-        )
-        try:
-            client.ping()
-        except Exception:
-            pytest.skip("Redis not available")
-
-        cache = RedisCache(client, prefix="test:async:")
-
-        keys = [(("graph", "node"), "async_key")]
-        values = {keys[0]: ({"async": True}, None)}
-
-        # Async set (delegates to sync)
-        await cache.aset(values)
-
-        # Async get (delegates to sync)
-        result = await cache.aget(keys)
-        assert len(result) == 1
-        assert result[keys[0]] == {"async": True}
-
-        # Cleanup
-        client.flushdb()
-
-    @pytest.mark.asyncio
-    async def test_async_clear(self):
-        """Test async clear operations with sync Redis client."""
-        # Create sync Redis client and cache (like main integration tests)
-        client = redis.Redis(
-            host="localhost", port=6379, db=1, decode_responses=False
-        )
-        try:
-            client.ping()
-        except Exception:
-            pytest.skip("Redis not available")
-
-        cache = RedisCache(client, prefix="test:async:")
-
-        keys = [(("graph", "node"), "key")]
-        values = {keys[0]: ({"data": "test"}, None)}
-
-        await cache.aset(values)
-
-        # Verify data exists
-        result = await cache.aget(keys)
-        assert len(result) == 1
-
-        # Clear all (delegates to sync)
-        await cache.aclear()
-
-        # Verify data is gone
-        result = await cache.aget(keys)
-        assert len(result) == 0
-
-        # Cleanup
-        client.flushdb()
-
-    def test_redis_unavailable_get(self):
-        """Test behavior when Redis is unavailable during get operations."""
-        # Create cache with non-existent Redis server
-        bad_client = redis.Redis(
-            host="nonexistent", port=9999, socket_connect_timeout=0.1
-        )
-        cache = RedisCache(bad_client, prefix="test:cache:")
-
-        keys = [(("graph", "node"), "key")]
-        result = cache.get(keys)
-
-        # Should return empty dict when Redis unavailable
-        assert result == {}
-
-    def test_redis_unavailable_set(self):
-        """Test behavior when Redis is unavailable during set operations."""
-        # Create cache with non-existent Redis server
-        bad_client = redis.Redis(
-            host="nonexistent", port=9999, socket_connect_timeout=0.1
-        )
-        cache = RedisCache(bad_client, prefix="test:cache:")
-
-        keys = [(("graph", "node"), "key")]
-        values = {keys[0]: ({"data": "test"}, None)}
-
-        # Should not raise exception when Redis unavailable
-        cache.set(values)  # Should silently fail
-
-    @pytest.mark.asyncio
-    async def test_redis_unavailable_async(self):
-        """Test async behavior when Redis is unavailable."""
-        # Create sync cache with non-existent Redis server (like main integration tests)
-        bad_client = redis.Redis(
-            host="nonexistent", port=9999, socket_connect_timeout=0.1
-        )
-        cache = RedisCache(bad_client, prefix="test:cache:")
-
-        keys = [(("graph", "node"), "key")]
-        values = {keys[0]: ({"data": "test"}, None)}
-
-        # Should return empty dict for get (delegates to sync)
-        result = await cache.aget(keys)
-        assert result == {}
-
-        # Should not raise exception for set (delegates to sync)
-        await cache.aset(values)  # Should silently fail
-
-    def test_corrupted_data_handling(self):
-        """Test handling of corrupted data in Redis."""
-        # Set some valid data first
-        keys = [(("graph", "node"), "valid_key")]
-        values = {keys[0]: ({"data": "valid"}, None)}
-        self.cache.set(values)
-
-        # Manually insert corrupted data
-        corrupted_key = self.cache._make_key(("graph", "node"), "corrupted_key")
-        self.client.set(corrupted_key, b"invalid:data:format:too:many:colons")
-
-        # Should skip corrupted entry and return only valid ones
-        all_keys = [keys[0], (("graph", "node"), "corrupted_key")]
-        result = self.cache.get(all_keys)
-
-        assert len(result) == 1
-        assert result[keys[0]] == {"data": "valid"}
-
-    def test_key_parsing_edge_cases(self):
-        """Test key parsing with edge cases."""
-        # Test empty namespace
-        key1 = ((), "empty_ns")
-        values = {key1: ({"data": "empty_ns"}, None)}
-        self.cache.set(values)
-        result = self.cache.get([key1])
-        assert result[key1] == {"data": "empty_ns"}
-
-        # Test namespace with special characters
-        key2 = (("graph:with:colons", "node-with-dashes"), "key_with_underscores")
-        values = {key2: ({"data": "special_chars"}, None)}
-        self.cache.set(values)
-        result = self.cache.get([key2])
-        assert result[key2] == {"data": "special_chars"}
-
-    def test_large_data_serialization(self):
-        """Test handling of large data objects."""
-        # Create a large data structure
-        large_data = {"large_list": list(range(1000)), "nested": {"data": "x" * 1000}}
-        key = (("graph", "node"), "large_key")
-        values = {key: (large_data, None)}
-
-        self.cache.set(values)
-        result = self.cache.get([key])
-
-        assert len(result) == 1
-        assert result[key] == large_data

libs/checkpoint/tests/test_store.py

@@ -34,42 +34,6 @@ class MockAsyncBatchedStore(AsyncBatchedBaseStore):
         return self._store.batch(ops)
 
 
-async def test_async_batch_store_resilience() -> None:
-    """Test that AsyncBatchedBaseStore recovers gracefully from task cancellation."""
-    doc = {"foo": "bar"}
-    async_store = MockAsyncBatchedStore()
-
-    await async_store.aput(("foo", "langgraph", "foo"), "bar", doc)
-
-    # Store the original task reference
-    original_task = async_store._task
-    assert original_task is not None
-    assert not original_task.done()
-
-    # Cancel the background task
-    original_task.cancel()
-    await asyncio.sleep(0.01)
-    assert original_task.cancelled()
-
-    # Perform a new operation - this should trigger _ensure_task() to create a new task
-    result = await async_store.asearch(("foo", "langgraph", "foo"))
-    assert len(result) > 0
-    assert result[0].value == doc
-
-    # Verify a new task was created
-    new_task = async_store._task
-    assert new_task is not None
-    assert new_task is not original_task
-    assert not new_task.done()
-
-    # Test that operations continue to work with the new task
-    doc2 = {"baz": "qux"}
-    await async_store.aput(("test", "namespace"), "key", doc2)
-    result2 = await async_store.aget(("test", "namespace"), "key")
-    assert result2 is not None
-    assert result2.value == doc2
-
-
 def test_get_text_at_path() -> None:
     nested_data = {
         "name": "test",

libs/checkpoint/uv.lock

@@ -32,15 +32,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload-time = "2025-03-17T00:02:52.713Z" },
 ]
 
-[[package]]
-name = "async-timeout"
-version = "5.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a5/ae/136395dfbfe00dfc94da3f3e136d0b13f394cba8f4841120e34226265780/async_timeout-5.0.1.tar.gz", hash = "sha256:d9321a7a3d5a6a5e187e824d2fa0793ce379a202935782d555d6e9d2735677d3", size = 9274, upload-time = "2024-11-06T16:41:39.6Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fe/ba/e2081de779ca30d473f21f5b30e0e737c438205440784c7dfc81efc2b029/async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c", size = 6233, upload-time = "2024-11-06T16:41:37.9Z" },
-]
-
 [[package]]
 name = "certifi"
 version = "2025.7.9"
@@ -354,7 +345,6 @@ dev = [
     { name = "pytest-asyncio" },
     { name = "pytest-mock" },
     { name = "pytest-watcher" },
-    { name = "redis" },
     { name = "ruff" },
 ]
 
@@ -376,7 +366,6 @@ dev = [
     { name = "pytest-asyncio" },
     { name = "pytest-mock" },
     { name = "pytest-watcher" },
-    { name = "redis" },
     { name = "ruff" },
 ]
 
@@ -1164,18 +1153,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/19/87/5124b1c1f2412bb95c59ec481eaf936cd32f0fe2a7b16b97b81c4c017a6a/PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8", size = 162312, upload-time = "2024-08-06T20:33:49.073Z" },
 ]
 
-[[package]]
-name = "redis"
-version = "6.3.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "async-timeout", marker = "python_full_version < '3.11.3'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/21/cd/030274634a1a052b708756016283ea3d84e91ae45f74d7f5dcf55d753a0f/redis-6.3.0.tar.gz", hash = "sha256:3000dbe532babfb0999cdab7b3e5744bcb23e51923febcfaeb52c8cfb29632ef", size = 4647275, upload-time = "2025-08-05T08:12:31.648Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/df/a7/2fe45801534a187543fc45d28b3844d84559c1589255bc2ece30d92dc205/redis-6.3.0-py3-none-any.whl", hash = "sha256:92f079d656ded871535e099080f70fab8e75273c0236797126ac60242d638e9b", size = 280018, upload-time = "2025-08-05T08:12:30.093Z" },
-]
-
 [[package]]
 name = "requests"
 version = "2.32.4"

libs/cli/examples/.env.example

@@ -7,4 +7,7 @@ LANGCHAIN_API_KEY=placeholder
 LANGCHAIN_PROJECT=placeholder
 LANGGRAPH_AUTH_TYPE=noop
 LANGSMITH_AUTH_ENDPOINT=placeholder
-LANGSMITH_TENANT_ID=placeholder
+LANGSMITH_TENANT_ID=placeholder
+DATABASE_URI=placeholder
+REDIS_URI=placeholder
+

libs/cli/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph-cli"
-version = "0.3.6"
+version = "0.3.7"
 description = "CLI for interacting with LangGraph API"
 authors = []
 requires-python = ">=3.9"
@@ -18,8 +18,8 @@ dependencies = [
 
 [project.optional-dependencies]
 inmem = [
-    "langgraph-api>=0.2.67,<0.3.0 ; python_version >= '3.11'",
-    "langgraph-runtime-inmem>=0.6.0 ; python_version >= '3.11'",
+    "langgraph-api>=0.2.120,<0.3.0 ; python_version >= '3.11'",
+    "langgraph-runtime-inmem>=0.6.8 ; python_version >= '3.11'",
     "python-dotenv>=0.8.0",
 ]
 

libs/cli/uv.lock

@@ -18,16 +18,16 @@ wheels = [
 
 [[package]]
 name = "anyio"
-version = "4.9.0"
+version = "4.10.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna", marker = "python_full_version >= '3.11'" },
     { name = "sniffio", marker = "python_full_version >= '3.11'" },
     { name = "typing-extensions", marker = "python_full_version >= '3.11' and python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949, upload-time = "2025-03-17T00:02:54.77Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/b4/636b3b65173d3ce9a38ef5f0522789614e590dab6a8d505340a4efe4c567/anyio-4.10.0.tar.gz", hash = "sha256:3f3fae35c96039744587aa5b8371e7e8e603c0702999535961dd336026973ba6", size = 213252, upload-time = "2025-08-04T08:54:26.451Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload-time = "2025-03-17T00:02:52.713Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/12/e5e0282d673bb9746bacfb6e2dba8719989d3660cdb2ea79aee9a9651afb/anyio-4.10.0-py3-none-any.whl", hash = "sha256:60e474ac86736bbfd6f210f7a61218939c318f43f9972497381f1c5e930ed3d1", size = 107213, upload-time = "2025-08-04T08:54:24.882Z" },
 ]
 
 [[package]]
@@ -53,11 +53,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2025.7.14"
+version = "2025.8.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b3/76/52c535bcebe74590f296d6c77c86dabf761c41980e1347a2422e4aa2ae41/certifi-2025.7.14.tar.gz", hash = "sha256:8ea99dbdfaaf2ba2f9bac77b9249ef62ec5218e7c2b2e903378ed5fccf765995", size = 163981, upload-time = "2025-07-14T03:29:28.449Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/dc/67/960ebe6bf230a96cda2e0abcf73af550ec4f090005363542f0765df162e0/certifi-2025.8.3.tar.gz", hash = "sha256:e564105f78ded564e3ae7c923924435e1daa7463faeab5bb932bc53ffae63407", size = 162386, upload-time = "2025-08-03T03:07:47.08Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4f/52/34c6cf5bb9285074dc3531c437b3919e825d976fde097a7a73f79e726d03/certifi-2025.7.14-py3-none-any.whl", hash = "sha256:6b31f564a415d79ee77df69d757bb49a5bb53bd9f756cbbe24394ffd6fc1f4b2", size = 162722, upload-time = "2025-07-14T03:29:26.863Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/48/1549795ba7742c948d2ad169c1c8cdbae65bc450d6cd753d124b17c8cd32/certifi-2025.8.3-py3-none-any.whl", hash = "sha256:f6c12493cfb1b06ba2ff328595af9350c65d6644968e5d3a2ffd78699af217a5", size = 161216, upload-time = "2025-08-03T03:07:45.777Z" },
 ]
 
 [[package]]
@@ -453,7 +453,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "0.3.69"
+version = "0.3.72"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch", marker = "python_full_version >= '3.11'" },
@@ -464,14 +464,14 @@ dependencies = [
     { name = "tenacity", marker = "python_full_version >= '3.11'" },
     { name = "typing-extensions", marker = "python_full_version >= '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/82/26/c4770d3933237cde2918d502e3b0a8b6ce100b296840b632658f3e59b341/langchain_core-0.3.69.tar.gz", hash = "sha256:c132961117cc7f0227a4c58dd3e209674a6dd5b7e74abc61a0df93b0d736e283", size = 563824, upload-time = "2025-07-15T21:19:56.626Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/8b/49/7568baeb96a57d3218cb5f1f113b142063679088fd3a0d0cae1feb0b3d36/langchain_core-0.3.72.tar.gz", hash = "sha256:4de3828909b3d7910c313242ab07b241294650f5cb6eac17738dd3638b1cd7de", size = 567227, upload-time = "2025-07-24T00:40:08.5Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/51/7b/bb7b088440ff9cc55e9e6eba94162cbdcd3b1693c194e1ad4764acba29b9/langchain_core-0.3.69-py3-none-any.whl", hash = "sha256:383e9cb4919f7ef4b24bf8552ef42e4323c064924fea88b28dd5d7ddb740d3b8", size = 441556, upload-time = "2025-07-15T21:19:55.342Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/7d/9f75023c478e3b854d67da31d721e39f0eb30ae969ec6e755430cb1c0fb5/langchain_core-0.3.72-py3-none-any.whl", hash = "sha256:9fa15d390600eb6b6544397a7aa84be9564939b6adf7a2b091179ea30405b240", size = 442806, upload-time = "2025-07-24T00:40:06.994Z" },
 ]
 
 [[package]]
 name = "langgraph"
-version = "0.5.3"
+version = "0.6.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core", marker = "python_full_version >= '3.11'" },
@@ -481,14 +481,14 @@ dependencies = [
     { name = "pydantic", marker = "python_full_version >= '3.11'" },
     { name = "xxhash", marker = "python_full_version >= '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/99/f4/f4ebb83dff589b31d4a11c0d3c9c39a55d41f2a722dfb78761f7ed95e96d/langgraph-0.5.3.tar.gz", hash = "sha256:36d4b67f984ff2649d447826fc99b1a2af3e97599a590058f20750048e4f548f", size = 442591, upload-time = "2025-07-14T20:10:02.907Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/d8/ecedf01b3e90ad288343eeb06d91d8511e049ee0b16d7f3c146baeed2a49/langgraph-0.6.3.tar.gz", hash = "sha256:0d2280d295133dc34ccc12eae1ad4d82ee847b009c59801de418068fa9248e1b", size = 452277, upload-time = "2025-08-03T11:21:35.74Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d7/2f/11be9302d3a213debcfe44355453a1e8fd7ee5e3138edeb8bd82b56bc8f6/langgraph-0.5.3-py3-none-any.whl", hash = "sha256:9819b88a6ef6134a0fa6d6121a81b202dc3d17b25cf7ea3fe4d7669b9b252b5d", size = 143774, upload-time = "2025-07-14T20:10:01.497Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/93/7836486f6c18b0b11e6bde5bc0f318947e610637aa5231081bd4adf79eb9/langgraph-0.6.3-py3-none-any.whl", hash = "sha256:733efd8c59b9915e582619da40f2ab5ebb121319a4d7718adef82d6db07547eb", size = 152463, upload-time = "2025-08-03T11:21:34.002Z" },
 ]
 
 [[package]]
 name = "langgraph-api"
-version = "0.2.96"
+version = "0.2.120"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cloudpickle", marker = "python_full_version >= '3.11'" },
@@ -511,9 +511,9 @@ dependencies = [
     { name = "uvicorn", marker = "python_full_version >= '3.11'" },
     { name = "watchfiles", marker = "python_full_version >= '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ee/4c/837c5ce4aab704b6b13f27c5dd6330dabaf2f25d198032cb18e5d5dcaa53/langgraph_api-0.2.96.tar.gz", hash = "sha256:c498b5542a952d194121cdbe5a4b04e2f48fbc37480141ea2b87ba39a132ddb1", size = 238776, upload-time = "2025-07-17T17:57:47.274Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/3d/be14b80646d62ce33452873304d53dec60844a5cff7ea81039c31abc9729/langgraph_api-0.2.120.tar.gz", hash = "sha256:78279577ad0b6a431d2b0124e5aa6dc2f2d6a557aa950ce53ce4fd53cf88f7a8", size = 243518, upload-time = "2025-08-04T18:08:53.263Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d9/7f/dfae9bc0f85a98bbd96d00df2a39e8b8386977e8ce4a6199d1065bb3709d/langgraph_api-0.2.96-py3-none-any.whl", hash = "sha256:304d424d7a85735489fab1764b439e8219739619ad708b9465b8b8f421f17b37", size = 194393, upload-time = "2025-07-17T17:57:45.89Z" },
+    { url = "https://files.pythonhosted.org/packages/33/d3/036cedb46083411bf8d8df8e8f293a1be4c4a2de5a9d05618e6068014c2d/langgraph_api-0.2.120-py3-none-any.whl", hash = "sha256:a1e6b565c237d370f99ca73a03d66a284e6acfdfb9a20b8c51d0e18435698bb2", size = 198181, upload-time = "2025-08-04T18:08:52.044Z" },
 ]
 
 [[package]]
@@ -531,7 +531,7 @@ wheels = [
 
 [[package]]
 name = "langgraph-cli"
-version = "0.3.6"
+version = "0.3.7"
 source = { editable = "." }
 dependencies = [
     { name = "click", version = "8.1.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
@@ -561,8 +561,8 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "click", specifier = ">=8.1.7" },
-    { name = "langgraph-api", marker = "python_full_version >= '3.11' and extra == 'inmem'", specifier = ">=0.2.67,<0.3.0" },
-    { name = "langgraph-runtime-inmem", marker = "python_full_version >= '3.11' and extra == 'inmem'", specifier = ">=0.6.0" },
+    { name = "langgraph-api", marker = "python_full_version >= '3.11' and extra == 'inmem'", specifier = ">=0.2.120,<0.3.0" },
+    { name = "langgraph-runtime-inmem", marker = "python_full_version >= '3.11' and extra == 'inmem'", specifier = ">=0.6.8" },
     { name = "langgraph-sdk", marker = "python_full_version >= '3.11'", specifier = ">=0.1.0" },
     { name = "python-dotenv", marker = "extra == 'inmem'", specifier = ">=0.8.0" },
 ]
@@ -582,20 +582,20 @@ dev = [
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "0.5.2"
+version = "0.6.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core", marker = "python_full_version >= '3.11'" },
     { name = "langgraph-checkpoint", marker = "python_full_version >= '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/bb/11/98134c47832fbde0caf0e06f1a104577da9215c358d7854093c1d835b272/langgraph_prebuilt-0.5.2.tar.gz", hash = "sha256:2c900a5be0d6a93ea2521e0d931697cad2b646f1fcda7aa5c39d8d7539772465", size = 117808, upload-time = "2025-06-30T19:52:48.307Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/6a/7f662e24eb89bf74fcf2fd109f350ec023373d196b16d12b54e66961f145/langgraph_prebuilt-0.6.3.tar.gz", hash = "sha256:5e1ca7ba98f53ce98400f34bdb0afe47f71d0167c4108b11d4aeed4c6d4a1d3d", size = 125368, upload-time = "2025-08-03T11:16:24.789Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/64/6bc45ab9e0e1112698ebff579fe21f5606ea65cd08266995a357e312a4d2/langgraph_prebuilt-0.5.2-py3-none-any.whl", hash = "sha256:1f4cd55deca49dffc3e5127eec12fcd244fc381321002f728afa88642d5ec59d", size = 23776, upload-time = "2025-06-30T19:52:47.494Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/27/049a9e07d1d75c39e0109445e93c9df8bc4a8c51730655be561ecdf04dee/langgraph_prebuilt-0.6.3-py3-none-any.whl", hash = "sha256:cea830fc73d1a6fb871c5c6739e894bffcb7b7a07343198b56f263d3113ae8d6", size = 28917, upload-time = "2025-08-03T11:16:23.695Z" },
 ]
 
 [[package]]
 name = "langgraph-runtime-inmem"
-version = "0.6.0"
+version = "0.6.8"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "blockbuster", marker = "python_full_version >= '3.11'" },
@@ -605,27 +605,27 @@ dependencies = [
     { name = "starlette", marker = "python_full_version >= '3.11'" },
     { name = "structlog", marker = "python_full_version >= '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/04/0c/d145c6d83d36efda17b10812760711b77ec05f5bbe962c961d75b32e3c17/langgraph_runtime_inmem-0.6.0.tar.gz", hash = "sha256:b09675789a331be4a2b387c9c46de8772c4c8418e74c057b4ca24e85c25acae3", size = 77618, upload-time = "2025-07-17T16:51:01.504Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/70/af/5bb8de4f16412db4d894dafec4b83e8fcbe3e409fae2318ab95348843e8c/langgraph_runtime_inmem-0.6.8.tar.gz", hash = "sha256:7213e6c09fad509a112b9c57f7eafa99b61ff7965b5f867798fe916b5f670713", size = 79571, upload-time = "2025-07-30T22:42:01.192Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/12/6a/9dc5769b5d2f97d1feacbbf93b180c359dff7462454b37dfef8aed4ebcf7/langgraph_runtime_inmem-0.6.0-py3-none-any.whl", hash = "sha256:312dab25bec6557f1edf95cb8bd7c8bb52f7f4bfeecaf66e7001662f095c9079", size = 29317, upload-time = "2025-07-17T16:51:00.622Z" },
+    { url = "https://files.pythonhosted.org/packages/82/60/702a2704b904abf8ae0338e9bdee2ca82b67cc1fa7b5a5fcaaa8601ab310/langgraph_runtime_inmem-0.6.8-py3-none-any.whl", hash = "sha256:749dbd1897eec1c46512f5723de7133369d5076bdadb6d164ce5c70f52ad48c6", size = 30291, upload-time = "2025-07-30T22:42:00.196Z" },
 ]
 
 [[package]]
 name = "langgraph-sdk"
-version = "0.1.73"
+version = "0.2.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx", marker = "python_full_version >= '3.11'" },
     { name = "orjson", marker = "python_full_version >= '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ba/e8/daf0271f91e93b10566533955c00ee16e471066755c2efd1ba9a887a7eab/langgraph_sdk-0.1.73.tar.gz", hash = "sha256:6e6dcdf66bcf8710739899616856527a72a605ce15beb76fbac7f4ce0e2ad080", size = 72157, upload-time = "2025-07-14T23:57:22.765Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2a/3e/3dc45dc7682c9940db9edaf8773d2e157397c5bd6881f6806808afd8731e/langgraph_sdk-0.2.0.tar.gz", hash = "sha256:cd8b5f6595e5571be5cbffd04cf936978ab8f5d1005517c99715947ef871e246", size = 72510, upload-time = "2025-07-22T17:31:06.745Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/77/86/56e01e715e5b0028cdaff1492a89e54fa12e18c21e03b805a10ea36ecd5a/langgraph_sdk-0.1.73-py3-none-any.whl", hash = "sha256:a60ac33f70688ad07051edff1d5ed8089c8f0de1f69dc900be46e095ca20eed8", size = 50222, upload-time = "2025-07-14T23:57:21.42Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/03/a8ab0e8ea74be6058cb48bb1d85485b5c65d6ea183e3ee1aa8ca1ac73b3e/langgraph_sdk-0.2.0-py3-none-any.whl", hash = "sha256:150722264f225c4d47bbe7394676be102fdbf04c4400a0dd1bd41a70c6430cc7", size = 50569, upload-time = "2025-07-22T17:31:04.582Z" },
 ]
 
 [[package]]
 name = "langsmith"
-version = "0.4.6"
+version = "0.4.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx", marker = "python_full_version >= '3.11'" },
@@ -636,9 +636,9 @@ dependencies = [
     { name = "requests-toolbelt", marker = "python_full_version >= '3.11'" },
     { name = "zstandard", marker = "python_full_version >= '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/fc/9e/11536528c6e351820ad3fca0d2807f0e0f0619ff907529c78f68ba648497/langsmith-0.4.6.tar.gz", hash = "sha256:9189dbc9c60f2086ca3a1f0110cfe3aff6b0b7c2e0e3384f9572e70502e7933c", size = 352364, upload-time = "2025-07-15T19:43:18.541Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fb/9f/c6d24c90fded8bb0a5f62f4eb5c84b5f3997c7ef13fd021d7a9ea8b80954/langsmith-0.4.12.tar.gz", hash = "sha256:95cb05772da0325e5e4ed48b5df859ebcac801804e25702fc0543589be7bbfb1", size = 920606, upload-time = "2025-08-06T05:10:39.762Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a7/9b/f2be47db823e89448ea41bfd8fc5ce6a995556bd25be4c23e5b3bb5b6c9b/langsmith-0.4.6-py3-none-any.whl", hash = "sha256:900e83fe59ee672bcf2f75c8bb47cd012bf8154d92a99c0355fc38b6485cbd3e", size = 367901, upload-time = "2025-07-15T19:43:16.508Z" },
+    { url = "https://files.pythonhosted.org/packages/15/5c/429409109c95c511b04981c35a235eac810e12fc0e79e53d5126d64348d4/langsmith-0.4.12-py3-none-any.whl", hash = "sha256:adbd9bc9062ecda93117f124bc7ce4f09bf72b116c3297aef47cbbb7df1f0582", size = 372305, upload-time = "2025-08-06T05:10:37.29Z" },
 ]
 
 [[package]]
@@ -686,7 +686,7 @@ wheels = [
 
 [[package]]
 name = "mypy"
-version = "1.17.0"
+version = "1.17.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "mypy-extensions" },
@@ -694,39 +694,45 @@ dependencies = [
     { name = "tomli", marker = "python_full_version < '3.11'" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/1e/e3/034322d5a779685218ed69286c32faa505247f1f096251ef66c8fd203b08/mypy-1.17.0.tar.gz", hash = "sha256:e5d7ccc08ba089c06e2f5629c660388ef1fee708444f1dee0b9203fa031dee03", size = 3352114, upload-time = "2025-07-14T20:34:30.181Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/8e/22/ea637422dedf0bf36f3ef238eab4e455e2a0dcc3082b5cc067615347ab8e/mypy-1.17.1.tar.gz", hash = "sha256:25e01ec741ab5bb3eec8ba9cdb0f769230368a22c959c4937360efb89b7e9f01", size = 3352570, upload-time = "2025-07-31T07:54:19.204Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6a/31/e762baa3b73905c856d45ab77b4af850e8159dffffd86a52879539a08c6b/mypy-1.17.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f8e08de6138043108b3b18f09d3f817a4783912e48828ab397ecf183135d84d6", size = 10998313, upload-time = "2025-07-14T20:33:24.519Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/c1/25b2f0d46fb7e0b5e2bee61ec3a47fe13eff9e3c2f2234f144858bbe6485/mypy-1.17.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ce4a17920ec144647d448fc43725b5873548b1aae6c603225626747ededf582d", size = 10128922, upload-time = "2025-07-14T20:34:06.414Z" },
-    { url = "https://files.pythonhosted.org/packages/02/78/6d646603a57aa8a2886df1b8881fe777ea60f28098790c1089230cd9c61d/mypy-1.17.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6ff25d151cc057fdddb1cb1881ef36e9c41fa2a5e78d8dd71bee6e4dcd2bc05b", size = 11913524, upload-time = "2025-07-14T20:33:19.109Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/19/dae6c55e87ee426fb76980f7e78484450cad1c01c55a1dc4e91c930bea01/mypy-1.17.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93468cf29aa9a132bceb103bd8475f78cacde2b1b9a94fd978d50d4bdf616c9a", size = 12650527, upload-time = "2025-07-14T20:32:44.095Z" },
-    { url = "https://files.pythonhosted.org/packages/86/e1/f916845a235235a6c1e4d4d065a3930113767001d491b8b2e1b61ca56647/mypy-1.17.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:98189382b310f16343151f65dd7e6867386d3e35f7878c45cfa11383d175d91f", size = 12897284, upload-time = "2025-07-14T20:33:38.168Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/dc/414760708a4ea1b096bd214d26a24e30ac5e917ef293bc33cdb6fe22d2da/mypy-1.17.0-cp310-cp310-win_amd64.whl", hash = "sha256:c004135a300ab06a045c1c0d8e3f10215e71d7b4f5bb9a42ab80236364429937", size = 9506493, upload-time = "2025-07-14T20:34:01.093Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/24/82efb502b0b0f661c49aa21cfe3e1999ddf64bf5500fc03b5a1536a39d39/mypy-1.17.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9d4fe5c72fd262d9c2c91c1117d16aac555e05f5beb2bae6a755274c6eec42be", size = 10914150, upload-time = "2025-07-14T20:31:51.985Z" },
-    { url = "https://files.pythonhosted.org/packages/03/96/8ef9a6ff8cedadff4400e2254689ca1dc4b420b92c55255b44573de10c54/mypy-1.17.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d96b196e5c16f41b4f7736840e8455958e832871990c7ba26bf58175e357ed61", size = 10039845, upload-time = "2025-07-14T20:32:30.527Z" },
-    { url = "https://files.pythonhosted.org/packages/df/32/7ce359a56be779d38021d07941cfbb099b41411d72d827230a36203dbb81/mypy-1.17.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:73a0ff2dd10337ceb521c080d4147755ee302dcde6e1a913babd59473904615f", size = 11837246, upload-time = "2025-07-14T20:32:01.28Z" },
-    { url = "https://files.pythonhosted.org/packages/82/16/b775047054de4d8dbd668df9137707e54b07fe18c7923839cd1e524bf756/mypy-1.17.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:24cfcc1179c4447854e9e406d3af0f77736d631ec87d31c6281ecd5025df625d", size = 12571106, upload-time = "2025-07-14T20:34:26.942Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/cf/fa33eaf29a606102c8d9ffa45a386a04c2203d9ad18bf4eef3e20c43ebc8/mypy-1.17.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3c56f180ff6430e6373db7a1d569317675b0a451caf5fef6ce4ab365f5f2f6c3", size = 12759960, upload-time = "2025-07-14T20:33:42.882Z" },
-    { url = "https://files.pythonhosted.org/packages/94/75/3f5a29209f27e739ca57e6350bc6b783a38c7621bdf9cac3ab8a08665801/mypy-1.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:eafaf8b9252734400f9b77df98b4eee3d2eecab16104680d51341c75702cad70", size = 9503888, upload-time = "2025-07-14T20:32:34.392Z" },
-    { url = "https://files.pythonhosted.org/packages/12/e9/e6824ed620bbf51d3bf4d6cbbe4953e83eaf31a448d1b3cfb3620ccb641c/mypy-1.17.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f986f1cab8dbec39ba6e0eaa42d4d3ac6686516a5d3dccd64be095db05ebc6bb", size = 11086395, upload-time = "2025-07-14T20:34:11.452Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/51/a4afd1ae279707953be175d303f04a5a7bd7e28dc62463ad29c1c857927e/mypy-1.17.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:51e455a54d199dd6e931cd7ea987d061c2afbaf0960f7f66deef47c90d1b304d", size = 10120052, upload-time = "2025-07-14T20:33:09.897Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/71/19adfeac926ba8205f1d1466d0d360d07b46486bf64360c54cb5a2bd86a8/mypy-1.17.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3204d773bab5ff4ebbd1f8efa11b498027cd57017c003ae970f310e5b96be8d8", size = 11861806, upload-time = "2025-07-14T20:32:16.028Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/64/d6120eca3835baf7179e6797a0b61d6c47e0bc2324b1f6819d8428d5b9ba/mypy-1.17.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1051df7ec0886fa246a530ae917c473491e9a0ba6938cfd0ec2abc1076495c3e", size = 12744371, upload-time = "2025-07-14T20:33:33.503Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/dc/56f53b5255a166f5bd0f137eed960e5065f2744509dfe69474ff0ba772a5/mypy-1.17.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f773c6d14dcc108a5b141b4456b0871df638eb411a89cd1c0c001fc4a9d08fc8", size = 12914558, upload-time = "2025-07-14T20:33:56.961Z" },
-    { url = "https://files.pythonhosted.org/packages/69/ac/070bad311171badc9add2910e7f89271695a25c136de24bbafc7eded56d5/mypy-1.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:1619a485fd0e9c959b943c7b519ed26b712de3002d7de43154a489a2d0fd817d", size = 9585447, upload-time = "2025-07-14T20:32:20.594Z" },
-    { url = "https://files.pythonhosted.org/packages/be/7b/5f8ab461369b9e62157072156935cec9d272196556bdc7c2ff5f4c7c0f9b/mypy-1.17.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2c41aa59211e49d717d92b3bb1238c06d387c9325d3122085113c79118bebb06", size = 11070019, upload-time = "2025-07-14T20:32:07.99Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/f8/c49c9e5a2ac0badcc54beb24e774d2499748302c9568f7f09e8730e953fa/mypy-1.17.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0e69db1fb65b3114f98c753e3930a00514f5b68794ba80590eb02090d54a5d4a", size = 10114457, upload-time = "2025-07-14T20:33:47.285Z" },
-    { url = "https://files.pythonhosted.org/packages/89/0c/fb3f9c939ad9beed3e328008b3fb90b20fda2cddc0f7e4c20dbefefc3b33/mypy-1.17.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:03ba330b76710f83d6ac500053f7727270b6b8553b0423348ffb3af6f2f7b889", size = 11857838, upload-time = "2025-07-14T20:33:14.462Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/66/85607ab5137d65e4f54d9797b77d5a038ef34f714929cf8ad30b03f628df/mypy-1.17.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:037bc0f0b124ce46bfde955c647f3e395c6174476a968c0f22c95a8d2f589bba", size = 12731358, upload-time = "2025-07-14T20:32:25.579Z" },
-    { url = "https://files.pythonhosted.org/packages/73/d0/341dbbfb35ce53d01f8f2969facbb66486cee9804048bf6c01b048127501/mypy-1.17.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c38876106cb6132259683632b287238858bd58de267d80defb6f418e9ee50658", size = 12917480, upload-time = "2025-07-14T20:34:21.868Z" },
-    { url = "https://files.pythonhosted.org/packages/64/63/70c8b7dbfc520089ac48d01367a97e8acd734f65bd07813081f508a8c94c/mypy-1.17.0-cp313-cp313-win_amd64.whl", hash = "sha256:d30ba01c0f151998f367506fab31c2ac4527e6a7b2690107c7a7f9e3cb419a9c", size = 9589666, upload-time = "2025-07-14T20:34:16.841Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/a0/6263dd11941231f688f0a8f2faf90ceac1dc243d148d314a089d2fe25108/mypy-1.17.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:63e751f1b5ab51d6f3d219fe3a2fe4523eaa387d854ad06906c63883fde5b1ab", size = 10988185, upload-time = "2025-07-14T20:33:04.797Z" },
-    { url = "https://files.pythonhosted.org/packages/02/13/b8f16d6b0dc80277129559c8e7dbc9011241a0da8f60d031edb0e6e9ac8f/mypy-1.17.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f7fb09d05e0f1c329a36dcd30e27564a3555717cde87301fae4fb542402ddfad", size = 10120169, upload-time = "2025-07-14T20:32:38.84Z" },
-    { url = "https://files.pythonhosted.org/packages/14/ef/978ba79df0d65af680e20d43121363cf643eb79b04bf3880d01fc8afeb6f/mypy-1.17.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b72c34ce05ac3a1361ae2ebb50757fb6e3624032d91488d93544e9f82db0ed6c", size = 11918121, upload-time = "2025-07-14T20:33:52.328Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/10/55ef70b104151a0d8280474f05268ff0a2a79be8d788d5e647257d121309/mypy-1.17.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:434ad499ad8dde8b2f6391ddfa982f41cb07ccda8e3c67781b1bfd4e5f9450a8", size = 12648821, upload-time = "2025-07-14T20:32:59.631Z" },
-    { url = "https://files.pythonhosted.org/packages/26/8c/7781fcd2e1eef48fbedd3a422c21fe300a8e03ed5be2eb4bd10246a77f4e/mypy-1.17.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:f105f61a5eff52e137fd73bee32958b2add9d9f0a856f17314018646af838e97", size = 12896955, upload-time = "2025-07-14T20:32:49.543Z" },
-    { url = "https://files.pythonhosted.org/packages/78/13/03ac759dabe86e98ca7b6681f114f90ee03f3ff8365a57049d311bd4a4e3/mypy-1.17.0-cp39-cp39-win_amd64.whl", hash = "sha256:ba06254a5a22729853209550d80f94e28690d5530c661f9416a68ac097b13fc4", size = 9512957, upload-time = "2025-07-14T20:33:28.619Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/fc/ee058cc4316f219078464555873e99d170bde1d9569abd833300dbeb484a/mypy-1.17.0-py3-none-any.whl", hash = "sha256:15d9d0018237ab058e5de3d8fce61b6fa72cc59cc78fd91f1b474bce12abf496", size = 2283195, upload-time = "2025-07-14T20:31:54.753Z" },
+    { url = "https://files.pythonhosted.org/packages/77/a9/3d7aa83955617cdf02f94e50aab5c830d205cfa4320cf124ff64acce3a8e/mypy-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3fbe6d5555bf608c47203baa3e72dbc6ec9965b3d7c318aa9a4ca76f465bd972", size = 11003299, upload-time = "2025-07-31T07:54:06.425Z" },
+    { url = "https://files.pythonhosted.org/packages/83/e8/72e62ff837dd5caaac2b4a5c07ce769c8e808a00a65e5d8f94ea9c6f20ab/mypy-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:80ef5c058b7bce08c83cac668158cb7edea692e458d21098c7d3bce35a5d43e7", size = 10125451, upload-time = "2025-07-31T07:53:52.974Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/10/f3f3543f6448db11881776f26a0ed079865926b0c841818ee22de2c6bbab/mypy-1.17.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a580f8a70c69e4a75587bd925d298434057fe2a428faaf927ffe6e4b9a98df", size = 11916211, upload-time = "2025-07-31T07:53:18.879Z" },
+    { url = "https://files.pythonhosted.org/packages/06/bf/63e83ed551282d67bb3f7fea2cd5561b08d2bb6eb287c096539feb5ddbc5/mypy-1.17.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd86bb649299f09d987a2eebb4d52d10603224500792e1bee18303bbcc1ce390", size = 12652687, upload-time = "2025-07-31T07:53:30.544Z" },
+    { url = "https://files.pythonhosted.org/packages/69/66/68f2eeef11facf597143e85b694a161868b3b006a5fbad50e09ea117ef24/mypy-1.17.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:a76906f26bd8d51ea9504966a9c25419f2e668f012e0bdf3da4ea1526c534d94", size = 12896322, upload-time = "2025-07-31T07:53:50.74Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/87/8e3e9c2c8bd0d7e071a89c71be28ad088aaecbadf0454f46a540bda7bca6/mypy-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:e79311f2d904ccb59787477b7bd5d26f3347789c06fcd7656fa500875290264b", size = 9507962, upload-time = "2025-07-31T07:53:08.431Z" },
+    { url = "https://files.pythonhosted.org/packages/46/cf/eadc80c4e0a70db1c08921dcc220357ba8ab2faecb4392e3cebeb10edbfa/mypy-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ad37544be07c5d7fba814eb370e006df58fed8ad1ef33ed1649cb1889ba6ff58", size = 10921009, upload-time = "2025-07-31T07:53:23.037Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/c1/c869d8c067829ad30d9bdae051046561552516cfb3a14f7f0347b7d973ee/mypy-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:064e2ff508e5464b4bd807a7c1625bc5047c5022b85c70f030680e18f37273a5", size = 10047482, upload-time = "2025-07-31T07:53:26.151Z" },
+    { url = "https://files.pythonhosted.org/packages/98/b9/803672bab3fe03cee2e14786ca056efda4bb511ea02dadcedde6176d06d0/mypy-1.17.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70401bbabd2fa1aa7c43bb358f54037baf0586f41e83b0ae67dd0534fc64edfd", size = 11832883, upload-time = "2025-07-31T07:53:47.948Z" },
+    { url = "https://files.pythonhosted.org/packages/88/fb/fcdac695beca66800918c18697b48833a9a6701de288452b6715a98cfee1/mypy-1.17.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e92bdc656b7757c438660f775f872a669b8ff374edc4d18277d86b63edba6b8b", size = 12566215, upload-time = "2025-07-31T07:54:04.031Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/37/a932da3d3dace99ee8eb2043b6ab03b6768c36eb29a02f98f46c18c0da0e/mypy-1.17.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c1fdf4abb29ed1cb091cf432979e162c208a5ac676ce35010373ff29247bcad5", size = 12751956, upload-time = "2025-07-31T07:53:36.263Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/cf/6438a429e0f2f5cab8bc83e53dbebfa666476f40ee322e13cac5e64b79e7/mypy-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:ff2933428516ab63f961644bc49bc4cbe42bbffb2cd3b71cc7277c07d16b1a8b", size = 9507307, upload-time = "2025-07-31T07:53:59.734Z" },
+    { url = "https://files.pythonhosted.org/packages/17/a2/7034d0d61af8098ec47902108553122baa0f438df8a713be860f7407c9e6/mypy-1.17.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:69e83ea6553a3ba79c08c6e15dbd9bfa912ec1e493bf75489ef93beb65209aeb", size = 11086295, upload-time = "2025-07-31T07:53:28.124Z" },
+    { url = "https://files.pythonhosted.org/packages/14/1f/19e7e44b594d4b12f6ba8064dbe136505cec813549ca3e5191e40b1d3cc2/mypy-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1b16708a66d38abb1e6b5702f5c2c87e133289da36f6a1d15f6a5221085c6403", size = 10112355, upload-time = "2025-07-31T07:53:21.121Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/69/baa33927e29e6b4c55d798a9d44db5d394072eef2bdc18c3e2048c9ed1e9/mypy-1.17.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:89e972c0035e9e05823907ad5398c5a73b9f47a002b22359b177d40bdaee7056", size = 11875285, upload-time = "2025-07-31T07:53:55.293Z" },
+    { url = "https://files.pythonhosted.org/packages/90/13/f3a89c76b0a41e19490b01e7069713a30949d9a6c147289ee1521bcea245/mypy-1.17.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03b6d0ed2b188e35ee6d5c36b5580cffd6da23319991c49ab5556c023ccf1341", size = 12737895, upload-time = "2025-07-31T07:53:43.623Z" },
+    { url = "https://files.pythonhosted.org/packages/23/a1/c4ee79ac484241301564072e6476c5a5be2590bc2e7bfd28220033d2ef8f/mypy-1.17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c837b896b37cd103570d776bda106eabb8737aa6dd4f248451aecf53030cdbeb", size = 12931025, upload-time = "2025-07-31T07:54:17.125Z" },
+    { url = "https://files.pythonhosted.org/packages/89/b8/7409477be7919a0608900e6320b155c72caab4fef46427c5cc75f85edadd/mypy-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:665afab0963a4b39dff7c1fa563cc8b11ecff7910206db4b2e64dd1ba25aed19", size = 9584664, upload-time = "2025-07-31T07:54:12.842Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/82/aec2fc9b9b149f372850291827537a508d6c4d3664b1750a324b91f71355/mypy-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93378d3203a5c0800c6b6d850ad2f19f7a3cdf1a3701d3416dbf128805c6a6a7", size = 11075338, upload-time = "2025-07-31T07:53:38.873Z" },
+    { url = "https://files.pythonhosted.org/packages/07/ac/ee93fbde9d2242657128af8c86f5d917cd2887584cf948a8e3663d0cd737/mypy-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:15d54056f7fe7a826d897789f53dd6377ec2ea8ba6f776dc83c2902b899fee81", size = 10113066, upload-time = "2025-07-31T07:54:14.707Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/68/946a1e0be93f17f7caa56c45844ec691ca153ee8b62f21eddda336a2d203/mypy-1.17.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:209a58fed9987eccc20f2ca94afe7257a8f46eb5df1fb69958650973230f91e6", size = 11875473, upload-time = "2025-07-31T07:53:14.504Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/0f/478b4dce1cb4f43cf0f0d00fba3030b21ca04a01b74d1cd272a528cf446f/mypy-1.17.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:099b9a5da47de9e2cb5165e581f158e854d9e19d2e96b6698c0d64de911dd849", size = 12744296, upload-time = "2025-07-31T07:53:03.896Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/70/afa5850176379d1b303f992a828de95fc14487429a7139a4e0bdd17a8279/mypy-1.17.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa6ffadfbe6994d724c5a1bb6123a7d27dd68fc9c059561cd33b664a79578e14", size = 12914657, upload-time = "2025-07-31T07:54:08.576Z" },
+    { url = "https://files.pythonhosted.org/packages/53/f9/4a83e1c856a3d9c8f6edaa4749a4864ee98486e9b9dbfbc93842891029c2/mypy-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:9a2b7d9180aed171f033c9f2fc6c204c1245cf60b0cb61cf2e7acc24eea78e0a", size = 9593320, upload-time = "2025-07-31T07:53:01.341Z" },
+    { url = "https://files.pythonhosted.org/packages/38/56/79c2fac86da57c7d8c48622a05873eaab40b905096c33597462713f5af90/mypy-1.17.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:15a83369400454c41ed3a118e0cc58bd8123921a602f385cb6d6ea5df050c733", size = 11040037, upload-time = "2025-07-31T07:54:10.942Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/c3/adabe6ff53638e3cad19e3547268482408323b1e68bf082c9119000cd049/mypy-1.17.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:55b918670f692fc9fba55c3298d8a3beae295c5cded0a55dccdc5bbead814acd", size = 10131550, upload-time = "2025-07-31T07:53:41.307Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/c5/2e234c22c3bdeb23a7817af57a58865a39753bde52c74e2c661ee0cfc640/mypy-1.17.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:62761474061feef6f720149d7ba876122007ddc64adff5ba6f374fda35a018a0", size = 11872963, upload-time = "2025-07-31T07:53:16.878Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/26/c13c130f35ca8caa5f2ceab68a247775648fdcd6c9a18f158825f2bc2410/mypy-1.17.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c49562d3d908fd49ed0938e5423daed8d407774a479b595b143a3d7f87cdae6a", size = 12710189, upload-time = "2025-07-31T07:54:01.962Z" },
+    { url = "https://files.pythonhosted.org/packages/82/df/c7d79d09f6de8383fe800521d066d877e54d30b4fb94281c262be2df84ef/mypy-1.17.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:397fba5d7616a5bc60b45c7ed204717eaddc38f826e3645402c426057ead9a91", size = 12900322, upload-time = "2025-07-31T07:53:10.551Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/98/3d5a48978b4f708c55ae832619addc66d677f6dc59f3ebad71bae8285ca6/mypy-1.17.1-cp314-cp314-win_amd64.whl", hash = "sha256:9d6b20b97d373f41617bd0708fd46aa656059af57f2ef72aa8c7d6a2b73b74ed", size = 9751879, upload-time = "2025-07-31T07:52:56.683Z" },
+    { url = "https://files.pythonhosted.org/packages/29/cb/673e3d34e5d8de60b3a61f44f80150a738bff568cd6b7efb55742a605e98/mypy-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5d1092694f166a7e56c805caaf794e0585cabdbf1df36911c414e4e9abb62ae9", size = 10992466, upload-time = "2025-07-31T07:53:57.574Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/d0/fe1895836eea3a33ab801561987a10569df92f2d3d4715abf2cfeaa29cb2/mypy-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:79d44f9bfb004941ebb0abe8eff6504223a9c1ac51ef967d1263c6572bbebc99", size = 10117638, upload-time = "2025-07-31T07:53:34.256Z" },
+    { url = "https://files.pythonhosted.org/packages/97/f3/514aa5532303aafb95b9ca400a31054a2bd9489de166558c2baaeea9c522/mypy-1.17.1-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b01586eed696ec905e61bd2568f48740f7ac4a45b3a468e6423a03d3788a51a8", size = 11915673, upload-time = "2025-07-31T07:52:59.361Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/c3/c0805f0edec96fe8e2c048b03769a6291523d509be8ee7f56ae922fa3882/mypy-1.17.1-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43808d9476c36b927fbcd0b0255ce75efe1b68a080154a38ae68a7e62de8f0f8", size = 12649022, upload-time = "2025-07-31T07:53:45.92Z" },
+    { url = "https://files.pythonhosted.org/packages/45/3e/d646b5a298ada21a8512fa7e5531f664535a495efa672601702398cea2b4/mypy-1.17.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:feb8cc32d319edd5859da2cc084493b3e2ce5e49a946377663cc90f6c15fb259", size = 12895536, upload-time = "2025-07-31T07:53:06.17Z" },
+    { url = "https://files.pythonhosted.org/packages/14/55/e13d0dcd276975927d1f4e9e2ec4fd409e199f01bdc671717e673cc63a22/mypy-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d7598cf74c3e16539d4e2f0b8d8c318e00041553d83d4861f87c7a72e95ac24d", size = 9512564, upload-time = "2025-07-31T07:53:12.346Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/f3/8fcd2af0f5b806f6cf463efaffd3c9548a28f84220493ecd38d127b6b66d/mypy-1.17.1-py3-none-any.whl", hash = "sha256:a9f52c0351c21fe24c21d8c0eb1f62967b262d6729393397b6f443c3b773c3b9", size = 2283411, upload-time = "2025-07-31T07:53:24.664Z" },
 ]
 
 [[package]]
@@ -740,81 +746,92 @@ wheels = [
 
 [[package]]
 name = "orjson"
-version = "3.11.0"
+version = "3.11.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/29/87/03ababa86d984952304ac8ce9fbd3a317afb4a225b9a81f9b606ac60c873/orjson-3.11.0.tar.gz", hash = "sha256:2e4c129da624f291bcc607016a99e7f04a353f6874f3bd8d9b47b88597d5f700", size = 5318246, upload-time = "2025-07-15T16:08:29.194Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/19/3b/fd9ff8ff64ae3900f11554d5cfc835fb73e501e043c420ad32ec574fe27f/orjson-3.11.1.tar.gz", hash = "sha256:48d82770a5fd88778063604c566f9c7c71820270c9cc9338d25147cbf34afd96", size = 5393373, upload-time = "2025-07-25T14:33:52.898Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/07/aa/50818f480f0edcb33290c8f35eef6dd3a31e2ff7e1195f8b236ac7419811/orjson-3.11.0-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:b8913baba9751f7400f8fa4ec18a8b618ff01177490842e39e47b66c1b04bc79", size = 240422, upload-time = "2025-07-15T16:06:23.029Z" },
-    { url = "https://files.pythonhosted.org/packages/16/50/5235aff455fa76337493d21e68618e7cf53aa9db011aaeb06cf378f1344c/orjson-3.11.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d4d86910554de5c9c87bc560b3bdd315cc3988adbdc2acf5dda3797079407ed", size = 132473, upload-time = "2025-07-15T16:06:25.598Z" },
-    { url = "https://files.pythonhosted.org/packages/23/93/bf1c4e77e7affc46cca13fb852842a86dca2dabbee1d91515ed17b1c21c4/orjson-3.11.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:84ae3d329360cf18fb61b67c505c00dedb61b0ee23abfd50f377a58e7d7bed06", size = 127195, upload-time = "2025-07-15T16:06:27.001Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/2d/64b52c6827e43aa3d98def19e188e091a6c574ca13d9ecef5f3f3284fac6/orjson-3.11.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:47a54e660414baacd71ebf41a69bb17ea25abb3c5b69ce9e13e43be7ac20e342", size = 128895, upload-time = "2025-07-15T16:06:28.641Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/5f/9d290bc7a88392f9f7dc2e92ceb2e3efbbebaaf56bbba655b5fe2e3d2ca3/orjson-3.11.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2560b740604751854be146169c1de7e7ee1e6120b00c1788ec3f3a012c6a243f", size = 132016, upload-time = "2025-07-15T16:06:32.576Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/8c/b2bdc34649bbb7b44827d487aef7ad4d6a96c53ebc490ddcc191d47bc3b9/orjson-3.11.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dd7f9cd995da9e46fbac0a371f0ff6e89a21d8ecb7a8a113c0acb147b0a32f73", size = 134251, upload-time = "2025-07-15T16:06:34.075Z" },
-    { url = "https://files.pythonhosted.org/packages/33/be/b763b602976aa27407e6f75331ac581258c719f8abb70f66f2de962f649f/orjson-3.11.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7cf728cb3a013bdf9f4132575404bf885aa773d8bb4205656575e1890fc91990", size = 128078, upload-time = "2025-07-15T16:06:35.408Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/24/1b0fed70392bf179ac8b5abe800f1102ed94f89ac4f889d83916947a2b4e/orjson-3.11.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:c27de273320294121200440cd5002b6aeb922d3cb9dab3357087c69f04ca6934", size = 130734, upload-time = "2025-07-15T16:06:36.832Z" },
-    { url = "https://files.pythonhosted.org/packages/05/d2/2d042bb4fe1da067692cb70d8c01a5ce2737e2f56444e6b2d716853ce8c3/orjson-3.11.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:4430ec6ff1a1f4595dd7e0fad991bdb2fed65401ed294984c490ffa025926325", size = 404040, upload-time = "2025-07-15T16:06:38.259Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/c5/54938ab416c0d19c93f0d6977a47bb2b3d121e150305380b783f7d6da185/orjson-3.11.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:325be41a8d7c227d460a9795a181511ba0e731cf3fee088c63eb47e706ea7559", size = 144808, upload-time = "2025-07-15T16:06:39.796Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/be/5ead422f396ee7c8941659ceee3da001e26998971f7d5fe0a38519c48aa5/orjson-3.11.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d9760217b84d1aee393b4436fbe9c639e963ec7bc0f2c074581ce5fb3777e466", size = 132570, upload-time = "2025-07-15T16:06:41.209Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/01/db8352f7d0374d7eec25144e294991800aa85738b2dc7f19cc152ba1b254/orjson-3.11.0-cp310-cp310-win32.whl", hash = "sha256:fe36e5012f886ff91c68b87a499c227fa220e9668cea96335219874c8be5fab5", size = 134763, upload-time = "2025-07-15T16:06:42.524Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/f5/1322b64d5836d92f0b0c119d959853b3c968b8aae23dd1e3c1bfa566823b/orjson-3.11.0-cp310-cp310-win_amd64.whl", hash = "sha256:ebeecd5d5511b3ca9dc4e7db0ab95266afd41baf424cc2fad8c2d3a3cdae650a", size = 129506, upload-time = "2025-07-15T16:06:43.929Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/2c/0b71a763f0f5130aa2631ef79e2cd84d361294665acccbb12b7a9813194e/orjson-3.11.0-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:1785df7ada75c18411ff7e20ac822af904a40161ea9dfe8c55b3f6b66939add6", size = 240007, upload-time = "2025-07-15T16:06:45.411Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/5a/f79ccd63d378b9c7c771d7a54c203d261b4c618fe3034ae95cd30f934f34/orjson-3.11.0-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:a57899bebbcea146616a2426d20b51b3562b4bc9f8039a3bd14fae361c23053d", size = 129320, upload-time = "2025-07-15T16:06:47.249Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/8a/63dafc147fa5ba945ad809c374b8f4ee692bb6b18aa6e161c3e6b69b594e/orjson-3.11.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b6fbc2fc825aff1456dd358c11a0ad7912a4cb4537d3db92e5334af7463a967", size = 132254, upload-time = "2025-07-15T16:06:48.597Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/11/4d1eb230483cc689a2f039c531bb2c980029c40ca5a9b5f64dce9786e955/orjson-3.11.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4305a638f4cf9bed3746ca3b7c242f14e05177d5baec2527026e0f9ee6c24fb7", size = 127003, upload-time = "2025-07-15T16:06:50.34Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/39/b6e96072946d908684e0f4b3de1639062fd5b32016b2929c035bd8e5c847/orjson-3.11.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1235fe7bbc37164f69302199d46f29cfb874018738714dccc5a5a44042c79c77", size = 128674, upload-time = "2025-07-15T16:06:51.659Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/dd/c77e3013f35b202ec2cc1f78a95fadf86b8c5a320d56eb1a0bbb965a87bb/orjson-3.11.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a640e3954e7b4fcb160097551e54cafbde9966be3991932155b71071077881aa", size = 131846, upload-time = "2025-07-15T16:06:53.359Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/7d/d83f0f96c2b142f9cdcf12df19052ea3767970989dc757598dc108db208f/orjson-3.11.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6d750b97d22d5566955e50b02c622f3a1d32744d7a578c878b29a873190ccb7a", size = 134016, upload-time = "2025-07-15T16:06:54.691Z" },
-    { url = "https://files.pythonhosted.org/packages/67/4f/d22f79a3c56dde563c4fbc12eebf9224a1b87af5e4ec61beb11f9b3eb499/orjson-3.11.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4bfcfe498484161e011f8190a400591c52b026de96b3b3cbd3f21e8999b9dc0e", size = 127930, upload-time = "2025-07-15T16:06:56.001Z" },
-    { url = "https://files.pythonhosted.org/packages/07/1e/26aede257db2163d974139fd4571f1e80f565216ccbd2c44ee1d43a63dcc/orjson-3.11.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:feaed3ed43a1d2df75c039798eb5ec92c350c7d86be53369bafc4f3700ce7df2", size = 130569, upload-time = "2025-07-15T16:06:57.275Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/bf/2cb57eac8d6054b555cba27203490489a7d3f5dca8c34382f22f2f0f17ba/orjson-3.11.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:aa1120607ec8fc98acf8c54aac6fb0b7b003ba883401fa2d261833111e2fa071", size = 403844, upload-time = "2025-07-15T16:06:59.107Z" },
-    { url = "https://files.pythonhosted.org/packages/76/34/36e859ccfc45464df7b35c438c0ecc7751c930b3ebbefb50db7e3a641eb7/orjson-3.11.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c4b48d9775b0cf1f0aca734f4c6b272cbfacfac38e6a455e6520662f9434afb7", size = 144613, upload-time = "2025-07-15T16:07:00.48Z" },
-    { url = "https://files.pythonhosted.org/packages/31/c5/5aeb84cdd0b44dc3972668944a1312f7983c2a45fb6b0e5e32b2f9408540/orjson-3.11.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f018ed1986d79434ac712ff19f951cd00b4dfcb767444410fbb834ebec160abf", size = 132419, upload-time = "2025-07-15T16:07:01.927Z" },
-    { url = "https://files.pythonhosted.org/packages/59/0c/95ee1e61a067ad24c4921609156b3beeca8b102f6f36dca62b08e1a7c7a8/orjson-3.11.0-cp311-cp311-win32.whl", hash = "sha256:08e191f8a55ac2c00be48e98a5d10dca004cbe8abe73392c55951bfda60fc123", size = 134620, upload-time = "2025-07-15T16:07:03.304Z" },
-    { url = "https://files.pythonhosted.org/packages/94/3e/afd5e284db9387023803553061ea05c785c36fe7845e4fe25912424b343f/orjson-3.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:b5a4214ea59c8a3b56f8d484b28114af74e9fba0956f9be5c3ce388ae143bf1f", size = 129333, upload-time = "2025-07-15T16:07:04.973Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/a4/d29e9995d73f23f2444b4db299a99477a4f7e6f5bf8923b775ef43a4e660/orjson-3.11.0-cp311-cp311-win_arm64.whl", hash = "sha256:57e8e7198a679ab21241ab3f355a7990c7447559e35940595e628c107ef23736", size = 126656, upload-time = "2025-07-15T16:07:06.288Z" },
-    { url = "https://files.pythonhosted.org/packages/92/c9/241e304fb1e58ea70b720f1a9e5349c6bb7735ffac401ef1b94f422edd6d/orjson-3.11.0-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:b4089f940c638bb1947d54e46c1cd58f4259072fcc97bc833ea9c78903150ac9", size = 240269, upload-time = "2025-07-15T16:07:08.173Z" },
-    { url = "https://files.pythonhosted.org/packages/26/7c/289457cdf40be992b43f1d90ae213ebc03a31a8e2850271ecd79e79a3135/orjson-3.11.0-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:8335a0ba1c26359fb5c82d643b4c1abbee2bc62875e0f2b5bde6c8e9e25eb68c", size = 129276, upload-time = "2025-07-15T16:07:10.128Z" },
-    { url = "https://files.pythonhosted.org/packages/66/de/5c0528d46ded965939b6b7f75b1fe93af42b9906b0039096fc92c9001c12/orjson-3.11.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:63c1c9772dafc811d16d6a7efa3369a739da15d1720d6e58ebe7562f54d6f4a2", size = 131966, upload-time = "2025-07-15T16:07:11.509Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/74/39822f267b5935fb6fc961ccc443f4968a74d34fc9270b83caa44e37d907/orjson-3.11.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9457ccbd8b241fb4ba516417a4c5b95ba0059df4ac801309bcb4ec3870f45ad9", size = 127028, upload-time = "2025-07-15T16:07:13.023Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/e3/28f6ed7f03db69bddb3ef48621b2b05b394125188f5909ee0a43fcf4820e/orjson-3.11.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0846e13abe79daece94a00b92574f294acad1d362be766c04245b9b4dd0e47e1", size = 129105, upload-time = "2025-07-15T16:07:14.367Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/50/8867fd2fc92c0ab1c3e14673ec5d9d0191202e4ab8ba6256d7a1d6943ad3/orjson-3.11.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5587c85ae02f608a3f377b6af9eb04829606f518257cbffa8f5081c1aacf2e2f", size = 131902, upload-time = "2025-07-15T16:07:16.176Z" },
-    { url = "https://files.pythonhosted.org/packages/13/65/c189deea10342afee08006331082ff67d11b98c2394989998b3ea060354a/orjson-3.11.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c7a1964a71c1567b4570c932a0084ac24ad52c8cf6253d1881400936565ed438", size = 134042, upload-time = "2025-07-15T16:07:17.937Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/e4/cf23c3f4231d2a9a043940ab045f799f84a6df1b4fb6c9b4412cdc3ebf8c/orjson-3.11.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b5a8243e73690cc6e9151c9e1dd046a8f21778d775f7d478fa1eb4daa4897c61", size = 128260, upload-time = "2025-07-15T16:07:19.651Z" },
-    { url = "https://files.pythonhosted.org/packages/de/b9/2cb94d3a67edb918d19bad4a831af99cd96c3657a23daa239611bcf335d7/orjson-3.11.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:51646f6d995df37b6e1b628f092f41c0feccf1d47e3452c6e95e2474b547d842", size = 130282, upload-time = "2025-07-15T16:07:21.022Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/96/df963cc973e689d4c56398647917b4ee95f47e5b6d2779338c09c015b23b/orjson-3.11.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:2fb8ca8f0b4e31b8aaec674c7540649b64ef02809410506a44dc68d31bd5647b", size = 403765, upload-time = "2025-07-15T16:07:25.469Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/92/71429ee1badb69f53281602dbb270fa84fc2e51c83193a814d0208bb63b0/orjson-3.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:64a6a3e94a44856c3f6557e6aa56a6686544fed9816ae0afa8df9077f5759791", size = 144779, upload-time = "2025-07-15T16:07:27.339Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/ab/3678b2e5ff0c622a974cb8664ed7cdda5ed26ae2b9d71ba66ec36f32d6cf/orjson-3.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d69f95d484938d8fab5963e09131bcf9fbbb81fa4ec132e316eb2fb9adb8ce78", size = 132797, upload-time = "2025-07-15T16:07:28.717Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/8c/74509f715ff189d2aca90ebb0bd5af6658e0f9aa2512abbe6feca4c78208/orjson-3.11.0-cp312-cp312-win32.whl", hash = "sha256:8514f9f9c667ce7d7ef709ab1a73e7fcab78c297270e90b1963df7126d2b0e23", size = 134695, upload-time = "2025-07-15T16:07:30.034Z" },
-    { url = "https://files.pythonhosted.org/packages/82/ba/ef25e3e223f452a01eac6a5b38d05c152d037508dcbf87ad2858cbb7d82e/orjson-3.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:41b38a894520b8cb5344a35ffafdf6ae8042f56d16771b2c5eb107798cee85ee", size = 129446, upload-time = "2025-07-15T16:07:31.412Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/cd/6f4d93867c5d81bb4ab2d4ac870d3d6e9ba34fa580a03b8d04bf1ce1d8ad/orjson-3.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:5579acd235dd134467340b2f8a670c1c36023b5a69c6a3174c4792af7502bd92", size = 126400, upload-time = "2025-07-15T16:07:34.143Z" },
-    { url = "https://files.pythonhosted.org/packages/31/63/82d9b6b48624009d230bc6038e54778af8f84dfd54402f9504f477c5cfd5/orjson-3.11.0-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:4a8ba9698655e16746fdf5266939427da0f9553305152aeb1a1cc14974a19cfb", size = 240125, upload-time = "2025-07-15T16:07:35.976Z" },
-    { url = "https://files.pythonhosted.org/packages/16/3a/d557ed87c63237d4c97a7bac7ac054c347ab8c4b6da09748d162ca287175/orjson-3.11.0-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:67133847f9a35a5ef5acfa3325d4a2f7fe05c11f1505c4117bb086fc06f2a58f", size = 129189, upload-time = "2025-07-15T16:07:37.486Z" },
-    { url = "https://files.pythonhosted.org/packages/69/5e/b2c9e22e2cd10aa7d76a629cee65d661e06a61fbaf4dc226386f5636dd44/orjson-3.11.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f797d57814975b78f5f5423acb003db6f9be5186b72d48bd97a1000e89d331d", size = 131953, upload-time = "2025-07-15T16:07:39.254Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/60/760fcd9b50eb44d1206f2b30c8d310b79714553b9d94a02f9ea3252ebe63/orjson-3.11.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:28acd19822987c5163b9e03a6e60853a52acfee384af2b394d11cb413b889246", size = 126922, upload-time = "2025-07-15T16:07:41.282Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/7a/8c46daa867ccc92da6de9567608be62052774b924a77c78382e30d50b579/orjson-3.11.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e8d38d9e1e2cf9729658e35956cf01e13e89148beb4cb9e794c9c10c5cb252f8", size = 128787, upload-time = "2025-07-15T16:07:42.681Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/14/a2f1b123d85f11a19e8749f7d3f9ed6c9b331c61f7b47cfd3e9a1fedb9bc/orjson-3.11.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:05f094edd2b782650b0761fd78858d9254de1c1286f5af43145b3d08cdacfd51", size = 131895, upload-time = "2025-07-15T16:07:44.519Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/10/362e8192df7528e8086ea712c5cb01355c8d4e52c59a804417ba01e2eb2d/orjson-3.11.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6d09176a4a9e04a5394a4a0edd758f645d53d903b306d02f2691b97d5c736a9e", size = 133868, upload-time = "2025-07-15T16:07:46.227Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/4e/ef43582ef3e3dfd2a39bc3106fa543364fde1ba58489841120219da6e22f/orjson-3.11.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2a585042104e90a61eda2564d11317b6a304eb4e71cd33e839f5af6be56c34d3", size = 128234, upload-time = "2025-07-15T16:07:48.123Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/fa/02dabb2f1d605bee8c4bb1160cfc7467976b1ed359a62cc92e0681b53c45/orjson-3.11.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d2218629dbfdeeb5c9e0573d59f809d42f9d49ae6464d2f479e667aee14c3ef4", size = 130232, upload-time = "2025-07-15T16:07:50.197Z" },
-    { url = "https://files.pythonhosted.org/packages/16/76/951b5619605c8d2ede80cc989f32a66abc954530d86e84030db2250c63a1/orjson-3.11.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:613e54a2b10b51b656305c11235a9c4a5c5491ef5c283f86483d4e9e123ed5e4", size = 403648, upload-time = "2025-07-15T16:07:52.136Z" },
-    { url = "https://files.pythonhosted.org/packages/96/e2/5fa53bb411455a63b3713db90b588e6ca5ed2db59ad49b3fb8a0e94e0dda/orjson-3.11.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:9dac7fbf3b8b05965986c5cfae051eb9a30fced7f15f1d13a5adc608436eb486", size = 144572, upload-time = "2025-07-15T16:07:54.004Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/d0/7d6f91e1e0f034258c3a3358f20b0c9490070e8a7ab8880085547274c7f9/orjson-3.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93b64b254414e2be55ac5257124b5602c5f0b4d06b80bd27d1165efe8f36e836", size = 132766, upload-time = "2025-07-15T16:07:55.936Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/f8/4d46481f1b3fb40dc826d62179f96c808eb470cdcc74b6593fb114d74af3/orjson-3.11.0-cp313-cp313-win32.whl", hash = "sha256:359cbe11bc940c64cb3848cf22000d2aef36aff7bfd09ca2c0b9cb309c387132", size = 134638, upload-time = "2025-07-15T16:07:57.343Z" },
-    { url = "https://files.pythonhosted.org/packages/85/3f/544938dcfb7337d85ee1e43d7685cf8f3bfd452e0b15a32fe70cb4ca5094/orjson-3.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:0759b36428067dc777b202dd286fbdd33d7f261c6455c4238ea4e8474358b1e6", size = 129411, upload-time = "2025-07-15T16:07:58.852Z" },
-    { url = "https://files.pythonhosted.org/packages/43/0c/f75015669d7817d222df1bb207f402277b77d22c4833950c8c8c7cf2d325/orjson-3.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:51cdca2f36e923126d0734efaf72ddbb5d6da01dbd20eab898bdc50de80d7b5a", size = 126349, upload-time = "2025-07-15T16:08:00.322Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/41/eac31c44ce001b3da8a6b5ebbb8a4fc2c3eaf479e2d068e36b2ea6ab7095/orjson-3.11.0-cp39-cp39-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:d79c180cfb3ae68f13245d0ff551dca03d96258aa560830bf8a223bd68d8272c", size = 241023, upload-time = "2025-07-15T16:08:02.233Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/d6/1edc258f3eff573af7416b2b8536032e6f4ed3759fa5773c5db95a28d2f2/orjson-3.11.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:105bca887532dc71ce4b05a5de95dea447a310409d7a8cf0cb1c4a120469e9ad", size = 132245, upload-time = "2025-07-15T16:08:04.734Z" },
-    { url = "https://files.pythonhosted.org/packages/24/89/49236838cdc8d88b93f1c80f44531103f589307e4e783c855a6a63f28b45/orjson-3.11.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:acf5a63ae9cdb88274126af85913ceae554d8fd71122effa24a53227abbeee16", size = 126981, upload-time = "2025-07-15T16:08:06.114Z" },
-    { url = "https://files.pythonhosted.org/packages/80/78/8744b86efae7693344edcf255addc2a9f9e4f5552ccf71d9581d03c3e1aa/orjson-3.11.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:894635df36c0be32f1c8c8607e853b8865edb58e7618e57892e85d06418723eb", size = 128686, upload-time = "2025-07-15T16:08:07.843Z" },
-    { url = "https://files.pythonhosted.org/packages/91/8c/4c45feee9fa52488e67be2e887eb966337d4ddb6675129471f0dab98587d/orjson-3.11.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:02dd4f0a1a2be943a104ce5f3ec092631ee3e9f0b4bb9eeee3400430bd94ddef", size = 131830, upload-time = "2025-07-15T16:08:14.423Z" },
-    { url = "https://files.pythonhosted.org/packages/47/15/9462308306650de38d042af226e186d2fe28ee8e44c5462e011e767e6e44/orjson-3.11.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:720b4bb5e1b971960a62c2fa254c2d2a14e7eb791e350d05df8583025aa59d15", size = 134004, upload-time = "2025-07-15T16:08:16.024Z" },
-    { url = "https://files.pythonhosted.org/packages/db/1d/bfa55d7681cf704d73e9c6de8138535b2f41e06a49d88bf9bdf27c8d4d7b/orjson-3.11.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8bf058105a8aed144e0d1cfe7ac4174748c3fc7203f225abaeac7f4121abccb0", size = 127893, upload-time = "2025-07-15T16:08:17.558Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/bb/e91aa9e63077d8754d1578787e8917078e5c6743579290bc454bbc609241/orjson-3.11.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:a2788f741e5a0e885e5eaf1d91d0c9106e03cb9575b0c55ba36fd3d48b0b1e9b", size = 130546, upload-time = "2025-07-15T16:08:19.21Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/67/4c53a325ac9abf883e922da214707f63efcb8b4d54529984df0e6aff1d0b/orjson-3.11.0-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:c60c99fe1e15894367b0340b2ff16c7c69f9c3f3a54aa3961a58c102b292ad94", size = 403849, upload-time = "2025-07-15T16:08:21.025Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/64/a779341bd2231e28eb09cf6e6260d9f713a39ae5163b0f1228ab5175bfee/orjson-3.11.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:99d17aab984f4d029b8f3c307e6be3c63d9ee5ef55e30d761caf05e883009949", size = 144600, upload-time = "2025-07-15T16:08:22.701Z" },
-    { url = "https://files.pythonhosted.org/packages/03/c1/fc36a6e3b40df3388ecf57b18a940f6584362652e6ee57464ccc5715b2e3/orjson-3.11.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:e98f02e23611763c9e5dfcb83bd33219231091589f0d1691e721aea9c52bf329", size = 132416, upload-time = "2025-07-15T16:08:24.258Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/29/eb5ed777d7ea5d0fdee5981751e3a4e9de73f47e32bb20f1ea748b04b1d2/orjson-3.11.0-cp39-cp39-win32.whl", hash = "sha256:923301f33ea866b18f8836cf41d9c6d33e3b5cab8577d20fed34ec29f0e13a0d", size = 134617, upload-time = "2025-07-15T16:08:26.052Z" },
-    { url = "https://files.pythonhosted.org/packages/72/40/feba627d9349bb1a91500e0047ae526d83bb1918545ff4dfee3e1bd7195e/orjson-3.11.0-cp39-cp39-win_amd64.whl", hash = "sha256:475491bb78af2a0170f49e90013f1a0f1286527f3617491f8940d7e5da862da7", size = 129320, upload-time = "2025-07-15T16:08:27.484Z" },
+    { url = "https://files.pythonhosted.org/packages/94/8b/7dd88f416e2e5834fd9809d871f471aae7d12dfd83d4786166fa5a926601/orjson-3.11.1-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:92d771c492b64119456afb50f2dff3e03a2db8b5af0eba32c5932d306f970532", size = 241312, upload-time = "2025-07-25T14:31:52.841Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/5d/5bfc371bd010ffbec90e64338aa59abcb13ed94191112199048653ee2f34/orjson-3.11.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0085ef83a4141c2ed23bfec5fecbfdb1e95dd42fc8e8c76057bdeeec1608ea65", size = 132791, upload-time = "2025-07-25T14:31:55.547Z" },
+    { url = "https://files.pythonhosted.org/packages/48/e2/c07854a6bad71e4249345efadb686c0aff250073bdab8ba9be7626af6516/orjson-3.11.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5caf7f13f2e1b4e137060aed892d4541d07dabc3f29e6d891e2383c7ed483440", size = 128690, upload-time = "2025-07-25T14:31:56.708Z" },
+    { url = "https://files.pythonhosted.org/packages/48/e4/2e075348e7772aa1404d51d8df25ff4d6ee3daf682732cb21308e3b59c32/orjson-3.11.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f716bcc166524eddfcf9f13f8209ac19a7f27b05cf591e883419079d98c8c99d", size = 130646, upload-time = "2025-07-25T14:31:58.165Z" },
+    { url = "https://files.pythonhosted.org/packages/97/09/50daacd3ac7ae564186924c8d1121940f2c78c64d6804dbe81dd735ab087/orjson-3.11.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:507d6012fab05465d8bf21f5d7f4635ba4b6d60132874e349beff12fb51af7fe", size = 132620, upload-time = "2025-07-25T14:31:59.226Z" },
+    { url = "https://files.pythonhosted.org/packages/da/21/5f22093fa90e6d6fcf8111942b530a4ad19ee1cc0b06ddad4a63b16ab852/orjson-3.11.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b1545083b0931f754c80fd2422a73d83bea7a6d1b6de104a5f2c8dd3d64c291e", size = 135121, upload-time = "2025-07-25T14:32:00.653Z" },
+    { url = "https://files.pythonhosted.org/packages/48/90/77ad4bfa6bd400a3d241695e3e39975e32fe027aea5cb0b171bd2080c427/orjson-3.11.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e217ce3bad76351e1eb29ebe5ca630326f45cd2141f62620107a229909501a3", size = 131131, upload-time = "2025-07-25T14:32:01.821Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/64/d383675229f7ffd971b6ec6cdd3016b00877bb6b2d5fc1fd099c2ec2ad57/orjson-3.11.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:06ef26e009304bda4df42e4afe518994cde6f89b4b04c0ff24021064f83f4fbb", size = 131025, upload-time = "2025-07-25T14:32:02.879Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/82/e4017d8d98597f6056afaf75021ff390154d1e2722c66ba45a4d50f82606/orjson-3.11.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:ba49683b87bea3ae1489a88e766e767d4f423a669a61270b6d6a7ead1c33bd65", size = 404464, upload-time = "2025-07-25T14:32:04.384Z" },
+    { url = "https://files.pythonhosted.org/packages/77/7e/45c7f813c30d386c0168a32ce703494262458af6b222a3eeac1c0bb88822/orjson-3.11.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:5072488fcc5cbcda2ece966d248e43ea1d222e19dd4c56d3f82747777f24d864", size = 146416, upload-time = "2025-07-25T14:32:05.57Z" },
+    { url = "https://files.pythonhosted.org/packages/41/71/6ccb4d7875ec3349409960769a28349f477856f05de9fd961454c2b99230/orjson-3.11.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f58ae2bcd119226fe4aa934b5880fe57b8e97b69e51d5d91c88a89477a307016", size = 135497, upload-time = "2025-07-25T14:32:06.704Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ce/df8dac7da075962fdbfca55d53e3601aa910c9f23606033bf0f084835720/orjson-3.11.1-cp310-cp310-win32.whl", hash = "sha256:6723be919c07906781b9c63cc52dc7d2fb101336c99dd7e85d3531d73fb493f7", size = 136807, upload-time = "2025-07-25T14:32:08.303Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/a0/f6c2be24709d1742d878b4530fa0c3f4a5e190d51397b680abbf44d11dbf/orjson-3.11.1-cp310-cp310-win_amd64.whl", hash = "sha256:5fd44d69ddfdfb4e8d0d83f09d27a4db34930fba153fbf79f8d4ae8b47914e04", size = 131561, upload-time = "2025-07-25T14:32:09.444Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/92/7ab270b5b3df8d5b0d3e572ddf2f03c9f6a79726338badf1ec8594e1469d/orjson-3.11.1-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:15e2a57ce3b57c1a36acffcc02e823afefceee0a532180c2568c62213c98e3ef", size = 240918, upload-time = "2025-07-25T14:32:11.021Z" },
+    { url = "https://files.pythonhosted.org/packages/80/41/df44684cfbd2e2e03bf9b09fdb14b7abcfff267998790b6acfb69ad435f0/orjson-3.11.1-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:17040a83ecaa130474af05bbb59a13cfeb2157d76385556041f945da936b1afd", size = 129386, upload-time = "2025-07-25T14:32:12.361Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/08/958f56edd18ba1827ad0c74b2b41a7ae0864718adee8ccb5d1a5528f8761/orjson-3.11.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a68f23f09e5626cc0867a96cf618f68b91acb4753d33a80bf16111fd7f9928c", size = 132508, upload-time = "2025-07-25T14:32:13.917Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/b6/5e56e189dacbf51e53ba8150c20e61ee746f6d57b697f5c52315ffc88a83/orjson-3.11.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47e07528bb6ccbd6e32a55e330979048b59bfc5518b47c89bc7ab9e3de15174a", size = 128501, upload-time = "2025-07-25T14:32:15.13Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/de/f6c301a514f5934405fd4b8f3d3efc758c911d06c3de3f4be1e30d675fa4/orjson-3.11.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3807cce72bf40a9d251d689cbec28d2efd27e0f6673709f948f971afd52cb09", size = 130465, upload-time = "2025-07-25T14:32:17.355Z" },
+    { url = "https://files.pythonhosted.org/packages/47/08/f7dbaab87d6f05eebff2d7b8e6a8ed5f13b2fe3e3ae49472b527d03dbd7a/orjson-3.11.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b2dc7e88da4ca201c940f5e6127998d9e89aa64264292334dad62854bc7fc27", size = 132416, upload-time = "2025-07-25T14:32:18.933Z" },
+    { url = "https://files.pythonhosted.org/packages/43/3f/dd5a185273b7ba6aa238cfc67bf9edaa1885ae51ce942bc1a71d0f99f574/orjson-3.11.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3091dad33ac9e67c0a550cfff8ad5be156e2614d6f5d2a9247df0627751a1495", size = 134924, upload-time = "2025-07-25T14:32:20.134Z" },
+    { url = "https://files.pythonhosted.org/packages/db/ef/729d23510eaa81f0ce9d938d99d72dcf5e4ed3609d9d0bcf9c8a282cc41a/orjson-3.11.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ed0fce2307843b79a0c83de49f65b86197f1e2310de07af9db2a1a77a61ce4c", size = 130938, upload-time = "2025-07-25T14:32:21.769Z" },
+    { url = "https://files.pythonhosted.org/packages/82/96/120feb6807f9e1f4c68fc842a0f227db8575eafb1a41b2537567b91c19d8/orjson-3.11.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5a31e84782a18c30abd56774c0cfa7b9884589f4d37d9acabfa0504dad59bb9d", size = 130811, upload-time = "2025-07-25T14:32:22.931Z" },
+    { url = "https://files.pythonhosted.org/packages/89/66/4695e946a453fa22ff945da4b1ed0691b3f4ec86b828d398288db4a0ff79/orjson-3.11.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:26b6c821abf1ae515fbb8e140a2406c9f9004f3e52acb780b3dee9bfffddbd84", size = 404272, upload-time = "2025-07-25T14:32:25.238Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/7b/1c953e2c9e55af126c6cb678a30796deb46d7713abdeb706b8765929464c/orjson-3.11.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f857b3d134b36a8436f1e24dcb525b6b945108b30746c1b0b556200b5cb76d39", size = 146196, upload-time = "2025-07-25T14:32:26.909Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/c2/bef5d3bc83f2e178592ff317e2cf7bd38ebc16b641f076ea49f27aadd1d3/orjson-3.11.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:df146f2a14116ce80f7da669785fcb411406d8e80136558b0ecda4c924b9ac55", size = 135336, upload-time = "2025-07-25T14:32:28.22Z" },
+    { url = "https://files.pythonhosted.org/packages/92/95/bc6006881ebdb4608ed900a763c3e3c6be0d24c3aadd62beb774f9464ec6/orjson-3.11.1-cp311-cp311-win32.whl", hash = "sha256:d777c57c1f86855fe5492b973f1012be776e0398571f7cc3970e9a58ecf4dc17", size = 136665, upload-time = "2025-07-25T14:32:29.976Z" },
+    { url = "https://files.pythonhosted.org/packages/59/c3/1f2b9cc0c60ea2473d386fed2df2b25ece50aeb73c798d4669aadff3061e/orjson-3.11.1-cp311-cp311-win_amd64.whl", hash = "sha256:e9a5fd589951f02ec2fcb8d69339258bbf74b41b104c556e6d4420ea5e059313", size = 131388, upload-time = "2025-07-25T14:32:31.595Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/e5/40c97e5a6b85944022fe54b463470045b8651b7bb2f1e16a95c42812bf97/orjson-3.11.1-cp311-cp311-win_arm64.whl", hash = "sha256:4cddbe41ee04fddad35d75b9cf3e3736ad0b80588280766156b94783167777af", size = 126786, upload-time = "2025-07-25T14:32:32.787Z" },
+    { url = "https://files.pythonhosted.org/packages/98/77/e55513826b712807caadb2b733eee192c1df105c6bbf0d965c253b72f124/orjson-3.11.1-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:2b7c8be96db3a977367250c6367793a3c5851a6ca4263f92f0b48d00702f9910", size = 240955, upload-time = "2025-07-25T14:32:34.056Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/88/a78132dddcc9c3b80a9fa050b3516bb2c996a9d78ca6fb47c8da2a80a696/orjson-3.11.1-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:72e18088f567bd4a45db5e3196677d9ed1605e356e500c8e32dd6e303167a13d", size = 129294, upload-time = "2025-07-25T14:32:35.323Z" },
+    { url = "https://files.pythonhosted.org/packages/09/02/6591e0dcb2af6bceea96cb1b5f4b48c1445492a3ef2891ac4aa306bb6f73/orjson-3.11.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d346e2ae1ce17888f7040b65a5a4a0c9734cb20ffbd228728661e020b4c8b3a5", size = 132310, upload-time = "2025-07-25T14:32:36.53Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/36/c1cfbc617bcfa4835db275d5e0fe9bbdbe561a4b53d3b2de16540ec29c50/orjson-3.11.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4bda5426ebb02ceb806a7d7ec9ba9ee5e0c93fca62375151a7b1c00bc634d06b", size = 128529, upload-time = "2025-07-25T14:32:37.817Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/bd/91a156c5df3aaf1d68b2ab5be06f1969955a8d3e328d7794f4338ac1d017/orjson-3.11.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:10506cebe908542c4f024861102673db534fd2e03eb9b95b30d94438fa220abf", size = 130925, upload-time = "2025-07-25T14:32:39.03Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/4c/a65cc24e9a5f87c9833a50161ab97b5edbec98bec99dfbba13827549debc/orjson-3.11.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:45202ee3f5494644e064c41abd1320497fb92fd31fc73af708708af664ac3b56", size = 132432, upload-time = "2025-07-25T14:32:40.619Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/4d/3fc3e5d7115f4f7d01b481e29e5a79bcbcc45711a2723242787455424f40/orjson-3.11.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5adaf01b92e0402a9ac5c3ebe04effe2bbb115f0914a0a53d34ea239a746289", size = 135069, upload-time = "2025-07-25T14:32:41.84Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/c6/7585aa8522af896060dc0cd7c336ba6c574ae854416811ee6642c505cc95/orjson-3.11.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6162a1a757a1f1f4a94bc6ffac834a3602e04ad5db022dd8395a54ed9dd51c81", size = 131045, upload-time = "2025-07-25T14:32:43.085Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/4e/b8a0a943793d2708ebc39e743c943251e08ee0f3279c880aefd8e9cb0c70/orjson-3.11.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:78404206977c9f946613d3f916727c189d43193e708d760ea5d4b2087d6b0968", size = 130597, upload-time = "2025-07-25T14:32:44.336Z" },
+    { url = "https://files.pythonhosted.org/packages/72/2b/7d30e2aed2f585d5d385fb45c71d9b16ba09be58c04e8767ae6edc6c9282/orjson-3.11.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:db48f8e81072e26df6cdb0e9fff808c28597c6ac20a13d595756cf9ba1fed48a", size = 404207, upload-time = "2025-07-25T14:32:45.612Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/7e/772369ec66fcbce79477f0891918309594cd00e39b67a68d4c445d2ab754/orjson-3.11.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0c1e394e67ced6bb16fea7054d99fbdd99a539cf4d446d40378d4c06e0a8548d", size = 146628, upload-time = "2025-07-25T14:32:46.981Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/c8/62bdb59229d7e393ae309cef41e32cc1f0b567b21dfd0742da70efb8b40c/orjson-3.11.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e7a840752c93d4eecd1378e9bb465c3703e127b58f675cd5c620f361b6cf57a4", size = 135449, upload-time = "2025-07-25T14:32:48.727Z" },
+    { url = "https://files.pythonhosted.org/packages/02/47/1c99aa60e19f781424eabeaacd9e999eafe5b59c81ead4273b773f0f3af1/orjson-3.11.1-cp312-cp312-win32.whl", hash = "sha256:4537b0e09f45d2b74cb69c7f39ca1e62c24c0488d6bf01cd24673c74cd9596bf", size = 136653, upload-time = "2025-07-25T14:32:50.622Z" },
+    { url = "https://files.pythonhosted.org/packages/31/9a/132999929a2892ab07e916669accecc83e5bff17e11a1186b4c6f23231f0/orjson-3.11.1-cp312-cp312-win_amd64.whl", hash = "sha256:dbee6b050062540ae404530cacec1bf25e56e8d87d8d9b610b935afeb6725cae", size = 131426, upload-time = "2025-07-25T14:32:51.883Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/77/d984ee5a1ca341090902e080b187721ba5d1573a8d9759e0c540975acfb2/orjson-3.11.1-cp312-cp312-win_arm64.whl", hash = "sha256:f55e557d4248322d87c4673e085c7634039ff04b47bfc823b87149ae12bef60d", size = 126635, upload-time = "2025-07-25T14:32:53.2Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/e9/880ef869e6f66279ce3a381a32afa0f34e29a94250146911eee029e56efc/orjson-3.11.1-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:53cfefe4af059e65aabe9683f76b9c88bf34b4341a77d329227c2424e0e59b0e", size = 240835, upload-time = "2025-07-25T14:32:54.507Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/1f/52039ef3d03eeea21763b46bc99ebe11d9de8510c72b7b5569433084a17e/orjson-3.11.1-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:93d5abed5a6f9e1b6f9b5bf6ed4423c11932b5447c2f7281d3b64e0f26c6d064", size = 129226, upload-time = "2025-07-25T14:32:55.908Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/da/59fdffc9465a760be2cd3764ef9cd5535eec8f095419f972fddb123b6d0e/orjson-3.11.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dbf06642f3db2966df504944cdd0eb68ca2717f0353bb20b20acd78109374a6", size = 132261, upload-time = "2025-07-25T14:32:57.538Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/5c/8610911c7e969db7cf928c8baac4b2f1e68d314bc3057acf5ca64f758435/orjson-3.11.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:dddf4e78747fa7f2188273f84562017a3c4f0824485b78372513c1681ea7a894", size = 128614, upload-time = "2025-07-25T14:32:58.808Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a1/a1db9d4310d014c90f3b7e9b72c6fb162cba82c5f46d0b345669eaebdd3a/orjson-3.11.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fa3fe8653c9f57f0e16f008e43626485b6723b84b2f741f54d1258095b655912", size = 130968, upload-time = "2025-07-25T14:33:00.038Z" },
+    { url = "https://files.pythonhosted.org/packages/56/ff/11acd1fd7c38ea7a1b5d6bf582ae3da05931bee64620995eb08fd63c77fe/orjson-3.11.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6334d2382aff975a61f6f4d1c3daf39368b887c7de08f7c16c58f485dcf7adb2", size = 132439, upload-time = "2025-07-25T14:33:01.354Z" },
+    { url = "https://files.pythonhosted.org/packages/70/f9/bb564dd9450bf8725e034a8ad7f4ae9d4710a34caf63b85ce1c0c6d40af0/orjson-3.11.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a3d0855b643f259ee0cb76fe3df4c04483354409a520a902b067c674842eb6b8", size = 135299, upload-time = "2025-07-25T14:33:03.079Z" },
+    { url = "https://files.pythonhosted.org/packages/94/bb/c8eafe6051405e241dda3691db4d9132d3c3462d1d10a17f50837dd130b4/orjson-3.11.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0eacdfeefd0a79987926476eb16e0245546bedeb8febbbbcf4b653e79257a8e4", size = 131004, upload-time = "2025-07-25T14:33:04.416Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/40/bed8d7dcf1bd2df8813bf010a25f645863a2f75e8e0ebdb2b55784cf1a62/orjson-3.11.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0ed07faf9e4873518c60480325dcbc16d17c59a165532cccfb409b4cdbaeff24", size = 130583, upload-time = "2025-07-25T14:33:05.768Z" },
+    { url = "https://files.pythonhosted.org/packages/57/e7/cfa2eb803ad52d74fbb5424a429b5be164e51d23f1d853e5e037173a5c48/orjson-3.11.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:d6d308dd578ae3658f62bb9eba54801533225823cd3248c902be1ebc79b5e014", size = 404218, upload-time = "2025-07-25T14:33:07.117Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/21/bc703af5bc6e9c7e18dcf4404dcc4ec305ab9bb6c82d3aee5952c0c56abf/orjson-3.11.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:c4aa13ca959ba6b15c0a98d3d204b850f9dc36c08c9ce422ffb024eb30d6e058", size = 146605, upload-time = "2025-07-25T14:33:08.55Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/fe/d26a0150534c4965a06f556aa68bf3c3b82999d5d7b0facd3af7b390c4af/orjson-3.11.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:be3d0653322abc9b68e5bcdaee6cfd58fcbe9973740ab222b87f4d687232ab1f", size = 135434, upload-time = "2025-07-25T14:33:09.967Z" },
+    { url = "https://files.pythonhosted.org/packages/89/b6/1cb28365f08cbcffc464f8512320c6eb6db6a653f03d66de47ea3c19385f/orjson-3.11.1-cp313-cp313-win32.whl", hash = "sha256:4dd34e7e2518de8d7834268846f8cab7204364f427c56fb2251e098da86f5092", size = 136596, upload-time = "2025-07-25T14:33:11.333Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/35/7870d0d3ed843652676d84d8a6038791113eacc85237b673b925802826b8/orjson-3.11.1-cp313-cp313-win_amd64.whl", hash = "sha256:d6895d32032b6362540e6d0694b19130bb4f2ad04694002dce7d8af588ca5f77", size = 131319, upload-time = "2025-07-25T14:33:12.614Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/3e/5bcd50fd865eb664d4edfdaaaff51e333593ceb5695a22c0d0a0d2b187ba/orjson-3.11.1-cp313-cp313-win_arm64.whl", hash = "sha256:bb7c36d5d3570fcbb01d24fa447a21a7fe5a41141fd88e78f7994053cc4e28f4", size = 126613, upload-time = "2025-07-25T14:33:13.927Z" },
+    { url = "https://files.pythonhosted.org/packages/61/d8/0a5cd31ed100b4e569e143cb0cddefc21f0bcb8ce284f44bca0bb0e10f3d/orjson-3.11.1-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:7b71ef394327b3d0b39f6ea7ade2ecda2731a56c6a7cbf0d6a7301203b92a89b", size = 240819, upload-time = "2025-07-25T14:33:15.223Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/95/7eb2c76c92192ceca16bc81845ff100bbb93f568b4b94d914b6a4da47d61/orjson-3.11.1-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:77c0fe28ed659b62273995244ae2aa430e432c71f86e4573ab16caa2f2e3ca5e", size = 129218, upload-time = "2025-07-25T14:33:16.637Z" },
+    { url = "https://files.pythonhosted.org/packages/da/84/e6b67f301b18adbbc346882f456bea44daebbd032ba725dbd7b741e3a7f1/orjson-3.11.1-cp314-cp314-manylinux_2_34_aarch64.whl", hash = "sha256:1495692f1f1ba2467df429343388a0ed259382835922e124c0cfdd56b3d1f727", size = 132238, upload-time = "2025-07-25T14:33:17.934Z" },
+    { url = "https://files.pythonhosted.org/packages/84/78/a45a86e29d9b2f391f9d00b22da51bc4b46b86b788fd42df2c5fcf3e8005/orjson-3.11.1-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:08c6a762fca63ca4dc04f66c48ea5d2428db55839fec996890e1bfaf057b658c", size = 130998, upload-time = "2025-07-25T14:33:19.282Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/8f/6eb3ee6760d93b2ce996a8529164ee1f5bafbdf64b74c7314b68db622b32/orjson-3.11.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9e26794fe3976810b2c01fda29bd9ac7c91a3c1284b29cc9a383989f7b614037", size = 130559, upload-time = "2025-07-25T14:33:20.589Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/78/9572ae94bdba6813917c9387e7834224c011ea6b4530ade07d718fd31598/orjson-3.11.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:4b4b4f8f0b1d3ef8dc73e55363a0ffe012a42f4e2f1a140bf559698dca39b3fa", size = 404231, upload-time = "2025-07-25T14:33:22.019Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/a3/68381ad0757e084927c5ee6cfdeab1c6c89405949ee493db557e60871c4c/orjson-3.11.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:848be553ea35aa89bfefbed2e27c8a41244c862956ab8ba00dc0b27e84fd58de", size = 146658, upload-time = "2025-07-25T14:33:23.675Z" },
+    { url = "https://files.pythonhosted.org/packages/00/db/fac56acf77aab778296c3f541a3eec643266f28ecd71d6c0cba251e47655/orjson-3.11.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c964c29711a4b1df52f8d9966f015402a6cf87753a406c1c4405c407dd66fd45", size = 135443, upload-time = "2025-07-25T14:33:25.04Z" },
+    { url = "https://files.pythonhosted.org/packages/76/b1/326fa4b87426197ead61c1eec2eeb3babc9eb33b480ac1f93894e40c8c08/orjson-3.11.1-cp314-cp314-win32.whl", hash = "sha256:33aada2e6b6bc9c540d396528b91e666cedb383740fee6e6a917f561b390ecb1", size = 136643, upload-time = "2025-07-25T14:33:26.449Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/8e/2987ae2109f3bfd39680f8a187d1bc09ad7f8fb019dcdc719b08c7242ade/orjson-3.11.1-cp314-cp314-win_amd64.whl", hash = "sha256:68e10fd804e44e36188b9952543e3fa22f5aa8394da1b5283ca2b423735c06e8", size = 131324, upload-time = "2025-07-25T14:33:27.896Z" },
+    { url = "https://files.pythonhosted.org/packages/21/5f/253e08e6974752b124fbf3a4de3ad53baa766b0cb4a333d47706d307e396/orjson-3.11.1-cp314-cp314-win_arm64.whl", hash = "sha256:f3cf6c07f8b32127d836be8e1c55d4f34843f7df346536da768e9f73f22078a1", size = 126605, upload-time = "2025-07-25T14:33:29.244Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/64/ce5c07420fe7367bd3da769161f07ae54b35c552468c6eb7947c023a25c6/orjson-3.11.1-cp39-cp39-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:3d593a9e0bccf2c7401ae53625b519a7ad7aa555b1c82c0042b322762dc8af4e", size = 241861, upload-time = "2025-07-25T14:33:30.585Z" },
+    { url = "https://files.pythonhosted.org/packages/94/17/7894ff2867e83d0d5cdda6e41210963a88764b292ec7a91fa93bcb5afd9e/orjson-3.11.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0baad413c498fc1eef568504f11ea46bc71f94b845c075e437da1e2b85b4fb86", size = 132485, upload-time = "2025-07-25T14:33:32.123Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/38/e8f907733e281e65ba912be552fe5ad5b53f0fdddaa0b43c3a9bc0bce5df/orjson-3.11.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:22cf17ae1dae3f9b5f37bfcdba002ed22c98bbdb70306e42dc18d8cc9b50399a", size = 128513, upload-time = "2025-07-25T14:33:33.571Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/49/d6d0f23036a16c9909ca4cb09d53b2bf9341e7b1ae7d03ded302a3673448/orjson-3.11.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e855c1e97208133ce88b3ef6663c9a82ddf1d09390cd0856a1638deee0390c3c", size = 130462, upload-time = "2025-07-25T14:33:35.061Z" },
+    { url = "https://files.pythonhosted.org/packages/04/70/df75afdfe6d3c027c03d656f0a5074159ace27a24dbf22d4af7fabf811df/orjson-3.11.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b5861c5f7acff10599132854c70ab10abf72aebf7c627ae13575e5f20b1ab8fe", size = 132438, upload-time = "2025-07-25T14:33:36.893Z" },
+    { url = "https://files.pythonhosted.org/packages/56/ef/938ae6995965cc7884d8460177bed20248769d1edf99d1904dfd46eebd7d/orjson-3.11.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b1e6415c5b5ff3a616a6dafad7b6ec303a9fc625e9313c8e1268fb1370a63dcb", size = 134928, upload-time = "2025-07-25T14:33:38.755Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2c/97be96e9ed22123724611c8511f306a69e6cd0273d4c6424edda5716d108/orjson-3.11.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:912579642f5d7a4a84d93c5eed8daf0aa34e1f2d3f4dc6571a8e418703f5701e", size = 130903, upload-time = "2025-07-25T14:33:40.585Z" },
+    { url = "https://files.pythonhosted.org/packages/86/ed/7cf17c1621a5a4c6716dfa8099dc9a4153cc8bd402195ae9028d7e5286e3/orjson-3.11.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2092e1d3b33f64e129ff8271642afddc43763c81f2c30823b4a4a4a5f2ea5b55", size = 130793, upload-time = "2025-07-25T14:33:42.397Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/72/add1805918b6af187c193895d38bddc7717eea30d1ea8b25833a9668b469/orjson-3.11.1-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:b8ac64caba1add2c04e9cd4782d4d0c4d6c554b7a3369bdec1eed7854c98db7b", size = 404283, upload-time = "2025-07-25T14:33:44.035Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/f1/b27c05bab8b49ff2fb30e6c42e8602ae51d6c9dd19564031da37f7ea61ba/orjson-3.11.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:23196b826ebc85c43f8e27bee0ab33c5fb13a29ea47fb4fcd6ebb1e660eb0252", size = 146169, upload-time = "2025-07-25T14:33:46.036Z" },
+    { url = "https://files.pythonhosted.org/packages/91/5b/5a2cdc081bc2093708726887980d8f0c7c0edc31ab0d3c5ccc1db70ede0e/orjson-3.11.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:f2d3364cfad43003f1e3d564a069c8866237cca30f9c914b26ed2740b596ed00", size = 135304, upload-time = "2025-07-25T14:33:47.519Z" },
+    { url = "https://files.pythonhosted.org/packages/01/7f/fe09ebaecbaec6a741b29f79ccbbe38736dff51e8413f334067ad914df26/orjson-3.11.1-cp39-cp39-win32.whl", hash = "sha256:20b0dca94ea4ebe4628330de50975b35817a3f52954c1efb6d5d0498a3bbe581", size = 136652, upload-time = "2025-07-25T14:33:49.38Z" },
+    { url = "https://files.pythonhosted.org/packages/97/2f/71fe70d7d06087d8abef423843d880e3d4cf21cfc38c299feebb0a98f7c1/orjson-3.11.1-cp39-cp39-win_amd64.whl", hash = "sha256:200c3ad7ed8b5d31d49143265dfebd33420c4b61934ead16833b5cd2c3d241be", size = 131373, upload-time = "2025-07-25T14:33:51.359Z" },
 ]
 
 [[package]]
@@ -1190,27 +1207,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.12.4"
+version = "0.12.7"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9b/ce/8d7dbedede481245b489b769d27e2934730791a9a82765cb94566c6e6abd/ruff-0.12.4.tar.gz", hash = "sha256:13efa16df6c6eeb7d0f091abae50f58e9522f3843edb40d56ad52a5a4a4b6873", size = 5131435, upload-time = "2025-07-17T17:27:19.138Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/81/0bd3594fa0f690466e41bd033bdcdf86cba8288345ac77ad4afbe5ec743a/ruff-0.12.7.tar.gz", hash = "sha256:1fc3193f238bc2d7968772c82831a4ff69252f673be371fb49663f0068b7ec71", size = 5197814, upload-time = "2025-07-29T22:32:35.877Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ae/9f/517bc5f61bad205b7f36684ffa5415c013862dee02f55f38a217bdbe7aa4/ruff-0.12.4-py3-none-linux_armv6l.whl", hash = "sha256:cb0d261dac457ab939aeb247e804125a5d521b21adf27e721895b0d3f83a0d0a", size = 10188824, upload-time = "2025-07-17T17:26:31.412Z" },
-    { url = "https://files.pythonhosted.org/packages/28/83/691baae5a11fbbde91df01c565c650fd17b0eabed259e8b7563de17c6529/ruff-0.12.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:55c0f4ca9769408d9b9bac530c30d3e66490bd2beb2d3dae3e4128a1f05c7442", size = 10884521, upload-time = "2025-07-17T17:26:35.084Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/8d/756d780ff4076e6dd035d058fa220345f8c458391f7edfb1c10731eedc75/ruff-0.12.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a8224cc3722c9ad9044da7f89c4c1ec452aef2cfe3904365025dd2f51daeae0e", size = 10277653, upload-time = "2025-07-17T17:26:37.897Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/97/8eeee0f48ece153206dce730fc9e0e0ca54fd7f261bb3d99c0a4343a1892/ruff-0.12.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e9949d01d64fa3672449a51ddb5d7548b33e130240ad418884ee6efa7a229586", size = 10485993, upload-time = "2025-07-17T17:26:40.68Z" },
-    { url = "https://files.pythonhosted.org/packages/49/b8/22a43d23a1f68df9b88f952616c8508ea6ce4ed4f15353b8168c48b2d7e7/ruff-0.12.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:be0593c69df9ad1465e8a2d10e3defd111fdb62dcd5be23ae2c06da77e8fcffb", size = 10022824, upload-time = "2025-07-17T17:26:43.564Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/70/37c234c220366993e8cffcbd6cadbf332bfc848cbd6f45b02bade17e0149/ruff-0.12.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a7dea966bcb55d4ecc4cc3270bccb6f87a337326c9dcd3c07d5b97000dbff41c", size = 11524414, upload-time = "2025-07-17T17:26:46.219Z" },
-    { url = "https://files.pythonhosted.org/packages/14/77/c30f9964f481b5e0e29dd6a1fae1f769ac3fd468eb76fdd5661936edd262/ruff-0.12.4-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:afcfa3ab5ab5dd0e1c39bf286d829e042a15e966b3726eea79528e2e24d8371a", size = 12419216, upload-time = "2025-07-17T17:26:48.883Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/79/af7fe0a4202dce4ef62c5e33fecbed07f0178f5b4dd9c0d2fcff5ab4a47c/ruff-0.12.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c057ce464b1413c926cdb203a0f858cd52f3e73dcb3270a3318d1630f6395bb3", size = 11976756, upload-time = "2025-07-17T17:26:51.754Z" },
-    { url = "https://files.pythonhosted.org/packages/09/d1/33fb1fc00e20a939c305dbe2f80df7c28ba9193f7a85470b982815a2dc6a/ruff-0.12.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e64b90d1122dc2713330350626b10d60818930819623abbb56535c6466cce045", size = 11020019, upload-time = "2025-07-17T17:26:54.265Z" },
-    { url = "https://files.pythonhosted.org/packages/64/f4/e3cd7f7bda646526f09693e2e02bd83d85fff8a8222c52cf9681c0d30843/ruff-0.12.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2abc48f3d9667fdc74022380b5c745873499ff827393a636f7a59da1515e7c57", size = 11277890, upload-time = "2025-07-17T17:26:56.914Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/d0/69a85fb8b94501ff1a4f95b7591505e8983f38823da6941eb5b6badb1e3a/ruff-0.12.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:2b2449dc0c138d877d629bea151bee8c0ae3b8e9c43f5fcaafcd0c0d0726b184", size = 10348539, upload-time = "2025-07-17T17:26:59.381Z" },
-    { url = "https://files.pythonhosted.org/packages/16/a0/91372d1cb1678f7d42d4893b88c252b01ff1dffcad09ae0c51aa2542275f/ruff-0.12.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:56e45bb11f625db55f9b70477062e6a1a04d53628eda7784dce6e0f55fd549eb", size = 10009579, upload-time = "2025-07-17T17:27:02.462Z" },
-    { url = "https://files.pythonhosted.org/packages/23/1b/c4a833e3114d2cc0f677e58f1df6c3b20f62328dbfa710b87a1636a5e8eb/ruff-0.12.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:478fccdb82ca148a98a9ff43658944f7ab5ec41c3c49d77cd99d44da019371a1", size = 10942982, upload-time = "2025-07-17T17:27:05.343Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/ce/ce85e445cf0a5dd8842f2f0c6f0018eedb164a92bdf3eda51984ffd4d989/ruff-0.12.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:0fc426bec2e4e5f4c4f182b9d2ce6a75c85ba9bcdbe5c6f2a74fcb8df437df4b", size = 11343331, upload-time = "2025-07-17T17:27:08.652Z" },
-    { url = "https://files.pythonhosted.org/packages/35/cf/441b7fc58368455233cfb5b77206c849b6dfb48b23de532adcc2e50ccc06/ruff-0.12.4-py3-none-win32.whl", hash = "sha256:4de27977827893cdfb1211d42d84bc180fceb7b72471104671c59be37041cf93", size = 10267904, upload-time = "2025-07-17T17:27:11.814Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/7e/20af4a0df5e1299e7368d5ea4350412226afb03d95507faae94c80f00afd/ruff-0.12.4-py3-none-win_amd64.whl", hash = "sha256:fe0b9e9eb23736b453143d72d2ceca5db323963330d5b7859d60d101147d461a", size = 11209038, upload-time = "2025-07-17T17:27:14.417Z" },
-    { url = "https://files.pythonhosted.org/packages/11/02/8857d0dfb8f44ef299a5dfd898f673edefb71e3b533b3b9d2db4c832dd13/ruff-0.12.4-py3-none-win_arm64.whl", hash = "sha256:0618ec4442a83ab545e5b71202a5c0ed7791e8471435b94e655b570a5031a98e", size = 10469336, upload-time = "2025-07-17T17:27:16.913Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/d2/6cb35e9c85e7a91e8d22ab32ae07ac39cc34a71f1009a6f9e4a2a019e602/ruff-0.12.7-py3-none-linux_armv6l.whl", hash = "sha256:76e4f31529899b8c434c3c1dede98c4483b89590e15fb49f2d46183801565303", size = 11852189, upload-time = "2025-07-29T22:31:41.281Z" },
+    { url = "https://files.pythonhosted.org/packages/63/5b/a4136b9921aa84638f1a6be7fb086f8cad0fde538ba76bda3682f2599a2f/ruff-0.12.7-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:789b7a03e72507c54fb3ba6209e4bb36517b90f1a3569ea17084e3fd295500fb", size = 12519389, upload-time = "2025-07-29T22:31:54.265Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/c9/3e24a8472484269b6b1821794141f879c54645a111ded4b6f58f9ab0705f/ruff-0.12.7-py3-none-macosx_11_0_arm64.whl", hash = "sha256:2e1c2a3b8626339bb6369116e7030a4cf194ea48f49b64bb505732a7fce4f4e3", size = 11743384, upload-time = "2025-07-29T22:31:59.575Z" },
+    { url = "https://files.pythonhosted.org/packages/26/7c/458dd25deeb3452c43eaee853c0b17a1e84169f8021a26d500ead77964fd/ruff-0.12.7-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32dec41817623d388e645612ec70d5757a6d9c035f3744a52c7b195a57e03860", size = 11943759, upload-time = "2025-07-29T22:32:01.95Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/8b/658798472ef260ca050e400ab96ef7e85c366c39cf3dfbef4d0a46a528b6/ruff-0.12.7-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47ef751f722053a5df5fa48d412dbb54d41ab9b17875c6840a58ec63ff0c247c", size = 11654028, upload-time = "2025-07-29T22:32:04.367Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/86/9c2336f13b2a3326d06d39178fd3448dcc7025f82514d1b15816fe42bfe8/ruff-0.12.7-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a828a5fc25a3efd3e1ff7b241fd392686c9386f20e5ac90aa9234a5faa12c423", size = 13225209, upload-time = "2025-07-29T22:32:06.952Z" },
+    { url = "https://files.pythonhosted.org/packages/76/69/df73f65f53d6c463b19b6b312fd2391dc36425d926ec237a7ed028a90fc1/ruff-0.12.7-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:5726f59b171111fa6a69d82aef48f00b56598b03a22f0f4170664ff4d8298efb", size = 14182353, upload-time = "2025-07-29T22:32:10.053Z" },
+    { url = "https://files.pythonhosted.org/packages/58/1e/de6cda406d99fea84b66811c189b5ea139814b98125b052424b55d28a41c/ruff-0.12.7-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:74e6f5c04c4dd4aba223f4fe6e7104f79e0eebf7d307e4f9b18c18362124bccd", size = 13631555, upload-time = "2025-07-29T22:32:12.644Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/ae/625d46d5164a6cc9261945a5e89df24457dc8262539ace3ac36c40f0b51e/ruff-0.12.7-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5d0bfe4e77fba61bf2ccadf8cf005d6133e3ce08793bbe870dd1c734f2699a3e", size = 12667556, upload-time = "2025-07-29T22:32:15.312Z" },
+    { url = "https://files.pythonhosted.org/packages/55/bf/9cb1ea5e3066779e42ade8d0cd3d3b0582a5720a814ae1586f85014656b6/ruff-0.12.7-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06bfb01e1623bf7f59ea749a841da56f8f653d641bfd046edee32ede7ff6c606", size = 12939784, upload-time = "2025-07-29T22:32:17.69Z" },
+    { url = "https://files.pythonhosted.org/packages/55/7f/7ead2663be5627c04be83754c4f3096603bf5e99ed856c7cd29618c691bd/ruff-0.12.7-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e41df94a957d50083fd09b916d6e89e497246698c3f3d5c681c8b3e7b9bb4ac8", size = 11771356, upload-time = "2025-07-29T22:32:20.134Z" },
+    { url = "https://files.pythonhosted.org/packages/17/40/a95352ea16edf78cd3a938085dccc55df692a4d8ba1b3af7accbe2c806b0/ruff-0.12.7-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:4000623300563c709458d0ce170c3d0d788c23a058912f28bbadc6f905d67afa", size = 11612124, upload-time = "2025-07-29T22:32:22.645Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/74/633b04871c669e23b8917877e812376827c06df866e1677f15abfadc95cb/ruff-0.12.7-py3-none-musllinux_1_2_i686.whl", hash = "sha256:69ffe0e5f9b2cf2b8e289a3f8945b402a1b19eff24ec389f45f23c42a3dd6fb5", size = 12479945, upload-time = "2025-07-29T22:32:24.765Z" },
+    { url = "https://files.pythonhosted.org/packages/be/34/c3ef2d7799c9778b835a76189c6f53c179d3bdebc8c65288c29032e03613/ruff-0.12.7-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:a07a5c8ffa2611a52732bdc67bf88e243abd84fe2d7f6daef3826b59abbfeda4", size = 12998677, upload-time = "2025-07-29T22:32:27.022Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ab/aca2e756ad7b09b3d662a41773f3edcbd262872a4fc81f920dc1ffa44541/ruff-0.12.7-py3-none-win32.whl", hash = "sha256:c928f1b2ec59fb77dfdf70e0419408898b63998789cc98197e15f560b9e77f77", size = 11756687, upload-time = "2025-07-29T22:32:29.381Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/71/26d45a5042bc71db22ddd8252ca9d01e9ca454f230e2996bb04f16d72799/ruff-0.12.7-py3-none-win_amd64.whl", hash = "sha256:9c18f3d707ee9edf89da76131956aba1270c6348bfee8f6c647de841eac7194f", size = 12912365, upload-time = "2025-07-29T22:32:31.517Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/9b/0b8aa09817b63e78d94b4977f18b1fcaead3165a5ee49251c5d5c245bb2d/ruff-0.12.7-py3-none-win_arm64.whl", hash = "sha256:dfce05101dbd11833a0776716d5d1578641b7fddb537fe7fa956ab85d1769b69", size = 11982083, upload-time = "2025-07-29T22:32:33.881Z" },
 ]
 
 [[package]]
@@ -1238,15 +1255,15 @@ wheels = [
 
 [[package]]
 name = "starlette"
-version = "0.47.1"
+version = "0.47.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio", marker = "python_full_version >= '3.11'" },
     { name = "typing-extensions", marker = "python_full_version >= '3.11' and python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/0a/69/662169fdb92fb96ec3eaee218cf540a629d629c86d7993d9651226a6789b/starlette-0.47.1.tar.gz", hash = "sha256:aef012dd2b6be325ffa16698f9dc533614fb1cebd593a906b90dc1025529a79b", size = 2583072, upload-time = "2025-06-21T04:03:17.337Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/57/d062573f391d062710d4088fa1369428c38d51460ab6fedff920efef932e/starlette-0.47.2.tar.gz", hash = "sha256:6ae9aa5db235e4846decc1e7b79c4f346adf41e9777aebeb49dfd09bbd7023d8", size = 2583948, upload-time = "2025-07-20T17:31:58.522Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/82/95/38ef0cd7fa11eaba6a99b3c4f5ac948d8bc6ff199aabd327a29cc000840c/starlette-0.47.1-py3-none-any.whl", hash = "sha256:5e11c9f5c7c3f24959edbf2dffdc01bba860228acf657129467d8a7468591527", size = 72747, upload-time = "2025-06-21T04:03:15.705Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/1f/b876b1f83aef204198a42dc101613fefccb32258e5428b5f9259677864b4/starlette-0.47.2-py3-none-any.whl", hash = "sha256:c5847e96134e5c5371ee9fac6fdf1a67336d5815e09eb2a01fdb57a351ef915b", size = 72984, upload-time = "2025-07-20T17:31:56.738Z" },
 ]
 
 [[package]]
@@ -1308,11 +1325,11 @@ wheels = [
 
 [[package]]
 name = "truststore"
-version = "0.10.1"
+version = "0.10.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0f/a7/b7a43228762966a13598a404f3dfb4803ea29a906f449d8b0e73ed0bcd30/truststore-0.10.1.tar.gz", hash = "sha256:eda021616b59021812e800fa0a071e51b266721bef3ce092db8a699e21c63539", size = 26101, upload-time = "2025-02-07T18:57:38.201Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/19/d90d35e584f58bac270beee003dd93b664335c0b9074b03b8604c6ea36ec/truststore-0.10.3.tar.gz", hash = "sha256:16ff5f6faf692acca470f9b92e66b4c0faccb9b702d0b0486d3d465932b6b3b1", size = 26214, upload-time = "2025-07-29T19:05:31.67Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/bc/df/8ad635bdcfa8214c399e5614f7c2121dced47defb755a85ea1fa702ffb1c/truststore-0.10.1-py3-none-any.whl", hash = "sha256:b64e6025a409a43ebdd2807b0c41c8bff49ea7ae6550b5087ac6df6619352d4c", size = 18496, upload-time = "2025-02-07T18:57:36.348Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/49/184050dc32c6ae6a1ef4ebd16ab5128483c02fa1e686d5559df0ba1c08b2/truststore-0.10.3-py3-none-any.whl", hash = "sha256:5bcc0889390f7b69e56be3df02f4912cfbb5a8bdb77a63fdcacb91049707879b", size = 18649, upload-time = "2025-07-29T19:05:30.414Z" },
 ]
 
 [[package]]

libs/langgraph/Makefile

@@ -37,11 +37,11 @@ coverage:
 		--cov-report xml \
 		--cov-report term-missing:skip-covered
 
-start-services:
-	docker compose -f tests/compose-postgres.yml -f tests/compose-redis.yml up -V --force-recreate --wait --remove-orphans
+start-postgres:
+	docker compose -f tests/compose-postgres.yml up -V --force-recreate --wait --remove-orphans
 
-stop-services:
-	docker compose -f tests/compose-postgres.yml -f tests/compose-redis.yml down -v
+stop-postgres:
+	docker compose -f tests/compose-postgres.yml down -v
 
 start-dev-server:
 	LOG_LEVEL=warning uv run langgraph dev --config tests/example_app/langgraph.json --no-browser & echo "$$!" > .devserver.pid
@@ -60,11 +60,11 @@ NO_DOCKER ?= $(sh command -v docker >/dev/null 2>&1 && echo "false" || echo "tru
 
 test:
 	if [ "$(NO_DOCKER)" = "false" ]; then \
-		make start-services &&\
+		make start-postgres &&\
 		make start-dev-server &&\
 		uv run pytest $(TEST); \
 		EXIT_CODE=$$?; \
-		make stop-services; \
+		make stop-postgres; \
 		make stop-dev-server; \
 		exit $$EXIT_CODE; \
 	else \
@@ -74,11 +74,11 @@ test:
 	fi
 
 test_parallel:
-	make start-services &&\
+	make start-postgres &&\
 	make start-dev-server &&\
 	uv run pytest -n auto --dist worksteal $(TEST); \
 	EXIT_CODE=$$?; \
-	make stop-services; \
+	make stop-postgres; \
 	make stop-dev-server; \
 	exit $$EXIT_CODE
 
@@ -93,11 +93,11 @@ MAXFAIL_ARGS := $(if $(MAXFAIL),--maxfail $(MAXFAIL),)
 XDIST_ARGS := $(if $(WORKERS),-x $(XDIST_ARGS),)
 
 test_watch:
-	make start-services &&\
+	make start-postgres &&\
 	make start-dev-server &&\
 	uv run ptw . -- --ff -vv $(XDIST_ARGS) $(MAXFAIL_ARGS) $(TEST); \
 	EXIT_CODE=$$?; \
-	make stop-services; \
+	make stop-postgres; \
 	make stop-dev-server; \
 	exit $$EXIT_CODE
 

libs/langgraph/langgraph/graph/_branch.py

@@ -41,16 +41,16 @@ _Writer = Callable[
 
 
 def _get_branch_path_input_schema(
-    path: Callable[..., Hashable | Sequence[Hashable]]
-    | Callable[..., Awaitable[Hashable | Sequence[Hashable]]]
-    | Runnable[Any, Hashable | Sequence[Hashable]],
+    path: Callable[..., Hashable | list[Hashable]]
+    | Callable[..., Awaitable[Hashable | list[Hashable]]]
+    | Runnable[Any, Hashable | list[Hashable]],
 ) -> type[Any] | None:
     input = None
     # detect input schema annotation in the branch callable
     try:
         callable_: (
-            Callable[..., Hashable | Sequence[Hashable]]
-            | Callable[..., Awaitable[Hashable | Sequence[Hashable]]]
+            Callable[..., Hashable | list[Hashable]]
+            | Callable[..., Awaitable[Hashable | list[Hashable]]]
             | None
         ) = None
         if isinstance(path, (RunnableCallable, RunnableLambda)):

libs/langgraph/langgraph/graph/message.py

@@ -22,11 +22,10 @@ from langchain_core.messages import (
     convert_to_messages,
     message_chunk_to_message,
 )
-from typing_extensions import TypedDict, deprecated
+from typing_extensions import TypedDict
 
 from langgraph._internal._constants import CONF, CONFIG_KEY_SEND, NS_SEP
 from langgraph.graph.state import StateGraph
-from langgraph.warnings import LangGraphDeprecatedSinceV10
 
 __all__ = (
     "add_messages",
@@ -234,16 +233,9 @@ def add_messages(
     return merged
 
 
-@deprecated(
-    "MessageGraph is deprecated in LangGraph v1.0.0, to be removed in v2.0.0. Please use StateGraph with a `messages` key instead.",
-    category=None,
-)
 class MessageGraph(StateGraph):
     """A StateGraph where every node receives a list of messages as input and returns one or more messages as output.
 
-    !!! warning "Deprecation"
-        MessageGraph is deprecated in LangGraph v1.0.0, to be removed in v2.0.0. Please use StateGraph with a `messages` key instead.
-
     MessageGraph is a subclass of StateGraph whose entire state is a single, append-only* list of messages.
     Each node in a MessageGraph takes a list of messages as input and returns zero or more
     messages as output. The `add_messages` function is used to merge the output messages from each node
@@ -289,11 +281,6 @@ class MessageGraph(StateGraph):
     """
 
     def __init__(self) -> None:
-        warnings.warn(
-            "MessageGraph is deprecated in LangGraph v1.0.0, to be removed in v2.0.0. Please use StateGraph with a `messages` key instead.",
-            category=LangGraphDeprecatedSinceV10,
-            stacklevel=2,
-        )
         super().__init__(Annotated[list[AnyMessage], add_messages])  # type: ignore[arg-type]
 
 

libs/langgraph/langgraph/graph/state.py

@@ -607,9 +607,9 @@ class StateGraph(Generic[StateT, ContextT, InputT, OutputT]):
     def add_conditional_edges(
         self,
         source: str,
-        path: Callable[..., Hashable | Sequence[Hashable]]
-        | Callable[..., Awaitable[Hashable | Sequence[Hashable]]]
-        | Runnable[Any, Hashable | Sequence[Hashable]],
+        path: Callable[..., Hashable | list[Hashable]]
+        | Callable[..., Awaitable[Hashable | list[Hashable]]]
+        | Runnable[Any, Hashable | list[Hashable]],
         path_map: dict[Hashable, str] | list[str] | None = None,
     ) -> Self:
         """Add a conditional edge from the starting node to any number of destination nodes.
@@ -710,9 +710,9 @@ class StateGraph(Generic[StateT, ContextT, InputT, OutputT]):
 
     def set_conditional_entry_point(
         self,
-        path: Callable[..., Hashable | Sequence[Hashable]]
-        | Callable[..., Awaitable[Hashable | Sequence[Hashable]]]
-        | Runnable[Any, Hashable | Sequence[Hashable]],
+        path: Callable[..., Hashable | list[Hashable]]
+        | Callable[..., Awaitable[Hashable | list[Hashable]]]
+        | Runnable[Any, Hashable | list[Hashable]],
         path_map: dict[Hashable, str] | list[str] | None = None,
     ) -> Self:
         """Sets a conditional entry point in the graph.

libs/langgraph/langgraph/pregel/_checkpoint.py

@@ -29,7 +29,6 @@ def create_checkpoint(
     step: int,
     *,
     id: str | None = None,
-    updated_channels: set[str] | None = None,
 ) -> Checkpoint:
     """Create a checkpoint for the given channels."""
     ts = datetime.now(timezone.utc).isoformat()
@@ -50,7 +49,6 @@ def create_checkpoint(
         channel_values=values,
         channel_versions=checkpoint["channel_versions"],
         versions_seen=checkpoint["versions_seen"],
-        updated_channels=None if updated_channels is None else sorted(updated_channels),
     )
 
 
@@ -83,5 +81,4 @@ def copy_checkpoint(checkpoint: Checkpoint) -> Checkpoint:
         channel_values=checkpoint["channel_values"].copy(),
         channel_versions=checkpoint["channel_versions"].copy(),
         versions_seen={k: v.copy() for k, v in checkpoint["versions_seen"].items()},
-        updated_channels=checkpoint.get("updated_channels", None),
     )

libs/langgraph/langgraph/pregel/_loop.py

@@ -568,9 +568,7 @@ class PregelLoop:
             if task := tasks.get(tid):
                 task.writes.append((k, v))
 
-    def _first(
-        self, *, input_keys: str | Sequence[str], updated_channels: set[str] | None
-    ) -> set[str] | None:
+    def _first(self, *, input_keys: str | Sequence[str]) -> set[str] | None:
         # resuming from previous checkpoint requires
         # - finding a previous checkpoint
         # - receiving None input (outer graph) or RESUMING flag (subgraph)
@@ -587,6 +585,8 @@ class PregelLoop:
                 ),
             )
         )
+        # this can be set only when there are input_writes
+        updated_channels: set[str] | None = None
 
         # map command to writes
         if isinstance(self.input, Command):
@@ -614,15 +614,13 @@ class PregelLoop:
         if null_writes := [
             w[1:] for w in self.checkpoint_pending_writes if w[0] == NULL_TASK_ID
         ]:
-            null_updated_channels = apply_writes(
+            apply_writes(
                 self.checkpoint,
                 self.channels,
                 [PregelTaskWrites((), INPUT, null_writes, [])],
                 self.checkpointer_get_next_version,
                 self.trigger_to_nodes,
             )
-            if updated_channels is not None:
-                updated_channels.update(null_updated_channels)
         # proceed past previous checkpoint
         if is_resuming:
             self.checkpoint["versions_seen"].setdefault(INTERRUPT, {})
@@ -650,7 +648,6 @@ class PregelLoop:
                 store=None,
                 checkpointer=None,
                 manager=None,
-                updated_channels=updated_channels,
             )
             # apply input writes
             updated_channels = apply_writes(
@@ -664,7 +661,6 @@ class PregelLoop:
                 self.trigger_to_nodes,
             )
             # save input checkpoint
-            self.updated_channels = updated_channels
             self._put_checkpoint({"source": "input"})
         elif CONFIG_KEY_RESUMING not in configurable:
             raise EmptyInputError(f"Received no input for {input_keys}")
@@ -697,7 +693,6 @@ class PregelLoop:
             self.channels if do_checkpoint else None,
             self.step,
             id=self.checkpoint["id"] if exiting else None,
-            updated_channels=self.updated_channels,
         )
         # bail if no checkpointer
         if do_checkpoint and self._checkpointer_put_after_previous is not None:
@@ -1041,12 +1036,7 @@ class SyncPregelLoop(PregelLoop, AbstractContextManager):
         self.step = self.checkpoint_metadata["step"] + 1
         self.stop = self.step + self.config["recursion_limit"] + 1
         self.checkpoint_previous_versions = self.checkpoint["channel_versions"].copy()
-        self.updated_channels = self._first(
-            input_keys=self.input_keys,
-            updated_channels=set(self.checkpoint.get("updated_channels"))  # type: ignore[arg-type]
-            if self.checkpoint.get("updated_channels")
-            else None,
-        )
+        self.updated_channels = self._first(input_keys=self.input_keys)
 
         return self
 
@@ -1222,12 +1212,7 @@ class AsyncPregelLoop(PregelLoop, AbstractAsyncContextManager):
         self.step = self.checkpoint_metadata["step"] + 1
         self.stop = self.step + self.config["recursion_limit"] + 1
         self.checkpoint_previous_versions = self.checkpoint["channel_versions"].copy()
-        self.updated_channels = self._first(
-            input_keys=self.input_keys,
-            updated_channels=set(self.checkpoint.get("updated_channels"))  # type: ignore[arg-type]
-            if self.checkpoint.get("updated_channels")
-            else None,
-        )
+        self.updated_channels = self._first(input_keys=self.input_keys)
 
         return self
 

libs/langgraph/langgraph/pregel/_messages.py

@@ -29,51 +29,16 @@ Meta = tuple[tuple[str, ...], dict[str, Any]]
 
 class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
     """A callback handler that implements stream_mode=messages.
-
-    Collects messages from:
-    (1) chat model stream events; and
-    (2) node outputs.
-    """
+    Collects messages from (1) chat model stream events and (2) node outputs."""
 
     run_inline = True
-    """We want this callback to run in the main thread to avoid order/locking issues."""
+    """We want this callback to run in the main thread, to avoid order/locking issues."""
 
-    def __init__(
-        self,
-        stream: Callable[[StreamChunk], None],
-        subgraphs: bool,
-        *,
-        parent_ns: tuple[str, ...] | None = None,
-    ) -> None:
-        """Configure the handler to stream messages from LLMs and nodes.
-
-        Args:
-            stream: A callable that takes a StreamChunk and emits it.
-            subgraphs: Whether to emit messages from subgraphs.
-            parent_ns: The namespace where the handler was created.
-                We keep track of this namespace to allow calls to subgraphs that
-                were explicitly requested as a stream with `messages` mode
-                configured.
-
-        Example:
-            parent_ns is used to handle scenarios where the subgraph is explicitly
-            streamed with `stream_mode="messages"`.
-
-            ```python
-            def parent_graph_node():
-                # This node is in the parent graph.
-                async for event in some_subgraph(..., stream_mode="messages"):
-                    do something with event # <-- these events will be emitted
-                return ...
-
-            parent_graph.invoke(subgraphs=False)
-            ```
-        """
+    def __init__(self, stream: Callable[[StreamChunk], None], subgraphs: bool):
         self.stream = stream
         self.subgraphs = subgraphs
         self.metadata: dict[UUID, Meta] = {}
         self.seen: set[int | str] = set()
-        self.parent_ns = parent_ns
 
     def _emit(self, meta: Meta, message: BaseMessage, *, dedupe: bool = False) -> None:
         if dedupe and message.id in self.seen:
@@ -135,7 +100,7 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
             ns = tuple(cast(str, metadata["langgraph_checkpoint_ns"]).split(NS_SEP))[
                 :-1
             ]
-            if not self.subgraphs and len(ns) > 0 and ns != self.parent_ns:
+            if not self.subgraphs and len(ns) > 0:
                 return
             if tags:
                 if filtered_tags := [t for t in tags if not t.startswith("seq:step")]:

libs/langgraph/langgraph/pregel/main.py

@@ -11,7 +11,7 @@ from collections.abc import AsyncIterator, Iterator, Mapping, Sequence
 from dataclasses import is_dataclass
 from functools import partial
 from inspect import isclass
-from typing import Any, Callable, Generic, Optional, Union, cast, get_type_hints
+from typing import Any, Callable, Generic, Union, cast, get_type_hints
 from uuid import UUID, uuid5
 
 from langchain_core.globals import get_debug
@@ -2534,13 +2534,8 @@ class Pregel(
                 config[CONF][CONFIG_KEY_CHECKPOINT_NS] = recast_checkpoint_ns(ns)
             # set up messages stream mode
             if "messages" in stream_modes:
-                ns_ = cast(Optional[str], config[CONF].get(CONFIG_KEY_CHECKPOINT_NS))
                 run_manager.inheritable_handlers.append(
-                    StreamMessagesHandler(
-                        stream.put,
-                        subgraphs,
-                        parent_ns=tuple(ns_.split(NS_SEP)) if ns_ else None,
-                    )
+                    StreamMessagesHandler(stream.put, subgraphs)
                 )
 
             # set up custom stream mode
@@ -2819,14 +2814,8 @@ class Pregel(
                 config[CONF][CONFIG_KEY_CHECKPOINT_NS] = recast_checkpoint_ns(ns)
             # set up messages stream mode
             if "messages" in stream_modes:
-                # namespace can be None in a root level graph?
-                ns_ = cast(Optional[str], config[CONF].get(CONFIG_KEY_CHECKPOINT_NS))
                 run_manager.inheritable_handlers.append(
-                    StreamMessagesHandler(
-                        stream_put,
-                        subgraphs,
-                        parent_ns=tuple(ns_.split(NS_SEP)) if ns_ else None,
-                    )
+                    StreamMessagesHandler(stream_put, subgraphs)
                 )
 
             # set up custom stream mode

libs/langgraph/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph"
-version = "0.6.4"
+version = "0.6.3"
 description = "Building stateful, multi-actor applications with LLMs"
 authors = []
 requires-python = ">=3.9"
@@ -49,7 +49,6 @@ dev = [
     "types-requests",
     "pycryptodome",
     "langgraph-cli[inmem]",
-    "redis",
 ]
 
 [tool.uv]

libs/langgraph/tests/compose-redis.yml

@@ -1,16 +0,0 @@
-name: langgraph-tests
-services:
-  redis-test:
-    image: redis:7-alpine
-    ports:
-      - "6379:6379"
-    command: redis-server --maxmemory 256mb --maxmemory-policy allkeys-lru
-    healthcheck:
-      test: redis-cli ping
-      start_period: 10s
-      timeout: 1s
-      retries: 5
-      interval: 5s
-      start_interval: 1s
-    tmpfs:
-      - /data  # Use tmpfs for faster testing

libs/langgraph/tests/conftest.py

@@ -3,12 +3,10 @@ from collections.abc import AsyncIterator, Iterator
 from uuid import UUID
 
 import pytest
-import redis
 from pytest_mock import MockerFixture
 
 from langgraph.cache.base import BaseCache
 from langgraph.cache.memory import InMemoryCache
-from langgraph.cache.redis import RedisCache
 from langgraph.cache.sqlite import SqliteCache
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.store.base import BaseStore
@@ -57,34 +55,12 @@ def durability(request: pytest.FixtureRequest) -> Durability:
     return request.param
 
 
-@pytest.fixture(
-    scope="function",
-    params=["sqlite", "memory"] if NO_DOCKER else ["sqlite", "memory", "redis"],
-)
+@pytest.fixture(scope="function", params=["sqlite", "memory"])
 def cache(request: pytest.FixtureRequest) -> Iterator[BaseCache]:
     if request.param == "sqlite":
         yield SqliteCache(path=":memory:")
     elif request.param == "memory":
         yield InMemoryCache()
-    elif request.param == "redis":
-        # Get worker ID for parallel test isolation
-        worker_id = getattr(request.config, "workerinput", {}).get("workerid", "master")
-        
-        redis_client = redis.Redis(
-            host="localhost", port=6379, db=0, decode_responses=False
-        )
-        # Use worker-specific prefix to avoid cache pollution between parallel tests
-        cache = RedisCache(redis_client, prefix=f"test:cache:{worker_id}:")
-        yield cache
-
-        try:
-            # Only clear keys with our specific prefix
-            pattern = f"test:cache:{worker_id}:*"
-            keys = redis_client.keys(pattern)
-            if keys:
-                redis_client.delete(*keys)
-        except Exception:
-            pass
     else:
         raise ValueError(f"Unknown cache type: {request.param}")
 

libs/langgraph/tests/test_checkpoint_migration.py

@@ -330,7 +330,6 @@ SAVED_CHECKPOINTS = {
                     "docs": ["doc1", "doc2", "doc3", "doc4"],
                     "answer": "doc1,doc2,doc3,doc4",
                 },
-                "updated_channels": None,
             },
             metadata={
                 "source": "loop",
@@ -391,7 +390,6 @@ SAVED_CHECKPOINTS = {
                     "docs": ["doc1", "doc2", "doc3", "doc4"],
                     "branch:to:qa": None,
                 },
-                "updated_channels": None,
             },
             metadata={
                 "source": "loop",
@@ -467,7 +465,6 @@ SAVED_CHECKPOINTS = {
                     "branch:to:retriever_one": None,
                     "docs": ["doc3", "doc4"],
                 },
-                "updated_channels": None,
             },
             metadata={
                 "source": "loop",
@@ -519,7 +516,6 @@ SAVED_CHECKPOINTS = {
                     "branch:to:analyzer_one": None,
                     "branch:to:retriever_two": None,
                 },
-                "updated_channels": None,
             },
             metadata={
                 "source": "loop",
@@ -574,7 +570,6 @@ SAVED_CHECKPOINTS = {
                     "query": "what is weather in sf",
                     "branch:to:rewrite_query": None,
                 },
-                "updated_channels": None,
             },
             metadata={
                 "source": "loop",
@@ -623,7 +618,6 @@ SAVED_CHECKPOINTS = {
                 },
                 "versions_seen": {"__input__": {}},
                 "channel_values": {"__start__": {"query": "what is weather in sf"}},
-                "updated_channels": None,
             },
             metadata={
                 "source": "input",

libs/langgraph/tests/test_deprecation.py

@@ -12,7 +12,6 @@ from langgraph.channels.last_value import LastValue
 from langgraph.errors import NodeInterrupt
 from langgraph.func import entrypoint, task
 from langgraph.graph import StateGraph
-from langgraph.graph.message import MessageGraph
 from langgraph.pregel import NodeBuilder, Pregel
 from langgraph.types import Interrupt, RetryPolicy
 from langgraph.warnings import LangGraphDeprecatedSinceV05, LangGraphDeprecatedSinceV10
@@ -333,11 +332,3 @@ def test_config_parameter_incorrect_typing() -> None:
 
         builder.add_node(async_node_with_untyped_config)
         assert len(w) == 0
-
-
-def test_message_graph_deprecation() -> None:
-    with pytest.warns(
-        LangGraphDeprecatedSinceV10,
-        match="MessageGraph is deprecated in LangGraph v1.0.0, to be removed in v2.0.0. Please use StateGraph with a `messages` key instead.",
-    ):
-        MessageGraph()

libs/langgraph/tests/test_large_cases.py

@@ -6,9 +6,7 @@ from dataclasses import replace
 from typing import Annotated, Any, Literal, Optional, Union, cast
 
 import pytest
-from langchain_core.messages import AIMessage, AnyMessage, ToolCall
 from langchain_core.runnables import RunnableConfig, RunnableMap, RunnablePick
-from langchain_core.tools import tool
 from pytest_mock import MockerFixture
 from syrupy import SnapshotAssertion
 from typing_extensions import TypedDict
@@ -20,7 +18,7 @@ from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.checkpoint.memory import InMemorySaver
 from langgraph.constants import END, START
 from langgraph.graph import StateGraph
-from langgraph.graph.message import MessagesState, add_messages
+from langgraph.graph.message import MessageGraph, MessagesState, add_messages
 from langgraph.prebuilt.chat_agent_executor import create_react_agent
 from langgraph.prebuilt.tool_node import ToolNode
 from langgraph.pregel import NodeBuilder, Pregel
@@ -2443,7 +2441,7 @@ def test_message_graph(
             return "continue"
 
     # Define a new graph
-    workflow = StateGraph(state_schema=Annotated[list[AnyMessage], add_messages])  # type: ignore[arg-type]
+    workflow = MessageGraph()
 
     # Define the two nodes we will cycle between
     workflow.add_node("agent", model)
@@ -2489,7 +2487,7 @@ def test_message_graph(
         assert json.dumps(app.get_graph().to_json(), indent=2) == snapshot
         assert app.get_graph().draw_mermaid(with_styles=False) == snapshot
 
-    assert app.invoke([HumanMessage(content="what is weather in sf")]) == [
+    assert app.invoke(HumanMessage(content="what is weather in sf")) == [
         _AnyIdHumanMessage(
             content="what is weather in sf",
         ),
@@ -6437,6 +6435,10 @@ def test_weather_subgraph(
     from langchain_core.language_models.fake_chat_models import (
         FakeMessagesListChatModel,
     )
+    from langchain_core.messages import AIMessage, ToolCall
+    from langchain_core.tools import tool
+
+    from langgraph.graph import MessagesState
 
     # setup subgraph
 

libs/langgraph/tests/test_large_cases_async.py

@@ -11,7 +11,7 @@ from typing import (
 )
 
 import pytest
-from langchain_core.messages import AnyMessage, ToolCall
+from langchain_core.messages import ToolCall
 from langchain_core.runnables import RunnableConfig, RunnablePick
 from pytest_mock import MockerFixture
 from typing_extensions import TypedDict
@@ -21,7 +21,7 @@ from langgraph.channels.last_value import LastValue
 from langgraph.channels.untracked_value import UntrackedValue
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.constants import END, START
-from langgraph.graph.message import add_messages
+from langgraph.graph.message import MessageGraph, add_messages
 from langgraph.graph.state import StateGraph
 from langgraph.prebuilt.chat_agent_executor import create_react_agent
 from langgraph.prebuilt.tool_node import ToolNode
@@ -2117,7 +2117,7 @@ async def test_message_graph(async_checkpointer: BaseCheckpointSaver) -> None:
             return "continue"
 
     # Define a new graph
-    workflow = StateGraph(state_schema=Annotated[list[AnyMessage], add_messages])  # type: ignore[arg-type]
+    workflow = MessageGraph()
 
     # Define the two nodes we will cycle between
     workflow.add_node("agent", model)
@@ -2157,7 +2157,7 @@ async def test_message_graph(async_checkpointer: BaseCheckpointSaver) -> None:
     # meaning you can use it as you would any other runnable
     app = workflow.compile()
 
-    assert await app.ainvoke([HumanMessage(content="what is weather in sf")]) == [
+    assert await app.ainvoke(HumanMessage(content="what is weather in sf")) == [
         _AnyIdHumanMessage(
             content="what is weather in sf",
         ),

libs/langgraph/tests/test_pregel.py

@@ -16,7 +16,6 @@ from typing import Annotated, Any, Literal, Optional, Union, get_type_hints
 
 import pytest
 from langchain_core.language_models import GenericFakeChatModel
-from langchain_core.messages import AnyMessage
 from langchain_core.runnables import (
     RunnableConfig,
     RunnableLambda,
@@ -27,7 +26,7 @@ from langsmith import traceable
 from pydantic import BaseModel, ConfigDict, Field, ValidationError
 from pytest_mock import MockerFixture
 from syrupy import SnapshotAssertion
-from typing_extensions import NotRequired, TypedDict
+from typing_extensions import TypedDict
 
 from langgraph._internal._constants import CONFIG_KEY_NODE_FINISHED, ERROR, PULL
 from langgraph.cache.base import BaseCache
@@ -46,7 +45,7 @@ from langgraph.config import get_stream_writer
 from langgraph.errors import GraphRecursionError, InvalidUpdateError, ParentCommand
 from langgraph.func import entrypoint, task
 from langgraph.graph import END, START, StateGraph
-from langgraph.graph.message import MessagesState, add_messages
+from langgraph.graph.message import MessageGraph, MessagesState, add_messages
 from langgraph.prebuilt.tool_node import ToolNode
 from langgraph.pregel import (
     NodeBuilder,
@@ -968,7 +967,6 @@ def test_pending_writes_resume(
                 "branch:to:two": AnyVersion(),
             },
             "channel_values": {"value": 6},
-            "updated_channels": ["value"],
         },
         metadata={
             "parents": {},
@@ -1016,7 +1014,6 @@ def test_pending_writes_resume(
                 "branch:to:one": None,
                 "branch:to:two": None,
             },
-            "updated_channels": ["branch:to:one", "branch:to:two", "value"],
         },
         metadata={
             "parents": {},
@@ -1068,7 +1065,6 @@ def test_pending_writes_resume(
                 "__start__": AnyVersion(),
             },
             "channel_values": {"__start__": {"value": 1}},
-            "updated_channels": ["__start__"],
         },
         metadata={
             "parents": {},
@@ -3911,7 +3907,7 @@ def test_remove_message_via_state_update(
 ) -> None:
     from langchain_core.messages import AIMessage, HumanMessage, RemoveMessage
 
-    workflow = StateGraph(state_schema=Annotated[list[AnyMessage], add_messages])  # type: ignore[arg-type]
+    workflow = MessageGraph()
     workflow.add_node(
         "chatbot",
         lambda state: [
@@ -3944,7 +3940,7 @@ def test_remove_message_via_state_update(
 def test_remove_message_from_node():
     from langchain_core.messages import AIMessage, HumanMessage, RemoveMessage
 
-    workflow = StateGraph(state_schema=Annotated[list[AnyMessage], add_messages])  # type: ignore[arg-type]
+    workflow = MessageGraph()
     workflow.add_node(
         "chatbot",
         lambda state: [
@@ -8266,53 +8262,3 @@ def test_fork_and_update_task_results(sync_checkpointer: BaseCheckpointSaver) ->
             ],
         ],
     ]
-
-
-def test_subgraph_streaming_sync() -> None:
-    """Test subgraph streaming when used as a node in sync version"""
-
-    # Create a fake chat model that returns a simple response
-    model = GenericFakeChatModel(messages=iter(["The weather is sunny today."]))
-
-    # Create a subgraph that uses the fake chat model
-    def call_model_node(state: MessagesState, config: RunnableConfig) -> MessagesState:
-        """Node that calls the model with the last message."""
-        messages = state["messages"]
-        last_message = messages[-1].content if messages else ""
-        response = model.invoke([("user", last_message)], config)
-        return {"messages": [response]}
-
-    # Build the subgraph
-    subgraph = StateGraph(MessagesState)
-    subgraph.add_node("call_model", call_model_node)
-    subgraph.add_edge(START, "call_model")
-    compiled_subgraph = subgraph.compile()
-
-    class SomeCustomState(TypedDict):
-        last_chunk: NotRequired[str]
-        num_chunks: NotRequired[int]
-
-    # Will invoke a subgraph as a function
-    def parent_node(state: SomeCustomState, config: RunnableConfig) -> dict:
-        """Node that runs the subgraph."""
-        msgs = {"messages": [("user", "What is the weather in Tokyo?")]}
-        events = []
-        for event in compiled_subgraph.stream(msgs, config, stream_mode="messages"):
-            events.append(event)
-        ai_msg_chunks = [ai_msg_chunk for ai_msg_chunk, _ in events]
-        return {
-            "last_chunk": ai_msg_chunks[-1],
-            "num_chunks": len(ai_msg_chunks),
-        }
-
-    # Build the main workflow
-    workflow = StateGraph(SomeCustomState)
-    workflow.add_node("subgraph", parent_node)
-    workflow.add_edge(START, "subgraph")
-    compiled_workflow = workflow.compile()
-
-    # Test the basic functionality
-    result = compiled_workflow.invoke({})
-
-    assert result["last_chunk"].content == "today."
-    assert result["num_chunks"] == 9

libs/langgraph/tests/test_pregel_async.py

@@ -26,7 +26,7 @@ from langchain_core.utils.aiter import aclosing
 from pydantic import BaseModel, ConfigDict, Field, ValidationError
 from pytest_mock import MockerFixture
 from syrupy import SnapshotAssertion
-from typing_extensions import NotRequired, TypedDict
+from typing_extensions import TypedDict
 
 from langgraph._internal._constants import CONFIG_KEY_NODE_FINISHED, ERROR, PULL
 from langgraph.cache.base import BaseCache
@@ -1908,7 +1908,6 @@ async def test_pending_writes_resume(
                 "branch:to:two": AnyVersion(),
             },
             "channel_values": {"value": 6},
-            "updated_channels": ["value"],
         },
         metadata={
             "parents": {},
@@ -1956,7 +1955,6 @@ async def test_pending_writes_resume(
                 "branch:to:one": None,
                 "branch:to:two": None,
             },
-            "updated_channels": ["branch:to:one", "branch:to:two", "value"],
         },
         metadata={
             "parents": {},
@@ -2004,7 +2002,6 @@ async def test_pending_writes_resume(
                 "__start__": AnyVersion(),
             },
             "channel_values": {"__start__": {"value": 1}},
-            "updated_channels": ["__start__"],
         },
         metadata={
             "parents": {},
@@ -9053,57 +9050,3 @@ async def test_fork_and_update_task_results(
             ],
         ],
     ]
-
-
-async def test_subgraph_streaming_async() -> None:
-    """Test subgraph streaming when used as a node in async version"""
-
-    # Create a fake chat model that returns a simple response
-    model = GenericFakeChatModel(messages=iter(["The weather is sunny today."]))
-
-    # Create a subgraph that uses the fake chat model
-    async def call_model_node(
-        state: MessagesState, config: RunnableConfig
-    ) -> MessagesState:
-        """Node that calls the model with the last message."""
-        messages = state["messages"]
-        last_message = messages[-1].content if messages else ""
-        response = await model.ainvoke([("user", last_message)], config)
-        return {"messages": [response]}
-
-    # Build the subgraph
-    subgraph = StateGraph(MessagesState)
-    subgraph.add_node("call_model", call_model_node)
-    subgraph.add_edge(START, "call_model")
-    compiled_subgraph = subgraph.compile()
-
-    class SomeCustomState(TypedDict):
-        last_chunk: NotRequired[str]
-        num_chunks: NotRequired[int]
-
-    # Will invoke a subgraph as a function
-    async def parent_node(state: SomeCustomState, config: RunnableConfig) -> dict:
-        """Node that runs the subgraph."""
-        msgs = {"messages": [("user", "What is the weather in Tokyo?")]}
-        events = []
-        async for event in compiled_subgraph.astream(
-            msgs, config, stream_mode="messages"
-        ):
-            events.append(event)
-        ai_msg_chunks = [ai_msg_chunk for ai_msg_chunk, _ in events]
-        return {
-            "last_chunk": ai_msg_chunks[-1],
-            "num_chunks": len(ai_msg_chunks),
-        }
-
-    # Build the main workflow
-    workflow = StateGraph(SomeCustomState)
-    workflow.add_node("subgraph", parent_node)
-    workflow.add_edge(START, "subgraph")
-    compiled_workflow = workflow.compile()
-
-    # Test the basic functionality
-    result = await compiled_workflow.ainvoke({})
-
-    assert result["last_chunk"].content == "today."
-    assert result["num_chunks"] == 9

libs/langgraph/uv.lock

@@ -119,15 +119,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/03/49/d10027df9fce941cb8184e78a02857af36360d33e1721df81c5ed2179a1a/async_lru-2.0.5-py3-none-any.whl", hash = "sha256:ab95404d8d2605310d345932697371a5f40def0487c03d6d0ad9138de52c9943", size = 6069, upload-time = "2025-03-16T17:25:35.422Z" },
 ]
 
-[[package]]
-name = "async-timeout"
-version = "5.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a5/ae/136395dfbfe00dfc94da3f3e136d0b13f394cba8f4841120e34226265780/async_timeout-5.0.1.tar.gz", hash = "sha256:d9321a7a3d5a6a5e187e824d2fa0793ce379a202935782d555d6e9d2735677d3", size = 9274, upload-time = "2024-11-06T16:41:39.6Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fe/ba/e2081de779ca30d473f21f5b30e0e737c438205440784c7dfc81efc2b029/async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c", size = 6233, upload-time = "2024-11-06T16:41:37.9Z" },
-]
-
 [[package]]
 name = "attrs"
 version = "25.3.0"
@@ -1201,7 +1192,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "0.6.4"
+version = "0.6.3"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-core" },
@@ -1234,7 +1225,6 @@ dev = [
     { name = "pytest-repeat" },
     { name = "pytest-watcher" },
     { name = "pytest-xdist", extra = ["psutil"] },
-    { name = "redis" },
     { name = "ruff" },
     { name = "syrupy" },
     { name = "types-requests" },
@@ -1273,7 +1263,6 @@ dev = [
     { name = "pytest-repeat" },
     { name = "pytest-watcher" },
     { name = "pytest-xdist", extras = ["psutil"] },
-    { name = "redis" },
     { name = "ruff" },
     { name = "syrupy" },
     { name = "types-requests" },
@@ -1282,7 +1271,7 @@ dev = [
 
 [[package]]
 name = "langgraph-api"
-version = "0.2.95"
+version = "0.2.120"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cloudpickle", marker = "python_full_version >= '3.11'" },
@@ -1305,9 +1294,9 @@ dependencies = [
     { name = "uvicorn", marker = "python_full_version >= '3.11'" },
     { name = "watchfiles", marker = "python_full_version >= '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ea/3d/5afd71e18806b71634e2178ba9e5e78a6678e0b8121158c9f458e57a8b9b/langgraph_api-0.2.95.tar.gz", hash = "sha256:7604cf276e592af00ab17642c053ced6f87122c53186256645593c7da4fbbfa3", size = 238773, upload-time = "2025-07-17T16:56:11.606Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/3d/be14b80646d62ce33452873304d53dec60844a5cff7ea81039c31abc9729/langgraph_api-0.2.120.tar.gz", hash = "sha256:78279577ad0b6a431d2b0124e5aa6dc2f2d6a557aa950ce53ce4fd53cf88f7a8", size = 243518, upload-time = "2025-08-04T18:08:53.263Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7d/17/63636946f3d5d1c59b5b0a2d936d8009860227368e8868d33c72b61dfbbb/langgraph_api-0.2.95-py3-none-any.whl", hash = "sha256:25946eef80794bf92c27daf21db4af864779677bb9f92c1bc795901d7113e9ae", size = 194381, upload-time = "2025-07-17T16:56:10.275Z" },
+    { url = "https://files.pythonhosted.org/packages/33/d3/036cedb46083411bf8d8df8e8f293a1be4c4a2de5a9d05618e6068014c2d/langgraph_api-0.2.120-py3-none-any.whl", hash = "sha256:a1e6b565c237d370f99ca73a03d66a284e6acfdfb9a20b8c51d0e18435698bb2", size = 198181, upload-time = "2025-08-04T18:08:52.044Z" },
 ]
 
 [[package]]
@@ -1337,7 +1326,6 @@ dev = [
     { name = "pytest-asyncio" },
     { name = "pytest-mock" },
     { name = "pytest-watcher" },
-    { name = "redis" },
     { name = "ruff" },
 ]
 
@@ -1406,7 +1394,7 @@ dev = [
 
 [[package]]
 name = "langgraph-cli"
-version = "0.3.6"
+version = "0.3.7"
 source = { editable = "../cli" }
 dependencies = [
     { name = "click", version = "8.1.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
@@ -1424,8 +1412,8 @@ inmem = [
 [package.metadata]
 requires-dist = [
     { name = "click", specifier = ">=8.1.7" },
-    { name = "langgraph-api", marker = "python_full_version >= '3.11' and extra == 'inmem'", specifier = ">=0.2.67,<0.3.0" },
-    { name = "langgraph-runtime-inmem", marker = "python_full_version >= '3.11' and extra == 'inmem'", specifier = ">=0.6.0" },
+    { name = "langgraph-api", marker = "python_full_version >= '3.11' and extra == 'inmem'", specifier = ">=0.2.120,<0.3.0" },
+    { name = "langgraph-runtime-inmem", marker = "python_full_version >= '3.11' and extra == 'inmem'", specifier = ">=0.6.8" },
     { name = "langgraph-sdk", marker = "python_full_version >= '3.11'", specifier = ">=0.1.0" },
     { name = "python-dotenv", marker = "extra == 'inmem'", specifier = ">=0.8.0" },
 ]
@@ -1445,7 +1433,7 @@ dev = [
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "0.6.4"
+version = "0.6.3"
 source = { editable = "../prebuilt" }
 dependencies = [
     { name = "langchain-core" },
@@ -1476,7 +1464,7 @@ dev = [
 
 [[package]]
 name = "langgraph-runtime-inmem"
-version = "0.6.0"
+version = "0.6.8"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "blockbuster", marker = "python_full_version >= '3.11'" },
@@ -1486,9 +1474,9 @@ dependencies = [
     { name = "starlette", marker = "python_full_version >= '3.11'" },
     { name = "structlog", marker = "python_full_version >= '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/04/0c/d145c6d83d36efda17b10812760711b77ec05f5bbe962c961d75b32e3c17/langgraph_runtime_inmem-0.6.0.tar.gz", hash = "sha256:b09675789a331be4a2b387c9c46de8772c4c8418e74c057b4ca24e85c25acae3", size = 77618, upload-time = "2025-07-17T16:51:01.504Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/70/af/5bb8de4f16412db4d894dafec4b83e8fcbe3e409fae2318ab95348843e8c/langgraph_runtime_inmem-0.6.8.tar.gz", hash = "sha256:7213e6c09fad509a112b9c57f7eafa99b61ff7965b5f867798fe916b5f670713", size = 79571, upload-time = "2025-07-30T22:42:01.192Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/12/6a/9dc5769b5d2f97d1feacbbf93b180c359dff7462454b37dfef8aed4ebcf7/langgraph_runtime_inmem-0.6.0-py3-none-any.whl", hash = "sha256:312dab25bec6557f1edf95cb8bd7c8bb52f7f4bfeecaf66e7001662f095c9079", size = 29317, upload-time = "2025-07-17T16:51:00.622Z" },
+    { url = "https://files.pythonhosted.org/packages/82/60/702a2704b904abf8ae0338e9bdee2ca82b67cc1fa7b5a5fcaaa8601ab310/langgraph_runtime_inmem-0.6.8-py3-none-any.whl", hash = "sha256:749dbd1897eec1c46512f5723de7133369d5076bdadb6d164ce5c70f52ad48c6", size = 30291, upload-time = "2025-07-30T22:42:00.196Z" },
 ]
 
 [[package]]
@@ -2640,18 +2628,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/51/8b/619a9ee2fa4d3c724fbadde946427735ade64da03894b071bbdc3b789d83/pyzmq-27.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:096af9e133fec3a72108ddefba1e42985cb3639e9de52cfd336b6fc23aa083e9", size = 544715, upload-time = "2025-06-13T14:09:05.579Z" },
 ]
 
-[[package]]
-name = "redis"
-version = "6.3.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "async-timeout", marker = "python_full_version < '3.11.3'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/21/cd/030274634a1a052b708756016283ea3d84e91ae45f74d7f5dcf55d753a0f/redis-6.3.0.tar.gz", hash = "sha256:3000dbe532babfb0999cdab7b3e5744bcb23e51923febcfaeb52c8cfb29632ef", size = 4647275, upload-time = "2025-08-05T08:12:31.648Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/df/a7/2fe45801534a187543fc45d28b3844d84559c1589255bc2ece30d92dc205/redis-6.3.0-py3-none-any.whl", hash = "sha256:92f079d656ded871535e099080f70fab8e75273c0236797126ac60242d638e9b", size = 280018, upload-time = "2025-08-05T08:12:30.093Z" },
-]
-
 [[package]]
 name = "referencing"
 version = "0.36.2"

libs/prebuilt/Makefile

@@ -7,11 +7,11 @@ all: help
 # TESTING AND COVERAGE
 ######################
 
-start-services:
-	docker compose -f tests/compose-postgres.yml -f tests/compose-redis.yml up -V --force-recreate --wait --remove-orphans
+start-postgres:
+	docker compose -f tests/compose-postgres.yml up -V --force-recreate --wait --remove-orphans
 
-stop-services:
-	docker compose -f tests/compose-postgres.yml -f tests/compose-redis.yml down -v
+stop-postgres:
+	docker compose -f tests/compose-postgres.yml down -v
 
 TEST ?= .
 
@@ -19,20 +19,17 @@ test-fast:
 	LANGGRAPH_TEST_FAST=1 uv run pytest $(TEST)
 
 test:
-	make start-services && LANGGRAPH_TEST_FAST=0 uv run pytest $(TEST); \
+	make start-postgres && LANGGRAPH_TEST_FAST=0 uv run pytest $(TEST); \
 	EXIT_CODE=$$?; \
-	make stop-services; \
+	make stop-postgres; \
 	exit $$EXIT_CODE
 
 test_watch:
-	make start-services && LANGGRAPH_TEST_FAST=0 uv run ptw $(TEST); \
+	make start-postgres && LANGGRAPH_TEST_FAST=0 uv run ptw $(TEST); \
 	EXIT_CODE=$$?; \
-	make stop-services; \
+	make stop-postgres; \
 	exit $$EXIT_CODE
 
-snapshot_upate:
-	LANGGRAPH_TEST_FAST=1 uv run pytest --snapshot-update $(TEST)
-
 ######################
 # LINTING AND FORMATTING
 ######################

libs/prebuilt/langgraph/prebuilt/_internal.py

@@ -0,0 +1,26 @@
+from typing import Any, Literal, TypedDict
+
+from langchain_core.messages import ToolCall
+
+
+class ToolCallWithContext(TypedDict):
+    """ToolCall with additional context for graph state.
+
+    This is an internal data-structure meant to help the ToolNode accept
+    tools calls with additional context (e.g. state) when dispatched using the
+    `Send` API.
+
+    The Send API is used in create_react_agent to be able to distribute the tool
+    calls in parallel and support human-in-the-loop workflows where graph execution
+    may be paused for an indefinite time.
+    """
+
+    tool_call: ToolCall
+    __type: Literal["tool_call_with_context"]
+    """Type to parameterize the payload.
+    
+    Using "__" as a prefix to be defensive against potential name collisions with
+    regular user state.
+    """
+    state: Any
+    """The state is provided as additional context."""

libs/prebuilt/langgraph/prebuilt/_internal/_injection.py

@@ -1,160 +0,0 @@
-from __future__ import annotations
-
-import inspect
-from dataclasses import dataclass
-from typing import Any, Optional, Callable
-
-from langchain_core.runnables import RunnableConfig
-
-from langgraph.store.base import BaseStore
-from langgraph.types import StreamWriter
-
-
-# Special type to denote any type is accepted
-ANY_TYPE = object()
-
-VALID_KINDS = (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY)
-
-
-
-# List of keyword arguments that can be injected into nodes / tasks / tools at runtime.
-# A named argument may appear multiple times if it appears with distinct types.
-KWARGS_CONFIG_KEYS: tuple[tuple[str, tuple[Any, ...], str, Any], ...] = (
-    (
-        "config",
-        (
-            RunnableConfig,
-            "RunnableConfig",
-            Optional[RunnableConfig],
-            "Optional[RunnableConfig]",
-            inspect.Parameter.empty,
-        ),
-        # for now, use config directly, eventually, will pop off of Runtime
-        "N/A",
-        inspect.Parameter.empty,
-    ),
-    (
-        "writer",
-        (StreamWriter, "StreamWriter", inspect.Parameter.empty),
-        "stream_writer",
-        lambda _: None,
-    ),
-    (
-        "store",
-        (
-            BaseStore,
-            "BaseStore",
-            inspect.Parameter.empty,
-        ),
-        "store",
-        inspect.Parameter.empty,
-    ),
-    (
-        "store",
-        (
-            Optional[BaseStore],
-            "Optional[BaseStore]",
-        ),
-        "store",
-        None,
-    ),
-    (
-        "previous",
-        (ANY_TYPE,),
-        "previous",
-        inspect.Parameter.empty,
-    ),
-    (
-        "runtime",
-        (ANY_TYPE,),
-        # we never hit this block, we just inject runtime directly
-        "N/A",
-        inspect.Parameter.empty,
-    ),
-)
-
-
-@dataclass
-class InjectionInfo:
-    """Information about which injected arguments a function supports.
-
-    Attributes:
-        func_accepts: Dictionary mapping argument names to tuples of (runtime_key, default_value)
-        supported_args: Set of argument names that the function accepts for injection
-        has_config: Whether the function accepts a 'config' argument
-        has_writer: Whether the function accepts a 'writer' argument
-        has_store: Whether the function accepts a 'store' argument
-        has_previous: Whether the function accepts a 'previous' argument
-        has_runtime: Whether the function accepts a 'runtime' argument
-    """
-
-    func_accepts: dict[str, tuple[str, Any]]
-    supported_args: set[str]
-    has_config: bool
-    has_writer: bool
-    has_store: bool
-    has_previous: bool
-    has_runtime: bool
-
-
-def get_function_injection_info(func: Callable) -> InjectionInfo:
-    """Determine which injected arguments are supported by a function.
-
-    This function analyzes a function's signature to determine which runtime arguments
-    it can accept for injection. It uses the same logic as RunnableCallable to check
-    parameter names, types, and annotations against the supported injection types.
-
-    Args:
-        func: The function to analyze for injection support
-
-    Returns:
-        InjectionInfo containing details about which arguments the function supports
-
-    Example:
-        ```python
-        def my_tool(x: int, config: RunnableConfig, store: BaseStore) -> str:
-            return f"x={x}, config={config is not None}, store={store is not None}"
-
-        info = get_function_injection_info(my_tool)
-        print(info.has_config)  # True
-        print(info.has_store)   # True
-        print(info.has_writer)  # False
-        print(info.supported_args)  # {'config', 'store'}
-        ```
-    """
-    func_accepts: dict[str, tuple[str, Any]] = {}
-    params = inspect.signature(func).parameters
-
-    for kw, typ, runtime_key, default in KWARGS_CONFIG_KEYS:
-        p = params.get(kw)
-
-        if p is None or p.kind not in VALID_KINDS:
-            # If parameter is not found or is not a valid kind, skip
-            continue
-
-        if typ != (ANY_TYPE,) and p.annotation not in typ:
-            # A specific type is required, but the function annotation does
-            # not match the expected type.
-
-            # If this is a config parameter with incorrect typing, we still accept it
-            # but could emit a warning (following RunnableCallable behavior)
-            if kw == "config" and p.annotation != inspect.Parameter.empty:
-                # Could add warning here if needed
-                pass
-            else:
-                continue
-
-        # If the kwarg is accepted by the function, store the key / runtime attribute to inject
-        func_accepts[kw] = (runtime_key, default)
-
-    supported_args = set(func_accepts.keys())
-
-    return InjectionInfo(
-        func_accepts=func_accepts,
-        supported_args=supported_args,
-        has_config="config" in supported_args,
-        has_writer="writer" in supported_args,
-        has_store="store" in supported_args,
-        has_previous="previous" in supported_args,
-        has_runtime="runtime" in supported_args,
-    )

libs/prebuilt/langgraph/prebuilt/tool_node.py

@@ -31,8 +31,6 @@ Typical Usage:
     ```
 """
 
-from __future__ import annotations
-
 import asyncio
 import inspect
 import json
@@ -76,6 +74,7 @@ from typing_extensions import Annotated, get_args, get_origin
 from langgraph._internal._runnable import RunnableCallable
 from langgraph.errors import GraphBubbleUp
 from langgraph.graph.message import REMOVE_ALL_MESSAGES
+from langgraph.prebuilt._internal import ToolCallWithContext
 from langgraph.store.base import BaseStore
 from langgraph.types import Command, Send
 
@@ -239,50 +238,17 @@ def _infer_handled_types(handler: Callable[..., str]) -> tuple[type[Exception],
 
 
 class ToolNode(RunnableCallable):
-    """A node for executing tools in LangGraph workflows.
+    """A node that runs the tools called in the last AIMessage.
 
-    Handles tool execution patterns including function calls, state injection,
-    persistent storage, and control flow. Manages parallel execution,
-    error handling.
+    It can be used either in StateGraph with a "messages" state key (or a custom key passed via ToolNode's 'messages_key').
+    If multiple tool calls are requested, they will be run in parallel. The output will be
+    a list of ToolMessages, one for each tool call.
 
-    Input Formats:
-        1. Graph state with `messages` key that has a list of messages:
-           - Common representation for agentic workflows
-           - Supports custom messages key via ``messages_key`` parameter
-
-        2. **Message List**: ``[AIMessage(..., tool_calls=[...])]``
-           - List of messages with tool calls in the last AIMessage
-
-        3. **Direct Tool Calls**: ``[{"name": "tool", "args": {...}, "id": "1", "type": "tool_call"}]``
-           - Bypasses message parsing for direct tool execution
-           - For programmatic tool invocation and testing
-
-    Tool Types:
-        1. **Regular tools**: Functions or BaseTool instances that return values or
-            Commands.
-        2. **Structured output tools**: Pydantic model classes for schema-validated
-           responses
-
-    Output Formats:
-        Output format depends on input type and tool behavior:
-
-        **For Regular tools**:
-        - Dict input → ``{"messages": [ToolMessage(...)]}``
-        - List input → ``[ToolMessage(...)]``
-
-        **For Command tools**:
-        - Returns ``[Command(...)]`` or mixed list with regular tool outputs
-        - Commands can update state, trigger navigation, or send messages
-
-        **For Structured output tools**:
-        - Returns ``[Command(update={"messages": [...], "structured_response": schema_instance})]``
-        - Includes both message and structured data in the graph state
+    Tool calls can also be passed directly as a list of `ToolCall` dicts.
 
     Args:
-        tools: A sequence of tools that can be invoked by this node. Supports:
-            - **BaseTool instances**: Tools with schemas and metadata
-            - **Plain functions**: Automatically converted to tools with inferred schemas
-            - **Pydantic model classes**: Treated as structured output tools
+        tools: A sequence of tools that can be invoked by this node. Tools can be
+            BaseTool instances or plain functions that will be converted to tools.
         name: The name identifier for this node in the graph. Used for debugging
             and visualization. Defaults to "tools".
         tags: Optional metadata tags to associate with the node for filtering
@@ -290,24 +256,21 @@ class ToolNode(RunnableCallable):
         handle_tool_errors: Configuration for error handling during tool execution.
             Defaults to True. Supports multiple strategies:
 
-            - **True**: Catch all errors and return a ToolMessage with the default
+            - True: Catch all errors and return a ToolMessage with the default
               error template containing the exception details.
-            - **str**: Catch all errors and return a ToolMessage with this custom
+            - str: Catch all errors and return a ToolMessage with this custom
               error message string.
-            - **tuple[type[Exception], ...]**: Only catch exceptions with the specified
+            - tuple[type[Exception], ...]: Only catch exceptions of the specified
               types and return default error messages for them.
-            - **Callable[..., str]**: Catch exceptions matching the callable's signature
+            - Callable[..., str]: Catch exceptions matching the callable's signature
               and return the string result of calling it with the exception.
-            - **False**: Disable error handling entirely, allowing exceptions to
-              propagate.
+            - False: Disable error handling entirely, allowing exceptions to propagate.
 
         messages_key: The key in the state dictionary that contains the message list.
-            This same key will be used for the output ToolMessages.
-            Defaults to "messages".
-            Allows custom state schemas with different message field names.
+            This same key will be used for the output ToolMessages. Defaults to "messages".
 
-    Examples:
-        Basic usage:
+    Example:
+        Basic usage with simple tools:
 
         ```python
         from langgraph.prebuilt import ToolNode
@@ -321,35 +284,42 @@ class ToolNode(RunnableCallable):
         tool_node = ToolNode([calculator])
         ```
 
-        State injection:
+        Custom error handling:
 
         ```python
-        from typing_extensions import Annotated
-        from langgraph.prebuilt import InjectedState
+        def handle_math_errors(e: ZeroDivisionError) -> str:
+            return "Cannot divide by zero!"
 
-        @tool
-        def context_tool(query: str, state: Annotated[dict, InjectedState]) -> str:
-            \"\"\"Some tool that uses state.\"\"\"
-            return f"Query: {query}, Messages: {len(state['messages'])}"
-
-        tool_node = ToolNode([context_tool])
+        tool_node = ToolNode([calculator], handle_tool_errors=handle_math_errors)
         ```
 
-        Error handling:
+        Direct tool call execution:
 
         ```python
-        def handle_errors(e: ValueError) -> str:
-            return "Invalid input provided"
-
-        tool_node = ToolNode([my_tool], handle_tool_errors=handle_errors)
+        tool_calls = [{"name": "calculator", "args": {"a": 5, "b": 3}, "id": "1", "type": "tool_call"}]
+        result = tool_node.invoke(tool_calls)
         ```
+
+    Note:
+        The ToolNode expects input in one of three formats:
+        1. A dictionary with a messages key containing a list of messages
+        2. A list of messages directly
+        3. A list of tool call dictionaries
+
+        When using message formats, the last message must be an AIMessage with
+        tool_calls populated. The node automatically extracts and processes these
+        tool calls concurrently.
+
+        For advanced use cases involving state injection or store access, tools
+        can be annotated with InjectedState or InjectedStore to receive graph
+        context automatically.
     """
 
-    name: str = "tools"
+    name: str = "ToolNode"
 
     def __init__(
         self,
-        tools: Sequence[Union[BaseTool, BaseModel, Callable]],
+        tools: Sequence[Union[BaseTool, Callable]],
         *,
         name: str = "tools",
         tags: Optional[list[str]] = None,
@@ -368,36 +338,17 @@ class ToolNode(RunnableCallable):
             messages_key: State key containing messages.
         """
         super().__init__(self._func, self._afunc, name=name, tags=tags, trace=False)
-        self._tools_by_name: dict[str, BaseTool] = {}
-        self._structured_output_tools_by_name: dict[str, type[BaseModel]] = {}
-        self._tool_to_state_args: dict[str, dict[str, Optional[str]]] = {}
-        self._tool_to_store_arg: dict[str, Optional[str]] = {}
-        self._handle_tool_errors = handle_tool_errors
-        self._messages_key = messages_key
-        for tool in tools:
-            if inspect.isclass(tool) and issubclass(tool, BaseModel):
-                # Handle Pydantic model classes as structured output tools
-                self._structured_output_tools_by_name[tool.__name__] = tool
-                self._tool_to_state_args[tool.__name__] = {}
-                self._tool_to_store_arg[tool.__name__] = None
-            else:
-                if not isinstance(tool, BaseTool):
-                    tool_ = create_tool(cast(Type[BaseTool], tool))
-                else:
-                    tool_ = tool
-                self._tools_by_name[tool_.name] = tool_
-                self._tool_to_state_args[tool_.name] = _get_state_args(tool_)
-                self._tool_to_store_arg[tool_.name] = _get_store_arg(tool_)
-
-    @property
-    def tools_by_name(self) -> dict[str, BaseTool]:
-        """Mapping from tool name to BaseTool instance."""
-        return self._tools_by_name
-
-    @property
-    def structured_output_tools(self) -> dict[str, type[BaseModel]]:
-        """Mapping from structured output tool name to Pydantic model class."""
-        return self._structured_output_tools_by_name
+        self.tools_by_name: dict[str, BaseTool] = {}
+        self.tool_to_state_args: dict[str, dict[str, Optional[str]]] = {}
+        self.tool_to_store_arg: dict[str, Optional[str]] = {}
+        self.handle_tool_errors = handle_tool_errors
+        self.messages_key = messages_key
+        for tool_ in tools:
+            if not isinstance(tool_, BaseTool):
+                tool_ = create_tool(tool_)
+            self.tools_by_name[tool_.name] = tool_
+            self.tool_to_state_args[tool_.name] = _get_state_args(tool_)
+            self.tool_to_store_arg[tool_.name] = _get_store_arg(tool_)
 
     def _func(
         self,
@@ -410,7 +361,8 @@ class ToolNode(RunnableCallable):
         *,
         store: Optional[BaseStore],
     ) -> Any:
-        tool_calls, input_type = self._parse_input(input, store)
+        tool_calls, input_type = self._parse_input(input)
+        tool_calls = [self.inject_tool_args(call, input, store) for call in tool_calls]
         config_list = get_config_list(config, len(tool_calls))
         input_types = [input_type] * len(tool_calls)
         with get_executor_for_config(config) as executor:
@@ -431,7 +383,8 @@ class ToolNode(RunnableCallable):
         *,
         store: Optional[BaseStore],
     ) -> Any:
-        tool_calls, input_type = self._parse_input(input, store)
+        tool_calls, input_type = self._parse_input(input)
+        tool_calls = [self.inject_tool_args(call, input, store) for call in tool_calls]
         outputs = await asyncio.gather(
             *(self._arun_one(call, input_type, config) for call in tool_calls)
         )
@@ -440,14 +393,14 @@ class ToolNode(RunnableCallable):
 
     def _combine_tool_outputs(
         self,
-        outputs: list[Union[ToolMessage, Command]],
+        outputs: list[ToolMessage],
         input_type: Literal["list", "dict", "tool_calls"],
     ) -> list[Union[Command, list[ToolMessage], dict[str, list[ToolMessage]]]]:
         # preserve existing behavior for non-command tool outputs for backwards
         # compatibility
         if not any(isinstance(output, Command) for output in outputs):
             # TypedDict, pydantic, dataclass, etc. should all be able to load from dict
-            return outputs if input_type == "list" else {self._messages_key: outputs}
+            return outputs if input_type == "list" else {self.messages_key: outputs}
 
         # LangGraph will automatically handle list of Command and non-command node
         # updates
@@ -475,7 +428,7 @@ class ToolNode(RunnableCallable):
                     combined_outputs.append(output)
             else:
                 combined_outputs.append(
-                    [output] if input_type == "list" else {self._messages_key: [output]}
+                    [output] if input_type == "list" else {self.messages_key: [output]}
                 )
 
         if parent_command:
@@ -487,31 +440,13 @@ class ToolNode(RunnableCallable):
         call: ToolCall,
         input_type: Literal["list", "dict", "tool_calls"],
         config: RunnableConfig,
-    ) -> Union[ToolMessage, Command]:
+    ) -> ToolMessage:
         """Run a single tool call synchronously."""
         if invalid_tool_message := self._validate_tool_call(call):
             return invalid_tool_message
-
-        # Handle structured output tools
-        if call["name"] in self.structured_output_tools:
-            response_schema = self._structured_output_tools_by_name[call["name"]]
-            return Command(
-                update={
-                    "messages": [
-                        ToolMessage(
-                            content="ok!",
-                            name=call["name"],
-                            tool_call_id=call["id"],
-                        )
-                    ],
-                    "structured_response": response_schema(**call["args"]),
-                }
-            )
-
         try:
             call_args = {**call, **{"type": "tool_call"}}
-            tool = self.tools_by_name[call["name"]]
-            response = tool.invoke(call_args, config)
+            response = self.tools_by_name[call["name"]].invoke(call_args, config)
 
         # GraphInterrupt is a special exception that will always be raised.
         # It can be triggered in the following scenarios,
@@ -523,20 +458,20 @@ class ToolNode(RunnableCallable):
         except GraphBubbleUp as e:
             raise e
         except Exception as e:
-            if isinstance(self._handle_tool_errors, tuple):
-                handled_types: tuple = self._handle_tool_errors
-            elif callable(self._handle_tool_errors):
-                handled_types = _infer_handled_types(self._handle_tool_errors)
+            if isinstance(self.handle_tool_errors, tuple):
+                handled_types: tuple = self.handle_tool_errors
+            elif callable(self.handle_tool_errors):
+                handled_types = _infer_handled_types(self.handle_tool_errors)
             else:
                 # default behavior is catching all exceptions
                 handled_types = (Exception,)
 
             # Unhandled
-            if not self._handle_tool_errors or not isinstance(e, handled_types):
+            if not self.handle_tool_errors or not isinstance(e, handled_types):
                 raise e
             # Handled
             else:
-                content = _handle_tool_error(e, flag=self._handle_tool_errors)
+                content = _handle_tool_error(e, flag=self.handle_tool_errors)
             return ToolMessage(
                 content=content,
                 name=call["name"],
@@ -561,55 +496,38 @@ class ToolNode(RunnableCallable):
         call: ToolCall,
         input_type: Literal["list", "dict", "tool_calls"],
         config: RunnableConfig,
-    ) -> Union[ToolMessage, Command]:
+    ) -> ToolMessage:
         """Run a single tool call asynchronously."""
         if invalid_tool_message := self._validate_tool_call(call):
             return invalid_tool_message
 
-        # Handle structured output tools
-        if call["name"] in self.structured_output_tools:
-            response_schema = self._structured_output_tools_by_name[call["name"]]
-            return Command(
-                update={
-                    "messages": [
-                        ToolMessage(
-                            content="ok!",
-                            name=call["name"],
-                            tool_call_id=call["id"],
-                        )
-                    ],
-                    "structured_response": response_schema(**call["args"]),
-                }
-            )
-
         try:
-            call_args = {**call, **{"type": "tool_call"}}
-            tool = self.tools_by_name[call["name"]]
-            response = await tool.ainvoke(call_args, config)
+            input = {**call, **{"type": "tool_call"}}
+            response = await self.tools_by_name[call["name"]].ainvoke(input, config)
+
         # GraphInterrupt is a special exception that will always be raised.
-        # It can be triggered in the following scenarios,
-        # Where GraphInterrupt(GraphBubbleUp) is raised from an `interrupt` invocation most commonly:
-        # (1) a GraphInterrupt is raised inside a tool
-        # (2) a GraphInterrupt is raised inside a graph node for a graph called as a tool
+        # It can be triggered in the following scenarios:
+        # (1) a NodeInterrupt is raised inside a tool
+        # (2) a NodeInterrupt is raised inside a graph node for a graph called as a tool
         # (3) a GraphInterrupt is raised when a subgraph is interrupted inside a graph called as a tool
         # (2 and 3 can happen in a "supervisor w/ tools" multi-agent architecture)
         except GraphBubbleUp as e:
             raise e
         except Exception as e:
-            if isinstance(self._handle_tool_errors, tuple):
-                handled_types: tuple = self._handle_tool_errors
-            elif callable(self._handle_tool_errors):
-                handled_types = _infer_handled_types(self._handle_tool_errors)
+            if isinstance(self.handle_tool_errors, tuple):
+                handled_types: tuple = self.handle_tool_errors
+            elif callable(self.handle_tool_errors):
+                handled_types = _infer_handled_types(self.handle_tool_errors)
             else:
                 # default behavior is catching all exceptions
                 handled_types = (Exception,)
 
             # Unhandled
-            if not self._handle_tool_errors or not isinstance(e, handled_types):
+            if not self.handle_tool_errors or not isinstance(e, handled_types):
                 raise e
             # Handled
             else:
-                content = _handle_tool_error(e, flag=self._handle_tool_errors)
+                content = _handle_tool_error(e, flag=self.handle_tool_errors)
 
             return ToolMessage(
                 content=content,
@@ -637,7 +555,6 @@ class ToolNode(RunnableCallable):
             dict[str, Any],
             BaseModel,
         ],
-        store: Optional[BaseStore],
     ) -> Tuple[list[ToolCall], Literal["list", "dict", "tool_calls"]]:
         input_type: Literal["list", "dict", "tool_calls"]
         if isinstance(input, list):
@@ -648,11 +565,18 @@ class ToolNode(RunnableCallable):
             else:
                 input_type = "list"
                 messages = input
-        elif isinstance(input, dict) and (
-            messages := input.get(self._messages_key, [])
+        elif (
+            isinstance(input, dict) and input.get("__type") == "tool_call_with_context"
         ):
+            # mypy will not be able to type narrow correctly since the signature
+            # for input contains dict[str, Any]. We'd need to type dict[str, Any]
+            # before we can apply correct typing.
+            input = cast(ToolCallWithContext, input)  # type: ignore[assignment]
+            input_type = "tool_calls"
+            return [input["tool_call"]], input_type
+        elif isinstance(input, dict) and (messages := input.get(self.messages_key, [])):
             input_type = "dict"
-        elif messages := getattr(input, self._messages_key, []):
+        elif messages := getattr(input, self.messages_key, []):
             # Assume dataclass-like state that can coerce from dict
             input_type = "dict"
         else:
@@ -665,24 +589,14 @@ class ToolNode(RunnableCallable):
         except StopIteration:
             raise ValueError("No AIMessage found in input")
 
-        tool_calls = [
-            self.inject_tool_args(call, input, store)
-            for call in latest_ai_message.tool_calls
-        ]
+        tool_calls = [call for call in latest_ai_message.tool_calls]
         return tool_calls, input_type
 
     def _validate_tool_call(self, call: ToolCall) -> Optional[ToolMessage]:
-        requested_tool = call["name"]
-        if (
-            requested_tool not in self.tools_by_name
-            and requested_tool not in self._structured_output_tools_by_name
-        ):
-            all_tool_names = list(self.tools_by_name.keys()) + list(
-                self._structured_output_tools_by_name.keys()
-            )
+        if (requested_tool := call["name"]) not in self.tools_by_name:
             content = INVALID_TOOL_NAME_ERROR_TEMPLATE.format(
                 requested_tool=requested_tool,
-                available_tools=", ".join(all_tool_names),
+                available_tools=", ".join(self.tools_by_name.keys()),
             )
             return ToolMessage(
                 content, name=requested_tool, tool_call_id=call["id"], status="error"
@@ -699,15 +613,15 @@ class ToolNode(RunnableCallable):
             BaseModel,
         ],
     ) -> ToolCall:
-        state_args = self._tool_to_state_args[tool_call["name"]]
+        state_args = self.tool_to_state_args[tool_call["name"]]
         if state_args and isinstance(input, list):
             required_fields = list(state_args.values())
             if (
                 len(required_fields) == 1
-                and required_fields[0] == self._messages_key
+                and required_fields[0] == self.messages_key
                 or required_fields[0] is None
             ):
-                input = {self._messages_key: input}
+                input = {self.messages_key: input}
             else:
                 err_msg = (
                     f"Invalid input to ToolNode. Tool {tool_call['name']} requires "
@@ -718,14 +632,19 @@ class ToolNode(RunnableCallable):
                     err_msg += f" State should contain fields {required_fields_str}."
                 raise ValueError(err_msg)
 
-        if isinstance(input, dict):
+        if isinstance(input, dict) and input.get("__type") == "tool_call_with_context":
+            state = input["state"]
+        else:
+            state = input
+
+        if isinstance(state, dict):
             tool_state_args = {
-                tool_arg: input[state_field] if state_field else input
+                tool_arg: state[state_field] if state_field else state
                 for tool_arg, state_field in state_args.items()
             }
         else:
             tool_state_args = {
-                tool_arg: getattr(input, state_field) if state_field else input
+                tool_arg: getattr(state, state_field) if state_field else state
                 for tool_arg, state_field in state_args.items()
             }
 
@@ -738,7 +657,7 @@ class ToolNode(RunnableCallable):
     def _inject_store(
         self, tool_call: ToolCall, store: Optional[BaseStore]
     ) -> ToolCall:
-        store_arg = self._tool_to_store_arg[tool_call["name"]]
+        store_arg = self.tool_to_store_arg[tool_call["name"]]
         if not store_arg:
             return tool_call
 
@@ -797,10 +716,7 @@ class ToolNode(RunnableCallable):
             The injection is performed on a copy of the tool call to avoid mutating
             the original.
         """
-        if (
-            tool_call["name"] not in self.tools_by_name
-            and tool_call["name"] not in self._structured_output_tools_by_name
-        ):
+        if tool_call["name"] not in self.tools_by_name:
             return tool_call
 
         tool_call_copy: ToolCall = copy(tool_call)
@@ -818,15 +734,15 @@ class ToolNode(RunnableCallable):
             # input type is dict when ToolNode is invoked with a dict input (e.g. {"messages": [AIMessage(..., tool_calls=[...])]})
             if input_type not in ("dict", "tool_calls"):
                 raise ValueError(
-                    f"Tools can provide a dict in Command.update only when using dict with '{self._messages_key}' key as ToolNode input, "
+                    f"Tools can provide a dict in Command.update only when using dict with '{self.messages_key}' key as ToolNode input, "
                     f"got: {command.update} for tool '{call['name']}'"
                 )
 
             updated_command = deepcopy(command)
             state_update = cast(dict[str, Any], updated_command.update) or {}
-            messages_update = state_update.get(self._messages_key, [])
+            messages_update = state_update.get(self.messages_key, [])
         elif isinstance(command.update, list):
-            # Input type is list when ToolNode is invoked with a list input (e.g. [AIMessage(..., tool_calls=[...])])
+            # input type is list when ToolNode is invoked with a list input (e.g. [AIMessage(..., tool_calls=[...])])
             if input_type != "list":
                 raise ValueError(
                     f"Tools can provide a list of messages in Command.update only when using list of messages as ToolNode input, "
@@ -886,6 +802,7 @@ def tools_condition(
 
     Args:
         state: The current graph state to examine for tool calls. Supported formats:
+            - List of messages (for MessageGraph)
             - Dictionary containing a messages key (for StateGraph)
             - BaseModel instance with a messages attribute
         messages_key: The key or attribute name containing the message list in the state.

libs/prebuilt/langgraph/prebuilt/tool_validator.py

@@ -2,7 +2,8 @@
 in a langchain graph. It applies a pydantic schema to tool_calls in the models' outputs,
 and returns a ToolMessage with the validated content. If the schema is not valid, it
 returns a ToolMessage with the error message. The ValidationNode can be used in a
-StateGraph with a "messages" key. If multiple tool calls are requested, they will be run in parallel.
+StateGraph with a "messages" key or in a MessageGraph. If multiple tool calls are
+requested, they will be run in parallel.
 """
 
 from typing import (
@@ -48,7 +49,7 @@ def _default_format_error(
 class ValidationNode(RunnableCallable):
     """A node that validates all tools requests from the last AIMessage.
 
-    It can be used either in StateGraph with a "messages" key.
+    It can be used either in StateGraph with a "messages" key or in MessageGraph.
 
     !!! note
 

libs/prebuilt/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph-prebuilt"
-version = "0.6.4"
+version = "0.6.3"
 description = "Library with high-level APIs for creating and executing LangGraph agents and tools."
 authors = []
 requires-python = ">=3.9"

libs/prebuilt/tests/__snapshots__/test_react_agent_graph.ambr

@@ -171,191 +171,3 @@
   
   '''
 # ---
-# name: test_react_agent_graph_structure_with_individual_nodes[no_response_format-no_post_hook-no_pre_hook-no_tools]
-  '''
-  graph TD;
-  	__start__ --> agent;
-  	agent --> __end__;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[no_response_format-no_post_hook-no_pre_hook-two_tools]
-  '''
-  graph TD;
-  	__start__ --> agent;
-  	agent -.-> __end__;
-  	agent -.-> tool;
-  	agent -.-> tool2;
-  	tool --> agent;
-  	tool2 --> agent;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[no_response_format-no_post_hook-with_pre_hook-no_tools]
-  '''
-  graph TD;
-  	__start__ --> pre_model_hook;
-  	pre_model_hook --> agent;
-  	agent --> __end__;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[no_response_format-no_post_hook-with_pre_hook-two_tools]
-  '''
-  graph TD;
-  	__start__ --> pre_model_hook;
-  	agent -.-> __end__;
-  	agent -.-> tool;
-  	agent -.-> tool2;
-  	pre_model_hook --> agent;
-  	tool --> pre_model_hook;
-  	tool2 --> pre_model_hook;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[no_response_format-with_post_hook-no_pre_hook-no_tools]
-  '''
-  graph TD;
-  	__start__ --> agent;
-  	agent --> post_model_hook;
-  	post_model_hook --> __end__;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[no_response_format-with_post_hook-no_pre_hook-two_tools]
-  '''
-  graph TD;
-  	__start__ --> agent;
-  	agent --> post_model_hook;
-  	post_model_hook -.-> __end__;
-  	post_model_hook -.-> agent;
-  	post_model_hook -.-> tool;
-  	post_model_hook -.-> tool2;
-  	tool --> agent;
-  	tool2 --> agent;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[no_response_format-with_post_hook-with_pre_hook-no_tools]
-  '''
-  graph TD;
-  	__start__ --> pre_model_hook;
-  	agent --> post_model_hook;
-  	pre_model_hook --> agent;
-  	post_model_hook --> __end__;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[no_response_format-with_post_hook-with_pre_hook-two_tools]
-  '''
-  graph TD;
-  	__start__ --> pre_model_hook;
-  	agent --> post_model_hook;
-  	post_model_hook -.-> __end__;
-  	post_model_hook -.-> pre_model_hook;
-  	post_model_hook -.-> tool;
-  	post_model_hook -.-> tool2;
-  	pre_model_hook --> agent;
-  	tool --> pre_model_hook;
-  	tool2 --> pre_model_hook;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[with_response_format-no_post_hook-no_pre_hook-no_tools]
-  '''
-  graph TD;
-  	__start__ --> agent;
-  	agent --> generate_structured_response;
-  	generate_structured_response --> __end__;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[with_response_format-no_post_hook-no_pre_hook-two_tools]
-  '''
-  graph TD;
-  	__start__ --> agent;
-  	agent -.-> generate_structured_response;
-  	agent -.-> tool;
-  	agent -.-> tool2;
-  	tool --> agent;
-  	tool2 --> agent;
-  	generate_structured_response --> __end__;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[with_response_format-no_post_hook-with_pre_hook-no_tools]
-  '''
-  graph TD;
-  	__start__ --> pre_model_hook;
-  	agent --> generate_structured_response;
-  	pre_model_hook --> agent;
-  	generate_structured_response --> __end__;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[with_response_format-no_post_hook-with_pre_hook-two_tools]
-  '''
-  graph TD;
-  	__start__ --> pre_model_hook;
-  	agent -.-> generate_structured_response;
-  	agent -.-> tool;
-  	agent -.-> tool2;
-  	pre_model_hook --> agent;
-  	tool --> pre_model_hook;
-  	tool2 --> pre_model_hook;
-  	generate_structured_response --> __end__;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[with_response_format-with_post_hook-no_pre_hook-no_tools]
-  '''
-  graph TD;
-  	__start__ --> agent;
-  	agent --> post_model_hook;
-  	post_model_hook --> generate_structured_response;
-  	generate_structured_response --> __end__;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[with_response_format-with_post_hook-no_pre_hook-two_tools]
-  '''
-  graph TD;
-  	__start__ --> agent;
-  	agent --> post_model_hook;
-  	post_model_hook -.-> agent;
-  	post_model_hook -.-> generate_structured_response;
-  	post_model_hook -.-> tool;
-  	post_model_hook -.-> tool2;
-  	tool --> agent;
-  	tool2 --> agent;
-  	generate_structured_response --> __end__;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[with_response_format-with_post_hook-with_pre_hook-no_tools]
-  '''
-  graph TD;
-  	__start__ --> pre_model_hook;
-  	agent --> post_model_hook;
-  	post_model_hook --> generate_structured_response;
-  	pre_model_hook --> agent;
-  	generate_structured_response --> __end__;
-  
-  '''
-# ---
-# name: test_react_agent_graph_structure_with_individual_nodes[with_response_format-with_post_hook-with_pre_hook-two_tools]
-  '''
-  graph TD;
-  	__start__ --> pre_model_hook;
-  	agent --> post_model_hook;
-  	post_model_hook -.-> generate_structured_response;
-  	post_model_hook -.-> pre_model_hook;
-  	post_model_hook -.-> tool;
-  	post_model_hook -.-> tool2;
-  	pre_model_hook --> agent;
-  	tool --> pre_model_hook;
-  	tool2 --> pre_model_hook;
-  	generate_structured_response --> __end__;
-  
-  '''
-# ---

libs/prebuilt/tests/compose-redis.yml

@@ -1,16 +0,0 @@
-name: langgraph-tests-redis
-services:
-  redis-test:
-    image: redis:7-alpine
-    ports:
-      - "6379:6379"
-    command: redis-server --maxmemory 256mb --maxmemory-policy allkeys-lru
-    healthcheck:
-      test: redis-cli ping
-      start_period: 10s
-      timeout: 1s
-      retries: 5
-      interval: 5s
-      start_interval: 1s
-    tmpfs:
-      - /data  # Use tmpfs for faster testing

libs/prebuilt/tests/test_deprecation.py

@@ -31,11 +31,3 @@ def test_config_schema_deprecation() -> None:
         match="`get_config_jsonschema` is deprecated. Use `get_context_jsonschema` instead.",
     ):
         assert agent.get_config_jsonschema() is not None
-
-
-def test_extra_kwargs_deprecation() -> None:
-    with pytest.raises(
-        TypeError,
-        match="create_react_agent\(\) got unexpected keyword arguments: \{'extra': 'extra'\}",
-    ):
-        create_react_agent(FakeToolCallingModel(), [], extra="extra")

libs/prebuilt/tests/test_react_agent.py

@@ -1,9 +1,14 @@
 import dataclasses
 import inspect
+import json
+from functools import partial
 from typing import (
     Annotated,
+    List,
     Literal,
     Optional,
+    Type,
+    TypeVar,
     Union,
 )
 
@@ -11,6 +16,7 @@ import pytest
 from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import (
     AIMessage,
+    AnyMessage,
     HumanMessage,
     MessageLikeRepresentation,
     RemoveMessage,
@@ -18,18 +24,21 @@ from langchain_core.messages import (
     ToolCall,
     ToolMessage,
 )
-from langchain_core.runnables import RunnableConfig, RunnableLambda
+from langchain_core.runnables import RunnableLambda
 from langchain_core.tools import InjectedToolCallId, ToolException
 from langchain_core.tools import tool as dec_tool
 from pydantic import BaseModel, Field
+from pydantic.v1 import BaseModel as BaseModelV1
 from typing_extensions import TypedDict
 
 from langgraph.checkpoint.base import BaseCheckpointSaver
-from langgraph.graph import START, MessagesState, StateGraph
+from langgraph.config import get_stream_writer
+from langgraph.graph import START, MessagesState, StateGraph, add_messages
 from langgraph.graph.message import REMOVE_ALL_MESSAGES
 from langgraph.prebuilt import (
     ToolNode,
     create_react_agent,
+    tools_condition,
 )
 from langgraph.prebuilt.chat_agent_executor import (
     AgentState,
@@ -175,7 +184,7 @@ def test_runnable_prompt():
 
 
 @pytest.mark.parametrize("version", REACT_TOOL_CALL_VERSIONS)
-def test_prompt_with_store(version: Literal["v1", "v2"]):
+def test_prompt_with_store(version: str):
     def add(a: int, b: int):
         """Adds a and b"""
         return a + b
@@ -645,6 +654,124 @@ def test_react_agent_parallel_tool_calls(
         assert get_weather_execution_count == 1
 
 
+class _InjectStateSchema(TypedDict):
+    messages: list
+    foo: str
+
+
+class _InjectedStatePydanticSchema(BaseModelV1):
+    messages: list
+    foo: str
+
+
+class _InjectedStatePydanticV2Schema(BaseModel):
+    messages: list
+    foo: str
+
+
+@dataclasses.dataclass
+class _InjectedStateDataclassSchema:
+    messages: list
+    foo: str
+
+
+T = TypeVar("T")
+
+
+@pytest.mark.parametrize(
+    "schema_",
+    [
+        _InjectStateSchema,
+        _InjectedStatePydanticSchema,
+        _InjectedStatePydanticV2Schema,
+        _InjectedStateDataclassSchema,
+    ],
+)
+def test_tool_node_inject_state(schema_: Type[T]) -> None:
+    def tool1(some_val: int, state: Annotated[T, InjectedState]) -> str:
+        """Tool 1 docstring."""
+        if isinstance(state, dict):
+            return state["foo"]
+        else:
+            return getattr(state, "foo")
+
+    def tool2(some_val: int, state: Annotated[T, InjectedState()]) -> str:
+        """Tool 2 docstring."""
+        if isinstance(state, dict):
+            return state["foo"]
+        else:
+            return getattr(state, "foo")
+
+    def tool3(
+        some_val: int,
+        foo: Annotated[str, InjectedState("foo")],
+        msgs: Annotated[List[AnyMessage], InjectedState("messages")],
+    ) -> str:
+        """Tool 1 docstring."""
+        return foo
+
+    def tool4(
+        some_val: int, msgs: Annotated[List[AnyMessage], InjectedState("messages")]
+    ) -> str:
+        """Tool 1 docstring."""
+        return msgs[0].content
+
+    node = ToolNode([tool1, tool2, tool3, tool4])
+    for tool_name in ("tool1", "tool2", "tool3"):
+        tool_call = {
+            "name": tool_name,
+            "args": {"some_val": 1},
+            "id": "some 0",
+            "type": "tool_call",
+        }
+        msg = AIMessage("hi?", tool_calls=[tool_call])
+        result = node.invoke(schema_(**{"messages": [msg], "foo": "bar"}))
+        tool_message = result["messages"][-1]
+        assert tool_message.content == "bar", f"Failed for tool={tool_name}"
+
+        if tool_name == "tool3":
+            failure_input = None
+            try:
+                failure_input = schema_(**{"messages": [msg], "notfoo": "bar"})
+            except Exception:
+                pass
+            if failure_input is not None:
+                with pytest.raises(KeyError):
+                    node.invoke(failure_input)
+
+                with pytest.raises(ValueError):
+                    node.invoke([msg])
+        else:
+            failure_input = None
+            try:
+                failure_input = schema_(**{"messages": [msg], "notfoo": "bar"})
+            except Exception:
+                # We'd get a validation error from pydantic state and wouldn't make it to the node
+                # anyway
+                pass
+            if failure_input is not None:
+                messages_ = node.invoke(failure_input)
+                tool_message = messages_["messages"][-1]
+                assert "KeyError" in tool_message.content
+                tool_message = node.invoke([msg])[-1]
+                assert "KeyError" in tool_message.content
+
+    tool_call = {
+        "name": "tool4",
+        "args": {"some_val": 1},
+        "id": "some 0",
+        "type": "tool_call",
+    }
+    msg = AIMessage("hi?", tool_calls=[tool_call])
+    result = node.invoke(schema_(**{"messages": [msg], "foo": ""}))
+    tool_message = result["messages"][-1]
+    assert tool_message.content == "hi?"
+
+    result = node.invoke([msg])
+    tool_message = result[-1]
+    assert tool_message.content == "hi?"
+
+
 class AgentStateExtraKey(AgentState):
     foo: int
 
@@ -653,24 +780,14 @@ class AgentStateExtraKeyPydantic(AgentStatePydantic):
     foo: int
 
 
-@pytest.mark.parametrize("version", ["v1", "v2"])
+@pytest.mark.parametrize("version", REACT_TOOL_CALL_VERSIONS)
 @pytest.mark.parametrize(
     "state_schema", [AgentStateExtraKey, AgentStateExtraKeyPydantic]
 )
-@pytest.mark.parametrize(
-    "use_individual_tool_nodes",
-    [False, True],
-    ids=["single_tool_node", "node_per_tool"],
-)
 def test_create_react_agent_inject_vars(
-    version: Literal["v1", "v2"],
-    state_schema: StateSchemaType,
-    use_individual_tool_nodes: bool,
+    version: Literal["v1", "v2"], state_schema: StateSchemaType
 ) -> None:
     """Test that the agent can inject state and store into tool functions."""
-    if version == "v1" and use_individual_tool_nodes:
-        pytest.skip("v1 does not support individual tool nodes")
-
     store = InMemoryStore()
     namespace = ("test",)
     store.put(namespace, "test_key", {"bar": 3})
@@ -709,7 +826,6 @@ def test_create_react_agent_inject_vars(
         state_schema=state_schema,
         store=store,
         version=version,
-        use_individual_tool_nodes=use_individual_tool_nodes,
     )
     result = agent.invoke({"messages": [{"role": "user", "content": "hi"}], "foo": 2})
     assert result["messages"] == [
@@ -721,18 +837,137 @@ def test_create_react_agent_inject_vars(
     assert result["foo"] == 2
 
 
-@pytest.mark.parametrize("version", REACT_TOOL_CALL_VERSIONS)
-@pytest.mark.parametrize(
-    "use_individual_tool_nodes",
-    [False, True],
-    ids=["single_tool_node", "node_per_tool"],
-)
-async def test_return_direct(
-    version: Literal["v1", "v2"], use_individual_tool_nodes: bool
-) -> None:
-    if version == "v1" and use_individual_tool_nodes:
-        pytest.skip("v1 does not support individual tool nodes")
+def test_tool_node_inject_store() -> None:
+    store = InMemoryStore()
+    namespace = ("test",)
 
+    def tool1(some_val: int, store: Annotated[BaseStore, InjectedStore()]) -> str:
+        """Tool 1 docstring."""
+        store_val = store.get(namespace, "test_key").value["foo"]
+        return f"Some val: {some_val}, store val: {store_val}"
+
+    def tool2(some_val: int, store: Annotated[BaseStore, InjectedStore()]) -> str:
+        """Tool 2 docstring."""
+        store_val = store.get(namespace, "test_key").value["foo"]
+        return f"Some val: {some_val}, store val: {store_val}"
+
+    def tool3(
+        some_val: int,
+        bar: Annotated[str, InjectedState("bar")],
+        store: Annotated[BaseStore, InjectedStore()],
+    ) -> str:
+        """Tool 3 docstring."""
+        store_val = store.get(namespace, "test_key").value["foo"]
+        return f"Some val: {some_val}, store val: {store_val}, state val: {bar}"
+
+    node = ToolNode([tool1, tool2, tool3], handle_tool_errors=True)
+    store.put(namespace, "test_key", {"foo": "bar"})
+
+    class State(MessagesState):
+        bar: str
+
+    builder = StateGraph(State)
+    builder.add_node("tools", node)
+    builder.add_edge(START, "tools")
+    graph = builder.compile(store=store)
+
+    for tool_name in ("tool1", "tool2"):
+        tool_call = {
+            "name": tool_name,
+            "args": {"some_val": 1},
+            "id": "some 0",
+            "type": "tool_call",
+        }
+        msg = AIMessage("hi?", tool_calls=[tool_call])
+        node_result = node.invoke({"messages": [msg]}, store=store)
+        graph_result = graph.invoke({"messages": [msg]})
+        for result in (node_result, graph_result):
+            result["messages"][-1]
+            tool_message = result["messages"][-1]
+            assert tool_message.content == "Some val: 1, store val: bar", (
+                f"Failed for tool={tool_name}"
+            )
+
+    tool_call = {
+        "name": "tool3",
+        "args": {"some_val": 1},
+        "id": "some 0",
+        "type": "tool_call",
+    }
+    msg = AIMessage("hi?", tool_calls=[tool_call])
+    node_result = node.invoke({"messages": [msg], "bar": "baz"}, store=store)
+    graph_result = graph.invoke({"messages": [msg], "bar": "baz"})
+    for result in (node_result, graph_result):
+        result["messages"][-1]
+        tool_message = result["messages"][-1]
+        assert tool_message.content == "Some val: 1, store val: bar, state val: baz", (
+            f"Failed for tool={tool_name}"
+        )
+
+    # test injected store without passing store to compiled graph
+    failing_graph = builder.compile()
+    with pytest.raises(ValueError):
+        failing_graph.invoke({"messages": [msg], "bar": "baz"})
+
+
+def test_tool_node_ensure_utf8() -> None:
+    @dec_tool
+    def get_day_list(days: list[str]) -> list[str]:
+        """choose days"""
+        return days
+
+    data = ["星期一", "水曜日", "목요일", "Friday"]
+    tools = [get_day_list]
+    tool_calls = [ToolCall(name=get_day_list.name, args={"days": data}, id="test_id")]
+    outputs: list[ToolMessage] = ToolNode(tools).invoke(
+        [AIMessage(content="", tool_calls=tool_calls)]
+    )
+    assert outputs[0].content == json.dumps(data, ensure_ascii=False)
+
+
+def test_tool_node_messages_key() -> None:
+    @dec_tool
+    def add(a: int, b: int):
+        """Adds a and b."""
+        return a + b
+
+    model = FakeToolCallingModel(
+        tool_calls=[[ToolCall(name=add.name, args={"a": 1, "b": 2}, id="test_id")]]
+    )
+
+    class State(TypedDict):
+        subgraph_messages: Annotated[list[AnyMessage], add_messages]
+
+    def call_model(state: State):
+        response = model.invoke(state["subgraph_messages"])
+        model.tool_calls = []
+        return {"subgraph_messages": response}
+
+    builder = StateGraph(State)
+    builder.add_node("agent", call_model)
+    builder.add_node("tools", ToolNode([add], messages_key="subgraph_messages"))
+    builder.add_conditional_edges(
+        "agent", partial(tools_condition, messages_key="subgraph_messages")
+    )
+    builder.add_edge(START, "agent")
+    builder.add_edge("tools", "agent")
+
+    graph = builder.compile()
+    result = graph.invoke({"subgraph_messages": [HumanMessage(content="hi")]})
+    assert result["subgraph_messages"] == [
+        _AnyIdHumanMessage(content="hi"),
+        AIMessage(
+            content="hi",
+            id="0",
+            tool_calls=[ToolCall(name=add.name, args={"a": 1, "b": 2}, id="test_id")],
+        ),
+        _AnyIdToolMessage(content="3", name=add.name, tool_call_id="test_id"),
+        AIMessage(content="hi-hi-3", id="1"),
+    ]
+
+
+@pytest.mark.parametrize("version", REACT_TOOL_CALL_VERSIONS)
+async def test_return_direct(version: str) -> None:
     @dec_tool(return_direct=True)
     def tool_return_direct(input: str) -> str:
         """A tool that returns directly."""
@@ -760,7 +995,6 @@ async def test_return_direct(
         model,
         [tool_return_direct, tool_normal],
         version=version,
-        use_individual_tool_nodes=use_individual_tool_nodes,
     )
 
     # Test direct return for tool_return_direct
@@ -854,27 +1088,15 @@ def test__get_state_args() -> None:
 
 
 def test_inspect_react() -> None:
-    """Test that we can inspect the agent and its nodes."""
     model = FakeToolCallingModel(tool_calls=[])
     agent = create_react_agent(model, [])
     inspect.getclosurevars(agent.nodes["agent"].bound.func)
 
 
 @pytest.mark.parametrize("version", REACT_TOOL_CALL_VERSIONS)
-@pytest.mark.parametrize(
-    "use_individual_tool_nodes",
-    [False, True],
-    ids=["single_tool_node", "node_per_tool"],
-)
 def test_react_with_subgraph_tools(
-    sync_checkpointer: BaseCheckpointSaver,
-    version: Literal["v1", "v2"],
-    use_individual_tool_nodes: bool,
+    sync_checkpointer: BaseCheckpointSaver, version: Literal["v1", "v2"]
 ) -> None:
-    """Test React agent with subgraph tools."""
-    if version == "v1" and use_individual_tool_nodes:
-        pytest.skip("v1 does not support individual tool nodes")
-
     class State(TypedDict):
         a: int
         b: int
@@ -930,7 +1152,6 @@ def test_react_with_subgraph_tools(
         tool_node,
         checkpointer=sync_checkpointer,
         version=version,
-        use_individual_tool_nodes=use_individual_tool_nodes,
     )
     result = agent.invoke(
         {"messages": [HumanMessage(content="What's 2 + 3 and 2 * 3?")]},
@@ -961,198 +1182,58 @@ def test_react_with_subgraph_tools(
     ]
 
 
-@pytest.mark.parametrize("version", REACT_TOOL_CALL_VERSIONS)
-@pytest.mark.parametrize(
-    "use_individual_tool_nodes",
-    [False, True],
-    ids=["single_tool_node", "node_per_tool"],
-)
-def test_react_agent_subgraph_streaming_sync(
-    version: Literal["v1", "v2"], use_individual_tool_nodes: bool
-) -> None:
-    """Test React agent streaming when used as a subgraph node sync version"""
-    if version == "v1" and use_individual_tool_nodes:
-        pytest.skip("v1 does not support individual tool nodes")
-
+def test_tool_node_stream_writer() -> None:
     @dec_tool
-    def get_weather(city: str) -> str:
-        """Get the weather of a city."""
-        return f"The weather of {city} is sunny."
+    def streaming_tool(x: int) -> str:
+        """Do something with writer."""
+        my_writer = get_stream_writer()
+        for value in ["foo", "bar", "baz"]:
+            my_writer({"custom_tool_value": value})
 
-    # Create a React agent
-    model = FakeToolCallingModel(
-        tool_calls=[
-            [{"args": {"city": "Tokyo"}, "id": "1", "name": "get_weather"}],
-            [],
-        ]
+        return x
+
+    tool_node = ToolNode([streaming_tool])
+    graph = (
+        StateGraph(MessagesState)
+        .add_node("tools", tool_node)
+        .add_edge(START, "tools")
+        .compile()
     )
 
-    agent = create_react_agent(
-        model,
-        tools=[get_weather],
-        prompt="You are a helpful travel assistant.",
-        version=version,
-        use_individual_tool_nodes=use_individual_tool_nodes,
-    )
+    tool_call = {
+        "name": "streaming_tool",
+        "args": {"x": 1},
+        "id": "1",
+        "type": "tool_call",
+    }
+    inputs = {
+        "messages": [AIMessage("", tool_calls=[tool_call])],
+    }
 
-    # Create a subgraph that uses the React agent as a node
-    def react_agent_node(state: MessagesState, config: RunnableConfig) -> MessagesState:
-        """Node that runs the React agent and collects streaming output."""
-        collected_content = ""
-
-        # Stream the agent output and collect content
-        for msg_chunk, msg_metadata in agent.stream(
-            {"messages": [("user", state["messages"][-1].content)]},
-            config,
-            stream_mode="messages",
-        ):
-            if hasattr(msg_chunk, "content") and msg_chunk.content:
-                collected_content += msg_chunk.content
-
-        return {"messages": [("assistant", collected_content)]}
-
-    # Create the main workflow with the React agent as a subgraph node
-    workflow = StateGraph(MessagesState)
-    workflow.add_node("react_agent", react_agent_node)
-    workflow.add_edge(START, "react_agent")
-    workflow.add_edge("react_agent", "__end__")
-    compiled_workflow = workflow.compile()
-
-    # Test the streaming functionality
-    result = compiled_workflow.invoke(
-        {"messages": [("user", "What is the weather in Tokyo?")]}
-    )
-
-    # Verify the result contains expected structure
-    assert len(result["messages"]) == 2
-    assert result["messages"][0].content == "What is the weather in Tokyo?"
-    assert "assistant" in str(result["messages"][1])
-
-    # Test streaming with subgraphs = True
-    result = compiled_workflow.invoke(
-        {"messages": [("user", "What is the weather in Tokyo?")]},
-        subgraphs=True,
-    )
-    assert len(result["messages"]) == 2
-
-    events = []
-    for event in compiled_workflow.stream(
-        {"messages": [("user", "What is the weather in Tokyo?")]},
-        stream_mode="messages",
-        subgraphs=False,
-    ):
-        events.append(event)
-
-    assert len(events) == 0
-
-    events = []
-    for event in compiled_workflow.stream(
-        {"messages": [("user", "What is the weather in Tokyo?")]},
-        stream_mode="messages",
-        subgraphs=True,
-    ):
-        events.append(event)
-
-    assert len(events) == 3
-    namespace, (msg, metadata) = events[0]
-    # FakeToolCallingModel returns a single AIMessage with tool calls
-    # The content of the AIMessage reflects the input message
-    assert msg.content.startswith("You are a helpful travel assistant")
-    namespace, (msg, metadata) = events[1]  # ToolMessage
-    assert msg.content.startswith("The weather of Tokyo is sunny.")
-
-
-@pytest.mark.parametrize("version", REACT_TOOL_CALL_VERSIONS)
-async def test_react_agent_subgraph_streaming(version: Literal["v1", "v2"]) -> None:
-    """Test React agent streaming when used as a subgraph node."""
-
-    @dec_tool
-    def get_weather(city: str) -> str:
-        """Get the weather of a city."""
-        return f"The weather of {city} is sunny."
-
-    # Create a React agent
-    model = FakeToolCallingModel(
-        tool_calls=[
-            [{"args": {"city": "Tokyo"}, "id": "1", "name": "get_weather"}],
-            [],
-        ]
-    )
-
-    agent = create_react_agent(
-        model,
-        tools=[get_weather],
-        prompt="You are a helpful travel assistant.",
-        version=version,
-    )
-
-    # Create a subgraph that uses the React agent as a node
-    async def react_agent_node(
-        state: MessagesState, config: RunnableConfig
-    ) -> MessagesState:
-        """Node that runs the React agent and collects streaming output."""
-        collected_content = ""
-
-        # Stream the agent output and collect content
-        async for msg_chunk, msg_metadata in agent.astream(
-            {"messages": [("user", state["messages"][-1].content)]},
-            config,
-            stream_mode="messages",
-        ):
-            if hasattr(msg_chunk, "content") and msg_chunk.content:
-                collected_content += msg_chunk.content
-
-        return {"messages": [("assistant", collected_content)]}
-
-    # Create the main workflow with the React agent as a subgraph node
-    workflow = StateGraph(MessagesState)
-    workflow.add_node("react_agent", react_agent_node)
-    workflow.add_edge(START, "react_agent")
-    workflow.add_edge("react_agent", "__end__")
-    compiled_workflow = workflow.compile()
-
-    # Test the streaming functionality
-    result = await compiled_workflow.ainvoke(
-        {"messages": [("user", "What is the weather in Tokyo?")]}
-    )
-
-    # Verify the result contains expected structure
-    assert len(result["messages"]) == 2
-    assert result["messages"][0].content == "What is the weather in Tokyo?"
-    assert "assistant" in str(result["messages"][1])
-
-    # Test streaming with subgraphs = True
-    result = await compiled_workflow.ainvoke(
-        {"messages": [("user", "What is the weather in Tokyo?")]},
-        subgraphs=True,
-    )
-    assert len(result["messages"]) == 2
-
-    events = []
-    async for event in compiled_workflow.astream(
-        {"messages": [("user", "What is the weather in Tokyo?")]},
-        stream_mode="messages",
-        subgraphs=False,
-    ):
-        events.append(event)
-
-    assert len(events) == 0
-
-    events = []
-    async for event in compiled_workflow.astream(
-        {"messages": [("user", "What is the weather in Tokyo?")]},
-        stream_mode="messages",
-        subgraphs=True,
-    ):
-        events.append(event)
-
-    assert len(events) == 3
-    namespace, (msg, metadata) = events[0]
-    # FakeToolCallingModel returns a single AIMessage with tool calls
-    # The content of the AIMessage reflects the input message
-    assert msg.content.startswith("You are a helpful travel assistant")
-    namespace, (msg, metadata) = events[1]  # ToolMessage
-    assert msg.content.startswith("The weather of Tokyo is sunny.")
+    assert list(graph.stream(inputs, stream_mode="custom")) == [
+        {"custom_tool_value": "foo"},
+        {"custom_tool_value": "bar"},
+        {"custom_tool_value": "baz"},
+    ]
+    assert list(graph.stream(inputs, stream_mode=["custom", "updates"])) == [
+        ("custom", {"custom_tool_value": "foo"}),
+        ("custom", {"custom_tool_value": "bar"}),
+        ("custom", {"custom_tool_value": "baz"}),
+        (
+            "updates",
+            {
+                "tools": {
+                    "messages": [
+                        _AnyIdToolMessage(
+                            content="1",
+                            name="streaming_tool",
+                            tool_call_id="1",
+                        ),
+                    ],
+                },
+            },
+        ),
+    ]
 
 
 @pytest.mark.parametrize("version", REACT_TOOL_CALL_VERSIONS)

libs/prebuilt/tests/test_react_agent_graph.py

@@ -15,11 +15,6 @@ def tool() -> None:
     ...
 
 
-def tool2() -> None:
-    """Another testing tool."""
-    ...
-
-
 def pre_model_hook() -> None:
     """Pre-model hook."""
     ...
@@ -54,44 +49,4 @@ def test_react_agent_graph_structure(
         post_model_hook=post_model_hook,
         response_format=response_format,
     )
-    try:
-        assert agent.get_graph().draw_mermaid(with_styles=False) == snapshot
-    except Exception as e:
-        raise ValueError(
-            "The graph structure has changed. Please update the snapshot."
-            "Configuration used:\n"
-            f"tools: {tools}, "
-            f"pre_model_hook: {pre_model_hook}, "
-            f"post_model_hook: {post_model_hook}, "
-            f"response_format: {response_format}"
-        ) from e
-
-
-@pytest.mark.parametrize("tools", [[], [tool, tool2]], ids=["no_tools", "two_tools"])
-@pytest.mark.parametrize(
-    "pre_model_hook", [None, pre_model_hook], ids=["no_pre_hook", "with_pre_hook"]
-)
-@pytest.mark.parametrize(
-    "post_model_hook", [None, post_model_hook], ids=["no_post_hook", "with_post_hook"]
-)
-@pytest.mark.parametrize(
-    "response_format",
-    [None, ResponseFormat],
-    ids=["no_response_format", "with_response_format"],
-)
-def test_react_agent_graph_structure_with_individual_nodes(
-    snapshot: SnapshotAssertion,
-    tools: list[Callable],
-    pre_model_hook: Union[Callable, None],
-    post_model_hook: Union[Callable, None],
-    response_format: Union[type[BaseModel], None],
-) -> None:
-    agent = create_react_agent(
-        model,
-        tools=tools,
-        pre_model_hook=pre_model_hook,
-        post_model_hook=post_model_hook,
-        response_format=response_format,
-        use_individual_tool_nodes=True,
-    )
     assert agent.get_graph().draw_mermaid(with_styles=False) == snapshot

libs/prebuilt/tests/test_tool_node.py

@@ -1,49 +1,25 @@
-import dataclasses
-import json
-from functools import partial
 from typing import (
     Annotated,
     Any,
-    List,
-    Type,
-    TypeVar,
     Union,
 )
 
 import pytest
 from langchain_core.messages import (
     AIMessage,
-    AnyMessage,
-    HumanMessage,
     RemoveMessage,
-    ToolCall,
     ToolMessage,
 )
 from langchain_core.tools import BaseTool, ToolException
 from langchain_core.tools import tool as dec_tool
 from pydantic import BaseModel, ValidationError
-from pydantic.v1 import BaseModel as BaseModelV1
 from pydantic.v1 import ValidationError as ValidationErrorV1
-from typing_extensions import TypedDict
 
-from langgraph.config import get_stream_writer
 from langgraph.errors import GraphBubbleUp, GraphInterrupt
-from langgraph.graph import START, MessagesState, StateGraph
-from langgraph.graph.message import REMOVE_ALL_MESSAGES, add_messages
-from langgraph.prebuilt import (
-    ToolNode,
-)
-from langgraph.prebuilt.tool_node import (
-    TOOL_CALL_ERROR_TEMPLATE,
-    InjectedState,
-    InjectedStore,
-    tools_condition,
-)
-from langgraph.store.base import BaseStore
-from langgraph.store.memory import InMemoryStore
+from langgraph.graph.message import REMOVE_ALL_MESSAGES
+from langgraph.prebuilt import ToolNode
+from langgraph.prebuilt.tool_node import TOOL_CALL_ERROR_TEMPLATE
 from langgraph.types import Command, Send
-from tests.messages import _AnyIdHumanMessage, _AnyIdToolMessage
-from tests.model import FakeToolCallingModel
 
 pytestmark = pytest.mark.anyio
 
@@ -86,8 +62,7 @@ def tool5(some_val: int):
 tool5.handle_tool_error = "foo"
 
 
-async def test_tool_node() -> None:
-    """Test tool node."""
+async def test_tool_node():
     result = ToolNode([tool1]).invoke(
         {
             "messages": [
@@ -179,7 +154,7 @@ async def test_tool_node() -> None:
     assert tool_message.tool_call_id == "some 3"
 
 
-async def test_tool_node_tool_call_input() -> None:
+async def test_tool_node_tool_call_input():
     # Single tool call
     tool_call_1 = {
         "name": "tool1",
@@ -220,7 +195,7 @@ async def test_tool_node_tool_call_input() -> None:
     ]
 
 
-async def test_tool_node_error_handling() -> None:
+async def test_tool_node_error_handling():
     def handle_all(e: Union[ValueError, ToolException, ValidationError]):
         return TOOL_CALL_ERROR_TEMPLATE.format(error=repr(e))
 
@@ -282,7 +257,7 @@ async def test_tool_node_error_handling() -> None:
         assert result_error["messages"][2].tool_call_id == "another id"
 
 
-async def test_tool_node_error_handling_callable() -> None:
+async def test_tool_node_error_handling_callable():
     def handle_value_error(e: ValueError):
         return "Value error"
 
@@ -1181,395 +1156,3 @@ async def test_tool_node_command_remove_all_messages():
     command = result[0]
     assert isinstance(command, Command)
     assert command.update == {"messages": [RemoveMessage(id=REMOVE_ALL_MESSAGES)]}
-
-
-class _InjectStateSchema(TypedDict):
-    messages: list
-    foo: str
-
-
-class _InjectedStatePydanticSchema(BaseModelV1):
-    messages: list
-    foo: str
-
-
-class _InjectedStatePydanticV2Schema(BaseModel):
-    messages: list
-    foo: str
-
-
-@dataclasses.dataclass
-class _InjectedStateDataclassSchema:
-    messages: list
-    foo: str
-
-
-T = TypeVar("T")
-
-
-@pytest.mark.parametrize(
-    "schema_",
-    [
-        _InjectStateSchema,
-        _InjectedStatePydanticSchema,
-        _InjectedStatePydanticV2Schema,
-        _InjectedStateDataclassSchema,
-    ],
-)
-def test_tool_node_inject_state(schema_: Type[T]) -> None:
-    def tool1(some_val: int, state: Annotated[T, InjectedState]) -> str:
-        """Tool 1 docstring."""
-        if isinstance(state, dict):
-            return state["foo"]
-        else:
-            return getattr(state, "foo")
-
-    def tool2(some_val: int, state: Annotated[T, InjectedState()]) -> str:
-        """Tool 2 docstring."""
-        if isinstance(state, dict):
-            return state["foo"]
-        else:
-            return getattr(state, "foo")
-
-    def tool3(
-        some_val: int,
-        foo: Annotated[str, InjectedState("foo")],
-        msgs: Annotated[List[AnyMessage], InjectedState("messages")],
-    ) -> str:
-        """Tool 1 docstring."""
-        return foo
-
-    def tool4(
-        some_val: int, msgs: Annotated[List[AnyMessage], InjectedState("messages")]
-    ) -> str:
-        """Tool 1 docstring."""
-        return msgs[0].content
-
-    node = ToolNode([tool1, tool2, tool3, tool4])
-    for tool_name in ("tool1", "tool2", "tool3"):
-        tool_call = {
-            "name": tool_name,
-            "args": {"some_val": 1},
-            "id": "some 0",
-            "type": "tool_call",
-        }
-        msg = AIMessage("hi?", tool_calls=[tool_call])
-        result = node.invoke(schema_(**{"messages": [msg], "foo": "bar"}))
-        tool_message = result["messages"][-1]
-        assert tool_message.content == "bar", f"Failed for tool={tool_name}"
-
-        if tool_name == "tool3":
-            failure_input = None
-            try:
-                failure_input = schema_(**{"messages": [msg], "notfoo": "bar"})
-            except Exception:
-                pass
-            if failure_input is not None:
-                with pytest.raises(KeyError):
-                    node.invoke(failure_input)
-
-                with pytest.raises(ValueError):
-                    node.invoke([msg])
-        else:
-            failure_input = None
-            try:
-                failure_input = schema_(**{"messages": [msg], "notfoo": "bar"})
-            except Exception:
-                # We'd get a validation error from pydantic state and wouldn't make it to the node
-                # anyway
-                pass
-            if failure_input is not None:
-                messages_ = node.invoke(failure_input)
-                tool_message = messages_["messages"][-1]
-                assert "KeyError" in tool_message.content
-                tool_message = node.invoke([msg])[-1]
-                assert "KeyError" in tool_message.content
-
-    tool_call = {
-        "name": "tool4",
-        "args": {"some_val": 1},
-        "id": "some 0",
-        "type": "tool_call",
-    }
-    msg = AIMessage("hi?", tool_calls=[tool_call])
-    result = node.invoke(schema_(**{"messages": [msg], "foo": ""}))
-    tool_message = result["messages"][-1]
-    assert tool_message.content == "hi?"
-
-    result = node.invoke([msg])
-    tool_message = result[-1]
-    assert tool_message.content == "hi?"
-
-
-def test_tool_node_inject_store() -> None:
-    store = InMemoryStore()
-    namespace = ("test",)
-
-    def tool1(some_val: int, store: Annotated[BaseStore, InjectedStore()]) -> str:
-        """Tool 1 docstring."""
-        store_val = store.get(namespace, "test_key").value["foo"]
-        return f"Some val: {some_val}, store val: {store_val}"
-
-    def tool2(some_val: int, store: Annotated[BaseStore, InjectedStore()]) -> str:
-        """Tool 2 docstring."""
-        store_val = store.get(namespace, "test_key").value["foo"]
-        return f"Some val: {some_val}, store val: {store_val}"
-
-    def tool3(
-        some_val: int,
-        bar: Annotated[str, InjectedState("bar")],
-        store: Annotated[BaseStore, InjectedStore()],
-    ) -> str:
-        """Tool 3 docstring."""
-        store_val = store.get(namespace, "test_key").value["foo"]
-        return f"Some val: {some_val}, store val: {store_val}, state val: {bar}"
-
-    node = ToolNode([tool1, tool2, tool3], handle_tool_errors=True)
-    store.put(namespace, "test_key", {"foo": "bar"})
-
-    class State(MessagesState):
-        bar: str
-
-    builder = StateGraph(State)
-    builder.add_node("tools", node)
-    builder.add_edge(START, "tools")
-    graph = builder.compile(store=store)
-
-    for tool_name in ("tool1", "tool2"):
-        tool_call = {
-            "name": tool_name,
-            "args": {"some_val": 1},
-            "id": "some 0",
-            "type": "tool_call",
-        }
-        msg = AIMessage("hi?", tool_calls=[tool_call])
-        node_result = node.invoke({"messages": [msg]}, store=store)
-        graph_result = graph.invoke({"messages": [msg]})
-        for result in (node_result, graph_result):
-            result["messages"][-1]
-            tool_message = result["messages"][-1]
-            assert tool_message.content == "Some val: 1, store val: bar", (
-                f"Failed for tool={tool_name}"
-            )
-
-    tool_call = {
-        "name": "tool3",
-        "args": {"some_val": 1},
-        "id": "some 0",
-        "type": "tool_call",
-    }
-    msg = AIMessage("hi?", tool_calls=[tool_call])
-    node_result = node.invoke({"messages": [msg], "bar": "baz"}, store=store)
-    graph_result = graph.invoke({"messages": [msg], "bar": "baz"})
-    for result in (node_result, graph_result):
-        result["messages"][-1]
-        tool_message = result["messages"][-1]
-        assert tool_message.content == "Some val: 1, store val: bar, state val: baz", (
-            f"Failed for tool={tool_name}"
-        )
-
-    # test injected store without passing store to compiled graph
-    failing_graph = builder.compile()
-    with pytest.raises(ValueError):
-        failing_graph.invoke({"messages": [msg], "bar": "baz"})
-
-
-def test_tool_node_ensure_utf8() -> None:
-    @dec_tool
-    def get_day_list(days: list[str]) -> list[str]:
-        """choose days"""
-        return days
-
-    data = ["星期一", "水曜日", "목요일", "Friday"]
-    tools = [get_day_list]
-    tool_calls = [ToolCall(name=get_day_list.name, args={"days": data}, id="test_id")]
-    outputs: list[ToolMessage] = ToolNode(tools).invoke(
-        [AIMessage(content="", tool_calls=tool_calls)]
-    )
-    assert outputs[0].content == json.dumps(data, ensure_ascii=False)
-
-
-def test_tool_node_messages_key() -> None:
-    @dec_tool
-    def add(a: int, b: int):
-        """Adds a and b."""
-        return a + b
-
-    model = FakeToolCallingModel(
-        tool_calls=[[ToolCall(name=add.name, args={"a": 1, "b": 2}, id="test_id")]]
-    )
-
-    class State(TypedDict):
-        subgraph_messages: Annotated[list[AnyMessage], add_messages]
-
-    def call_model(state: State):
-        response = model.invoke(state["subgraph_messages"])
-        model.tool_calls = []
-        return {"subgraph_messages": response}
-
-    builder = StateGraph(State)
-    builder.add_node("agent", call_model)
-    builder.add_node("tools", ToolNode([add], messages_key="subgraph_messages"))
-    builder.add_conditional_edges(
-        "agent", partial(tools_condition, messages_key="subgraph_messages")
-    )
-    builder.add_edge(START, "agent")
-    builder.add_edge("tools", "agent")
-
-    graph = builder.compile()
-    result = graph.invoke({"subgraph_messages": [HumanMessage(content="hi")]})
-    assert result["subgraph_messages"] == [
-        _AnyIdHumanMessage(content="hi"),
-        AIMessage(
-            content="hi",
-            id="0",
-            tool_calls=[ToolCall(name=add.name, args={"a": 1, "b": 2}, id="test_id")],
-        ),
-        _AnyIdToolMessage(content="3", name=add.name, tool_call_id="test_id"),
-        AIMessage(content="hi-hi-3", id="1"),
-    ]
-
-
-def test_tool_node_stream_writer() -> None:
-    @dec_tool
-    def streaming_tool(x: int) -> str:
-        """Do something with writer."""
-        my_writer = get_stream_writer()
-        for value in ["foo", "bar", "baz"]:
-            my_writer({"custom_tool_value": value})
-
-        return x
-
-    tool_node = ToolNode([streaming_tool])
-    graph = (
-        StateGraph(MessagesState)
-        .add_node("tools", tool_node)
-        .add_edge(START, "tools")
-        .compile()
-    )
-
-    tool_call = {
-        "name": "streaming_tool",
-        "args": {"x": 1},
-        "id": "1",
-        "type": "tool_call",
-    }
-    inputs = {
-        "messages": [AIMessage("", tool_calls=[tool_call])],
-    }
-
-    assert list(graph.stream(inputs, stream_mode="custom")) == [
-        {"custom_tool_value": "foo"},
-        {"custom_tool_value": "bar"},
-        {"custom_tool_value": "baz"},
-    ]
-    assert list(graph.stream(inputs, stream_mode=["custom", "updates"])) == [
-        ("custom", {"custom_tool_value": "foo"}),
-        ("custom", {"custom_tool_value": "bar"}),
-        ("custom", {"custom_tool_value": "baz"}),
-        (
-            "updates",
-            {
-                "tools": {
-                    "messages": [
-                        _AnyIdToolMessage(
-                            content="1",
-                            name="streaming_tool",
-                            tool_call_id="1",
-                        ),
-                    ],
-                },
-            },
-        ),
-    ]
-
-
-def test_structured_output_tools_sync() -> None:
-    """Test that ToolNode handles Pydantic model classes as structured output tools."""
-
-    class OutputSchema(BaseModel):
-        name: str
-        age: int
-        location: str
-
-    tool_node = ToolNode([OutputSchema])
-
-    # Test that the structured output tool is registered correctly
-    assert "OutputSchema" in tool_node.structured_output_tools
-
-    # Create a tool call that matches the schema
-    tool_call = {
-        "name": "OutputSchema",
-        "args": {"name": "Alice", "age": 30, "location": "NYC"},
-        "id": "call_123",
-        "type": "tool_call",
-    }
-
-    # Test sync execution
-    result = tool_node.invoke(
-        {"messages": [AIMessage(content="", tool_calls=[tool_call])]}
-    )
-
-    # Should return a Command with structured response
-    assert isinstance(result, list)
-    assert len(result) == 1
-    command = result[0]
-    assert isinstance(command, Command)
-
-    # Check the update structure
-    assert "messages" in command.update
-    assert "structured_response" in command.update
-
-    # Check the tool message
-    tool_message = command.update["messages"][0]
-    assert isinstance(tool_message, ToolMessage)
-    assert tool_message.name == "OutputSchema"
-    assert tool_message.tool_call_id == "call_123"
-
-    # Check the structured response
-    structured_response = command.update["structured_response"]
-    assert isinstance(structured_response, OutputSchema)
-    assert structured_response.name == "Alice"
-    assert structured_response.age == 30
-    assert structured_response.location == "NYC"
-
-
-async def test_structured_output_tools_async() -> None:
-    """Test that ToolNode handles Pydantic model classes as structured output tools."""
-
-    class OutputSchema(BaseModel):
-        name: str
-        age: int
-        location: str
-
-    tool_node = ToolNode([OutputSchema])
-
-    # Test that the structured output tool is registered correctly
-    assert "OutputSchema" not in tool_node.tools_by_name
-    assert "OutputSchema" in tool_node.structured_output_tools
-
-    # Create a tool call that matches the schema
-    tool_call = {
-        "name": "OutputSchema",
-        "args": {"name": "Alice", "age": 30, "location": "NYC"},
-        "id": "call_123",
-        "type": "tool_call",
-    }
-
-    # Test async execution
-    result_async = await tool_node.ainvoke(
-        {"messages": [AIMessage(content="", tool_calls=[tool_call])]}
-    )
-
-    # Should produce the same result
-    assert isinstance(result_async, list)
-    assert len(result_async) == 1
-    command_async = result_async[0]
-    assert isinstance(command_async, Command)
-    assert "structured_response" in command_async.update
-
-    structured_response_async = command_async.update["structured_response"]
-    assert isinstance(structured_response_async, OutputSchema)
-    assert structured_response_async.name == "Alice"
-    assert structured_response_async.age == 30
-    assert structured_response_async.location == "NYC"

libs/prebuilt/uv.lock

@@ -316,7 +316,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "0.6.4"
+version = "0.6.3"
 source = { editable = "../langgraph" }
 dependencies = [
     { name = "langchain-core" },
@@ -359,7 +359,6 @@ dev = [
     { name = "pytest-repeat" },
     { name = "pytest-watcher" },
     { name = "pytest-xdist", extras = ["psutil"] },
-    { name = "redis" },
     { name = "ruff" },
     { name = "syrupy" },
     { name = "types-requests" },
@@ -393,7 +392,6 @@ dev = [
     { name = "pytest-asyncio" },
     { name = "pytest-mock" },
     { name = "pytest-watcher" },
-    { name = "redis" },
     { name = "ruff" },
 ]
 
@@ -462,7 +460,7 @@ dev = [
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "0.6.4"
+version = "0.6.3"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-core" },