langchain-core 0.3.70__tar.gz → 0.3.71__tar.gz

{langchain_core-0.3.70 → langchain_core-0.3.71}/PKG-INFO

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

@@ -111,8 +111,9 @@ def _generate_response_from_error(error: BaseException) -> list[ChatGeneration]:
 def _format_for_tracing(messages: list[BaseMessage]) -> list[BaseMessage]:
     """Format messages for tracing in on_chat_model_start.
 
-    For backward compatibility, we update image content blocks to OpenAI Chat
-    Completions format.
+    - Update image content blocks to OpenAI Chat Completions format (backward
+    compatibility).
+    - Add "type" key to content blocks that have a single key.
 
     Args:
         messages: List of messages to format.
@@ -125,20 +126,36 @@ def _format_for_tracing(messages: list[BaseMessage]) -> list[BaseMessage]:
         message_to_trace = message
         if isinstance(message.content, list):
             for idx, block in enumerate(message.content):
-                if (
-                    isinstance(block, dict)
-                    and block.get("type") == "image"
-                    and is_data_content_block(block)
-                    and block.get("source_type") != "id"
-                ):
-                    if message_to_trace is message:
-                        message_to_trace = message.model_copy()
-                        # Also shallow-copy content
-                        message_to_trace.content = list(message_to_trace.content)
-
-                    message_to_trace.content[idx] = (  # type: ignore[index]  # mypy confused by .model_copy
-                        convert_to_openai_image_block(block)
-                    )
+                if isinstance(block, dict):
+                    # Update image content blocks to OpenAI # Chat Completions format.
+                    if (
+                        block.get("type") == "image"
+                        and is_data_content_block(block)
+                        and block.get("source_type") != "id"
+                    ):
+                        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] = (  # type: ignore[index]  # mypy confused by .model_copy
+                            convert_to_openai_image_block(block)
+                        )
+                    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
+                        # choice for the type (e.g., a single key in the block).
+                        if message_to_trace is message:
+                            # Shallow copy
+                            message_to_trace = message.model_copy()
+                            message_to_trace.content = list(message_to_trace.content)
+                        key = next(iter(block))
+                        message_to_trace.content[idx] = {  # type: ignore[index]
+                            "type": key,
+                            key: block[key],
+                        }
+                    else:
+                        pass
         messages_to_trace.append(message_to_trace)
 
     return messages_to_trace

{langchain_core-0.3.70 → langchain_core-0.3.71}/langchain_core/runnables/config.py

@@ -230,6 +230,7 @@ def ensure_config(config: Optional[RunnableConfig] = None) -> RunnableConfig:
             not key.startswith("__")
             and isinstance(value, (str, int, float, bool))
             and key not in empty["metadata"]
+            and key != "api_key"
         ):
             empty["metadata"][key] = value
     return empty

{langchain_core-0.3.70 → langchain_core-0.3.71}/langchain_core/utils/__init__.py

@@ -23,7 +23,12 @@ if TYPE_CHECKING:
     from langchain_core.utils.iter import batch_iterate
     from langchain_core.utils.loading import try_load_from_hub
     from langchain_core.utils.pydantic import pre_init
-    from langchain_core.utils.strings import comma_list, stringify_dict, stringify_value
+    from langchain_core.utils.strings import (
+        comma_list,
+        sanitize_for_postgres,
+        stringify_dict,
+        stringify_value,
+    )
     from langchain_core.utils.utils import (
         build_extra_kwargs,
         check_package_version,
@@ -59,6 +64,7 @@ __all__ = (
     "pre_init",
     "print_text",
     "raise_for_status_with_text",
+    "sanitize_for_postgres",
     "secret_from_env",
     "stringify_dict",
     "stringify_value",
@@ -81,6 +87,7 @@ _dynamic_imports = {
     "try_load_from_hub": "loading",
     "pre_init": "pydantic",
     "comma_list": "strings",
+    "sanitize_for_postgres": "strings",
     "stringify_dict": "strings",
     "stringify_value": "strings",
     "build_extra_kwargs": "utils",

{langchain_core-0.3.70 → langchain_core-0.3.71}/langchain_core/utils/strings.py

@@ -46,3 +46,26 @@ def comma_list(items: list[Any]) -> str:
         str: The comma-separated string.
     """
     return ", ".join(str(item) for item in items)
