langchain-core 1.0.0a3__tar.gz → 1.0.0a4__tar.gz

{langchain_core-1.0.0a3 → langchain_core-1.0.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-core
-Version: 1.0.0a3
+Version: 1.0.0a4
 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-1.0.0a3 → langchain_core-1.0.0a4}/langchain_core/language_models/chat_models.py

@@ -48,7 +48,6 @@ from langchain_core.messages import (
     message_chunk_to_message,
 )
 from langchain_core.messages.block_translators.openai import (
-    convert_to_openai_data_block,
     convert_to_openai_image_block,
 )
 from langchain_core.output_parsers.openai_tools import (
@@ -149,16 +148,18 @@ def _format_for_tracing(messages: list[BaseMessage]) -> list[BaseMessage]:
                         block.get("type") == "file"
                         and is_data_content_block(block)  # v0 (image/audio/file) or v1
                         and "base64" in block
-                        # Narrows to old Base64ContentBlock or new FileContentBlock
+                        # Backward compat: convert v1 base64 blocks to v0
                     ):
                         if message_to_trace is message:
                             # Shallow copy
                             message_to_trace = message.model_copy()
                             message_to_trace.content = list(message_to_trace.content)
 
-                        message_to_trace.content[idx] = convert_to_openai_data_block(  # type: ignore[index]
-                            block
-                        )
+                        message_to_trace.content[idx] = {  # type: ignore[index]
+                            **{k: v for k, v in block.items() if k != "base64"},
+                            "data": block["base64"],
+                            "source_type": "base64",
+                        }
                     elif len(block) == 1 and "type" not in block:
                         # Tracing assumes all content blocks have a "type" key. Here
                         # we add this key if it is missing, and there's an obvious

{langchain_core-1.0.0a3 → langchain_core-1.0.0a4}/langchain_core/messages/base.py

@@ -184,6 +184,9 @@ class BaseMessage(Serializable):
         from langchain_core.messages.block_translators.anthropic import (  # noqa: PLC0415
             _convert_to_v1_from_anthropic_input,
         )
+        from langchain_core.messages.block_translators.bedrock_converse import (  # noqa: PLC0415
+            _convert_to_v1_from_converse_input,
+        )
         from langchain_core.messages.block_translators.langchain_v0 import (  # noqa: PLC0415
             _convert_v0_multimodal_input_to_v1,
         )
@@ -214,6 +217,7 @@ class BaseMessage(Serializable):
             _convert_v0_multimodal_input_to_v1,
             _convert_to_v1_from_chat_completions_input,
             _convert_to_v1_from_anthropic_input,
+            _convert_to_v1_from_converse_input,
         ]:
             blocks = parsing_step(blocks)
         return blocks

{langchain_core-1.0.0a3 → langchain_core-1.0.0a4}/langchain_core/messages/block_translators/anthropic.py

@@ -2,7 +2,7 @@
 
 import json
 from collections.abc import Iterable
-from typing import Any, Optional, cast
+from typing import Any, Optional, Union, cast
 
 from langchain_core.messages import AIMessage, AIMessageChunk
 from langchain_core.messages import content as types
@@ -17,7 +17,7 @@ def _populate_extras(
 
     for key, value in block.items():
         if key not in known_fields:
-            if "extras" not in block:
+            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]
@@ -186,10 +186,12 @@ def _convert_citation_to_v1(citation: dict[str, Any]) -> types.Annotation:
 def _convert_to_v1_from_anthropic(message: AIMessage) -> list[types.ContentBlock]:
     """Convert Anthropic message content to v1 format."""
     if isinstance(message.content, str):
-        message.content = [{"type": "text", "text": message.content}]
+        content: list[Union[str, dict]] = [{"type": "text", "text": message.content}]
+    else:
+        content = message.content
 
     def _iter_blocks() -> Iterable[types.ContentBlock]:
-        for block in message.content:
+        for block in content:
             if not isinstance(block, dict):
                 continue
             block_type = block.get("type")
