fix: dont save empty text messages (breaks Converse API) (#185)

Author: bergjaak

src/bedrock_agentcore/memory/integrations/strands/bedrock_converter.py

@@ -14,6 +14,13 @@
 class AgentCoreMemoryConverter:
     """Handles conversion between Strands and Bedrock AgentCore Memory formats."""
 
+    @staticmethod
+    def _filter_empty_text(message: dict) -> dict:
+        """The Bedrock Converse API can't take empty text as input. So we need to filter out empty text."""
+        content = message.get("content", [])
+        filtered_content = [item for item in content if "text" not in item or item.get("text", "").strip() != ""]
+        return {**message, "content": filtered_content}
+
     @staticmethod
     def message_to_payload(session_message: SessionMessage) -> list[Tuple[str, str]]:
         """Convert a SessionMessage to Bedrock AgentCore Memory message format.
@@ -23,9 +30,15 @@ def message_to_payload(session_message: SessionMessage) -> list[Tuple[str, str]]
 
         Returns:
             list[Tuple[str, str]]: list of (text, role) tuples for Bedrock AgentCore Memory.
+                Returns empty list if message has no content after filtering.
         """
+        filtered_message = AgentCoreMemoryConverter._filter_empty_text(session_message.message)
+        if not filtered_message.get("content"):
+            logger.debug("Skipping message with no content after filtering empty text")
+            return []
         session_dict = session_message.to_dict()
-        return [(json.dumps(session_dict), session_message.message["role"])]
+        session_dict["message"] = filtered_message
+        return [(json.dumps(session_dict), filtered_message["role"])]
 
     @staticmethod
     def events_to_messages(events: list[dict[str, Any]]) -> list[SessionMessage]:
@@ -61,13 +74,19 @@ def events_to_messages(events: list[dict[str, Any]]) -> list[SessionMessage]:
             for payload_item in event.get("payload", []):
                 if "conversational" in payload_item:
                     conv = payload_item["conversational"]
-                    messages.append(SessionMessage.from_dict(json.loads(conv["content"]["text"])))
+                    session_msg = SessionMessage.from_dict(json.loads(conv["content"]["text"]))
+                    session_msg.message = AgentCoreMemoryConverter._filter_empty_text(session_msg.message)
+                    if session_msg.message.get("content"):
+                        messages.append(session_msg)
                 elif "blob" in payload_item:
                     try:
                         blob_data = json.loads(payload_item["blob"])
                         if isinstance(blob_data, (tuple, list)) and len(blob_data) == 2:
                             try:
-                                messages.append(SessionMessage.from_dict(json.loads(blob_data[0])))
+                                session_msg = SessionMessage.from_dict(json.loads(blob_data[0]))
+                                session_msg.message = AgentCoreMemoryConverter._filter_empty_text(session_msg.message)
+                                if session_msg.message.get("content"):
+                                    messages.append(session_msg)
                             except (json.JSONDecodeError, ValueError):
                                 logger.error("This is not a SessionMessage but just a blob message. Ignoring")
                     except (json.JSONDecodeError, ValueError):

tests/bedrock_agentcore/memory/integrations/strands/test_bedrock_converter.py

@@ -96,3 +96,94 @@ def test_exceeds_conversational_limit_true(self):
         message = (long_text, long_text)
         result = AgentCoreMemoryConverter.exceeds_conversational_limit(message)
         assert result is True
+
+    def test_filter_empty_text_removes_empty_string(self):
+        """Test filtering removes empty text items."""
+        message = {"role": "user", "content": [{"text": ""}, {"text": "hello"}]}
+        result = AgentCoreMemoryConverter._filter_empty_text(message)
+        assert len(result["content"]) == 1
+        assert result["content"][0]["text"] == "hello"
+
+    def test_filter_empty_text_removes_whitespace_only(self):
+        """Test filtering removes whitespace-only text items."""
+        message = {"role": "user", "content": [{"text": "   "}, {"text": "hello"}]}
+        result = AgentCoreMemoryConverter._filter_empty_text(message)
+        assert len(result["content"]) == 1
+        assert result["content"][0]["text"] == "hello"
+
+    def test_filter_empty_text_keeps_non_text_items(self):
+        """Test filtering keeps non-text items like toolUse."""
+        message = {"role": "user", "content": [{"text": ""}, {"toolUse": {"name": "test"}}]}
+        result = AgentCoreMemoryConverter._filter_empty_text(message)
+        assert len(result["content"]) == 1
+        assert "toolUse" in result["content"][0]
+
+    def test_filter_empty_text_all_empty_returns_empty_content(self):
+        """Test filtering all empty text returns empty content array."""
+        message = {"role": "user", "content": [{"text": ""}]}
+        result = AgentCoreMemoryConverter._filter_empty_text(message)
+        assert result["content"] == []
+
+    def test_message_to_payload_skips_all_empty_text(self):
+        """Test message_to_payload returns empty list when all text is empty."""
+        message = SessionMessage(
+            message_id=1, message={"role": "user", "content": [{"text": ""}]}, created_at="2023-01-01T00:00:00Z"
+        )
+        result = AgentCoreMemoryConverter.message_to_payload(message)
+        assert result == []
+
+    def test_message_to_payload_filters_empty_text_items(self):
+        """Test message_to_payload filters out empty text but keeps valid content."""
+        message = SessionMessage(
+            message_id=1,
+            message={"role": "user", "content": [{"text": ""}, {"text": "hello"}]},
+            created_at="2023-01-01T00:00:00Z",
+        )
+        result = AgentCoreMemoryConverter.message_to_payload(message)
+        assert len(result) == 1
+        parsed = json.loads(result[0][0])
+        assert len(parsed["message"]["content"]) == 1
+        assert parsed["message"]["content"][0]["text"] == "hello"
+
+    def test_events_to_messages_filters_empty_text_conversational(self):
+        """Test events_to_messages filters empty text from conversational payloads."""
+        msg_with_empty = SessionMessage(
+            message_id=1,
+            message={"role": "user", "content": [{"text": ""}, {"text": "hello"}]},
+            created_at="2023-01-01T00:00:00Z",
+        )
+        events = [
+            {
+                "payload": [
+                    {"conversational": {"content": {"text": json.dumps(msg_with_empty.to_dict())}, "role": "USER"}}
+                ]
+            }
+        ]
+        result = AgentCoreMemoryConverter.events_to_messages(events)
+        assert len(result) == 1
+        assert len(result[0].message["content"]) == 1
+        assert result[0].message["content"][0]["text"] == "hello"
+
+    def test_events_to_messages_drops_all_empty_conversational(self):
+        """Test events_to_messages drops messages with only empty text."""
+        empty_msg = SessionMessage(
+            message_id=1, message={"role": "user", "content": [{"text": ""}]}, created_at="2023-01-01T00:00:00Z"
+        )
+        events = [
+            {"payload": [{"conversational": {"content": {"text": json.dumps(empty_msg.to_dict())}, "role": "USER"}}]}
+        ]
+        result = AgentCoreMemoryConverter.events_to_messages(events)
+        assert len(result) == 0
+
+    def test_events_to_messages_filters_empty_text_blob(self):
+        """Test events_to_messages filters empty text from blob payloads."""
+        msg_with_empty = SessionMessage(
+            message_id=1,
+            message={"role": "user", "content": [{"text": ""}, {"text": "hello"}]},
+            created_at="2023-01-01T00:00:00Z",
+        )
+        events = [{"payload": [{"blob": json.dumps([json.dumps(msg_with_empty.to_dict()), "user"])}]}]
+        result = AgentCoreMemoryConverter.events_to_messages(events)
+        assert len(result) == 1
+        assert len(result[0].message["content"]) == 1
+        assert result[0].message["content"][0]["text"] == "hello"