langchain-core 0.3.69__tar.gz → 0.3.70__tar.gz

{langchain_core-0.3.69 → langchain_core-0.3.70}/PKG-INFO

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

{langchain_core-0.3.69 → langchain_core-0.3.70}/langchain_core/_import_utils.py

@@ -27,8 +27,8 @@ def import_attr(
     else:
         try:
             module = import_module(f".{module_name}", package=package)
-        except ModuleNotFoundError:
-            msg = f"module '{package!r}.{module_name!r}' not found"
+        except ModuleNotFoundError as err:
+            msg = f"module '{package!r}.{module_name!r}' not found ({err})"
             raise ImportError(msg) from None
         result = getattr(module, attr_name)
     return result

{langchain_core-0.3.69 → langchain_core-0.3.70}/langchain_core/language_models/fake_chat_models.py

@@ -36,6 +36,8 @@ class FakeMessagesListChatModel(BaseChatModel):
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> ChatResult:
+        if self.sleep is not None:
+            time.sleep(self.sleep)
         response = self.responses[self.i]
         if self.i < len(self.responses) - 1:
             self.i += 1
@@ -61,9 +63,9 @@ class FakeListChatModel(SimpleChatModel):
     """List of responses to **cycle** through in order."""
     sleep: Optional[float] = None
     i: int = 0
-    """List of responses to **cycle** through in order."""
-    error_on_chunk_number: Optional[int] = None
     """Internally incremented after every model invocation."""
+    error_on_chunk_number: Optional[int] = None
+    """If set, raise an error on the specified chunk number during streaming."""
 
     @property
     @override
@@ -79,6 +81,8 @@ class FakeListChatModel(SimpleChatModel):
         **kwargs: Any,
     ) -> str:
         """First try to lookup in queries, else return 'foo' or 'bar'."""
+        if self.sleep is not None:
+            time.sleep(self.sleep)
         response = self.responses[self.i]
         if self.i < len(self.responses) - 1:
             self.i += 1

{langchain_core-0.3.69 → langchain_core-0.3.70}/langchain_core/output_parsers/openai_tools.py

@@ -234,12 +234,39 @@ class JsonOutputKeyToolsParser(JsonOutputToolsParser):
         Returns:
             The parsed tool calls.
         """
-        parsed_result = super().parse_result(result, partial=partial)
-
+        generation = result[0]
+        if not isinstance(generation, ChatGeneration):
+            msg = "This output parser can only be used with a chat generation."
+            raise OutputParserException(msg)
+        message = generation.message
+        if isinstance(message, AIMessage) and message.tool_calls:
+            parsed_tool_calls = [dict(tc) for tc in message.tool_calls]
+            for tool_call in parsed_tool_calls:
+                if not self.return_id:
+                    _ = tool_call.pop("id")
+        else:
+            try:
+                raw_tool_calls = copy.deepcopy(message.additional_kwargs["tool_calls"])
+            except KeyError:
+                if self.first_tool_only:
+                    return None
+                return []
+            parsed_tool_calls = parse_tool_calls(
+                raw_tool_calls,
+                partial=partial,
+                strict=self.strict,
+                return_id=self.return_id,
+            )
+        # For backwards compatibility
+        for tc in parsed_tool_calls:
+            tc["type"] = tc.pop("name")
         if self.first_tool_only:
+            parsed_result = list(
+                filter(lambda x: x["type"] == self.key_name, parsed_tool_calls)
+            )
             single_result = (
-                parsed_result
-                if parsed_result and parsed_result["type"] == self.key_name
+                parsed_result[0]
+                if parsed_result and parsed_result[0]["type"] == self.key_name
                 else None
             )
             if self.return_id:
@@ -247,10 +274,13 @@ class JsonOutputKeyToolsParser(JsonOutputToolsParser):
             if single_result:
                 return single_result["args"]
             return None
-        parsed_result = [res for res in parsed_result if res["type"] == self.key_name]
-        if not self.return_id:
-            parsed_result = [res["args"] for res in parsed_result]
-        return parsed_result
+        return (
+            [res for res in parsed_tool_calls if res["type"] == self.key_name]
+            if self.return_id
+            else [
+                res["args"] for res in parsed_tool_calls if res["type"] == self.key_name
+            ]
+        )
 
 
 # Common cause of ValidationError is truncated output due to max_tokens.

{langchain_core-0.3.69 → langchain_core-0.3.70}/langchain_core/outputs/__init__.py

@@ -1,24 +1,23 @@
 """Output classes.
 
