langchain 1.0.0a7__py3-none-any.whl → 1.0.0a8__py3-none-any.whl

langchain/agents/middleware/__init__.py

@@ -1,6 +1,5 @@
 """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
@@ -11,7 +10,6 @@ __all__ = [
     "AgentState",
     # should move to langchain-anthropic if we decide to keep it
     "AnthropicPromptCachingMiddleware",
-    "DynamicSystemPromptMiddleware",
     "HumanInTheLoopMiddleware",
     "ModelRequest",
     "SummarizationMiddleware",

langchain/agents/middleware/human_in_the_loop.py

@@ -112,14 +112,14 @@ class HumanInTheLoopMiddleware(AgentMiddleware):
 
     def __init__(
         self,
-        tool_configs: dict[str, bool | ToolConfig],
+        interrupt_on: dict[str, bool | ToolConfig],
         *,
         description_prefix: str = "Tool execution requires approval",
     ) -> None:
         """Initialize the human in the loop middleware.
 
         Args:
-            tool_configs: Mapping of tool name to allowed actions.
+            interrupt_on: 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.
@@ -130,7 +130,7 @@ class HumanInTheLoopMiddleware(AgentMiddleware):
         """
         super().__init__()
         resolved_tool_configs: dict[str, ToolConfig] = {}
-        for tool_name, tool_config in tool_configs.items():
+        for tool_name, tool_config in interrupt_on.items():
             if isinstance(tool_config, bool):
                 if tool_config is True:
                     resolved_tool_configs[tool_name] = ToolConfig(
@@ -138,13 +138,15 @@ class HumanInTheLoopMiddleware(AgentMiddleware):
                         allow_edit=True,
                         allow_respond=True,
                     )
-            else:
+            elif any(
+                tool_config.get(x, False) for x in ["allow_accept", "allow_edit", "allow_respond"]
+            ):
                 resolved_tool_configs[tool_name] = tool_config
-        self.tool_configs = resolved_tool_configs
+        self.interrupt_on = resolved_tool_configs
         self.description_prefix = description_prefix
 
     def after_model(self, state: AgentState) -> dict[str, Any] | None:  # type: ignore[override]
-        """Trigger HITL flows for relevant tool calls after an AIMessage."""
+        """Trigger interrupt flows for relevant tool calls after an AIMessage."""
         messages = state["messages"]
         if not messages:
             return None
@@ -154,16 +156,16 @@ class HumanInTheLoopMiddleware(AgentMiddleware):
             return None
 
         # Separate tool calls that need interrupts from those that don't
-        hitl_tool_calls: list[ToolCall] = []
+        interrupt_tool_calls: list[ToolCall] = []
         auto_approved_tool_calls = []
 
         for tool_call in last_ai_msg.tool_calls:
-            hitl_tool_calls.append(tool_call) if tool_call[
+            interrupt_tool_calls.append(tool_call) if tool_call[
                 "name"
-            ] in self.tool_configs else auto_approved_tool_calls.append(tool_call)
+            ] in self.interrupt_on else auto_approved_tool_calls.append(tool_call)
 
         # If no interrupts needed, return early
-        if not hitl_tool_calls:
+        if not interrupt_tool_calls:
             return None
 
         # Process all tool calls that require interrupts
@@ -171,11 +173,11 @@ class HumanInTheLoopMiddleware(AgentMiddleware):
         artificial_tool_messages: list[ToolMessage] = []
 
         # Create interrupt requests for all tools that need approval
-        hitl_requests: list[HumanInTheLoopRequest] = []
-        for tool_call in hitl_tool_calls:
+        interrupt_requests: list[HumanInTheLoopRequest] = []
+        for tool_call in interrupt_tool_calls:
             tool_name = tool_call["name"]
             tool_args = tool_call["args"]
-            config = self.tool_configs[tool_name]
+            config = self.interrupt_on[tool_name]
             description = (
                 config.get("description")
                 or f"{self.description_prefix}\n\nTool: {tool_name}\nArgs: {tool_args}"
@@ -189,21 +191,23 @@ class HumanInTheLoopMiddleware(AgentMiddleware):
                 "config": config,
                 "description": description,
             }
-            hitl_requests.append(request)
+            interrupt_requests.append(request)
 
-        responses: list[HumanInTheLoopResponse] = interrupt(hitl_requests)
+        responses: list[HumanInTheLoopResponse] = interrupt(interrupt_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)):
+        if (responses_len := len(responses)) != (
+            interrupt_tool_calls_len := len(interrupt_tool_calls)
+        ):
             msg = (
                 f"Number of human responses ({responses_len}) does not match "
-                f"number of hanging tool calls ({hitl_tool_calls_len})."
+                f"number of hanging tool calls ({interrupt_tool_calls_len})."
             )
             raise ValueError(msg)
 
         for i, response in enumerate(responses):
-            tool_call = hitl_tool_calls[i]
-            config = self.tool_configs[tool_call["name"]]
+            tool_call = interrupt_tool_calls[i]
+            config = self.interrupt_on[tool_call["name"]]
 
             if response["type"] == "accept" and config.get("allow_accept"):
                 approved_tool_calls.append(tool_call)

langchain/agents/middleware/prompt_caching.py

@@ -1,6 +1,7 @@
 """Anthropic prompt caching middleware."""
 
 from typing import Literal
+from warnings import warn
 
 from langchain.agents.middleware.types import AgentMiddleware, ModelRequest
 
@@ -19,6 +20,7 @@ class AnthropicPromptCachingMiddleware(AgentMiddleware):
         type: Literal["ephemeral"] = "ephemeral",
         ttl: Literal["5m", "1h"] = "5m",
         min_messages_to_cache: int = 0,
+        unsupported_model_behavior: Literal["ignore", "warn", "raise"] = "warn",
     ) -> None:
         """Initialize the middleware with cache control settings.
 
