dojozero 0.3.0__tar.gz → 0.4.0__tar.gz

{dojozero-0.3.0 → dojozero-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dojozero
-Version: 0.3.0
+Version: 0.4.0
 Summary: A platform for running AI agents on realtime sport data and make predictions about game outcomes.
 Project-URL: Homepage, https://github.com/agentscope-ai/DojoZero
 Project-URL: Repository, https://github.com/agentscope-ai/DojoZero
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.11
-Requires-Dist: agentscope[gemini]>=1.0.14
+Requires-Dist: agentscope[gemini]<2,>=1.0.14
 Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: dashscope>=1.0.0
 Requires-Dist: fastapi>=0.128.0

{dojozero-0.3.0 → dojozero-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dojozero"
-version = "0.3.0"
+version = "0.4.0"
 description = "A platform for running AI agents on realtime sport data and make predictions about game outcomes."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -26,7 +26,7 @@ dependencies = [
     "PyYAML>=6.0",
     "pydantic>=2.12.4",
     "aiohttp>=3.9.0",
-    "agentscope[gemini]>=1.0.14",
+    "agentscope[gemini]>=1.0.14,<2",
     "py-clob-client>=0.1.0",
     "fastapi>=0.128.0",
     "uvicorn>=0.40.0",

{dojozero-0.3.0 → dojozero-0.4.0}/src/dojozero/agents/_config.py

@@ -122,8 +122,14 @@ def load_persona_config(config_path: str | Path) -> PersonaConfig:
         Parsed PersonaConfig dictionary
     """
     path = Path(config_path)
-    with path.open("r", encoding="utf-8") as f:
-        data: dict[str, Any] = yaml.safe_load(f)
+    try:
+        with path.open("r", encoding="utf-8") as f:
+            data: dict[str, Any] = yaml.safe_load(f)
+    except FileNotFoundError as e:
+        raise FileNotFoundError(
+            f"Persona config file not found: {path}. Check the persona_config_path "
+            "referenced by your agent or trial-source config."
+        ) from e
 
     return PersonaConfig(sys_prompt=data.get("sys_prompt", ""))
 
@@ -156,8 +162,14 @@ def load_llm_file_config(config_path: str | Path) -> LLMFileConfig:
         Parsed LLMFileConfig dictionary with llm as a list of LLMConfig
     """
     path = Path(config_path)
-    with path.open("r", encoding="utf-8") as f:
-        data: dict[str, Any] = yaml.safe_load(f)
+    try:
+        with path.open("r", encoding="utf-8") as f:
+            data: dict[str, Any] = yaml.safe_load(f)
+    except FileNotFoundError as e:
+        raise FileNotFoundError(
+            f"LLM config file not found: {path}. Check the llm_config_path "
+            "referenced by your agent or trial-source config."
+        ) from e
 
     llm_configs: list[LLMConfig] = []
 

{dojozero-0.3.0 → dojozero-0.4.0}/src/dojozero/arena_server/_cache.py

@@ -62,7 +62,7 @@ class CacheConfig:
 from dojozero.arena_server._config import ArenaServerConfig  # noqa: E402
 
 DEFAULT_CACHE_CONFIG = CacheConfig()
-CACHEABLE_LEAGUES: frozenset[str] = frozenset({"NBA", "NFL"})
+CACHEABLE_LEAGUES: frozenset[str] = frozenset({"NBA", "NFL", "WORLD_CUP"})
 LEADERBOARD_PERIODS: tuple[str, ...] = ("7d", "14d", "30d")
 
 
@@ -102,7 +102,7 @@ class LandingPageCache:
     - leaderboard: Agent rankings (global + per-league)
     - agent_actions: Recent agent actions (global + per-league)
 
-    Per-league caches are maintained for CACHEABLE_LEAGUES (NBA, NFL).
+    Per-league caches are maintained for CACHEABLE_LEAGUES.
 
     Note: No lock is needed because BackgroundRefresher is the single writer
     and Python's GIL ensures atomic reference assignments.

{dojozero-0.3.0 → dojozero-0.4.0}/src/dojozero/arena_server/_server.py

@@ -29,7 +29,7 @@ Filtering:
 
     Supported endpoints: /api/landing, /api/stats, /api/games, /api/leaderboard, /api/agent-actions
 
-    Per-league results are cached separately for leagues in CACHEABLE_LEAGUES (NBA, NFL).
+    Per-league results are cached separately for leagues in CACHEABLE_LEAGUES.
     To add a new league, update CACHEABLE_LEAGUES in the code.
 
 Configuration:
@@ -90,6 +90,7 @@ from dojozero.arena_server._utils import (
     _compute_leaderboard,
     _compute_leaderboard_from_spans,
     _load_replay_data,
+    ARENA_RENDERED_OPERATIONS,
     TRIAL_INFO_OPERATION_NAMES,
     trial_id_for_span_grouping,
 )
@@ -789,7 +790,11 @@ class BackgroundRefresher:
             tid: str, span_start: datetime | None
         ) -> tuple[str, list[SpanData]]:
             async with sem:
-                spans = await self.trace_reader.get_spans(tid, start_time=span_start)
+                spans = await self.trace_reader.get_spans(
+                    tid,
+                    start_time=span_start,
+                    operation_names=ARENA_RENDERED_OPERATIONS,
+                )
                 return tid, spans
 
         if is_initial or self._last_span_fetch_time is None:
@@ -1417,7 +1422,9 @@ class BackgroundRefresher:
 
         # Fallback to SLS (slow path)
         if not spans:
-            spans = await self.trace_reader.get_spans(trial_id)
+            spans = await self.trace_reader.get_spans(
+                trial_id, operation_names=ARENA_RENDERED_OPERATIONS
+            )
 
         existing = self.cache.get_trial_details(trial_id)
 

{dojozero-0.3.0 → dojozero-0.4.0}/src/dojozero/arena_server/_utils.py

@@ -58,6 +58,42 @@ TRIAL_INFO_OPERATION_NAMES = [
     "event.ncaa_game_update",
 ]
 
+
+def _build_arena_rendered_operations() -> list[str]:
+    """Enumerate every operation name that arena actually renders.
+
+    Used as a server-side whitelist when calling trace readers so that large
+    span types the arena does not render (notably GenAI ``chat`` spans) never
+    reach the UI's read path.
+
+    Derived from the dispatch table in ``core/_models.py::deserialize_span``
+    plus the registered ``EventTypes`` enum and ``BrokerStateChangeType``
+    literals. Must be kept in sync with ``deserialize_span``; the unit test
+    ``test_arena_projection`` asserts the invariant.
+    """
+    from dojozero.data import EventTypes
+
+    ops: list[str] = [
+        "trial.started",
+        "trial.stopped",
+        "trial.terminated",
+        "agent.response",
+        "agent.agent_initialize",
+        "broker.bet",
+        "broker.state_update",
+        "broker.bet_executed",
+        "broker.final_stats",
+    ]
+    # All registered event types (event.*).
+    for item in EventTypes:
+        ops.append(str(item.value))
+    return ops
+
+
+# Arena renders only these operation names. Any span type not listed here (in
+# particular GenAI ``chat`` spans) is filtered out server-side.
+ARENA_RENDERED_OPERATIONS: list[str] = _build_arena_rendered_operations()
+
 # Tag used by DojoZero to correlate all spans for a trial (see TrialOrchestrator, create_span_from_event).
 _TRIAL_ID_TAG = "dojozero.trial.id"
 
@@ -923,6 +959,8 @@ def _compute_leaderboard_from_spans(
 
     agent_stats: dict[str, _AgentStats] = {}
     agent_bets: dict[str, list[BetRecord]] = {}
+    has_prediction_data = False
+    agent_pred_stats: dict[str, dict[str, Any]] = {}
 
     # Filter to requested trials or use all
     trials_to_process = (
@@ -1031,6 +1069,26 @@ def _compute_leaderboard_from_spans(
                 # Fill is_external/created_at from accounts (one pass)
                 _fill_account_info(typed)
 
+                # Collect prediction stats in the same pass
+                if typed.prediction_statistics:
+                    has_prediction_data = True
+                    for agent_id, pred_stat in typed.prediction_statistics.items():
+                        if agent_id not in agent_pred_stats:
+                            agent_pred_stats[agent_id] = {
+                                "total_score": 0.0,
+                                "total_predictions": 0,
+                                "correct_predictions": 0,
+                            }
+                        agent_pred_stats[agent_id]["total_score"] += float(
+                            pred_stat.total_score
+                        )
+                        agent_pred_stats[agent_id]["total_predictions"] += (
+                            pred_stat.total_predictions
+                        )
+                        agent_pred_stats[agent_id]["correct_predictions"] += (
+                            pred_stat.correct_predictions
+                        )
+
                 if use_date_filter:
                     # Date-filtered: recompute from individual bets
                     # Track per-agent wagered/profit within this trial
@@ -1098,26 +1156,100 @@ def _compute_leaderboard_from_spans(
 
     # Convert to sorted list
     leaderboard: list[LeaderboardEntry] = []
-    for stats in agent_stats.values():
-        win_rate = (stats.wins / stats.total_bets * 100) if stats.total_bets > 0 else 0
-        roi = (
-            (stats.winnings / stats.total_wagered * 100)
-            if stats.total_wagered > 0
-            else 0
-        )
-        sharpe = _compute_sharpe(stats.per_trial_rois)
-
-        leaderboard.append(
-            LeaderboardEntry(
-                agent=stats.agent,
-                winnings=round(stats.winnings, 2),
-                winRate=round(win_rate, 1),
-                totalBets=stats.total_bets,
-                roi=round(roi, 1),
-                sharpe=round(sharpe, 2),
-                createdAt=stats.agent.created_at,
+
+    # Handle prediction-based leaderboard if available
+    if has_prediction_data:
+        all_agent_ids = set(list(agent_stats.keys()) + list(agent_pred_stats.keys()))
+
+        for agent_id in all_agent_ids:
+            agent_info = None
+
+            # Get agent info from existing stats or create default
+            if agent_id in agent_stats:
+                agent_info = agent_stats[agent_id].agent
+                winnings = agent_stats[agent_id].winnings
+                wins = agent_stats[agent_id].wins
+                total_bets = agent_stats[agent_id].total_bets
+                total_wagered = agent_stats[agent_id].total_wagered
+                per_trial_rois = agent_stats[agent_id].per_trial_rois
+            else:
+                agent_info = agent_info_cache.get(agent_id)
+                if agent_info is None:
+                    agent_info = AgentInfo(agent_id=agent_id, persona=agent_id)
+                winnings = 0.0
+                wins = 0
+                total_bets = 0
+                total_wagered = 0.0
+                per_trial_rois = []
+
+            # Calculate prediction stats
+            pred_score = None
+            accuracy = None
+            if agent_id in agent_pred_stats:
+                stats = agent_pred_stats[agent_id]
+                pred_score = round(stats["total_score"], 2)
+                if stats["total_predictions"] > 0:
+                    accuracy = round(
+                        (stats["correct_predictions"] / stats["total_predictions"])
+                        * 100,
+                        1,
+                    )
+
+            # Calculate traditional stats
+            win_rate = (wins / total_bets * 100) if total_bets > 0 else 0
+            roi = (winnings / total_wagered * 100) if total_wagered > 0 else 0
+            sharpe = _compute_sharpe(per_trial_rois)
+
+            leaderboard.append(
+                LeaderboardEntry(
+                    agent=agent_info,
+                    winnings=round(winnings, 2),
+                    winRate=round(win_rate, 1),
+                    totalBets=total_bets,
+                    roi=round(roi, 1),
+                    sharpe=round(sharpe, 2),
+                    createdAt=agent_info.created_at,
+                    predictionScore=pred_score,
+                    accuracy=accuracy,
+                )
+            )
+    else:
+        # Use traditional betting-based leaderboard
+        for stats in agent_stats.values():
+            win_rate = (
+                (stats.wins / stats.total_bets * 100) if stats.total_bets > 0 else 0
+            )
+            roi = (
+                (stats.winnings / stats.total_wagered * 100)
+                if stats.total_wagered > 0
+                else 0
+            )
+            sharpe = _compute_sharpe(stats.per_trial_rois)
+
+            leaderboard.append(
+                LeaderboardEntry(
+                    agent=stats.agent,
+                    winnings=round(stats.winnings, 2),
+                    winRate=round(win_rate, 1),
+                    totalBets=stats.total_bets,
+                    roi=round(roi, 1),
+                    sharpe=round(sharpe, 2),
+                    createdAt=stats.agent.created_at,
+                )
             )
-        )
+
+    # Determine which field to sort by based on available data.
+    # In prediction mode there is no balance/ROI/win-rate, so all betting sort
+    # keys must remap to prediction_score — otherwise the lambdas return 0 for
+    # every entry and the sort is deterministically wrong.
+    effective_sort_by = sort_by
+    if has_prediction_data and sort_by in (
+        "winnings",
+        "win_rate",
+        "roi",
+        "total_bets",
+    ):
+        effective_sort_by = "prediction_score"
 
     # Sort by requested field
     sort_key_map: dict[str, Any] = {
@@ -1126,8 +1258,12 @@ def _compute_leaderboard_from_spans(
         "roi": lambda x: x.roi,
         "sharpe": lambda x: x.sharpe,
         "total_bets": lambda x: x.total_bets,
+        "prediction_score": lambda x: (
+            x.prediction_score if x.prediction_score is not None else -float("inf")
+        ),
+        "accuracy": lambda x: x.accuracy if x.accuracy is not None else -float("inf"),
     }
-    key_fn = sort_key_map.get(sort_by, sort_key_map["winnings"])
+    key_fn = sort_key_map.get(effective_sort_by, sort_key_map["winnings"])
     leaderboard.sort(key=key_fn, reverse=(sort_order != "asc"))
 
     entries = leaderboard[:limit] if limit is not None else leaderboard
@@ -1392,7 +1528,9 @@ async def _load_replay_data(
 
     if not spans:
         try:
-            spans = await trace_reader.get_spans(trial_id)
+            spans = await trace_reader.get_spans(
+                trial_id, operation_names=ARENA_RENDERED_OPERATIONS
+            )
         except Exception as e:
             LOGGER.error("Failed to fetch spans for replay: %s", e)
             return None, "trial_not_found"

{dojozero-0.3.0 → dojozero-0.4.0}/src/dojozero/betting/__init__.py

@@ -2,27 +2,14 @@
 
 This module provides reusable components for sports betting scenarios:
 - BettingAgent: Generic LLM-powered betting agent
-- BrokerOperator: Sport-agnostic betting broker managing accounts, bets, and events
+- BrokerOperator: Sport-agnostic classic betting broker (accounts, bets, odds)
+- PredictionBroker: Sport-agnostic prediction-contest broker with five
+  fixed windows (pre-game and Q1-Q4) and shared per-window prize pools
 
 These components work with any sport (NBA, NFL, etc.) by:
 1. Handling sport-prefixed event types (e.g., "nfl_game_start" -> "game_start")
 2. Supporting pluggable event formatters for sport-specific display
 3. Converting between different odds formats (decimal, American moneyline)
-
-Example usage:
-    from dojozero.betting import BettingAgent, BrokerOperator
-
-    # Create broker
-    broker_config = {"actor_id": "broker", "initial_balance": "1000"}
-    broker = BrokerOperator(broker_config, trial_id)
-
-    # Create agent with custom formatter
-    agent = BettingAgent.from_yaml(
-        config_path="agent.yaml",
-        actor_id="agent1",
-        trial_id=trial_id,
-        event_formatter=my_custom_formatter,
-    )
 """
 
 from dojozero.betting._agent import (
@@ -50,9 +37,14 @@ from dojozero.betting._models import (
     BetStatus,
     BetType,
     BettingEvent,
+    BettingFinalStats,
     BrokerFinalStats,
     EventStatus,
     OrderType,
+    Prediction,
+    PredictionFinalStats,
+    PredictionOutcome,
+    PredictionStatistics,
     Statistics,
     StatisticsList,
     # Agent Message Models
@@ -68,6 +60,16 @@ from dojozero.betting._broker import (
     BrokerOperator,
     BrokerOperatorConfig,
 )
+from dojozero.betting._prediction_broker import (
+    PredictionBroker,
+    PredictionBrokerConfig,
+)
+from dojozero.betting._protocol import ContestOperator
+from dojozero.betting._scoring import (
+    DEFAULT_WINDOW_POOLS,
+    NUM_WINDOWS,
+    settle_window_predictions,
+)
 
 __all__ = [
     # Agent
@@ -79,9 +81,17 @@ __all__ = [
     # Metadata types
     "BettingTrialMetadata",
     "BacktestBettingTrialMetadata",
-    # Broker
+    # Brokers
     "BrokerOperator",
     "BrokerOperatorConfig",
+    "PredictionBroker",
+    "PredictionBrokerConfig",
+    "ContestOperator",
+    # Scoring
+    "DEFAULT_WINDOW_POOLS",
+    "NUM_WINDOWS",
+    "settle_window_predictions",
+    # Domain models
     "Account",
     "BettingEvent",
     "BetRequest",
@@ -93,6 +103,11 @@ __all__ = [
     "BetSettledPayload",
     "Statistics",
     "BrokerFinalStats",
+    "BettingFinalStats",
+    "PredictionFinalStats",
+    "Prediction",
+    "PredictionOutcome",
+    "PredictionStatistics",
     # Enums
     "EventStatus",
     "OrderType",

{dojozero-0.3.0 → dojozero-0.4.0}/src/dojozero/betting/_agent.py

@@ -11,6 +11,7 @@ import json
 import logging
 import time
 from collections import deque
+from datetime import datetime, timezone
 from typing import Any, Callable, Mapping, Sequence, TypedDict, cast
 
 from agentscope.agent import ReActAgent
@@ -27,7 +28,12 @@ from dojozero.agents import (
     create_toolkit,
 )
 from dojozero.core import RuntimeContext, Agent, AgentBase, Operator, StreamEvent
-from dojozero.core._tracing import create_span_from_event, emit_span
+from dojozero.core._tracing import (
+    SpanData,
+    create_span_from_event,
+    emit_span,
+    emit_span_sls_only,
+)
 from dojozero.betting._config import MEMORY_SUMMARY_PROMPT
 from dojozero.data._models import (
     BaseGameUpdateEvent,
@@ -318,7 +324,9 @@ class BettingAgent(AgentBase, Agent[BettingAgentConfig]):
         event_formatter: EventFormatter | None = None,
     ) -> None:
         super().__init__(actor_id, trial_id)
-        # Create internal ReActAgent for LLM reasoning
+        # Create internal ReActAgent for LLM reasoning. LLM-level OTel GenAI
+        # spans are emitted by AgentScope's built-in ``@trace_llm`` decorator,
+        # wired via ``enable_agentscope_tracing()`` at server startup.
         self._react_agent = ReActAgent(
             name=name,
             sys_prompt=sys_prompt,
@@ -603,19 +611,26 @@ class BettingAgent(AgentBase, Agent[BettingAgentConfig]):
         )
 
     async def register_operators(self, operators: Sequence[Operator]) -> None:
-        """Register operators and auto-register broker tools if available."""
+        """Register operators and auto-register broker tools if available.
+
+        The agent's system prompt is *not* modified here. Contest rules and
+        operator-specific information are obtained at runtime via tools (e.g.
+        ``get_rules`` exposed by :class:`PredictionBroker`) so that internal
+        and external (gateway) agents follow the same discovery flow.
+        """
         all_tools = []
+
         for op in operators:
             self._operator_registry[op.actor_id] = op
             logger.info(
                 "agent '%s' registered operator '%s'", self.actor_id, op.actor_id
             )
+
             agent_tools = getattr(op, "agent_tools", None)
             if callable(agent_tools):
                 tools_result = agent_tools(self.actor_id, operator=op)
                 if inspect.iscoroutine(tools_result):
                     tools_result = await tools_result
-                # After awaiting, tools_result should be a list
                 if isinstance(tools_result, list):
                     all_tools.extend(tools_result)
                     logger.info(
@@ -774,26 +789,14 @@ class BettingAgent(AgentBase, Agent[BettingAgentConfig]):
         )
         emit_span(span)
 
-    def _emit_response_span(self, message: AgentResponseMessage) -> None:
-        """Emit a span for agent response to the OTel exporter.
-
-        Args:
-            message: Structured agent response message (includes bet fields if present)
-        """
-        # Build tags from message, excluding None values (e.g., empty bet fields)
+    def _response_tags(self, message: AgentResponseMessage) -> dict[str, Any]:
+        """Build the tag dict for an ``agent.response`` span."""
         tags = message.model_dump(exclude_none=True)
-
-        # Serialize cot_steps to JSON string for proper display in tracing UI
         if "cot_steps" in tags:
             tags["cot_steps"] = json.dumps(tags["cot_steps"])
-
-        span = create_span_from_event(
-            trial_id=self.trial_id,
-            actor_id=self.actor_id,
-            operation_name="agent.response",
-            extra_tags=tags,
-        )
-        emit_span(span)
+        tags["actor.id"] = self.actor_id
+        tags["dojozero.trial.id"] = self.trial_id
+        return tags
 
     def _format_events_for_llm(self, events: list[StreamEvent[Any]]) -> str:
         """Format multiple events into a consolidated LLM-friendly message.
@@ -939,48 +942,88 @@ class BettingAgent(AgentBase, Agent[BettingAgentConfig]):
         memory_before = await self.memory.get_memory()
         memory_before_dicts = [m.to_dict() for m in memory_before]
 
-        # Call agent
-        response = await self._react_agent(msg)
-
-        # Capture memory state AFTER agent call
-        memory_after = await self.memory.get_memory()
-        memory_after_dicts = [m.to_dict() for m in memory_after]
-        self._state = memory_after_dicts
-
-        # Get only this turn's new messages
-        turn_messages = _extract_memory_diff(memory_before_dicts, memory_after_dicts)
-
-        # Emit span for agent response
-        if response is not None:
-            response_content = getattr(response, "content", None)
-            text_content, _ = _parse_response_content(response_content)
-
-            # Parse CoT steps and bet info from this turn's messages
-            cot_steps = _parse_cot_steps(turn_messages)
-            bet = _extract_bet_from_tool_calls(turn_messages)
-
-            # Build trigger safely (empty string if no events)
-            trigger = ""
-            if events:
-                last_payload = events[-1].payload
-                if isinstance(last_payload, HotTopicsEvent):
-                    trigger = format_hot_topics_for_llm(last_payload)
-                elif _is_formattable_payload(last_payload):
-                    trigger = self._event_formatter(last_payload)
-
-            # Emit agent response span with structured message (includes bet fields if present)
-            response_message = AgentResponseMessage(
-                sequence=self._event_count,
-                stream_id=primary_stream_id,
-                agent_id=self.actor_id,
-                content=text_content,
-                cot_steps=cot_steps,
-                trigger=trigger,
-                game_id=game_id,
-                # Bet fields - None if no bet, otherwise populated from bet dict
-                **(bet or {}),
+        # Open a real OTel context-managed span for agent.response so that the
+        # ``chat`` spans AgentScope's ``@trace_llm`` emits from inside
+        # ``_react_agent`` become children via OTel context propagation. After
+        # the span closes we also mirror it to SLS (flat-log logstore).
+        from opentelemetry import trace as _otel_trace
+
+        tracer = _otel_trace.get_tracer("dojozero.agent")
+        response_start = datetime.now(timezone.utc)
+        response_start_us = int(response_start.timestamp() * 1_000_000)
+        response_start_mono = time.monotonic()
+
+        response: Any = None
+        response_tags: dict[str, Any] | None = None
+        otel_span_id: int = 0
+        with tracer.start_as_current_span("agent.response") as otel_span:
+            # Identifiers useful for an error span (before response_tags
+            # overwrites / adds to them on the success path).
+            otel_span.set_attribute("actor.id", self.actor_id)
+            otel_span.set_attribute("dojozero.trial.id", self.trial_id)
+            otel_span.set_attribute("sequence", self._event_count)
+
+            # Let the context manager's __exit__ record exceptions / set
+            # ERROR status automatically if the model call raises.
+            response = await self._react_agent(msg)
+
+            # Capture memory state AFTER agent call
+            memory_after = await self.memory.get_memory()
+            memory_after_dicts = [m.to_dict() for m in memory_after]
+            self._state = memory_after_dicts
+
+            # Get only this turn's new messages
+            turn_messages = _extract_memory_diff(
+                memory_before_dicts, memory_after_dicts
+            )
+
+            if response is not None:
+                response_content = getattr(response, "content", None)
+                text_content, _ = _parse_response_content(response_content)
+
+                cot_steps = _parse_cot_steps(turn_messages)
+                bet = _extract_bet_from_tool_calls(turn_messages)
+
+                trigger = ""
+                if events:
+                    last_payload = events[-1].payload
+                    if isinstance(last_payload, HotTopicsEvent):
+                        trigger = format_hot_topics_for_llm(last_payload)
+                    elif _is_formattable_payload(last_payload):
+                        trigger = self._event_formatter(last_payload)
+
+                response_message = AgentResponseMessage(
+                    sequence=self._event_count,
+                    stream_id=primary_stream_id,
+                    agent_id=self.actor_id,
+                    content=text_content,
+                    cot_steps=cot_steps,
+                    trigger=trigger,
+                    game_id=game_id,
+                    **(bet or {}),
+                )
+                response_tags = self._response_tags(response_message)
+                for key, value in response_tags.items():
+                    if isinstance(value, (str, int, float, bool)):
+                        otel_span.set_attribute(key, value)
+                    elif value is not None:
+                        otel_span.set_attribute(key, str(value))
+
+            otel_span_id = otel_span.get_span_context().span_id
+
+        response_duration_us = int((time.monotonic() - response_start_mono) * 1_000_000)
+
+        if response_tags is not None:
+            sls_span = SpanData(
+                trace_id=self.trial_id,
+                span_id=f"{otel_span_id:016x}",
+                operation_name="agent.response",
+                start_time=response_start_us,
+                duration=response_duration_us,
+                parent_span_id=None,
+                tags=response_tags,
             )
-            self._emit_response_span(response_message)
+            emit_span_sls_only(sls_span)
         # Compact memory for next iteration when context becomes too large
         if (
             self._estimate_memory_tokens(memory_after_dicts)