langchain 1.0.0a5__py3-none-any.whl → 1.0.0a6__py3-none-any.whl

langchain/agents/middleware/__init__.py

@@ -1,5 +1,6 @@
 """Middleware plugins for agents."""
 
+from .dynamic_system_prompt import DynamicSystemPromptMiddleware
 from .human_in_the_loop import HumanInTheLoopMiddleware
 from .prompt_caching import AnthropicPromptCachingMiddleware
 from .summarization import SummarizationMiddleware
@@ -8,7 +9,9 @@ from .types import AgentMiddleware, AgentState, ModelRequest
 __all__ = [
     "AgentMiddleware",
     "AgentState",
+    # should move to langchain-anthropic if we decide to keep it
     "AnthropicPromptCachingMiddleware",
+    "DynamicSystemPromptMiddleware",
     "HumanInTheLoopMiddleware",
     "ModelRequest",
     "SummarizationMiddleware",

langchain/agents/middleware/dynamic_system_prompt.py

@@ -0,0 +1,105 @@
+"""Dynamic System Prompt Middleware.
+
+Allows setting the system prompt dynamically right before each model invocation.
+Useful when the prompt depends on the current agent state or per-invocation context.
+"""
+
+from __future__ import annotations
+
+from inspect import signature
+from typing import TYPE_CHECKING, Protocol, TypeAlias, cast
+
+from langgraph.typing import ContextT
+
+from langchain.agents.middleware.types import (
+    AgentMiddleware,
+    AgentState,
+    ModelRequest,
+)
+
+if TYPE_CHECKING:
+    from langgraph.runtime import Runtime
+
+
+class DynamicSystemPromptWithoutRuntime(Protocol):
+    """Dynamic system prompt without runtime in call signature."""
+
+    def __call__(self, state: AgentState) -> str:
+        """Return the system prompt for the next model call."""
+        ...
+
+
+class DynamicSystemPromptWithRuntime(Protocol[ContextT]):
+    """Dynamic system prompt with runtime in call signature."""
+
+    def __call__(self, state: AgentState, runtime: Runtime[ContextT]) -> str:
+        """Return the system prompt for the next model call."""
+        ...
+
+
+DynamicSystemPrompt: TypeAlias = (
+    DynamicSystemPromptWithoutRuntime | DynamicSystemPromptWithRuntime[ContextT]
+)
+
+
+class DynamicSystemPromptMiddleware(AgentMiddleware):
+    """Dynamic System Prompt Middleware.
+
+    Allows setting the system prompt dynamically right before each model invocation.
+    Useful when the prompt depends on the current agent state or per-invocation context.
+
+    Example:
+        ```python
+        from langchain.agents.middleware import DynamicSystemPromptMiddleware
+
+
+        class Context(TypedDict):
+            user_name: str
+
+
+        def system_prompt(state: AgentState, runtime: Runtime[Context]) -> str:
+            user_name = runtime.context.get("user_name", "n/a")
+            return (
+                f"You are a helpful assistant. Always address the user by their name: {user_name}"
+            )
+
+
+        middleware = DynamicSystemPromptMiddleware(system_prompt)
+        ```
+    """
+
+    _accepts_runtime: bool
+
+    def __init__(
+        self,
+        dynamic_system_prompt: DynamicSystemPrompt[ContextT],
+    ) -> None:
+        """Initialize the dynamic system prompt middleware.
+
+        Args:
+            dynamic_system_prompt: Function that receives the current agent state
+                and optionally runtime with context, and returns the system prompt for
+                the next model call. Returns a string.
+        """
+        super().__init__()
+        self.dynamic_system_prompt = dynamic_system_prompt
+        self._accepts_runtime = "runtime" in signature(dynamic_system_prompt).parameters
+
+    def modify_model_request(
+        self,
+        request: ModelRequest,
+        state: AgentState,
+        runtime: Runtime[ContextT],
+    ) -> ModelRequest:
+        """Modify the model request to include the dynamic system prompt."""
+        if self._accepts_runtime:
+            system_prompt = cast(
+                "DynamicSystemPromptWithRuntime[ContextT]", self.dynamic_system_prompt
+            )(state, runtime)
+        else:
+            system_prompt = cast("DynamicSystemPromptWithoutRuntime", self.dynamic_system_prompt)(
+                state
+            )
+
+        request.system_prompt = system_prompt
+        return request

langchain/agents/middleware/human_in_the_loop.py

@@ -1,19 +1,110 @@
 """Human in the loop middleware."""
 
-from typing import Any
-
-from langgraph.prebuilt.interrupt import (
-    ActionRequest,
-    HumanInterrupt,
-    HumanInterruptConfig,
-    HumanResponse,
-)
+from typing import Any, Literal
+
+from langchain_core.messages import AIMessage, ToolCall, ToolMessage
 from langgraph.types import interrupt
+from typing_extensions import NotRequired, TypedDict
 
-from langchain.agents.middleware._utils import _generate_correction_tool_messages
 from langchain.agents.middleware.types import AgentMiddleware, AgentState
 
-ToolInterruptConfig = dict[str, HumanInterruptConfig]
+
+class HumanInTheLoopConfig(TypedDict):
+    """Configuration that defines what actions are allowed for a human interrupt.
+
+    This controls the available interaction options when the graph is paused for human input.
+    """
+
+    allow_accept: NotRequired[bool]
+    """Whether the human can approve the current action without changes."""
+    allow_edit: NotRequired[bool]
+    """Whether the human can approve the current action with edited content."""
+    allow_respond: NotRequired[bool]
+    """Whether the human can reject the current action with feedback."""
+
+
+class ActionRequest(TypedDict):
+    """Represents a request with a name and arguments."""
+
+    action: str
+    """The type or name of action being requested (e.g., "add_numbers")."""
+    args: dict
+    """Key-value pairs of arguments needed for the action (e.g., {"a": 1, "b": 2})."""
+
+
+class HumanInTheLoopRequest(TypedDict):
+    """Represents an interrupt triggered by the graph that requires human intervention.
+
+    Example:
+        ```python
+        # Extract a tool call from the state and create an interrupt request
+        request = HumanInterrupt(
+            action_request=ActionRequest(
+                action="run_command",  # The action being requested
+                args={"command": "ls", "args": ["-l"]},  # Arguments for the action
+            ),
+            config=HumanInTheLoopConfig(
+                allow_accept=True,  # Allow approval
+                allow_respond=True,  # Allow rejection with feedback
+                allow_edit=False,  # Don't allow approval with edits
+            ),
+            description="Please review the command before execution",
+        )
+        # Send the interrupt request and get the response
+        response = interrupt([request])[0]
+        ```
+    """
+
+    action_request: ActionRequest
+    """The specific action being requested from the human."""
+    config: HumanInTheLoopConfig
+    """Configuration defining what response types are allowed."""
+    description: str | None
+    """Optional detailed description of what input is needed."""
+
+
+class AcceptPayload(TypedDict):
+    """Response when a human approves the action."""
+
+    type: Literal["accept"]
+    """The type of response when a human approves the action."""
+
+
+class ResponsePayload(TypedDict):
+    """Response when a human rejects the action."""
+
+    type: Literal["response"]
+    """The type of response when a human rejects the action."""
+
+    args: NotRequired[str]
+    """The message to be sent to the model explaining why the action was rejected."""
+
+
+class EditPayload(TypedDict):
+    """Response when a human edits the action."""
+
+    type: Literal["edit"]
+    """The type of response when a human edits the action."""
+
+    args: ActionRequest
+    """The action request with the edited content."""
+
+
+HumanInTheLoopResponse = AcceptPayload | ResponsePayload | EditPayload
+"""Aggregated response type for all possible human in the loop responses."""
+
+
+class ToolConfig(TypedDict):
+    """Configuration for a tool requiring human in the loop."""
+
+    allow_accept: NotRequired[bool]
+    """Whether the human can approve the current action without changes."""
+    allow_edit: NotRequired[bool]
+    """Whether the human can approve the current action with edited content."""
+    allow_respond: NotRequired[bool]
+    """Whether the human can reject the current action with feedback."""
+    description: NotRequired[str]
+    """The description attached to the request for human input."""
 
 
 class HumanInTheLoopMiddleware(AgentMiddleware):
@@ -21,115 +112,142 @@ class HumanInTheLoopMiddleware(AgentMiddleware):
 
     def __init__(
         self,
-        tool_configs: ToolInterruptConfig,
-        message_prefix: str = "Tool execution requires approval",
+        tool_configs: dict[str, bool | ToolConfig],
+        *,
+        description_prefix: str = "Tool execution requires approval",
     ) -> None:
         """Initialize the human in the loop middleware.
 
         Args:
-            tool_configs: The tool interrupt configs to use for the middleware.
-            message_prefix: The message prefix to use when constructing interrupt content.
+            tool_configs: Mapping of tool name to allowed actions.
+                If a tool doesn't have an entry, it's auto-approved by default.
+                * `True` indicates all actions are allowed: accept, edit, and respond.
+                * `False` indicates that the tool is auto-approved.
+                * ToolConfig indicates the specific actions allowed for this tool.
+            description_prefix: The prefix to use when constructing action requests.
+                This is used to provide context about the tool call and the action being requested.
+                Not used if a tool has a description in its ToolConfig.
         """
         super().__init__()
-        self.tool_configs = tool_configs
-        self.message_prefix = message_prefix
+        resolved_tool_configs: dict[str, ToolConfig] = {}
+        for tool_name, tool_config in tool_configs.items():
+            if isinstance(tool_config, bool):
+                if tool_config is True:
+                    resolved_tool_configs[tool_name] = ToolConfig(
+                        allow_accept=True,
+                        allow_edit=True,
+                        allow_respond=True,
+                    )
+            else:
+                resolved_tool_configs[tool_name] = tool_config
+        self.tool_configs = resolved_tool_configs
+        self.description_prefix = description_prefix
 
-    def after_model(self, state: AgentState) -> dict[str, Any] | None:
+    def after_model(self, state: AgentState) -> dict[str, Any] | None:  # type: ignore[override]
         """Trigger HITL flows for relevant tool calls after an AIMessage."""
         messages = state["messages"]
         if not messages:
             return None
 
-        last_message = messages[-1]
-
-        if not hasattr(last_message, "tool_calls") or not last_message.tool_calls:
+        last_ai_msg = next((msg for msg in messages if isinstance(msg, AIMessage)), None)
+        if not last_ai_msg or not last_ai_msg.tool_calls:
             return None
 
         # Separate tool calls that need interrupts from those that don't
-        interrupt_tool_calls = []
+        hitl_tool_calls: list[ToolCall] = []
         auto_approved_tool_calls = []
 
-        for tool_call in last_message.tool_calls:
-            tool_name = tool_call["name"]
-            if tool_name in self.tool_configs:
-                interrupt_tool_calls.append(tool_call)
-            else:
-                auto_approved_tool_calls.append(tool_call)
+        for tool_call in last_ai_msg.tool_calls:
+            hitl_tool_calls.append(tool_call) if tool_call[
+                "name"
+            ] in self.tool_configs else auto_approved_tool_calls.append(tool_call)
 
         # If no interrupts needed, return early
-        if not interrupt_tool_calls:
+        if not hitl_tool_calls:
             return None
 
-        approved_tool_calls = auto_approved_tool_calls.copy()
+        # Process all tool calls that require interrupts
+        approved_tool_calls: list[ToolCall] = auto_approved_tool_calls.copy()
+        artificial_tool_messages: list[ToolMessage] = []
 
-        # Right now, we do not support multiple tool calls with interrupts
-        if len(interrupt_tool_calls) > 1:
-            tool_names = [t["name"] for t in interrupt_tool_calls]
-            msg = (
-                f"Called the following tools which require interrupts: {tool_names}\n\n"
-                "You may only call ONE tool that requires an interrupt at a time"
+        # Create interrupt requests for all tools that need approval
+        hitl_requests: list[HumanInTheLoopRequest] = []
+        for tool_call in hitl_tool_calls:
+            tool_name = tool_call["name"]
+            tool_args = tool_call["args"]
+            config = self.tool_configs[tool_name]
+            description = (
+                config.get("description")
+                or f"{self.description_prefix}\n\nTool: {tool_name}\nArgs: {tool_args}"
             )
-            return {
-                "messages": _generate_correction_tool_messages(msg, last_message.tool_calls),
-                "jump_to": "model",
+
+            request: HumanInTheLoopRequest = {
+                "action_request": ActionRequest(
+                    action=tool_name,
+                    args=tool_args,
+                ),
+                "config": config,
+                "description": description,
             }
+            hitl_requests.append(request)
 
-        # Right now, we do not support interrupting a tool call if other tool calls exist
-        if auto_approved_tool_calls:
-            tool_names = [t["name"] for t in interrupt_tool_calls]
+        responses: list[HumanInTheLoopResponse] = interrupt(hitl_requests)
+
+        # Validate that the number of responses matches the number of interrupt tool calls
+        if (responses_len := len(responses)) != (hitl_tool_calls_len := len(hitl_tool_calls)):
             msg = (
-                f"Called the following tools which require interrupts: {tool_names}. "
-                "You also called other tools that do not require interrupts. "
-                "If you call a tool that requires and interrupt, you may ONLY call that tool."
+                f"Number of human responses ({responses_len}) does not match "
+                f"number of hanging tool calls ({hitl_tool_calls_len})."
             )
-            return {
-                "messages": _generate_correction_tool_messages(msg, last_message.tool_calls),
-                "jump_to": "model",
-            }
-
-        # Only one tool call will need interrupts
-        tool_call = interrupt_tool_calls[0]
-        tool_name = tool_call["name"]
-        tool_args = tool_call["args"]
-        description = f"{self.message_prefix}\n\nTool: {tool_name}\nArgs: {tool_args}"
-        tool_config = self.tool_configs[tool_name]
-
-        request: HumanInterrupt = {
-            "action_request": ActionRequest(
-                action=tool_name,
-                args=tool_args,
-            ),
-            "config": tool_config,
-            "description": description,
-        }
-
-        responses: list[HumanResponse] = interrupt([request])
-        response = responses[0]
-
-        if response["type"] == "accept":
-            approved_tool_calls.append(tool_call)
-        elif response["type"] == "edit":
-            edited: ActionRequest = response["args"]  # type: ignore[assignment]
-            new_tool_call = {
-                "type": "tool_call",
-                "name": tool_call["name"],
-                "args": edited["args"],
-                "id": tool_call["id"],
-            }
-            approved_tool_calls.append(new_tool_call)
-        elif response["type"] == "ignore":
-            return {"jump_to": "__end__"}
-        elif response["type"] == "response":
-            tool_message = {
-                "role": "tool",
-                "tool_call_id": tool_call["id"],
-                "content": response["args"],
-            }
-            return {"messages": [tool_message], "jump_to": "model"}
-        else:
-            msg = f"Unknown response type: {response['type']}"
             raise ValueError(msg)
 
-        last_message.tool_calls = approved_tool_calls
-
-        return {"messages": [last_message]}
+        for i, response in enumerate(responses):
+            tool_call = hitl_tool_calls[i]
+            config = self.tool_configs[tool_call["name"]]
+
+            if response["type"] == "accept" and config.get("allow_accept"):
+                approved_tool_calls.append(tool_call)
+            elif response["type"] == "edit" and config.get("allow_edit"):
+                edited_action = response["args"]
+                approved_tool_calls.append(
+                    ToolCall(
+                        type="tool_call",
+                        name=edited_action["action"],
+                        args=edited_action["args"],
+                        id=tool_call["id"],
+                    )
+                )
+            elif response["type"] == "response" and config.get("allow_respond"):
+                # Create a tool message with the human's text response
+                content = response.get("args") or (
+                    f"User rejected the tool call for `{tool_call['name']}` "
+                    f"with id {tool_call['id']}"
+                )
+                tool_message = ToolMessage(
+                    content=content,
+                    name=tool_call["name"],
+                    tool_call_id=tool_call["id"],
+                    status="error",
+                )
+                artificial_tool_messages.append(tool_message)
+            else:
+                allowed_actions = [
+                    action
+                    for action in ["accept", "edit", "response"]
+                    if config.get(f"allow_{'respond' if action == 'response' else action}")
+                ]
+                msg = (
+                    f"Unexpected human response: {response}. "
+                    f"Response action '{response.get('type')}' "
+                    f"is not allowed for tool '{tool_call['name']}'. "
+                    f"Expected one of {allowed_actions} based on the tool's configuration."
+                )
+                raise ValueError(msg)
+
+        # Update the AI message to only include approved tool calls
+        last_ai_msg.tool_calls = approved_tool_calls
+
+        if len(approved_tool_calls) > 0:
+            return {"messages": [last_ai_msg, *artificial_tool_messages]}
+
+        return {"jump_to": "model", "messages": artificial_tool_messages}

langchain/agents/middleware/prompt_caching.py

@@ -2,7 +2,7 @@
 
 from typing import Literal
 
-from langchain.agents.middleware.types import AgentMiddleware, AgentState, ModelRequest
+from langchain.agents.middleware.types import AgentMiddleware, ModelRequest
 
 
 class AnthropicPromptCachingMiddleware(AgentMiddleware):
@@ -32,7 +32,10 @@ class AnthropicPromptCachingMiddleware(AgentMiddleware):
         self.ttl = ttl
         self.min_messages_to_cache = min_messages_to_cache
 
-    def modify_model_request(self, request: ModelRequest, state: AgentState) -> ModelRequest:  # noqa: ARG002
+    def modify_model_request(  # type: ignore[override]
+        self,
+        request: ModelRequest,
+    ) -> ModelRequest:
         """Modify the model request to add cache control blocks."""
         try:
             from langchain_anthropic import ChatAnthropic

langchain/agents/middleware/summarization.py

@@ -98,7 +98,7 @@ class SummarizationMiddleware(AgentMiddleware):
         self.summary_prompt = summary_prompt
         self.summary_prefix = summary_prefix
 
-    def before_model(self, state: AgentState) -> dict[str, Any] | None:
+    def before_model(self, state: AgentState) -> dict[str, Any] | None:  # type: ignore[override]
         """Process messages before model invocation, potentially triggering summarization."""
         messages = state["messages"]
         self._ensure_message_ids(messages)

langchain/agents/middleware/types.py

@@ -8,15 +8,27 @@ from typing import TYPE_CHECKING, Annotated, Any, Generic, Literal, cast
 # needed as top level import for pydantic schema generation on AgentState
 from langchain_core.messages import AnyMessage  # noqa: TC002
 from langgraph.channels.ephemeral_value import EphemeralValue
-from langgraph.graph.message import Messages, add_messages
+from langgraph.graph.message import add_messages
+from langgraph.runtime import Runtime
+from langgraph.typing import ContextT
 from typing_extensions import NotRequired, Required, TypedDict, TypeVar
 
 if TYPE_CHECKING:
     from langchain_core.language_models.chat_models import BaseChatModel
     from langchain_core.tools import BaseTool
+    from langgraph.runtime import Runtime
 
     from langchain.agents.structured_output import ResponseFormat
 
+__all__ = [
+    "AgentMiddleware",
+    "AgentState",
+    "ContextT",
+    "ModelRequest",
+    "OmitFromSchema",
+    "PublicAgentState",
+]
+
 JumpTo = Literal["tools", "model", "__end__"]
 """Destination to jump to when a middleware node returns."""
 
@@ -36,26 +48,49 @@ class ModelRequest:
     model_settings: dict[str, Any] = field(default_factory=dict)
 
 
+@dataclass
+class OmitFromSchema:
+    """Annotation used to mark state attributes as omitted from input or output schemas."""
+
+    input: bool = True
+    """Whether to omit the attribute from the input schema."""
+
+    output: bool = True
+    """Whether to omit the attribute from the output schema."""
+
+
+OmitFromInput = OmitFromSchema(input=True, output=False)
+"""Annotation used to mark state attributes as omitted from input schema."""
+
+OmitFromOutput = OmitFromSchema(input=False, output=True)
+"""Annotation used to mark state attributes as omitted from output schema."""
+
+PrivateStateAttr = OmitFromSchema(input=True, output=True)
+"""Annotation used to mark state attributes as purely internal for a given middleware."""
+
+
 class AgentState(TypedDict, Generic[ResponseT]):
     """State schema for the agent."""
 
     messages: Required[Annotated[list[AnyMessage], add_messages]]
-    model_request: NotRequired[Annotated[ModelRequest | None, EphemeralValue]]
-    jump_to: NotRequired[Annotated[JumpTo | None, EphemeralValue]]
+    jump_to: NotRequired[Annotated[JumpTo | None, EphemeralValue, PrivateStateAttr]]
     response: NotRequired[ResponseT]
 
 
 class PublicAgentState(TypedDict, Generic[ResponseT]):
-    """Input / output schema for the agent."""
+    """Public state schema for the agent.
 
-    messages: Required[Messages]
+    Just used for typing purposes.
+    """
+
+    messages: Required[Annotated[list[AnyMessage], add_messages]]
     response: NotRequired[ResponseT]
 
 
-StateT = TypeVar("StateT", bound=AgentState)
+StateT = TypeVar("StateT", bound=AgentState, default=AgentState)
 
 
-class AgentMiddleware(Generic[StateT]):
+class AgentMiddleware(Generic[StateT, ContextT]):
     """Base middleware class for an agent.
 
     Subclass this and implement any of the defined methods to customize agent behavior
@@ -68,12 +103,17 @@ class AgentMiddleware(Generic[StateT]):
     tools: list[BaseTool]
     """Additional tools registered by the middleware."""
 
-    def before_model(self, state: StateT) -> dict[str, Any] | None:
+    def before_model(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None:
         """Logic to run before the model is called."""
 
-    def modify_model_request(self, request: ModelRequest, state: StateT) -> ModelRequest:  # noqa: ARG002
+    def modify_model_request(
+        self,
+        request: ModelRequest,
+        state: StateT,  # noqa: ARG002
+        runtime: Runtime[ContextT],  # noqa: ARG002
+    ) -> ModelRequest:
         """Logic to modify request kwargs before the model is called."""
         return request
 
-    def after_model(self, state: StateT) -> dict[str, Any] | None:
+    def after_model(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None:
         """Logic to run after the model is called."""

langchain/agents/middleware_agent.py

@@ -2,26 +2,28 @@
 
 import itertools
 from collections.abc import Callable, Sequence
-from typing import Any
+from inspect import signature
+from typing import Annotated, Any, cast, get_args, get_origin, get_type_hints
 
 from langchain_core.language_models.chat_models import BaseChatModel
-from langchain_core.messages import AIMessage, SystemMessage, ToolMessage
+from langchain_core.messages import AIMessage, AnyMessage, SystemMessage, ToolMessage
 from langchain_core.runnables import Runnable
 from langchain_core.tools import BaseTool
 from langgraph.constants import END, START
 from langgraph.graph.state import StateGraph
+from langgraph.runtime import Runtime
+from langgraph.types import Send
 from langgraph.typing import ContextT
-from typing_extensions import TypedDict, TypeVar
+from typing_extensions import NotRequired, Required, TypedDict, TypeVar
 
 from langchain.agents.middleware.types import (
     AgentMiddleware,
     AgentState,
     JumpTo,
     ModelRequest,
+    OmitFromSchema,
     PublicAgentState,
 )
-
-# Import structured output classes from the old implementation
 from langchain.agents.structured_output import (
     MultipleStructuredOutputsError,
     OutputToolBinding,
@@ -37,26 +39,49 @@ from langchain.chat_models import init_chat_model
 STRUCTURED_OUTPUT_ERROR_TEMPLATE = "Error: {error}\n Please fix your mistakes."
 
 
-def _merge_state_schemas(schemas: list[type]) -> type:
-    """Merge multiple TypedDict schemas into a single schema with all fields."""
-    if not schemas:
-        return AgentState
+def _resolve_schema(schemas: set[type], schema_name: str, omit_flag: str | None = None) -> type:
+    """Resolve schema by merging schemas and optionally respecting OmitFromSchema annotations.
 
+    Args:
+        schemas: List of schema types to merge
+        schema_name: Name for the generated TypedDict
+        omit_flag: If specified, omit fields with this flag set ('input' or 'output')
+    """
     all_annotations = {}
 
     for schema in schemas:
-        all_annotations.update(schema.__annotations__)
+        hints = get_type_hints(schema, include_extras=True)
+
+        for field_name, field_type in hints.items():
+            should_omit = False
+
+            if omit_flag:
+                # Check for omission in the annotation metadata
+                metadata = _extract_metadata(field_type)
+                for meta in metadata:
+                    if isinstance(meta, OmitFromSchema) and getattr(meta, omit_flag) is True:
+                        should_omit = True
+                        break
+
+            if not should_omit:
+                all_annotations[field_name] = field_type
 
-    return TypedDict("MergedState", all_annotations)  # type: ignore[operator]
+    return TypedDict(schema_name, all_annotations)  # type: ignore[operator]
 
 
-def _filter_state_for_schema(state: dict[str, Any], schema: type) -> dict[str, Any]:
-    """Filter state to only include fields defined in the given schema."""
-    if not hasattr(schema, "__annotations__"):
-        return state
+def _extract_metadata(type_: type) -> list:
+    """Extract metadata from a field type, handling Required/NotRequired and Annotated wrappers."""
+    # Handle Required[Annotated[...]] or NotRequired[Annotated[...]]
+    if get_origin(type_) in (Required, NotRequired):
+        inner_type = get_args(type_)[0]
+        if get_origin(inner_type) is Annotated:
+            return list(get_args(inner_type)[1:])
 
-    schema_fields = set(schema.__annotations__.keys())
-    return {k: v for k, v in state.items() if k in schema_fields}
+    # Handle direct Annotated[...]
+    elif get_origin(type_) is Annotated:
+        return list(get_args(type_)[1:])
+
+    return []
 
 
 def _supports_native_structured_output(model: str | BaseChatModel) -> bool:
@@ -113,7 +138,7 @@ def create_agent(  # noqa: PLR0915
     model: str | BaseChatModel,
     tools: Sequence[BaseTool | Callable | dict[str, Any]] | ToolNode | None = None,
     system_prompt: str | None = None,
-    middleware: Sequence[AgentMiddleware] = (),
+    middleware: Sequence[AgentMiddleware[AgentState[ResponseT], ContextT]] = (),
     response_format: ResponseFormat[ResponseT] | type[ResponseT] | None = None,
     context_schema: type[ContextT] | None = None,
 ) -> StateGraph[
@@ -198,28 +223,30 @@ def create_agent(  # noqa: PLR0915
         m for m in middleware if m.__class__.after_model is not AgentMiddleware.after_model
     ]
 
-    # Collect all middleware state schemas and create merged schema
-    merged_state_schema: type[AgentState] = _merge_state_schemas(
-        [m.state_schema for m in middleware]
-    )
+    state_schemas = {m.state_schema for m in middleware}
+    state_schemas.add(AgentState)
+
+    state_schema = _resolve_schema(state_schemas, "StateSchema", None)
+    input_schema = _resolve_schema(state_schemas, "InputSchema", "input")
+    output_schema = _resolve_schema(state_schemas, "OutputSchema", "output")
 
     # create graph, add nodes
-    graph = StateGraph(
-        merged_state_schema,
-        input_schema=PublicAgentState,
-        output_schema=PublicAgentState,
+    graph: StateGraph[
+        AgentState[ResponseT], ContextT, PublicAgentState[ResponseT], PublicAgentState[ResponseT]
+    ] = StateGraph(
+        state_schema=state_schema,
+        input_schema=input_schema,
+        output_schema=output_schema,
         context_schema=context_schema,
     )
 
-    def _handle_model_output(state: dict[str, Any], output: AIMessage) -> dict[str, Any]:
+    def _handle_model_output(output: AIMessage) -> dict[str, Any]:
         """Handle model output including structured responses."""
         # Handle structured output with native strategy
         if isinstance(response_format, ProviderStrategy):
             if not output.tool_calls and native_output_binding:
                 structured_response = native_output_binding.parse(output)
                 return {"messages": [output], "response": structured_response}
-            if state.get("response") is not None:
-                return {"messages": [output], "response": None}
             return {"messages": [output]}
 
         # Handle structured output with tools strategy
@@ -297,9 +324,6 @@ def create_agent(  # noqa: PLR0915
                         ],
                     }
 
-        # Standard response handling
-        if state.get("response") is not None:
-            return {"messages": [output], "response": None}
         return {"messages": [output]}
 
     def _get_bound_model(request: ModelRequest) -> Runnable:
@@ -322,7 +346,14 @@ def create_agent(  # noqa: PLR0915
             )
         return request.model.bind(**request.model_settings)
 
-    def model_request(state: dict[str, Any]) -> dict[str, Any]:
+    model_request_signatures: list[
+        tuple[bool, AgentMiddleware[AgentState[ResponseT], ContextT]]
+    ] = [
+        ("runtime" in signature(m.modify_model_request).parameters, m)
+        for m in middleware_w_modify_model_request
+    ]
+
+    def model_request(state: AgentState, runtime: Runtime[ContextT]) -> dict[str, Any]:
         """Sync model request handler with sequential middleware processing."""
         request = ModelRequest(
             model=model,
@@ -334,10 +365,11 @@ def create_agent(  # noqa: PLR0915
         )
 
         # Apply modify_model_request middleware in sequence
-        for m in middleware_w_modify_model_request:
-            # Filter state to only include fields defined in this middleware's schema
-            filtered_state = _filter_state_for_schema(state, m.state_schema)
-            request = m.modify_model_request(request, filtered_state)
+        for use_runtime, m in model_request_signatures:
+            if use_runtime:
+                m.modify_model_request(request, state, runtime)
+            else:
+                m.modify_model_request(request, state)  # type: ignore[call-arg]
 
         # Get the final model and messages
         model_ = _get_bound_model(request)
@@ -346,9 +378,9 @@ def create_agent(  # noqa: PLR0915
             messages = [SystemMessage(request.system_prompt), *messages]
 
         output = model_.invoke(messages)
-        return _handle_model_output(state, output)
+        return _handle_model_output(output)
 
-    async def amodel_request(state: dict[str, Any]) -> dict[str, Any]:
+    async def amodel_request(state: AgentState, runtime: Runtime[ContextT]) -> dict[str, Any]:
         """Async model request handler with sequential middleware processing."""
         # Start with the base model request
         request = ModelRequest(
@@ -361,10 +393,11 @@ def create_agent(  # noqa: PLR0915
         )
 
         # Apply modify_model_request middleware in sequence
-        for m in middleware_w_modify_model_request:
-            # Filter state to only include fields defined in this middleware's schema
-            filtered_state = _filter_state_for_schema(state, m.state_schema)
-            request = m.modify_model_request(request, filtered_state)
+        for use_runtime, m in model_request_signatures:
+            if use_runtime:
+                m.modify_model_request(request, state, runtime)
+            else:
+                m.modify_model_request(request, state)  # type: ignore[call-arg]
 
         # Get the final model and messages
         model_ = _get_bound_model(request)
@@ -373,7 +406,7 @@ def create_agent(  # noqa: PLR0915
             messages = [SystemMessage(request.system_prompt), *messages]
 
         output = await model_.ainvoke(messages)
-        return _handle_model_output(state, output)
+        return _handle_model_output(output)
 
     # Use sync or async based on model capabilities
     from langgraph._internal._runnable import RunnableCallable
@@ -388,16 +421,12 @@ def create_agent(  # noqa: PLR0915
     for m in middleware:
         if m.__class__.before_model is not AgentMiddleware.before_model:
             graph.add_node(
-                f"{m.__class__.__name__}.before_model",
-                m.before_model,
-                input_schema=m.state_schema,
+                f"{m.__class__.__name__}.before_model", m.before_model, input_schema=state_schema
             )
 
         if m.__class__.after_model is not AgentMiddleware.after_model:
             graph.add_node(
-                f"{m.__class__.__name__}.after_model",
-                m.after_model,
-                input_schema=m.state_schema,
+                f"{m.__class__.__name__}.after_model", m.after_model, input_schema=state_schema
             )
 
     # add start edge
@@ -417,12 +446,12 @@ def create_agent(  # noqa: PLR0915
     if tool_node is not None:
         graph.add_conditional_edges(
             "tools",
-            _make_tools_to_model_edge(tool_node, first_node),
+            _make_tools_to_model_edge(tool_node, first_node, structured_output_tools),
             [first_node, END],
         )
         graph.add_conditional_edges(
             last_node,
-            _make_model_to_tools_edge(first_node, structured_output_tools),
+            _make_model_to_tools_edge(first_node, structured_output_tools, tool_node),
             [first_node, "tools", END],
         )
     elif last_node == "model_request":
@@ -481,27 +510,48 @@ def _resolve_jump(jump_to: JumpTo | None, first_node: str) -> str | None:
     return None
 
 
+def _fetch_last_ai_and_tool_messages(
+    messages: list[AnyMessage],
+) -> tuple[AIMessage, list[ToolMessage]]:
+    last_ai_index: int
+    last_ai_message: AIMessage
+
+    for i in range(len(messages) - 1, -1, -1):
+        if isinstance(messages[i], AIMessage):
+            last_ai_index = i
+            last_ai_message = cast("AIMessage", messages[i])
+            break
+
+    tool_messages = [m for m in messages[last_ai_index + 1 :] if isinstance(m, ToolMessage)]
+    return last_ai_message, tool_messages
+
+
 def _make_model_to_tools_edge(
-    first_node: str, structured_output_tools: dict[str, OutputToolBinding]
-) -> Callable[[AgentState], str | None]:
-    def model_to_tools(state: AgentState) -> str | None:
+    first_node: str, structured_output_tools: dict[str, OutputToolBinding], tool_node: ToolNode
+) -> Callable[[AgentState], str | list[Send] | None]:
+    def model_to_tools(state: AgentState) -> str | list[Send] | None:
         if jump_to := state.get("jump_to"):
             return _resolve_jump(jump_to, first_node)
 
-        message = state["messages"][-1]
-
-        # Check if this is a ToolMessage from structured output - if so, end
-        if isinstance(message, ToolMessage) and message.name in structured_output_tools:
-            return END
-
-        # Check for tool calls
-        if isinstance(message, AIMessage) and message.tool_calls:
-            # If all tool calls are for structured output, don't go to tools
-            non_structured_calls = [
-                tc for tc in message.tool_calls if tc["name"] not in structured_output_tools
+        last_ai_message, tool_messages = _fetch_last_ai_and_tool_messages(state["messages"])
+        tool_message_ids = [m.tool_call_id for m in tool_messages]
+
+        pending_tool_calls = [
+            c
+            for c in last_ai_message.tool_calls
+            if c["id"] not in tool_message_ids and c["name"] not in structured_output_tools
+        ]
+
+        if pending_tool_calls:
+            # imo we should not be injecting state, store here,
+            # this should be done by the tool node itself ideally but this is a consequence
+            # of using Send w/ tool calls directly which allows more intuitive interrupt behavior
+            # largely internal so can be fixed later
+            pending_tool_calls = [
+                tool_node.inject_tool_args(call, state, None)  # type: ignore[arg-type]
+                for call in pending_tool_calls
             ]
-            if non_structured_calls:
-                return "tools"
+            return [Send("tools", [tool_call]) for tool_call in pending_tool_calls]
 
         return END
 
@@ -509,17 +559,21 @@ def _make_model_to_tools_edge(
 
 
 def _make_tools_to_model_edge(
-    tool_node: ToolNode, next_node: str
+    tool_node: ToolNode, next_node: str, structured_output_tools: dict[str, OutputToolBinding]
 ) -> Callable[[AgentState], str | None]:
     def tools_to_model(state: AgentState) -> str | None:
-        ai_message = [m for m in state["messages"] if isinstance(m, AIMessage)][-1]
+        last_ai_message, tool_messages = _fetch_last_ai_and_tool_messages(state["messages"])
+
         if all(
             tool_node.tools_by_name[c["name"]].return_direct
-            for c in ai_message.tool_calls
+            for c in last_ai_message.tool_calls
             if c["name"] in tool_node.tools_by_name
         ):
             return END
 
+        if any(t.name in structured_output_tools for t in tool_messages):
+            return END
+
         return next_node
 
     return tools_to_model

{langchain-1.0.0a5.dist-info → langchain-1.0.0a6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain
-Version: 1.0.0a5
+Version: 1.0.0a6
 Summary: Building applications with LLMs through composability
 License: MIT
 Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/langchain
@@ -11,12 +11,16 @@ Requires-Dist: langchain-core<2.0.0,>=0.3.75
 Requires-Dist: langchain-text-splitters<1.0.0,>=0.3.11
 Requires-Dist: langgraph>=0.6.7
 Requires-Dist: pydantic>=2.7.4
+Provides-Extra: community
+Requires-Dist: langchain-community; extra == "community"
 Provides-Extra: anthropic
 Requires-Dist: langchain-anthropic; extra == "anthropic"
 Provides-Extra: openai
 Requires-Dist: langchain-openai; extra == "openai"
 Provides-Extra: azure-ai
 Requires-Dist: langchain-azure-ai; extra == "azure-ai"
+Provides-Extra: cohere
+Requires-Dist: langchain-cohere; extra == "cohere"
 Provides-Extra: google-vertexai
 Requires-Dist: langchain-google-vertexai; extra == "google-vertexai"
 Provides-Extra: google-genai

{langchain-1.0.0a5.dist-info → langchain-1.0.0a6.dist-info}/RECORD

@@ -1,7 +1,7 @@
-langchain-1.0.0a5.dist-info/METADATA,sha256=jLS1O5F9tpkBC2XfYfwNhOYRKtUCDQHaqL_aAcW1ydM,6079
-langchain-1.0.0a5.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-langchain-1.0.0a5.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-langchain-1.0.0a5.dist-info/licenses/LICENSE,sha256=TsZ-TKbmch26hJssqCJhWXyGph7iFLvyFBYAa3stBHg,1067
+langchain-1.0.0a6.dist-info/METADATA,sha256=aQuJBnnQyJd-FIIP8hM5wyak8eIB0IydkPjHePq5doo,6236
+langchain-1.0.0a6.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+langchain-1.0.0a6.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+langchain-1.0.0a6.dist-info/licenses/LICENSE,sha256=TsZ-TKbmch26hJssqCJhWXyGph7iFLvyFBYAa3stBHg,1067
 langchain/__init__.py,sha256=PFBJL2dLkGgUXz9JY16bIhvoo4rwZryOiatsWVexLJk,604
 langchain/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langchain/_internal/_documents.py,sha256=z9wAPukoASOMw4WTFFBKCCZYsvsKbo-Cq6CeHjdq9eE,1045
@@ -12,14 +12,13 @@ langchain/_internal/_utils.py,sha256=lG8X9muiRAWtQjRPudq-1x-wHbk0J3spu_rYZckVdYs
 langchain/agents/__init__.py,sha256=NG2S3dic9L3i4sAD9mpgaTv6Dl4L3u45xxK6jn-I4W8,281
 langchain/agents/_internal/__init__.py,sha256=5nNBeaeQIvv9IOQjY4_aNW8pffWzMXQgi0b6Nx-WghM,37
 langchain/agents/_internal/_typing.py,sha256=JoWa-KL5uLNeq6yrm56wnIvhDeFnCt2fTzgUcj5zWy4,270
-langchain/agents/interrupt.py,sha256=bhfWERwjoZf7YfH5kw3NFahi4jh_dAyjqPj2vfdIEUU,3318
-langchain/agents/middleware/__init__.py,sha256=qS6U6996Ypsiu4ZbV20pRoWmzZS3zD86ZOJo3794W9M,446
-langchain/agents/middleware/_utils.py,sha256=XMEwKA5WjALrHcU3k89KzMxOytn5Nt_j2IwB7hIk7_I,359
-langchain/agents/middleware/human_in_the_loop.py,sha256=p-P8L-fz-ZaUoWpaY-8TAm5wXdAXPfU0xltPTS-KZvI,4937
-langchain/agents/middleware/prompt_caching.py,sha256=mjEf1nzRnNZ2pjUmBibKWL48Ouv8fnDq9KjrQKJ6qUU,2261
-langchain/agents/middleware/summarization.py,sha256=1ZQ8Q_eBqUy-dXFmNzjZ4yV2UmPwMb1vAnk7XFYZgMI,10255
-langchain/agents/middleware/types.py,sha256=ODGEtDDw53hV9aDKAiDP7Ig0SiiVtCGRCcBYKsqZuEI,2674
-langchain/agents/middleware_agent.py,sha256=Qy1QnX9c3MArYqZtpFNUDgcvgPFrui1cyEYRevMn5W0,21429
+langchain/agents/middleware/__init__.py,sha256=Q68coEBPtxTnb7LuDDSKvUrK0RvppqEwyyzpE8-RgiE,613
+langchain/agents/middleware/dynamic_system_prompt.py,sha256=uakW4wyVc9h52T2QO4BeKWmbc2UK31VqFGuMMvj9wX8,3267
+langchain/agents/middleware/human_in_the_loop.py,sha256=xBP_Xc8ZMLUeWLzJyd4GH77mUapsL_7ilKDNLd8_tjE,10091
+langchain/agents/middleware/prompt_caching.py,sha256=du_qrBr0_kwWhdO_xggtfrEN5FTcGLKu3oYQDnSS0Do,2263
+langchain/agents/middleware/summarization.py,sha256=qqEqAuJXQ5rfewhFHftHLnrX8jhdMu9dPfz0akhzfuc,10281
+langchain/agents/middleware/types.py,sha256=DRsl0GjgWXbPlFTiiVnI8pMhzMJF3Y2VkE2zLMKQhaY,3826
+langchain/agents/middleware_agent.py,sha256=hfIt4LdtDjkZGs0ylo8xti67iecpPEsuklYCjJ20V8k,23746
 langchain/agents/react_agent.py,sha256=6ZNI2dp0hTL7hTm7ao-HkQ3hmVvBQuFu9pJz0PSK_eg,49712
 langchain/agents/structured_output.py,sha256=QWNafJx7au_jJawJgIfovnDoP8Z9mLxDZNvDX_1RRJ0,13327
 langchain/agents/tool_node.py,sha256=QabTfIi8nGrwfzaSOeWfyHos6sgXjFTdRXexQG7u2HE,46596
@@ -37,4 +36,4 @@ langchain/storage/exceptions.py,sha256=Fl_8tON3KmByBKwXtno5WSj0-c2RiZxnhw3gv5aS2
 langchain/storage/in_memory.py,sha256=ozrmu0EtaJJVSAzK_u7nzxWpr9OOscWkANHSg-qIVYQ,369
 langchain/text_splitter.py,sha256=yxWs4secpnkfK6VZDiNJNdlYOrRZ18RQZj1S3xNQ73A,1554
 langchain/tools/__init__.py,sha256=NYQzLxW2iI5Twu3voefVC-dJEI4Wgh7jC311CQEpvZs,252
-langchain-1.0.0a5.dist-info/RECORD,,
+langchain-1.0.0a6.dist-info/RECORD,,

langchain/agents/interrupt.py

@@ -1,97 +0,0 @@
-"""Interrupt types to use with agent inbox like setups."""
-
-from typing import Literal
-
-from typing_extensions import TypedDict
-
-
-class HumanInterruptConfig(TypedDict):
-    """Configuration that defines what actions are allowed for a human interrupt.
-
-    This controls the available interaction options when the graph is paused for human input.
-
-    Attributes:
-        allow_ignore: Whether the human can choose to ignore/skip the current step
-        allow_respond: Whether the human can provide a text response/feedback
-        allow_edit: Whether the human can edit the provided content/state
-        allow_accept: Whether the human can accept/approve the current state
-    """
-
-    allow_ignore: bool
-    allow_respond: bool
-    allow_edit: bool
-    allow_accept: bool
-
-
-class ActionRequest(TypedDict):
-    """Represents a request for human action within the graph execution.
-
-    Contains the action type and any associated arguments needed for the action.
-
-    Attributes:
-        action: The type or name of action being requested (e.g., "Approve XYZ action")
-        args: Key-value pairs of arguments needed for the action
-    """
-
-    action: str
-    args: dict
-
-
-class HumanInterrupt(TypedDict):
-    """Represents an interrupt triggered by the graph that requires human intervention.
-
-    This is passed to the `interrupt` function when execution is paused for human input.
-
-    Attributes:
-        action_request: The specific action being requested from the human
-        config: Configuration defining what actions are allowed
-        description: Optional detailed description of what input is needed
-
-    Example:
-        ```python
-        # Extract a tool call from the state and create an interrupt request
-        request = HumanInterrupt(
-            action_request=ActionRequest(
-                action="run_command",  # The action being requested
-                args={"command": "ls", "args": ["-l"]},  # Arguments for the action
-            ),
-            config=HumanInterruptConfig(
-                allow_ignore=True,  # Allow skipping this step
-                allow_respond=True,  # Allow text feedback
-                allow_edit=False,  # Don't allow editing
-                allow_accept=True,  # Allow direct acceptance
-            ),
-            description="Please review the command before execution",
-        )
-        # Send the interrupt request and get the response
-        response = interrupt([request])[0]
-        ```
-    """
-
-    action_request: ActionRequest
-    config: HumanInterruptConfig
-    description: str | None
-
-
-class HumanResponse(TypedDict):
-    """Human response.
-
-    The response provided by a human to an interrupt,
-    which is returned when graph execution resumes.
-
-    Attributes:
-        type: The type of response:
-
-            - "accept": Approves the current state without changes
-            - "ignore": Skips/ignores the current step
-            - "response": Provides text feedback or instructions
-            - "edit": Modifies the current state/content
-        args: The response payload:
-
-            - None: For ignore/accept actions
-            - str: For text responses
-            - ActionRequest: For edit actions with updated content
-    """
-
-    type: Literal["accept", "ignore", "response", "edit"]
-    args: None | str | ActionRequest

langchain/agents/middleware/_utils.py

@@ -1,11 +0,0 @@
-"""Utility functions for middleware."""
-
-from typing import Any
-
-
-def _generate_correction_tool_messages(content: str, tool_calls: list) -> list[dict[str, Any]]:
-    """Generate tool messages for model behavior correction."""
-    return [
-        {"role": "tool", "content": content, "tool_call_id": tool_call["id"]}
-        for tool_call in tool_calls
-    ]