-**Output** classes are used to represent the output of a language model call
-and the output of a chat.
+Used to represent the output of a language model call and the output of a chat.
 
-The top container for information is the `LLMResult` object. `LLMResult` is used by
-both chat models and LLMs. This object contains the output of the language
-model and any additional information that the model provider wants to return.
+The top container for information is the `LLMResult` object. `LLMResult` is used by both
+chat models and LLMs. This object contains the output of the language model and any
+additional information that the model provider wants to return.
 
 When invoking models via the standard runnable methods (e.g. invoke, batch, etc.):
+
 - Chat models will return `AIMessage` objects.
 - LLMs will return regular text strings.
 
 In addition, users can access the raw output of either LLMs or chat models via
-callbacks. The on_chat_model_end and on_llm_end callbacks will return an
+callbacks. The ``on_chat_model_end`` and ``on_llm_end`` callbacks will return an
 LLMResult object containing the generated outputs and any additional information
 returned by the model provider.
 
-In general, if information is already available
-in the AIMessage object, it is recommended to access it from there rather than
-from the `LLMResult` object.
+In general, if information is already available in the AIMessage object, it is
+recommended to access it from there rather than from the `LLMResult` object.
 """
 
 from typing import TYPE_CHECKING

{langchain_core-0.3.69 → langchain_core-0.3.70}/langchain_core/outputs/chat_generation.py

@@ -27,7 +27,11 @@ class ChatGeneration(Generation):
     """
 
     text: str = ""
-    """*SHOULD NOT BE SET DIRECTLY* The text contents of the output message."""
+    """The text contents of the output message.
+
+    .. warning::
+        SHOULD NOT BE SET DIRECTLY!
+    """
     message: BaseMessage
     """The message output by the chat model."""
     # Override type to be ChatGeneration, ignore mypy error as this is intentional

{langchain_core-0.3.69 → langchain_core-0.3.70}/langchain_core/outputs/generation.py

@@ -11,7 +11,8 @@ from langchain_core.utils._merge import merge_dicts
 class Generation(Serializable):
     """A single text generation output.
 
-    Generation represents the response from an "old-fashioned" LLM that
+    Generation represents the response from an
+    `"old-fashioned" LLM <https://python.langchain.com/docs/concepts/text_llms/>__` that
     generates regular text (not chat messages).
 
     This model is used internally by chat model and will eventually

{langchain_core-0.3.69 → langchain_core-0.3.70}/langchain_core/outputs/llm_result.py

@@ -15,9 +15,9 @@ from langchain_core.outputs.run_info import RunInfo
 class LLMResult(BaseModel):
     """A container for results of an LLM call.
 
-    Both chat models and LLMs generate an LLMResult object. This object contains
-    the generated outputs and any additional information that the model provider
-    wants to return.
+    Both chat models and LLMs generate an LLMResult object. This object contains the
+    generated outputs and any additional information that the model provider wants to
+    return.
     """
 
     generations: list[
@@ -25,17 +25,16 @@ class LLMResult(BaseModel):
     ]
     """Generated outputs.
 
-    The first dimension of the list represents completions for different input
-    prompts.
+    The first dimension of the list represents completions for different input prompts.
 
-    The second dimension of the list represents different candidate generations
-    for a given prompt.
+    The second dimension of the list represents different candidate generations for a
+    given prompt.
 
-    When returned from an LLM the type is list[list[Generation]].
-    When returned from a chat model the type is list[list[ChatGeneration]].
+    - When returned from **an LLM**, the type is ``list[list[Generation]]``.
+    - When returned from a **chat model**, the type is ``list[list[ChatGeneration]]``.
 
-    ChatGeneration is a subclass of Generation that has a field for a structured
-    chat message.
+    ChatGeneration is a subclass of Generation that has a field for a structured chat
+    message.
     """
     llm_output: Optional[dict] = None
     """For arbitrary LLM provider specific output.
@@ -43,9 +42,8 @@ class LLMResult(BaseModel):
     This dictionary is a free-form dictionary that can contain any information that the
     provider wants to return. It is not standardized and is provider-specific.
 