+
+
+def sanitize_for_postgres(text: str, replacement: str = "") -> str:
+    r"""Sanitize text by removing NUL bytes that are incompatible with PostgreSQL.
+
+    PostgreSQL text fields cannot contain NUL (0x00) bytes, which can cause
+    psycopg.DataError when inserting documents. This function removes or replaces
+    such characters to ensure compatibility.
+
+    Args:
+        text: The text to sanitize.
+        replacement: String to replace NUL bytes with. Defaults to empty string.
+
+    Returns:
+        str: The sanitized text with NUL bytes removed or replaced.
+
+    Example:
+        >>> sanitize_for_postgres("Hello\\x00world")
+        'Helloworld'
+        >>> sanitize_for_postgres("Hello\\x00world", " ")
+        'Hello world'
+    """
+    return text.replace("\x00", replacement)

{langchain_core-0.3.70 → langchain_core-0.3.71}/langchain_core/version.py

@@ -1,3 +1,3 @@
 """langchain-core version information and utilities."""
 
-VERSION = "0.3.70"
+VERSION = "0.3.71"

{langchain_core-0.3.70 → langchain_core-0.3.71}/pyproject.toml

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

{langchain_core-0.3.70 → langchain_core-0.3.71}/tests/unit_tests/language_models/chat_models/test_base.py

@@ -467,6 +467,55 @@ def test_trace_images_in_openai_format() -> None:
     ]
 
 
+def test_trace_content_blocks_with_no_type_key() -> None:
+    """Test that we add a ``type`` key to certain content blocks that don't have one."""
+    llm = ParrotFakeChatModel()
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "Hello",
+                },
+                {
+                    "cachePoint": {"type": "default"},
+                },
+            ],
+        }
+    ]
+    tracer = FakeChatModelStartTracer()
+    response = llm.invoke(messages, config={"callbacks": [tracer]})
+    assert tracer.messages == [
+        [
+            [
+                HumanMessage(
+                    [
+                        {
+                            "type": "text",
+                            "text": "Hello",
+                        },
+                        {
+                            "type": "cachePoint",
+                            "cachePoint": {"type": "default"},
+                        },
+                    ]
+                )
+            ]
+        ]
+    ]
+    # Test no mutation
+    assert response.content == [
+        {
+            "type": "text",
+            "text": "Hello",
+        },
+        {
+            "cachePoint": {"type": "default"},
+        },
+    ]
+
+
 def test_extend_support_to_openai_multimodal_formats() -> None:
     """Test that chat models normalize OpenAI file and audio inputs."""
     llm = ParrotFakeChatModel()

{langchain_core-0.3.70 → langchain_core-0.3.71}/tests/unit_tests/utils/test_imports.py

@@ -27,6 +27,7 @@ EXPECTED_ALL = [
     "pre_init",
     "from_env",
     "secret_from_env",
+    "sanitize_for_postgres",
 ]
 
 

langchain_core-0.3.71/tests/unit_tests/utils/test_strings.py

@@ -0,0 +1,49 @@
+"""Test string utilities."""
+
+from langchain_core.utils.strings import (
+    comma_list,
+    sanitize_for_postgres,
+    stringify_dict,
+    stringify_value,
+)
+
+
+def test_sanitize_for_postgres() -> None:
+    """Test sanitizing text for PostgreSQL compatibility."""
+    # Test with NUL bytes
+    text_with_nul = "Hello\x00world\x00test"
+    expected = "Helloworldtest"
+    assert sanitize_for_postgres(text_with_nul) == expected
+
+    # Test with replacement character
+    expected_with_replacement = "Hello world test"
+    assert sanitize_for_postgres(text_with_nul, " ") == expected_with_replacement
+
+    # Test with text without NUL bytes
+    clean_text = "Hello world"
+    assert sanitize_for_postgres(clean_text) == clean_text
+
+    # Test empty string
+    assert sanitize_for_postgres("") == ""
+
+    # Test with multiple consecutive NUL bytes
+    text_with_multiple_nuls = "Hello\x00\x00\x00world"
+    assert sanitize_for_postgres(text_with_multiple_nuls) == "Helloworld"
+    assert sanitize_for_postgres(text_with_multiple_nuls, "-") == "Hello---world"
+
+
+def test_existing_string_functions() -> None:
+    """Test existing string functions still work."""
+    # Test comma_list
+    assert comma_list([1, 2, 3]) == "1, 2, 3"
+    assert comma_list(["a", "b", "c"]) == "a, b, c"
+
+    # Test stringify_value
+    assert stringify_value("hello") == "hello"
+    assert stringify_value(42) == "42"
+
+    # Test stringify_dict
+    data = {"key": "value", "number": 123}
+    result = stringify_dict(data)
+    assert "key: value" in result
+    assert "number: 123" in result