Support injectable message converter in AgentCoreMemorySessionManager

[afarntrog]

Is your feature request related to a problem? Please describe.
The AgentCoreMemorySessionManager currently uses a hardcoded AgentCoreMemoryConverter for converting between Strands SessionMessage format and Bedrock AgentCore Memory event format. This creates an interoperability gap when users have messages stored in STM using non-Bedrock formats (e.g., OpenAI format).

Current behavior:

• Users can store messages in STM in any format (as long as it adheres to the STM payload structure)
• When using AgentCoreMemorySessionManager with pre-existing OpenAI-formatted messages, list_messages() fails because AgentCoreMemoryConverter.events_to_messages() expects Bedrock Converse format

Current hardcoded usage in session_manager.py:

messages = AgentCoreMemoryConverter.message_to_payload(session_message)  # line ~290
# ...
messages = AgentCoreMemoryConverter.events_to_messages(events)  # line ~350

Describe the solution you'd like

Proposed Solution

Make the converter injectable into AgentCoreMemorySessionManager to support multiple message formats.

1. Define a Converter Protocol

from typing import Protocol

class MemoryConverter(Protocol):
    """Protocol for converting between Strands messages and STM event payloads."""
    
    @staticmethod
    def message_to_payload(session_message: SessionMessage) -> list[tuple[str, str]]:
        """Convert SessionMessage to STM event payload format."""
        ...
    
    @staticmethod
    def events_to_messages(events: list[dict[str, Any]]) -> list[SessionMessage]:
        """Convert STM events to SessionMessages."""
        ...
    
    @staticmethod
    def exceeds_conversational_limit(message: tuple[str, str]) -> bool:
        """Check if message exceeds conversational payload size limit."""
        ...

2. Update AgentCoreMemorySessionManager Constructor

def __init__(
    self,
    agentcore_memory_config: AgentCoreMemoryConfig,
    converter: Optional[Type[MemoryConverter]] = None,  # NEW PARAMETER
    region_name: Optional[str] = None,
    boto_session: Optional[boto3.Session] = None,
    boto_client_config: Optional[BotocoreConfig] = None,
    **kwargs: Any,
):
    self.converter = converter or AgentCoreMemoryConverter  # Default to current behavior
    # ...

3. Replace Hardcoded Converter Usage

# In create_message():
messages = self.converter.message_to_payload(session_message)

# In list_messages():
messages = self.converter.events_to_messages(events)

Use Cases

1. Default (Bedrock): Users using Strands with Bedrock models continue to work as-is
2. OpenAI Integration: Users can provide an OpenAIConverter that transforms OpenAI messages ↔ Strands format
3. Custom Formats: Users can implement their own converters for proprietary formats

Example Usage

from bedrock_agentcore.memory.integrations.strands import (
    AgentCoreMemorySessionManager,
    AgentCoreMemoryConfig,
)
from my_app.converters import OpenAIConverter

session_manager = AgentCoreMemorySessionManager(
    agentcore_memory_config=config,
    converter=OpenAIConverter,  # Custom converter
)

Describe alternatives you've considered

Workaround (Until This Feature is Implemented)

Users can subclass AgentCoreMemorySessionManager and override create_message() and list_messages() methods to use a custom converter.

Additional context
Add any other context or screenshots about the feature request here.