@@ -429,12 +431,12 @@ def _convert_to_v1_from_anthropic(message: AIMessage) -> list[types.ContentBlock
 
 
 def translate_content(message: AIMessage) -> list[types.ContentBlock]:
-    """Derive standard content blocks from a message with OpenAI content."""
+    """Derive standard content blocks from a message with Anthropic content."""
     return _convert_to_v1_from_anthropic(message)
 
 
 def translate_content_chunk(message: AIMessageChunk) -> list[types.ContentBlock]:
-    """Derive standard content blocks from a message chunk with OpenAI content."""
+    """Derive standard content blocks from a message chunk with Anthropic content."""
     return _convert_to_v1_from_anthropic(message)
 
 

langchain_core-1.0.0a4/langchain_core/messages/block_translators/bedrock.py

@@ -0,0 +1,94 @@
+"""Derivations of standard content blocks from Bedrock content."""
+
+from langchain_core.messages import AIMessage, AIMessageChunk
+from langchain_core.messages import content as types
+from langchain_core.messages.block_translators.anthropic import (
+    _convert_to_v1_from_anthropic,
+)
+
+
+def _convert_to_v1_from_bedrock(message: AIMessage) -> list[types.ContentBlock]:
+    """Convert bedrock message content to v1 format."""
+    out = _convert_to_v1_from_anthropic(message)
+
+    content_tool_call_ids = {
+        block.get("id")
+        for block in out
+        if isinstance(block, dict) and block.get("type") == "tool_call"
+    }
+    for tool_call in message.tool_calls:
+        if (id_ := tool_call.get("id")) and id_ not in content_tool_call_ids:
+            tool_call_block: types.ToolCall = {
+                "type": "tool_call",
+                "id": id_,
+                "name": tool_call["name"],
+                "args": tool_call["args"],
+            }
+            if "index" in tool_call:
+                tool_call_block["index"] = tool_call["index"]  # type: ignore[typeddict-item]
+            if "extras" in tool_call:
+                tool_call_block["extras"] = tool_call["extras"]  # type: ignore[typeddict-item]
+            out.append(tool_call_block)
+    return out
+
+
+def _convert_to_v1_from_bedrock_chunk(
+    message: AIMessageChunk,
+) -> list[types.ContentBlock]:
+    """Convert bedrock message chunk content to v1 format."""
+    if (
+        message.content == ""
+        and not message.additional_kwargs
+        and not message.tool_calls
+    ):
+        # Bedrock outputs multiple chunks containing response metadata
+        return []
+
+    out = _convert_to_v1_from_anthropic(message)
+
+    if (
+        message.tool_call_chunks
+        and not message.content
+        and message.chunk_position != "last"  # keep tool_calls if aggregated
+    ):
+        for tool_call_chunk in message.tool_call_chunks:
+            tc: types.ToolCallChunk = {
+                "type": "tool_call_chunk",
+                "id": tool_call_chunk.get("id"),
+                "name": tool_call_chunk.get("name"),
+                "args": tool_call_chunk.get("args"),
+            }
+            if (idx := tool_call_chunk.get("index")) is not None:
+                tc["index"] = idx
+            out.append(tc)
+    return out
+
+
+def translate_content(message: AIMessage) -> list[types.ContentBlock]:
+    """Derive standard content blocks from a message with Bedrock content."""
+    if "claude" not in message.response_metadata.get("model_name", "").lower():
+        raise NotImplementedError  # fall back to best-effort parsing
+    return _convert_to_v1_from_bedrock(message)
+
+
+def translate_content_chunk(message: AIMessageChunk) -> list[types.ContentBlock]:
+    """Derive standard content blocks from a message chunk with Bedrock content."""
+    # TODO: add model_name to all Bedrock chunks and update core merging logic
+    # to not append during aggregation. Then raise NotImplementedError here if
+    # not an Anthropic model to fall back to best-effort parsing.
+    return _convert_to_v1_from_bedrock_chunk(message)
+
+
+def _register_bedrock_translator() -> None:
+    """Register the bedrock translator with the central registry.
+
+    Run automatically when the module is imported.
+    """
+    from langchain_core.messages.block_translators import (  # noqa: PLC0415
+        register_translator,
+    )
+
+    register_translator("bedrock", translate_content, translate_content_chunk)
+
+
+_register_bedrock_translator()

langchain_core-1.0.0a4/langchain_core/messages/block_translators/bedrock_converse.py

@@ -0,0 +1,283 @@
+"""Derivations of standard content blocks from Amazon (Bedrock Converse) content."""
+
+import base64
+from collections.abc import Iterable
+from typing import Any, Optional, cast
+
+from langchain_core.messages import AIMessage, AIMessageChunk
+from langchain_core.messages import content as types
+
+
+def _bytes_to_b64_str(bytes_: bytes) -> str:
+    return base64.b64encode(bytes_).decode("utf-8")
+
+
+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
+
+    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 _convert_to_v1_from_converse_input(
+    content: list[types.ContentBlock],
+) -> list[types.ContentBlock]:
+    """Attempt to unpack non-standard blocks."""
+
+    def _iter_blocks() -> Iterable[types.ContentBlock]:
+        blocks: list[dict[str, Any]] = [
+            cast("dict[str, Any]", block)
+            if block.get("type") != "non_standard"
+            else block["value"]  # type: ignore[typeddict-item]  # this is only non-standard blocks
+            for block in content
+        ]
+        for block in blocks:
+            num_keys = len(block)
+
+            if num_keys == 1 and (text := block.get("text")):
+                yield {"type": "text", "text": text}
+
+            elif (
+                num_keys == 1
+                and (document := block.get("document"))
+                and isinstance(document, dict)
+                and "format" in document
+            ):
+                if document.get("format") == "pdf":
+                    if "bytes" in document.get("source", {}):
+                        file_block: types.FileContentBlock = {
+                            "type": "file",
+                            "base64": _bytes_to_b64_str(document["source"]["bytes"]),
+                            "mime_type": "application/pdf",
+                        }
+                        _populate_extras(file_block, document, {"format", "source"})
+                        yield file_block
+
+                    else:
+                        yield {"type": "non_standard", "value": block}
+
+                elif document["format"] == "txt":
+                    if "text" in document.get("source", {}):
+                        plain_text_block: types.PlainTextContentBlock = {
+                            "type": "text-plain",
+                            "text": document["source"]["text"],
+                            "mime_type": "text/plain",
+                        }
+                        _populate_extras(
+                            plain_text_block, document, {"format", "source"}
+                        )
+                        yield plain_text_block
+                    else:
+                        yield {"type": "non_standard", "value": block}
+
+                else:
+                    yield {"type": "non_standard", "value": block}
+
+            elif (
+                num_keys == 1
+                and (image := block.get("image"))
+                and isinstance(image, dict)
+                and "format" in image
+            ):
+                if "bytes" in image.get("source", {}):
+                    image_block: types.ImageContentBlock = {
+                        "type": "image",
+                        "base64": _bytes_to_b64_str(image["source"]["bytes"]),
+                        "mime_type": f"image/{image['format']}",
+                    }
+                    _populate_extras(image_block, image, {"format", "source"})
+                    yield image_block
+
+                else:
+                    yield {"type": "non_standard", "value": block}
+
+            elif block.get("type") in types.KNOWN_BLOCK_TYPES:
+                yield cast("types.ContentBlock", block)
+
+            else:
+                yield {"type": "non_standard", "value": block}
+
+    return list(_iter_blocks())
+
+
+def _convert_citation_to_v1(citation: dict[str, Any]) -> types.Annotation:
+    standard_citation: types.Citation = {"type": "citation"}
+    if "title" in citation:
+        standard_citation["title"] = citation["title"]
+    if (
+        (source_content := citation.get("source_content"))
+        and isinstance(source_content, list)
+        and all(isinstance(item, dict) for item in source_content)
+    ):
+        standard_citation["cited_text"] = "".join(
+            item.get("text", "") for item in source_content
+        )
+
+    known_fields = {"type", "source_content", "title", "index", "extras"}
+
+    for key, value in citation.items():
+        if key not in known_fields:
+            if "extras" not in standard_citation:
+                standard_citation["extras"] = {}
+            standard_citation["extras"][key] = value
+
+    return standard_citation
+
+
+def _convert_to_v1_from_converse(message: AIMessage) -> list[types.ContentBlock]:
+    """Convert Bedrock Converse message content to v1 format."""
+    if (
+        message.content == ""
+        and not message.additional_kwargs
+        and not message.tool_calls
+    ):
+        # Converse outputs multiple chunks containing response metadata
+        return []
+
+    if isinstance(message.content, str):
+        message.content = [{"type": "text", "text": message.content}]
+
+    def _iter_blocks() -> Iterable[types.ContentBlock]:
+        for block in message.content:
+            if not isinstance(block, dict):
+                continue
+            block_type = block.get("type")
+
+            if block_type == "text":
+                if citations := block.get("citations"):
+                    text_block: types.TextContentBlock = {
+                        "type": "text",
+                        "text": block.get("text", ""),
+                        "annotations": [_convert_citation_to_v1(a) for a in citations],
+                    }
+                else:
+                    text_block = {"type": "text", "text": block["text"]}
+                if "index" in block:
+                    text_block["index"] = block["index"]
+                yield text_block
+
+            elif block_type == "reasoning_content":
+                reasoning_block: types.ReasoningContentBlock = {"type": "reasoning"}
+                if reasoning_content := block.get("reasoning_content"):
+                    if reasoning := reasoning_content.get("text"):
+                        reasoning_block["reasoning"] = reasoning
+                    if signature := reasoning_content.get("signature"):
+                        if "extras" not in reasoning_block:
+                            reasoning_block["extras"] = {}
+                        reasoning_block["extras"]["signature"] = signature
+
+                if "index" in block:
+                    reasoning_block["index"] = block["index"]
+
+                known_fields = {"type", "reasoning_content", "index", "extras"}
+                for key in block:
+                    if key not in known_fields:
+                        if "extras" not in reasoning_block:
+                            reasoning_block["extras"] = {}
+                        reasoning_block["extras"][key] = block[key]
+                yield reasoning_block
+
+            elif block_type == "tool_use":
+                if (
+                    isinstance(message, AIMessageChunk)
+                    and len(message.tool_call_chunks) == 1
+                    and message.chunk_position != "last"
+                ):
+                    # Isolated chunk
+                    tool_call_chunk: types.ToolCallChunk = (
+                        message.tool_call_chunks[0].copy()  # type: ignore[assignment]
+                    )
+                    if "type" not in tool_call_chunk:
+                        tool_call_chunk["type"] = "tool_call_chunk"
+                    yield tool_call_chunk
+                else:
+                    tool_call_block: Optional[types.ToolCall] = None
+                    # Non-streaming or gathered chunk
+                    if len(message.tool_calls) == 1:
+                        tool_call_block = {
+                            "type": "tool_call",
+                            "name": message.tool_calls[0]["name"],
+                            "args": message.tool_calls[0]["args"],
+                            "id": message.tool_calls[0].get("id"),
+                        }
+                    elif call_id := block.get("id"):
+                        for tc in message.tool_calls:
+                            if tc.get("id") == call_id:
+                                tool_call_block = {
+                                    "type": "tool_call",
+                                    "name": tc["name"],
+                                    "args": tc["args"],
+                                    "id": tc.get("id"),
+                                }
+                                break
+                    else:
+                        pass
+                    if not tool_call_block:
+                        tool_call_block = {
+                            "type": "tool_call",
+                            "name": block.get("name", ""),
+                            "args": block.get("input", {}),
+                            "id": block.get("id", ""),
+                        }
+                    if "index" in block:
+                        tool_call_block["index"] = block["index"]
+                    yield tool_call_block
+
+            elif (
+                block_type == "input_json_delta"
+                and isinstance(message, AIMessageChunk)
+                and len(message.tool_call_chunks) == 1
+            ):
+                tool_call_chunk = (
+                    message.tool_call_chunks[0].copy()  # type: ignore[assignment]
+                )
+                if "type" not in tool_call_chunk:
+                    tool_call_chunk["type"] = "tool_call_chunk"
+                yield tool_call_chunk
+
+            else:
+                new_block: types.NonStandardContentBlock = {
+                    "type": "non_standard",
+                    "value": block,
+                }
+                if "index" in new_block["value"]:
+                    new_block["index"] = new_block["value"].pop("index")
+                yield new_block
+
+    return list(_iter_blocks())
+
+
+def translate_content(message: AIMessage) -> list[types.ContentBlock]:
+    """Derive standard content blocks from a message with Bedrock Converse content."""
+    return _convert_to_v1_from_converse(message)
+
+
+def translate_content_chunk(message: AIMessageChunk) -> list[types.ContentBlock]:
+    """Derive standard content blocks from a chunk with Bedrock Converse content."""
+    return _convert_to_v1_from_converse(message)
+
+
+def _register_bedrock_converse_translator() -> None:
+    """Register the Bedrock Converse translator with the central registry.
+
+    Run automatically when the module is imported.
+    """
+    from langchain_core.messages.block_translators import (  # noqa: PLC0415
+        register_translator,
+    )
+
+    register_translator("bedrock_converse", translate_content, translate_content_chunk)
+
+
+_register_bedrock_converse_translator()

{langchain_core-1.0.0a3 → langchain_core-1.0.0a4}/langchain_core/version.py

@@ -1,3 +1,3 @@
 """langchain-core version information and utilities."""
 
-VERSION = "1.0.0a3"
+VERSION = "1.0.0a4"

{langchain_core-1.0.0a3 → langchain_core-1.0.0a4}/pyproject.toml

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

{langchain_core-1.0.0a3 → langchain_core-1.0.0a4}/tests/unit_tests/language_models/chat_models/test_base.py

@@ -1,6 +1,7 @@
 """Test base chat model."""
 
 import uuid
+import warnings
 from collections.abc import AsyncIterator, Iterator
 from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
@@ -505,6 +506,45 @@ def test_trace_images_in_openai_format() -> None:
     ]
 
 
