econagents 0.0.1__tar.gz → 0.0.3__tar.gz

econagents-0.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Delft University of Technology
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{econagents-0.0.1 → econagents-0.0.3}/PKG-INFO

@@ -1,24 +1,27 @@
 Metadata-Version: 2.3
 Name: econagents
-Version: 0.0.1
+Version: 0.0.3
 Summary: 
-License: Apache-2.0
-Author: Dylan
-Requires-Python: >=3.10,<3.13
-Classifier: License :: OSI Approved :: Apache Software License
+License: MIT
+Author: Dylan Castillo
+Author-email: dylan@iwanalabs.com
+Requires-Python: >=3.10,<4
+Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: langsmith (>=0.3.13,<0.4.0)
-Requires-Dist: numpy (>=2.2.3,<3.0.0)
-Requires-Dist: openai (>=1.65.5,<2.0.0)
-Requires-Dist: pydantic (>=2.10.6,<3.0.0)
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: all
+Provides-Extra: default
+Provides-Extra: langfuse
+Provides-Extra: langsmith
+Provides-Extra: ollama
+Provides-Extra: openai
+Requires-Dist: jinja2 (>=3.1.6,<4.0.0)
+Requires-Dist: pydantic (>=2.11.3,<3.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
-Requires-Dist: typing-extensions (>=4.12.2,<5.0.0)
 Requires-Dist: websockets (>=15.0,<16.0)
-Project-URL: Homepage, https://github.com/iwanalabs/econagents
-Project-URL: Repository, https://github.com/iwanalabs/econagents
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -61,13 +64,15 @@ econagents consists of four key components:
 
 ## Example Experiments
 
-The repository includes two example experiments:
+The repository includes three example games:
 
 1. **`prisoner`**: An iterated Prisoner's Dilemma game with 5 rounds and 2 LLM agents.
-2. **`tudeflt/harberger`**: A Harberger Tax simulation with LLM agents.
-3. **`tudeflt/futarchy`**: A Futarchy simulation with LLM agents.
+2. **`ibex_tudelft/harberger`**: A Harberger Tax simulation with LLM agents.
+3. **`ibex_tudelft/futarchy`**: A Futarchy simulation with LLM agents.
 
-### Running the Prisoner's Dilemma Experiment
+### Running the Prisoner's Dilemma game
+
+The simplest game to run is a version of the repeated prisoner's dilemma game that runs on your local machine.
 
 ```shell
 # Run the server
@@ -77,6 +82,8 @@ python examples/server/prisoner/server.py
 python examples/prisoner/run_game.py
 ```
 
+Note: you still have to set up the connection to the agents.
+
 ## Key Features
 
 - **Flexible Agent Customization**: Customize agent behavior with Jinja templates or custom Python methods

{econagents-0.0.1 → econagents-0.0.3}/README.md

@@ -38,13 +38,15 @@ econagents consists of four key components:
 
 ## Example Experiments
 
-The repository includes two example experiments:
+The repository includes three example games:
 
 1. **`prisoner`**: An iterated Prisoner's Dilemma game with 5 rounds and 2 LLM agents.
-2. **`tudeflt/harberger`**: A Harberger Tax simulation with LLM agents.
-3. **`tudeflt/futarchy`**: A Futarchy simulation with LLM agents.
+2. **`ibex_tudelft/harberger`**: A Harberger Tax simulation with LLM agents.
+3. **`ibex_tudelft/futarchy`**: A Futarchy simulation with LLM agents.
 
-### Running the Prisoner's Dilemma Experiment
+### Running the Prisoner's Dilemma game
+
+The simplest game to run is a version of the repeated prisoner's dilemma game that runs on your local machine.
 
 ```shell
 # Run the server
@@ -54,6 +56,8 @@ python examples/server/prisoner/server.py
 python examples/prisoner/run_game.py
 ```
 
+Note: you still have to set up the connection to the agents.
+
 ## Key Features
 
 - **Flexible Agent Customization**: Customize agent behavior with Jinja templates or custom Python methods

{econagents-0.0.1 → econagents-0.0.3}/econagents/__init__.py

@@ -1,17 +1,18 @@
 """
-econagents: A Python library for setting up and running economic experiments with LLMs or human subjects.
+econagents: A Python library that lets you use LLM agents in economic experiments. 
 """
 
 from econagents.core.agent_role import AgentRole
 from econagents.core.game_runner import GameRunner, HybridGameRunnerConfig, TurnBasedGameRunnerConfig
 from econagents.core.manager import AgentManager
+from econagents.core.transport import WebSocketTransport
 from econagents.core.manager.phase import PhaseManager, HybridPhaseManager, TurnBasedPhaseManager
 from econagents.core.state.fields import EventField
 from econagents.core.state.game import GameState, MetaInformation, PrivateInformation, PublicInformation
 from econagents.llm.openai import ChatOpenAI
 
 # Don't manually change, let poetry-dynamic-versioning handle it.
-__version__ = "0.0.1"
+__version__ = "0.0.3"
 
 __all__: list[str] = [
     "AgentRole",
@@ -28,4 +29,5 @@ __all__: list[str] = [
     "TurnBasedGameRunnerConfig",
     "HybridGameRunnerConfig",
     "EventField",
+    "WebSocketTransport",
 ]

{econagents-0.0.1 → econagents-0.0.3}/econagents/core/agent_role.py

@@ -3,13 +3,14 @@ import logging
 import re
 from abc import ABC
 from pathlib import Path
+from jinja2 import FileSystemLoader
 from typing import Any, Callable, ClassVar, Dict, Generic, Literal, Optional, Pattern, Protocol, TypeVar
 
 from jinja2.sandbox import SandboxedEnvironment
 
 from econagents.core.logging_mixin import LoggerMixin
 from econagents.core.state.game import GameStateProtocol
-from econagents.llm.openai import ChatOpenAI
+from econagents.llm.base import BaseLLM
 
 StateT_contra = TypeVar("StateT_contra", bound=GameStateProtocol, contravariant=True)
 
@@ -17,7 +18,7 @@ StateT_contra = TypeVar("StateT_contra", bound=GameStateProtocol, contravariant=
 class AgentProtocol(Protocol):
     role: ClassVar[int]
     name: ClassVar[str]
-    llm: ChatOpenAI
+    llm: BaseLLM
     task_phases: ClassVar[list[int]]
 
 
@@ -41,12 +42,12 @@ class AgentRole(ABC, Generic[StateT_contra], LoggerMixin):
     """Unique identifier for this role"""
     name: ClassVar[str]
     """Human-readable name for this role"""
-    llm: ChatOpenAI
+    llm: BaseLLM
     """Language model instance for generating responses"""
     task_phases: ClassVar[list[int]] = []  # Empty list means no specific phases are required
     """List of phases this agent should participate in (empty means all phases)"""
     task_phases_excluded: ClassVar[list[int]] = []  # Empty list means no phases are excluded
-
+    """ Alternative way to specify phases this agent should participate in, listed phases are excluded (empty means nothing excluded)"""
     # Regex patterns for method name extraction
     _SYSTEM_PROMPT_PATTERN: ClassVar[Pattern] = re.compile(r"get_phase_(\d+)_system_prompt")
     _USER_PROMPT_PATTERN: ClassVar[Pattern] = re.compile(r"get_phase_(\d+)_user_prompt")
@@ -109,9 +110,9 @@ class AgentRole(ABC, Generic[StateT_contra], LoggerMixin):
 
         Template resolution order:
 
-        1. Agent-specific phase prompt (e.g., "agent_name_system_phase_1.jinja2")
+        1. Role-specific phase prompt (e.g., "role_name_system_phase_1.jinja2")
 
-        2. Agent-specific general prompt (e.g., "agent_name_system.jinja2")
+        2. Role-specific general prompt (e.g., "role_name_system.jinja2")
 
         3. All-role phase prompt (e.g., "all_system_phase_1.jinja2")
 
@@ -129,12 +130,20 @@ class AgentRole(ABC, Generic[StateT_contra], LoggerMixin):
         Raises:
             FileNotFoundError: If no matching prompt template is found
         """
+        # Initialize Jinja environment with a file system loader
+        env = SandboxedEnvironment(loader=FileSystemLoader(prompts_path))
+
         # Try role-specific prompt first, then fall back to 'all'
         for role in [self.name, "all"]:
-            if prompt_file := self._resolve_prompt_file(prompt_type, phase, role, prompts_path):
-                with prompt_file.open() as f:
-                    template = SandboxedEnvironment().from_string(f.read())
-                return template.render(**context)
+            if prompt_file_path := self._resolve_prompt_file(prompt_type, phase, role, prompts_path):
+                # Get filename relative to the prompts_path for the loader
+                template_filename = str(prompt_file_path.relative_to(prompts_path))
+                try:
+                    template = env.get_template(template_filename)
+                    return template.render(**context)
+                except Exception as e:  # Catch potential Jinja errors during loading/rendering
+                    self.logger.error(f"Error loading/rendering template {template_filename}: {e}")
+                    raise  # Re-raise after logging
 
         raise FileNotFoundError(
             f"No prompt template found for type={prompt_type}, phase={phase}, "

{econagents-0.0.1 → econagents-0.0.3}/econagents/core/game_runner.py

@@ -4,14 +4,14 @@ import queue
 from contextvars import ContextVar
 from logging.handlers import QueueHandler, QueueListener
 from pathlib import Path
-from typing import Optional, Type
+from typing import Literal, Optional, Type
 
 from pydantic import BaseModel, Field
 
-from econagents.core.manager.base import AgentManager
 from econagents.core.manager.phase import PhaseManager
 from econagents.core.state.game import GameState
 from econagents.core.transport import AuthenticationMechanism, SimpleLoginPayloadAuth
+from econagents.llm.observability import get_observability_provider
 
 ctx_agent_id: ContextVar[str] = ContextVar("agent_id", default="N/A")
 
@@ -59,6 +59,14 @@ class GameRunnerConfig(BaseModel):
     state_class: Optional[Type[GameState]] = None
     """Class to use for the state"""
 
+    # Observability configuration
+    observability_provider: Optional[Literal["langsmith", "langfuse"]] = None
+    """Name of the observability provider to use. Options: 'langsmith' or 'langfuse'"""
+
+    # Agent stop configuration
+    end_game_event: str = "game-over"
+    """Event type that signals the end of the game and should stop the agent."""
+
 
 class TurnBasedGameRunnerConfig(GameRunnerConfig):
     """Configuration class for TurnBasedGameRunner."""
@@ -299,12 +307,26 @@ class GameRunner:
             agent_manager.auth_mechanism = self.config.auth_mechanism
             agent_manager.logger.debug(f"Injected default auth mechanism: {agent_manager.auth_mechanism}")
 
+        if agent_manager.end_game_event_type != self.config.end_game_event:
+            agent_manager.end_game_event_type = self.config.end_game_event
+            agent_manager.logger.debug(f"Injected default end game event: {agent_manager.end_game_event_type}")
+
+        if agent_manager.llm_provider and self.config.observability_provider:
+            try:
+                provider = get_observability_provider(self.config.observability_provider)
+                agent_manager.llm_provider.observability = provider
+                agent_manager.logger.debug(
+                    f"Injected {self.config.observability_provider} observability provider into LLM provider"
+                )
+            except Exception as e:
+                agent_manager.logger.error(f"Failed to initialize observability provider: {e}")
+
         if isinstance(self.config, HybridGameRunnerConfig):
             agent_manager.continuous_phases = set(self.config.continuous_phases)
             agent_manager.min_action_delay = self.config.min_action_delay
             agent_manager.max_action_delay = self.config.max_action_delay
             agent_manager.logger.debug(
-                f"Injected default continuous phases: {agent_manager.continuous_phases}, min action delay: {agent_manager.min_action_delay}, max action delay: {agent_manager.max_action_delay}"
+                f"Injected default continuous-time phases: {agent_manager.continuous_phases}, min action delay: {agent_manager.min_action_delay}, max action delay: {agent_manager.max_action_delay}"
             )
 
     def _inject_agent_logger(self, agent_manager: PhaseManager, agent_id: int) -> None:
@@ -335,7 +357,7 @@ class GameRunner:
             agent_manager.logger.info(f"Connecting to WebSocket URL: {agent_manager.url}")
             await agent_manager.start()
         except Exception:
-            agent_manager.logger.exception(f"Error in simulation for Agent {agent_id}")
+            agent_manager.logger.exception(f"Error in game for Agent {agent_id}")
             raise
 
     async def run_game(self) -> None:
@@ -346,7 +368,7 @@ class GameRunner:
 
         try:
             tasks = []
-            game_logger.info("Starting simulations")
+            game_logger.info("Starting game")
 
             for i, agent_manager in enumerate(self.agents, start=1):
                 tasks.append(self.spawn_agent(agent_manager, i))
@@ -355,4 +377,5 @@ class GameRunner:
             game_logger.exception(f"Failed to run game: {e}")
             raise
         finally:
+            game_logger.info("Game over")
             self.cleanup_logging()

{econagents-0.0.1 → econagents-0.0.3}/econagents/core/manager/base.py

@@ -68,6 +68,10 @@ class AgentManager(LoggerMixin):
         self._global_pre_event_hooks: list[Callable[[Message], Any]] = []
         self._global_post_event_hooks: list[Callable[[Message], Any]] = []
 
+        # Default event type to trigger stopping the agent
+        self._end_game_event_type: str = "game-over"
+        self.register_event_handler(self._end_game_event_type, self._handle_end_game)
+
         # Initialize transport if URL is provided
         if url:
             self._initialize_transport()
@@ -156,6 +160,30 @@ class AgentManager(LoggerMixin):
             return None
         return Message(message_type=message_type, event_type=event_type, data=data)
 
+    @property
+    def end_game_event_type(self) -> str:
+        """Get the event type that triggers the agent to stop."""
+        return self._end_game_event_type
+
+    @end_game_event_type.setter
+    def end_game_event_type(self, value: str):
+        """
+        Set the event type that triggers the agent to stop.
+
+        Unregisters the stop handler from the old event type and registers it
+        for the new event type.
+
+        Args:
+            value (str): The new event type to listen for.
+        """
+        if self._end_game_event_type != value:
+            # Unregister from the old event type
+            self.unregister_event_handler(self._end_game_event_type, self._handle_end_game)
+            # Register for the new event type
+            self._end_game_event_type = value
+            self.register_event_handler(self._end_game_event_type, self._handle_end_game)
+            self.logger.info(f"End game event type set to: {value}")
+
     async def on_message(self, message: Message):
         """
         Default implementation to handle incoming messages from the server.
@@ -202,6 +230,7 @@ class AgentManager(LoggerMixin):
         self.running = False
         if self.transport:
             await self.transport.stop()
+            self.logger.info("Agent manager stopped and connection closed.")
 
     async def on_event(self, message: Message):
         """
@@ -270,6 +299,16 @@ class AgentManager(LoggerMixin):
             if hasattr(result, "__await__"):
                 await result
 
+    async def _handle_end_game(self, message: Message):
+        """
+        Default handler for the 'end_game_event_type'. Stops the agent manager.
+
+        Args:
+            message (Message): The event message triggering the end game.
+        """
+        self.logger.info(f"Received end game event ({message.event_type}). Stopping agent manager...")
+        await self.stop()
+
     # Event handler registration
     def register_event_handler(self, event_type: str, handler: Callable[[Message], Any]):
         """
@@ -355,7 +394,17 @@ class AgentManager(LoggerMixin):
             if handler is None:
                 self._event_handlers.pop(event_type)
             else:
-                self._event_handlers[event_type] = [h for h in self._event_handlers[event_type] if h != handler]
+                # Use list comprehension to avoid modifying list while iterating
+                handlers_to_keep = [h for h in self._event_handlers[event_type] if h != handler]
+                if not handlers_to_keep:
+                    # Remove the key if the list becomes empty
+                    self._event_handlers.pop(event_type, None)
+                else:
+                    self._event_handlers[event_type] = handlers_to_keep
+                # Explicitly handle removal of the default end game handler
+                if event_type == self._end_game_event_type and handler == self._handle_end_game:
+                    self.logger.warning(f"Default end game handler for '{event_type}' unregistered.")
+
         return self
 
     def unregister_global_event_handler(self, handler: Optional[Callable] = None):
@@ -384,7 +433,13 @@ class AgentManager(LoggerMixin):
             if hook is None:
                 self._pre_event_hooks.pop(event_type)
             else:
-                self._pre_event_hooks[event_type] = [h for h in self._pre_event_hooks[event_type] if h != hook]
+                # Use list comprehension to avoid modifying list while iterating
+                hooks_to_keep = [h for h in self._pre_event_hooks[event_type] if h != hook]
+                if not hooks_to_keep:
+                    # Remove the key if the list becomes empty
+                    self._pre_event_hooks.pop(event_type, None)
+                else:
+                    self._pre_event_hooks[event_type] = hooks_to_keep
         return self
 
     def unregister_global_pre_event_hook(self, hook: Optional[Callable] = None):
@@ -413,7 +468,13 @@ class AgentManager(LoggerMixin):
             if hook is None:
                 self._post_event_hooks.pop(event_type)
             else:
-                self._post_event_hooks[event_type] = [h for h in self._post_event_hooks[event_type] if h != hook]
+                # Use list comprehension to avoid modifying list while iterating
+                hooks_to_keep = [h for h in self._post_event_hooks[event_type] if h != hook]
+                if not hooks_to_keep:
+                    # Remove the key if the list becomes empty
+                    self._post_event_hooks.pop(event_type, None)
+                else:
+                    self._post_event_hooks[event_type] = hooks_to_keep
         return self
 
     def unregister_global_post_event_hook(self, hook: Optional[Callable] = None):

{econagents-0.0.1 → econagents-0.0.3}/econagents/core/manager/phase.py

@@ -3,30 +3,28 @@ import json
 import logging
 import random
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Optional
 from pathlib import Path
+from typing import Any, Callable, Optional
 
 from econagents.core.agent_role import AgentRole
 from econagents.core.events import Message
 from econagents.core.manager.base import AgentManager
 from econagents.core.state.game import GameState
-from econagents.core.transport import AuthenticationMechanism, SimpleLoginPayloadAuth
+from econagents.core.transport import AuthenticationMechanism
 
 
 class PhaseManager(AgentManager, ABC):
     """
     Abstract manager that handles the concept of 'phases' in a game.
 
-    This manager standardizes the interface for phase-based games with hooks for
-    phase transitions and optional continuous phase handling.
+    This manager standardizes the interface for phase-based games with optional
+    continuous-time phase handling.
 
     Features:
     1. Standardized interface for starting a phase
 
     2. Optional continuous "tick loop" for phases
 
-    3. Hooks for "on phase start," "on phase end," and "on phase transition event"
-
     All configuration parameters can be:
 
     1. Provided at initialization time
@@ -38,8 +36,8 @@ class PhaseManager(AgentManager, ABC):
         phase_transition_event (Optional[str]): Event name for phase transitions
         phase_identifier_key (Optional[str]): Key in the event data that identifies the phase
         continuous_phases (Optional[set[int]]): set of phase numbers that should be treated as continuous
-        min_action_delay (Optional[int]): Minimum delay in seconds between actions in continuous phases
-        max_action_delay (Optional[int]): Maximum delay in seconds between actions in continuous phases
+        min_action_delay (Optional[int]): Minimum delay in seconds between actions in continuous-time phases
+        max_action_delay (Optional[int]): Maximum delay in seconds between actions in continuous-time phases
         state (Optional[GameState]): Game state object to track game state
         agent_role (Optional[AgentRole]): Agent role instance to handle game phases
         auth_mechanism (Optional[AuthenticationMechanism]): Authentication mechanism to use
@@ -145,12 +143,12 @@ class PhaseManager(AgentManager, ABC):
 
     @property
     def continuous_phases(self) -> set[int]:
-        """Get the set of continuous phases."""
+        """Get the set of continuous-time phases."""
         return self._continuous_phases  # type: ignore
 
     @continuous_phases.setter
     def continuous_phases(self, value: set[int]):
-        """Set the continuous phases."""
+        """Set the continuous-time phases."""
         self._continuous_phases = value
 
     @property
@@ -183,6 +181,13 @@ class PhaseManager(AgentManager, ABC):
         """Set the prompts directory."""
         self._prompts_dir = value
 
+    @property
+    def llm_provider(self):
+        """Get the LLM provider from the agent role."""
+        if self._agent_role and hasattr(self._agent_role, "llm"):
+            return self._agent_role.llm
+        return None
+
     async def start(self):
         """Start the manager."""
         # TODO: is there a better place to do this?
@@ -220,38 +225,27 @@ class PhaseManager(AgentManager, ABC):
         Handle a phase transition.
 
         This method is the main orchestrator for phase transitions:
-        1. If leaving a continuous phase, stops the continuous task
-        2. Calls the on_phase_end hook for the old phase
-        3. Updates the current phase
-        4. Calls the on_phase_start hook for the new phase
-        5. Starts a continuous task if entering a continuous phase
-        6. Executes a single action if entering a non-continuous phase
+        1. If leaving a continuous-time phase, stops the continuous task
+        2. Updates the current phase
+        3. Starts a continuous task if entering a continuous-time phase
+        4. Executes a single action if entering a non-continuous-time phase
 
         Args:
             new_phase (Optional[int]): The new phase number
         """
         self.logger.info(f"Transitioning to phase {new_phase}")
 
-        # If we were in a continuous phase, stop it
+        # If we were in a continuous-time phase, stop it
         if self.in_continuous_phase and new_phase != self.current_phase:
-            self.logger.info(f"Stopping continuous phase {self.current_phase}")
+            self.logger.info(f"Stopping continuous-time phase {self.current_phase}")
             self.in_continuous_phase = False
             if self._continuous_task:
                 self._continuous_task.cancel()
                 self._continuous_task = None
 
-        # Call the on_phase_end hook for the old phase
-        old_phase = self.current_phase
-        if old_phase is not None:
-            await self.on_phase_end(old_phase)
-
-        # Update current phase
         self.current_phase = new_phase
 
         if new_phase is not None:
-            # Call the on_phase_start hook for the new phase
-            await self.on_phase_start(new_phase)
-
             # If the new phase is continuous, start a continuous task
             if self.continuous_phases and new_phase in self.continuous_phases:
                 self.in_continuous_phase = True
@@ -260,12 +254,12 @@ class PhaseManager(AgentManager, ABC):
                 # Execute an initial action
                 await self.execute_phase_action(new_phase)
             else:
-                # Execute a single action for non-continuous phases
+                # Execute a single action for non-continuous-time phases
                 await self.execute_phase_action(new_phase)
 
     async def _continuous_phase_loop(self, phase: int):
         """
-        Run a loop that periodically executes actions for a continuous phase.
+        Run a loop that periodically executes actions for a continuous-time phase.
 
         Args:
             phase (int): The phase number
@@ -277,16 +271,16 @@ class PhaseManager(AgentManager, ABC):
                 self.logger.debug(f"Waiting {delay} seconds before next action in phase {phase}")
                 await asyncio.sleep(delay)
 
-                # Check if we're still in the same continuous phase
+                # Check if we're still in the same continuous-time phase
                 if not self.in_continuous_phase or self.current_phase != phase:
                     break
 
                 # Execute the action
                 await self.execute_phase_action(phase)
         except asyncio.CancelledError:
-            self.logger.info(f"Continuous phase {phase} loop cancelled")
+            self.logger.info(f"Continuous-time phase {phase} loop cancelled")
         except Exception as e:
-            self.logger.exception(f"Error in continuous phase {phase} loop: {e}")
+            self.logger.exception(f"Error in continuous-time phase {phase} loop: {e}")
 
     @abstractmethod
     async def execute_phase_action(self, phase: int):
@@ -301,30 +295,8 @@ class PhaseManager(AgentManager, ABC):
         """
         pass
 
-    async def on_phase_start(self, phase: int):
-        """
-        Hook that is called when a phase starts.
-
-        Subclasses can override this to implement custom behavior.
-
-        Args:
-            phase (int): The phase number
-        """
-        pass
-
-    async def on_phase_end(self, phase: int):
-        """
-        Hook that is called when a phase ends.
-
-        Subclasses can override this to implement custom behavior.
-
-        Args:
-            phase (int): The phase number
-        """
-        pass
-
     async def stop(self):
-        """Stop the manager and cancel any continuous phase tasks."""
+        """Stop the manager and cancel any continuous-time phase tasks."""
         self.in_continuous_phase = False
         if self._continuous_task:
             self._continuous_task.cancel()
@@ -337,7 +309,8 @@ class TurnBasedPhaseManager(PhaseManager):
     A manager for turn-based games that handles phase transitions.
 
     This manager inherits from PhaseManager and provides a concrete implementation
-    for executing actions in each phase.
+    for executing actions in each phase. All phases are treated as turn-based,
+    meaning actions are only taken when explicitly triggered (no continuous actions).
 
     Args:
         url (Optional[str]): WebSocket server URL
@@ -416,7 +389,11 @@ class HybridPhaseManager(PhaseManager):
     A manager for games that combine turn-based and continuous action phases.
 
     This manager extends PhaseManager and configures it with specific phases
-    that should be treated as continuous.
+    that should be treated as continuous. By default, all phases are treated as
+    turn-based unless explicitly included in the continuous_phases parameter.
+
+    For continuous-time phases, the manager will automatically execute actions periodically
+    with random delays between min_action_delay and max_action_delay seconds.
 
     Args:
         continuous_phases (Optional[set[int]]): Set of phase numbers that should be treated as continuous
@@ -425,8 +402,8 @@ class HybridPhaseManager(PhaseManager):
         auth_mechanism_kwargs (Optional[dict[str, Any]]): Keyword arguments for the authentication mechanism
         phase_transition_event (Optional[str]): Event name for phase transitions
         phase_identifier_key (Optional[str]): Key in the event data that identifies the phase
-        min_action_delay (Optional[int]): Minimum delay in seconds between actions in continuous phases
-        max_action_delay (Optional[int]): Maximum delay in seconds between actions in continuous phases
+        min_action_delay (Optional[int]): Minimum delay in seconds between actions in continuous-time phases
+        max_action_delay (Optional[int]): Maximum delay in seconds between actions in continuous-time phases
         state (Optional[GameState]): Game state object to track game state
         agent_role (Optional[AgentRole]): Agent role instance to handle game phases
         logger (Optional[logging.Logger]): Logger instance for tracking events