langwatch-scenario 0.7.2__py3-none-any.whl → 0.7.7__py3-none-any.whl

{langwatch_scenario-0.7.2.dist-info → langwatch_scenario-0.7.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langwatch-scenario
-Version: 0.7.2
+Version: 0.7.7
 Summary: The end-to-end agent testing library
 Author-email: LangWatch Team <support@langwatch.ai>
 License: MIT
@@ -30,12 +30,12 @@ Requires-Dist: pksuid>=1.1.2
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rx>=3.2.0
 Requires-Dist: python-dateutil>=2.9.0.post0
+Requires-Dist: pydantic-settings>=2.9.1
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
-Requires-Dist: commitizen; extra == "dev"
 Requires-Dist: pyright; extra == "dev"
 Requires-Dist: pydantic-ai; extra == "dev"
 Requires-Dist: function-schema; extra == "dev"
@@ -88,7 +88,7 @@ result = await scenario.run(
     # Define the agents that will play this simulation
     agents=[
         WeatherAgent(),
-        scenario.UserSimulatorAgent(model="openai/gpt-4.1-mini"),
+        scenario.UserSimulatorAgent(model="openai/gpt-4.1"),
     ],
 
     # (Optional) Control the simulation
@@ -159,7 +159,7 @@ import pytest
 import scenario
 import litellm
 
-scenario.configure(default_model="openai/gpt-4.1-mini")
+scenario.configure(default_model="openai/gpt-4.1")
 
 
 @pytest.mark.agent_test
@@ -189,6 +189,7 @@ async def test_vegetarian_recipe_agent():
                 ]
             ),
         ],
+        set_id="python-examples",
     )
 
     # Assert for pytest to know whether the test passed