+def test_trace_pdfs() -> None:
+    # For backward compat
+    llm = ParrotFakeChatModel()
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "file",
+                    "mime_type": "application/pdf",
+                    "base64": "<base64 string>",
+                }
+            ],
+        }
+    ]
+    tracer = FakeChatModelStartTracer()
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        llm.invoke(messages, config={"callbacks": [tracer]})
+
+    assert tracer.messages == [
+        [
+            [
+                HumanMessage(
+                    content=[
+                        {
+                            "type": "file",
+                            "mime_type": "application/pdf",
+                            "source_type": "base64",
+                            "data": "<base64 string>",
+                        }
+                    ]
+                )
+            ]
+        ]
+    ]
+
+
 def test_content_block_transformation_v0_to_v1_image() -> None:
     """Test that v0 format image content blocks are transformed to v1 format."""
     # Create a message with v0 format image content

{langchain_core-1.0.0a3 → langchain_core-1.0.0a4}/tests/unit_tests/messages/block_translators/test_anthropic.py

@@ -162,6 +162,11 @@ def test_convert_to_v1_from_anthropic() -> None:
     # Check no mutation
     assert message.content != expected_content
 
+    message = AIMessage("Hello", response_metadata={"model_provider": "anthropic"})
+    expected_content = [{"type": "text", "text": "Hello"}]
+    assert message.content_blocks == expected_content
+    assert message.content != expected_content  # check no mutation
+
 
 def test_convert_to_v1_from_anthropic_chunk() -> None:
     chunks = [