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

langchain_core/messages/block_translators/langchain_v0.py

@@ -6,32 +6,36 @@ from langchain_core.messages import content as types
 
 
 def _convert_v0_multimodal_input_to_v1(
-    blocks: list[types.ContentBlock],
+    content: list[types.ContentBlock],
 ) -> list[types.ContentBlock]:
     """Convert v0 multimodal blocks to v1 format.
 
-    Processes ``'non_standard'`` blocks that might be v0 format and converts them
-    to proper v1 ``ContentBlock``.
+    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 v0 format
+    blocks to v1 format.
+
+    If conversion fails, the block is left as a ``'non_standard'`` block.
 
     Args:
-        blocks: List of content blocks to process.
+        content: List of content blocks to process.
 
     Returns:
-        Updated list with v0 blocks converted to v1 format.
-
+        v1 content blocks.
     """
     converted_blocks = []
     unpacked_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 blocks
+        for block in content
     ]
     for block in unpacked_blocks:
         if block.get("type") in {"image", "audio", "file"} and "source_type" in block:
             converted_block = _convert_legacy_v0_content_block_to_v1(block)
             converted_blocks.append(cast("types.ContentBlock", converted_block))
         elif block.get("type") in types.KNOWN_BLOCK_TYPES:
+            # Guard in case this function is used outside of the .content_blocks flow
             converted_blocks.append(cast("types.ContentBlock", block))
         else:
             converted_blocks.append({"type": "non_standard", "value": block})
