langchain-core 1.0.0a8__py3-none-any.whl → 1.0.0rc1__py3-none-any.whl

langchain_core/messages/block_translators/__init__.py

@@ -1,13 +1,13 @@
 """Derivations of standard content blocks from provider content.
 
-``AIMessage`` will first attempt to use a provider-specific translator if
-``model_provider`` is set in ``response_metadata`` on the message. Consequently, each
+`AIMessage` will first attempt to use a provider-specific translator if
+`model_provider` is set in `response_metadata` on the message. Consequently, each
 provider translator must handle all possible content response types from the provider,
 including text.
 
 If no provider is set, or if the provider does not have a registered translator,
-``AIMessage`` will fall back to best-effort parsing of the content into blocks using
-the implementation in ``BaseMessage``.
+`AIMessage` will fall back to best-effort parsing of the content into blocks using
+the implementation in `BaseMessage`.
 """
 
 from __future__ import annotations
@@ -23,15 +23,15 @@ if TYPE_CHECKING:
 PROVIDER_TRANSLATORS: dict[str, dict[str, Callable[..., list[types.ContentBlock]]]] = {}
 """Map model provider names to translator functions.
 
-The dictionary maps provider names (e.g. ``'openai'``, ``'anthropic'``) to another
+The dictionary maps provider names (e.g. `'openai'`, `'anthropic'`) to another
 dictionary with two keys:
-- ``'translate_content'``: Function to translate ``AIMessage`` content.
-- ``'translate_content_chunk'``: Function to translate ``AIMessageChunk`` content.
+- `'translate_content'`: Function to translate `AIMessage` content.
+- `'translate_content_chunk'`: Function to translate `AIMessageChunk` content.
 
-When calling `.content_blocks` on an ``AIMessage`` or ``AIMessageChunk``, if
-``model_provider`` is set in ``response_metadata``, the corresponding translator
+When calling `.content_blocks` on an `AIMessage` or `AIMessageChunk`, if
+`model_provider` is set in `response_metadata`, the corresponding translator
 functions will be used to parse the content into blocks. Otherwise, best-effort parsing
-in ``BaseMessage`` will be used.
+in `BaseMessage` will be used.
 """
 
 
