From 9259dcbea6de0ad460070edd0c4345403b1a53e9 Mon Sep 17 00:00:00 2001 From: Abhiram Shaji Date: Fri, 20 Nov 2026 10:15:31 -0500 Subject: [PATCH 1/2] fix(memory): skip stored events that are not a SessionMessage on restore AgentCoreMemoryConverter.events_to_messages parsed every conversational payload as a SessionMessage with no guard, so one plain text event, or any JSON that is not a SessionMessage, raised inside list_messages and the restored agent started with an empty history. The blob branch had the same gap for non string entries and non object JSON. Both branches now go through one parser that returns None for anything that is not a SessionMessage with a Strands Message shape, and that one payload is skipped and logged while the rest of the history is restored. Thanks to @kimnamu for reproducing this on main, finding the 3, null and {"note": "x"} shapes the first suggested fix missed, and writing the parametrized test this change extends. Fixes #743 --- .../integrations/strands/bedrock_converter.py | 52 ++++++++++++++----- .../strands/test_bedrock_converter.py | 47 +++++++++++++++++ 2 files changed, 85 insertions(+), 14 deletions(-) diff --git a/src/bedrock_agentcore/memory/integrations/strands/bedrock_converter.py b/src/bedrock_agentcore/memory/integrations/strands/bedrock_converter.py index 90a26617..45ee922b 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): + except (TypeError, ValueError, RecursionError): logger.error("Failed to parse blob content: %s", payload_item) + 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..9e2d6f71 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,52 @@ 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_malformed_payload_does_not_break_batch(self, mock_logger): """Test a malformed blob payload between two valid conversational payloads in a single event.""" From 8da42717137a1abfeca29437276221493a577caa Mon Sep 17 00:00:00 2001 From: Abhiram Shaji Date: Fri, 20 Nov 2026 16:31:50 -0500 Subject: [PATCH 2/2] fix(memory): log only the event id when a blob payload fails to parse --- .../integrations/strands/bedrock_converter.py | 2 +- .../integrations/strands/test_bedrock_converter.py | 14 ++++++++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/src/bedrock_agentcore/memory/integrations/strands/bedrock_converter.py b/src/bedrock_agentcore/memory/integrations/strands/bedrock_converter.py index 45ee922b..3eb16dfd 100644 --- a/src/bedrock_agentcore/memory/integrations/strands/bedrock_converter.py +++ b/src/bedrock_agentcore/memory/integrations/strands/bedrock_converter.py @@ -104,7 +104,7 @@ def events_to_messages(events: list[dict[str, Any]]) -> list[SessionMessage]: try: blob_data = json.loads(payload_item["blob"]) except (TypeError, ValueError, RecursionError): - logger.error("Failed to parse blob content: %s", payload_item) + 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 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 9e2d6f71..7ae9fe97 100644 --- a/tests/bedrock_agentcore/memory/integrations/strands/test_bedrock_converter.py +++ b/tests/bedrock_agentcore/memory/integrations/strands/test_bedrock_converter.py @@ -390,6 +390,20 @@ def test_events_to_messages_blob_non_string_entry_does_not_break_batch(self, moc 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."""