econagents 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

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/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/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/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/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

econagents/core/state/game.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Optional, Protocol, Type, TypeVar
+from typing import Any, Callable, Optional, Protocol, Type, TypeVar, cast
 
 from pydantic import BaseModel, ConfigDict
 
@@ -220,3 +220,25 @@ class GameState(BaseModel):
             dict[str, EventHandler]: A mapping of event types to handler functions.
         """
         return {}
+
+    def reset(self) -> None:
+        """
+        Resets meta, private_information, and public_information
+        to their initial state by re-initializing them using their default factories.
+        This effectively removes any dynamically added attributes.
+        """
+        # Re-initialize components using their default factories from the GameState model definition
+        meta_field = self.__class__.model_fields["meta"]
+        if meta_field.default_factory:
+            fac = cast("Callable[[], Any]", meta_field.default_factory)
+            self.meta = fac()
+
+        private_field = self.__class__.model_fields["private_information"]
+        if private_field.default_factory:
+            fac = cast("Callable[[], Any]", private_field.default_factory)
+            self.private_information = fac()
+
+        public_field = self.__class__.model_fields["public_information"]
+        if public_field.default_factory:
+            fac = cast("Callable[[], Any]", public_field.default_factory)
+            self.public_information = fac()

econagents/llm/__init__.py

@@ -1,3 +1,20 @@
-from econagents.llm.openai import ChatOpenAI
+from econagents.llm.base import BaseLLM, LLMProvider
+from econagents.llm.observability import ObservabilityProvider, get_observability_provider
 
-__all__: list[str] = ["ChatOpenAI"]
+# Import specific implementations if available
+try:
+    from econagents.llm.openai import ChatOpenAI
+except ImportError:
+    pass
+
+try:
+    from econagents.llm.ollama import ChatOllama
+except ImportError:
+    pass
+
+__all__: list[str] = [
+    "BaseLLM",
+    "LLMProvider",
+    "ObservabilityProvider",
+    "get_observability_provider",
+]

econagents/llm/base.py

@@ -0,0 +1,62 @@
+from abc import ABC, abstractmethod
+from typing import Any, Protocol, runtime_checkable
+
+from econagents.llm.observability import ObservabilityProvider, get_observability_provider
+
+
+@runtime_checkable
+class LLMProvider(Protocol):
+    """Protocol for LLM providers."""
+
+    async def get_response(
+        self,
+        messages: list[dict[str, Any]],
+        tracing_extra: dict[str, Any],
+        **kwargs: Any,
+    ) -> str:
+        """Get a response from the LLM."""
+        ...
+
+    def build_messages(self, system_prompt: str, user_prompt: str) -> list[dict[str, Any]]:
+        """Build messages for the LLM."""
+        ...
+
+
+class BaseLLM(ABC):
+    """Base class for LLM implementations."""
+
+    observability: ObservabilityProvider = get_observability_provider("noop")
+
+    def build_messages(self, system_prompt: str, user_prompt: str) -> list[dict[str, Any]]:
+        """Build messages for the LLM.
+
+        Args:
+            system_prompt: The system prompt for the LLM.
+            user_prompt: The user prompt for the LLM.
+
+        Returns:
+            The messages for the LLM.
+        """
+        return [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ]
+
+    @abstractmethod
+    async def get_response(
+        self,
+        messages: list[dict[str, Any]],
+        tracing_extra: dict[str, Any],
+        **kwargs: Any,
+    ) -> str:
+        """Get a response from the LLM.
+
+        Args:
+            messages: The messages for the LLM.
+            tracing_extra: The extra tracing information.
+            **kwargs: Additional arguments to pass to the LLM.
+
+        Returns:
+            The response from the LLM.
+        """
+        ...

econagents/llm/observability.py

@@ -0,0 +1,282 @@
+"""Observability interfaces for LLM providers."""
+
+import importlib.util
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ObservabilityProvider(ABC):
+    """Base class for observability providers."""
+
+    @abstractmethod
+    def track_llm_call(
+        self,
+        name: str,
+        model: str,
+        messages: List[Dict[str, Any]],
+        response: Any,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Track an LLM call directly without creating a run tree.
+
+        Args:
+            name: Name of the operation.
+            model: Model used for the call.
+            messages: Messages sent to the model.
+            response: Response from the model.
+            metadata: Additional metadata for the call.
+        """
+        ...
+
+
+class NoOpObservability(ObservabilityProvider):
+    """No-op observability provider that does nothing."""
+
+    def track_llm_call(
+        self,
+        name: str,
+        model: str,
+        messages: List[Dict[str, Any]],
+        response: Any,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """No-op implementation of track_llm_call."""
+        pass
+
+
+class LangSmithObservability(ObservabilityProvider):
+    """LangSmith observability provider."""
+
+    def __init__(self) -> None:
+        """Initialize the LangSmith observability provider."""
+        self._check_langsmith_available()
+
+    def _check_langsmith_available(self) -> None:
+        """Check if LangSmith is available."""
+        if not importlib.util.find_spec("langsmith"):
+            raise ImportError("LangSmith is not installed. Install it with: pip install econagents[langsmith]")
+
+    def _create_run_tree(
+        self,
+        name: str,
+        run_type: str,
+        inputs: Dict[str, Any],
+    ) -> Any:
+        """Create a LangSmith run tree.
+
+        Args:
+            name: Name of the run.
+            run_type: Type of the run (e.g., "chain", "llm").
+            inputs: Inputs for the run.
+
+        Returns:
+            A LangSmith RunTree object.
+        """
+        try:
+            from langsmith.run_trees import RunTree
+
+            run_tree = RunTree(name=name, run_type=run_type, inputs=inputs)
+            run_tree.post()
+            return run_tree
+        except ImportError:
+            logger.warning("LangSmith is not available. Using no-op run tree.")
+            return {"name": name, "run_type": run_type, "inputs": inputs}
+
+    def _create_child_run(
+        self,
+        parent_run: Any,
+        name: str,
+        run_type: str,
+        inputs: Dict[str, Any],
+    ) -> Any:
+        """Create a child run in LangSmith.
+
+        Args:
+            parent_run: Parent RunTree object.
+            name: Name of the child run.
+            run_type: Type of the child run.
+            inputs: Inputs for the child run.
+
+        Returns:
+            A child RunTree object.
+        """
+        try:
+            child_run = parent_run.create_child(
+                name=name,
+                run_type=run_type,
+                inputs=inputs,
+            )
+            child_run.post()
+            return child_run
+        except (ImportError, AttributeError):
+            logger.warning("LangSmith create_child failed. Using no-op child run.")
+            return {"name": name, "run_type": run_type, "inputs": inputs, "parent": parent_run}
+
+    def _end_run(
+        self,
+        run: Any,
+        outputs: Dict[str, Any],
+    ) -> None:
+        """End a LangSmith run with outputs.
+
+        Args:
+            run: RunTree object to end.
+            outputs: Outputs of the run.
+        """
+        try:
+            run.end(outputs=outputs)
+            run.patch()
+        except (ImportError, AttributeError) as e:
+            logger.warning(f"LangSmith end_run failed: {e}")
+
+    def track_llm_call(
+        self,
+        name: str,
+        model: str,
+        messages: List[Dict[str, Any]],
+        response: Any,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Track an LLM call using LangSmith RunTree.
+
+        Args:
+            name: Name of the operation.
+            model: Model used for the call.
+            messages: Messages sent to the model.
+            response: Response from the model.
+            metadata: Additional metadata for the call.
+        """
+        try:
+            # Create a top-level run
+            run_tree = self._create_run_tree(
+                name=name, run_type="chain", inputs={"messages": messages, "metadata": metadata or {}}
+            )
+
+            # Create LLM child run
+            child_run = self._create_child_run(
+                parent_run=run_tree, name=f"{model} Call", run_type="llm", inputs={"messages": messages}
+            )
+
+            # End the runs
+            self._end_run(child_run, outputs=response)
+
+            # Get the content from the response if it's in the expected format
+            output_content = None
+            if hasattr(response, "choices") and response.choices:
+                if hasattr(response.choices[0], "message") and hasattr(response.choices[0].message, "content"):
+                    output_content = response.choices[0].message.content
+
+            self._end_run(run_tree, outputs={"response": output_content or response})
+        except Exception as e:
+            logger.warning(f"Failed to track LLM call with LangSmith: {e}")
+
+
+class LangFuseObservability(ObservabilityProvider):
+    """LangFuse observability provider."""
+
+    def __init__(self) -> None:
+        """Initialize the LangFuse observability provider."""
+        self._check_langfuse_available()
+        self._langfuse_client = None
+
+    def _check_langfuse_available(self) -> None:
+        """Check if LangFuse is available."""
+        if not importlib.util.find_spec("langfuse"):
+            raise ImportError("LangFuse is not installed. Install it with: pip install econagents[langfuse]")
+
+    def _get_langfuse_client(self) -> Any:
+        """Get or create a LangFuse client."""
+        if self._langfuse_client is None:
+            try:
+                from langfuse import Langfuse
+
+                self._langfuse_client = Langfuse()
+            except ImportError:
+                logger.warning("LangFuse is not available.")
+                return None
+        return self._langfuse_client
+
+    def track_llm_call(
+        self,
+        name: str,
+        model: str,
+        messages: List[Dict[str, Any]],
+        response: Any,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Track an LLM call using LangFuse generation.
+
+        Args:
+            name: Name of the operation.
+            model: Model used for the call.
+            messages: Messages sent to the model.
+            response: Response from the model.
+            metadata: Additional metadata for the call.
+        """
+        client = self._get_langfuse_client()
+        if client is None:
+            return
+
+        try:
+            # Create a generation in Langfuse
+            trace = client.trace(name=name, metadata={"model": model, **metadata} if metadata else {}, input=messages)
+            generation = trace.generation(
+                name=name + "_generation",
+                model=model,
+                model_parameters=metadata.get("model_parameters", {}) if metadata else {},
+                input=messages,
+                metadata=metadata or {},
+            )
+
+            # Get response content in appropriate format
+            output_content = response
+            if hasattr(response, "choices") and response.choices:
+                if hasattr(response.choices[0], "message") and hasattr(response.choices[0].message, "content"):
+                    output_content = response.choices[0].message.content
+            elif isinstance(response, dict) and "message" in response and "content" in response["message"]:
+                output_content = response["message"]["content"]
+
+            # Update generation and set end time
+            generation.end(output=output_content)
+            trace.update(output=output_content)
+
+            # Flush to ensure all requests are sent
+            client.flush()
+        except Exception as e:
+            logger.warning(f"Failed to track LLM call with LangFuse: {e}")
+
+
+def get_observability_provider(provider_name: str = "noop") -> ObservabilityProvider:
+    """Get an observability provider by name.
+
+    Args:
+        provider_name: The name of the provider to get.
+                      Options: "noop", "langsmith", "langfuse"
+
+    Returns:
+        An observability provider.
+
+    Raises:
+        ValueError: If the provider_name is invalid.
+    """
+    if provider_name == "noop":
+        return NoOpObservability()
+    elif provider_name == "langsmith":
+        try:
+            return LangSmithObservability()
+        except ImportError as e:
+            logger.warning(f"Failed to initialize LangSmith: {e}")
+            logger.warning("Falling back to NoOpObservability")
+            return NoOpObservability()
+    elif provider_name == "langfuse":
+        try:
+            return LangFuseObservability()
+        except ImportError as e:
+            logger.warning(f"Failed to initialize LangFuse: {e}")
+            logger.warning("Falling back to NoOpObservability")
+            return NoOpObservability()
+    else:
+        raise ValueError(f"Invalid observability provider: {provider_name}")

econagents/llm/ollama.py

@@ -0,0 +1,77 @@
+import importlib.util
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+from econagents.llm.base import BaseLLM
+
+logger = logging.getLogger(__name__)
+
+
+class ChatOllama(BaseLLM):
+    """A wrapper for LLM queries using Ollama."""
+
+    def __init__(
+        self,
+        model_name: str,
+        host: Optional[str] = None,
+    ) -> None:
+        """Initialize the Ollama LLM interface.
+
+        Args:
+            model_name: The model name to use.
+            host: The host for the Ollama API (e.g., "http://localhost:11434").
+        """
+        self._check_ollama_available()
+        self.model_name = model_name
+        self.host = host
+
+    def _check_ollama_available(self) -> None:
+        """Check if Ollama is available."""
+        if not importlib.util.find_spec("ollama"):
+            raise ImportError("Ollama is not installed. Install it with: pip install econagents[ollama]")
+
+    async def get_response(
+        self,
+        messages: List[Dict[str, Any]],
+        tracing_extra: Dict[str, Any],
+        **kwargs: Any,
+    ) -> str:
+        """Get a response from the LLM.
+
+        Args:
+            messages: The messages for the LLM.
+            tracing_extra: The extra tracing information.
+            **kwargs: Additional arguments to pass to the LLM.
+
+        Returns:
+            The response from the LLM.
+
+        Raises:
+            ImportError: If Ollama is not installed.
+        """
+        try:
+            from ollama import AsyncClient
+
+            client = AsyncClient(host=self.host)
+
+            response = await client.chat(
+                model=self.model_name,
+                messages=messages,
+                **kwargs,
+            )
+
+            # End the LLM run
+            self.observability.track_llm_call(
+                name="ollama_chat_completion",
+                model=self.model_name,
+                messages=messages,
+                response=response,
+                metadata=tracing_extra,
+            )
+
+            return response["message"]["content"]
+
+        except ImportError as e:
+            logger.error(f"Failed to import Ollama: {e}")
+            raise ImportError("Ollama is not installed. Install it with: pip install econagents[ollama]") from e

econagents/llm/openai.py

@@ -1,61 +1,77 @@
+import importlib.util
+import logging
 from typing import Any, Optional
 
-from langsmith import traceable
-from langsmith.wrappers import wrap_openai
-from openai import AsyncOpenAI
+from econagents.llm.base import BaseLLM
 
+logger = logging.getLogger(__name__)
 
-class ChatOpenAI:
-    """
-    A simple wrapper for LLM queries, e.g. using OpenAI and LangSmith.
-    """
+
+class ChatOpenAI(BaseLLM):
+    """A wrapper for LLM queries using OpenAI."""
 
     def __init__(
         self,
         model_name: str = "gpt-4o",
         api_key: Optional[str] = None,
     ) -> None:
-        """Initialize the LLM interface."""
-        self.model_name = model_name
-        self.api_key = api_key
-
-    def build_messages(self, system_prompt: str, user_prompt: str):
-        """Build messages for the LLM.
+        """Initialize the OpenAI LLM interface.
 
         Args:
-            system_prompt (str): The system prompt for the LLM.
-            user_prompt (str): The user prompt for the LLM.
-
-        Returns:
-            list[dict[str, Any]]: The messages for the LLM.
+            model_name: The model name to use.
+            api_key: The API key to use for authentication.
         """
-        return [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_prompt},
-        ]
+        self.model_name = model_name
+        self.api_key = api_key
+        self._check_openai_available()
+
+    def _check_openai_available(self) -> None:
+        """Check if OpenAI is available."""
+        if not importlib.util.find_spec("openai"):
+            raise ImportError("OpenAI is not installed. Install it with: pip install econagents[openai]")
 
-    @traceable
     async def get_response(
         self,
         messages: list[dict[str, Any]],
         tracing_extra: dict[str, Any],
         **kwargs: Any,
-    ):
+    ) -> str:
         """Get a response from the LLM.
 
         Args:
-            messages (list[dict[str, Any]]): The messages for the LLM.
-            tracing_extra (dict[str, Any]): The extra tracing information.
+            messages: The messages for the LLM.
+            tracing_extra: The extra tracing information.
+            **kwargs: Additional arguments to pass to the LLM.
 
         Returns:
-            str: The response from the LLM.
+            The response from the LLM.
+
+        Raises:
+            ImportError: If OpenAI is not installed.
         """
-        client = wrap_openai(AsyncOpenAI(api_key=self.api_key))
-        response = await client.chat.completions.create(
-            messages=messages,  # type: ignore
-            model=self.model_name,
-            response_format={"type": "json_object"},
-            langsmith_extra=tracing_extra,
-            **kwargs,
-        )
-        return response.choices[0].message.content
+        try:
+            from openai import AsyncOpenAI
+
+            client = AsyncOpenAI(api_key=self.api_key)
+
+            # Create OpenAI completion
+            response = await client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,  # type: ignore
+                response_format={"type": "json_object"},
+                **kwargs,
+            )
+
+            # Track the LLM call using the observability provider
+            self.observability.track_llm_call(
+                name="openai_chat_completion",
+                model=self.model_name,
+                messages=messages,
+                response=response,
+                metadata=tracing_extra,
+            )
+
+            return response.choices[0].message.content
+        except ImportError as e:
+            logger.error(f"Failed to import OpenAI: {e}")
+            raise ImportError("OpenAI is not installed. Install it with: pip install econagents[openai]") from e

econagents-0.0.3.dist-info/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.dist-info → econagents-0.0.3.dist-info}/METADATA

@@ -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.3.dist-info/RECORD

@@ -0,0 +1,25 @@
+econagents/__init__.py,sha256=gFWs83sRb_j9pq30PhclH3DNXifyHiPMz0IKN1O4xJk,1111
+econagents/_c_extension.pyi,sha256=evVvDNUCGqyMPrNViPF7QXfGUNNIMbUdY5HemRNQ1_o,113
+econagents/core/__init__.py,sha256=QZoOp6n5CX1j-Ob6PZgyCNY78vi2kWmd_LVLrJUj1TU,393
+econagents/core/agent_role.py,sha256=MA0aaTEWiI5NLSKN2YmWHb8gBYljtDVlLOSpohkv45M,15895
+econagents/core/events.py,sha256=hx-Ru_NoSISuN--7ZFC3CIql5hry3AATSnHZJJv3Kds,294
+econagents/core/game_runner.py,sha256=lrujwoeL3lXwCInA9msu6YvovCJuBUTcV0DrnyryQDE,14099
+econagents/core/logging_mixin.py,sha256=tYsRc5ngW-hzfElrb838KO-9-BGOPyUv2v5LLuJToBE,1421
+econagents/core/manager/__init__.py,sha256=bDpCQlFcw_E-js575X3Xl6iwZ1uILC18An1vt6oE7S4,284
+econagents/core/manager/base.py,sha256=qJyqBaUz0dMz3XCny4YydJ8iV6mqEy5osKgL2lNozkc,19032
+econagents/core/manager/phase.py,sha256=gx1ku_hPVmT-BgKTdc55BSZ56Qd3fN1smUgjPbYYtCs,19268
+econagents/core/state/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+econagents/core/state/fields.py,sha256=YxVOqdriaHRHoyeXsIB8ZDHygneMJD1OikOyeILK_oA,1854
+econagents/core/state/game.py,sha256=6J3xV_SViShwBNgcWc_sK1dQPNO8Abb7qONFF0d4qVs,9729
+econagents/core/state/market.py,sha256=Jg-X9mYH6B3cYOwxzjFDV5PDbCIYxipx2UN4ecfyyDE,3909
+econagents/core/transport.py,sha256=7eq31nb2KY67RuL5i2kxJrcGtwfcVm5qy0eVj4_xWQw,5063
+econagents/llm/__init__.py,sha256=J1PqpG3wL41oBAfzp5QaaP2ekwxCM_tiRq4H0OeSv4w,482
+econagents/llm/base.py,sha256=TFZhot8ffW-2JAOxDxeCG8V5Nn56ulSjCzJwSBopKg0,1726
+econagents/llm/observability.py,sha256=WSkJ7lZZl2FVpDWpFivudoeOENR_lyLZscUisveAi6k,9467
+econagents/llm/ollama.py,sha256=0ElnQhyCCAOu6u-TIC2JeNzh8OV6_VZjchFpi1F3HxU,2242
+econagents/llm/openai.py,sha256=x1L9GS2DXNvPTECXP6DVMwr9fuhcHMZh_2k8ds30i-Y,2395
+econagents/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+econagents-0.0.3.dist-info/LICENSE,sha256=Bd4MAEaMayyDO5BncOl3q0T2b6sWcjABigXLRFxgKIU,1082
+econagents-0.0.3.dist-info/METADATA,sha256=Ks0NdoiMiHBGGWZmJpY3fPurimnzd38RnWX3lzN5KSE,3557
+econagents-0.0.3.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+econagents-0.0.3.dist-info/RECORD,,

{econagents-0.0.1.dist-info → econagents-0.0.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.1
+Generator: poetry-core 2.1.2
 Root-Is-Purelib: true
 Tag: py3-none-any

econagents-0.0.1.dist-info/RECORD

@@ -1,21 +0,0 @@
-econagents/__init__.py,sha256=7oAI7W8akjmKDPArgmCjA7SDpWqvI7eLPbGeBRTiEzc,1050
-econagents/_c_extension.pyi,sha256=evVvDNUCGqyMPrNViPF7QXfGUNNIMbUdY5HemRNQ1_o,113
-econagents/core/__init__.py,sha256=QZoOp6n5CX1j-Ob6PZgyCNY78vi2kWmd_LVLrJUj1TU,393
-econagents/core/agent_role.py,sha256=viT7V6U9AmwDplgr4xGIVQvm3vLMtIFpGaMcGKM4oWE,15216
-econagents/core/events.py,sha256=hx-Ru_NoSISuN--7ZFC3CIql5hry3AATSnHZJJv3Kds,294
-econagents/core/game_runner.py,sha256=CToHQWIWQ1dwFLWRBxgFGlNecOjtlQUx3YbuS4cfOFQ,12869
-econagents/core/logging_mixin.py,sha256=tYsRc5ngW-hzfElrb838KO-9-BGOPyUv2v5LLuJToBE,1421
-econagents/core/manager/__init__.py,sha256=bDpCQlFcw_E-js575X3Xl6iwZ1uILC18An1vt6oE7S4,284
-econagents/core/manager/base.py,sha256=IMGkyCrghHlkJnkQLGUVfUSSr7sqZsKHYsmgf4UtGlI,16186
-econagents/core/manager/phase.py,sha256=M7s7jyA99BESXC1V9VNBuAOcvVncGoN5lF1nK8dh0Eo,19632
-econagents/core/state/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-econagents/core/state/fields.py,sha256=YxVOqdriaHRHoyeXsIB8ZDHygneMJD1OikOyeILK_oA,1854
-econagents/core/state/game.py,sha256=Ux0s7WhOxu0aFvwgX_LM0Aiho-aa1N3yh1ManwWBRP4,8681
-econagents/core/state/market.py,sha256=Jg-X9mYH6B3cYOwxzjFDV5PDbCIYxipx2UN4ecfyyDE,3909
-econagents/core/transport.py,sha256=7eq31nb2KY67RuL5i2kxJrcGtwfcVm5qy0eVj4_xWQw,5063
-econagents/llm/__init__.py,sha256=-tgv6qf77EdceWENIX6pDWXxu2AumhuUCjLiv4FmGKk,82
-econagents/llm/openai.py,sha256=1w8nHr8Ge2aEzO8lEsxKO3tUgLPEaGhYLwYu12653GY,1782
-econagents/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-econagents-0.0.1.dist-info/METADATA,sha256=N9v2yhoCGJ_2JdYq-lZQzoE7QKtMHqDamEDVAQVjAno,3431
-econagents-0.0.1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-econagents-0.0.1.dist-info/RECORD,,