@@ -27,10 +29,15 @@ class AnthropicPromptCachingMiddleware(AgentMiddleware):
             ttl: The time to live for the cache, only "5m" and "1h" are supported.
             min_messages_to_cache: The minimum number of messages until the cache is used,
                 default is 0.
+            unsupported_model_behavior: The behavior to take when an unsupported model is used.
+                "ignore" will ignore the unsupported model and continue without caching.
+                "warn" will warn the user and continue without caching.
+                "raise" will raise an error and stop the agent.
         """
         self.type = type
         self.ttl = ttl
         self.min_messages_to_cache = min_messages_to_cache
+        self.unsupported_model_behavior = unsupported_model_behavior
 
     def modify_model_request(  # type: ignore[override]
         self,
@@ -40,19 +47,29 @@ class AnthropicPromptCachingMiddleware(AgentMiddleware):
         try:
             from langchain_anthropic import ChatAnthropic
         except ImportError:
+            ChatAnthropic = None  # noqa: N806
+
+        msg: str | None = None
+
+        if ChatAnthropic is None:
             msg = (
                 "AnthropicPromptCachingMiddleware caching middleware only supports "
-                "Anthropic models."
+                "Anthropic models. "
                 "Please install langchain-anthropic."
             )
-            raise ValueError(msg)
-
-        if not isinstance(request.model, ChatAnthropic):
+        elif not isinstance(request.model, ChatAnthropic):
             msg = (
                 "AnthropicPromptCachingMiddleware caching middleware only supports "
                 f"Anthropic models, not instances of {type(request.model)}"
             )
-            raise ValueError(msg)
+
+        if msg is not None:
+            if self.unsupported_model_behavior == "raise":
+                raise ValueError(msg)
+            if self.unsupported_model_behavior == "warn":
+                warn(msg, stacklevel=3)
+            else:
+                return request
 
         messages_count = (
             len(request.messages) + 1 if request.system_prompt else len(request.messages)

langchain/agents/middleware/types.py

@@ -3,7 +3,20 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Annotated, Any, Generic, Literal, cast
+from inspect import signature
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    ClassVar,
+    Generic,
+    Literal,
+    Protocol,
+    TypeAlias,
+    TypeGuard,
+    cast,
+    overload,
+)
 
 # needed as top level import for pydantic schema generation on AgentState
 from langchain_core.messages import AnyMessage  # noqa: TC002
@@ -14,9 +27,12 @@ from langgraph.typing import ContextT
 from typing_extensions import NotRequired, Required, TypedDict, TypeVar
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from langchain_core.language_models.chat_models import BaseChatModel
     from langchain_core.tools import BaseTool
     from langgraph.runtime import Runtime
+    from langgraph.types import Command
 
     from langchain.agents.structured_output import ResponseFormat
 
@@ -88,6 +104,7 @@ class PublicAgentState(TypedDict, Generic[ResponseT]):
 
 
 StateT = TypeVar("StateT", bound=AgentState, default=AgentState)
+StateT_contra = TypeVar("StateT_contra", bound=AgentState, contravariant=True)
 
 
 class AgentMiddleware(Generic[StateT, ContextT]):
@@ -103,6 +120,12 @@ class AgentMiddleware(Generic[StateT, ContextT]):
     tools: list[BaseTool]
     """Additional tools registered by the middleware."""
 
+    before_model_jump_to: ClassVar[list[JumpTo]] = []
+    """Valid jump destinations for before_model hook. Used to establish conditional edges."""
+
+    after_model_jump_to: ClassVar[list[JumpTo]] = []
+    """Valid jump destinations for after_model hook. Used to establish conditional edges."""
+
     def before_model(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None:
         """Logic to run before the model is called."""
 
@@ -117,3 +140,404 @@ class AgentMiddleware(Generic[StateT, ContextT]):
 
     def after_model(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None:
         """Logic to run after the model is called."""
+
+
+class _CallableWithState(Protocol[StateT_contra]):
+    """Callable with AgentState as argument."""
+
+    def __call__(self, state: StateT_contra) -> dict[str, Any] | Command | None:
+        """Perform some logic with the state."""
+        ...
+
+
+class _CallableWithStateAndRuntime(Protocol[StateT_contra, ContextT]):
+    """Callable with AgentState and Runtime as arguments."""
+
+    def __call__(
+        self, state: StateT_contra, runtime: Runtime[ContextT]
+    ) -> dict[str, Any] | Command | None:
+        """Perform some logic with the state and runtime."""
+        ...
+
+
+class _CallableWithModelRequestAndState(Protocol[StateT_contra]):
+    """Callable with ModelRequest and AgentState as arguments."""
+
+    def __call__(self, request: ModelRequest, state: StateT_contra) -> ModelRequest:
+        """Perform some logic with the model request and state."""
+        ...
+
+
+class _CallableWithModelRequestAndStateAndRuntime(Protocol[StateT_contra, ContextT]):
+    """Callable with ModelRequest, AgentState, and Runtime as arguments."""
+
+    def __call__(
+        self, request: ModelRequest, state: StateT_contra, runtime: Runtime[ContextT]
+    ) -> ModelRequest:
+        """Perform some logic with the model request, state, and runtime."""
+        ...
+
+
+_NodeSignature: TypeAlias = (
+    _CallableWithState[StateT] | _CallableWithStateAndRuntime[StateT, ContextT]
+)
+_ModelRequestSignature: TypeAlias = (
+    _CallableWithModelRequestAndState[StateT]
+    | _CallableWithModelRequestAndStateAndRuntime[StateT, ContextT]
+)
+
+
+def is_callable_with_runtime(
+    func: _NodeSignature[StateT, ContextT],
+) -> TypeGuard[_CallableWithStateAndRuntime[StateT, ContextT]]:
+    return "runtime" in signature(func).parameters
+
+
+def is_callable_with_runtime_and_request(
+    func: _ModelRequestSignature[StateT, ContextT],
+) -> TypeGuard[_CallableWithModelRequestAndStateAndRuntime[StateT, ContextT]]:
+    return "runtime" in signature(func).parameters
+
+
+@overload
+def before_model(
+    func: _NodeSignature[StateT, ContextT],
+) -> AgentMiddleware[StateT, ContextT]: ...
+
+
+@overload
+def before_model(
+    func: None = None,
+    *,
+    state_schema: type[StateT] | None = None,
+    tools: list[BaseTool] | None = None,
+    jump_to: list[JumpTo] | None = None,
+    name: str | None = None,
+) -> Callable[[_NodeSignature[StateT, ContextT]], AgentMiddleware[StateT, ContextT]]: ...
+
+
+def before_model(
+    func: _NodeSignature[StateT, ContextT] | None = None,
+    *,
+    state_schema: type[StateT] | None = None,
+    tools: list[BaseTool] | None = None,
+    jump_to: list[JumpTo] | None = None,
+    name: str | None = None,
+) -> (
+    Callable[[_NodeSignature[StateT, ContextT]], AgentMiddleware[StateT, ContextT]]
+    | AgentMiddleware[StateT, ContextT]
+):
+    """Decorator used to dynamically create a middleware with the before_model hook.
+
+    Args:
+        func: The function to be decorated. Can accept either:
+            - `state: StateT` - Just the agent state
+            - `state: StateT, runtime: Runtime[ContextT]` - State and runtime context
+        state_schema: Optional custom state schema type. If not provided, uses the default
+            AgentState schema.
+        tools: Optional list of additional tools to register with this middleware.
+        jump_to: Optional list of valid jump destinations for conditional edges.
+            Valid values are: "tools", "model", "__end__"
+        name: Optional name for the generated middleware class. If not provided,
+            uses the decorated function's name.
+
+    Returns:
+        Either an AgentMiddleware instance (if func is provided directly) or a decorator function
+        that can be applied to a function its wrapping.
+
+    The decorated function should return:
+        - `dict[str, Any]` - State updates to merge into the agent state
+        - `Command` - A command to control flow (e.g., jump to different node)
+        - `None` - No state updates or flow control
+
+    Examples:
+        Basic usage with state only:
+        ```python
+        @before_model
+        def log_before_model(state: AgentState) -> None:
+            print(f"About to call model with {len(state['messages'])} messages")
+        ```
+
+        Advanced usage with runtime and conditional jumping:
+        ```python
+        @before_model(jump_to=["__end__"])
+        def conditional_before_model(state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
+            if some_condition(state):
+                return {"jump_to": "__end__"}
+            return None
+        ```
+
+        With custom state schema:
+        ```python
+        @before_model(
+            state_schema=MyCustomState,
+        )
+        def custom_before_model(state: MyCustomState) -> dict[str, Any]:
+            return {"custom_field": "updated_value"}
+        ```
+    """
+
+    def decorator(func: _NodeSignature[StateT, ContextT]) -> AgentMiddleware[StateT, ContextT]:
+        if is_callable_with_runtime(func):
+
+            def wrapped_with_runtime(
+                self: AgentMiddleware[StateT, ContextT],  # noqa: ARG001
+                state: StateT,
+                runtime: Runtime[ContextT],
+            ) -> dict[str, Any] | Command | None:
+                return func(state, runtime)
+
+            wrapped = wrapped_with_runtime
+        else:
+
+            def wrapped_without_runtime(
+                self: AgentMiddleware[StateT, ContextT],  # noqa: ARG001
+                state: StateT,
+            ) -> dict[str, Any] | Command | None:
+                return func(state)  # type: ignore[call-arg]
+
+            wrapped = wrapped_without_runtime  # type: ignore[assignment]
+
+        # Use function name as default if no name provided
+        middleware_name = name or cast("str", getattr(func, "__name__", "BeforeModelMiddleware"))
+
+        return type(
+            middleware_name,
+            (AgentMiddleware,),
+            {
+                "state_schema": state_schema or AgentState,
+                "tools": tools or [],
+                "before_model_jump_to": jump_to or [],
+                "before_model": wrapped,
+            },
+        )()
+
+    if func is not None:
+        return decorator(func)
+    return decorator
+
+
+@overload
+def modify_model_request(
+    func: _ModelRequestSignature[StateT, ContextT],
+) -> AgentMiddleware[StateT, ContextT]: ...
+
+
+@overload
+def modify_model_request(
+    func: None = None,
+    *,
+    state_schema: type[StateT] | None = None,
+    tools: list[BaseTool] | None = None,
+    name: str | None = None,
+) -> Callable[[_ModelRequestSignature[StateT, ContextT]], AgentMiddleware[StateT, ContextT]]: ...
+
+
+def modify_model_request(
+    func: _ModelRequestSignature[StateT, ContextT] | None = None,
+    *,
+    state_schema: type[StateT] | None = None,
+    tools: list[BaseTool] | None = None,
+    name: str | None = None,
+) -> (
+    Callable[[_ModelRequestSignature[StateT, ContextT]], AgentMiddleware[StateT, ContextT]]
+    | AgentMiddleware[StateT, ContextT]
+):
+    r"""Decorator used to dynamically create a middleware with the modify_model_request hook.
+
+    Args:
+        func: The function to be decorated. Can accept either:
+            - `request: ModelRequest, state: StateT` - Model request and agent state
+            - `request: ModelRequest, state: StateT, runtime: Runtime[ContextT]` -
+              Model request, state, and runtime context
+        state_schema: Optional custom state schema type. If not provided, uses the default
+            AgentState schema.
+        tools: Optional list of additional tools to register with this middleware.
+        name: Optional name for the generated middleware class. If not provided,
+            uses the decorated function's name.
+
+    Returns:
+        Either an AgentMiddleware instance (if func is provided) or a decorator function
+        that can be applied to a function.
+
+    The decorated function should return:
+        - `ModelRequest` - The modified model request to be sent to the language model
+
+    Examples:
+        Basic usage to modify system prompt:
+        ```python
+        @modify_model_request
+        def add_context_to_prompt(request: ModelRequest, state: AgentState) -> ModelRequest:
+            if request.system_prompt:
+                request.system_prompt += "\n\nAdditional context: ..."
+            else:
+                request.system_prompt = "Additional context: ..."
+            return request
+        ```
+
+        Advanced usage with runtime and custom model settings:
+        ```python
+        @modify_model_request
+        def dynamic_model_settings(
+            request: ModelRequest, state: AgentState, runtime: Runtime
+        ) -> ModelRequest:
+            # Use a different model based on user subscription tier
+            if runtime.context.get("subscription_tier") == "premium":
+                request.model = "gpt-4o"
+            else:
+                request.model = "gpt-4o-mini"
+
+            return request
+        ```
+    """
+
+    def decorator(
+        func: _ModelRequestSignature[StateT, ContextT],
+    ) -> AgentMiddleware[StateT, ContextT]:
+        if is_callable_with_runtime_and_request(func):
+
+            def wrapped_with_runtime(
+                self: AgentMiddleware[StateT, ContextT],  # noqa: ARG001
+                request: ModelRequest,
+                state: StateT,
+                runtime: Runtime[ContextT],
+            ) -> ModelRequest:
+                return func(request, state, runtime)
+
+            wrapped = wrapped_with_runtime
+        else:
+
+            def wrapped_without_runtime(
+                self: AgentMiddleware[StateT, ContextT],  # noqa: ARG001
+                request: ModelRequest,
+                state: StateT,
+            ) -> ModelRequest:
+                return func(request, state)  # type: ignore[call-arg]
+
+            wrapped = wrapped_without_runtime  # type: ignore[assignment]
+
+        # Use function name as default if no name provided
+        middleware_name = name or cast(
+            "str", getattr(func, "__name__", "ModifyModelRequestMiddleware")
+        )
+
+        return type(
+            middleware_name,
+            (AgentMiddleware,),
+            {
+                "state_schema": state_schema or AgentState,
+                "tools": tools or [],
+                "modify_model_request": wrapped,
+            },
+        )()
+
+    if func is not None:
+        return decorator(func)
+    return decorator
+
+
+@overload
+def after_model(
+    func: _NodeSignature[StateT, ContextT],
+) -> AgentMiddleware[StateT, ContextT]: ...
+
+
+@overload
+def after_model(
+    func: None = None,
+    *,
+    state_schema: type[StateT] | None = None,
+    tools: list[BaseTool] | None = None,
+    jump_to: list[JumpTo] | None = None,
+    name: str | None = None,
+) -> Callable[[_NodeSignature[StateT, ContextT]], AgentMiddleware[StateT, ContextT]]: ...
+
+
+def after_model(
+    func: _NodeSignature[StateT, ContextT] | None = None,
+    *,
+    state_schema: type[StateT] | None = None,
+    tools: list[BaseTool] | None = None,
+    jump_to: list[JumpTo] | None = None,
+    name: str | None = None,
+) -> (
+    Callable[[_NodeSignature[StateT, ContextT]], AgentMiddleware[StateT, ContextT]]
+    | AgentMiddleware[StateT, ContextT]
+):
+    """Decorator used to dynamically create a middleware with the after_model hook.
+
+    Args:
+        func: The function to be decorated. Can accept either:
+            - `state: StateT` - Just the agent state (includes model response)
+            - `state: StateT, runtime: Runtime[ContextT]` - State and runtime context
+        state_schema: Optional custom state schema type. If not provided, uses the default
+            AgentState schema.
+        tools: Optional list of additional tools to register with this middleware.
+        jump_to: Optional list of valid jump destinations for conditional edges.
+            Valid values are: "tools", "model", "__end__"
+        name: Optional name for the generated middleware class. If not provided,
+            uses the decorated function's name.
+
+    Returns:
+        Either an AgentMiddleware instance (if func is provided) or a decorator function
+        that can be applied to a function.
+
+    The decorated function should return:
+        - `dict[str, Any]` - State updates to merge into the agent state
+        - `Command` - A command to control flow (e.g., jump to different node)
+        - `None` - No state updates or flow control
+
+    Examples:
+        Basic usage for logging model responses:
+        ```python
+        @after_model
+        def log_latest_message(state: AgentState) -> None:
+            print(state["messages"][-1].content)
+        ```
+
+        With custom state schema:
+        ```python
+        @after_model(state_schema=MyCustomState, name="MyAfterModelMiddleware")
+        def custom_after_model(state: MyCustomState) -> dict[str, Any]:
+            return {"custom_field": "updated_after_model"}
+        ```
+    """
+
+    def decorator(func: _NodeSignature[StateT, ContextT]) -> AgentMiddleware[StateT, ContextT]:
+        if is_callable_with_runtime(func):
+
+            def wrapped_with_runtime(
+                self: AgentMiddleware[StateT, ContextT],  # noqa: ARG001
+                state: StateT,
+                runtime: Runtime[ContextT],
+            ) -> dict[str, Any] | Command | None:
+                return func(state, runtime)
+
+            wrapped = wrapped_with_runtime
+        else:
+
+            def wrapped_without_runtime(
+                self: AgentMiddleware[StateT, ContextT],  # noqa: ARG001
+                state: StateT,
+            ) -> dict[str, Any] | Command | None:
+                return func(state)  # type: ignore[call-arg]
+
+            wrapped = wrapped_without_runtime  # type: ignore[assignment]
+
+        # Use function name as default if no name provided
+        middleware_name = name or cast("str", getattr(func, "__name__", "AfterModelMiddleware"))
+
+        return type(
+            middleware_name,
+            (AgentMiddleware,),
+            {
+                "state_schema": state_schema or AgentState,
+                "tools": tools or [],
+                "after_model_jump_to": jump_to or [],
+                "after_model": wrapped,
+            },
+        )()
+
+    if func is not None:
+        return decorator(func)
+    return decorator

langchain/agents/middleware_agent.py

@@ -464,7 +464,7 @@ def create_agent(  # noqa: PLR0915
             f"{middleware_w_after[0].__class__.__name__}.after_model",
             END,
             first_node,
-            tools_available=tool_node is not None,
+            jump_to=middleware_w_after[0].after_model_jump_to,
         )
 
     # Add middleware edges (same as before)
@@ -475,7 +475,7 @@ def create_agent(  # noqa: PLR0915
                 f"{m1.__class__.__name__}.before_model",
                 f"{m2.__class__.__name__}.before_model",
                 first_node,
-                tools_available=tool_node is not None,
+                jump_to=m1.before_model_jump_to,
             )
         # Go directly to model_request after the last before_model
         _add_middleware_edge(
@@ -483,7 +483,7 @@ def create_agent(  # noqa: PLR0915
             f"{middleware_w_before[-1].__class__.__name__}.before_model",
             "model_request",
             first_node,
-            tools_available=tool_node is not None,
+            jump_to=middleware_w_before[-1].before_model_jump_to,
         )
 
     if middleware_w_after:
@@ -496,7 +496,7 @@ def create_agent(  # noqa: PLR0915
                 f"{m1.__class__.__name__}.after_model",
                 f"{m2.__class__.__name__}.after_model",
                 first_node,
-                tools_available=tool_node is not None,
+                jump_to=m1.after_model_jump_to,
             )
 
     return graph
@@ -528,8 +528,8 @@ def _fetch_last_ai_and_tool_messages(
 
 def _make_model_to_tools_edge(
     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:
+) -> Callable[[dict[str, Any]], str | list[Send] | None]:
+    def model_to_tools(state: dict[str, Any]) -> str | list[Send] | None:
         if jump_to := state.get("jump_to"):
             return _resolve_jump(jump_to, first_node)
 
@@ -548,8 +548,7 @@ def _make_model_to_tools_edge(
             # 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
+                tool_node.inject_tool_args(call, state, None) for call in pending_tool_calls
             ]
             return [Send("tools", [tool_call]) for tool_call in pending_tool_calls]
 
@@ -560,8 +559,8 @@ def _make_model_to_tools_edge(
 
 def _make_tools_to_model_edge(
     tool_node: ToolNode, next_node: str, structured_output_tools: dict[str, OutputToolBinding]
-) -> Callable[[AgentState], str | None]:
-    def tools_to_model(state: AgentState) -> str | None:
+) -> Callable[[dict[str, Any]], str | None]:
+    def tools_to_model(state: dict[str, Any]) -> str | None:
         last_ai_message, tool_messages = _fetch_last_ai_and_tool_messages(state["messages"])
 
         if all(
@@ -584,7 +583,7 @@ def _add_middleware_edge(
     name: str,
     default_destination: str,
     model_destination: str,
-    tools_available: bool,  # noqa: FBT001
+    jump_to: list[JumpTo] | None,
 ) -> None:
     """Add an edge to the graph for a middleware node.
 
