[owl] Handle bedrock restriction on blank content (#924)

* Handle bedrock restriction on blank content

Author: haoshan98

.github/workflows/ci.yml

@@ -134,6 +134,7 @@ jobs:
           echo 'OWL_FLUSH_CLICKHOUSE_BUFFER_SEC=5' >> .env
         env:
           OWL_ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          OWL_BEDROCK_API_KEY: ${{ secrets.BEDROCK_API_KEY }}
           OWL_COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
           OWL_DEEPSEEK_API_KEY: ${{ secrets.DEEPSEEK_API_KEY }}
           OWL_ELLM_API_KEY: ${{ secrets.CUSTOM_API_KEY }}

services/api/src/owl/utils/lm.py

@@ -760,6 +760,35 @@ async def _get_deployment(
 
     ### --- Chat Completion --- ###
 
+    @staticmethod
+    def _prepare_bedrock_messages(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Replace empty string with a dot as Bedrock provider treats empty string as no content and throws error."""
+        messages = deepcopy(messages)
+        for message in messages:
+            content = message.get("content", None)
+            if isinstance(content, str):
+                if content.strip() == "":
+                    message["content"] = "."
+            elif isinstance(content, list):
+                if len(content) == 0:
+                    message["content"] = [{"type": "text", "text": "."}]
+                    continue
+                for part in content:
+                    if (
+                        isinstance(part, dict)
+                        and part.get("type") == "text"
+                        and (part.get("text", "") or "").strip() == ""
+                    ):
+                        part["text"] = "."
+        return messages
+
+    def _prepare_provider_specific_messages(
+        self, messages: list[dict], ctx: DeploymentContext
+    ) -> list[dict]:
+        if ctx.deployment.provider == CloudProvider.BEDROCK:
+            return self._prepare_bedrock_messages(messages)
+        return messages
+
     async def _prepare_chat(
         self,
         *,
@@ -1154,10 +1183,10 @@ async def _completion_stream(
             with attempt:
                 async with self._get_deployment(messages=messages, **hyperparams) as ctx:
                     self._prepare_hyperparams(ctx, hyperparams)
-                    # logger.warning(f"{hyperparams=}")
+                    prepared_messages = self._prepare_provider_specific_messages(messages, ctx)
                     if ctx.use_openai_responses:
                         async for chunk in self._openai_responses_stream(
-                            ctx, messages, **hyperparams
+                            ctx, prepared_messages, **hyperparams
                         ):
                             yield chunk
                     else:
@@ -1166,7 +1195,7 @@ async def _completion_stream(
                             api_key=ctx.api_key,
                             base_url=ctx.deployment.api_base or None,
                             model=ctx.routing_id,
-                            messages=messages,
+                            messages=prepared_messages,
                             stream=True,
                             stream_options={"include_usage": True},
                             **hyperparams,
@@ -1191,14 +1220,15 @@ async def _completion(
             with attempt:
                 async with self._get_deployment(messages=messages, **hyperparams) as ctx:
                     self._prepare_hyperparams(ctx, hyperparams)
+                    prepared_messages = self._prepare_provider_specific_messages(messages, ctx)
                     if ctx.use_openai_responses:
-                        return await self._openai_responses(ctx, messages, **hyperparams)
+                        return await self._openai_responses(ctx, prepared_messages, **hyperparams)
                     response = await acompletion(
                         timeout=self.config.timeout,
                         api_key=ctx.api_key,
                         base_url=ctx.deployment.api_base or None,
                         model=ctx.routing_id,
-                        messages=messages,
+                        messages=prepared_messages,
                         stream=False,
                         **hyperparams,
                     )

services/api/src/owl/utils/test.py

@@ -395,6 +395,20 @@ def setup_projects():
     context_length=1280000,
     languages=["en"],
 )
+BEDROCK_CLAUDE_HAIKU_CONFIG = ModelConfigCreate(
+    id="anthropic/claude-haiku-4-5-bedrock",
+    name="Bedrock Claude 4.5 Haiku",
+    type=ModelType.LLM,
+    capabilities=[
+        ModelCapability.CHAT,
+        ModelCapability.IMAGE,
+        ModelCapability.REASONING,
+        ModelCapability.TOOL,
+    ],
+    context_length=128000,
+    languages=["en"],
+    owned_by="anthropic",
+)
 ELLM_DESCRIBE_CONFIG = ModelConfigCreate(
     id="ellm/describe",
     name="Describe Message",
@@ -481,6 +495,13 @@ def setup_projects():
     routing_id=OPENAI_O4_MINI_CONFIG.id,
     api_base="",
 )
+BEDROCK_CLAUDE_HAIKU_DEPLOYMENT = DeploymentCreate(
+    model_id=BEDROCK_CLAUDE_HAIKU_CONFIG.id,
+    name=f"{BEDROCK_CLAUDE_HAIKU_CONFIG.name} Deployment",
+    provider=CloudProvider.BEDROCK,
+    routing_id="global.anthropic.claude-haiku-4-5-20251001-v1:0",
+    api_base="",
+)
 ELLM_DESCRIBE_DEPLOYMENT = DeploymentCreate(
     model_id=ELLM_DESCRIBE_CONFIG.id,
     name=f"{ELLM_DESCRIBE_CONFIG.name} Deployment",

services/api/tests/gen_table/test_row_ops.py

@@ -54,6 +54,8 @@
     ResourceNotFoundError,
 )
 from owl.utils.test import (
+    BEDROCK_CLAUDE_HAIKU_CONFIG,
+    BEDROCK_CLAUDE_HAIKU_DEPLOYMENT,
     ELLM_EMBEDDING_CONFIG,
     ELLM_EMBEDDING_DEPLOYMENT,
     GPT_4O_MINI_CONFIG,
@@ -146,6 +148,7 @@ def setup():
             create_model_config(GPT_4O_MINI_CONFIG),
             create_model_config(GPT_5_MINI_CONFIG),
             create_model_config(OPENAI_O4_MINI_CONFIG),
+            create_model_config(BEDROCK_CLAUDE_HAIKU_CONFIG),
             create_model_config(
                 {
                     # "id": "openai/Qwen/Qwen-2-Audio-7B",
@@ -166,6 +169,7 @@ def setup():
                 create_deployment(GPT_4O_MINI_DEPLOYMENT),
                 create_deployment(GPT_5_MINI_DEPLOYMENT),
                 create_deployment(OPENAI_O4_MINI_DEPLOYMENT),
+                create_deployment(BEDROCK_CLAUDE_HAIKU_DEPLOYMENT),
                 create_deployment(
                     DeploymentCreate(
                         model_id=llm_config_audio.id,
@@ -1761,6 +1765,60 @@ def test_chat_history_and_sequential_regen(
         assert "8" in output, output
 
 
+@pytest.mark.parametrize("table_type", TABLE_TYPES)
+@pytest.mark.parametrize("stream", **STREAM_PARAMS)
+def test_bedrock_multiturn_handle_blank_content(
+    setup: ServingContext,
+    table_type: TableType,
+    stream: bool,
+):
+    client = JamAI(user_id=setup.user_id, project_id=setup.project_id)
+    cols = [
+        ColumnSchemaCreate(id="input", dtype="str"),
+        ColumnSchemaCreate(
+            id="output",
+            dtype="str",
+            gen_config=LLMGenConfig(
+                system_prompt="You are a calculator.",
+                prompt="${input}",
+                multi_turn=True,
+                temperature=0.001,
+                top_p=0.001,
+                max_tokens=1050,  # higher than thinking.budget_tokens
+                model="anthropic/claude-haiku-4-5-bedrock",
+                reasoning_effort="low",
+            ),
+        ),
+    ]
+    with _create_table(client, table_type, cols=cols) as table:
+        assert isinstance(table, TableMetaResponse)
+        # Initialise chat thread and set output format
+        response = client.table.add_table_rows(
+            table_type,
+            MultiRowAddRequest(
+                table_id=table.id,
+                data=[
+                    dict(input="x = 0", output="0"),
+                    dict(input="Add 1", output=""),
+                    dict(input="Add 2", output=""),
+                    dict(input="Add 1", output="4"),
+                ],
+                stream=False,
+            ),
+        )
+        # Test adding one row
+        response = client.table.add_table_rows(
+            table_type,
+            MultiRowAddRequest(
+                table_id=table.id,
+                data=[dict(input="Add 1")],
+                stream=stream,
+            ),
+        )
+        output = _collect_text(response, "output")
+        assert "5" in output, output
+
+
 @pytest.mark.parametrize("table_type", TABLE_TYPES)
 @pytest.mark.parametrize("stream", **STREAM_PARAMS)
 def test_convert_into_multi_turn(

services/api/tests/utils/test_lm.py

@@ -159,6 +159,42 @@ def _make_vllm_context(*, is_reasoning_model: bool = True) -> DeploymentContext:
     )
 
 
+def test_prepare_bedrock_messages_should_replace_blank_content() -> None:
+    messages = [
+        {"role": "system", "content": ""},
+        {"role": "user", "content": "  "},
+        {"role": "assistant", "content": ""},
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": ""},
+                {"type": "image_url", "image_url": {"url": "data:image/png;base64,abc"}},
+            ],
+        },
+        {"role": "user", "content": []},
+        {"role": "assistant", "content": "ok"},
+    ]
+
+    prepared = DeploymentRouter._prepare_bedrock_messages(messages)
+
+    assert prepared == [
+        {"role": "system", "content": "."},
+        {"role": "user", "content": "."},
+        {"role": "assistant", "content": "."},
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": "."},
+                {"type": "image_url", "image_url": {"url": "data:image/png;base64,abc"}},
+            ],
+        },
+        {"role": "user", "content": [{"type": "text", "text": "."}]},
+        {"role": "assistant", "content": "ok"},
+    ]
+    assert messages[0]["content"] == ""
+    assert messages[3]["content"][0]["text"] == ""
+
+
 def test_inference_provider_should_prefer_vllm_cloud_over_owned_by() -> None:
     router = _make_router()