diff --git a/src/bedrock_agentcore/memory/integrations/strands/bedrock_converter.py b/src/bedrock_agentcore/memory/integrations/strands/bedrock_converter.py index 90a26617..3eb16dfd 100644 --- a/src/bedrock_agentcore/memory/integrations/strands/bedrock_converter.py +++ b/src/bedrock_agentcore/memory/integrations/strands/bedrock_converter.py @@ -13,6 +13,15 @@ CONVERSATIONAL_MAX_SIZE = 100000 +def _is_message(value: Any) -> bool: + if not isinstance(value, dict) or value.get("role") not in ("user", "assistant"): + return False + content = value.get("content") + return isinstance(content, list) and all( + isinstance(block, dict) and isinstance(block.get("text", ""), str) for block in content + ) + + class AgentCoreMemoryConverter: """Handles conversion between Strands and Bedrock AgentCore Memory formats.""" @@ -44,6 +53,19 @@ def message_to_payload(session_message: SessionMessage) -> list[Tuple[str, str]] session_dict["message"] = filtered_message return [(json.dumps(session_dict), filtered_message["role"])] + @staticmethod + def _parse_session_message(text: Any) -> SessionMessage | None: + try: + data = json.loads(text) + session_msg = SessionMessage.from_dict(data) if isinstance(data, dict) else None + except (TypeError, ValueError, RecursionError): + return None + if session_msg is None or not _is_message(session_msg.message): + return None + if session_msg.redact_message is not None and not _is_message(session_msg.redact_message): + return None + return session_msg + @staticmethod def events_to_messages(events: list[dict[str, Any]]) -> list[SessionMessage]: """Convert Bedrock AgentCore Memory events to SessionMessages. @@ -77,24 +99,26 @@ def events_to_messages(events: list[dict[str, Any]]) -> list[SessionMessage]: for event in reversed(events): for payload_item in event.get("payload", []): if "conversational" in payload_item: - conv = payload_item["conversational"] - 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) + text = payload_item["conversational"].get("content", {}).get("text") 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: - 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): - logger.error("Failed to parse blob content: %s", payload_item) + except (TypeError, ValueError, RecursionError): + logger.error("Failed to parse blob content in event %s", event.get("eventId")) + continue + if not (isinstance(blob_data, list) and len(blob_data) == 2): + continue + text = blob_data[0] + else: + continue + + session_msg = AgentCoreMemoryConverter._parse_session_message(text) + if session_msg is None: + logger.error("Skipping a payload that is not a SessionMessage in event %s", event.get("eventId")) + continue + session_msg.message = AgentCoreMemoryConverter._filter_empty_text(session_msg.message) + if session_msg.message.get("content"): + messages.append(session_msg) return messages @staticmethod diff --git a/tests/bedrock_agentcore/memory/integrations/strands/test_bedrock_converter.py b/tests/bedrock_agentcore/memory/integrations/strands/test_bedrock_converter.py index a1f66bd8..7ae9fe97 100644 --- a/tests/bedrock_agentcore/memory/integrations/strands/test_bedrock_converter.py +++ b/tests/bedrock_agentcore/memory/integrations/strands/test_bedrock_converter.py @@ -3,6 +3,7 @@ import json from unittest.mock import patch +import pytest from strands.types.session import SessionMessage from bedrock_agentcore.memory.integrations.strands.bedrock_converter import AgentCoreMemoryConverter @@ -343,6 +344,66 @@ def test_events_to_messages_mixed_blob_and_conversational_ordering(self): assert result[0].message["content"][0]["text"] == "First" assert result[1].message["content"][0]["text"] == "Second" + @pytest.mark.parametrize( + "text", + [ + "I prefer window seats", + "3", + "null", + "[]", + '{"note": "x"}', + '{"role": "user", "content": "hi"}', + '{"message": "hi", "message_id": 0}', + '{"message": {"role": "user", "content": "hi"}, "message_id": 0}', + '{"message": {"role": "user", "content": ["hi"]}, "message_id": 0}', + '{"message": {"role": "user", "content": [{"text": 5}]}, "message_id": 0}', + '{"message": {"role": "system", "content": [{"text": "hi"}]}, "message_id": 0}', + '{"message": {"content": [{"text": "hi"}]}, "message_id": 0}', + '{"message": {"role": "user", "content": [{"text": "hi"}]}, "message_id": 0, "redact_message": "x"}', + '{"message": {"role": "user", "content": [{"image": {"__bytes_encoded__": true, "data": "a"}}]},' + ' "message_id": 0}', + pytest.param("[" * 50000 + "]" * 50000, id="deep-nesting"), + ], + ) + @pytest.mark.parametrize("wrap", ["conversational", "blob"]) + @patch("bedrock_agentcore.memory.integrations.strands.bedrock_converter.logger") + def test_events_to_messages_non_session_message_does_not_break_batch(self, mock_logger, wrap, text): + msg = SessionMessage(message_id=1, message={"role": "user", "content": [{"text": "msg1"}]}) + valid = {"conversational": {"content": {"text": json.dumps(msg.to_dict())}, "role": "USER"}} + if wrap == "conversational": + other = {"conversational": {"content": {"text": text}, "role": "USER"}} + else: + other = {"blob": json.dumps([text, "user"])} + + result = AgentCoreMemoryConverter.events_to_messages([{"payload": [other, valid]}]) + + assert [m.message["content"][0]["text"] for m in result] == ["msg1"] + mock_logger.error.assert_called() + + @patch("bedrock_agentcore.memory.integrations.strands.bedrock_converter.logger") + def test_events_to_messages_blob_non_string_entry_does_not_break_batch(self, mock_logger): + msg = SessionMessage(message_id=1, message={"role": "user", "content": [{"text": "msg1"}]}) + valid = {"conversational": {"content": {"text": json.dumps(msg.to_dict())}, "role": "USER"}} + + result = AgentCoreMemoryConverter.events_to_messages([{"payload": [{"blob": "[3, 4]"}, valid]}]) + + assert [m.message["content"][0]["text"] for m in result] == ["msg1"] + mock_logger.error.assert_called() + + @patch("bedrock_agentcore.memory.integrations.strands.bedrock_converter.logger") + def test_events_to_messages_unparseable_blob_does_not_log_content(self, mock_logger): + events = [ + {"eventId": "evt-1", "payload": [{"blob": {"secret": "do-not-log"}}]}, + {"eventId": "evt-2", "payload": [{"blob": "do-not-log"}]}, + ] + + result = AgentCoreMemoryConverter.events_to_messages(events) + + assert result == [] + assert mock_logger.error.call_count == 2 + assert "do-not-log" not in str(mock_logger.error.call_args_list) + assert {c.args[-1] for c in mock_logger.error.call_args_list} == {"evt-1", "evt-2"} + @patch("bedrock_agentcore.memory.integrations.strands.bedrock_converter.logger") def test_events_to_messages_malformed_payload_does_not_break_batch(self, mock_logger): """Test a malformed blob payload between two valid conversational payloads in a single event."""