langchain-core 1.0.0rc2__py3-none-any.whl → 1.0.1__py3-none-any.whl

langchain_core/runnables/base.py

@@ -860,7 +860,7 @@ class Runnable(ABC, Generic[Input, Output]):
 
         The default implementation of batch works well for IO bound runnables.
 
-        Subclasses should override this method if they can batch more efficiently;
+        Subclasses must override this method if they can batch more efficiently;
         e.g., if the underlying `Runnable` uses an API which supports a batch mode.
 
         Args:
@@ -992,7 +992,7 @@ class Runnable(ABC, Generic[Input, Output]):
 
         The default implementation of `batch` works well for IO bound runnables.
 
-        Subclasses should override this method if they can batch more efficiently;
+        Subclasses must override this method if they can batch more efficiently;
         e.g., if the underlying `Runnable` uses an API which supports a batch mode.
 
         Args:
@@ -1112,7 +1112,7 @@ class Runnable(ABC, Generic[Input, Output]):
     ) -> Iterator[Output]:
         """Default implementation of `stream`, which calls `invoke`.
 
-        Subclasses should override this method if they support streaming output.
+        Subclasses must override this method if they support streaming output.
 
         Args:
             input: The input to the `Runnable`.
@@ -1133,7 +1133,7 @@ class Runnable(ABC, Generic[Input, Output]):
     ) -> AsyncIterator[Output]:
         """Default implementation of `astream`, which calls `ainvoke`.
 
-        Subclasses should override this method if they support streaming output.
+        Subclasses must override this method if they support streaming output.
 
         Args:
             input: The input to the `Runnable`.
@@ -1367,8 +1367,8 @@ class Runnable(ABC, Generic[Input, Output]):
 
         events = [event async for event in chain.astream_events("hello", version="v2")]
 
