feat: remove sessionType, combine session creation branches

Author: JackYPCOnline

src/strands/session/file_session_manager.py

@@ -9,7 +9,7 @@
 
 from .. import _identifier
 from ..types.exceptions import SessionException
-from ..types.session import Session, SessionAgent, SessionMessage, SessionType
+from ..types.session import Session, SessionAgent, SessionMessage
 from .repository_session_manager import RepositorySessionManager
 from .session_repository import SessionRepository
 
@@ -45,8 +45,6 @@ def __init__(
         self,
         session_id: str,
         storage_dir: Optional[str] = None,
-        *,
-        session_type: SessionType = SessionType.AGENT,
         **kwargs: Any,
     ):
         """Initialize FileSession with filesystem storage.
@@ -55,13 +53,12 @@ def __init__(
             session_id: ID for the session.
                 ID is not allowed to contain path separators (e.g., a/b).
             storage_dir: Directory for local filesystem storage (defaults to temp dir).
-            session_type: single agent or multiagent.
             **kwargs: Additional keyword arguments for future extensibility.
         """
         self.storage_dir = storage_dir or os.path.join(tempfile.gettempdir(), "strands/sessions")
         os.makedirs(self.storage_dir, exist_ok=True)
 
-        super().__init__(session_id=session_id, session_repository=self, session_type=session_type)
+        super().__init__(session_id=session_id, session_repository=self)
 
     def _get_session_path(self, session_id: str) -> str:
         """Get session directory path.
@@ -133,10 +130,9 @@ def create_session(self, session: Session, **kwargs: Any) -> Session:
 
         # Create directory structure
         os.makedirs(session_dir, exist_ok=True)
-        if self.session_type == SessionType.AGENT:
-            os.makedirs(os.path.join(session_dir, "agents"), exist_ok=True)
-        else:
-            os.makedirs(os.path.join(session_dir, "multi_agents"), exist_ok=True)
+        os.makedirs(os.path.join(session_dir, "agents"), exist_ok=True)
+        os.makedirs(os.path.join(session_dir, "multi_agents"), exist_ok=True)
+
         # Write session file
         session_file = os.path.join(session_dir, "session.json")
         session_dict = session.to_dict()

src/strands/session/repository_session_manager.py

@@ -29,8 +29,6 @@ def __init__(
         self,
         session_id: str,
         session_repository: SessionRepository,
-        *,
-        session_type: SessionType = SessionType.AGENT,
         **kwargs: Any,
     ):
         """Initialize the RepositorySessionManager.
