langchain 1.0.1__py3-none-any.whl → 1.0.4__py3-none-any.whl

langchain/agents/middleware/tool_call_limit.py

@@ -2,24 +2,36 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Annotated, Any, Literal
+from typing import TYPE_CHECKING, Annotated, Any, Generic, Literal
 
-from langchain_core.messages import AIMessage, AnyMessage, HumanMessage
+from langchain_core.messages import AIMessage, ToolCall, ToolMessage
 from langgraph.channels.untracked_value import UntrackedValue
+from langgraph.typing import ContextT
 from typing_extensions import NotRequired
 
 from langchain.agents.middleware.types import (
     AgentMiddleware,
     AgentState,
     PrivateStateAttr,
+    ResponseT,
     hook_config,
 )
 
 if TYPE_CHECKING:
     from langgraph.runtime import Runtime
 
+ExitBehavior = Literal["continue", "error", "end"]
+"""How to handle execution when tool call limits are exceeded.
 
-class ToolCallLimitState(AgentState):
+- `"continue"`: Block exceeded tools with error messages, let other tools continue (default)
+- `"error"`: Raise a `ToolCallLimitExceededError` exception
+- `"end"`: Stop execution immediately, injecting a ToolMessage and an AI message
+    for the single tool call that exceeded the limit. Raises `NotImplementedError`
+    if there are other pending tool calls (due to parallel tool calling).
+"""
+
+
+class ToolCallLimitState(AgentState[ResponseT], Generic[ResponseT]):
     """State schema for ToolCallLimitMiddleware.
 
     Extends AgentState with tool call tracking fields.
@@ -33,61 +45,35 @@ class ToolCallLimitState(AgentState):
     run_tool_call_count: NotRequired[Annotated[dict[str, int], UntrackedValue, PrivateStateAttr]]
 
 
-def _count_tool_calls_in_messages(messages: list[AnyMessage], tool_name: str | None = None) -> int:
-    """Count tool calls in a list of messages.
-
-    Args:
-        messages: List of messages to count tool calls in.
-        tool_name: If specified, only count calls to this specific tool.
-            If `None`, count all tool calls.
-
-    Returns:
-        The total number of tool calls (optionally filtered by tool_name).
-    """
-    count = 0
-    for message in messages:
-        if isinstance(message, AIMessage) and message.tool_calls:
-            if tool_name is None:
-                # Count all tool calls
-                count += len(message.tool_calls)
-            else:
-                # Count only calls to the specified tool
-                count += sum(1 for tc in message.tool_calls if tc["name"] == tool_name)
-    return count
+def _build_tool_message_content(tool_name: str | None) -> str:
+    """Build the error message content for ToolMessage when limit is exceeded.
 
-
-def _get_run_messages(messages: list[AnyMessage]) -> list[AnyMessage]:
-    """Get messages from the current run (after the last HumanMessage).
+    This message is sent to the model, so it should not reference thread/run concepts
+    that the model has no notion of.
 
     Args:
-        messages: Full list of messages.
+        tool_name: Tool name being limited (if specific tool), or None for all tools.
 
     Returns:
-        Messages from the current run (after last HumanMessage).
+        A concise message instructing the model not to call the tool again.
     """