@@ -594,18 +593,23 @@ def _add_middleware_edge(
         name: The name of the middleware node.
         default_destination: The default destination for the edge.
         model_destination: The destination for the edge to the model.
-        tools_available: Whether tools are available for the edge to potentially route to.
+        jump_to: The conditionally jumpable destinations for the edge.
     """
+    if jump_to:
+
+        def jump_edge(state: dict[str, Any]) -> str:
+            return _resolve_jump(state.get("jump_to"), model_destination) or default_destination
 
-    def jump_edge(state: AgentState) -> str:
-        return _resolve_jump(state.get("jump_to"), model_destination) or default_destination
+        destinations = [default_destination]
 
-    destinations = [default_destination]
-    if default_destination != END:
-        destinations.append(END)
-    if tools_available:
-        destinations.append("tools")
-    if name != model_destination:
-        destinations.append(model_destination)
+        if "__end__" in jump_to:
+            destinations.append(END)
+        if "tools" in jump_to:
+            destinations.append("tools")
+        if "model" in jump_to and name != model_destination:
+            destinations.append(model_destination)
 
-    graph.add_conditional_edges(name, jump_edge, destinations)
+        graph.add_conditional_edges(name, jump_edge, destinations)
+
+    else:
+        graph.add_edge(name, default_destination)

{langchain-1.0.0a7.dist-info → langchain-1.0.0a8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain
-Version: 1.0.0a7
+Version: 1.0.0a8
 Summary: Building applications with LLMs through composability
 License: MIT
 Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/langchain

{langchain-1.0.0a7.dist-info → langchain-1.0.0a8.dist-info}/RECORD

@@ -1,7 +1,7 @@
-langchain-1.0.0a7.dist-info/METADATA,sha256=avxuGLMGlcJmBGdtOt03ZUAml3qw6l6Hfo8Lkvp1Q2g,6259
-langchain-1.0.0a7.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-langchain-1.0.0a7.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-langchain-1.0.0a7.dist-info/licenses/LICENSE,sha256=TsZ-TKbmch26hJssqCJhWXyGph7iFLvyFBYAa3stBHg,1067
+langchain-1.0.0a8.dist-info/METADATA,sha256=slSRaiJXGZdoNrLCLCYpJqqaPdM0keHqtv2aCBHLC7w,6259
+langchain-1.0.0a8.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+langchain-1.0.0a8.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+langchain-1.0.0a8.dist-info/licenses/LICENSE,sha256=TsZ-TKbmch26hJssqCJhWXyGph7iFLvyFBYAa3stBHg,1067
 langchain/__init__.py,sha256=Z6r4MjNaC6DSyiMgFSRmi8EhizelVIOb_CVJJRAVjDc,604
 langchain/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langchain/_internal/_documents.py,sha256=z9wAPukoASOMw4WTFFBKCCZYsvsKbo-Cq6CeHjdq9eE,1045
@@ -12,13 +12,12 @@ 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/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=0XX0fvd6XezrbhAnhBRe3OgHQDnZeWK0LcorqWC0_BE,10101
-langchain/agents/middleware/prompt_caching.py,sha256=du_qrBr0_kwWhdO_xggtfrEN5FTcGLKu3oYQDnSS0Do,2263
+langchain/agents/middleware/__init__.py,sha256=-NzMTmD5ogpzlsqHGjv6SnTrfXqU3vTahGUoGDk299U,511
+langchain/agents/middleware/human_in_the_loop.py,sha256=_6THKNzp1dvYBwBLdnZ9PXsHJP3uedn4A60ZON4xlvI,10301
+langchain/agents/middleware/prompt_caching.py,sha256=QLoWdd9jUiXAytGqbXW0I_Mg8WgrgTBO8gOZ-s8Bx8g,3081
 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/middleware/types.py,sha256=a9B6Ihx12mNTroopL1SqHxsO51ZfSkxdtkPeZXw8EJc,18606
+langchain/agents/middleware_agent.py,sha256=fncjAFNsqZqEkDYSsBfq-goxN4GqNlQixirWRBguXhs,23847
 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
@@ -36,4 +35,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.0a7.dist-info/RECORD,,
+langchain-1.0.0a8.dist-info/RECORD,,

langchain/agents/middleware/dynamic_system_prompt.py

@@ -1,105 +0,0 @@
-"""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