-    Users should generally avoid relying on this field and instead rely on
-    accessing relevant information from standardized fields present in
-    AIMessage.
+    Users should generally avoid relying on this field and instead rely on accessing
+    relevant information from standardized fields present in AIMessage.
     """
     run: Optional[list[RunInfo]] = None
     """List of metadata info for model call for each input."""

{langchain_core-0.3.69 → langchain_core-0.3.70}/langchain_core/rate_limiters.py

@@ -146,13 +146,12 @@ class InMemoryRateLimiter(BaseRateLimiter):
 
         Args:
             requests_per_second: The number of tokens to add per second to the bucket.
-                Must be at least 1. The tokens represent "credit" that can be used
-                to make requests.
+                The tokens represent "credit" that can be used to make requests.
             check_every_n_seconds: check whether the tokens are available
                 every this many seconds. Can be a float to represent
                 fractions of a second.
             max_bucket_size: The maximum number of tokens that can be in the bucket.
-                This is used to prevent bursts of requests.
+                Must be at least 1. Used to prevent bursts of requests.
         """
         # Number of requests that we can make per second.
         self.requests_per_second = requests_per_second

{langchain_core-0.3.69 → langchain_core-0.3.70}/langchain_core/tools/structured.py

@@ -197,7 +197,14 @@ class StructuredTool(BaseTool):
             description_ = source_function.__doc__ or None
         if description_ is None and args_schema:
             if isinstance(args_schema, type) and is_basemodel_subclass(args_schema):
-                description_ = args_schema.__doc__ or None
+                description_ = args_schema.__doc__
+                if (
+                    description_
+                    and "A base class for creating Pydantic models" in description_
+                ):
+                    description_ = ""
+                elif not description_:
+                    description_ = None
             elif isinstance(args_schema, dict):
                 description_ = args_schema.get("description")
             else:

langchain_core-0.3.70/langchain_core/utils/json_schema.py

