Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -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."""

Expand Down Expand Up @@ -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.
Expand Down Expand Up @@ -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
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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."""
Expand Down