@@ -43,9 +43,9 @@ def register_translator(
     """Register content translators for a provider in `PROVIDER_TRANSLATORS`.
 
     Args:
-        provider: The model provider name (e.g. ``'openai'``, ``'anthropic'``).
-        translate_content: Function to translate ``AIMessage`` content.
-        translate_content_chunk: Function to translate ``AIMessageChunk`` content.
+        provider: The model provider name (e.g. `'openai'`, `'anthropic'`).
+        translate_content: Function to translate `AIMessage` content.
+        translate_content_chunk: Function to translate `AIMessageChunk` content.
     """
     PROVIDER_TRANSLATORS[provider] = {
         "translate_content": translate_content,
@@ -62,9 +62,9 @@ def get_translator(
         provider: The model provider name.
 
     Returns:
-        Dictionary with ``'translate_content'`` and ``'translate_content_chunk'``
+        Dictionary with `'translate_content'` and `'translate_content_chunk'`
         functions, or None if no translator is registered for the provider. In such
-        case, best-effort parsing in ``BaseMessage`` will be used.
+        case, best-effort parsing in `BaseMessage` will be used.
     """
     return PROVIDER_TRANSLATORS.get(provider)
 
@@ -72,10 +72,10 @@ def get_translator(
 def _register_translators() -> None:
     """Register all translators in langchain-core.
 
-    A unit test ensures all modules in ``block_translators`` are represented here.
+    A unit test ensures all modules in `block_translators` are represented here.
 
     For translators implemented outside langchain-core, they can be registered by
-    calling ``register_translator`` from within the integration package.
+    calling `register_translator` from within the integration package.
     """
     from langchain_core.messages.block_translators.anthropic import (  # noqa: PLC0415
         _register_anthropic_translator,

langchain_core/messages/block_translators/anthropic.py

@@ -32,11 +32,11 @@ def _convert_to_v1_from_anthropic_input(
     """Convert Anthropic format blocks to v1 format.
 
     During the `.content_blocks` parsing process, we wrap blocks not recognized as a v1
-    block as a ``'non_standard'`` block with the original block stored in the ``value``
+    block as a `'non_standard'` block with the original block stored in the `value`
     field. This function attempts to unpack those blocks and convert any blocks that
     might be Anthropic format to v1 ContentBlocks.
 
-    If conversion fails, the block is left as a ``'non_standard'`` block.
+    If conversion fails, the block is left as a `'non_standard'` block.
 
     Args:
         content: List of content blocks to process.

langchain_core/messages/block_translators/bedrock_converse.py

@@ -36,11 +36,11 @@ def _convert_to_v1_from_converse_input(
     """Convert Bedrock Converse format blocks to v1 format.
 
     During the `.content_blocks` parsing process, we wrap blocks not recognized as a v1
-    block as a ``'non_standard'`` block with the original block stored in the ``value``
+    block as a `'non_standard'` block with the original block stored in the `value`
     field. This function attempts to unpack those blocks and convert any blocks that
     might be Converse format to v1 ContentBlocks.
 
-    If conversion fails, the block is left as a ``'non_standard'`` block.
+    If conversion fails, the block is left as a `'non_standard'` block.
 
     Args:
         content: List of content blocks to process.

langchain_core/messages/block_translators/google_genai.py

@@ -106,11 +106,11 @@ def _convert_to_v1_from_genai_input(
     `response_metadata`.
 
     During the `.content_blocks` parsing process, we wrap blocks not recognized as a v1
-    block as a ``'non_standard'`` block with the original block stored in the ``value``
+    block as a `'non_standard'` block with the original block stored in the `value`
     field. This function attempts to unpack those blocks and convert any blocks that
     might be GenAI format to v1 ContentBlocks.
 
-    If conversion fails, the block is left as a ``'non_standard'`` block.
+    If conversion fails, the block is left as a `'non_standard'` block.
 
     Args:
         content: List of content blocks to process.

langchain_core/messages/block_translators/groq.py

@@ -1,39 +1,135 @@
 """Derivations of standard content blocks from Groq content."""
 
-import warnings
+import json
+import re
+from typing import Any
 
 from langchain_core.messages import AIMessage, AIMessageChunk
 from langchain_core.messages import content as types
+from langchain_core.messages.base import _extract_reasoning_from_additional_kwargs
 
-WARNED = False
 
+def _populate_extras(
+    standard_block: types.ContentBlock, block: dict[str, Any], known_fields: set[str]
+) -> types.ContentBlock:
+    """Mutate a block, populating extras."""
+    if standard_block.get("type") == "non_standard":
+        return standard_block
 
-def translate_content(message: AIMessage) -> list[types.ContentBlock]:  # noqa: ARG001
-    """Derive standard content blocks from a message with Groq content."""
-    global WARNED  # noqa: PLW0603
-    if not WARNED:
-        warning_message = (
-            "Content block standardization is not yet fully supported for Groq."
+    for key, value in block.items():
+        if key not in known_fields:
+            if "extras" not in standard_block:
+                # Below type-ignores are because mypy thinks a non-standard block can
+                # get here, although we exclude them above.
+                standard_block["extras"] = {}  # type: ignore[typeddict-unknown-key]
+            standard_block["extras"][key] = value  # type: ignore[typeddict-item]
+
+    return standard_block
+
+
+def _parse_code_json(s: str) -> dict:
+    """Extract Python code from Groq built-in tool content.
+
+    Extracts the value of the 'code' field from a string of the form:
+    {"code": some_arbitrary_text_with_unescaped_quotes}
+
+    As Groq may not escape quotes in the executed tools, e.g.:
+    ```
+    '{"code": "import math; print("The square root of 101 is: "); print(math.sqrt(101))"}'
+    ```
+    """  # noqa: E501
+    m = re.fullmatch(r'\s*\{\s*"code"\s*:\s*"(.*)"\s*\}\s*', s, flags=re.DOTALL)
+    if not m:
+        msg = (
+            "Could not extract Python code from Groq tool arguments. "
+            "Expected a JSON object with a 'code' field."
         )
-        warnings.warn(warning_message, stacklevel=2)
-        WARNED = True
-    raise NotImplementedError
+        raise ValueError(msg)
+    return {"code": m.group(1)}
+
+
+def _convert_to_v1_from_groq(message: AIMessage) -> list[types.ContentBlock]:
+    """Convert groq message content to v1 format."""
+    content_blocks: list[types.ContentBlock] = []
 
+    if reasoning_block := _extract_reasoning_from_additional_kwargs(message):
+        content_blocks.append(reasoning_block)
 
-def translate_content_chunk(message: AIMessageChunk) -> list[types.ContentBlock]:  # noqa: ARG001
-    """Derive standard content blocks from a message chunk with Groq content."""
-    global WARNED  # noqa: PLW0603
-    if not WARNED:
-        warning_message = (
-            "Content block standardization is not yet fully supported for Groq."
+    if executed_tools := message.additional_kwargs.get("executed_tools"):
+        for idx, executed_tool in enumerate(executed_tools):
+            args: dict[str, Any] | None = None
+            if arguments := executed_tool.get("arguments"):
+                try:
+                    args = json.loads(arguments)
+                except json.JSONDecodeError:
+                    if executed_tool.get("type") == "python":
+                        try:
+                            args = _parse_code_json(arguments)
+                        except ValueError:
+                            continue
+                    elif (
+                        executed_tool.get("type") == "function"
+                        and executed_tool.get("name") == "python"
+                    ):
+                        # GPT-OSS
+                        args = {"code": arguments}
+                    else:
+                        continue
+            if isinstance(args, dict):
+                name = ""
+                if executed_tool.get("type") == "search":
+                    name = "web_search"
+                elif executed_tool.get("type") == "python" or (
+                    executed_tool.get("type") == "function"
+                    and executed_tool.get("name") == "python"
+                ):
+                    name = "code_interpreter"
+                server_tool_call: types.ServerToolCall = {
+                    "type": "server_tool_call",
+                    "name": name,
+                    "id": str(idx),
+                    "args": args,
+                }
+                content_blocks.append(server_tool_call)
+            if tool_output := executed_tool.get("output"):
+                tool_result: types.ServerToolResult = {
+                    "type": "server_tool_result",
+                    "tool_call_id": str(idx),
+                    "output": tool_output,
+                    "status": "success",
+                }
+                known_fields = {"type", "arguments", "index", "output"}
+                _populate_extras(tool_result, executed_tool, known_fields)
+                content_blocks.append(tool_result)
+
+    if isinstance(message.content, str) and message.content:
+        content_blocks.append({"type": "text", "text": message.content})
+
+    for tool_call in message.tool_calls:
+        content_blocks.append(  # noqa: PERF401
+            {
+                "type": "tool_call",
+                "name": tool_call["name"],
+                "args": tool_call["args"],
+                "id": tool_call.get("id"),
+            }
         )
-        warnings.warn(warning_message, stacklevel=2)
-        WARNED = True
-    raise NotImplementedError
+
+    return content_blocks
+
+
+def translate_content(message: AIMessage) -> list[types.ContentBlock]:
+    """Derive standard content blocks from a message with groq content."""
+    return _convert_to_v1_from_groq(message)
+
+
+def translate_content_chunk(message: AIMessageChunk) -> list[types.ContentBlock]:
+    """Derive standard content blocks from a message chunk with groq content."""
+    return _convert_to_v1_from_groq(message)
 
 
 def _register_groq_translator() -> None:
-    """Register the Groq translator with the central registry.
+    """Register the groq translator with the central registry.
 
     Run automatically when the module is imported.
     """

langchain_core/messages/block_translators/langchain_v0.py

@@ -11,11 +11,11 @@ def _convert_v0_multimodal_input_to_v1(
     """Convert v0 multimodal blocks to v1 format.
 
     During the `.content_blocks` parsing process, we wrap blocks not recognized as a v1
-    block as a ``'non_standard'`` block with the original block stored in the ``value``
+    block as a `'non_standard'` block with the original block stored in the `value`
     field. This function attempts to unpack those blocks and convert any v0 format
     blocks to v1 format.
 
-    If conversion fails, the block is left as a ``'non_standard'`` block.
+    If conversion fails, the block is left as a `'non_standard'` block.
 
     Args:
         content: List of content blocks to process.

langchain_core/messages/block_translators/openai.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
 
 
 def convert_to_openai_image_block(block: dict[str, Any]) -> dict:
-    """Convert ``ImageContentBlock`` to format expected by OpenAI Chat Completions."""
+    """Convert `ImageContentBlock` to format expected by OpenAI Chat Completions."""
     if "url" in block:
         return {
             "type": "image_url",
@@ -156,11 +156,11 @@ def _convert_to_v1_from_chat_completions_input(
     """Convert OpenAI Chat Completions format blocks to v1 format.
 
     During the `.content_blocks` parsing process, we wrap blocks not recognized as a v1
-    block as a ``'non_standard'`` block with the original block stored in the ``value``
+    block as a `'non_standard'` block with the original block stored in the `value`
     field. This function attempts to unpack those blocks and convert any blocks that
     might be OpenAI format to v1 ContentBlocks.
 
-    If conversion fails, the block is left as a ``'non_standard'`` block.
+    If conversion fails, the block is left as a `'non_standard'` block.
 
     Args:
         content: List of content blocks to process.
@@ -263,7 +263,7 @@ _FUNCTION_CALL_IDS_MAP_KEY = "__openai_function_call_ids__"
 
 
 def _convert_from_v03_ai_message(message: AIMessage) -> AIMessage:
-    """Convert v0 AIMessage into ``output_version="responses/v1"`` format."""
+    """Convert v0 AIMessage into `output_version="responses/v1"` format."""
     from langchain_core.messages import AIMessageChunk  # noqa: PLC0415
 
     # Only update ChatOpenAI v0.3 AIMessages

langchain_core/messages/chat.py

@@ -31,7 +31,7 @@ class ChatMessageChunk(ChatMessage, BaseMessageChunk):
     type: Literal["ChatMessageChunk"] = "ChatMessageChunk"  # type: ignore[assignment]
     """The type of the message (used during serialization).
 
-    Defaults to ``'ChatMessageChunk'``.
+    Defaults to `'ChatMessageChunk'`.
 
     """