Merge remote-tracking branch 'origin/release-1.11.0' into fix/release-1.11.0-core-runtime-wheel-assert

Author: vjgit96

src/bundles/anthropic/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lfx-anthropic"
-version = "0.1.0"
+version = "0.1.1"
 description = "Anthropic component(s) as a standalone Langflow Extension Bundle."
 readme = "README.md"
 requires-python = ">=3.10,<3.15"

src/bundles/anthropic/src/lfx_anthropic/anthropic_chat_model.py

@@ -0,0 +1,31 @@
+"""Bundle-local ChatAnthropic compatibility wrapper.
+
+Keep this implementation inside ``lfx-anthropic`` so the standalone bundle
+continues to work with every LFX version admitted by its minor-line dependency
+floor. The LFX unified-model registry carries an equivalent wrapper for Agent
+model construction.
+"""
+
+from typing import Any
+
+from langchain_anthropic import ChatAnthropic
+
+
+def _ensure_thinking_field(payload: dict) -> None:
+    """Backfill `thinking` on thinking blocks serialized without it."""
+    for message in payload.get("messages", []):
+        content = message.get("content")
+        if not isinstance(content, list):
+            continue
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "thinking" and block.get("thinking") is None:
+                block["thinking"] = ""
+
+
+class ChatAnthropicThinkingCompat(ChatAnthropic):
+    """ChatAnthropic that normalizes thinking blocks in outgoing payloads."""
+
+    def _get_request_payload(self, *args: Any, **kwargs: Any) -> dict:
+        payload = super()._get_request_payload(*args, **kwargs)
+        _ensure_thinking_field(payload)
+        return payload

src/bundles/anthropic/src/lfx_anthropic/components/anthropic/anthropic.py

@@ -77,14 +77,14 @@ class AnthropicModelComponent(LCModelComponent):
 
     def build_model(self) -> LanguageModel:  # type: ignore[type-var]
         try:
-            from langchain_anthropic.chat_models import ChatAnthropic
+            from lfx_anthropic.anthropic_chat_model import ChatAnthropicThinkingCompat
         except ImportError as e:
             msg = "langchain_anthropic is not installed. Please install it with `pip install langchain_anthropic`."
             raise ImportError(msg) from e
         try:
             max_tokens_value = getattr(self, "max_tokens", "")
             max_tokens_value = 4096 if max_tokens_value == "" else int(max_tokens_value)