-        # will produce the following events (run_id, and parent_ids
-        # has been omitted for brevity):
+        # Will produce the following events
+        # (run_id, and parent_ids has been omitted for brevity):
         [
             {
                 "data": {"input": "hello"},
@@ -1423,7 +1423,7 @@ class Runnable(ABC, Generic[Input, Output]):
 
         async for event in slow_thing.astream_events("some_input", version="v2"):
             print(event)
-        ``
+        ```
 
         Args:
             input: The input to the `Runnable`.
@@ -1497,7 +1497,7 @@ class Runnable(ABC, Generic[Input, Output]):
 
         Default implementation of transform, which buffers input and calls `astream`.
 
-        Subclasses should override this method if they can start producing output while
+        Subclasses must override this method if they can start producing output while
         input is still being generated.
 
         Args:
@@ -1542,7 +1542,7 @@ class Runnable(ABC, Generic[Input, Output]):
 
         Default implementation of atransform, which buffers input and calls `astream`.
 
-        Subclasses should override this method if they can start producing output while
+        Subclasses must override this method if they can start producing output while
         input is still being generated.
 
         Args:
@@ -1813,7 +1813,7 @@ class Runnable(ABC, Generic[Input, Output]):
             output_type: The output type to bind to the `Runnable`.
 
         Returns:
-            A new Runnable with the types bound.
+            A new `Runnable` with the types bound.
         """
         return RunnableBinding(
             bound=self,
@@ -1840,7 +1840,7 @@ class Runnable(ABC, Generic[Input, Output]):
                 giving up.
             exponential_jitter_params: Parameters for
                 `tenacity.wait_exponential_jitter`. Namely: `initial`, `max`,
-                `exp_base`, and `jitter` (all float values).
+                `exp_base`, and `jitter` (all `float` values).
 
         Returns:
             A new Runnable that retries the original Runnable on exceptions.
@@ -1925,15 +1925,15 @@ class Runnable(ABC, Generic[Input, Output]):
             fallbacks: A sequence of runnables to try if the original `Runnable`
                 fails.
             exceptions_to_handle: A tuple of exception types to handle.
-            exception_key: If string is specified then handled exceptions will be passed
-                to fallbacks as part of the input under the specified key.
+            exception_key: If `string` is specified then handled exceptions will be
+                passed to fallbacks as part of the input under the specified key.
                 If `None`, exceptions will not be passed to fallbacks.
                 If used, the base `Runnable` and its fallbacks must accept a
                 dictionary as input.
 
         Returns:
             A new `Runnable` that will try the original `Runnable`, and then each
-            Fallback in order, upon failures.
+                Fallback in order, upon failures.
 
         Example:
             ```python
@@ -1961,16 +1961,15 @@ class Runnable(ABC, Generic[Input, Output]):
             fallbacks: A sequence of runnables to try if the original `Runnable`
                 fails.
             exceptions_to_handle: A tuple of exception types to handle.
-            exception_key: If string is specified then handled exceptions will be passed
-                to fallbacks as part of the input under the specified key.
+            exception_key: If `string` is specified then handled exceptions will be
+                passed to fallbacks as part of the input under the specified key.
                 If `None`, exceptions will not be passed to fallbacks.
                 If used, the base `Runnable` and its fallbacks must accept a
                 dictionary as input.
 
         Returns:
             A new `Runnable` that will try the original `Runnable`, and then each
-            Fallback in order, upon failures.
-
+                Fallback in order, upon failures.
         """
         # Import locally to prevent circular import
         from langchain_core.runnables.fallbacks import (  # noqa: PLC0415
@@ -2520,9 +2519,6 @@ class Runnable(ABC, Generic[Input, Output]):
         as_tool = runnable.as_tool()
         as_tool.invoke("b")
         ```
-
-        !!! version-added "Added in version 0.2.14"
-
         """
         # Avoid circular import
         from langchain_core.tools import convert_runnable_to_tool  # noqa: PLC0415

langchain_core/runnables/branch.py

@@ -40,13 +40,13 @@ from langchain_core.runnables.utils import (
 class RunnableBranch(RunnableSerializable[Input, Output]):
     """Runnable that selects which branch to run based on a condition.
 
-    The Runnable is initialized with a list of (condition, Runnable) pairs and
+    The Runnable is initialized with a list of `(condition, Runnable)` pairs and
     a default branch.
 
     When operating on an input, the first condition that evaluates to True is
-    selected, and the corresponding Runnable is run on the input.
+    selected, and the corresponding `Runnable` is run on the input.
 
-    If no condition evaluates to True, the default branch is run on the input.
+    If no condition evaluates to `True`, the default branch is run on the input.
 
     Examples:
         ```python
@@ -65,9 +65,9 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
     """
 
     branches: Sequence[tuple[Runnable[Input, bool], Runnable[Input, Output]]]
-    """A list of (condition, Runnable) pairs."""
+    """A list of `(condition, Runnable)` pairs."""
     default: Runnable[Input, Output]
-    """A Runnable to run if no condition is met."""
+    """A `Runnable` to run if no condition is met."""
 
     def __init__(
         self,
@@ -79,15 +79,15 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
         ]
         | RunnableLike,
     ) -> None:
-        """A Runnable that runs one of two branches based on a condition.
+        """A `Runnable` that runs one of two branches based on a condition.
 
         Args:
-            *branches: A list of (condition, Runnable) pairs.
-                Defaults a Runnable to run if no condition is met.
+            *branches: A list of `(condition, Runnable)` pairs.
+                Defaults a `Runnable` to run if no condition is met.
 
         Raises:
             ValueError: If the number of branches is less than 2.
-            TypeError: If the default branch is not Runnable, Callable or Mapping.
+            TypeError: If the default branch is not `Runnable`, `Callable` or `Mapping`.
             TypeError: If a branch is not a tuple or list.
             ValueError: If a branch is not of length 2.
         """

langchain_core/runnables/config.py

@@ -75,26 +75,26 @@ class RunnableConfig(TypedDict, total=False):
     max_concurrency: int | None
     """
     Maximum number of parallel calls to make. If not provided, defaults to
-    ThreadPoolExecutor's default.
+    `ThreadPoolExecutor`'s default.
     """
 
     recursion_limit: int
     """
-    Maximum number of times a call can recurse. If not provided, defaults to 25.
+    Maximum number of times a call can recurse. If not provided, defaults to `25`.
     """
 
     configurable: dict[str, Any]
     """
-    Runtime values for attributes previously made configurable on this Runnable,
-    or sub-Runnables, through .configurable_fields() or .configurable_alternatives().
-    Check .output_schema() for a description of the attributes that have been made
+    Runtime values for attributes previously made configurable on this `Runnable`,
+    or sub-Runnables, through `configurable_fields` or `configurable_alternatives`.
+    Check `output_schema` for a description of the attributes that have been made
     configurable.
     """
 
     run_id: uuid.UUID | None
     """
     Unique identifier for the tracer run for this call. If not provided, a new UUID
-        will be generated.
+    will be generated.
     """
 
 
@@ -527,8 +527,7 @@ class ContextThreadPoolExecutor(ThreadPoolExecutor):
         self,
         fn: Callable[..., T],
         *iterables: Iterable[Any],
-        timeout: float | None = None,
-        chunksize: int = 1,
+        **kwargs: Any,
     ) -> Iterator[T]:
         """Map a function to multiple iterables.
 
@@ -549,8 +548,7 @@ class ContextThreadPoolExecutor(ThreadPoolExecutor):
         return super().map(
             _wrapped_fn,
             *iterables,
-            timeout=timeout,
-            chunksize=chunksize,
+            **kwargs,
         )
 
 

langchain_core/runnables/fallbacks.py

@@ -96,7 +96,7 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
     Any exception that is not a subclass of these exceptions will be raised immediately.
     """
     exception_key: str | None = None
-    """If string is specified then handled exceptions will be passed to fallbacks as
+    """If `string` is specified then handled exceptions will be passed to fallbacks as
         part of the input under the specified key. If `None`, exceptions
         will not be passed to fallbacks. If used, the base Runnable and its fallbacks
         must accept a dictionary as input."""

langchain_core/runnables/retry.py

@@ -126,7 +126,7 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
 
     exponential_jitter_params: ExponentialJitterParams | None = None
     """Parameters for `tenacity.wait_exponential_jitter`. Namely: `initial`,
-    `max`, `exp_base`, and `jitter` (all float values).
+    `max`, `exp_base`, and `jitter` (all `float` values).
     """
 
     max_attempt_number: int = 3

langchain_core/runnables/schema.py

@@ -65,7 +65,7 @@ class BaseStreamEvent(TypedDict):
 
         events = [event async for event in chain.astream_events("hello")]
 
-        # will produce the following events
+        # Will produce the following events
         # (where some fields have been omitted for brevity):
         [
             {
@@ -168,10 +168,7 @@ class StandardStreamEvent(BaseStreamEvent):
 
 
 class CustomStreamEvent(BaseStreamEvent):
-    """Custom stream event created by the user.
-
-    !!! version-added "Added in version 0.2.15"
-    """
+    """Custom stream event created by the user."""
 
     # Overwrite the event field to be more specific.
     event: Literal["on_custom_event"]  # type: ignore[misc]

langchain_core/runnables/utils.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import ast
 import asyncio
 import inspect
+import sys
 import textwrap
 from collections.abc import Callable, Mapping, Sequence
 from contextvars import Context
@@ -118,14 +119,13 @@ def accepts_context(callable: Callable[..., Any]) -> bool:  # noqa: A002
         return False
 
 
-@lru_cache(maxsize=1)
 def asyncio_accepts_context() -> bool:
-    """Cache the result of checking if asyncio.create_task accepts a `context` arg.
+    """Check if asyncio.create_task accepts a `context` arg.
 
     Returns:
         True if `asyncio.create_task` accepts a context argument, `False` otherwise.
     """
-    return accepts_context(asyncio.create_task)
+    return sys.version_info >= (3, 11)
 
 
 def coro_with_context(

langchain_core/stores.py

@@ -86,7 +86,7 @@ class BaseStore(ABC, Generic[K, V]):
 
         Returns:
             A sequence of optional values associated with the keys.
-            If a key is not found, the corresponding value will be None.
+            If a key is not found, the corresponding value will be `None`.
         """
 
     async def amget(self, keys: Sequence[K]) -> list[V | None]:
@@ -97,7 +97,7 @@ class BaseStore(ABC, Generic[K, V]):
 
         Returns:
             A sequence of optional values associated with the keys.
-            If a key is not found, the corresponding value will be None.
+            If a key is not found, the corresponding value will be `None`.
         """
         return await run_in_executor(None, self.mget, keys)
 
@@ -243,8 +243,7 @@ class InMemoryStore(InMemoryBaseStore[Any]):
     """In-memory store for any type of data.
 
     Attributes:
-        store (dict[str, Any]): The underlying dictionary that stores
-            the key-value pairs.
+        store: The underlying dictionary that stores the key-value pairs.
 
     Examples:
         ```python
@@ -267,8 +266,7 @@ class InMemoryByteStore(InMemoryBaseStore[bytes]):
     """In-memory store for bytes.
 
     Attributes:
-        store (dict[str, bytes]): The underlying dictionary that stores
-            the key-value pairs.
+        store: The underlying dictionary that stores the key-value pairs.
 
     Examples:
         ```python

langchain_core/tools/base.py

@@ -483,7 +483,7 @@ class ChildTool(BaseTool):
     """The tool response format.
 
     If `"content"` then the output of the tool is interpreted as the contents of a
-    ToolMessage. If `"content_and_artifact"` then the output is expected to be a
+    `ToolMessage`. If `"content_and_artifact"` then the output is expected to be a
     two-tuple corresponding to the (content, artifact) of a `ToolMessage`.
     """
 
@@ -615,7 +615,7 @@ class ChildTool(BaseTool):
             The parsed and validated input.
 
         Raises:
-            ValueError: If string input is provided with JSON schema `args_schema`.
+            ValueError: If `string` input is provided with JSON schema `args_schema`.
             ValueError: If InjectedToolCallId is required but `tool_call_id` is not
                 provided.
             TypeError: If args_schema is not a Pydantic `BaseModel` or dict.
@@ -1210,6 +1210,26 @@ class InjectedToolArg:
     """
 
 
+class _DirectlyInjectedToolArg:
+    """Annotation for tool arguments that are injected at runtime.
+
+    Injected via direct type annotation, rather than annotated metadata.
+
+    For example, ToolRuntime is a directly injected argument.
+    Note the direct annotation rather than the verbose alternative:
+    Annotated[ToolRuntime, InjectedRuntime]
+    ```python
+    from langchain_core.tools import tool, ToolRuntime
+
+
+    @tool
+    def foo(x: int, runtime: ToolRuntime) -> str:
+        # use runtime.state, runtime.context, runtime.store, etc.
+        ...
+    ```
+    """
+
+
 class InjectedToolCallId(InjectedToolArg):
     """Annotation for injecting the tool call ID.
 
@@ -1237,6 +1257,24 @@ class InjectedToolCallId(InjectedToolArg):
     """
 
 
+def _is_directly_injected_arg_type(type_: Any) -> bool:
+    """Check if a type annotation indicates a directly injected argument.
+
+    This is currently only used for ToolRuntime.
+    Checks if either the annotation itself is a subclass of _DirectlyInjectedToolArg
+    or the origin of the annotation is a subclass of _DirectlyInjectedToolArg.
+
+    Ex: ToolRuntime or ToolRuntime[ContextT, StateT] would both return True.
+    """
+    return (
+        isinstance(type_, type) and issubclass(type_, _DirectlyInjectedToolArg)
+    ) or (
+        (origin := get_origin(type_)) is not None
+        and isinstance(origin, type)
+        and issubclass(origin, _DirectlyInjectedToolArg)
+    )
+
+
 def _is_injected_arg_type(
     type_: type | TypeVar, injected_type: type[InjectedToolArg] | None = None
 ) -> bool:
@@ -1249,7 +1287,15 @@ def _is_injected_arg_type(
     Returns:
         `True` if the type is an injected argument, `False` otherwise.
     """
-    injected_type = injected_type or InjectedToolArg
+    if injected_type is None:
+        # if no injected type is specified,
+        # check if the type is a directly injected argument
+        if _is_directly_injected_arg_type(type_):
+            return True
+        injected_type = InjectedToolArg
+
+    # if the type is an Annotated type, check if annotated metadata
+    # is an intance or subclass of the injected type
     return any(
         isinstance(arg, injected_type)
         or (isinstance(arg, type) and issubclass(arg, injected_type))

langchain_core/tools/convert.py

@@ -151,8 +151,6 @@ def tool(
             return "partial json of results", {"full": "object of results"}
         ```
 
-    !!! version-added "Added in version 0.2.14"
-
         Parse Google-style docstrings:
 
         ```python

langchain_core/tracers/event_stream.py

@@ -128,7 +128,10 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
             exclude_tags=exclude_tags,
         )
 
-        loop = asyncio.get_event_loop()
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
         memory_stream = _MemoryStream[StreamEvent](loop)
         self.send_stream = memory_stream.get_send_stream()
         self.receive_stream = memory_stream.get_receive_stream()

langchain_core/tracers/log_stream.py

@@ -264,7 +264,10 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
         self.exclude_types = exclude_types
         self.exclude_tags = exclude_tags
 
-        loop = asyncio.get_event_loop()
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
         memory_stream = _MemoryStream[RunLogPatch](loop)
         self.lock = threading.Lock()
         self.send_stream = memory_stream.get_send_stream()

langchain_core/utils/function_calling.py

@@ -425,6 +425,14 @@ def convert_to_openai_function(
             oai_function["parameters"] = _recursive_set_additional_properties_false(
                 oai_function["parameters"]
             )
+            # All fields must be `required`
+            parameters = oai_function.get("parameters")
+            if isinstance(parameters, dict):
+                fields = parameters.get("properties")
+                if isinstance(fields, dict) and fields:
+                    parameters = dict(parameters)
+                    parameters["required"] = list(fields.keys())
+                    oai_function["parameters"] = parameters
     return oai_function
 
 

langchain_core/utils/json_schema.py

@@ -226,7 +226,7 @@ def dereference_refs(
         ... }
         >>> result = dereference_refs(schema)  # Won't cause infinite recursion
 
-    Note:
+    !!! note
         - Circular references are handled gracefully by breaking cycles
         - Mixed $ref objects (with both $ref and other properties) are supported
         - Additional properties in mixed $refs override resolved properties