langchain-core 1.0.7__py3-none-any.whl → 1.2.1__py3-none-any.whl

langchain_core/messages/ai.py

@@ -51,22 +51,22 @@ class InputTokenDetails(TypedDict, total=False):
     May also hold extra provider-specific keys.
 
     !!! version-added "Added in `langchain-core` 0.3.9"
-
     """
 
     audio: int
     """Audio input tokens."""
+
     cache_creation: int
     """Input tokens that were cached and there was a cache miss.
 
     Since there was a cache miss, the cache was created from these tokens.
     """
+
     cache_read: int
     """Input tokens that were cached and there was a cache hit.
 
     Since there was a cache hit, the tokens were read from the cache. More precisely,
     the model state given these tokens was read from the cache.
-
     """
 
 
@@ -91,12 +91,12 @@ class OutputTokenDetails(TypedDict, total=False):
 
     audio: int
     """Audio output tokens."""
+
     reasoning: int
     """Reasoning output tokens.
 
     Tokens generated by the model in a chain of thought process (i.e. by OpenAI's o1
     models) that are not returned as part of model output.
-
     """
 
 
@@ -124,9 +124,11 @@ class UsageMetadata(TypedDict):
         ```
 
     !!! warning "Behavior changed in `langchain-core` 0.3.9"
+
         Added `input_token_details` and `output_token_details`.
 
     !!! note "LangSmith SDK"
+
         The LangSmith SDK also has a `UsageMetadata` class. While the two share fields,
         LangSmith's `UsageMetadata` has additional fields to capture cost information
         used by the LangSmith platform.
@@ -134,15 +136,19 @@ class UsageMetadata(TypedDict):
 
     input_tokens: int
     """Count of input (or prompt) tokens. Sum of all input token types."""
+
     output_tokens: int
     """Count of output (or completion) tokens. Sum of all output token types."""
+
     total_tokens: int
     """Total token count. Sum of `input_tokens` + `output_tokens`."""
+
     input_token_details: NotRequired[InputTokenDetails]
     """Breakdown of input token counts.
 
     Does *not* need to sum to full input token count. Does *not* need to have all keys.
     """
+
     output_token_details: NotRequired[OutputTokenDetails]
     """Breakdown of output token counts.
 
@@ -162,8 +168,10 @@ class AIMessage(BaseMessage):
 
     tool_calls: list[ToolCall] = []
     """If present, tool calls associated with the message."""
+
     invalid_tool_calls: list[InvalidToolCall] = []
     """If present, tool calls with parsing errors associated with the message."""
+
     usage_metadata: UsageMetadata | None = None
     """If present, usage metadata for a message, such as token counts.
 
@@ -555,7 +563,7 @@ class AIMessageChunk(AIMessage, BaseMessageChunk):
 
     @model_validator(mode="after")
     def init_server_tool_calls(self) -> Self:
-        """Parse `server_tool_call_chunks`."""
+        """Parse `server_tool_call_chunks` from [`ServerToolCallChunk`][langchain.messages.ServerToolCallChunk] objects."""  # noqa: E501
         if (
             self.chunk_position == "last"
             and self.response_metadata.get("output_version") == "v1"

langchain_core/messages/base.py

@@ -391,12 +391,12 @@ class BaseMessageChunk(BaseMessage):
         Raises:
             TypeError: If the other object is not a message chunk.
 
-        For example,
-
-        `AIMessageChunk(content="Hello") + AIMessageChunk(content=" World")`
-
-        will give `AIMessageChunk(content="Hello World")`
-
+        Example:
+            ```txt
+              AIMessageChunk(content="Hello", ...)
+            + AIMessageChunk(content=" World", ...)
+            = AIMessageChunk(content="Hello World", ...)
+            ```
         """
         if isinstance(other, BaseMessageChunk):
             # If both are (subclasses of) BaseMessageChunk,

langchain_core/messages/block_translators/anthropic.py

@@ -245,11 +245,20 @@ def _convert_to_v1_from_anthropic(message: AIMessage) -> list[types.ContentBlock
                     and message.chunk_position != "last"
                 ):
                     # Isolated chunk