@@ -47,11 +51,18 @@ def _convert_legacy_v0_content_block_to_v1(
     Preserves unknown keys as extras to avoid data loss.
 
     Returns the original block unchanged if it's not in v0 format.
-
     """
 
     def _extract_v0_extras(block_dict: dict, known_keys: set[str]) -> dict[str, Any]:
-        """Extract unknown keys from v0 block to preserve as extras."""
+        """Extract unknown keys from v0 block to preserve as extras.
+
+        Args:
+            block_dict: The original v0 block dictionary.
+            known_keys: Set of keys known to be part of the v0 format for this block.
+
+        Returns:
+            A dictionary of extra keys not part of the known v0 format.
+        """
         return {k: v for k, v in block_dict.items() if k not in known_keys}
 
     # Check if this is actually a v0 format block
@@ -63,7 +74,8 @@ def _convert_legacy_v0_content_block_to_v1(
     if block.get("type") == "image":
         source_type = block.get("source_type")
         if source_type == "url":
-            known_keys = {"type", "source_type", "url", "mime_type"}
+            # image-url
+            known_keys = {"mime_type", "type", "source_type", "url"}
             extras = _extract_v0_extras(block, known_keys)
             if "id" in block:
                 return types.create_image_block(
@@ -74,17 +86,21 @@ def _convert_legacy_v0_content_block_to_v1(
                 )
 
             # Don't construct with an ID if not present in original block
-            v1_block = types.ImageContentBlock(type="image", url=block["url"])
+            v1_image_url = types.ImageContentBlock(type="image", url=block["url"])
             if block.get("mime_type"):
-                v1_block["mime_type"] = block["mime_type"]
+                v1_image_url["mime_type"] = block["mime_type"]
 
+            v1_image_url["extras"] = {}
             for key, value in extras.items():
                 if value is not None:
-                    v1_block["extras"] = {}
-                    v1_block["extras"][key] = value
-            return v1_block
+                    v1_image_url["extras"][key] = value
+            if v1_image_url["extras"] == {}:
+                del v1_image_url["extras"]
+
+            return v1_image_url
         if source_type == "base64":
-            known_keys = {"type", "source_type", "data", "mime_type"}
+            # image-base64
+            known_keys = {"mime_type", "type", "source_type", "data"}
             extras = _extract_v0_extras(block, known_keys)
             if "id" in block:
                 return types.create_image_block(
@@ -94,71 +110,192 @@ def _convert_legacy_v0_content_block_to_v1(
                     **extras,
                 )
 
-            v1_block = types.ImageContentBlock(type="image", base64=block["data"])
+            v1_image_base64 = types.ImageContentBlock(
+                type="image", base64=block["data"]
+            )
             if block.get("mime_type"):
-                v1_block["mime_type"] = block["mime_type"]
+                v1_image_base64["mime_type"] = block["mime_type"]
 
+            v1_image_base64["extras"] = {}
             for key, value in extras.items():
                 if value is not None:
-                    v1_block["extras"] = {}
-                    v1_block["extras"][key] = value
-            return v1_block
+                    v1_image_base64["extras"][key] = value
+            if v1_image_base64["extras"] == {}:
+                del v1_image_base64["extras"]
+
+            return v1_image_base64
         if source_type == "id":
+            # image-id
             known_keys = {"type", "source_type", "id"}
             extras = _extract_v0_extras(block, known_keys)
             # For id `source_type`, `id` is the file reference, not block ID
-            v1_block = types.ImageContentBlock(type="image", file_id=block["id"])
+            v1_image_id = types.ImageContentBlock(type="image", file_id=block["id"])
 
+            v1_image_id["extras"] = {}
             for key, value in extras.items():
                 if value is not None:
-                    v1_block["extras"] = {}
-                    v1_block["extras"][key] = value
+                    v1_image_id["extras"][key] = value
+            if v1_image_id["extras"] == {}:
+                del v1_image_id["extras"]
 
-            return v1_block
+            return v1_image_id
     elif block.get("type") == "audio":
         source_type = block.get("source_type")
         if source_type == "url":
-            known_keys = {"type", "source_type", "url", "mime_type"}
+            # audio-url
+            known_keys = {"mime_type", "type", "source_type", "url"}
             extras = _extract_v0_extras(block, known_keys)
-            return types.create_audio_block(
-                url=block["url"], mime_type=block.get("mime_type"), **extras
+            if "id" in block:
+                return types.create_audio_block(
+                    url=block["url"],
+                    mime_type=block.get("mime_type"),
+                    id=block["id"],
+                    **extras,
+                )
+
+            # Don't construct with an ID if not present in original block
+            v1_audio_url: types.AudioContentBlock = types.AudioContentBlock(
+                type="audio", url=block["url"]
             )
+            if block.get("mime_type"):
+                v1_audio_url["mime_type"] = block["mime_type"]
+
+            v1_audio_url["extras"] = {}
+            for key, value in extras.items():
+                if value is not None:
+                    v1_audio_url["extras"][key] = value
+            if v1_audio_url["extras"] == {}:
+                del v1_audio_url["extras"]
+
+            return v1_audio_url
         if source_type == "base64":
-            known_keys = {"type", "source_type", "data", "mime_type"}
+            # audio-base64
+            known_keys = {"mime_type", "type", "source_type", "data"}
             extras = _extract_v0_extras(block, known_keys)
-            return types.create_audio_block(
-                base64=block["data"], mime_type=block.get("mime_type"), **extras
+            if "id" in block:
+                return types.create_audio_block(
+                    base64=block["data"],
+                    mime_type=block.get("mime_type"),
+                    id=block["id"],
+                    **extras,
+                )
+
+            v1_audio_base64: types.AudioContentBlock = types.AudioContentBlock(
+                type="audio", base64=block["data"]
             )
+            if block.get("mime_type"):
+                v1_audio_base64["mime_type"] = block["mime_type"]
+
+            v1_audio_base64["extras"] = {}
+            for key, value in extras.items():
+                if value is not None:
+                    v1_audio_base64["extras"][key] = value
+            if v1_audio_base64["extras"] == {}:
+                del v1_audio_base64["extras"]
+
+            return v1_audio_base64
         if source_type == "id":
+            # audio-id
             known_keys = {"type", "source_type", "id"}
             extras = _extract_v0_extras(block, known_keys)
-            return types.create_audio_block(file_id=block["id"], **extras)
+            v1_audio_id: types.AudioContentBlock = types.AudioContentBlock(
+                type="audio", file_id=block["id"]
+            )
+
+            v1_audio_id["extras"] = {}
+            for key, value in extras.items():
+                if value is not None:
+                    v1_audio_id["extras"][key] = value
+            if v1_audio_id["extras"] == {}:
+                del v1_audio_id["extras"]
+
+            return v1_audio_id
     elif block.get("type") == "file":
         source_type = block.get("source_type")
         if source_type == "url":
-            known_keys = {"type", "source_type", "url", "mime_type"}
+            # file-url
+            known_keys = {"mime_type", "type", "source_type", "url"}
             extras = _extract_v0_extras(block, known_keys)
-            return types.create_file_block(
-                url=block["url"], mime_type=block.get("mime_type"), **extras
+            if "id" in block:
+                return types.create_file_block(
+                    url=block["url"],
+                    mime_type=block.get("mime_type"),
+                    id=block["id"],
+                    **extras,
+                )
+
+            v1_file_url: types.FileContentBlock = types.FileContentBlock(
+                type="file", url=block["url"]
             )
+            if block.get("mime_type"):
+                v1_file_url["mime_type"] = block["mime_type"]
+
+            v1_file_url["extras"] = {}
+            for key, value in extras.items():
+                if value is not None:
+                    v1_file_url["extras"][key] = value
+            if v1_file_url["extras"] == {}:
+                del v1_file_url["extras"]
+
+            return v1_file_url
         if source_type == "base64":
-            known_keys = {"type", "source_type", "data", "mime_type"}
+            # file-base64
+            known_keys = {"mime_type", "type", "source_type", "data"}
             extras = _extract_v0_extras(block, known_keys)
-            return types.create_file_block(
-                base64=block["data"], mime_type=block.get("mime_type"), **extras
+            if "id" in block:
+                return types.create_file_block(
+                    base64=block["data"],
+                    mime_type=block.get("mime_type"),
+                    id=block["id"],
+                    **extras,
+                )
+
+            v1_file_base64: types.FileContentBlock = types.FileContentBlock(
+                type="file", base64=block["data"]
             )
+            if block.get("mime_type"):
+                v1_file_base64["mime_type"] = block["mime_type"]
+
+            v1_file_base64["extras"] = {}
+            for key, value in extras.items():
+                if value is not None:
+                    v1_file_base64["extras"][key] = value
+            if v1_file_base64["extras"] == {}:
+                del v1_file_base64["extras"]
+
+            return v1_file_base64
         if source_type == "id":
+            # file-id
             known_keys = {"type", "source_type", "id"}
             extras = _extract_v0_extras(block, known_keys)
             return types.create_file_block(file_id=block["id"], **extras)
         if source_type == "text":
-            known_keys = {"type", "source_type", "url", "mime_type"}
+            # file-text
+            known_keys = {"mime_type", "type", "source_type", "url"}
             extras = _extract_v0_extras(block, known_keys)
-            return types.create_plaintext_block(
-                # In v0, URL points to the text file content
-                text=block["url"],
-                **extras,
+            if "id" in block:
+                return types.create_plaintext_block(
+                    # In v0, URL points to the text file content
+                    # TODO: attribute this claim
+                    text=block["url"],
+                    id=block["id"],
+                    **extras,
+                )
+
+            v1_file_text: types.PlainTextContentBlock = types.PlainTextContentBlock(
+                type="text-plain", text=block["url"], mime_type="text/plain"
             )
+            if block.get("mime_type"):
+                v1_file_text["mime_type"] = block["mime_type"]
+
+            v1_file_text["extras"] = {}
+            for key, value in extras.items():
+                if value is not None:
+                    v1_file_text["extras"][key] = value
+            if v1_file_text["extras"] == {}:
+                del v1_file_text["extras"]
+
+            return v1_file_text
 
     # If we can't convert, return the block unchanged
     return block

langchain_core/messages/block_translators/openai.py

@@ -151,15 +151,19 @@ def _convert_to_v1_from_chat_completions(
 
 
 def _convert_to_v1_from_chat_completions_input(
-    blocks: list[types.ContentBlock],
+    content: list[types.ContentBlock],
 ) -> list[types.ContentBlock]:
     """Convert OpenAI Chat Completions format blocks to v1 format.
 
-    Processes non_standard blocks that might be OpenAI format and converts them
-    to proper ContentBlocks. If conversion fails, leaves them as non_standard.
+    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 OpenAI format to v1 ContentBlocks.
+
+    If conversion fails, the block is left as a ``'non_standard'`` block.
 
     Args:
-        blocks: List of content blocks to process.
+        content: List of content blocks to process.
 
     Returns:
         Updated list with OpenAI blocks converted to v1 format.
@@ -171,7 +175,7 @@ def _convert_to_v1_from_chat_completions_input(
         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 blocks
+        for block in content
     ]
     for block in unpacked_blocks:
         if block.get("type") in {
@@ -713,21 +717,27 @@ def _convert_to_v1_from_responses(message: AIMessage) -> list[types.ContentBlock
                     yield tool_call_block
 
             elif block_type == "web_search_call":
-                web_search_call = {"type": "web_search_call", "id": block["id"]}
+                web_search_call = {
+                    "type": "server_tool_call",
+                    "name": "web_search",
+                    "args": {},
+                    "id": block["id"],
+                }
                 if "index" in block:
                     web_search_call["index"] = f"lc_wsc_{block['index']}"
-                if (
-                    "action" in block
-                    and isinstance(block["action"], dict)
-                    and block["action"].get("type") == "search"
-                    and "query" in block["action"]
-                ):
-                    web_search_call["query"] = block["action"]["query"]
+
+                sources: Optional[dict[str, Any]] = None
+                if "action" in block and isinstance(block["action"], dict):
+                    if "sources" in block["action"]:
+                        sources = block["action"]["sources"]
+                    web_search_call["args"] = {
+                        k: v for k, v in block["action"].items() if k != "sources"
+                    }
                 for key in block:
-                    if key not in ("type", "id", "index"):
+                    if key not in ("type", "id", "action", "status", "index"):
                         web_search_call[key] = block[key]
 
-                yield cast("types.WebSearchCall", web_search_call)
+                yield cast("types.ServerToolCall", web_search_call)
 
                 # If .content already has web_search_result, don't add
                 if not any(
@@ -736,21 +746,88 @@ def _convert_to_v1_from_responses(message: AIMessage) -> list[types.ContentBlock
                     and other_block.get("id") == block["id"]
                     for other_block in message.content
                 ):
-                    web_search_result = {"type": "web_search_result", "id": block["id"]}
+                    web_search_result = {
+                        "type": "server_tool_result",
+                        "tool_call_id": block["id"],
+                    }
+                    if sources:
+                        web_search_result["output"] = {"sources": sources}
+
+                    status = block.get("status")
+                    if status == "failed":
+                        web_search_result["status"] = "error"
+                    elif status == "completed":
+                        web_search_result["status"] = "success"
+                    elif status:
+                        web_search_result["extras"] = {"status": status}
+                    else:
+                        pass
                     if "index" in block and isinstance(block["index"], int):
                         web_search_result["index"] = f"lc_wsr_{block['index'] + 1}"
-                    yield cast("types.WebSearchResult", web_search_result)
+                    yield cast("types.ServerToolResult", web_search_result)
+
+            elif block_type == "file_search_call":
+                file_search_call = {
+                    "type": "server_tool_call",
+                    "name": "file_search",
+                    "id": block["id"],
+                    "args": {"queries": block.get("queries", [])},
+                }
+                if "index" in block:
+                    file_search_call["index"] = f"lc_fsc_{block['index']}"
+
+                for key in block:
+                    if key not in (
+                        "type",
+                        "id",
+                        "queries",
+                        "results",
+                        "status",
+                        "index",
+                    ):
+                        file_search_call[key] = block[key]
+
+                yield cast("types.ServerToolCall", file_search_call)
+
+                file_search_result = {
+                    "type": "server_tool_result",
+                    "tool_call_id": block["id"],
+                }
+                if file_search_output := block.get("results"):
+                    file_search_result["output"] = file_search_output
+
+                status = block.get("status")
+                if status == "failed":
+                    file_search_result["status"] = "error"
+                elif status == "completed":
+                    file_search_result["status"] = "success"
+                elif status:
+                    file_search_result["extras"] = {"status": status}
+                else:
+                    pass
+                if "index" in block and isinstance(block["index"], int):
+                    file_search_result["index"] = f"lc_fsr_{block['index'] + 1}"
+                yield cast("types.ServerToolResult", file_search_result)
 
             elif block_type == "code_interpreter_call":
                 code_interpreter_call = {
-                    "type": "code_interpreter_call",
+                    "type": "server_tool_call",
+                    "name": "code_interpreter",
                     "id": block["id"],
                 }
                 if "code" in block:
-                    code_interpreter_call["code"] = block["code"]
+                    code_interpreter_call["args"] = {"code": block["code"]}
                 if "index" in block:
                     code_interpreter_call["index"] = f"lc_cic_{block['index']}"
-                known_fields = {"type", "id", "language", "code", "extras", "index"}
+                known_fields = {
+                    "type",
+                    "id",
+                    "outputs",
+                    "status",
+                    "code",
+                    "extras",
+                    "index",
+                }
                 for key in block:
                     if key not in known_fields:
                         if "extras" not in code_interpreter_call:
@@ -758,33 +835,138 @@ def _convert_to_v1_from_responses(message: AIMessage) -> list[types.ContentBlock
                         code_interpreter_call["extras"][key] = block[key]
 
                 code_interpreter_result = {
-                    "type": "code_interpreter_result",
-                    "id": block["id"],
+                    "type": "server_tool_result",
+                    "tool_call_id": block["id"],
                 }
                 if "outputs" in block:
-                    code_interpreter_result["outputs"] = block["outputs"]
-                    for output in block["outputs"]:
-                        if (
-                            isinstance(output, dict)
-                            and (output_type := output.get("type"))
-                            and output_type == "logs"
-                        ):
-                            if "output" not in code_interpreter_result:
-                                code_interpreter_result["output"] = []
-                            code_interpreter_result["output"].append(
-                                {
-                                    "type": "code_interpreter_output",
-                                    "stdout": output.get("logs", ""),
-                                }
-                            )
-
-                if "status" in block:
-                    code_interpreter_result["status"] = block["status"]
+                    code_interpreter_result["output"] = block["outputs"]
+
+                status = block.get("status")
+                if status == "failed":
+                    code_interpreter_result["status"] = "error"
+                elif status == "completed":
+                    code_interpreter_result["status"] = "success"
+                elif status:
+                    code_interpreter_result["extras"] = {"status": status}
+                else:
+                    pass
                 if "index" in block and isinstance(block["index"], int):
                     code_interpreter_result["index"] = f"lc_cir_{block['index'] + 1}"
 
-                yield cast("types.CodeInterpreterCall", code_interpreter_call)
-                yield cast("types.CodeInterpreterResult", code_interpreter_result)
+                yield cast("types.ServerToolCall", code_interpreter_call)
+                yield cast("types.ServerToolResult", code_interpreter_result)
+
+            elif block_type == "mcp_call":
+                mcp_call = {
+                    "type": "server_tool_call",
+                    "name": "remote_mcp",
+                    "id": block["id"],
+                }
+                if (arguments := block.get("arguments")) and isinstance(arguments, str):
+                    try:
+                        mcp_call["args"] = json.loads(block["arguments"])
+                    except json.JSONDecodeError:
+                        mcp_call["extras"] = {"arguments": arguments}
+                if "name" in block:
+                    if "extras" not in mcp_call:
+                        mcp_call["extras"] = {}
+                    mcp_call["extras"]["tool_name"] = block["name"]
+                if "server_label" in block:
+                    if "extras" not in mcp_call:
+                        mcp_call["extras"] = {}
+                    mcp_call["extras"]["server_label"] = block["server_label"]
+                if "index" in block:
+                    mcp_call["index"] = f"lc_mcp_{block['index']}"
+                known_fields = {
+                    "type",
+                    "id",
+                    "arguments",
+                    "name",
+                    "server_label",
+                    "output",
+                    "error",
+                    "extras",
+                    "index",
+                }
+                for key in block:
+                    if key not in known_fields:
+                        if "extras" not in mcp_call:
+                            mcp_call["extras"] = {}
+                        mcp_call["extras"][key] = block[key]
+
+                yield cast("types.ServerToolCall", mcp_call)
+
+                mcp_result = {
+                    "type": "server_tool_result",
+                    "tool_call_id": block["id"],
+                }
+                if mcp_output := block.get("output"):
+                    mcp_result["output"] = mcp_output
+
+                error = block.get("error")
+                if error:
+                    if "extras" not in mcp_result:
+                        mcp_result["extras"] = {}
+                    mcp_result["extras"]["error"] = error
+                    mcp_result["status"] = "error"
+                else:
+                    mcp_result["status"] = "success"
+
+                if "index" in block and isinstance(block["index"], int):
+                    mcp_result["index"] = f"lc_mcpr_{block['index'] + 1}"
+                yield cast("types.ServerToolResult", mcp_result)
+
+            elif block_type == "mcp_list_tools":
+                mcp_list_tools_call = {
+                    "type": "server_tool_call",
+                    "name": "mcp_list_tools",
+                    "args": {},
+                    "id": block["id"],
+                }
+                if "server_label" in block:
+                    mcp_list_tools_call["extras"] = {}
+                    mcp_list_tools_call["extras"]["server_label"] = block[
+                        "server_label"
+                    ]
+                if "index" in block:
+                    mcp_list_tools_call["index"] = f"lc_mlt_{block['index']}"
+                known_fields = {
+                    "type",
+                    "id",
+                    "name",
+                    "server_label",
+                    "tools",
+                    "error",
+                    "extras",
+                    "index",
+                }
+                for key in block:
+                    if key not in known_fields:
+                        if "extras" not in mcp_list_tools_call:
+                            mcp_list_tools_call["extras"] = {}
+                        mcp_list_tools_call["extras"][key] = block[key]
+
+                yield cast("types.ServerToolCall", mcp_list_tools_call)
+
+                mcp_list_tools_result = {
+                    "type": "server_tool_result",
+                    "tool_call_id": block["id"],
+                }
+                if mcp_output := block.get("tools"):
+                    mcp_list_tools_result["output"] = mcp_output
+
+                error = block.get("error")
+                if error:
+                    if "extras" not in mcp_list_tools_result:
+                        mcp_list_tools_result["extras"] = {}
+                    mcp_list_tools_result["extras"]["error"] = error
+                    mcp_list_tools_result["status"] = "error"
+                else:
+                    mcp_list_tools_result["status"] = "success"
+
+                if "index" in block and isinstance(block["index"], int):
+                    mcp_list_tools_result["index"] = f"lc_mltr_{block['index'] + 1}"
+                yield cast("types.ServerToolResult", mcp_list_tools_result)
 
             elif block_type in types.KNOWN_BLOCK_TYPES:
                 yield cast("types.ContentBlock", block)

langchain_core/messages/chat.py

@@ -30,7 +30,10 @@ class ChatMessageChunk(ChatMessage, BaseMessageChunk):
     # non-chunk variant.
     type: Literal["ChatMessageChunk"] = "ChatMessageChunk"  # type: ignore[assignment]
     """The type of the message (used during serialization).
-    Defaults to "ChatMessageChunk"."""
+
+    Defaults to ``'ChatMessageChunk'``.
+
+    """
 
     @override
     def __add__(self, other: Any) -> BaseMessageChunk:  # type: ignore[override]