@@ -0,0 +1,122 @@
+"""Utilities for JSON Schema."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import TYPE_CHECKING, Any, Optional
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+def _retrieve_ref(path: str, schema: dict) -> dict:
+    components = path.split("/")
+    if components[0] != "#":
+        msg = (
+            "ref paths are expected to be URI fragments, meaning they should start "
+            "with #."
+        )
+        raise ValueError(msg)
+    out = schema
+    for component in components[1:]:
+        if component in out:
+            out = out[component]
+        elif component.isdigit():
+            index = int(component)
+            if (isinstance(out, list) and 0 <= index < len(out)) or (
+                isinstance(out, dict) and index in out
+            ):
+                out = out[index]
+            else:
+                msg = f"Reference '{path}' not found."
+                raise KeyError(msg)
+        else:
+            msg = f"Reference '{path}' not found."
+            raise KeyError(msg)
+    return deepcopy(out)
+
+
+def _dereference_refs_helper(
+    obj: Any,
+    full_schema: dict[str, Any],
+    processed_refs: Optional[set[str]],
+    skip_keys: Sequence[str],
+    shallow_refs: bool,  # noqa: FBT001
+) -> Any:
+    """Inline every pure {'$ref':...}.
+
+    But:
+    - if shallow_refs=True: only break cycles, do not inline nested refs
+    - if shallow_refs=False: deep-inline all nested refs
+
+    Also skip recursion under any key in skip_keys.
+    """
+    if processed_refs is None:
+        processed_refs = set()
+
+    # 1) Pure $ref node?
+    if isinstance(obj, dict) and set(obj.keys()) == {"$ref"}:
+        ref_path = obj["$ref"]
+        # cycle?
+        if ref_path in processed_refs:
+            return {}
+        processed_refs.add(ref_path)
+
+        # grab + copy the target
+        target = deepcopy(_retrieve_ref(ref_path, full_schema))
+
+        # deep inlining: recurse into everything
+        result = _dereference_refs_helper(
+            target, full_schema, processed_refs, skip_keys, shallow_refs
+        )
+
+        processed_refs.remove(ref_path)
+        return result
+
+    # 2) Not a pure-$ref: recurse, skipping any keys in skip_keys
+    if isinstance(obj, dict):
+        out: dict[str, Any] = {}
+        for k, v in obj.items():
+            if k in skip_keys:
+                # do not recurse under this key
+                out[k] = deepcopy(v)
+            elif isinstance(v, (dict, list)):
+                out[k] = _dereference_refs_helper(
+                    v, full_schema, processed_refs, skip_keys, shallow_refs
+                )
+            else:
+                out[k] = v
+        return out
+
+    if isinstance(obj, list):
+        return [
+            _dereference_refs_helper(
+                item, full_schema, processed_refs, skip_keys, shallow_refs
+            )
+            for item in obj
+        ]
+
+    return obj
+
+
+def dereference_refs(
+    schema_obj: dict,
+    *,
+    full_schema: Optional[dict] = None,
+    skip_keys: Optional[Sequence[str]] = None,
+) -> dict:
+    """Try to substitute $refs in JSON Schema.
+
+    Args:
+      schema_obj: The fragment to dereference.
+      full_schema: The complete schema (defaults to schema_obj).
+      skip_keys:
+        - If None (the default), we skip recursion under '$defs' *and* only
+            shallow-inline refs.
+        - If provided (even as an empty list), we will recurse under every key and
+            deep-inline all refs.
+    """
+    full = full_schema or schema_obj
+    keys_to_skip = list(skip_keys) if skip_keys is not None else ["$defs"]
+    shallow = skip_keys is None
+    return _dereference_refs_helper(schema_obj, full, None, keys_to_skip, shallow)

{langchain_core-0.3.69 → langchain_core-0.3.70}/langchain_core/utils/mustache.py

@@ -150,6 +150,11 @@ def parse_tag(template: str, l_del: str, r_del: str) -> tuple[tuple[str, str], s
         msg = f"unclosed tag at line {_CURRENT_LINE}"
         raise ChevronError(msg) from e
 
+    # Check for empty tags
+    if not tag.strip():
+        msg = f"empty tag at line {_CURRENT_LINE}"
+        raise ChevronError(msg)
+
     # Find the type meaning of the first character
     tag_type = tag_types.get(tag[0], "variable")
 

{langchain_core-0.3.69 → langchain_core-0.3.70}/langchain_core/vectorstores/utils.py

@@ -7,6 +7,7 @@ as they can change without notice.
 from __future__ import annotations
 
 import logging
+import warnings
 from typing import TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
@@ -46,6 +47,23 @@ def _cosine_similarity(x: Matrix, y: Matrix) -> np.ndarray:
 
     x = np.array(x)
     y = np.array(y)
+
+    # Check for NaN
+    if np.any(np.isnan(x)) or np.any(np.isnan(y)):
+        warnings.warn(
+            "NaN found in input arrays, unexpected return might follow",
+            category=RuntimeWarning,
+            stacklevel=2,
+        )
+
+    # Check for Inf
+    if np.any(np.isinf(x)) or np.any(np.isinf(y)):
+        warnings.warn(
+            "Inf found in input arrays, unexpected return might follow",
+            category=RuntimeWarning,
+            stacklevel=2,
+        )
+
     if x.shape[1] != y.shape[1]:
         msg = (
             f"Number of columns in X and Y must be the same. X has shape {x.shape} "

{langchain_core-0.3.69 → langchain_core-0.3.70}/langchain_core/version.py

@@ -1,3 +1,3 @@
 """langchain-core version information and utilities."""
 
-VERSION = "0.3.69"
+VERSION = "0.3.70"

{langchain_core-0.3.69 → langchain_core-0.3.70}/pyproject.toml

@@ -17,7 +17,7 @@ dependencies = [
     "pydantic>=2.7.4",
 ]
 name = "langchain-core"
-version = "0.3.69"
+version = "0.3.70"
 description = "Building applications with LLMs through composability"
 readme = "README.md"
 

{langchain_core-0.3.69 → langchain_core-0.3.70}/tests/unit_tests/fake/test_fake_chat_model.py

@@ -1,5 +1,6 @@
 """Tests for verifying that testing utility code works as expected."""
 
+import time
 from itertools import cycle
 from typing import Any, Optional, Union
 from uuid import UUID
@@ -9,10 +10,11 @@ from typing_extensions import override
 from langchain_core.callbacks.base import AsyncCallbackHandler
 from langchain_core.language_models import (
     FakeListChatModel,
+    FakeMessagesListChatModel,
     GenericFakeChatModel,
     ParrotFakeChatModel,
 )
-from langchain_core.messages import AIMessage, AIMessageChunk, BaseMessage
+from langchain_core.messages import AIMessage, AIMessageChunk, BaseMessage, HumanMessage
 from langchain_core.outputs import ChatGenerationChunk, GenerationChunk
 from tests.unit_tests.stubs import (
     _any_id_ai_message,
@@ -230,3 +232,18 @@ def test_fake_list_chat_model_batch() -> None:
         fake = FakeListChatModel(responses=["a", "b", "c"])
         resp = fake.batch(["1", "2", "3"])
         assert resp == expected
+
+
+def test_fake_messages_list_chat_model_sleep_delay() -> None:
+    sleep_time = 0.1
+    model = FakeMessagesListChatModel(
+        responses=[AIMessage(content="A"), AIMessage(content="B")],
+        sleep=sleep_time,
+    )
+    messages = [HumanMessage(content="C")]
+
+    start = time.time()
+    model.invoke(messages)
+    elapsed = time.time() - start
+
+    assert elapsed >= sleep_time