langchain 1.0.0a7__tar.gz → 1.0.0a8__tar.gz

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

@@ -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 → langchain-1.0.0a8}/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-1.0.0a7 → langchain-1.0.0a8}/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-1.0.0a7 → langchain-1.0.0a8}/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)