updated README

Author: akmarou

src/examples/actor_simulator_basic.py

@@ -1,48 +1,60 @@
 import asyncio
 
+from opentelemetry import trace
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
 from strands import Agent
 
 from strands_evals import ActorSimulator, Case, Dataset
-from strands_evals.evaluators import OutputEvaluator
+from strands_evals.evaluators import HelpfulnessEvaluator
+from strands_evals.mappers import StrandsInMemorySessionMapper
+from strands_evals.telemetry import StrandsEvalsTelemetry
 
+# ======================================
+# SETUP TELEMETRY
+# ======================================
+# Target agent telemetry
+target_telemetry = StrandsEvalsTelemetry()
+target_exporter = InMemorySpanExporter()
+target_telemetry.tracer_provider.add_span_processor(BatchSpanProcessor(target_exporter))
 
-async def simulate_conversation(case: Case) -> dict:
+# Simulator telemetry (no exporter)
+simulator_telemetry = StrandsEvalsTelemetry()
+
+
+async def task_function(case: Case) -> dict:
     """Simulate a multi-turn conversation between user and agent."""
     # Create agent under test
+    trace.set_tracer_provider(target_telemetry.tracer_provider)
     agent = Agent(system_prompt="You are a helpful travel assistant.", callback_handler=None)
 
     # Create user simulator from case
+    trace.set_tracer_provider(simulator_telemetry.tracer_provider)
     user_sim = ActorSimulator.from_case_for_user_simulator(case=case)
 
-    # Multi-turn conversation
-    conversation = []
-    max_turns = 10
-
-    # Initial user message
+    # Multi-turn conversation (max 10 turns as failsafe)
     user_message = case.input
-    conversation.append({"role": "user", "content": user_message})
 
-    for turn_num in range(max_turns):
-        print(f"Starting turn number {turn_num}")
-        # Check for completion
+    for _ in range(10):
         if "<stop/>" in user_message:
             break
 
         # Agent responds
+        trace.set_tracer_provider(target_telemetry.tracer_provider)
         agent_response = agent(user_message)
         agent_message = str(agent_response)
-        conversation.append({"role": "assistant", "content": agent_message})
 
         # User acts
+        trace.set_tracer_provider(simulator_telemetry.tracer_provider)
         user_result = user_sim.act(agent_message)
         user_message = str(user_result.structured_output.message)
-        conversation.append({"role": "user", "content": user_message})
 
-    return {
-        "output": conversation[-1]["content"] if conversation else "",
-        "conversation": conversation,
-        "turns": len(conversation) // 2,
-    }
+    # Collect traces
+    finished_spans = target_exporter.get_finished_spans()
+    mapper = StrandsInMemorySessionMapper()
+    session = mapper.map_to_session(finished_spans, session_id="test-session")
+
+    return {"output": str(agent_response), "trajectory": session}
 
 
 # Create test cases
@@ -62,15 +74,15 @@ async def simulate_conversation(case: Case) -> dict:
 ]
 
 # Create evaluator
-evaluator = OutputEvaluator(rubric="Evaluate if the agent successfully helped achieve the user's travel goal.")
+evaluator = HelpfulnessEvaluator()
 
 # Create dataset
 dataset = Dataset[str, str](cases=test_cases, evaluator=evaluator)
 
 
 # Run evaluations
 async def main():
-    report = await dataset.run_evaluations_async(simulate_conversation)
+    report = await dataset.run_evaluations_async(task_function)
     report.run_display()