-    # Find the last HumanMessage
-    last_human_index = -1
-    for i in range(len(messages) - 1, -1, -1):
-        if isinstance(messages[i], HumanMessage):
-            last_human_index = i
-            break
-
-    # If no HumanMessage found, return all messages
-    if last_human_index == -1:
-        return messages
-
-    # Return messages after the last HumanMessage
-    return messages[last_human_index + 1 :]
+    # Always instruct the model not to call again, regardless of which limit was hit
+    if tool_name:
+        return f"Tool call limit exceeded. Do not call '{tool_name}' again."
+    return "Tool call limit exceeded. Do not make additional tool calls."
 
 
-def _build_tool_limit_exceeded_message(
+def _build_final_ai_message_content(
     thread_count: int,
     run_count: int,
     thread_limit: int | None,
     run_limit: int | None,
     tool_name: str | None,
 ) -> str:
-    """Build a message indicating which tool call limits were exceeded.
+    """Build the final AI message content for 'end' behavior.
+
+    This message is displayed to the user, so it should include detailed information
+    about which limits were exceeded.
 
     Args:
         thread_count: Current thread tool call count.
@@ -99,14 +85,16 @@ def _build_tool_limit_exceeded_message(
     Returns:
         A formatted message describing which limits were exceeded.
     """
-    tool_desc = f"'{tool_name}' tool call" if tool_name else "Tool call"
+    tool_desc = f"'{tool_name}' tool" if tool_name else "Tool"
     exceeded_limits = []
-    if thread_limit is not None and thread_count >= thread_limit:
-        exceeded_limits.append(f"thread limit ({thread_count}/{thread_limit})")
-    if run_limit is not None and run_count >= run_limit:
-        exceeded_limits.append(f"run limit ({run_count}/{run_limit})")
 
-    return f"{tool_desc} limits exceeded: {', '.join(exceeded_limits)}"
+    if thread_limit is not None and thread_count > thread_limit:
+        exceeded_limits.append(f"thread limit exceeded ({thread_count}/{thread_limit} calls)")
+    if run_limit is not None and run_count > run_limit:
+        exceeded_limits.append(f"run limit exceeded ({run_count}/{run_limit} calls)")
+
+    limits_text = " and ".join(exceeded_limits)
+    return f"{tool_desc} call limit reached: {limits_text}."
 
 
 class ToolCallLimitExceededError(Exception):
@@ -139,46 +127,70 @@ class ToolCallLimitExceededError(Exception):
         self.run_limit = run_limit
         self.tool_name = tool_name
 
-        msg = _build_tool_limit_exceeded_message(
+        msg = _build_final_ai_message_content(
             thread_count, run_count, thread_limit, run_limit, tool_name
         )
         super().__init__(msg)
 
 
-class ToolCallLimitMiddleware(AgentMiddleware[ToolCallLimitState, Any]):
-    """Middleware that tracks tool call counts and enforces limits.
-
-    This middleware monitors the number of tool calls made during agent execution
-    and can terminate the agent when specified limits are reached. It supports
-    both thread-level and run-level call counting with configurable exit behaviors.
+class ToolCallLimitMiddleware(
+    AgentMiddleware[ToolCallLimitState[ResponseT], ContextT],
+    Generic[ResponseT, ContextT],
+):
+    """Track tool call counts and enforces limits during agent execution.
 
-    Thread-level: The middleware tracks the total number of tool calls and persists
-    call count across multiple runs (invocations) of the agent.
+    This middleware monitors the number of tool calls made and can terminate or
+    restrict execution when limits are exceeded. It supports both thread-level
+    (persistent across runs) and run-level (per invocation) call counting.
 
-    Run-level: The middleware tracks the number of tool calls made during a single
-    run (invocation) of the agent.
+    Configuration:
+        - `exit_behavior`: How to handle when limits are exceeded
+          - `"continue"`: Block exceeded tools, let execution continue (default)
+          - `"error"`: Raise an exception
+          - `"end"`: Stop immediately with a ToolMessage + AI message for the single
+            tool call that exceeded the limit (raises `NotImplementedError` if there
+            are other pending tool calls (due to parallel tool calling).
 
-    Example:
+    Examples:
+        Continue execution with blocked tools (default):
         ```python
         from langchain.agents.middleware.tool_call_limit import ToolCallLimitMiddleware
         from langchain.agents import create_agent
 
-        # Limit all tool calls globally
-        global_limiter = ToolCallLimitMiddleware(thread_limit=20, run_limit=10, exit_behavior="end")
-
-        # Limit a specific tool
-        search_limiter = ToolCallLimitMiddleware(
-            tool_name="search", thread_limit=5, run_limit=3, exit_behavior="end"
+        # Block exceeded tools but let other tools and model continue
+        limiter = ToolCallLimitMiddleware(
+            thread_limit=20,
+            run_limit=10,
+            exit_behavior="continue",  # default
         )
 
-        # Use both in the same agent
-        agent = create_agent("openai:gpt-4o", middleware=[global_limiter, search_limiter])
+        agent = create_agent("openai:gpt-4o", middleware=[limiter])
+        ```
+
+        Stop immediately when limit exceeded:
+        ```python
+        # End execution immediately with an AI message
+        limiter = ToolCallLimitMiddleware(run_limit=5, exit_behavior="end")
 
-        result = await agent.invoke({"messages": [HumanMessage("Help me with a task")]})
+        agent = create_agent("openai:gpt-4o", middleware=[limiter])
         ```
+
+        Raise exception on limit:
+        ```python
+        # Strict limit with exception handling
+        limiter = ToolCallLimitMiddleware(tool_name="search", thread_limit=5, exit_behavior="error")
+
+        agent = create_agent("openai:gpt-4o", middleware=[limiter])
+
+        try:
+            result = await agent.invoke({"messages": [HumanMessage("Task")]})
+        except ToolCallLimitExceededError as e:
+            print(f"Search limit exceeded: {e}")
+        ```
+
     """
 
-    state_schema = ToolCallLimitState
+    state_schema = ToolCallLimitState  # type: ignore[assignment]
 
     def __init__(
         self,
@@ -186,7 +198,7 @@ class ToolCallLimitMiddleware(AgentMiddleware[ToolCallLimitState, Any]):
         tool_name: str | None = None,
         thread_limit: int | None = None,
         run_limit: int | None = None,
-        exit_behavior: Literal["end", "error"] = "end",
+        exit_behavior: ExitBehavior = "continue",
     ) -> None:
         """Initialize the tool call limit middleware.
 
@@ -194,17 +206,21 @@ class ToolCallLimitMiddleware(AgentMiddleware[ToolCallLimitState, Any]):
             tool_name: Name of the specific tool to limit. If `None`, limits apply
                 to all tools. Defaults to `None`.
             thread_limit: Maximum number of tool calls allowed per thread.
-                None means no limit. Defaults to `None`.
+                `None` means no limit. Defaults to `None`.
             run_limit: Maximum number of tool calls allowed per run.
-                None means no limit. Defaults to `None`.
-            exit_behavior: What to do when limits are exceeded.
-                - "end": Jump to the end of the agent execution and
-                    inject an artificial AI message indicating that the limit was exceeded.
-                - "error": Raise a ToolCallLimitExceededError
-                Defaults to "end".
+                `None` means no limit. Defaults to `None`.
+            exit_behavior: How to handle when limits are exceeded.
+                - `"continue"`: Block exceeded tools with error messages, let other
+                  tools continue. Model decides when to end. (default)
+                - `"error"`: Raise a `ToolCallLimitExceededError` exception
+                - `"end"`: Stop execution immediately with a ToolMessage + AI message
+                  for the single tool call that exceeded the limit. Raises
+                  `NotImplementedError` if there are multiple parallel tool
+                  calls to other tools or multiple pending tool calls.
 
         Raises:
-            ValueError: If both limits are `None` or if `exit_behavior` is invalid.
+            ValueError: If both limits are `None`, if exit_behavior is invalid,
+                or if run_limit exceeds thread_limit.
         """
         super().__init__()
 
@@ -212,8 +228,16 @@ class ToolCallLimitMiddleware(AgentMiddleware[ToolCallLimitState, Any]):
             msg = "At least one limit must be specified (thread_limit or run_limit)"
             raise ValueError(msg)
 
-        if exit_behavior not in ("end", "error"):
-            msg = f"Invalid exit_behavior: {exit_behavior}. Must be 'end' or 'error'"
+        valid_behaviors = ("continue", "error", "end")
+        if exit_behavior not in valid_behaviors:
+            msg = f"Invalid exit_behavior: {exit_behavior!r}. Must be one of {valid_behaviors}"
+            raise ValueError(msg)
+
+        if thread_limit is not None and run_limit is not None and run_limit > thread_limit:
+            msg = (
+                f"run_limit ({run_limit}) cannot exceed thread_limit ({thread_limit}). "
+                "The run limit should be less than or equal to the thread limit."
+            )
             raise ValueError(msg)
 
         self.tool_name = tool_name
@@ -233,64 +257,84 @@ class ToolCallLimitMiddleware(AgentMiddleware[ToolCallLimitState, Any]):
             return f"{base_name}[{self.tool_name}]"
         return base_name
 
-    @hook_config(can_jump_to=["end"])
-    def before_model(self, state: ToolCallLimitState, runtime: Runtime) -> dict[str, Any] | None:  # noqa: ARG002
-        """Check tool call limits before making a model call.
+    def _would_exceed_limit(self, thread_count: int, run_count: int) -> bool:
+        """Check if incrementing the counts would exceed any configured limit.
 
         Args:
-            state: The current agent state containing tool call counts.
-            runtime: The langgraph runtime.
+            thread_count: Current thread call count.
+            run_count: Current run call count.
 
         Returns:
-            If limits are exceeded and exit_behavior is "end", returns
-            a Command to jump to the end with a limit exceeded message. Otherwise returns None.
+            True if either limit would be exceeded by one more call.
+        """
+        return (self.thread_limit is not None and thread_count + 1 > self.thread_limit) or (
+            self.run_limit is not None and run_count + 1 > self.run_limit
+        )
 
-        Raises:
-            ToolCallLimitExceededError: If limits are exceeded and exit_behavior
-                is "error".
+    def _matches_tool_filter(self, tool_call: ToolCall) -> bool:
+        """Check if a tool call matches this middleware's tool filter.
+
+        Args:
+            tool_call: The tool call to check.
+
+        Returns:
+            True if this middleware should track this tool call.
         """
-        # Get the count key for this middleware instance
-        count_key = self.tool_name if self.tool_name else "__all__"
+        return self.tool_name is None or tool_call["name"] == self.tool_name
 
-        thread_counts = state.get("thread_tool_call_count", {})
-        run_counts = state.get("run_tool_call_count", {})
+    def _separate_tool_calls(
+        self, tool_calls: list[ToolCall], thread_count: int, run_count: int
+    ) -> tuple[list[ToolCall], list[ToolCall], int, int]:
+        """Separate tool calls into allowed and blocked based on limits.
 
-        thread_count = thread_counts.get(count_key, 0)
-        run_count = run_counts.get(count_key, 0)
+        Args:
+            tool_calls: List of tool calls to evaluate.
+            thread_count: Current thread call count.
+            run_count: Current run call count.
 
-        # Check if any limits are exceeded
-        thread_limit_exceeded = self.thread_limit is not None and thread_count >= self.thread_limit
-        run_limit_exceeded = self.run_limit is not None and run_count >= self.run_limit
+        Returns:
+            Tuple of (allowed_calls, blocked_calls, final_thread_count, final_run_count).
+        """
+        allowed_calls: list[ToolCall] = []
+        blocked_calls: list[ToolCall] = []
+        temp_thread_count = thread_count
+        temp_run_count = run_count
 
-        if thread_limit_exceeded or run_limit_exceeded:
-            if self.exit_behavior == "error":
-                raise ToolCallLimitExceededError(
-                    thread_count=thread_count,
-                    run_count=run_count,
-                    thread_limit=self.thread_limit,
-                    run_limit=self.run_limit,
-                    tool_name=self.tool_name,
-                )
-            if self.exit_behavior == "end":
-                # Create a message indicating the limit was exceeded
-                limit_message = _build_tool_limit_exceeded_message(
-                    thread_count, run_count, self.thread_limit, self.run_limit, self.tool_name
-                )
-                limit_ai_message = AIMessage(content=limit_message)
+        for tool_call in tool_calls:
+            if not self._matches_tool_filter(tool_call):
+                continue
 
-                return {"jump_to": "end", "messages": [limit_ai_message]}
+            if self._would_exceed_limit(temp_thread_count, temp_run_count):
+                blocked_calls.append(tool_call)
+            else:
+                allowed_calls.append(tool_call)
+                temp_thread_count += 1
+                temp_run_count += 1
 
-        return None
+        return allowed_calls, blocked_calls, temp_thread_count, temp_run_count
 
-    def after_model(self, state: ToolCallLimitState, runtime: Runtime) -> dict[str, Any] | None:  # noqa: ARG002
-        """Increment tool call counts after a model call (when tool calls are made).
+    @hook_config(can_jump_to=["end"])
+    def after_model(
+        self,
+        state: ToolCallLimitState[ResponseT],
+        runtime: Runtime[ContextT],  # noqa: ARG002
+    ) -> dict[str, Any] | None:
+        """Increment tool call counts after a model call and check limits.
 
         Args:
             state: The current agent state.
             runtime: The langgraph runtime.
 
         Returns:
-            State updates with incremented tool call counts if tool calls were made.
+            State updates with incremented tool call counts. If limits are exceeded
+            and exit_behavior is "end", also includes a jump to end with a ToolMessage
+            and AI message for the single exceeded tool call.
+
+        Raises:
+            ToolCallLimitExceededError: If limits are exceeded and exit_behavior
+                is "error".
+            NotImplementedError: If limits are exceeded, exit_behavior is "end",
+                and there are multiple tool calls.
         """
         # Get the last AIMessage to check for tool calls
         messages = state.get("messages", [])
@@ -307,27 +351,104 @@ class ToolCallLimitMiddleware(AgentMiddleware[ToolCallLimitState, Any]):
         if not last_ai_message or not last_ai_message.tool_calls:
             return None
 
-        # Count relevant tool calls (filter by tool_name if specified)
-        tool_call_count = 0
-        for tool_call in last_ai_message.tool_calls:
-            if self.tool_name is None or tool_call["name"] == self.tool_name:
-                tool_call_count += 1
-
-        if tool_call_count == 0:
-            return None
-
         # Get the count key for this middleware instance
         count_key = self.tool_name if self.tool_name else "__all__"
 
         # Get current counts
         thread_counts = state.get("thread_tool_call_count", {}).copy()
         run_counts = state.get("run_tool_call_count", {}).copy()
+        current_thread_count = thread_counts.get(count_key, 0)
+        current_run_count = run_counts.get(count_key, 0)
 
-        # Increment counts for this key
-        thread_counts[count_key] = thread_counts.get(count_key, 0) + tool_call_count
-        run_counts[count_key] = run_counts.get(count_key, 0) + tool_call_count
+        # Separate tool calls into allowed and blocked
+        allowed_calls, blocked_calls, new_thread_count, new_run_count = self._separate_tool_calls(
+            last_ai_message.tool_calls, current_thread_count, current_run_count
+        )
 
+        # Update counts to include only allowed calls for thread count
+        # (blocked calls don't count towards thread-level tracking)
+        # But run count includes blocked calls since they were attempted in this run
+        thread_counts[count_key] = new_thread_count
+        run_counts[count_key] = new_run_count + len(blocked_calls)
+
+        # If no tool calls are blocked, just update counts
+        if not blocked_calls:
+            if allowed_calls:
+                return {
+                    "thread_tool_call_count": thread_counts,
+                    "run_tool_call_count": run_counts,
+                }
+            return None
+
+        # Get final counts for building messages
+        final_thread_count = thread_counts[count_key]
+        final_run_count = run_counts[count_key]
+
+        # Handle different exit behaviors
+        if self.exit_behavior == "error":
+            # Use hypothetical thread count to show which limit was exceeded
+            hypothetical_thread_count = final_thread_count + len(blocked_calls)
+            raise ToolCallLimitExceededError(
+                thread_count=hypothetical_thread_count,
+                run_count=final_run_count,
+                thread_limit=self.thread_limit,
+                run_limit=self.run_limit,
+                tool_name=self.tool_name,
+            )
+
+        # Build tool message content (sent to model - no thread/run details)
+        tool_msg_content = _build_tool_message_content(self.tool_name)
+
+        # Inject artificial error ToolMessages for blocked tool calls
+        artificial_messages: list[ToolMessage | AIMessage] = [
+            ToolMessage(
+                content=tool_msg_content,
+                tool_call_id=tool_call["id"],
+                name=tool_call.get("name"),
+                status="error",
+            )
+            for tool_call in blocked_calls
+        ]
+
+        if self.exit_behavior == "end":
+            # Check if there are tool calls to other tools that would continue executing
+            other_tools = [
+                tc
+                for tc in last_ai_message.tool_calls
+                if self.tool_name is not None and tc["name"] != self.tool_name
+            ]
+
+            if other_tools:
+                tool_names = ", ".join({tc["name"] for tc in other_tools})
+                msg = (
+                    f"Cannot end execution with other tool calls pending. "
+                    f"Found calls to: {tool_names}. Use 'continue' or 'error' behavior instead."
+                )
+                raise NotImplementedError(msg)
+
+            # Build final AI message content (displayed to user - includes thread/run details)
+            # Use hypothetical thread count (what it would have been if call wasn't blocked)
+            # to show which limit was actually exceeded
+            hypothetical_thread_count = final_thread_count + len(blocked_calls)
+            final_msg_content = _build_final_ai_message_content(
+                hypothetical_thread_count,
+                final_run_count,
+                self.thread_limit,
+                self.run_limit,
+                self.tool_name,
+            )
+            artificial_messages.append(AIMessage(content=final_msg_content))
+
+            return {
+                "thread_tool_call_count": thread_counts,
+                "run_tool_call_count": run_counts,
+                "jump_to": "end",
+                "messages": artificial_messages,
+            }
+
+        # For exit_behavior="continue", return error messages to block exceeded tools
         return {
             "thread_tool_call_count": thread_counts,
             "run_tool_call_count": run_counts,
+            "messages": artificial_messages,
         }

langchain/agents/middleware/tool_emulator.py

@@ -15,12 +15,12 @@ if TYPE_CHECKING:
 
     from langgraph.types import Command
 
+    from langchain.agents.middleware.types import ToolCallRequest
     from langchain.tools import BaseTool
-    from langchain.tools.tool_node import ToolCallRequest
 
 
 class LLMToolEmulator(AgentMiddleware):
-    """Middleware that emulates specified tools using an LLM instead of executing them.
+    """Emulates specified tools using an LLM instead of executing them.
 
     This middleware allows selective emulation of tools for testing purposes.
     By default (when tools=None), all tools are emulated. You can specify which
@@ -48,7 +48,7 @@ class LLMToolEmulator(AgentMiddleware):
         Use a custom model for emulation:
         ```python
         middleware = LLMToolEmulator(
-            tools=["get_weather"], model="anthropic:claude-3-5-sonnet-latest"
+            tools=["get_weather"], model="anthropic:claude-sonnet-4-5-20250929"
         )
         ```
 
@@ -71,7 +71,7 @@ class LLMToolEmulator(AgentMiddleware):
                 If None (default), ALL tools will be emulated.
                 If empty list, no tools will be emulated.
             model: Model to use for emulation.
-                Defaults to "anthropic:claude-3-5-sonnet-latest".
+                Defaults to "anthropic:claude-sonnet-4-5-20250929".
                 Can be a model identifier string or BaseChatModel instance.
         """
         super().__init__()
@@ -91,7 +91,7 @@ class LLMToolEmulator(AgentMiddleware):
 
         # Initialize emulator model
         if model is None:
-            self.model = init_chat_model("anthropic:claude-3-5-sonnet-latest", temperature=1)
+            self.model = init_chat_model("anthropic:claude-sonnet-4-5-20250929", temperature=1)
         elif isinstance(model, BaseChatModel):
             self.model = model
         else:

langchain/agents/middleware/tool_retry.py

@@ -16,8 +16,8 @@ if TYPE_CHECKING:
 
     from langgraph.types import Command
 
+    from langchain.agents.middleware.types import ToolCallRequest
     from langchain.tools import BaseTool
-    from langchain.tools.tool_node import ToolCallRequest
 
 
 class ToolRetryMiddleware(AgentMiddleware):

langchain/agents/middleware/types.py

@@ -19,14 +19,18 @@ from typing import (
 if TYPE_CHECKING:
     from collections.abc import Awaitable
 
-    from langchain.tools.tool_node import ToolCallRequest
-
 # Needed as top level import for Pydantic schema generation on AgentState
 from typing import TypeAlias
 
-from langchain_core.messages import AIMessage, AnyMessage, BaseMessage, ToolMessage  # noqa: TC002
+from langchain_core.messages import (  # noqa: TC002
+    AIMessage,
+    AnyMessage,
+    BaseMessage,
+    ToolMessage,
+)
 from langgraph.channels.ephemeral_value import EphemeralValue
 from langgraph.graph.message import add_messages
+from langgraph.prebuilt.tool_node import ToolCallRequest, ToolCallWrapper
 from langgraph.types import Command  # noqa: TC002
 from langgraph.typing import ContextT
 from typing_extensions import NotRequired, Required, TypedDict, TypeVar, Unpack
@@ -45,6 +49,10 @@ __all__ = [
     "ModelRequest",
     "ModelResponse",
     "OmitFromSchema",
+    "ResponseT",
+    "StateT_co",
+    "ToolCallRequest",
+    "ToolCallWrapper",
     "after_agent",
     "after_model",
     "before_agent",
@@ -185,6 +193,7 @@ class _OutputAgentState(TypedDict, Generic[ResponseT]):  # noqa: PYI049
 
 
 StateT = TypeVar("StateT", bound=AgentState, default=AgentState)
+StateT_co = TypeVar("StateT_co", bound=AgentState, default=AgentState, covariant=True)
 StateT_contra = TypeVar("StateT_contra", bound=AgentState, contravariant=True)