-                    tool_call_chunk: types.ToolCallChunk = (
-                        message.tool_call_chunks[0].copy()  # type: ignore[assignment]
+                    chunk = message.tool_call_chunks[0]
+
+                    tool_call_chunk = types.ToolCallChunk(
+                        name=chunk.get("name"),
+                        id=chunk.get("id"),
+                        args=chunk.get("args"),
+                        type="tool_call_chunk",
                     )
-                    if "type" not in tool_call_chunk:
-                        tool_call_chunk["type"] = "tool_call_chunk"
+                    if "caller" in block:
+                        tool_call_chunk["extras"] = {"caller": block["caller"]}
+
+                    index = chunk.get("index")
+                    if index is not None:
+                        tool_call_chunk["index"] = index
                     yield tool_call_chunk
                 else:
                     tool_call_block: types.ToolCall | None = None
@@ -282,17 +291,27 @@ def _convert_to_v1_from_anthropic(message: AIMessage) -> list[types.ContentBlock
                         }
                     if "index" in block:
                         tool_call_block["index"] = block["index"]
+                    if "caller" in block:
+                        if "extras" not in tool_call_block:
+                            tool_call_block["extras"] = {}
+                        tool_call_block["extras"]["caller"] = block["caller"]
+
                     yield tool_call_block
 
             elif block_type == "input_json_delta" and isinstance(
                 message, AIMessageChunk
             ):
                 if len(message.tool_call_chunks) == 1:
-                    tool_call_chunk = (
-                        message.tool_call_chunks[0].copy()  # type: ignore[assignment]
+                    chunk = message.tool_call_chunks[0]
+                    tool_call_chunk = types.ToolCallChunk(
+                        name=chunk.get("name"),
+                        id=chunk.get("id"),
+                        args=chunk.get("args"),
+                        type="tool_call_chunk",
                     )
-                    if "type" not in tool_call_chunk:
-                        tool_call_chunk["type"] = "tool_call_chunk"
+                    index = chunk.get("index")
+                    if index is not None:
+                        tool_call_chunk["index"] = index
                     yield tool_call_chunk
 
                 else:

langchain_core/messages/block_translators/bedrock_converse.py

@@ -209,11 +209,16 @@ def _convert_to_v1_from_converse(message: AIMessage) -> list[types.ContentBlock]
                     and message.chunk_position != "last"
                 ):
                     # Isolated chunk
-                    tool_call_chunk: types.ToolCallChunk = (
-                        message.tool_call_chunks[0].copy()  # type: ignore[assignment]
+                    chunk = message.tool_call_chunks[0]
+                    tool_call_chunk = types.ToolCallChunk(
+                        name=chunk.get("name"),
+                        id=chunk.get("id"),
+                        args=chunk.get("args"),
+                        type="tool_call_chunk",
                     )
-                    if "type" not in tool_call_chunk:
-                        tool_call_chunk["type"] = "tool_call_chunk"
+                    index = chunk.get("index")
+                    if index is not None:
+                        tool_call_chunk["index"] = index
                     yield tool_call_chunk
                 else:
                     tool_call_block: types.ToolCall | None = None
@@ -253,11 +258,16 @@ def _convert_to_v1_from_converse(message: AIMessage) -> list[types.ContentBlock]
                 and isinstance(message, AIMessageChunk)
                 and len(message.tool_call_chunks) == 1
             ):
-                tool_call_chunk = (
-                    message.tool_call_chunks[0].copy()  # type: ignore[assignment]
+                chunk = message.tool_call_chunks[0]
+                tool_call_chunk = types.ToolCallChunk(
+                    name=chunk.get("name"),
+                    id=chunk.get("id"),
+                    args=chunk.get("args"),
+                    type="tool_call_chunk",
                 )
-                if "type" not in tool_call_chunk:
-                    tool_call_chunk["type"] = "tool_call_chunk"
+                index = chunk.get("index")
+                if index is not None:
+                    tool_call_chunk["index"] = index
                 yield tool_call_chunk
 
             else:

langchain_core/messages/block_translators/google_genai.py

@@ -76,21 +76,36 @@ def translate_grounding_metadata_to_citations(
         for chunk_index in chunk_indices:
             if chunk_index < len(grounding_chunks):
                 chunk = grounding_chunks[chunk_index]
-                web_info = chunk.get("web", {})
+
+                # Handle web and maps grounding
+                web_info = chunk.get("web") or {}
+                maps_info = chunk.get("maps") or {}
+
+                # Extract citation info depending on source
+                url = maps_info.get("uri") or web_info.get("uri")
+                title = maps_info.get("title") or web_info.get("title")
+
+                # Note: confidence_scores is a legacy field from Gemini 2.0 and earlier
+                # that indicated confidence (0.0-1.0) for each grounding chunk.
+                #
+                # In Gemini 2.5+, this field is always None/empty and should be ignored.
+                extras_metadata = {
+                    "web_search_queries": web_search_queries,
+                    "grounding_chunk_index": chunk_index,
+                    "confidence_scores": support.get("confidence_scores") or [],
+                }
+
+                # Add maps-specific metadata if present
+                if maps_info.get("placeId"):
+                    extras_metadata["place_id"] = maps_info["placeId"]
 
                 citation = create_citation(
-                    url=web_info.get("uri"),
-                    title=web_info.get("title"),
+                    url=url,
+                    title=title,
                     start_index=start_index,
                     end_index=end_index,
                     cited_text=cited_text,
-                    extras={
-                        "google_ai_metadata": {
-                            "web_search_queries": web_search_queries,
-                            "grounding_chunk_index": chunk_index,
-                            "confidence_scores": support.get("confidence_scores", []),
-                        }
-                    },
+                    google_ai_metadata=extras_metadata,
                 )
                 citations.append(citation)
 

langchain_core/messages/content.py

@@ -654,7 +654,7 @@ class PlainTextContentBlock(TypedDict):
 
     !!! note
         Title and context are optional fields that may be passed to the model. See
-        Anthropic [example](https://docs.claude.com/en/docs/build-with-claude/citations#citable-vs-non-citable-content).
+        Anthropic [example](https://platform.claude.com/docs/en/build-with-claude/citations#citable-vs-non-citable-content).
 
     !!! note "Factory function"
         `create_plaintext_block` may also be used as a factory to create a

langchain_core/messages/tool.py

@@ -29,38 +29,39 @@ class ToolMessage(BaseMessage, ToolOutputMixin):
     `ToolMessage` objects contain the result of a tool invocation. Typically, the result
     is encoded inside the `content` field.
 
-    Example: A `ToolMessage` representing a result of `42` from a tool call with id
+    `tool_call_id` is used to associate the tool call request with the tool call
+    response. Useful in situations where a chat model is able to request multiple tool
+    calls in parallel.
 
-    ```python
-    from langchain_core.messages import ToolMessage
-
-    ToolMessage(content="42", tool_call_id="call_Jja7J89XsjrOLA5r!MEOW!SL")
-    ```
+    Example:
+        A `ToolMessage` representing a result of `42` from a tool call with id
 
-    Example: A `ToolMessage` where only part of the tool output is sent to the model
-    and the full output is passed in to artifact.
+        ```python
+        from langchain_core.messages import ToolMessage
 
-    ```python
-    from langchain_core.messages import ToolMessage
-
-    tool_output = {
-        "stdout": "From the graph we can see that the correlation between "
-        "x and y is ...",
-        "stderr": None,
-        "artifacts": {"type": "image", "base64_data": "/9j/4gIcSU..."},
-    }
-
-    ToolMessage(
-        content=tool_output["stdout"],
-        artifact=tool_output,
-        tool_call_id="call_Jja7J89XsjrOLA5r!MEOW!SL",
-    )
-    ```
+        ToolMessage(content="42", tool_call_id="call_Jja7J89XsjrOLA5r!MEOW!SL")
+        ```
 
-    The `tool_call_id` field is used to associate the tool call request with the
-    tool call response. Useful in situations where a chat model is able
-    to request multiple tool calls in parallel.
+    Example:
+        A `ToolMessage` where only part of the tool output is sent to the model
+        and the full output is passed in to artifact.
 
+        ```python
+        from langchain_core.messages import ToolMessage
+
+        tool_output = {
+            "stdout": "From the graph we can see that the correlation between "
+            "x and y is ...",
+            "stderr": None,
+            "artifacts": {"type": "image", "base64_data": "/9j/4gIcSU..."},
+        }
+
+        ToolMessage(
+            content=tool_output["stdout"],
+            artifact=tool_output,
+            tool_call_id="call_Jja7J89XsjrOLA5r!MEOW!SL",
+        )
+        ```
     """
 
     tool_call_id: str

langchain_core/messages/utils.py

@@ -15,12 +15,16 @@ import json
 import logging
 import math
 from collections.abc import Callable, Iterable, Sequence
-from functools import partial
+from functools import partial, wraps
 from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
+    Concatenate,
     Literal,
+    ParamSpec,
+    Protocol,
+    TypeVar,
     cast,
     overload,
 )
@@ -384,33 +388,54 @@ def convert_to_messages(
     return [_convert_to_message(m) for m in messages]
 
 
-def _runnable_support(func: Callable) -> Callable:
-    @overload
-    def wrapped(
-        messages: None = None, **kwargs: Any
-    ) -> Runnable[Sequence[MessageLikeRepresentation], list[BaseMessage]]: ...
+_P = ParamSpec("_P")
+_R_co = TypeVar("_R_co", covariant=True)
 
+
+class _RunnableSupportCallable(Protocol[_P, _R_co]):
     @overload
-    def wrapped(
-        messages: Sequence[MessageLikeRepresentation], **kwargs: Any
-    ) -> list[BaseMessage]: ...
+    def __call__(
+        self,
+        messages: None = None,
+        *args: _P.args,
+        **kwargs: _P.kwargs,
+    ) -> Runnable[Sequence[MessageLikeRepresentation], _R_co]: ...
 
+    @overload
+    def __call__(
+        self,
+        messages: Sequence[MessageLikeRepresentation] | PromptValue,
+        *args: _P.args,
+        **kwargs: _P.kwargs,
+    ) -> _R_co: ...
+
+    def __call__(
+        self,
+        messages: Sequence[MessageLikeRepresentation] | PromptValue | None = None,
+        *args: _P.args,
+        **kwargs: _P.kwargs,
+    ) -> _R_co | Runnable[Sequence[MessageLikeRepresentation], _R_co]: ...
+
+
+def _runnable_support(
+    func: Callable[
+        Concatenate[Sequence[MessageLikeRepresentation] | PromptValue, _P], _R_co
+    ],
+) -> _RunnableSupportCallable[_P, _R_co]:
+    @wraps(func)
     def wrapped(
-        messages: Sequence[MessageLikeRepresentation] | None = None,
-        **kwargs: Any,
-    ) -> (
-        list[BaseMessage]
-        | Runnable[Sequence[MessageLikeRepresentation], list[BaseMessage]]
-    ):
+        messages: Sequence[MessageLikeRepresentation] | PromptValue | None = None,
+        *args: _P.args,
+        **kwargs: _P.kwargs,
+    ) -> _R_co | Runnable[Sequence[MessageLikeRepresentation], _R_co]:
         # Import locally to prevent circular import.
         from langchain_core.runnables.base import RunnableLambda  # noqa: PLC0415
 
         if messages is not None:
-            return func(messages, **kwargs)
+            return func(messages, *args, **kwargs)
         return RunnableLambda(partial(func, **kwargs), name=func.__name__)
 
-    wrapped.__doc__ = func.__doc__
-    return wrapped
+    return cast("_RunnableSupportCallable[_P, _R_co]", wrapped)
 
 
 @_runnable_support
@@ -738,8 +763,10 @@ def trim_messages(
             Set to `len` to count the number of **messages** in the chat history.
 
             !!! note
+
                 Use `count_tokens_approximately` to get fast, approximate token
                 counts.
+
                 This is recommended for using `trim_messages` on the hot path, where
                 exact token counting is not necessary.
 

langchain_core/output_parsers/openai_tools.py

@@ -47,22 +47,24 @@ def parse_tool_call(
     """
     if "function" not in raw_tool_call:
         return None
+
+    arguments = raw_tool_call["function"]["arguments"]
+
     if partial:
         try:
-            function_args = parse_partial_json(
-                raw_tool_call["function"]["arguments"], strict=strict
-            )
+            function_args = parse_partial_json(arguments, strict=strict)
         except (JSONDecodeError, TypeError):  # None args raise TypeError
             return None
+    # Handle None or empty string arguments for parameter-less tools
+    elif not arguments:
+        function_args = {}
     else:
         try:
-            function_args = json.loads(
-                raw_tool_call["function"]["arguments"], strict=strict
-            )
+            function_args = json.loads(arguments, strict=strict)
         except JSONDecodeError as e:
             msg = (
                 f"Function {raw_tool_call['function']['name']} arguments:\n\n"
-                f"{raw_tool_call['function']['arguments']}\n\nare not valid JSON. "
+                f"{arguments}\n\nare not valid JSON. "
                 f"Received JSONDecodeError {e}"
             )
             raise OutputParserException(msg) from e

langchain_core/output_parsers/pydantic.py

@@ -37,7 +37,7 @@ class PydanticOutputParser(JsonOutputParser, Generic[TBaseModel]):
     def _parser_exception(
         self, e: Exception, json_object: dict
     ) -> OutputParserException:
-        json_string = json.dumps(json_object)
+        json_string = json.dumps(json_object, ensure_ascii=False)
         name = self.pydantic_object.__name__
         msg = f"Failed to parse {name} from completion {json_string}. Got: {e}"
         return OutputParserException(msg, llm_output=json_string)

langchain_core/output_parsers/string.py

@@ -6,7 +6,33 @@ from langchain_core.output_parsers.transform import BaseTransformOutputParser
 
 
 class StrOutputParser(BaseTransformOutputParser[str]):
-    """OutputParser that parses `LLMResult` into the top likely string."""
+    """Extract text content from model outputs as a string.
+
+    Converts model outputs (such as `AIMessage` or `AIMessageChunk` objects) into plain
+    text strings. It's the simplest output parser and is useful when you need string
+    responses for downstream processing, display, or storage.
+
+    Supports streaming, yielding text chunks as they're generated by the model.
+
+    Example:
+        ```python
+        from langchain_core.output_parsers import StrOutputParser
+        from langchain_openai import ChatOpenAI
+
+        model = ChatOpenAI(model="gpt-4o")
+        parser = StrOutputParser()
+
+        # Get string output from a model
+        message = model.invoke("Tell me a joke")
+        result = parser.invoke(message)
+        print(result)  # plain string
+
+        # With streaming - use transform() to process a stream
+        stream = model.stream("Tell me a story")
+        for chunk in parser.transform(stream):
+            print(chunk, end="", flush=True)
+        ```
+    """
 
     @classmethod
     def is_lc_serializable(cls) -> bool:

langchain_core/prompts/chat.py

@@ -903,23 +903,28 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
                 5. A string which is shorthand for `("human", template)`; e.g.,
                     `"{user_input}"`
             template_format: Format of the template.
-            input_variables: A list of the names of the variables whose values are
-                required as inputs to the prompt.
-            optional_variables: A list of the names of the variables for placeholder
-                or MessagePlaceholder that are optional.
-
-                These variables are auto inferred from the prompt and user need not
-                provide them.
-            partial_variables: A dictionary of the partial variables the prompt
-                template carries.
-
-                Partial variables populate the template so that you don't need to pass
-                them in every time you call the prompt.
-            validate_template: Whether to validate the template.
-            input_types: A dictionary of the types of the variables the prompt template
-                expects.
-
-                If not provided, all variables are assumed to be strings.
+            **kwargs: Additional keyword arguments passed to `BasePromptTemplate`,
+                including (but not limited to):
+
+                - `input_variables`: A list of the names of the variables whose values
+                    are required as inputs to the prompt.
+                - `optional_variables`: A list of the names of the variables for
+                    placeholder or `MessagePlaceholder` that are optional.
+
+                    These variables are auto inferred from the prompt and user need not
+                    provide them.
+
+                - `partial_variables`: A dictionary of the partial variables the prompt
+                    template carries.
+
+                    Partial variables populate the template so that you don't need to
+                    pass them in every time you call the prompt.
+
+                - `validate_template`: Whether to validate the template.
+                - `input_types`: A dictionary of the types of the variables the prompt
+                    template expects.
+
+                    If not provided, all variables are assumed to be strings.
 
         Examples:
             Instantiation from a list of message templates:

langchain_core/prompts/string.py

@@ -20,65 +20,8 @@ if TYPE_CHECKING:
 
 try:
     from jinja2 import meta
-    from jinja2.exceptions import SecurityError
     from jinja2.sandbox import SandboxedEnvironment
 
-    class _RestrictedSandboxedEnvironment(SandboxedEnvironment):
-        """A more restrictive Jinja2 sandbox that blocks all attribute/method access.
-
-        This sandbox only allows simple variable lookups, no attribute or method access.
-        This prevents template injection attacks via methods like parse_raw().
-        """
-
-        def is_safe_attribute(self, _obj: Any, _attr: str, _value: Any) -> bool:
-            """Block ALL attribute access for security.
-
-            Only allow accessing variables directly from the context dict,
-            no attribute access on those objects.
-
-            Args:
-                _obj: The object being accessed (unused, always blocked).
-                _attr: The attribute name (unused, always blocked).
-                _value: The attribute value (unused, always blocked).
-
-            Returns:
-                False - all attribute access is blocked.
-            """
-            # Block all attribute access
-            return False
-
-        def is_safe_callable(self, _obj: Any) -> bool:
-            """Block all method calls for security.
-
-            Args:
-                _obj: The object being checked (unused, always blocked).
-
-            Returns:
-                False - all callables are blocked.
-            """
-            return False
-
-        def getattr(self, obj: Any, attribute: str) -> Any:
-            """Override getattr to block all attribute access.
-
-            Args:
-                obj: The object.
-                attribute: The attribute name.
-
-            Returns:
-                Never returns.
-
-            Raises:
-                SecurityError: Always, to block attribute access.
-            """
-            msg = (
-                f"Access to attributes is not allowed in templates. "
-                f"Attempted to access '{attribute}' on {type(obj).__name__}. "
-                f"Use only simple variable names like {{{{variable}}}} "
-                f"without dots or methods."
-            )
-            raise SecurityError(msg)
-
     _HAS_JINJA2 = True
 except ImportError:
     _HAS_JINJA2 = False
@@ -121,7 +64,7 @@ def jinja2_formatter(template: str, /, **kwargs: Any) -> str:
     # Use a restricted sandbox that blocks ALL attribute/method access
     # Only simple variable lookups like {{variable}} are allowed
     # Attribute access like {{variable.attr}} or {{variable.method()}} is blocked
-    return _RestrictedSandboxedEnvironment().from_string(template).render(**kwargs)
+    return SandboxedEnvironment().from_string(template).render(**kwargs)
 
 
 def validate_jinja2(template: str, input_variables: list[str]) -> None:
@@ -156,7 +99,7 @@ def _get_jinja2_variables_from_template(template: str) -> set[str]:
             "Please install it with `pip install jinja2`."
         )
         raise ImportError(msg)
-    env = _RestrictedSandboxedEnvironment()
+    env = SandboxedEnvironment()
     ast = env.parse(template)
     return meta.find_undeclared_variables(ast)
 

langchain_core/prompts/structured.py

@@ -49,7 +49,13 @@ class StructuredPrompt(ChatPromptTemplate):
             structured_output_kwargs: additional kwargs for structured output.
             template_format: template format for the prompt.
         """
-        schema_ = schema_ or kwargs.pop("schema")
+        schema_ = schema_ or kwargs.pop("schema", None)
+        if not schema_:
+            err_msg = (
+                "Must pass in a non-empty structured output schema. Received: "
+                f"{schema_}"
+            )
+            raise ValueError(err_msg)
         structured_output_kwargs = structured_output_kwargs or {}
         for k in set(kwargs).difference(get_pydantic_field_names(self.__class__)):
             structured_output_kwargs[k] = kwargs.pop(k)