@@ -42,27 +40,22 @@ def __init__(
             session_id: ID to use for the session. A new session with this id will be created if it does
                 not exist in the repository yet
             session_repository: Underlying session repository to use to store the sessions state.
-            session_type: single agent or multiagent.
             **kwargs: Additional keyword arguments for future extensibility.
 
         """
-        super().__init__(session_type=session_type)
-
         self.session_repository = session_repository
         self.session_id = session_id
         session = session_repository.read_session(session_id)
         # Create a session if it does not exist yet
         if session is None:
             logger.debug("session_id=<%s> | session not found, creating new session", self.session_id)
-            session = Session(session_id=session_id, session_type=session_type)
+            session = Session(session_id=session_id, session_type=SessionType.AGENT)
             session_repository.create_session(session)
 
         self.session = session
-        self.session_type = session.session_type
 
         # Keep track of the latest message of each agent in case we need to redact it.
-        if self.session_type == SessionType.AGENT:
-            self._latest_agent_message: dict[str, Optional[SessionMessage]] = {}
+        self._latest_agent_message: dict[str, Optional[SessionMessage]] = {}
 
     def append_message(self, message: Message, agent: "Agent", **kwargs: Any) -> None:
         """Append a message to the agent's session.

src/strands/session/s3_session_manager.py

@@ -10,7 +10,7 @@
 
 from .. import _identifier
 from ..types.exceptions import SessionException
-from ..types.session import Session, SessionAgent, SessionMessage, SessionType
+from ..types.session import Session, SessionAgent, SessionMessage
 from .repository_session_manager import RepositorySessionManager
 from .session_repository import SessionRepository
 
@@ -50,8 +50,6 @@ def __init__(
         boto_session: Optional[boto3.Session] = None,
         boto_client_config: Optional[BotocoreConfig] = None,
         region_name: Optional[str] = None,
-        *,
-        session_type: SessionType = SessionType.AGENT,
         **kwargs: Any,
     ):
         """Initialize S3SessionManager with S3 storage.
@@ -64,7 +62,6 @@ def __init__(
             boto_session: Optional boto3 session
             boto_client_config: Optional boto3 client configuration
             region_name: AWS region for S3 storage
-            session_type: single agent or multiagent.
             **kwargs: Additional keyword arguments for future extensibility.
         """
         self.bucket = bucket
@@ -85,7 +82,7 @@ def __init__(
             client_config = BotocoreConfig(user_agent_extra="strands-agents")
 
         self.client = session.client(service_name="s3", config=client_config)
-        super().__init__(session_id=session_id, session_type=session_type, session_repository=self)
+        super().__init__(session_id=session_id, session_repository=self)
 
     def _get_session_path(self, session_id: str) -> str:
         """Get session S3 prefix.

src/strands/session/session_manager.py

@@ -12,7 +12,6 @@
 from ..hooks.events import AfterInvocationEvent, AgentInitializedEvent, MessageAddedEvent
 from ..hooks.registry import HookProvider, HookRegistry
 from ..types.content import Message
-from ..types.session import SessionType
 
 if TYPE_CHECKING:
     from ..agent.agent import Agent
@@ -30,37 +29,23 @@ class SessionManager(HookProvider, ABC):
     for an agent, and should be persisted in the session.
     """
 
-    def __init__(self, session_type: SessionType = SessionType.AGENT) -> None:
-        """Initialize SessionManager with session type.
-
-        Args:
-            session_type: Type of session (AGENT or MULTI_AGENT)
-        """
-        self.session_type: SessionType = session_type
-
     def register_hooks(self, registry: HookRegistry, **kwargs: Any) -> None:
         """Register hooks for persisting the agent to the session."""
-        if not hasattr(self, "session_type"):
-            self.session_type = SessionType.AGENT
-            logger.debug("Session type not set, defaulting to AGENT")
-
-        if self.session_type == SessionType.MULTI_AGENT:
-            registry.add_callback(MultiAgentInitializedEvent, lambda event: self.initialize_multi_agent(event.source))
-            registry.add_callback(AfterNodeCallEvent, lambda event: self.sync_multi_agent(event.source))
-            registry.add_callback(AfterMultiAgentInvocationEvent, lambda event: self.sync_multi_agent(event.source))
+        # After the normal Agent initialization behavior, call the session initialize function to restore the agent
+        registry.add_callback(AgentInitializedEvent, lambda event: self.initialize(event.agent))
 
-        else:
-            # After the normal Agent initialization behavior, call the session initialize function to restore the agent
-            registry.add_callback(AgentInitializedEvent, lambda event: self.initialize(event.agent))
+        # For each message appended to the Agents messages, store that message in the session
+        registry.add_callback(MessageAddedEvent, lambda event: self.append_message(event.message, event.agent))
 
-            # For each message appended to the Agents messages, store that message in the session
-            registry.add_callback(MessageAddedEvent, lambda event: self.append_message(event.message, event.agent))
+        # Sync the agent into the session for each message in case the agent state was updated
+        registry.add_callback(MessageAddedEvent, lambda event: self.sync_agent(event.agent))
 
-            # Sync the agent into the session for each message in case the agent state was updated
-            registry.add_callback(MessageAddedEvent, lambda event: self.sync_agent(event.agent))
+        # After an agent was invoked, sync it with the session to capture any conversation manager state updates
+        registry.add_callback(AfterInvocationEvent, lambda event: self.sync_agent(event.agent))
 
-            # After an agent was invoked, sync it with the session to capture any conversation manager state updates
-            registry.add_callback(AfterInvocationEvent, lambda event: self.sync_agent(event.agent))
+        registry.add_callback(MultiAgentInitializedEvent, lambda event: self.initialize_multi_agent(event.source))
+        registry.add_callback(AfterNodeCallEvent, lambda event: self.sync_multi_agent(event.source))
+        registry.add_callback(AfterMultiAgentInvocationEvent, lambda event: self.sync_multi_agent(event.source))
 
     @abstractmethod
     def redact_latest_message(self, redact_message: Message, agent: "Agent", **kwargs: Any) -> None:

src/strands/types/session.py

@@ -17,12 +17,11 @@
 class SessionType(str, Enum):
     """Enumeration of session types.
 
-    As sessions are expanded to support new usecases like multi-agent patterns,
+    As sessions are expanded to support new use cases like multi-agent patterns,
     new types will be added here.
     """
 
     AGENT = "AGENT"
-    MULTI_AGENT = "MULTI_AGENT"
 
 
 def encode_bytes_values(obj: Any) -> Any:

tests/strands/session/test_file_session_manager.py

@@ -63,16 +63,10 @@ def mock_multi_agent():
     return mock
 
 
-@pytest.fixture
-def multi_agent_session():
-    """Create sample multi-agent session for testing."""
-    return Session(session_id="test-session", session_type=SessionType.MULTI_AGENT)
-
-
 @pytest.fixture
 def multi_agent_manager(temp_dir):
-    """Create FileSessionManager with multi-agent session type."""
-    return FileSessionManager(session_id="test", storage_dir=temp_dir, session_type=SessionType.MULTI_AGENT)
+    """Create FileSessionManager."""
+    return FileSessionManager(session_id="test", storage_dir=temp_dir)
 
 
 def test_create_session(file_manager, sample_session):
@@ -432,14 +426,14 @@ def test__get_message_path_invalid_message_id(message_id, file_manager):
         file_manager._get_message_path("session1", "agent1", message_id)
 
 
-def test_create_multi_agent(multi_agent_manager, multi_agent_session, mock_multi_agent):
+def test_create_multi_agent(multi_agent_manager, sample_session, mock_multi_agent):
     """Test creating multi-agent state."""
-    multi_agent_manager.create_session(multi_agent_session)
-    multi_agent_manager.create_multi_agent(multi_agent_session.session_id, mock_multi_agent)
+    multi_agent_manager.create_session(sample_session)
+    multi_agent_manager.create_multi_agent(sample_session.session_id, mock_multi_agent)
 
     # Verify file created
     multi_agent_file = os.path.join(
-        multi_agent_manager._get_multi_agent_path(multi_agent_session.session_id, mock_multi_agent.id),
+        multi_agent_manager._get_multi_agent_path(sample_session.session_id, mock_multi_agent.id),
         "multi_agent.json",
     )
     assert os.path.exists(multi_agent_file)
@@ -451,58 +445,58 @@ def test_create_multi_agent(multi_agent_manager, multi_agent_session, mock_multi
         assert data["state"] == mock_multi_agent.state
 
 
-def test_read_multi_agent(multi_agent_manager, multi_agent_session, mock_multi_agent):
+def test_read_multi_agent(multi_agent_manager, sample_session, mock_multi_agent):
     """Test reading multi-agent state."""
     # Create session and multi-agent
-    multi_agent_manager.create_session(multi_agent_session)
-    multi_agent_manager.create_multi_agent(multi_agent_session.session_id, mock_multi_agent)
+    multi_agent_manager.create_session(sample_session)
+    multi_agent_manager.create_multi_agent(sample_session.session_id, mock_multi_agent)
 
     # Read multi-agent
-    result = multi_agent_manager.read_multi_agent(multi_agent_session.session_id, mock_multi_agent.id)
+    result = multi_agent_manager.read_multi_agent(sample_session.session_id, mock_multi_agent.id)
 
     assert result["id"] == mock_multi_agent.id
     assert result["state"] == mock_multi_agent.state
 
 
-def test_read_nonexistent_multi_agent(multi_agent_manager, multi_agent_session):
+def test_read_nonexistent_multi_agent(multi_agent_manager, sample_session):
     """Test reading multi-agent state that doesn't exist."""
-    result = multi_agent_manager.read_multi_agent(multi_agent_session.session_id, "nonexistent")
+    result = multi_agent_manager.read_multi_agent(sample_session.session_id, "nonexistent")
     assert result is None
 
 
-def test_update_multi_agent(multi_agent_manager, multi_agent_session, mock_multi_agent):
+def test_update_multi_agent(multi_agent_manager, sample_session, mock_multi_agent):
     """Test updating multi-agent state."""
     # Create session and multi-agent
-    multi_agent_manager.create_session(multi_agent_session)
-    multi_agent_manager.create_multi_agent(multi_agent_session.session_id, mock_multi_agent)
+    multi_agent_manager.create_session(sample_session)
+    multi_agent_manager.create_multi_agent(sample_session.session_id, mock_multi_agent)
 
     updated_mock = Mock()
     updated_mock.id = mock_multi_agent.id
     updated_mock.serialize_state.return_value = {"id": mock_multi_agent.id, "state": {"updated": "value"}}
-    multi_agent_manager.update_multi_agent(multi_agent_session.session_id, updated_mock)
+    multi_agent_manager.update_multi_agent(sample_session.session_id, updated_mock)
 
     # Verify update
-    result = multi_agent_manager.read_multi_agent(multi_agent_session.session_id, mock_multi_agent.id)
+    result = multi_agent_manager.read_multi_agent(sample_session.session_id, mock_multi_agent.id)
     assert result["state"] == {"updated": "value"}
 
 
-def test_update_nonexistent_multi_agent(multi_agent_manager, multi_agent_session):
+def test_update_nonexistent_multi_agent(multi_agent_manager, sample_session):
     """Test updating multi-agent state that doesn't exist."""
     # Create session
-    multi_agent_manager.create_session(multi_agent_session)
+    multi_agent_manager.create_session(sample_session)
 
     nonexistent_mock = Mock()
     nonexistent_mock.id = "nonexistent"
     with pytest.raises(SessionException):
-        multi_agent_manager.update_multi_agent(multi_agent_session.session_id, nonexistent_mock)
+        multi_agent_manager.update_multi_agent(sample_session.session_id, nonexistent_mock)
 
 
-def test_create_session_multi_agent_directory_structure(multi_agent_manager, multi_agent_session):
+def test_create_session_multi_agent_directory_structure(multi_agent_manager, sample_session):
     """Test multi-agent session creates correct directory structure."""
-    multi_agent_manager.create_session(multi_agent_session)
+    multi_agent_manager.create_session(sample_session)
 
     # Verify directory structure
-    session_dir = multi_agent_manager._get_session_path(multi_agent_session.session_id)
+    session_dir = multi_agent_manager._get_session_path(sample_session.session_id)
     multi_agents_dir = os.path.join(session_dir, "multi_agents")
 
     assert os.path.exists(session_dir)

tests/strands/session/test_repository_session_manager.py

@@ -44,14 +44,6 @@ def mock_multi_agent():
     return mock
 
 
-@pytest.fixture
-def multi_agent_session_manager(mock_repository):
-    """Create a multi-agent session manager."""
-    return RepositorySessionManager(
-        session_id="test-multi-session", session_repository=mock_repository, session_type=SessionType.MULTI_AGENT
-    )
-
-
 def test_init_creates_session_if_not_exists(mock_repository):
     """Test that init creates a session if it doesn't exist."""
     # Session doesn't exist yet
@@ -200,55 +192,44 @@ def test_append_message(session_manager):
     assert messages[0].message["content"][0]["text"] == "Hello"
 
 
-def test_init_multi_agent_session_type(mock_repository):
-    """Test creating session manager with multi-agent type."""
-    manager = RepositorySessionManager(
-        session_id="multi-session", session_repository=mock_repository, session_type=SessionType.MULTI_AGENT
-    )
-
-    assert manager.session_type == SessionType.MULTI_AGENT
-    session = mock_repository.read_session("multi-session")
-    assert session.session_type == SessionType.MULTI_AGENT
-
-
-def test_sync_multi_agent(multi_agent_session_manager, mock_multi_agent):
+def test_sync_multi_agent(session_manager, mock_multi_agent):
     """Test syncing multi-agent state."""
     # Create multi-agent first
-    multi_agent_session_manager.session_repository.create_multi_agent("test-multi-session", mock_multi_agent)
+    session_manager.session_repository.create_multi_agent("test-session", mock_multi_agent)
 
     # Sync multi-agent
-    multi_agent_session_manager.sync_multi_agent(mock_multi_agent)
+    session_manager.sync_multi_agent(mock_multi_agent)
 
     # Verify repository update_multi_agent was called
-    state = multi_agent_session_manager.session_repository.read_multi_agent("test-multi-session", mock_multi_agent.id)
+    state = session_manager.session_repository.read_multi_agent("test-session", mock_multi_agent.id)
     assert state["id"] == "test-multi-agent"
     assert state["state"] == {"key": "value"}
 
 
-def test_initialize_multi_agent_new(multi_agent_session_manager, mock_multi_agent):
+def test_initialize_multi_agent_new(session_manager, mock_multi_agent):
     """Test initializing new multi-agent state."""
-    multi_agent_session_manager.initialize_multi_agent(mock_multi_agent)
+    session_manager.initialize_multi_agent(mock_multi_agent)
 
     # Verify multi-agent was created
-    state = multi_agent_session_manager.session_repository.read_multi_agent("test-multi-session", mock_multi_agent.id)
+    state = session_manager.session_repository.read_multi_agent("test-session", mock_multi_agent.id)
     assert state["id"] == "test-multi-agent"
     assert state["state"] == {"key": "value"}
 
 
-def test_initialize_multi_agent_existing(multi_agent_session_manager, mock_multi_agent):
+def test_initialize_multi_agent_existing(session_manager, mock_multi_agent):
     """Test initializing existing multi-agent state."""
     # Create existing state first
-    multi_agent_session_manager.session_repository.create_multi_agent("test-multi-session", mock_multi_agent)
+    session_manager.session_repository.create_multi_agent("test-session", mock_multi_agent)
 
     # Create a mock with updated state for the update call
     updated_mock = Mock()
     updated_mock.id = "test-multi-agent"
     existing_state = {"id": "test-multi-agent", "state": {"restored": "data"}}
     updated_mock.serialize_state.return_value = existing_state
-    multi_agent_session_manager.session_repository.update_multi_agent("test-multi-session", updated_mock)
+    session_manager.session_repository.update_multi_agent("test-session", updated_mock)
 
     # Initialize multi-agent
-    multi_agent_session_manager.initialize_multi_agent(mock_multi_agent)
+    session_manager.initialize_multi_agent(mock_multi_agent)
 
     # Verify deserialize_state was called with existing state
     mock_multi_agent.deserialize_state.assert_called_once_with(existing_state)