-            output = ChatAnthropic(
+            output = ChatAnthropicThinkingCompat(
                 model=self.model_name,
                 anthropic_api_key=self.api_key,
                 max_tokens=max_tokens_value,

src/bundles/anthropic/src/lfx_anthropic/extension.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schemas.langflow.org/extension/v1.json",
   "id": "lfx-anthropic",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "name": "Anthropic",
   "description": "Anthropic component(s) as a standalone Langflow Extension Bundle.",
   "lfx": {

src/bundles/anthropic/tests/test_anthropic_thinking_blocks.py

@@ -0,0 +1,98 @@
+"""Regression tests for Anthropic thinking-block compatibility in the bundle."""
+
+from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+from lfx_anthropic.anthropic_chat_model import ChatAnthropicThinkingCompat, _ensure_thinking_field
+from lfx_anthropic.components.anthropic.anthropic import AnthropicModelComponent
+
+
+def _malformed_history() -> list:
+    """Return a tool-use history whose thinking block is missing `thinking`."""
+    ai_message = AIMessage(
+        content=[
+            {"type": "thinking", "signature": "sig==", "index": 0},
+            {
+                "type": "tool_use",
+                "id": "toolu_01",
+                "name": "echo",
+                "input": {"text": "hello"},
+                "index": 1,
+            },
+        ],
+        tool_calls=[{"name": "echo", "args": {"text": "hello"}, "id": "toolu_01", "type": "tool_call"}],
+    )
+    return [
+        HumanMessage(content="Use the 'echo' tool to echo: hello"),
+        ai_message,
+        ToolMessage(content="hello", tool_call_id="toolu_01"),
+    ]
+
+
+def _thinking_blocks(payload: dict) -> list[dict]:
+    blocks = []
+    for message in payload.get("messages", []):
+        content = message.get("content")
+        if isinstance(content, list):
+            blocks.extend(block for block in content if isinstance(block, dict) and block.get("type") == "thinking")
+    return blocks
+
+
+def _build_model() -> ChatAnthropicThinkingCompat:
+    component = AnthropicModelComponent(
+        model_name="claude-sonnet-5",
+        api_key="test-key",  # pragma: allowlist secret
+        max_tokens=1024,
+        temperature=0.1,
+        base_url="https://api.anthropic.com",
+        stream=False,
+    )
+    return component.build_model()
+
+
+def test_component_builds_bundle_local_compat_class():
+    model = _build_model()
+
+    assert type(model) is ChatAnthropicThinkingCompat
+    blocks = _thinking_blocks(model._get_request_payload(_malformed_history()))
+    assert blocks
+    assert all(block.get("thinking") == "" for block in blocks)
+
+
+def test_payload_preserves_existing_thinking_text():
+    model = _build_model()
+    history = _malformed_history()
+    history[1].content[0] = {
+        "type": "thinking",
+        "thinking": "let me reason",
+        "signature": "sig==",
+        "index": 0,
+    }
+
+    blocks = _thinking_blocks(model._get_request_payload(history))
+
+    assert blocks
+    assert blocks[0]["thinking"] == "let me reason"
+
+
+def test_ensure_thinking_field_handles_missing_and_none():
+    payload = {
+        "messages": [
+            {
+                "role": "assistant",
+                "content": [
+                    {"type": "thinking", "signature": "a=="},
+                    {"type": "thinking", "thinking": None, "signature": "b=="},
+                    {"type": "thinking", "thinking": "kept", "signature": "c=="},
+                    {"type": "text", "text": "hi"},
+                ],
+            },
+            {"role": "user", "content": "plain string content"},
+        ]
+    }
+
+    _ensure_thinking_field(payload)
+
+    blocks = payload["messages"][0]["content"]
+    assert blocks[0]["thinking"] == ""
+    assert blocks[1]["thinking"] == ""
+    assert blocks[2]["thinking"] == "kept"
+    assert payload["messages"][1]["content"] == "plain string content"

src/lfx/pyproject.toml

@@ -128,6 +128,7 @@ dev = [
     "blockbuster>=1.5.25",
     "coverage>=7.9.2",
     "hypothesis>=6.136.3",
+    "langchain-anthropic~=1.4.6",
     "pytest>=9.0.3",
     "pytest-asyncio>=0.26.0",
     "pytest-cov>=7.0.0",

src/lfx/src/lfx/base/models/anthropic_chat_model.py

@@ -0,0 +1,33 @@
+"""ChatAnthropic subclass that keeps thinking blocks round-trippable.
+
+langchain-anthropic (<= 1.4.8) drops the empty `thinking` text while merging
+streamed chunks when the model omits thinking display (the default on
+claude-sonnet-5 and newer), so assistant turns that carried a thinking block
+are serialized back to the API without the required field and the follow-up
+request fails with HTTP 400 `thinking.thinking: Field required`, aborting the
+Agent turn with an empty final message.
+"""
+
+from typing import Any
+
+from langchain_anthropic import ChatAnthropic
+
+
+def _ensure_thinking_field(payload: dict) -> None:
+    """Backfill `thinking` on thinking blocks serialized without it."""
+    for message in payload.get("messages", []):
+        content = message.get("content")
+        if not isinstance(content, list):
+            continue
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "thinking" and block.get("thinking") is None:
+                block["thinking"] = ""
+
+
+class ChatAnthropicThinkingCompat(ChatAnthropic):
+    """ChatAnthropic that normalizes thinking blocks in outgoing payloads."""
+
+    def _get_request_payload(self, *args: Any, **kwargs: Any) -> dict:
+        payload = super()._get_request_payload(*args, **kwargs)
+        _ensure_thinking_field(payload)
+        return payload

src/lfx/src/lfx/base/models/unified_models/class_registry.py

@@ -16,7 +16,11 @@
 
 _MODEL_CLASS_IMPORTS: dict[str, tuple[str, str, str | None]] = {
     "ChatOpenAI": ("langchain_openai", "ChatOpenAI", None),
-    "ChatAnthropic": ("langchain_anthropic", "ChatAnthropic", None),
+    "ChatAnthropic": (
+        "lfx.base.models.anthropic_chat_model",
+        "ChatAnthropicThinkingCompat",
+        "langchain-anthropic",
+    ),
     "ChatGoogleGenerativeAIFixed": (
         "lfx.base.models.google_generative_ai_model",
         "ChatGoogleGenerativeAIFixed",

src/lfx/tests/unit/base/models/test_anthropic_chat_model.py

@@ -0,0 +1,98 @@
+"""Regression tests for Anthropic thinking-block compatibility in LFX."""
+
+from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+from lfx.base.models.anthropic_chat_model import ChatAnthropicThinkingCompat, _ensure_thinking_field
+from lfx.base.models.unified_models.class_registry import get_model_class
+
+
+def _malformed_history() -> list:
+    """Return a tool-use history whose thinking block is missing `thinking`."""
+    ai_message = AIMessage(
+        content=[
+            {"type": "thinking", "signature": "sig==", "index": 0},
+            {
+                "type": "tool_use",
+                "id": "toolu_01",
+                "name": "echo",
+                "input": {"text": "hello"},
+                "index": 1,
+            },
+        ],
+        tool_calls=[{"name": "echo", "args": {"text": "hello"}, "id": "toolu_01", "type": "tool_call"}],
+    )
+    return [
+        HumanMessage(content="Use the 'echo' tool to echo: hello"),
+        ai_message,
+        ToolMessage(content="hello", tool_call_id="toolu_01"),
+    ]
+
+
+def _thinking_blocks(payload: dict) -> list[dict]:
+    blocks = []
+    for message in payload.get("messages", []):
+        content = message.get("content")
+        if isinstance(content, list):
+            blocks.extend(block for block in content if isinstance(block, dict) and block.get("type") == "thinking")
+    return blocks
+
+
+def test_payload_thinking_blocks_always_carry_thinking_field():
+    model = ChatAnthropicThinkingCompat(
+        model="claude-sonnet-5",
+        api_key="test-key",  # pragma: allowlist secret
+        max_tokens=1024,
+    )
+
+    blocks = _thinking_blocks(model._get_request_payload(_malformed_history()))
+
+    assert blocks
+    assert all(block.get("thinking") == "" for block in blocks)
+
+
+def test_payload_preserves_existing_thinking_text():
+    model = ChatAnthropicThinkingCompat(
+        model="claude-sonnet-5",
+        api_key="test-key",  # pragma: allowlist secret
+        max_tokens=1024,
+    )
+    history = _malformed_history()
+    history[1].content[0] = {
+        "type": "thinking",
+        "thinking": "let me reason",
+        "signature": "sig==",
+        "index": 0,
+    }
+
+    blocks = _thinking_blocks(model._get_request_payload(history))
+
+    assert blocks
+    assert blocks[0]["thinking"] == "let me reason"
+
+
+def test_agent_registry_resolves_compat_class():
+    assert get_model_class("ChatAnthropic") is ChatAnthropicThinkingCompat
+
+
+def test_ensure_thinking_field_handles_missing_and_none():
+    payload = {
+        "messages": [
+            {
+                "role": "assistant",
+                "content": [
+                    {"type": "thinking", "signature": "a=="},
+                    {"type": "thinking", "thinking": None, "signature": "b=="},
+                    {"type": "thinking", "thinking": "kept", "signature": "c=="},
+                    {"type": "text", "text": "hi"},
+                ],
+            },
+            {"role": "user", "content": "plain string content"},
+        ]
+    }
+
+    _ensure_thinking_field(payload)
+
+    blocks = payload["messages"][0]["content"]
+    assert blocks[0]["thinking"] == ""
+    assert blocks[1]["thinking"] == ""
+    assert blocks[2]["thinking"] == "kept"
+    assert payload["messages"][1]["content"] == "plain string content"