@@ -202,7 +203,7 @@ import litellm
 @scenario.cache()
 def vegetarian_recipe_agent(messages) -> scenario.AgentReturnTypes:
     response = litellm.completion(
-        model="openai/gpt-4.1-mini",
+        model="openai/gpt-4.1",
         messages=[
             {
                 "role": "system",
@@ -227,17 +228,17 @@ def vegetarian_recipe_agent(messages) -> scenario.AgentReturnTypes:
 Save it as `tests/vegetarian-recipe-agent.test.ts`:
 
 ```typescript
+import scenario, { type AgentAdapter, AgentRole } from "@langwatch/scenario";
 import { openai } from "@ai-sdk/openai";
-import * as scenario from "@langwatch/scenario";
 import { generateText } from "ai";
 import { describe, it, expect } from "vitest";
 
 describe("Vegetarian Recipe Agent", () => {
-  const agent: scenario.AgentAdapter = {
-    role: scenario.AgentRole.AGENT,
+  const agent: AgentAdapter = {
+    role: AgentRole.AGENT,
     call: async (input) => {
       const response = await generateText({
-        model: openai("gpt-4.1-mini"),
+        model: openai("gpt-4.1"),
         messages: [
           {
             role: "system",
@@ -258,7 +259,7 @@ describe("Vegetarian Recipe Agent", () => {
         agent,
         scenario.userSimulatorAgent(),
         scenario.judgeAgent({
-          model: openai("gpt-4.1-mini"),
+          model: openai("gpt-4.1"),
           criteria: [
             "Agent should not ask more than two follow-up questions",
             "Agent should generate a recipe",
@@ -268,6 +269,7 @@ describe("Vegetarian Recipe Agent", () => {
           ],
         }),
       ],
+      setId: "javascript-examples",
     });
     expect(result.success).toBe(true);
   });
@@ -417,7 +419,7 @@ You can enable debug mode by setting the `debug` field to `True` in the `Scenari
 Debug mode allows you to see the messages in slow motion step by step, and intervene with your own inputs to debug your agent from the middle of the conversation.
 
 ```python
-scenario.configure(default_model="openai/gpt-4.1-mini", debug=True)
+scenario.configure(default_model="openai/gpt-4.1", debug=True)
 ```
 
 or
@@ -431,7 +433,7 @@ pytest -s tests/test_vegetarian_recipe_agent.py --debug
 Each time the scenario runs, the testing agent might chose a different input to start, this is good to make sure it covers the variance of real users as well, however we understand that the non-deterministic nature of it might make it less repeatable, costly and harder to debug. To solve for it, you can use the `cache_key` field in the `Scenario.configure` method or in the specific scenario you are running, this will make the testing agent give the same input for given the same scenario:
 
 ```python
-scenario.configure(default_model="openai/gpt-4.1-mini", cache_key="42")
+scenario.configure(default_model="openai/gpt-4.1", cache_key="42")
 ```
 
 To bust the cache, you can simply pass a different `cache_key`, disable it, or delete the cache files located at `~/.scenario/cache`.
@@ -450,6 +452,48 @@ class MyAgent:
 
 This will cache any function call you decorate when running the tests and make them repeatable, hashed by the function arguments, the scenario being executed, and the `cache_key` you provided. You can exclude arguments that should not be hashed for the cache key by naming them in the `ignore` argument.
 
+## Grouping Your Sets and Batches
+
+While optional, we strongly recommend setting stable identifiers for your scenarios, sets, and batches for better organization and tracking in LangWatch.
+
+- **set_id**: Groups related scenarios into a test suite. This corresponds to the "Simulation Set" in the UI.
+- **batch_run_id**: Groups all scenarios that were run together in a single execution (e.g., a single CI job). This is automatically generated but can be overridden.
+
+```python
+import os
+
+result = await scenario.run(
+    name="my first scenario",
+    description="A simple test to see if the agent responds.",
+    set_id="my-test-suite",
+    agents=[
+        scenario.Agent(my_agent),
+        scenario.UserSimulatorAgent(),
+    ]
+)
+```
+
+You can also set the `batch_run_id` using environment variables for CI/CD integration:
+
+```python
+import os
+
+# Set batch ID for CI/CD integration
+os.environ["SCENARIO_BATCH_RUN_ID"] = os.environ.get("GITHUB_RUN_ID", "local-run")
+
+result = await scenario.run(
+    name="my first scenario",
+    description="A simple test to see if the agent responds.",
+    set_id="my-test-suite",
+    agents=[
+        scenario.Agent(my_agent),
+        scenario.UserSimulatorAgent(),
+    ]
+)
+```
+
+The `batch_run_id` is automatically generated for each test run, but you can also set it globally using the `SCENARIO_BATCH_RUN_ID` environment variable.
+
 ## Disable Output
 
 You can remove the `-s` flag from pytest to hide the output during test, which will only show up if the test fails. Alternatively, you can set `verbose=False` in the `Scenario.configure` method or in the specific scenario you are running.

{langwatch_scenario-0.7.2.dist-info → langwatch_scenario-0.7.7.dist-info}/RECORD

@@ -1,22 +1,22 @@
-scenario/__init__.py,sha256=na4kbWIovF68IVRcfcx4f2YopOUOq9sVbZKCNife_Fk,4228
-scenario/_error_messages.py,sha256=6lEx3jBGMbPx0kG0eX5zoZE-ENVM3O_ZkIbVMlnidYs,3892
+scenario/__init__.py,sha256=4WO8TjY8Lc0NhYL7b9LvaB1xCBqwUkLuI0uIA6PQP6c,4223
+scenario/_error_messages.py,sha256=QVFSbhzsVNGz2GOBOaoQFW6w6AOyZCWLTt0ySWPfnGw,3882
 scenario/agent_adapter.py,sha256=PoY2KQqYuqzIIb3-nhIU-MPXwHJc1vmwdweMy7ut-hk,4255
 scenario/cache.py,sha256=J6s6Sia_Ce6TrnsInlhfxm6SF8tygo3sH-_cQCRX1WA,6213
-scenario/config.py,sha256=xhUuXH-sThwPTmJNSuajKxX-WC_tcFwJ1jZc119DswA,6093
-scenario/judge_agent.py,sha256=d8vORsqpUPIA4yhlBTv5Yi4I2MdcfXselYBTFvfZx-4,16221
+scenario/judge_agent.py,sha256=7NsgeMu6wRMjU_HYTCFqkLma6H2AJuEkw9hJkt11190,16211
 scenario/pytest_plugin.py,sha256=DGrpgB6e71eq8QXWWxwLjAKNhiyYyzfzZ0L5Ax8iEmo,11317
-scenario/scenario_executor.py,sha256=EDRFgvyR7vUCX0fC6nMA5loJi3EUAvvyPWc-vCJSpII,32564
-scenario/scenario_state.py,sha256=dQDjazem-dn1c5mw6TwngEu6Tv_cHwEzemepsPBy2f0,7039
+scenario/scenario_executor.py,sha256=2ZPy2cywwEMIbUfBP1jHN__Ffjf5WGB144MX2SNr5IM,33101
+scenario/scenario_state.py,sha256=LWGqEQN-Yz0DIiC-TyMRHd-9rEiuBVUHKllMmKv-qGg,7029
 scenario/script.py,sha256=A0N5pP0l4FFn1xdKc78U_wkwWhEWH3EFeU_LRDtNyEI,12241
 scenario/types.py,sha256=qH5KFzJBDG1fEJB_qFRVtL3EZulxq3G1mztYczIzIAY,9613
-scenario/user_simulator_agent.py,sha256=fhwi8W44s343BGrjJXSJw960wcK7MgwTg-epxR1bqHo,9088
+scenario/user_simulator_agent.py,sha256=UJ75xhqHwoi8-3JkR1AsHDzpHM2Lx-aDSTJ1gnq_SXc,9101
 scenario/_events/__init__.py,sha256=4cj6H9zuXzvWhT2P2JNdjWzeF1PUepTjqIDw85Vid9s,1500
-scenario/_events/event_bus.py,sha256=PBnpfSj-81_DQHgCwI6oGYzlzbPCwmsNbmI0Kjp787Y,8052
-scenario/_events/event_reporter.py,sha256=gVLX3ftbNxDrD6zxMqsuSTeImswhQZQrAZGJFCzLXYc,3093
+scenario/_events/event_alert_message_logger.py,sha256=K0Pu76Gd36lGEEYh8e8r7NMt7J-OQhbw0cZmiwutCOE,3591
+scenario/_events/event_bus.py,sha256=KFN0OxAQIQXIk_tVrorDoN_YLKVK9dos5SXFALstHgE,9809
+scenario/_events/event_reporter.py,sha256=4uND_kdPBXe-aUWCdSj4BLrMA33TDnbZzokAEOU3_08,3771
 scenario/_events/events.py,sha256=UtEGY-_1B0LrwpgsNKgrvJBZhRtxuj3K_i6ZBfF7E4Q,6387
 scenario/_events/messages.py,sha256=quwP2OkeaGasNOoaV8GUeosZVKc5XDsde08T0xx_YQo,2297
 scenario/_events/utils.py,sha256=SproqiwjhLWAW7p82EirCgawpxAo0ksW1pBB4mKkcEs,3436
-scenario/_generated/langwatch_api_client/README.md,sha256=sWyTtXewM_pumKcaGFNV-F5D8e0uJ13a6q5VWmyFS3U,5445
+scenario/_generated/langwatch_api_client/README.md,sha256=Az5f2L4ChOnG_ZtrdBagzRVgeTCtBkbD_S5cIeAry2o,5424
 scenario/_generated/langwatch_api_client/pyproject.toml,sha256=Z8wxuGp4H9BJYVVJB8diW7rRU9XYxtPfw9mU4_wq4cA,560
 scenario/_generated/langwatch_api_client/lang_watch_api_client/__init__.py,sha256=vVrn17y-3l3fOqeJk8aN3GlStRm2fo0f313l_0LtJNs,368
 scenario/_generated/langwatch_api_client/lang_watch_api_client/client.py,sha256=o_mdLqyBCQstu5tS1WZFwqIEbGwkvWQ7eQjuCJw_5VY,12419
@@ -226,12 +226,16 @@ scenario/_generated/langwatch_api_client/lang_watch_api_client/models/search_req
 scenario/_generated/langwatch_api_client/lang_watch_api_client/models/search_response.py,sha256=zDYmJ8bFBSJyF9D3cEn_ffrey-ITIfwr-_7eu72zLyk,2832
 scenario/_generated/langwatch_api_client/lang_watch_api_client/models/timestamps.py,sha256=-nRKUPZTAJQNxiKz128xF7DKgZNbFo4G3mr5xNXrkaw,2173
 scenario/_generated/langwatch_api_client/lang_watch_api_client/models/trace.py,sha256=K9Lc_EQOrJ2dqMXx9EpiUXReT1_uYF7WRfYyhlfbi3I,7537
-scenario/_utils/__init__.py,sha256=5XkMVG8-g0D8PRtmcJ_PJakmPpUXdDX_gNf_jyILUXQ,999
-scenario/_utils/ids.py,sha256=K1iPuJgPh3gX9HCrDZGqK5lDgdwZXfOBF1YXVOWNHRg,1843
+scenario/_utils/__init__.py,sha256=ptNVzmjhypznnozdNIiuBDHZ0NLqtp7xhio9kEDovWQ,1311
+scenario/_utils/ids.py,sha256=v3JS8J7vrFuubK5bXJviU-BVZoLGWINCN1hUyAO9NZw,2074
 scenario/_utils/message_conversion.py,sha256=AWHn31E7J0mz9sBXWruVVAgtsrJz1R_xEf-dGbX6jjs,3636
 scenario/_utils/utils.py,sha256=msQgUWaLh3U9jIIHmxkEbOaklga63AF0KJzsaKa_mZc,14008
-langwatch_scenario-0.7.2.dist-info/METADATA,sha256=hHOIOIP9w51i6daij7jmQER_gMfGK_mHc8HrnO9GO90,18588
-langwatch_scenario-0.7.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-langwatch_scenario-0.7.2.dist-info/entry_points.txt,sha256=WlEnJ_gku0i18bIa3DSuGqXRX-QDQLe_s0YmRzK45TI,45
-langwatch_scenario-0.7.2.dist-info/top_level.txt,sha256=45Mn28aedJsetnBMB5xSmrJ-yo701QLH89Zlz4r1clE,9
-langwatch_scenario-0.7.2.dist-info/RECORD,,
+scenario/config/__init__.py,sha256=b2X_bqkIrd7jZY9dRrXk2wOqoPe87Nl_SRGuZhlolxA,1123
+scenario/config/langwatch.py,sha256=ijWchFbUsLbQooAZmwyTw4rxfRLQseZ1GoVSiPPbzpw,1677
+scenario/config/model.py,sha256=Ve49S2FyzUifXJ-SAyKPiNtVqs8BfsYbODu_M5y0c8Y,1155
+scenario/config/scenario.py,sha256=tVVnsUgG6Z0hYZiTDX-GGZz8l8co1HhyTqJUJNPinBk,5184
+langwatch_scenario-0.7.7.dist-info/METADATA,sha256=L7h0kgOaIij6MYVCac0EqPu8ODkZNKxDeIrHCSJg2l4,20003
+langwatch_scenario-0.7.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+langwatch_scenario-0.7.7.dist-info/entry_points.txt,sha256=WlEnJ_gku0i18bIa3DSuGqXRX-QDQLe_s0YmRzK45TI,45
+langwatch_scenario-0.7.7.dist-info/top_level.txt,sha256=45Mn28aedJsetnBMB5xSmrJ-yo701QLH89Zlz4r1clE,9
+langwatch_scenario-0.7.7.dist-info/RECORD,,

scenario/__init__.py

@@ -25,7 +25,7 @@ Basic Usage:
     import scenario
 
     # Configure global settings
-    scenario.configure(default_model="openai/gpt-4.1-mini")
+    scenario.configure(default_model="openai/gpt-4.1")
 
     # Create your agent adapter
     class MyAgent(scenario.AgentAdapter):

scenario/_error_messages.py

@@ -8,12 +8,12 @@ def agent_not_configured_error_message(class_name: str):
 
  {termcolor.colored("->", "cyan")} {class_name} was initialized without a model, please set the model when defining the testing agent, for example:
 
-    {class_name}(model="openai/gpt-4.1-mini")
+    {class_name}(model="openai/gpt-4.1")
     {termcolor.colored("^" * (29 + len(class_name)), "green")}
 
  {termcolor.colored("->", "cyan")} Alternatively, you can set the default model globally, for example:
 
-    scenario.configure(default_model="openai/gpt-4.1-mini")
+    scenario.configure(default_model="openai/gpt-4.1")
     {termcolor.colored("^" * 55, "green")}
 """
 

scenario/_events/event_alert_message_logger.py

@@ -0,0 +1,95 @@
+import os
+from typing import Set
+from .._utils.ids import get_batch_run_id
+
+
+class EventAlertMessageLogger:
+    """
+    Handles console output of alert messages for scenario events.
+
+    Single responsibility: Display user-friendly messages about event reporting status
+    and simulation watching instructions.
+    """
+
+    _shown_batch_ids: Set[str] = set()
+
+    def handle_greeting(self) -> None:
+        """
+        Shows a fancy greeting message about simulation reporting status.
+        Only shows once per batch run to avoid spam.
+        """
+        if self._is_greeting_disabled():
+            return
+
+        batch_run_id = get_batch_run_id()
+
+        if batch_run_id in EventAlertMessageLogger._shown_batch_ids:
+            return
+
+        EventAlertMessageLogger._shown_batch_ids.add(batch_run_id)
+        self._display_greeting(batch_run_id)
+
+    def handle_watch_message(self, set_url: str) -> None:
+        """
+        Shows a fancy message about how to watch the simulation.
+        Called when a run started event is received with a session ID.
+        """
+        if self._is_greeting_disabled():
+            return
+
+        self._display_watch_message(set_url)
+
+    def _is_greeting_disabled(self) -> bool:
+        """Check if greeting messages are disabled via environment variable."""
+        return bool(os.getenv("SCENARIO_DISABLE_SIMULATION_REPORT_INFO"))
+
+    def _display_greeting(self, batch_run_id: str) -> None:
+        """Display the greeting message with simulation reporting status."""
+        separator = "─" * 60
+
+        if not os.getenv("LANGWATCH_API_KEY"):
+            print(f"\n{separator}")
+            print("🚀  LangWatch Simulation Reporting")
+            print(f"{separator}")
+            print("➡️  API key not configured")
+            print("   Simulations will only output final results")
+            print("")
+            print("💡 To visualize conversations in real time:")
+            print("   • Set LANGWATCH_API_KEY environment variable")
+            print("   • Or configure apiKey in scenario.config.js")
+            print("")
+            print(f"📦 Batch Run ID: {batch_run_id}")
+            print("")
+            print("🔇 To disable these messages:")
+            print("   • Set SCENARIO_DISABLE_SIMULATION_REPORT_INFO=true")
+            print(f"{separator}\n")
+        else:
+            endpoint = os.getenv("LANGWATCH_ENDPOINT", "https://app.langwatch.ai")
+            api_key = os.getenv("LANGWATCH_API_KEY", "")
+
+            print(f"\n{separator}")
+            print("🚀  LangWatch Simulation Reporting")
+            print(f"{separator}")
+            print("✅ Simulation reporting enabled")
+            print(f"   Endpoint: {endpoint}")
+            print(f"   API Key: {'Configured' if api_key else 'Not configured'}")
+            print("")
+            print(f"📦 Batch Run ID: {batch_run_id}")
+            print("")
+            print("🔇 To disable these messages:")
+            print("   • Set SCENARIO_DISABLE_SIMULATION_REPORT_INFO=true")
+            print(f"{separator}\n")
+
+    def _display_watch_message(self, set_url: str) -> None:
+        """Display the watch message with URLs for viewing the simulation."""
+        separator = "─" * 60
+        batch_url = f"{set_url}/{get_batch_run_id()}"
+
+        print(f"\n{separator}")
+        print("👀 Watch Your Simulation Live")
+        print(f"{separator}")
+        print("🌐 Open in your browser:")
+        print(f"   Scenario Set: {set_url}")
+        print(f"   Batch Run: {batch_url}")
+        print("")
+        print(f"{separator}\n")

scenario/_events/event_bus.py

@@ -1,13 +1,15 @@
 from rx.core.observable.observable import Observable
-from typing import Optional, Any
+from typing import Optional, Any, Dict
 from .events import ScenarioEvent
 from .event_reporter import EventReporter
+from .event_alert_message_logger import EventAlertMessageLogger
 
 import asyncio
 import queue
 import threading
 import logging
 
+
 class ScenarioEventBus:
     """
     Subscribes to scenario event streams and handles HTTP posting using a dedicated worker thread.
@@ -24,6 +26,7 @@ class ScenarioEventBus:
 
     Attributes:
         _event_reporter: EventReporter instance for HTTP posting of events
+        _event_alert_message_logger: EventAlertMessageLogger for user-friendly console output
         _max_retries: Maximum number of retry attempts for failed event processing
         _event_queue: Thread-safe queue for passing events to worker thread
         _completed: Whether the event stream has completed
@@ -44,11 +47,12 @@ class ScenarioEventBus:
                        Defaults to 3 attempts with exponential backoff.
         """
         self._event_reporter: EventReporter = event_reporter or EventReporter()
+        self._event_alert_message_logger = EventAlertMessageLogger()
         self._max_retries = max_retries
-        
+
         # Custom logger for this class
         self.logger = logging.getLogger(__name__)
-        
+
         # Threading infrastructure
         self._event_queue: queue.Queue[ScenarioEvent] = queue.Queue()
         self._completed = False
@@ -61,9 +65,7 @@ class ScenarioEventBus:
         if self._worker_thread is None or not self._worker_thread.is_alive():
             self.logger.debug("Creating new worker thread")
             self._worker_thread = threading.Thread(
-                target=self._worker_loop,
-                daemon=False,
-                name="ScenarioEventBus-Worker"
+                target=self._worker_loop, daemon=False, name="ScenarioEventBus-Worker"
             )
             self._worker_thread.start()
             self.logger.debug("Worker thread started")
@@ -76,52 +78,108 @@ class ScenarioEventBus:
                 if self._shutdown_event.wait(timeout=0.1):
                     self.logger.debug("Worker thread received shutdown signal")
                     break
-                
+
                 try:
                     event = self._event_queue.get(timeout=0.1)
-                    self.logger.debug(f"Worker picked up event: {event.type_} ({event.scenario_run_id})")
+                    self.logger.debug(
+                        f"Worker picked up event: {event.type_} ({event.scenario_run_id})"
+                    )
                     self._process_event_sync(event)
                     self._event_queue.task_done()
                 except queue.Empty:
                     # Exit if stream completed and no more events
                     if self._completed:
-                        self.logger.debug("Stream completed and no more events, worker thread exiting")
+                        self.logger.debug(
+                            "Stream completed and no more events, worker thread exiting"
+                        )
                         break
                     continue
-                    
+
             except Exception as e:
                 self.logger.error(f"Worker thread error: {e}")
-        
+
         self.logger.debug("Worker thread loop ended")
 
     def _process_event_sync(self, event: ScenarioEvent) -> None:
         """
         Process event synchronously in worker thread with retry logic.
         """
-        self.logger.debug(f"Processing HTTP post for {event.type_} ({event.scenario_run_id})")
-        
+        self.logger.debug(
+            f"Processing HTTP post for {event.type_} ({event.scenario_run_id})"
+        )
+
         try:
-            # Convert async to sync using asyncio.run - this blocks until HTTP completes
-            success = asyncio.run(self._process_event_with_retry(event))
-            if not success:
-                self.logger.warning(f"Failed to process event {event.type_} after {self._max_retries} attempts")
-            else:
-                self.logger.debug(f"Successfully posted {event.type_} ({event.scenario_run_id})")
+            result = self._post_event_with_retry(event)
+            self._handle_event_result(event, result)
         except Exception as e:
             self.logger.error(f"Error processing event {event.type_}: {e}")
 
-    async def _process_event_with_retry(self, event: ScenarioEvent, attempt: int = 1) -> bool:
+    def _post_event_with_retry(self, event: ScenarioEvent) -> Optional[Dict[str, Any]]:
+        """
+        Post event with retry logic, converting async to sync.
+        """
+        return asyncio.run(self._process_event_with_retry(event))
+
+    def _handle_event_result(
+        self, event: ScenarioEvent, result: Optional[Dict[str, Any]]
+    ) -> None:
+        """
+        Handle the result of event processing, including logging and watch messages.
+        """
+        if result is None:
+            self.logger.warning(
+                f"Failed to process event {event.type_} after {self._max_retries} attempts"
+            )
+            return
+
+        self.logger.debug(
+            f"Successfully posted {event.type_} ({event.scenario_run_id})"
+        )
+
+        # Handle watch message for run started events
+        if event.type_ == "SCENARIO_RUN_STARTED" and result.get("setUrl"):
+            self._handle_watch_message(event, result)
+
+    def _handle_watch_message(
+        self, event: ScenarioEvent, result: Dict[str, Any]
+    ) -> None:
+        """
+        Handle watch message for scenario run started events.
+        """
+        self._event_alert_message_logger.handle_watch_message(
+            set_url=str(result["setUrl"]),
+        )
+
+    def _extract_scenario_set_id(self, event: ScenarioEvent) -> str:
+        """
+        Extract scenario set ID from event, handling Unset types from generated models.
+        """
+        scenario_set_id = getattr(event, "scenario_set_id", "default")
+
+        # Handle Unset type from generated models
+        if hasattr(scenario_set_id, "__class__") and "Unset" in str(
+            scenario_set_id.__class__
+        ):
+            return "default"
+
+        return str(scenario_set_id)
+
+    async def _process_event_with_retry(
+        self, event: ScenarioEvent, attempt: int = 1
+    ) -> Optional[Dict[str, Any]]:
         """
         Process a single event with retry logic (now runs in worker thread context).
         """
         try:
             if self._event_reporter:
-                await self._event_reporter.post_event(event)
-            return True
+                return await self._event_reporter.post_event(event)
+            return {}
         except Exception as e:
             if attempt >= self._max_retries:
-                return False
-            print(f"Error processing event (attempt {attempt}/{self._max_retries}): {e}")
+                return None
+            print(
+                f"Error processing event (attempt {attempt}/{self._max_retries}): {e}"
+            )
             await asyncio.sleep(0.1 * (2 ** (attempt - 1)))  # Exponential backoff
             return await self._process_event_with_retry(event, attempt + 1)
 
@@ -135,7 +193,9 @@ class ScenarioEventBus:
             return
 
         def handle_event(event: ScenarioEvent) -> None:
-            self.logger.debug(f"Event received, queuing: {event.type_} ({event.scenario_run_id})")
+            self.logger.debug(
+                f"Event received, queuing: {event.type_} ({event.scenario_run_id})"
+            )
             self._get_or_create_worker()
             self._event_queue.put(event)
             self.logger.debug(f"Event queued: {event.type_} ({event.scenario_run_id})")
@@ -144,7 +204,7 @@ class ScenarioEventBus:
         self._subscription = event_stream.subscribe(
             handle_event,
             lambda e: self.logger.error(f"Error in event stream: {e}"),
-            lambda: self._set_completed()
+            lambda: self._set_completed(),
         )
 
     def _set_completed(self):
@@ -155,17 +215,17 @@ class ScenarioEventBus:
     def drain(self) -> None:
         """
         Waits for all queued events to complete processing.
-        
+
         This method blocks until all events in the queue have been processed.
         Since _process_event_sync() uses asyncio.run(), HTTP requests complete
         before task_done() is called, so join() ensures everything is finished.
         """
         self.logger.debug("Drain started - waiting for queue to empty")
-        
+
         # Wait for all events to be processed - this is sufficient!
         self._event_queue.join()
         self.logger.debug("Event queue drained")
-        
+
         # Signal worker to shutdown and wait for it
         self._shutdown_event.set()
         if self._worker_thread and self._worker_thread.is_alive():
@@ -175,7 +235,7 @@ class ScenarioEventBus:
                 self.logger.warning("Worker thread did not shutdown within timeout")
             else:
                 self.logger.debug("Worker thread shutdown complete")
-        
+
         self.logger.info("Drain completed")
 
     def is_completed(self) -> bool: