langchain 1.0.0a5__tar.gz → 1.0.0a7__tar.gz

{langchain-1.0.0a5 → langchain-1.0.0a7}/PKG-INFO

@@ -1,22 +1,26 @@
 Metadata-Version: 2.1
 Name: langchain
-Version: 1.0.0a5
+Version: 1.0.0a7
 Summary: Building applications with LLMs through composability
 License: MIT
 Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/langchain
 Project-URL: Release Notes, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22langchain%3D%3D0%22&expanded=true
 Project-URL: repository, https://github.com/langchain-ai/langchain
-Requires-Python: >=3.10
+Requires-Python: <4.0.0,>=3.10.0
 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
+Requires-Dist: langchain-text-splitters<2.0.0,>=0.3.11
+Requires-Dist: langgraph<2.0.0,>=0.6.7
+Requires-Dist: pydantic<3.0.0,>=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 → langchain-1.0.0a7}/langchain/__init__.py

@@ -2,7 +2,7 @@
 
 from typing import Any
 
-__version__ = "1.0.0a4"
+__version__ = "1.0.0a6"
 
 
 def __getattr__(name: str) -> Any:  # noqa: ANN401

{langchain-1.0.0a5 → langchain-1.0.0a7}/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-1.0.0a7/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-1.0.0a7/langchain/agents/middleware/human_in_the_loop.py

@@ -0,0 +1,253 @@
+"""Human in the loop middleware."""
+
+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.types import AgentMiddleware, AgentState
+
+
+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):
+    """Human in the loop middleware."""
+
+    def __init__(
+        self,
+        tool_configs: 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.
+                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__()
+        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:  # type: ignore[override]
+        """Trigger HITL flows for relevant tool calls after an AIMessage."""
+        messages = state["messages"]
+        if not messages:
+            return None
+
+        last_ai_msg = next((msg for msg in reversed(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
+        hitl_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[
+                "name"
+            ] in self.tool_configs else auto_approved_tool_calls.append(tool_call)
+
+        # If no interrupts needed, return early
+        if not hitl_tool_calls:
+            return None
+
+        # Process all tool calls that require interrupts
+        approved_tool_calls: list[ToolCall] = auto_approved_tool_calls.copy()
+        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:
+            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}"
+            )
+
+            request: HumanInTheLoopRequest = {
+                "action_request": ActionRequest(
+                    action=tool_name,
+                    args=tool_args,
+                ),
+                "config": config,
+                "description": description,
+            }
+            hitl_requests.append(request)
+
+        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"Number of human responses ({responses_len}) does not match "
+                f"number of hanging tool calls ({hitl_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"]]
+
+            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-1.0.0a5 → langchain-1.0.0a7}/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-1.0.0a5 → langchain-1.0.0a7}/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-1.0.0a5 → langchain-1.0.0a7}/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."""