models - unsupported content types (#144)

Author: pgrayy

src/strands/models/anthropic.py

@@ -4,7 +4,6 @@
 """
 
 import base64
-import json
 import logging
 import mimetypes
 from typing import Any, Iterable, Optional, TypedDict, cast
@@ -95,6 +94,9 @@ def _format_request_message_content(self, content: ContentBlock) -> dict[str, An
 
         Returns:
             Anthropic formatted content block.
+
+        Raises:
+            TypeError: If the content block type cannot be converted to an Anthropic-compatible format.
         """
         if "document" in content:
             mime_type = mimetypes.types_map.get(f".{content['document']['format']}", "application/octet-stream")
@@ -151,7 +153,7 @@ def _format_request_message_content(self, content: ContentBlock) -> dict[str, An
                 "type": "tool_result",
             }
 
-        return {"text": json.dumps(content), "type": "text"}
+        raise TypeError(f"content_type=<{next(iter(content))}> | unsupported type")
 
     def _format_request_messages(self, messages: Messages) -> list[dict[str, Any]]:
         """Format an Anthropic messages array.
@@ -192,6 +194,10 @@ def format_request(
 
         Returns:
             An Anthropic streaming request.
+
+        Raises:
+            TypeError: If a message contains a content block type that cannot be converted to an Anthropic-compatible
+                format.
         """
         return {
             "max_tokens": self.config["max_tokens"],

src/strands/models/litellm.py

@@ -76,6 +76,9 @@ def format_request_message_content(content: ContentBlock) -> dict[str, Any]:
 
         Returns:
             LiteLLM formatted content block.
+
+        Raises:
+            TypeError: If the content block type cannot be converted to a LiteLLM-compatible format.
         """
         if "reasoningContent" in content:
             return {

src/strands/models/llamaapi.py

@@ -92,6 +92,9 @@ def _format_request_message_content(self, content: ContentBlock) -> dict[str, An
 
         Returns:
             LllamaAPI formatted content block.
+
+        Raises:
+            TypeError: If the content block type cannot be converted to a LlamaAPI-compatible format.
         """
         if "image" in content:
             mime_type = mimetypes.types_map.get(f".{content['image']['format']}", "application/octet-stream")
@@ -107,7 +110,7 @@ def _format_request_message_content(self, content: ContentBlock) -> dict[str, An
         if "text" in content:
             return {"text": content["text"], "type": "text"}
 
-        return {"text": json.dumps(content), "type": "text"}
+        raise TypeError(f"content_type=<{next(iter(content))}> | unsupported type")
 
     def _format_request_message_tool_call(self, tool_use: ToolUse) -> dict[str, Any]:
         """Format a Llama API tool call.
@@ -196,6 +199,10 @@ def format_request(
 
         Returns:
             An Llama API chat streaming request.
+
+        Raises:
+            TypeError: If a message contains a content block type that cannot be converted to a LlamaAPI-compatible
+                format.
         """
         request = {
             "messages": self._format_request_messages(messages, system_prompt),

src/strands/models/ollama.py

@@ -105,6 +105,10 @@ def format_request(
 
         Returns:
             An Ollama chat streaming request.
+
+        Raises:
+            TypeError: If a message contains a content block type that cannot be converted to an Ollama-compatible
+                format.
         """
 
         def format_message(message: Message, content: ContentBlock) -> dict[str, Any]:
@@ -153,7 +157,7 @@ def format_message(message: Message, content: ContentBlock) -> dict[str, Any]:
                     **({"images": result_images} if result_images else {}),
                 }
 
-            return {"role": message["role"], "content": json.dumps(content)}
+            raise TypeError(f"content_type=<{next(iter(content))}> | unsupported type")
 
         def format_messages() -> list[dict[str, Any]]:
             return [format_message(message, content) for message in messages for content in message["content"]]

src/strands/types/models/openai.py

@@ -40,6 +40,9 @@ def format_request_message_content(content: ContentBlock) -> dict[str, Any]:
 
         Returns:
             OpenAI compatible content block.
+
+        Raises:
+            TypeError: If the content block type cannot be converted to an OpenAI-compatible format.
         """
         if "document" in content:
             mime_type = mimetypes.types_map.get(f".{content['document']['format']}", "application/octet-stream")
@@ -67,7 +70,7 @@ def format_request_message_content(content: ContentBlock) -> dict[str, Any]:
         if "text" in content:
             return {"text": content["text"], "type": "text"}
 
-        return {"text": json.dumps(content), "type": "text"}
+        raise TypeError(f"content_type=<{next(iter(content))}> | unsupported type")
 
     @staticmethod
     def format_request_message_tool_call(tool_use: ToolUse) -> dict[str, Any]:
@@ -163,6 +166,10 @@ def format_request(
 
         Returns:
             An OpenAI compatible chat streaming request.
+
+        Raises:
+            TypeError: If a message contains a content block type that cannot be converted to an OpenAI-compatible
+                format.
         """
         return {
             "messages": self.format_request_messages(messages, system_prompt),

tests/strands/models/test_anthropic.py

@@ -1,4 +1,3 @@
-import json
 import unittest.mock
 
 import anthropic
@@ -339,33 +338,16 @@ def test_format_request_with_tool_results(model, model_id, max_tokens):
     assert tru_request == exp_request
 
 
-def test_format_request_with_other(model, model_id, max_tokens):
+def test_format_request_with_unsupported_type(model):
     messages = [
         {
             "role": "user",
-            "content": [{"other": {"a": 1}}],
+            "content": [{"unsupported": {}}],
         },
     ]
 
-    tru_request = model.format_request(messages)
-    exp_request = {
-        "max_tokens": max_tokens,
-        "messages": [
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "text": json.dumps({"other": {"a": 1}}),
-                        "type": "text",
-                    },
-                ],
-            },
-        ],
-        "model": model_id,
-        "tools": [],
-    }
-
-    assert tru_request == exp_request
+    with pytest.raises(TypeError, match="content_type=<unsupported> | unsupported type"):
+        model.format_request(messages)
 
 
 def test_format_request_with_cache_point(model, model_id, max_tokens):

tests/strands/models/test_llamaapi.py

@@ -233,6 +233,18 @@ def test_format_request_with_empty_content(model, model_id):
     assert tru_request == exp_request
 
 
+def test_format_request_with_unsupported_type(model):
+    messages = [
+        {
+            "role": "user",
+            "content": [{"unsupported": {}}],
+        },
+    ]
+
+    with pytest.raises(TypeError, match="content_type=<unsupported> | unsupported type"):
+        model.format_request(messages)
+
+
 def test_format_chunk_message_start(model):
     event = {"chunk_type": "message_start"}
 

tests/strands/models/test_ollama.py

@@ -280,29 +280,16 @@ def test_format_request_with_tool_result_other(model, model_id):
     assert tru_request == exp_request
 
 
-def test_format_request_with_other(model, model_id):
+def test_format_request_with_unsupported_type(model):
     messages = [
         {
             "role": "user",
-            "content": [{"other": {"a": 1}}],
-        }
+            "content": [{"unsupported": {}}],
+        },
     ]
 
-    tru_request = model.format_request(messages)
-    exp_request = {
-        "messages": [
-            {
-                "role": "user",
-                "content": json.dumps({"other": {"a": 1}}),
-            }
-        ],
-        "model": model_id,
-        "options": {},
-        "stream": True,
-        "tools": [],
-    }
-
-    assert tru_request == exp_request
+    with pytest.raises(TypeError, match="content_type=<unsupported> | unsupported type"):
+        model.format_request(messages)
 
 
 def test_format_request_with_tool_specs(model, messages, model_id):

tests/strands/types/models/test_openai.py

@@ -101,21 +101,20 @@ def system_prompt():
             {"text": "hello"},
             {"type": "text", "text": "hello"},
         ),
-        # Other
-        (
-            {"other": {"a": 1}},
-            {
-                "text": json.dumps({"other": {"a": 1}}),
-                "type": "text",
-            },
-        ),
     ],
 )
 def test_format_request_message_content(content, exp_result):
     tru_result = SAOpenAIModel.format_request_message_content(content)
     assert tru_result == exp_result
 
 
+def test_format_request_message_content_unsupported_type():
+    content = {"unsupported": {}}
+
+    with pytest.raises(TypeError, match="content_type=<unsupported> | unsupported type"):
+        SAOpenAIModel.format_request_message_content(content)
+
+
 def test_format_request_message_tool_call():
     tool_use = {
         "input": {"expression": "2+2"},