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

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/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/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/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,271 @@
 """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]:
+    """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
         )
-        warnings.warn(warning_message, stacklevel=2)
-        WARNED = True
-    raise NotImplementedError
 
+    known_fields = {"type", "source_content", "title", "index", "extras"}
 
-def translate_content_chunk(message: AIMessageChunk) -> list[types.ContentBlock]:  # noqa: ARG001
+    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."""
-    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:

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.dist-info → langchain_core-1.0.0a4.dist-info}/METADATA

@@ -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.dist-info → langchain_core-1.0.0a4.dist-info}/RECORD

@@ -1,6 +1,6 @@
-langchain_core-1.0.0a3.dist-info/METADATA,sha256=k94vpJybgVViNdkf_q3-vsyfxcOzOoZ5iN4zgzC1-cQ,3726
-langchain_core-1.0.0a3.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-langchain_core-1.0.0a3.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+langchain_core-1.0.0a4.dist-info/METADATA,sha256=-tXk2RBgmDu2EVJiVOTxeLUsjjDETU0EMm0EzS9ec9U,3726
+langchain_core-1.0.0a4.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+langchain_core-1.0.0a4.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
 langchain_core/__init__.py,sha256=TgvhxbrjCRVJwr2HddiyHvtH8W94K-uLM6-6ifNIBXo,713
 langchain_core/_api/__init__.py,sha256=WDOMw4faVuscjDCL5ttnRQNienJP_M9vGMmJUXS6L5w,1976
 langchain_core/_api/beta_decorator.py,sha256=LM5C32LB7_KNLfePssM2hgFRt7aPvqddf9J_TiOWIsw,8877
@@ -45,7 +45,7 @@ langchain_core/indexing/in_memory.py,sha256=YPVOGKE3d5-APCy7T0sJvSPjJJUcshSfPeCp
 langchain_core/language_models/__init__.py,sha256=UATdO6Ap7_UdEHv_sCNxXj_b20-LPDDZJnFkA7zazk8,3901
 langchain_core/language_models/_utils.py,sha256=L5isJ4pHLLPuPjsEjhAC5f2Lxgn_XuYyr-kmqFdzTpU,11164
 langchain_core/language_models/base.py,sha256=35rt7Io4_nMztFaQ3c2iukSdVsDDL2q6u4ETvgdWV_c,14583
-langchain_core/language_models/chat_models.py,sha256=timWQlovkW4P7u0O8EXy7XWlwUL4zZhA8qiuw4vyTJo,79654
+langchain_core/language_models/chat_models.py,sha256=pCVAzGYFOFYTTm6YrVkcpxAG88M0AVduAkV_s2gSJWU,79735
 langchain_core/language_models/fake.py,sha256=h9LhVTkmYLXkJ1_VvsKhqYVpkQsM7eAr9geXF_IVkPs,3772
 langchain_core/language_models/fake_chat_models.py,sha256=nbPFjZ4JSL2-OxKJjJFo39LTehciFZR6Usj5cstDME0,13496
 langchain_core/language_models/llms.py,sha256=wWmMcAJbQYyFBFrXxy2wkNDS4eEv63HwiJLfsOzKFzU,58049
@@ -57,11 +57,11 @@ langchain_core/load/serializable.py,sha256=P29Coe7ZE8-13goAmAtSt0rl85fKaUd96znRQ
 langchain_core/memory.py,sha256=bYgZGSldIa79GqpEd2m9Ve78euCq6SJatzTsHAHKosk,3693
 langchain_core/messages/__init__.py,sha256=y4HmwOTSPex6Py9fo7NPPBf82O_MkdgTUw5uj1f_gmg,6048
 langchain_core/messages/ai.py,sha256=kHFdWpswJ_H9XLY2YkmJ5jCQc11_15Op4YjjvGrGmMI,24629
-langchain_core/messages/base.py,sha256=3e4RNutCZfo3KJfoVrdmKt0hPxt79yM-M_aZuytMwlg,14909
+langchain_core/messages/base.py,sha256=ZUlWULLAe2hdfXo1YNJhfVUJhaQFnTFnT4uN5DzO8Xg,15113
 langchain_core/messages/block_translators/__init__.py,sha256=bBWL_RoZWfy7MZzRmKGZihbZpJ61LO-GMtQiGizRjqc,3255
-langchain_core/messages/block_translators/anthropic.py,sha256=5O-OkOUAX0iReOSRIxCiTOs6xAnITyFgPyKmHwzSyIo,19221
-langchain_core/messages/block_translators/bedrock.py,sha256=I71rdoi6D0V4TPTMV4kU_wIEp6WybgBfXrLZkYnzo0Y,1527
-langchain_core/messages/block_translators/bedrock_converse.py,sha256=M2EhLQHmNGGHRJHCIzYWWktTQDIZhvlFDIl-6LrhpgA,1638
+langchain_core/messages/block_translators/anthropic.py,sha256=U6MQoNxexcCM_XhkbJ4KT_zNtlJgGPjpXSwWVJ2dBIU,19295
+langchain_core/messages/block_translators/bedrock.py,sha256=yLjYwtCsYGHBEj9CSXHCZYLmwsA4F6D6NTT5kE11Bww,3511
+langchain_core/messages/block_translators/bedrock_converse.py,sha256=iCdqDUJmwRPUiaKuVOh6vHB-YBdwHhDjY93B80iKyps,11465
 langchain_core/messages/block_translators/google_genai.py,sha256=C_ug4rlO93alzoH14FCsk6temXJZrTXoEx2_AfGfZhk,1571
 langchain_core/messages/block_translators/google_vertexai.py,sha256=spEuRU1tFsmQvIlHdrQgDswDP5XSQr0-5qgW8x47vXQ,1628
 langchain_core/messages/block_translators/groq.py,sha256=8Iw_HSZM00MZQTrvlZucxSJ2bbx9gvkxR-SU_mjuJk8,1499
@@ -177,5 +177,5 @@ langchain_core/vectorstores/__init__.py,sha256=5P0eoeoH5LHab64JjmEeWa6SxX4eMy-et
 langchain_core/vectorstores/base.py,sha256=nWlfzbkVdOObfbPpvfdLKHw9J0PryACVohHC_Y6wWZM,41529
 langchain_core/vectorstores/in_memory.py,sha256=ye4hGrj1ZlZsFHQx0Pbn_pvVAJ4F3ENLY74x4oU_FkY,18137
 langchain_core/vectorstores/utils.py,sha256=D6St53Xg1kO73dnw4MPd8vlkro4C3gmCpcghUzcepi0,4971
-langchain_core/version.py,sha256=A39mxvDADQ-V2kWGTQvaBcNYLKxxEZ79po6fYefkO6M,77
-langchain_core-1.0.0a3.dist-info/RECORD,,
+langchain_core/version.py,sha256=529yKwZZh0pt1x5uDsBqsAkZTXltHSchWQYxzAIlqkw,77
+langchain_core-1.0.0a4.dist-info/RECORD,,