langchain-core 1.0.0a3__py3-none-any.whl → 1.0.0a5__py3-none-any.whl

langchain_core/messages/block_translators/bedrock.py

@@ -1,39 +1,86 @@
-"""Derivations of standard content blocks from Amazon (Bedrock) content."""
-
-import warnings
+"""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
+
 
-WARNED = False
+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)
 
-def translate_content(message: AIMessage) -> list[types.ContentBlock]:  # noqa: ARG001
+    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."""
-    global WARNED  # noqa: PLW0603
-    if not WARNED:
-        warning_message = (
-            "Content block standardization is not yet fully supported for Bedrock."
-        )
-        warnings.warn(warning_message, stacklevel=2)
-        WARNED = True
-    raise NotImplementedError
-
-
-def translate_content_chunk(message: AIMessageChunk) -> list[types.ContentBlock]:  # noqa: ARG001
-    """Derive standard content blocks from a chunk with Bedrock content."""
-    global WARNED  # noqa: PLW0603
-    if not WARNED:
-        warning_message = (
-            "Content block standardization is not yet fully supported for Bedrock."
-        )
-        warnings.warn(warning_message, stacklevel=2)
-        WARNED = True
-    raise NotImplementedError
+    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.
+    """Register the bedrock translator with the central registry.
 
     Run automatically when the module is imported.
     """

langchain_core/messages/block_translators/bedrock_converse.py

@@ -1,37 +1,285 @@
 """Derivations of standard content blocks from Amazon (Bedrock Converse) content."""
 
-import warnings
+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
 
-WARNED = False
 
+def _bytes_to_b64_str(bytes_: bytes) -> str:
+    return base64.b64encode(bytes_).decode("utf-8")
 
-def translate_content(message: AIMessage) -> list[types.ContentBlock]:  # noqa: ARG001
-    """Derive standard content blocks from a message with Bedrock Converse content."""
-    global WARNED  # noqa: PLW0603
-    if not WARNED:
-        warning_message = (
-            "Content block standardization is not yet fully supported for Bedrock "
-            "Converse."
+
+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]:
+    """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``
+    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.
+
+    Args:
+        content: List of content blocks to process.
+
+    Returns:
+        Updated list with Converse blocks converted to v1 format.
+    """
+
+    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
         )
-        warnings.warn(warning_message, stacklevel=2)
-        WARNED = True
-    raise NotImplementedError
 
+    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"]
 
-def translate_content_chunk(message: AIMessageChunk) -> list[types.ContentBlock]:  # noqa: ARG001
+                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."""
-    global WARNED  # noqa: PLW0603
-    if not WARNED:
-        warning_message = (
-            "Content block standardization is not yet fully supported for Bedrock "
-            "Converse."
-        )
-        warnings.warn(warning_message, stacklevel=2)
-        WARNED = True
-    raise NotImplementedError
+    return _convert_to_v1_from_converse(message)
 
 
 def _register_bedrock_converse_translator() -> None: