langchain 1.0.0a13__py3-none-any.whl → 1.0.0a14__py3-none-any.whl

langchain/agents/factory.py

@@ -13,9 +13,6 @@ from typing import (
     get_type_hints,
 )
 
-if TYPE_CHECKING:
-    from collections.abc import Awaitable
-
 from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_core.messages import AIMessage, AnyMessage, SystemMessage, ToolMessage
 from langchain_core.tools import BaseTool
@@ -47,11 +44,10 @@ from langchain.agents.structured_output import (
     ToolStrategy,
 )
 from langchain.chat_models import init_chat_model
-from langchain.tools import ToolNode
-from langchain.tools.tool_node import ToolCallWithContext
+from langchain.tools.tool_node import ToolCallWithContext, _ToolNode
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Sequence
+    from collections.abc import Awaitable, Callable, Sequence
 
     from langchain_core.runnables import Runnable
     from langgraph.cache.base import BaseCache
@@ -449,6 +445,70 @@ def _chain_tool_call_wrappers(
     return result
 
 
+def _chain_async_tool_call_wrappers(
+    wrappers: Sequence[
+        Callable[
+            [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
+            Awaitable[ToolMessage | Command],
+        ]
+    ],
+) -> (
+    Callable[
+        [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
+        Awaitable[ToolMessage | Command],
+    ]
+    | None
+):
+    """Compose async wrappers into middleware stack (first = outermost).
+
+    Args:
+        wrappers: Async wrappers in middleware order.
+
+    Returns:
+        Composed async wrapper, or None if empty.
+    """
+    if not wrappers:
+        return None
+
+    if len(wrappers) == 1:
+        return wrappers[0]
+
+    def compose_two(
+        outer: Callable[
+            [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
+            Awaitable[ToolMessage | Command],
+        ],
+        inner: Callable[
+            [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
+            Awaitable[ToolMessage | Command],
+        ],
+    ) -> Callable[
+        [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
+        Awaitable[ToolMessage | Command],
+    ]:
+        """Compose two async wrappers where outer wraps inner."""
+
+        async def composed(
+            request: ToolCallRequest,
+            execute: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
+        ) -> ToolMessage | Command:
+            # Create an async callable that invokes inner with the original execute
+            async def call_inner(req: ToolCallRequest) -> ToolMessage | Command:
+                return await inner(req, execute)
+
+            # Outer can call call_inner multiple times
+            return await outer(request, call_inner)
+
+        return composed
+
+    # Chain all wrappers: first -> second -> ... -> last
+    result = wrappers[-1]
+    for wrapper in reversed(wrappers[:-1]):
+        result = compose_two(wrapper, result)
+
+    return result
+
+
 def create_agent(  # noqa: PLR0915
     model: str | BaseChatModel,
     tools: Sequence[BaseTool | Callable | dict[str, Any]] | None = None,
@@ -576,9 +636,14 @@ def create_agent(  # noqa: PLR0915
             structured_output_tools[structured_tool_info.tool.name] = structured_tool_info
     middleware_tools = [t for m in middleware for t in getattr(m, "tools", [])]
 
-    # Collect middleware with wrap_tool_call hooks
+    # Collect middleware with wrap_tool_call or awrap_tool_call hooks
+    # Include middleware with either implementation to ensure NotImplementedError is raised
+    # when middleware doesn't support the execution path
     middleware_w_wrap_tool_call = [
-        m for m in middleware if m.__class__.wrap_tool_call is not AgentMiddleware.wrap_tool_call
+        m
+        for m in middleware
+        if m.__class__.wrap_tool_call is not AgentMiddleware.wrap_tool_call
+        or m.__class__.awrap_tool_call is not AgentMiddleware.awrap_tool_call
     ]
 
     # Chain all wrap_tool_call handlers into a single composed handler
@@ -587,8 +652,24 @@ def create_agent(  # noqa: PLR0915
         wrappers = [m.wrap_tool_call for m in middleware_w_wrap_tool_call]
         wrap_tool_call_wrapper = _chain_tool_call_wrappers(wrappers)
 
+    # Collect middleware with awrap_tool_call or wrap_tool_call hooks
+    # Include middleware with either implementation to ensure NotImplementedError is raised
+    # when middleware doesn't support the execution path
+    middleware_w_awrap_tool_call = [
+        m
+        for m in middleware
+        if m.__class__.awrap_tool_call is not AgentMiddleware.awrap_tool_call
+        or m.__class__.wrap_tool_call is not AgentMiddleware.wrap_tool_call
+    ]
+
+    # Chain all awrap_tool_call handlers into a single composed async handler
+    awrap_tool_call_wrapper = None
+    if middleware_w_awrap_tool_call:
+        async_wrappers = [m.awrap_tool_call for m in middleware_w_awrap_tool_call]
+        awrap_tool_call_wrapper = _chain_async_tool_call_wrappers(async_wrappers)
+
     # Setup tools
-    tool_node: ToolNode | None = None
+    tool_node: _ToolNode | None = None
     # Extract built-in provider tools (dict format) and regular tools (BaseTool/callables)
     built_in_tools = [t for t in tools if isinstance(t, dict)]
     regular_tools = [t for t in tools if not isinstance(t, dict)]
@@ -598,7 +679,11 @@ def create_agent(  # noqa: PLR0915
 
     # Only create ToolNode if we have client-side tools
     tool_node = (
-        ToolNode(tools=available_tools, wrap_tool_call=wrap_tool_call_wrapper)
+        _ToolNode(
+            tools=available_tools,
+            wrap_tool_call=wrap_tool_call_wrapper,
+            awrap_tool_call=awrap_tool_call_wrapper,
+        )
         if available_tools
         else None
     )
@@ -640,13 +725,23 @@ def create_agent(  # noqa: PLR0915
         if m.__class__.after_agent is not AgentMiddleware.after_agent
         or m.__class__.aafter_agent is not AgentMiddleware.aafter_agent
     ]
+    # Collect middleware with wrap_model_call or awrap_model_call hooks
+    # Include middleware with either implementation to ensure NotImplementedError is raised
+    # when middleware doesn't support the execution path
     middleware_w_wrap_model_call = [
-        m for m in middleware if m.__class__.wrap_model_call is not AgentMiddleware.wrap_model_call
+        m
+        for m in middleware
+        if m.__class__.wrap_model_call is not AgentMiddleware.wrap_model_call
+        or m.__class__.awrap_model_call is not AgentMiddleware.awrap_model_call
     ]
+    # Collect middleware with awrap_model_call or wrap_model_call hooks
+    # Include middleware with either implementation to ensure NotImplementedError is raised
+    # when middleware doesn't support the execution path
     middleware_w_awrap_model_call = [
         m
         for m in middleware
         if m.__class__.awrap_model_call is not AgentMiddleware.awrap_model_call
+        or m.__class__.wrap_model_call is not AgentMiddleware.wrap_model_call
     ]
 
     # Compose wrap_model_call handlers into a single middleware stack (sync)
@@ -1378,7 +1473,7 @@ def _make_model_to_model_edge(
 
 def _make_tools_to_model_edge(
     *,
-    tool_node: ToolNode,
+    tool_node: _ToolNode,
     model_destination: str,
     structured_output_tools: dict[str, OutputToolBinding],
     end_destination: str,

langchain/agents/middleware/pii.py

@@ -431,14 +431,12 @@ class PIIMiddleware(AgentMiddleware):
 
     Strategy Selection Guide:
 
-        ========  ===================  =======================================
-        Strategy  Preserves Identity?  Best For
-        ========  ===================  =======================================
-        `block`   N/A                  Avoid PII completely
-        `redact`  No                   General compliance, log sanitization
-        `mask`    No                   Human readability, customer service UIs
-        `hash`    Yes (pseudonymous)   Analytics, debugging
-        ========  ===================  =======================================
+        | Strategy | Preserves Identity? | Best For                                |
+        | -------- | ------------------- | --------------------------------------- |
+        | `block`  | N/A                 | Avoid PII completely                    |
+        | `redact` | No                  | General compliance, log sanitization    |
+        | `mask`   | No                  | Human readability, customer service UIs |
+        | `hash`   | Yes (pseudonymous)  | Analytics, debugging                    |
 
     Example:
         ```python

langchain/agents/middleware/types.py

@@ -21,7 +21,7 @@ if TYPE_CHECKING:
 
     from langchain.tools.tool_node import ToolCallRequest
 
-# needed as top level import for pydantic schema generation on AgentState
+# Needed as top level import for Pydantic schema generation on AgentState
 from typing import TypeAlias
 
 from langchain_core.messages import AIMessage, AnyMessage, BaseMessage, ToolMessage  # noqa: TC002
@@ -263,18 +263,35 @@ class AgentMiddleware(Generic[StateT, ContextT]):
                 return AIMessage(content="Simplified response")
             ```
         """
-        raise NotImplementedError
+        msg = (
+            "Synchronous implementation of wrap_model_call is not available. "
+            "You are likely encountering this error because you defined only the async version "
+            "(awrap_model_call) and invoked your agent in a synchronous context "
+            "(e.g., using `stream()` or `invoke()`). "
+            "To resolve this, either: "
+            "(1) subclass AgentMiddleware and implement the synchronous wrap_model_call method, "
+            "(2) use the @wrap_model_call decorator on a standalone sync function, or "
+            "(3) invoke your agent asynchronously using `astream()` or `ainvoke()`."
+        )
+        raise NotImplementedError(msg)
 
     async def awrap_model_call(
         self,
         request: ModelRequest,
         handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
     ) -> ModelCallResult:
-        """Async version of wrap_model_call.
+        """Intercept and control async model execution via handler callback.
+
+        The handler callback executes the model request and returns a ModelResponse.
+        Middleware can call the handler multiple times for retry logic, skip calling
+        it to short-circuit, or modify the request/response. Multiple middleware
+        compose with first in list as outermost layer.
 
         Args:
             request: Model request to execute (includes state and runtime).
-            handler: Async callback that executes the model request.
+            handler: Async callback that executes the model request and returns ModelResponse.
+                     Call this to execute the model. Can be called multiple times
+                     for retry logic. Can skip calling it to short-circuit.
 
         Returns:
             ModelCallResult
@@ -291,7 +308,17 @@ class AgentMiddleware(Generic[StateT, ContextT]):
                             raise
             ```
         """
-        raise NotImplementedError
+        msg = (
+            "Asynchronous implementation of awrap_model_call is not available. "
+            "You are likely encountering this error because you defined only the sync version "
+            "(wrap_model_call) and invoked your agent in an asynchronous context "
+            "(e.g., using `astream()` or `ainvoke()`). "
+            "To resolve this, either: "
+            "(1) subclass AgentMiddleware and implement the asynchronous awrap_model_call method, "
+            "(2) use the @wrap_model_call decorator on a standalone async function, or "
+            "(3) invoke your agent synchronously using `stream()` or `invoke()`."
+        )
+        raise NotImplementedError(msg)
 
     def after_agent(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None:
         """Logic to run after the agent execution completes."""
@@ -353,7 +380,77 @@ class AgentMiddleware(Generic[StateT, ContextT]):
                         continue
                     return result
         """
-        raise NotImplementedError
+        msg = (
+            "Synchronous implementation of wrap_tool_call is not available. "
+            "You are likely encountering this error because you defined only the async version "
+            "(awrap_tool_call) and invoked your agent in a synchronous context "
+            "(e.g., using `stream()` or `invoke()`). "
+            "To resolve this, either: "
+            "(1) subclass AgentMiddleware and implement the synchronous wrap_tool_call method, "
+            "(2) use the @wrap_tool_call decorator on a standalone sync function, or "
+            "(3) invoke your agent asynchronously using `astream()` or `ainvoke()`."
+        )
+        raise NotImplementedError(msg)
+
+    async def awrap_tool_call(
+        self,
+        request: ToolCallRequest,
+        handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
+    ) -> ToolMessage | Command:
+        """Intercept and control async tool execution via handler callback.
+
+        The handler callback executes the tool call and returns a ToolMessage or Command.
+        Middleware can call the handler multiple times for retry logic, skip calling
+        it to short-circuit, or modify the request/response. Multiple middleware
+        compose with first in list as outermost layer.
+
+        Args:
+            request: Tool call request with call dict, BaseTool, state, and runtime.
+                Access state via request.state and runtime via request.runtime.
+            handler: Async callable to execute the tool and returns ToolMessage or Command.
+                     Call this to execute the tool. Can be called multiple times
+                     for retry logic. Can skip calling it to short-circuit.
+
+        Returns:
+            ToolMessage or Command (the final result).
+
+        The handler callable can be invoked multiple times for retry logic.
+        Each call to handler is independent and stateless.
+
+        Examples:
+            Async retry on error:
+            ```python
+            async def awrap_tool_call(self, request, handler):
+                for attempt in range(3):
+                    try:
+                        result = await handler(request)
+                        if is_valid(result):
+                            return result
+                    except Exception:
+                        if attempt == 2:
+                            raise
+                return result
+            ```
+
+
+            async def awrap_tool_call(self, request, handler):
+                if cached := await get_cache_async(request):
+                    return ToolMessage(content=cached, tool_call_id=request.tool_call["id"])
+                result = await handler(request)
+                await save_cache_async(request, result)
+                return result
+        """
+        msg = (
+            "Asynchronous implementation of awrap_tool_call is not available. "
+            "You are likely encountering this error because you defined only the sync version "
+            "(wrap_tool_call) and invoked your agent in an asynchronous context "
+            "(e.g., using `astream()` or `ainvoke()`). "
+            "To resolve this, either: "
+            "(1) subclass AgentMiddleware and implement the asynchronous awrap_tool_call method, "
+            "(2) use the @wrap_tool_call decorator on a standalone async function, or "
+            "(3) invoke your agent synchronously using `stream()` or `invoke()`."
+        )
+        raise NotImplementedError(msg)
 
 
 class _CallableWithStateAndRuntime(Protocol[StateT_contra, ContextT]):
@@ -1104,6 +1201,16 @@ def dynamic_prompt(
             request.system_prompt = prompt
             return handler(request)
 
+        async def async_wrapped_from_sync(
+            self: AgentMiddleware[StateT, ContextT],  # noqa: ARG001
+            request: ModelRequest,
+            handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
+        ) -> ModelCallResult:
+            # Delegate to sync function
+            prompt = cast("str", func(request))
+            request.system_prompt = prompt
+            return await handler(request)
+
         middleware_name = cast("str", getattr(func, "__name__", "DynamicPromptMiddleware"))
 
         return type(
@@ -1113,6 +1220,7 @@ def dynamic_prompt(
                 "state_schema": AgentState,
                 "tools": [],
                 "wrap_model_call": wrapped,
+                "awrap_model_call": async_wrapped_from_sync,
             },
         )()
 
@@ -1309,6 +1417,7 @@ def wrap_tool_call(
     Args:
         func: Function accepting (request, handler) that calls
             handler(request) to execute the tool and returns final ToolMessage or Command.
+            Can be sync or async.
         tools: Additional tools to register with this middleware.
         name: Middleware class name. Defaults to function name.
 
@@ -1316,13 +1425,6 @@ def wrap_tool_call(
         AgentMiddleware instance if func provided, otherwise a decorator.
 
     Examples:
-        Basic passthrough:
-        ```python
-        @wrap_tool_call
-        def passthrough(request, handler):
-            return handler(request)
-        ```
-
         Retry logic:
         ```python
         @wrap_tool_call
@@ -1336,6 +1438,18 @@ def wrap_tool_call(
                         raise
         ```
 
+        Async retry logic:
+        ```python
+        @wrap_tool_call
+        async def async_retry(request, handler):
+            for attempt in range(3):
+                try:
+                    return await handler(request)
+                except Exception:
+                    if attempt == 2:
+                        raise
+        ```
+
         Modify request:
         ```python
         @wrap_tool_call
@@ -1359,6 +1473,31 @@ def wrap_tool_call(
     def decorator(
         func: _CallableReturningToolResponse,
     ) -> AgentMiddleware:
+        is_async = iscoroutinefunction(func)
+
+        if is_async:
+
+            async def async_wrapped(
+                self: AgentMiddleware,  # noqa: ARG001
+                request: ToolCallRequest,
+                handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
+            ) -> ToolMessage | Command:
+                return await func(request, handler)  # type: ignore[arg-type,misc]
+
+            middleware_name = name or cast(
+                "str", getattr(func, "__name__", "WrapToolCallMiddleware")
+            )
+
+            return type(
+                middleware_name,
+                (AgentMiddleware,),
+                {
+                    "state_schema": AgentState,
+                    "tools": tools or [],
+                    "awrap_tool_call": async_wrapped,
+                },
+            )()
+
         def wrapped(
             self: AgentMiddleware,  # noqa: ARG001
             request: ToolCallRequest,

langchain/embeddings/__init__.py

@@ -3,10 +3,8 @@
 from langchain_core.embeddings import Embeddings
 
 from langchain.embeddings.base import init_embeddings
-from langchain.embeddings.cache import CacheBackedEmbeddings
 
 __all__ = [
-    "CacheBackedEmbeddings",
     "Embeddings",
     "init_embeddings",
 ]

langchain/messages/__init__.py

@@ -3,29 +3,61 @@
 from langchain_core.messages import (
     AIMessage,
     AIMessageChunk,
+    Annotation,
     AnyMessage,
+    AudioContentBlock,
+    Citation,
+    ContentBlock,
+    DataContentBlock,
+    FileContentBlock,
     HumanMessage,
+    ImageContentBlock,
     InvalidToolCall,
     MessageLikeRepresentation,
+    NonStandardAnnotation,
+    NonStandardContentBlock,
+    PlainTextContentBlock,
+    ReasoningContentBlock,
     RemoveMessage,
+    ServerToolCall,
+    ServerToolCallChunk,
+    ServerToolResult,
     SystemMessage,
+    TextContentBlock,
     ToolCall,
     ToolCallChunk,
     ToolMessage,
+    VideoContentBlock,
     trim_messages,
 )
 
 __all__ = [
     "AIMessage",
     "AIMessageChunk",
+    "Annotation",
     "AnyMessage",
+    "AudioContentBlock",
+    "Citation",
+    "ContentBlock",
+    "DataContentBlock",
+    "FileContentBlock",
     "HumanMessage",
+    "ImageContentBlock",
     "InvalidToolCall",
     "MessageLikeRepresentation",
+    "NonStandardAnnotation",
+    "NonStandardContentBlock",
+    "PlainTextContentBlock",
+    "ReasoningContentBlock",
     "RemoveMessage",
+    "ServerToolCall",
+    "ServerToolCallChunk",
+    "ServerToolResult",
     "SystemMessage",
+    "TextContentBlock",
     "ToolCall",
     "ToolCallChunk",
     "ToolMessage",
+    "VideoContentBlock",
     "trim_messages",
 ]

langchain/tools/__init__.py

@@ -8,11 +8,7 @@ from langchain_core.tools import (
     tool,
 )
 
-from langchain.tools.tool_node import (
-    InjectedState,
-    InjectedStore,
-    ToolNode,
-)
+from langchain.tools.tool_node import InjectedState, InjectedStore, ToolInvocationError
 
 __all__ = [
     "BaseTool",
@@ -21,6 +17,6 @@ __all__ = [
     "InjectedToolArg",
     "InjectedToolCallId",
     "ToolException",
-    "ToolNode",
+    "ToolInvocationError",
     "tool",
 ]

langchain/tools/tool_node.py

@@ -38,7 +38,7 @@ from __future__ import annotations
 import asyncio
 import inspect
 import json
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 from copy import copy, deepcopy
 from dataclasses import dataclass, replace
 from types import UnionType
@@ -72,6 +72,7 @@ from langchain_core.tools import BaseTool, InjectedToolArg
 from langchain_core.tools import tool as create_tool
 from langchain_core.tools.base import (
     TOOL_MESSAGE_BLOCK_TYPES,
+    ToolException,
     get_all_basemodel_annotations,
 )
 from langgraph._internal._runnable import RunnableCallable
@@ -188,6 +189,12 @@ Examples:
         return result
 """
 
+AsyncToolCallWrapper = Callable[
+    [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
+    Awaitable[ToolMessage | Command],
+]
+"""Async wrapper for tool call execution with multi-call support."""
+
 
 class ToolCallWithContext(TypedDict):
     """ToolCall with additional context for graph state.
@@ -239,8 +246,11 @@ def msg_content_output(output: Any) -> str | list[dict]:
         return str(output)
 
 
-class ToolInvocationError(Exception):
-    """Exception raised when a tool invocation fails due to invalid arguments."""
+class ToolInvocationError(ToolException):
+    """An error occurred while invoking a tool due to invalid arguments.
+
+    This exception is only raised when invoking a tool using the ToolNode!
+    """
 
     def __init__(
         self, tool_name: str, source: ValidationError, tool_kwargs: dict[str, Any]
@@ -382,7 +392,7 @@ def _infer_handled_types(handler: Callable[..., str]) -> tuple[type[Exception],
     return (Exception,)
 
 
-class ToolNode(RunnableCallable):
+class _ToolNode(RunnableCallable):
     """A node for executing tools in LangGraph workflows.
 
     Handles tool execution patterns including function calls, state injection,
@@ -500,6 +510,7 @@ class ToolNode(RunnableCallable):
         | tuple[type[Exception], ...] = _default_handle_tool_errors,
         messages_key: str = "messages",
         wrap_tool_call: ToolCallWrapper | None = None,
+        awrap_tool_call: AsyncToolCallWrapper | None = None,
     ) -> None:
         """Initialize ToolNode with tools and configuration.
 
@@ -509,9 +520,11 @@ class ToolNode(RunnableCallable):
             tags: Optional metadata tags.
             handle_tool_errors: Error handling configuration.
             messages_key: State key containing messages.
-            wrap_tool_call: Wrapper function to intercept tool execution. Receives
+            wrap_tool_call: Sync wrapper function to intercept tool execution. Receives
                 ToolCallRequest and execute callable, returns ToolMessage or Command.
                 Enables retries, caching, request modification, and control flow.
+            awrap_tool_call: Async wrapper function to intercept tool execution.
+                If not provided, falls back to wrap_tool_call for async execution.
         """
         super().__init__(self._func, self._afunc, name=name, tags=tags, trace=False)
         self._tools_by_name: dict[str, BaseTool] = {}
@@ -520,6 +533,7 @@ class ToolNode(RunnableCallable):
         self._handle_tool_errors = handle_tool_errors
         self._messages_key = messages_key
         self._wrap_tool_call = wrap_tool_call
+        self._awrap_tool_call = awrap_tool_call
         for tool in tools:
             if not isinstance(tool, BaseTool):
                 tool_ = create_tool(cast("type[BaseTool]", tool))
@@ -855,7 +869,7 @@ class ToolNode(RunnableCallable):
         input: list[AnyMessage] | dict[str, Any] | BaseModel,
         runtime: Any,
     ) -> ToolMessage | Command:
-        """Execute single tool call asynchronously with wrap_tool_call wrapper if configured.
+        """Execute single tool call asynchronously with awrap_tool_call wrapper if configured.
 
         Args:
             call: Tool call dict.
@@ -883,7 +897,7 @@ class ToolNode(RunnableCallable):
             runtime=runtime,
         )
 
-        if self._wrap_tool_call is None:
+        if self._awrap_tool_call is None and self._wrap_tool_call is None:
             # No wrapper - execute directly
             return await self._execute_tool_async(tool_request, input_type, config)
 
@@ -892,12 +906,17 @@ class ToolNode(RunnableCallable):
             """Execute tool with given request. Can be called multiple times."""
             return await self._execute_tool_async(req, input_type, config)
 
+        def _sync_execute(req: ToolCallRequest) -> ToolMessage | Command:
+            """Sync execute fallback for sync wrapper."""
+            return self._execute_tool_sync(req, input_type, config)
+
         # Call wrapper with request and execute callable
-        # Note: wrapper is sync, but execute callable is async
         try:
-            result = self._wrap_tool_call(tool_request, execute)  # type: ignore[arg-type]
-            # If result is a coroutine, await it (though wrapper should be sync)
-            return await result if hasattr(result, "__await__") else result
+            if self._awrap_tool_call is not None:
+                return await self._awrap_tool_call(tool_request, execute)
+            # None check was performed above already
+            self._wrap_tool_call = cast("ToolCallWrapper", self._wrap_tool_call)
+            return self._wrap_tool_call(tool_request, _sync_execute)
         except Exception as e:
             # Wrapper threw an exception
             if not self._handle_tool_errors:

{langchain-1.0.0a13.dist-info → langchain-1.0.0a14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain
-Version: 1.0.0a13
+Version: 1.0.0a14
 Summary: Building applications with LLMs through composability
 Project-URL: homepage, https://docs.langchain.com/
 Project-URL: repository, https://github.com/langchain-ai/langchain/tree/master/libs/langchain

{langchain-1.0.0a13.dist-info → langchain-1.0.0a14.dist-info}/RECORD

@@ -1,36 +1,30 @@
 langchain/__init__.py,sha256=rED92FbyWFRmks07cFlRTuz5ZtaPKxYq6BcsxW5KhrE,64
 langchain/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langchain/agents/__init__.py,sha256=x85V7MqddVSrraoirGHplPMzEz9Lha-vL9fKjXCS7lA,258
-langchain/agents/factory.py,sha256=WcuuMvL0g3QbzL--weJC8SFDabEaCuXOdF_tLA6DwAw,57539
+langchain/agents/factory.py,sha256=e6xjbw_qTFvfP-AHXZtykXGrX-2GoX6hFaW_97WHiEw,61245
 langchain/agents/structured_output.py,sha256=msf-ClqDnMfJ-oGHqjwEyth860tMnx58GLTvqJijqg8,13686
 langchain/agents/middleware/__init__.py,sha256=FDwjEGYtxPgyFa9iiLAWT5M2W8c-NDYfGz6_y8cEqPI,1568
 langchain/agents/middleware/context_editing.py,sha256=6ca6Qed-F59JD1rAlrIuxlrBbDVIKQmCpfvZaIFbBy8,7691
 langchain/agents/middleware/human_in_the_loop.py,sha256=Bs4_Hgjuy9l0-AMUHvU9wlr_rL2Z1rUwL_VcfFLhhUM,12666
 langchain/agents/middleware/model_call_limit.py,sha256=H3lJL2cLv3u0uF0kJsRagFt1rBmHHgn5SFsfnmcyQdA,6703
 langchain/agents/middleware/model_fallback.py,sha256=pdKRSO9JD6MdMYHFl7IK4yj6LEwQfyzfTJiBE8uJ2pE,3118
-langchain/agents/middleware/pii.py,sha256=6KOrK152nbV8ag68459JspXCCmM35N2LJ0PrDW5GLhU,24830
+langchain/agents/middleware/pii.py,sha256=7hTBxnpcG_hSZd29TCg-4tbiLFO9IJb-wwnujCRMrv4,24780
 langchain/agents/middleware/planning.py,sha256=59Q6-4aALytjssIZ5a4hZkx5THxIG-RTeUHuDP1LGDA,9319
 langchain/agents/middleware/prompt_caching.py,sha256=cMvIJ_dpSsn4_cqCvZBBKjtw5GpcVkc8Lgf_VEPzM1w,3225
 langchain/agents/middleware/summarization.py,sha256=H1VxRkkbauw4p4sMMKyc_uZGbJhtqoVvOF7y_5JBXTc,10329
 langchain/agents/middleware/tool_call_limit.py,sha256=6cWviwPRzaf7UUcp9zlXwk6RJBBoWVaVSBc1NaVT2fI,9729
 langchain/agents/middleware/tool_emulator.py,sha256=5qJFPfTSiVukNclDeUo7_c7-PjGEVWyefbPC-zpYSlI,7115
 langchain/agents/middleware/tool_selection.py,sha256=6RYdgkg6aSNx1w-YxRyL2Hct7UPnMRgGg6YVZVtW5TU,11638
-langchain/agents/middleware/types.py,sha256=_dTVkDSXDhtuvfBOqO74WSFVTdIMAfuIC-gWu2_vh8w,47064
+langchain/agents/middleware/types.py,sha256=JqTdwFru-nqs8RlamYPqEM0cnak9WBPEp__dtsve3g4,53868
 langchain/chat_models/__init__.py,sha256=PTq9qskQEbqXYAcUUxUXDsugOcwISgFhv4w40JgkbgU,181
 langchain/chat_models/base.py,sha256=HPlD0QaLOGXRJAY1Qq6ojr1WcteBlgVO--_GoSqpxXE,34560
-langchain/documents/__init__.py,sha256=DjuBCy1TQbem4Vz8SsCcGAbZeFwW5KgGPvDrA8e9oGA,94
-langchain/embeddings/__init__.py,sha256=sJZEfZ4ovEFU5JJnoVNCJIjtSCLT1w9r9uFw1hieRZ8,269
+langchain/embeddings/__init__.py,sha256=kfLfu342i9bTrA0WC8yA6IJE2bgY4ZynWBi-_cMUg8E,179
 langchain/embeddings/base.py,sha256=o77Z1TrXoUZN1SdYY9nZCNehm7cZzC-TNqc5NIzWtww,7327
-langchain/embeddings/cache.py,sha256=znf9DBhrmSpqb64ugwqEqQQaU-7X62HYWxSL9L1fn8g,14267
-langchain/messages/__init__.py,sha256=rXBO7H-OOL1uknFjNdaRi8p1ryRVMMGdJLjSY8y1iGY,557
+langchain/messages/__init__.py,sha256=X5-dRewJP-jtehdC6oDbs21j9bxGDUbI5WlcNrO_bHk,1309
 langchain/rate_limiters/__init__.py,sha256=5490xUNhet37N2nX6kbJlDgf8u1DX-C1Cs_r7etXn8A,351
-langchain/storage/__init__.py,sha256=cvxc63N2nluqyVc7d9MeAj5mmO2iYl3GhcxMCpmqjUk,533
-langchain/storage/encoder_backed.py,sha256=z3CS_4kxt7IFv2q8TEfSjMr_EeBp25cloVBINu2KCpE,4179
-langchain/storage/exceptions.py,sha256=Fl_8tON3KmByBKwXtno5WSj0-c2RiZxnhw3gv5aS2T8,114
-langchain/storage/in_memory.py,sha256=ozrmu0EtaJJVSAzK_u7nzxWpr9OOscWkANHSg-qIVYQ,369
-langchain/tools/__init__.py,sha256=tWlUqT7jrnf1ouhMctuUkaYBWEuOPD3JQX4Y8uTHk5w,405
-langchain/tools/tool_node.py,sha256=ICsI7x0zkT3nJOCK3TGAEYgho9b8U_lAUsffbdB18Kc,57048
-langchain-1.0.0a13.dist-info/METADATA,sha256=usSvQLeqH64jSkqTl15cqX4RGhj5q3sQpcQeP0uir6E,6118
-langchain-1.0.0a13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langchain-1.0.0a13.dist-info/licenses/LICENSE,sha256=TsZ-TKbmch26hJssqCJhWXyGph7iFLvyFBYAa3stBHg,1067
-langchain-1.0.0a13.dist-info/RECORD,,
+langchain/tools/__init__.py,sha256=C0GW8HPluAgnVmGneHXY-ibwbl3kXixBtZS88PtnXSI,410
+langchain/tools/tool_node.py,sha256=p9NO3R8dgA9QhjCuGb-INebjizjzKj21tIsnoKSBkA8,57917
+langchain-1.0.0a14.dist-info/METADATA,sha256=5-_c3FrZ93AM_AtuB9-PkYjoYDLgfMFtfij0SSHjvJE,6118
+langchain-1.0.0a14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langchain-1.0.0a14.dist-info/licenses/LICENSE,sha256=TsZ-TKbmch26hJssqCJhWXyGph7iFLvyFBYAa3stBHg,1067
+langchain-1.0.0a14.dist-info/RECORD,,

langchain/documents/__init__.py

@@ -1,7 +0,0 @@
-"""Document."""
-
-from langchain_core.documents import Document
-
-__all__ = [
-    "Document",
-]

langchain/embeddings/cache.py

@@ -1,361 +0,0 @@
-"""Module contains code for a cache backed embedder.
-
-The cache backed embedder is a wrapper around an embedder that caches
-embeddings in a key-value store. The cache is used to avoid recomputing
-embeddings for the same text.
-
-The text is hashed and the hash is used as the key in the cache.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-import uuid
-import warnings
-from typing import TYPE_CHECKING, Literal, cast
-
-from langchain_core.embeddings import Embeddings
-from langchain_core.utils.iter import batch_iterate
-
-from langchain.storage.encoder_backed import EncoderBackedStore
-
-if TYPE_CHECKING:
-    from collections.abc import Callable, Sequence
-
-    from langchain_core.stores import BaseStore, ByteStore
-
-NAMESPACE_UUID = uuid.UUID(int=1985)
-
-
-def _sha1_hash_to_uuid(text: str) -> uuid.UUID:
-    """Return a UUID derived from *text* using SHA-1 (deterministic).
-
-    Deterministic and fast, **but not collision-resistant**.
-
-    A malicious attacker could try to create two different texts that hash to the same
-    UUID. This may not necessarily be an issue in the context of caching embeddings,
-    but new applications should swap this out for a stronger hash function like
-    xxHash, BLAKE2 or SHA-256, which are collision-resistant.
-    """
-    sha1_hex = hashlib.sha1(text.encode("utf-8"), usedforsecurity=False).hexdigest()
-    # Embed the hex string in `uuid5` to obtain a valid UUID.
-    return uuid.uuid5(NAMESPACE_UUID, sha1_hex)
-
-
-def _make_default_key_encoder(namespace: str, algorithm: str) -> Callable[[str], str]:
-    """Create a default key encoder function.
-
-    Args:
-        namespace: Prefix that segregates keys from different embedding models.
-        algorithm:
-           * `'sha1'` - fast but not collision-resistant
-           * `'blake2b'` - cryptographically strong, faster than SHA-1
-           * `'sha256'` - cryptographically strong, slower than SHA-1
-           * `'sha512'` - cryptographically strong, slower than SHA-1
-
-    Returns:
-        A function that encodes a key using the specified algorithm.
-    """
-    if algorithm == "sha1":
-        _warn_about_sha1_encoder()
-
-    def _key_encoder(key: str) -> str:
-        """Encode a key using the specified algorithm."""
-        if algorithm == "sha1":
-            return f"{namespace}{_sha1_hash_to_uuid(key)}"
-        if algorithm == "blake2b":
-            return f"{namespace}{hashlib.blake2b(key.encode('utf-8')).hexdigest()}"
-        if algorithm == "sha256":
-            return f"{namespace}{hashlib.sha256(key.encode('utf-8')).hexdigest()}"
-        if algorithm == "sha512":
-            return f"{namespace}{hashlib.sha512(key.encode('utf-8')).hexdigest()}"
-        msg = f"Unsupported algorithm: {algorithm}"
-        raise ValueError(msg)
-
-    return _key_encoder
-
-
-def _value_serializer(value: Sequence[float]) -> bytes:
-    """Serialize a value."""
-    return json.dumps(value).encode()
-
-
-def _value_deserializer(serialized_value: bytes) -> list[float]:
-    """Deserialize a value."""
-    return cast("list[float]", json.loads(serialized_value.decode()))
-
-
-# The warning is global; track emission, so it appears only once.
-_warned_about_sha1: bool = False
-
-
-def _warn_about_sha1_encoder() -> None:
-    """Emit a one-time warning about SHA-1 collision weaknesses."""
-    global _warned_about_sha1  # noqa: PLW0603
-    if not _warned_about_sha1:
-        warnings.warn(
-            "Using default key encoder: SHA-1 is *not* collision-resistant. "
-            "While acceptable for most cache scenarios, a motivated attacker "
-            "can craft two different payloads that map to the same cache key. "
-            "If that risk matters in your environment, supply a stronger "
-            "encoder (e.g. SHA-256 or BLAKE2) via the `key_encoder` argument. "
-            "If you change the key encoder, consider also creating a new cache, "
-            "to avoid (the potential for) collisions with existing keys.",
-            category=UserWarning,
-            stacklevel=2,
-        )
-        _warned_about_sha1 = True
-
-
-class CacheBackedEmbeddings(Embeddings):
-    """Interface for caching results from embedding models.
-
-    The interface allows works with any store that implements
-    the abstract store interface accepting keys of type str and values of list of
-    floats.
-
-    If need be, the interface can be extended to accept other implementations
-    of the value serializer and deserializer, as well as the key encoder.
-
-    Note that by default only document embeddings are cached. To cache query
-    embeddings too, pass in a query_embedding_store to constructor.
-
-    Examples:
-        ```python
-        from langchain.embeddings import CacheBackedEmbeddings
-        from langchain.storage import LocalFileStore
-        from langchain_community.embeddings import OpenAIEmbeddings
-
-        store = LocalFileStore("./my_cache")
-
-        underlying_embedder = OpenAIEmbeddings()
-        embedder = CacheBackedEmbeddings.from_bytes_store(
-            underlying_embedder, store, namespace=underlying_embedder.model
-        )
-
-        # Embedding is computed and cached
-        embeddings = embedder.embed_documents(["hello", "goodbye"])
-
-        # Embeddings are retrieved from the cache, no computation is done
-        embeddings = embedder.embed_documents(["hello", "goodbye"])
-        ```
-    """
-
-    def __init__(
-        self,
-        underlying_embeddings: Embeddings,
-        document_embedding_store: BaseStore[str, list[float]],
-        *,
-        batch_size: int | None = None,
-        query_embedding_store: BaseStore[str, list[float]] | None = None,
-    ) -> None:
-        """Initialize the embedder.
-
-        Args:
-            underlying_embeddings: the embedder to use for computing embeddings.
-            document_embedding_store: The store to use for caching document embeddings.
-            batch_size: The number of documents to embed between store updates.
-            query_embedding_store: The store to use for caching query embeddings.
-                If `None`, query embeddings are not cached.
-        """
-        super().__init__()
-        self.document_embedding_store = document_embedding_store
-        self.query_embedding_store = query_embedding_store
-        self.underlying_embeddings = underlying_embeddings
-        self.batch_size = batch_size
-
-    def embed_documents(self, texts: list[str]) -> list[list[float]]:
-        """Embed a list of texts.
-
-        The method first checks the cache for the embeddings.
-        If the embeddings are not found, the method uses the underlying embedder
-        to embed the documents and stores the results in the cache.
-
-        Args:
-            texts: A list of texts to embed.
-
-        Returns:
-            A list of embeddings for the given texts.
-        """
-        vectors: list[list[float] | None] = self.document_embedding_store.mget(
-            texts,
-        )
-        all_missing_indices: list[int] = [i for i, vector in enumerate(vectors) if vector is None]
-
-        for missing_indices in batch_iterate(self.batch_size, all_missing_indices):
-            missing_texts = [texts[i] for i in missing_indices]
-            missing_vectors = self.underlying_embeddings.embed_documents(missing_texts)
-            self.document_embedding_store.mset(
-                list(zip(missing_texts, missing_vectors, strict=False)),
-            )
-            for index, updated_vector in zip(missing_indices, missing_vectors, strict=False):
-                vectors[index] = updated_vector
-
-        return cast(
-            "list[list[float]]",
-            vectors,
-        )  # Nones should have been resolved by now
-
-    async def aembed_documents(self, texts: list[str]) -> list[list[float]]:
-        """Embed a list of texts.
-
-        The method first checks the cache for the embeddings.
-        If the embeddings are not found, the method uses the underlying embedder
-        to embed the documents and stores the results in the cache.
-
-        Args:
-            texts: A list of texts to embed.
-
-        Returns:
-            A list of embeddings for the given texts.
-        """
-        vectors: list[list[float] | None] = await self.document_embedding_store.amget(texts)
-        all_missing_indices: list[int] = [i for i, vector in enumerate(vectors) if vector is None]
-
-        # batch_iterate supports None batch_size which returns all elements at once
-        # as a single batch.
-        for missing_indices in batch_iterate(self.batch_size, all_missing_indices):
-            missing_texts = [texts[i] for i in missing_indices]
-            missing_vectors = await self.underlying_embeddings.aembed_documents(
-                missing_texts,
-            )
-            await self.document_embedding_store.amset(
-                list(zip(missing_texts, missing_vectors, strict=False)),
-            )
-            for index, updated_vector in zip(missing_indices, missing_vectors, strict=False):
-                vectors[index] = updated_vector
-
-        return cast(
-            "list[list[float]]",
-            vectors,
-        )  # Nones should have been resolved by now
-
-    def embed_query(self, text: str) -> list[float]:
-        """Embed query text.
-
-        By default, this method does not cache queries. To enable caching, set the
-        `cache_query` parameter to `True` when initializing the embedder.
-
-        Args:
-            text: The text to embed.
-
-        Returns:
-            The embedding for the given text.
-        """
-        if not self.query_embedding_store:
-            return self.underlying_embeddings.embed_query(text)
-
-        (cached,) = self.query_embedding_store.mget([text])
-        if cached is not None:
-            return cached
-
-        vector = self.underlying_embeddings.embed_query(text)
-        self.query_embedding_store.mset([(text, vector)])
-        return vector
-
-    async def aembed_query(self, text: str) -> list[float]:
-        """Embed query text.
-
-        By default, this method does not cache queries. To enable caching, set the
-        `cache_query` parameter to `True` when initializing the embedder.
-
-        Args:
-            text: The text to embed.
-
-        Returns:
-            The embedding for the given text.
-        """
-        if not self.query_embedding_store:
-            return await self.underlying_embeddings.aembed_query(text)
-
-        (cached,) = await self.query_embedding_store.amget([text])
-        if cached is not None:
-            return cached
-
-        vector = await self.underlying_embeddings.aembed_query(text)
-        await self.query_embedding_store.amset([(text, vector)])
-        return vector
-
-    @classmethod
-    def from_bytes_store(
-        cls,
-        underlying_embeddings: Embeddings,
-        document_embedding_cache: ByteStore,
-        *,
-        namespace: str = "",
-        batch_size: int | None = None,
-        query_embedding_cache: bool | ByteStore = False,
-        key_encoder: Callable[[str], str] | Literal["sha1", "blake2b", "sha256", "sha512"] = "sha1",
-    ) -> CacheBackedEmbeddings:
-        """On-ramp that adds the necessary serialization and encoding to the store.
-
-        Args:
-            underlying_embeddings: The embedder to use for embedding.
-            document_embedding_cache: The cache to use for storing document embeddings.
-            namespace: The namespace to use for document cache.
-                This namespace is used to avoid collisions with other caches.
-                For example, set it to the name of the embedding model used.
-            batch_size: The number of documents to embed between store updates.
-            query_embedding_cache: The cache to use for storing query embeddings.
-                True to use the same cache as document embeddings.
-                False to not cache query embeddings.
-            key_encoder: Optional callable to encode keys. If not provided,
-                a default encoder using SHA-1 will be used. SHA-1 is not
-                collision-resistant, and a motivated attacker could craft two
-                different texts that hash to the same cache key.
-
-                New applications should use one of the alternative encoders
-                or provide a custom and strong key encoder function to avoid this risk.
-
-                If you change a key encoder in an existing cache, consider
-                just creating a new cache, to avoid (the potential for)
-                collisions with existing keys or having duplicate keys
-                for the same text in the cache.
-
-        Returns:
-            An instance of CacheBackedEmbeddings that uses the provided cache.
-        """
-        if isinstance(key_encoder, str):
-            key_encoder = _make_default_key_encoder(namespace, key_encoder)
-        elif callable(key_encoder):
-            # If a custom key encoder is provided, it should not be used with a
-            # namespace.
-            # A user can handle namespacing in directly their custom key encoder.
-            if namespace:
-                msg = (
-                    "Do not supply `namespace` when using a custom key_encoder; "
-                    "add any prefixing inside the encoder itself."
-                )
-                raise ValueError(msg)
-        else:
-            msg = (
-                "key_encoder must be either 'blake2b', 'sha1', 'sha256', 'sha512' "
-                "or a callable that encodes keys."
-            )
-            raise ValueError(msg)  # noqa: TRY004
-
-        document_embedding_store = EncoderBackedStore[str, list[float]](
-            document_embedding_cache,
-            key_encoder,
-            _value_serializer,
-            _value_deserializer,
-        )
-        if query_embedding_cache is True:
-            query_embedding_store = document_embedding_store
-        elif query_embedding_cache is False:
-            query_embedding_store = None
-        else:
-            query_embedding_store = EncoderBackedStore[str, list[float]](
-                query_embedding_cache,
-                key_encoder,
-                _value_serializer,
-                _value_deserializer,
-            )
-
-        return cls(
-            underlying_embeddings,
-            document_embedding_store,
-            batch_size=batch_size,
-            query_embedding_store=query_embedding_store,
-        )

langchain/storage/__init__.py

@@ -1,22 +0,0 @@
-"""Implementations of key-value stores and storage helpers.
-
-Module provides implementations of various key-value stores that conform
-to a simple key-value interface.
-
-The primary goal of these storages is to support implementation of caching.
-"""
-
-from langchain_core.stores import (
-    InMemoryByteStore,
-    InMemoryStore,
-    InvalidKeyException,
-)
-
-from langchain.storage.encoder_backed import EncoderBackedStore
-
-__all__ = [
-    "EncoderBackedStore",
-    "InMemoryByteStore",
-    "InMemoryStore",
-    "InvalidKeyException",
-]

langchain/storage/encoder_backed.py

@@ -1,122 +0,0 @@
-"""Encoder-backed store implementation."""
-
-from collections.abc import AsyncIterator, Callable, Iterator, Sequence
-from typing import (
-    Any,
-    TypeVar,
-)
-
-from langchain_core.stores import BaseStore
-
-K = TypeVar("K")
-V = TypeVar("V")
-
-
-class EncoderBackedStore(BaseStore[K, V]):
-    """Wraps a store with key and value encoders/decoders.
-
-    Examples that uses JSON for encoding/decoding:
-
-    ```python
-    import json
-
-
-    def key_encoder(key: int) -> str:
-        return json.dumps(key)
-
-
-    def value_serializer(value: float) -> str:
-        return json.dumps(value)
-
-
-    def value_deserializer(serialized_value: str) -> float:
-        return json.loads(serialized_value)
-
-
-    # Create an instance of the abstract store
-    abstract_store = MyCustomStore()
-
-    # Create an instance of the encoder-backed store
-    store = EncoderBackedStore(
-        store=abstract_store,
-        key_encoder=key_encoder,
-        value_serializer=value_serializer,
-        value_deserializer=value_deserializer,
-    )
-
-    # Use the encoder-backed store methods
-    store.mset([(1, 3.14), (2, 2.718)])
-    values = store.mget([1, 2])  # Retrieves [3.14, 2.718]
-    store.mdelete([1, 2])  # Deletes the keys 1 and 2
-    ```
-    """
-
-    def __init__(
-        self,
-        store: BaseStore[str, Any],
-        key_encoder: Callable[[K], str],
-        value_serializer: Callable[[V], bytes],
-        value_deserializer: Callable[[Any], V],
-    ) -> None:
-        """Initialize an EncodedStore."""
-        self.store = store
-        self.key_encoder = key_encoder
-        self.value_serializer = value_serializer
-        self.value_deserializer = value_deserializer
-
-    def mget(self, keys: Sequence[K]) -> list[V | None]:
-        """Get the values associated with the given keys."""
-        encoded_keys: list[str] = [self.key_encoder(key) for key in keys]
-        values = self.store.mget(encoded_keys)
-        return [self.value_deserializer(value) if value is not None else value for value in values]
-
-    async def amget(self, keys: Sequence[K]) -> list[V | None]:
-        """Get the values associated with the given keys."""
-        encoded_keys: list[str] = [self.key_encoder(key) for key in keys]
-        values = await self.store.amget(encoded_keys)
-        return [self.value_deserializer(value) if value is not None else value for value in values]
-
-    def mset(self, key_value_pairs: Sequence[tuple[K, V]]) -> None:
-        """Set the values for the given keys."""
-        encoded_pairs = [
-            (self.key_encoder(key), self.value_serializer(value)) for key, value in key_value_pairs
-        ]
-        self.store.mset(encoded_pairs)
-
-    async def amset(self, key_value_pairs: Sequence[tuple[K, V]]) -> None:
-        """Set the values for the given keys."""
-        encoded_pairs = [
-            (self.key_encoder(key), self.value_serializer(value)) for key, value in key_value_pairs
-        ]
-        await self.store.amset(encoded_pairs)
-
-    def mdelete(self, keys: Sequence[K]) -> None:
-        """Delete the given keys and their associated values."""
-        encoded_keys = [self.key_encoder(key) for key in keys]
-        self.store.mdelete(encoded_keys)
-
-    async def amdelete(self, keys: Sequence[K]) -> None:
-        """Delete the given keys and their associated values."""
-        encoded_keys = [self.key_encoder(key) for key in keys]
-        await self.store.amdelete(encoded_keys)
-
-    def yield_keys(
-        self,
-        *,
-        prefix: str | None = None,
-    ) -> Iterator[K] | Iterator[str]:
-        """Get an iterator over keys that match the given prefix."""
-        # For the time being this does not return K, but str
-        # it's for debugging purposes. Should fix this.
-        yield from self.store.yield_keys(prefix=prefix)
-
-    async def ayield_keys(
-        self,
-        *,
-        prefix: str | None = None,
-    ) -> AsyncIterator[K] | AsyncIterator[str]:
-        """Get an iterator over keys that match the given prefix."""
-        # For the time being this does not return K, but str
-        # it's for debugging purposes. Should fix this.
-        async for key in self.store.ayield_keys(prefix=prefix):
-            yield key

langchain/storage/exceptions.py

@@ -1,5 +0,0 @@
-"""Store exceptions."""
-
-from langchain_core.stores import InvalidKeyException
-
-__all__ = ["InvalidKeyException"]

langchain/storage/in_memory.py

@@ -1,13 +0,0 @@
-"""In memory store that is not thread safe and has no eviction policy.
-
-This is a simple implementation of the BaseStore using a dictionary that is useful
-primarily for unit testing purposes.
-"""
-
-from langchain_core.stores import InMemoryBaseStore, InMemoryByteStore, InMemoryStore
-
-__all__ = [
-    "InMemoryBaseStore",
-    "InMemoryByteStore",
-    "InMemoryStore",
-]