@langwatch/scenario 0.2.0-prerelease.0 → 0.2.0

package/dist/index.js

@@ -38,6 +38,7 @@ __export(index_exports, {
   UserSimulatorAgentAdapter: () => UserSimulatorAgentAdapter,
   agent: () => agent,
   allAgentRoles: () => allAgentRoles,
+  default: () => index_default,
   defineConfig: () => defineConfig,
   fail: () => fail,
   judge: () => judge,
@@ -45,6 +46,7 @@ __export(index_exports, {
   message: () => message,
   proceed: () => proceed,
   run: () => run,
+  scenario: () => scenario,
   scenarioProjectConfigSchema: () => scenarioProjectConfigSchema,
   succeed: () => succeed,
   user: () => user,
@@ -52,31 +54,28 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/script/index.ts
-var message = (message2) => {
-  return (_state, executor) => executor.message(message2);
-};
-var agent = (content) => {
-  return (_state, executor) => executor.agent(content);
-};
-var judge = (content) => {
-  return (_state, executor) => executor.judge(content);
-};
-var user = (content) => {
-  return (_state, executor) => executor.user(content);
-};
-var proceed = (turns, onTurn, onStep) => {
-  return (_state, executor) => executor.proceed(turns, onTurn, onStep);
-};
-var succeed = (reasoning) => {
-  return (_state, executor) => executor.succeed(reasoning);
-};
-var fail = (reasoning) => {
-  return (_state, executor) => executor.fail(reasoning);
-};
+// src/agents/index.ts
+var agents_exports = {};
+__export(agents_exports, {
+  judgeAgent: () => judgeAgent,
+  userSimulatorAgent: () => userSimulatorAgent
+});
 
-// src/execution/scenario-execution.ts
-var import_rxjs = require("rxjs");
+// src/agents/judge-agent.ts
+var import_ai = require("ai");
+var import_zod2 = require("zod");
+
+// src/domain/index.ts
+var domain_exports = {};
+__export(domain_exports, {
+  AgentAdapter: () => AgentAdapter,
+  AgentRole: () => AgentRole,
+  JudgeAgentAdapter: () => JudgeAgentAdapter,
+  UserSimulatorAgentAdapter: () => UserSimulatorAgentAdapter,
+  allAgentRoles: () => allAgentRoles,
+  defineConfig: () => defineConfig,
+  scenarioProjectConfigSchema: () => scenarioProjectConfigSchema
+});
 
 // src/domain/core/config.ts
 var import_zod = require("zod");
@@ -120,264 +119,93 @@ var JudgeAgentAdapter = class {
   }
 };
 
-// src/utils/ids.ts
-var import_xksuid = require("xksuid");
-var batchRunId = null;
-function generateThreadId() {
-  return `thread_${(0, import_xksuid.generate)()}`;
-}
-function generateScenarioRunId() {
-  return `scenariorun_${(0, import_xksuid.generate)()}`;
-}
-function generateScenarioId() {
-  return `scenario_${(0, import_xksuid.generate)()}`;
-}
-function getBatchRunId() {
-  if (!batchRunId) {
-    batchRunId = process.env.SCENARIO_BATCH_RUN_ID ?? `scenariobatchrun_${(0, import_xksuid.generate)()}`;
-  }
-  return batchRunId;
-}
-function generateMessageId() {
-  return `scenariomsg_${(0, import_xksuid.generate)()}`;
-}
-
-// src/execution/scenario-execution-state.ts
-var ScenarioExecutionState = class {
-  _history = [];
-  _turn = 0;
-  _partialResult = null;
-  _threadId = "";
-  _agents = [];
-  _pendingMessages = /* @__PURE__ */ new Map();
-  _pendingRolesOnTurn = [];
-  _pendingAgentsOnTurn = /* @__PURE__ */ new Set();
-  _agentTimes = /* @__PURE__ */ new Map();
-  _totalStartTime = 0;
-  /**
-   * Creates a new ScenarioExecutionState.
-   */
-  constructor() {
-    this._totalStartTime = Date.now();
-  }
-  setThreadId(threadId) {
-    this._threadId = threadId;
-  }
-  setAgents(agents) {
-    this._agents = agents;
-    this._pendingMessages.clear();
-    this._agentTimes.clear();
-  }
-  appendMessage(role, content) {
-    const message2 = { role, content };
-    this._history.push({ ...message2, id: generateMessageId() });
-  }
-  appendUserMessage(content) {
-    this.appendMessage("user", content);
-  }
-  appendAssistantMessage(content) {
-    this.appendMessage("assistant", content);
-  }
-  addMessage(message2, fromAgentIdx) {
-    this._history.push({ ...message2, id: generateMessageId() });
-    for (let idx = 0; idx < this._agents.length; idx++) {
-      if (idx === fromAgentIdx) continue;
-      if (!this._pendingMessages.has(idx)) {
-        this._pendingMessages.set(idx, []);
-      }
-      this._pendingMessages.get(idx).push(message2);
-    }
-  }
-  addMessages(messages, fromAgentIdx) {
-    for (const message2 of messages) {
-      this.addMessage(message2, fromAgentIdx);
+// src/agents/utils.ts
+var toolMessageRole = "tool";
+var assistantMessageRole = "assistant";
+var userMessageRole = "user";
+var groupMessagesByToolBoundaries = (messages) => {
+  const segments = [];
+  let currentSegment = [];
+  for (const message2 of messages) {
+    currentSegment.push(message2);
+    if (message2.role === toolMessageRole) {
+      segments.push(currentSegment);
+      currentSegment = [];
     }
   }
-  getPendingMessages(agentIdx) {
-    return this._pendingMessages.get(agentIdx) || [];
-  }
-  clearPendingMessages(agentIdx) {
-    this._pendingMessages.set(agentIdx, []);
-  }
-  newTurn() {
-    this._pendingAgentsOnTurn = new Set(this._agents);
-    this._pendingRolesOnTurn = [
-      "User" /* USER */,
-      "Agent" /* AGENT */,
-      "Judge" /* JUDGE */
-    ];
-    if (this._turn === null) {
-      this._turn = 1;
-    } else {
-      this._turn++;
-    }
+  if (currentSegment.length > 0) {
+    segments.push(currentSegment);
   }
-  removePendingRole(role) {
-    const index = this._pendingRolesOnTurn.indexOf(role);
-    if (index > -1) {
-      this._pendingRolesOnTurn.splice(index, 1);
+  return segments;
+};
+var segmentHasToolMessages = (segment) => {
+  return segment.some((message2) => {
+    if (message2.role === toolMessageRole) return true;
+    if (message2.role === assistantMessageRole && Array.isArray(message2.content)) {
+      return message2.content.some((part) => part.type === "tool-call");
     }
-  }
-  removePendingAgent(agent2) {
-    this._pendingAgentsOnTurn.delete(agent2);
-  }
-  getNextAgentForRole(role) {
-    for (let i = 0; i < this._agents.length; i++) {
-      const agent2 = this._agents[i];
-      if (agent2.role === role && this._pendingAgentsOnTurn.has(agent2)) {
-        return { index: i, agent: agent2 };
+    return false;
+  });
+};
+var reverseSegmentRoles = (segment) => {
+  return segment.map((message2) => {
+    const hasStringContent = typeof message2.content === "string";
+    if (!hasStringContent) return message2;
+    const roleMap = {
+      [userMessageRole]: assistantMessageRole,
+      [assistantMessageRole]: userMessageRole
+    };
+    const newRole = roleMap[message2.role];
+    if (!newRole) return message2;
+    return {
+      role: newRole,
+      content: message2.content
+    };
+  });
+};
+var messageRoleReversal = (messages) => {
+  const segments = groupMessagesByToolBoundaries(messages);
+  const processedSegments = segments.map(
+    (segment) => segmentHasToolMessages(segment) ? segment : reverseSegmentRoles(segment)
+  );
+  return processedSegments.flat();
+};
+var criterionToParamName = (criterion) => {
+  return criterion.replace(/"/g, "").replace(/[^a-zA-Z0-9]/g, "_").replace(/ /g, "_").toLowerCase().substring(0, 70);
+};
+
+// src/config/load.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var import_node_url = require("url");
+async function loadScenarioProjectConfig() {
+  const cwd = process.cwd();
+  const configNames = [
+    "scenario.config.js",
+    "scenario.config.mjs"
+  ];
+  for (const name of configNames) {
+    const fullPath = import_node_path.default.join(cwd, name);
+    try {
+      await import_promises.default.access(fullPath);
+      const configModule = await import((0, import_node_url.pathToFileURL)(fullPath).href);
+      const config2 = configModule.default || configModule;
+      const parsed = scenarioProjectConfigSchema.safeParse(config2);
+      if (!parsed.success) {
+        throw new Error(
+          `Invalid config file ${name}: ${JSON.stringify(parsed.error.format(), null, 2)}`
+        );
+      }
+      return parsed.data;
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        continue;
       }
+      throw error;
     }
-    return null;
-  }
-  addAgentTime(agentIdx, time) {
-    const currentTime = this._agentTimes.get(agentIdx) || 0;
-    this._agentTimes.set(agentIdx, currentTime + time);
-  }
-  hasResult() {
-    return this._partialResult !== null;
-  }
-  setResult(result) {
-    this._partialResult = result;
-  }
-  get lastMessage() {
-    return this._history[this._history.length - 1];
-  }
-  get lastUserMessage() {
-    return this._history.findLast((message2) => message2.role === "user");
-  }
-  get lastAssistantMessage() {
-    return this._history.findLast((message2) => message2.role === "assistant");
-  }
-  get lastToolCall() {
-    return this._history.findLast((message2) => message2.role === "tool");
-  }
-  getLastToolCallByToolName(toolName) {
-    const toolMessage = this._history.findLast(
-      (message2) => message2.role === "tool" && message2.content.find(
-        (part) => part.type === "tool-result" && part.toolName === toolName
-      )
-    );
-    return toolMessage;
-  }
-  hasToolCall(toolName) {
-    return this._history.some(
-      (message2) => message2.role === "tool" && message2.content.find(
-        (part) => part.type === "tool-result" && part.toolName === toolName
-      )
-    );
-  }
-  get history() {
-    return this._history;
-  }
-  get historyWithoutLastMessage() {
-    return this._history.slice(0, -1);
-  }
-  get historyWithoutLastUserMessage() {
-    const lastUserMessageIndex = this._history.findLastIndex((message2) => message2.role === "user");
-    if (lastUserMessageIndex === -1) return this._history;
-    return this._history.slice(0, lastUserMessageIndex);
-  }
-  get turn() {
-    return this._turn;
-  }
-  set turn(turn) {
-    this._turn = turn;
-  }
-  get threadId() {
-    return this._threadId;
-  }
-  get agents() {
-    return this._agents;
-  }
-  get pendingRolesOnTurn() {
-    return this._pendingRolesOnTurn;
-  }
-  set pendingRolesOnTurn(roles) {
-    this._pendingRolesOnTurn = roles;
-  }
-  get pendingAgentsOnTurn() {
-    return Array.from(this._pendingAgentsOnTurn);
-  }
-  set pendingAgentsOnTurn(agents) {
-    this._pendingAgentsOnTurn = new Set(agents);
-  }
-  get partialResult() {
-    return this._partialResult;
-  }
-  get totalTime() {
-    return Date.now() - this._totalStartTime;
-  }
-  get agentTimes() {
-    return new Map(this._agentTimes);
   }
-  removeLastPendingRole() {
-    this._pendingRolesOnTurn.pop();
-  }
-};
-
-// src/events/schema.ts
-var import_core = require("@ag-ui/core");
-var import_zod2 = require("zod");
-var ScenarioRunStatus = /* @__PURE__ */ ((ScenarioRunStatus2) => {
-  ScenarioRunStatus2["SUCCESS"] = "SUCCESS";
-  ScenarioRunStatus2["ERROR"] = "ERROR";
-  ScenarioRunStatus2["CANCELLED"] = "CANCELLED";
-  ScenarioRunStatus2["IN_PROGRESS"] = "IN_PROGRESS";
-  ScenarioRunStatus2["PENDING"] = "PENDING";
-  ScenarioRunStatus2["FAILED"] = "FAILED";
-  return ScenarioRunStatus2;
-})(ScenarioRunStatus || {});
-var baseEventSchema = import_zod2.z.object({
-  type: import_zod2.z.nativeEnum(import_core.EventType),
-  timestamp: import_zod2.z.number().optional(),
-  rawEvent: import_zod2.z.any().optional()
-});
-var baseScenarioEventSchema = baseEventSchema.extend({
-  batchRunId: import_zod2.z.string(),
-  scenarioId: import_zod2.z.string(),
-  scenarioRunId: import_zod2.z.string()
-});
-var scenarioRunStartedSchema = baseScenarioEventSchema.extend({
-  type: import_zod2.z.literal("SCENARIO_RUN_STARTED" /* RUN_STARTED */),
-  metadata: import_zod2.z.object({
-    name: import_zod2.z.string(),
-    description: import_zod2.z.string().optional()
-    // config: z.record(z.unknown()).optional(),
-  })
-});
-var scenarioRunFinishedSchema = baseScenarioEventSchema.extend({
-  type: import_zod2.z.literal("SCENARIO_RUN_FINISHED" /* RUN_FINISHED */),
-  status: import_zod2.z.nativeEnum(ScenarioRunStatus)
-  //   error: z
-  //     .object({
-  //       message: z.string(),
-  //       code: z.string().optional(),
-  //       stack: z.string().optional(),
-  //     })
-  //     .optional(),
-  //   metrics: z.record(z.number()).optional(),
-});
-var scenarioMessageSnapshotSchema = import_core.MessagesSnapshotEventSchema.merge(
-  baseScenarioEventSchema.extend({
-    type: import_zod2.z.literal("SCENARIO_MESSAGE_SNAPSHOT" /* MESSAGE_SNAPSHOT */)
-  })
-);
-var scenarioEventSchema = import_zod2.z.discriminatedUnion("type", [
-  scenarioRunStartedSchema,
-  scenarioRunFinishedSchema,
-  scenarioMessageSnapshotSchema
-]);
-var successSchema = import_zod2.z.object({ success: import_zod2.z.boolean() });
-var errorSchema = import_zod2.z.object({ error: import_zod2.z.string() });
-var stateSchema = import_zod2.z.object({
-  state: import_zod2.z.object({
-    messages: import_zod2.z.array(import_zod2.z.any()),
-    status: import_zod2.z.string()
-  })
-});
-var runsSchema = import_zod2.z.object({ runs: import_zod2.z.array(import_zod2.z.string()) });
-var eventsSchema = import_zod2.z.object({ events: import_zod2.z.array(scenarioEventSchema) });
+  return await scenarioProjectConfigSchema.parseAsync({});
+}
 
 // src/utils/logger.ts
 var Logger = class _Logger {
@@ -445,300 +273,645 @@ var Logger = class _Logger {
   }
 };
 
-// src/execution/scenario-execution.ts
-var batchRunId2 = getBatchRunId();
-function convertAgentReturnTypesToMessages(response, role) {
-  if (typeof response === "string")
-    return [{ role, content: response }];
-  if (Array.isArray(response))
-    return response;
-  if (typeof response === "object" && "role" in response)
-    return [response];
-  return [];
-}
-var ScenarioExecution = class {
-  state = new ScenarioExecutionState();
-  eventSubject = new import_rxjs.Subject();
-  logger = new Logger("scenario.execution.ScenarioExecution");
-  config;
-  /**
-   * An observable stream of events that occur during the scenario execution.
-   * Subscribe to this to monitor the progress of the scenario in real-time.
-   */
-  events$ = this.eventSubject.asObservable();
-  /**
-   * Creates a new ScenarioExecution instance.
-   * @param config The scenario configuration.
-   * @param script The script steps to execute.
-   */
-  constructor(config2, script) {
-    this.config = {
-      id: config2.id ?? generateScenarioId(),
-      name: config2.name,
-      description: config2.description,
-      agents: config2.agents,
-      script,
-      verbose: config2.verbose ?? false,
-      maxTurns: config2.maxTurns ?? 10,
-      threadId: config2.threadId ?? generateThreadId()
-    };
-    this.reset();
-  }
-  /**
-   * The history of messages in the conversation.
-   */
-  get history() {
-    return this.state.history;
+// src/config/index.ts
+var logger = new Logger("scenario.config");
+var configLoaded = false;
+var config = null;
+var configLoadPromise = null;
+async function loadProjectConfig() {
+  if (configLoaded) {
+    return;
   }
-  /**
-   * The unique identifier for the conversation thread.
-   */
-  get threadId() {
-    return this.state.threadId;
+  if (configLoadPromise) {
+    return configLoadPromise;
   }
-  /**
-   * Executes the entire scenario from start to finish.
-   * This will run through the script and any automatic proceeding logic until a
-   * final result (success, failure, or error) is determined.
-   * @returns A promise that resolves with the final result of the scenario.
-   */
-  async execute() {
-    this.reset();
-    const scenarioRunId = generateScenarioRunId();
-    this.emitRunStarted({ scenarioRunId });
+  configLoadPromise = (async () => {
     try {
-      for (const scriptStep of this.config.script) {
-        this.logger.debug(`[${this.config.id}] Executing script step`, {
-          scriptStep
-        });
-        const result = await scriptStep(this.state, this);
-        this.emitMessageSnapshot({ scenarioRunId });
-        if (result && typeof result === "object" && "success" in result) {
-          this.emitRunFinished({
-            scenarioRunId,
-            status: result.success ? "SUCCESS" /* SUCCESS */ : "FAILED" /* FAILED */
-          });
-          return result;
-        }
-      }
-      this.emitRunFinished({ scenarioRunId, status: "FAILED" /* FAILED */ });
-      return this.reachedMaxTurns([
-        "Reached end of script without conclusion, add one of the following to the end of the script:",
-        "- `Scenario.proceed()` to let the simulation continue to play out",
-        "- `Scenario.judge()` to force criteria judgement",
-        "- `Scenario.succeed()` or `Scenario.fail()` to end the test with an explicit result"
-      ].join("\n"));
+      config = await loadScenarioProjectConfig();
+      logger.info("loaded scenario project config", { config });
     } catch (error) {
-      this.emitRunFinished({
-        scenarioRunId,
-        status: "ERROR" /* ERROR */
-      });
-      throw error;
-    }
-  }
-  /**
-   * Executes a single step in the scenario.
-   * A step usually corresponds to a single agent's turn. This method is useful
-   * for manually controlling the scenario's progress.
-   * @returns A promise that resolves with the new messages added during the step, or a final scenario result if the step concludes the scenario.
-   */
-  async step() {
-    const result = await this._step();
-    if (result === null) throw new Error("No result from step");
-    return result;
-  }
-  async _step(goToNextTurn = true, onTurn) {
-    if (this.state.pendingRolesOnTurn.length === 0) {
-      if (!goToNextTurn) return null;
-      this.state.newTurn();
-      if (onTurn) await onTurn(this.state);
-      if (this.state.turn != null && this.state.turn >= this.config.maxTurns)
-        return this.reachedMaxTurns();
-    }
-    const currentRole = this.state.pendingRolesOnTurn[0];
-    const { idx, agent: nextAgent } = this.nextAgentForRole(currentRole);
-    if (!nextAgent) {
-      this.state.removePendingRole(currentRole);
-      return this._step(goToNextTurn, onTurn);
+      logger.error("error loading scenario project config", { error });
+    } finally {
+      configLoaded = true;
     }
-    this.state.removePendingAgent(nextAgent);
-    return await this.callAgent(idx, currentRole);
+  })();
+  return configLoadPromise;
+}
+async function getProjectConfig() {
+  await loadProjectConfig();
+  return config;
+}
+
+// src/utils/config.ts
+function mergeConfig(config2, projectConfig) {
+  if (!projectConfig) {
+    return config2;
   }
-  async callAgent(idx, role, judgmentRequest = false) {
-    const agent2 = this.state.agents[idx];
-    const startTime = Date.now();
-    const agentInput = {
-      threadId: this.state.threadId,
-      messages: this.state.history,
-      newMessages: this.state.getPendingMessages(idx),
-      requestedRole: role,
-      judgmentRequest,
-      scenarioState: this.state,
-      scenarioConfig: this.config
-    };
-    const agentResponse = await agent2.call(agentInput);
-    const endTime = Date.now();
-    this.state.addAgentTime(idx, endTime - startTime);
-    this.state.clearPendingMessages(idx);
-    if (typeof agentResponse === "object" && agentResponse && "success" in agentResponse) {
-      return agentResponse;
-    }
-    const messages = convertAgentReturnTypesToMessages(
-      agentResponse,
-      role === "User" /* USER */ ? "user" : "assistant"
-    );
-    this.state.addMessages(messages, idx);
-    return messages;
+  return {
+    ...projectConfig.defaultModel,
+    ...config2
+  };
+}
+function mergeAndValidateConfig(config2, projectConfig) {
+  var _a;
+  const mergedConfig = mergeConfig(config2, projectConfig);
+  mergedConfig.model = mergedConfig.model ?? ((_a = projectConfig == null ? void 0 : projectConfig.defaultModel) == null ? void 0 : _a.model);
+  if (!mergedConfig.model) {
+    throw new Error("Model is required");
   }
-  nextAgentForRole(role) {
-    for (const agent2 of this.state.agents) {
-      if (agent2.role === role && this.state.pendingAgentsOnTurn.includes(agent2) && this.state.pendingRolesOnTurn.includes(role)) {
-        return { idx: this.state.agents.indexOf(agent2), agent: agent2 };
+  return mergedConfig;
+}
+
+// src/agents/judge-agent.ts
+function buildSystemPrompt(criteria, description) {
+  const criteriaList = (criteria == null ? void 0 : criteria.map((criterion, idx) => `${idx + 1}. ${criterion}`).join("\n")) || "No criteria provided";
+  return `
+<role>
+You are an LLM as a judge watching a simulated conversation as it plays out live to determine if the agent under test meets the criteria or not.
+</role>
+
+<goal>
+Your goal is to determine if you already have enough information to make a verdict of the scenario below, or if the conversation should continue for longer.
+If you do have enough information, use the finish_test tool to determine if all the criteria have been met, if not, use the continue_test tool to let the next step play out.
+</goal>
+
+<scenario>
+${description}
+</scenario>
+
+<criteria>
+${criteriaList}
+</criteria>
+
+<rules>
+- Be strict, do not let the conversation continue if the agent already broke one of the "do not" or "should not" criteria.
+- DO NOT make any judgment calls that are not explicitly listed in the success or failure criteria, withhold judgement if necessary
+</rules>
+`.trim();
+}
+function buildContinueTestTool() {
+  return (0, import_ai.tool)({
+    description: "Continue the test with the next step",
+    parameters: import_zod2.z.object({})
+  });
+}
+function buildFinishTestTool(criteria) {
+  const criteriaNames = criteria.map(criterionToParamName);
+  return (0, import_ai.tool)({
+    description: "Complete the test with a final verdict",
+    parameters: import_zod2.z.object({
+      criteria: import_zod2.z.object(
+        Object.fromEntries(
+          criteriaNames.map((name, idx) => [
+            name,
+            import_zod2.z.enum(["true", "false", "inconclusive"]).describe(criteria[idx])
+          ])
+        )
+      ).strict().describe("Strict verdict for each criterion"),
+      reasoning: import_zod2.z.string().describe("Explanation of what the final verdict should be"),
+      verdict: import_zod2.z.enum(["success", "failure", "inconclusive"]).describe("The final verdict of the test")
+    })
+  });
+}
+var judgeAgent = (cfg) => {
+  return {
+    role: "Judge" /* JUDGE */,
+    criteria: cfg.criteria,
+    call: async (input) => {
+      var _a;
+      const systemPrompt = cfg.systemPrompt ?? buildSystemPrompt(cfg.criteria, input.scenarioConfig.description);
+      const messages = [
+        { role: "system", content: systemPrompt },
+        ...input.messages
+      ];
+      const isLastMessage = input.scenarioState.currentTurn === input.scenarioConfig.maxTurns;
+      const projectConfig = await getProjectConfig();
+      const mergedConfig = mergeAndValidateConfig(cfg, projectConfig);
+      if (!mergedConfig.model) {
+        throw new Error("Model is required for the judge agent");
       }
-    }
-    return { idx: -1, agent: null };
-  }
-  reachedMaxTurns(errorMessage) {
-    var _a;
-    const agentRoleAgentsIdx = this.state.agents.map((agent2, i) => ({ agent: agent2, idx: i })).filter(({ agent: agent2 }) => agent2.role === "Agent" /* AGENT */).map(({ idx }) => idx);
-    const agentTimes = agentRoleAgentsIdx.map((i) => this.state.agentTimes.get(i) || 0);
-    const totalAgentTime = agentTimes.reduce((sum, time) => sum + time, 0);
-    return {
-      success: false,
-      messages: this.state.history,
-      reasoning: errorMessage || `Reached maximum turns (${this.config.maxTurns || 10}) without conclusion`,
-      passedCriteria: [],
-      failedCriteria: ((_a = this.getJudgeAgent()) == null ? void 0 : _a.criteria) ?? [],
-      totalTime: this.state.totalTime,
-      agentTime: totalAgentTime
-    };
-  }
-  getJudgeAgent() {
-    return this.state.agents.find((agent2) => agent2 instanceof JudgeAgentAdapter) ?? null;
-  }
-  consumeUntilRole(role) {
-    while (this.state.pendingRolesOnTurn.length > 0) {
-      const nextRole = this.state.pendingRolesOnTurn[0];
-      if (nextRole === role) break;
-      this.state.pendingRolesOnTurn.pop();
-    }
-  }
-  async scriptCallAgent(role, content, judgmentRequest = false) {
-    this.consumeUntilRole(role);
-    let index = -1;
-    let agent2 = null;
-    const nextAgent = this.state.getNextAgentForRole(role);
-    if (!nextAgent) {
-      this.state.newTurn();
-      this.consumeUntilRole(role);
-      const nextAgent2 = this.state.getNextAgentForRole(role);
-      if (!nextAgent2) {
-        let roleClass = "";
-        switch (role) {
-          case "User" /* USER */:
-            roleClass = "a scenario.userSimulatorAgent()";
-            break;
-          case "Agent" /* AGENT */:
-            roleClass = "a scenario.agent()";
-            break;
-          case "Judge" /* JUDGE */:
-            roleClass = "a scenario.judgeAgent()";
-            break;
-          default:
-            roleClass = "your agent";
-        }
-        if (content)
-          throw new Error(
-            `Cannot generate a message for role \`${role}\` with content \`${content}\` because no agent with this role was found, please add ${roleClass} to the scenario \`agents\` list`
-          );
-        throw new Error(
-          `Cannot generate a message for role \`${role}\` because no agent with this role was found, please add ${roleClass} to the scenario \`agents\` list`
-        );
+      const tools = {
+        continue_test: buildContinueTestTool(),
+        finish_test: buildFinishTestTool(cfg.criteria)
+      };
+      const enforceJudgement = input.judgmentRequest;
+      const hasCriteria = cfg.criteria.length && cfg.criteria.length > 0;
+      if (enforceJudgement && !hasCriteria) {
+        return {
+          success: false,
+          messages: [],
+          reasoning: "JudgeAgent: No criteria was provided to be judged against",
+          metCriteria: [],
+          unmetCriteria: []
+        };
       }
-      index = nextAgent2.index;
-      agent2 = nextAgent2.agent;
-    } else {
-      index = nextAgent.index;
-      agent2 = nextAgent.agent;
-    }
-    this.state.removePendingAgent(agent2);
-    if (content) {
-      if (typeof content === "string") {
-        if (role === "User" /* USER */) {
-          this.state.addMessage({ role: "user", content });
-        } else {
-          this.state.addMessage({ role: "assistant", content });
-        }
-      } else {
-        this.state.addMessage(content);
+      const toolChoice = (isLastMessage || enforceJudgement) && hasCriteria ? { type: "tool", toolName: "finish_test" } : "required";
+      const completion = await (0, import_ai.generateText)({
+        model: mergedConfig.model,
+        messages,
+        temperature: mergedConfig.temperature ?? 0,
+        maxTokens: mergedConfig.maxTokens,
+        tools,
+        toolChoice
+      });
+      let args;
+      if ((_a = completion.toolCalls) == null ? void 0 : _a.length) {
+        const toolCall = completion.toolCalls[0];
+        switch (toolCall.toolName) {
+          case "finish_test": {
+            args = toolCall.args;
+            const verdict = args.verdict || "inconclusive";
+            const reasoning = args.reasoning || "No reasoning provided";
+            const criteria = args.criteria || {};
+            const criteriaValues = Object.values(criteria);
+            const metCriteria = cfg.criteria.filter((_, i) => criteriaValues[i] === "true");
+            const unmetCriteria = cfg.criteria.filter((_, i) => criteriaValues[i] !== "true");
+            return {
+              success: verdict === "success",
+              messages: input.messages,
+              reasoning,
+              metCriteria,
+              unmetCriteria
+            };
+          }
+          case "continue_test":
+            return [];
+          default:
+            return {
+              success: false,
+              messages: input.messages,
+              reasoning: `JudgeAgent: Unknown tool call: ${toolCall.toolName}`,
+              metCriteria: [],
+              unmetCriteria: cfg.criteria
+            };
+        }
       }
-      return null;
+      return {
+        success: false,
+        messages: input.messages,
+        reasoning: `JudgeAgent: No tool call found in LLM output`,
+        metCriteria: [],
+        unmetCriteria: cfg.criteria
+      };
     }
-    const result = await this.callAgent(index, role, judgmentRequest);
-    if (Array.isArray(result))
-      return null;
-    return result;
+  };
+};
+
+// src/agents/user-simulator-agent.ts
+var import_ai2 = require("ai");
+function buildSystemPrompt2(description) {
+  return `
+<role>
+You are pretending to be a user, you are testing an AI Agent (shown as the user role) based on a scenario.
+Approach this naturally, as a human user would, with very short inputs, few words, all lowercase, imperative, not periods, like when they google or talk to chatgpt.
+</role>
+
+<goal>
+Your goal (assistant) is to interact with the Agent Under Test (user) as if you were a human user to see if it can complete the scenario successfully.
+</goal>
+
+<scenario>
+${description}
+</scenario>
+
+<rules>
+- DO NOT carry over any requests yourself, YOU ARE NOT the assistant today, you are the user
+</rules>
+`.trim();
+}
+var userSimulatorAgent = (config2) => {
+  return {
+    role: "User" /* USER */,
+    call: async (input) => {
+      const systemPrompt = buildSystemPrompt2(input.scenarioConfig.description);
+      const messages = [
+        { role: "system", content: systemPrompt },
+        { role: "assistant", content: "Hello, how can I help you today" },
+        ...input.messages
+      ];
+      const projectConfig = await getProjectConfig();
+      const mergedConfig = mergeAndValidateConfig(config2 ?? {}, projectConfig);
+      if (!mergedConfig.model) {
+        throw new Error("Model is required for the user simulator agent");
+      }
+      const reversedMessages = messageRoleReversal(messages);
+      const completion = await (0, import_ai2.generateText)({
+        model: mergedConfig.model,
+        messages: reversedMessages,
+        temperature: mergedConfig.temperature ?? 0,
+        maxTokens: mergedConfig.maxTokens
+      });
+      const messageContent = completion.text;
+      if (!messageContent) {
+        throw new Error("No response content from LLM");
+      }
+      return { role: "user", content: messageContent };
+    }
+  };
+};
+
+// src/execution/index.ts
+var execution_exports = {};
+__export(execution_exports, {
+  ScenarioExecution: () => ScenarioExecution,
+  ScenarioExecutionState: () => ScenarioExecutionState
+});
+
+// src/execution/scenario-execution.ts
+var import_rxjs = require("rxjs");
+
+// src/utils/ids.ts
+var import_xksuid = require("xksuid");
+var batchRunId = null;
+function generateThreadId() {
+  return `thread_${(0, import_xksuid.generate)()}`;
+}
+function generateScenarioRunId() {
+  return `scenariorun_${(0, import_xksuid.generate)()}`;
+}
+function generateScenarioId() {
+  return `scenario_${(0, import_xksuid.generate)()}`;
+}
+function getBatchRunId() {
+  if (!batchRunId) {
+    batchRunId = process.env.SCENARIO_BATCH_RUN_ID ?? `scenariobatchrun_${(0, import_xksuid.generate)()}`;
+  }
+  return batchRunId;
+}
+function generateMessageId() {
+  return `scenariomsg_${(0, import_xksuid.generate)()}`;
+}
+
+// src/execution/scenario-execution-state.ts
+var ScenarioExecutionState = class {
+  _messages = [];
+  _currentTurn = 0;
+  _threadId = "";
+  description;
+  config;
+  constructor(config2) {
+    this.config = config2;
+    this.description = config2.description;
+  }
+  get messages() {
+    return this._messages;
+  }
+  get currentTurn() {
+    return this._currentTurn;
+  }
+  set currentTurn(turn) {
+    this._currentTurn = turn;
+  }
+  get threadId() {
+    return this._threadId;
+  }
+  set threadId(value) {
+    this._threadId = value;
   }
   /**
    * Adds a message to the conversation history.
-   * This is part of the `ScenarioExecutionLike` interface used by script steps.
-   * @param message The message to add.
+   *
+   * @param message - The message to add.
    */
-  async message(message2) {
-    if (message2.role === "user") {
-      await this.scriptCallAgent("User" /* USER */, message2);
-    } else if (message2.role === "assistant") {
-      await this.scriptCallAgent("Agent" /* AGENT */, message2);
-    } else {
-      this.state.addMessage(message2);
+  addMessage(message2) {
+    this._messages.push({ ...message2, id: generateMessageId() });
+  }
+  lastMessage() {
+    if (this._messages.length === 0) {
+      throw new Error("No messages in history");
+    }
+    return this._messages[this._messages.length - 1];
+  }
+  lastUserMessage() {
+    if (this._messages.length === 0) {
+      throw new Error("No messages in history");
+    }
+    const lastMessage = this._messages.findLast((message2) => message2.role === "user");
+    if (!lastMessage) {
+      throw new Error("No user message in history");
     }
+    return lastMessage;
+  }
+  lastToolCall(toolName) {
+    if (this._messages.length === 0) {
+      throw new Error("No messages in history");
+    }
+    const lastMessage = this._messages.findLast((message2) => message2.role === "tool" && message2.content.find(
+      (part) => part.type === "tool-result" && part.toolName === toolName
+    ));
+    if (!lastMessage) {
+      throw new Error("No tool call message in history");
+    }
+    return lastMessage;
+  }
+  hasToolCall(toolName) {
+    return this._messages.some(
+      (message2) => message2.role === "tool" && message2.content.find(
+        (part) => part.type === "tool-result" && part.toolName === toolName
+      )
+    );
   }
+};
+
+// src/events/schema.ts
+var import_core = require("@ag-ui/core");
+var import_zod3 = require("zod");
+var Verdict = /* @__PURE__ */ ((Verdict2) => {
+  Verdict2["SUCCESS"] = "success";
+  Verdict2["FAILURE"] = "failure";
+  Verdict2["INCONCLUSIVE"] = "inconclusive";
+  return Verdict2;
+})(Verdict || {});
+var ScenarioRunStatus = /* @__PURE__ */ ((ScenarioRunStatus2) => {
+  ScenarioRunStatus2["SUCCESS"] = "SUCCESS";
+  ScenarioRunStatus2["ERROR"] = "ERROR";
+  ScenarioRunStatus2["CANCELLED"] = "CANCELLED";
+  ScenarioRunStatus2["IN_PROGRESS"] = "IN_PROGRESS";
+  ScenarioRunStatus2["PENDING"] = "PENDING";
+  ScenarioRunStatus2["FAILED"] = "FAILED";
+  return ScenarioRunStatus2;
+})(ScenarioRunStatus || {});
+var baseEventSchema = import_zod3.z.object({
+  type: import_zod3.z.nativeEnum(import_core.EventType),
+  timestamp: import_zod3.z.number(),
+  rawEvent: import_zod3.z.any().optional()
+});
+var batchRunIdSchema = import_zod3.z.string();
+var scenarioRunIdSchema = import_zod3.z.string();
+var scenarioIdSchema = import_zod3.z.string();
+var baseScenarioEventSchema = baseEventSchema.extend({
+  batchRunId: batchRunIdSchema,
+  scenarioId: scenarioIdSchema,
+  scenarioRunId: scenarioRunIdSchema,
+  scenarioSetId: import_zod3.z.string().optional().default("default")
+});
+var scenarioRunStartedSchema = baseScenarioEventSchema.extend({
+  type: import_zod3.z.literal("SCENARIO_RUN_STARTED" /* RUN_STARTED */),
+  metadata: import_zod3.z.object({
+    name: import_zod3.z.string().optional(),
+    description: import_zod3.z.string().optional()
+  })
+});
+var scenarioResultsSchema = import_zod3.z.object({
+  verdict: import_zod3.z.nativeEnum(Verdict),
+  reasoning: import_zod3.z.string().optional(),
+  metCriteria: import_zod3.z.array(import_zod3.z.string()),
+  unmetCriteria: import_zod3.z.array(import_zod3.z.string()),
+  error: import_zod3.z.string().optional()
+});
+var scenarioRunFinishedSchema = baseScenarioEventSchema.extend({
+  type: import_zod3.z.literal("SCENARIO_RUN_FINISHED" /* RUN_FINISHED */),
+  status: import_zod3.z.nativeEnum(ScenarioRunStatus),
+  results: scenarioResultsSchema.optional().nullable()
+});
+var scenarioMessageSnapshotSchema = import_core.MessagesSnapshotEventSchema.merge(
+  baseScenarioEventSchema.extend({
+    type: import_zod3.z.literal("SCENARIO_MESSAGE_SNAPSHOT" /* MESSAGE_SNAPSHOT */)
+  })
+);
+var scenarioEventSchema = import_zod3.z.discriminatedUnion("type", [
+  scenarioRunStartedSchema,
+  scenarioRunFinishedSchema,
+  scenarioMessageSnapshotSchema
+]);
+var successSchema = import_zod3.z.object({ success: import_zod3.z.boolean() });
+var errorSchema = import_zod3.z.object({ error: import_zod3.z.string() });
+var stateSchema = import_zod3.z.object({
+  state: import_zod3.z.object({
+    messages: import_zod3.z.array(import_zod3.z.any()),
+    status: import_zod3.z.string()
+  })
+});
+var runsSchema = import_zod3.z.object({ runs: import_zod3.z.array(import_zod3.z.string()) });
+var eventsSchema = import_zod3.z.object({ events: import_zod3.z.array(scenarioEventSchema) });
+
+// src/execution/scenario-execution.ts
+var batchRunId2 = getBatchRunId();
+var ScenarioExecution = class {
+  state;
+  eventSubject = new import_rxjs.Subject();
+  logger = new Logger("scenario.execution.ScenarioExecution");
+  config;
+  agents = [];
+  pendingRolesOnTurn = [];
+  pendingAgentsOnTurn = /* @__PURE__ */ new Set();
+  pendingMessages = /* @__PURE__ */ new Map();
+  partialResult = null;
+  agentTimes = /* @__PURE__ */ new Map();
+  totalStartTime = 0;
   /**
-   * Executes a user turn.
-   * If content is provided, it's used as the user's message.
-   * If not, the user simulator agent is called to generate a message.
-   * This is part of the `ScenarioExecutionLike` interface used by script steps.
-   * @param content The optional content of the user's message.
+   * An observable stream of events that occur during the scenario execution.
+   * Subscribe to this to monitor the progress of the scenario in real-time.
    */
-  async user(content) {
-    await this.scriptCallAgent("User" /* USER */, content);
+  events$ = this.eventSubject.asObservable();
+  /**
+   * Creates a new ScenarioExecution instance.
+   * @param config The scenario configuration.
+   * @param script The script steps to execute.
+   */
+  constructor(config2, script) {
+    this.config = {
+      id: config2.id ?? generateScenarioId(),
+      name: config2.name,
+      description: config2.description,
+      agents: config2.agents,
+      script,
+      verbose: config2.verbose ?? false,
+      maxTurns: config2.maxTurns ?? 10,
+      threadId: config2.threadId ?? generateThreadId(),
+      setId: config2.setId
+    };
+    this.state = new ScenarioExecutionState(this.config);
+    this.reset();
   }
   /**
-   * Executes an agent turn.
-   * If content is provided, it's used as the agent's message.
-   * If not, the agent under test is called to generate a response.
-   * This is part of the `ScenarioExecutionLike` interface used by script steps.
-   * @param content The optional content of the agent's message.
+   * The history of messages in the conversation.
    */
-  async agent(content) {
-    await this.scriptCallAgent("Agent" /* AGENT */, content);
+  get messages() {
+    return this.state.messages;
   }
   /**
-   * Invokes the judge agent to evaluate the current state of the conversation.
-   * This is part of the `ScenarioExecutionLike` interface used by script steps.
-   * @param content Optional message to pass to the judge.
-   * @returns A promise that resolves with the scenario result if the judge makes a final decision, otherwise null.
+   * The unique identifier for the conversation thread.
    */
-  async judge(content) {
-    return await this.scriptCallAgent("Judge" /* JUDGE */, content, true);
+  get threadId() {
+    return this.state.threadId;
   }
   /**
-   * Lets the scenario proceed automatically for a specified number of turns.
-   * This simulates the natural flow of conversation between agents.
-   * This is part of the `ScenarioExecutionLike` interface used by script steps.
-   * @param turns The number of turns to proceed. If undefined, runs until a conclusion or max turns is reached.
-   * @param onTurn A callback executed at the end of each turn.
-   * @param onStep A callback executed after each agent interaction.
-   * @returns A promise that resolves with the scenario result if a conclusion is reached.
+   * The total elapsed time for the scenario execution.
    */
-  async proceed(turns, onTurn, onStep) {
-    let initialTurn = this.state.turn;
-    while (true) {
-      const goToNextTurn = turns === void 0 || initialTurn === null || this.state.turn != null && this.state.turn + 1 < initialTurn + turns;
-      const nextMessage = await this._step(goToNextTurn, onTurn);
-      if (initialTurn === null)
-        initialTurn = this.state.turn;
-      if (nextMessage === null) {
+  get totalTime() {
+    return Date.now() - this.totalStartTime;
+  }
+  /**
+   * Executes the entire scenario from start to finish.
+   * This will run through the script and any automatic proceeding logic until a
+   * final result (success, failure, or error) is determined.
+   * @returns A promise that resolves with the final result of the scenario.
+   */
+  async execute() {
+    this.reset();
+    const scenarioRunId = generateScenarioRunId();
+    this.emitRunStarted({ scenarioRunId });
+    try {
+      for (const scriptStep of this.config.script) {
+        this.logger.debug(`[${this.config.id}] Executing script step`, {
+          scriptStep
+        });
+        const result = await scriptStep(this.state, this);
+        this.emitMessageSnapshot({ scenarioRunId });
+        if (result && typeof result === "object" && "success" in result) {
+          this.emitRunFinished({
+            scenarioRunId,
+            status: result.success ? "SUCCESS" /* SUCCESS */ : "FAILED" /* FAILED */,
+            result
+          });
+          return result;
+        }
+      }
+      this.emitRunFinished({ scenarioRunId, status: "FAILED" /* FAILED */ });
+      return this.reachedMaxTurns([
+        "Reached end of script without conclusion, add one of the following to the end of the script:",
+        "- `Scenario.proceed()` to let the simulation continue to play out",
+        "- `Scenario.judge()` to force criteria judgement",
+        "- `Scenario.succeed()` or `Scenario.fail()` to end the test with an explicit result"
+      ].join("\n"));
+    } catch (error) {
+      const errorResult = {
+        success: false,
+        messages: this.state.messages,
+        reasoning: `Scenario failed with error: ${error instanceof Error ? error.message : String(error)}`,
+        metCriteria: [],
+        unmetCriteria: [],
+        error: error instanceof Error ? error.message : String(error)
+      };
+      this.emitRunFinished({
+        scenarioRunId,
+        status: "ERROR" /* ERROR */,
+        result: errorResult
+      });
+      return errorResult;
+    }
+  }
+  /**
+   * Executes a single step in the scenario.
+   * A step usually corresponds to a single agent's turn. This method is useful
+   * for manually controlling the scenario's progress.
+   * @returns A promise that resolves with the new messages added during the step, or a final scenario result if the step concludes the scenario.
+   */
+  async step() {
+    const result = await this._step();
+    if (result === null) throw new Error("No result from step");
+    return result;
+  }
+  async _step(goToNextTurn = true, onTurn) {
+    if (this.pendingRolesOnTurn.length === 0) {
+      if (!goToNextTurn) return null;
+      this.newTurn();
+      if (onTurn) await onTurn(this.state);
+      if (this.state.currentTurn >= this.config.maxTurns)
+        return this.reachedMaxTurns();
+    }
+    const currentRole = this.pendingRolesOnTurn[0];
+    const { idx, agent: nextAgent } = this.nextAgentForRole(currentRole);
+    if (!nextAgent) {
+      this.removePendingRole(currentRole);
+      return this._step(goToNextTurn, onTurn);
+    }
+    this.removePendingAgent(nextAgent);
+    return await this.callAgent(idx, currentRole);
+  }
+  async callAgent(idx, role, judgmentRequest = false) {
+    const agent2 = this.agents[idx];
+    const startTime = Date.now();
+    const agentInput = {
+      threadId: this.state.threadId,
+      messages: this.state.messages,
+      newMessages: this.pendingMessages.get(idx) ?? [],
+      requestedRole: role,
+      judgmentRequest,
+      scenarioState: this.state,
+      scenarioConfig: this.config
+    };
+    const agentResponse = await agent2.call(agentInput);
+    const endTime = Date.now();
+    this.addAgentTime(idx, endTime - startTime);
+    this.pendingMessages.delete(idx);
+    if (agentResponse && typeof agentResponse === "object" && "success" in agentResponse) {
+      return agentResponse;
+    }
+    const currentAgentTime = this.agentTimes.get(idx) ?? 0;
+    this.agentTimes.set(idx, currentAgentTime + (Date.now() - startTime));
+    const messages = convertAgentReturnTypesToMessages(
+      agentResponse,
+      role === "User" /* USER */ ? "user" : "assistant"
+    );
+    for (const message2 of messages) {
+      this.state.addMessage(message2);
+      this.broadcastMessage(message2, idx);
+    }
+    return messages;
+  }
+  /**
+   * Adds a message to the conversation history.
+   * This is part of the `ScenarioExecutionLike` interface used by script steps.
+   * @param message The message to add.
+   */
+  async message(message2) {
+    if (message2.role === "user") {
+      await this.scriptCallAgent("User" /* USER */, message2);
+    } else if (message2.role === "assistant") {
+      await this.scriptCallAgent("Agent" /* AGENT */, message2);
+    } else {
+      this.state.addMessage(message2);
+      this.broadcastMessage(message2);
+    }
+  }
+  /**
+   * Executes a user turn.
+   * If content is provided, it's used as the user's message.
+   * If not, the user simulator agent is called to generate a message.
+   * This is part of the `ScenarioExecutionLike` interface used by script steps.
+   * @param content The optional content of the user's message.
+   */
+  async user(content) {
+    await this.scriptCallAgent("User" /* USER */, content);
+  }
+  /**
+   * Executes an agent turn.
+   * If content is provided, it's used as the agent's message.
+   * If not, the agent under test is called to generate a response.
+   * This is part of the `ScenarioExecutionLike` interface used by script steps.
+   * @param content The optional content of the agent's message.
+   */
+  async agent(content) {
+    await this.scriptCallAgent("Agent" /* AGENT */, content);
+  }
+  /**
+   * Invokes the judge agent to evaluate the current state of the conversation.
+   * This is part of the `ScenarioExecutionLike` interface used by script steps.
+   * @param content Optional message to pass to the judge.
+   * @returns A promise that resolves with the scenario result if the judge makes a final decision, otherwise null.
+   */
+  async judge(content) {
+    return await this.scriptCallAgent("Judge" /* JUDGE */, content, true);
+  }
+  /**
+   * Lets the scenario proceed automatically for a specified number of turns.
+   * This simulates the natural flow of conversation between agents.
+   * This is part of the `ScenarioExecutionLike` interface used by script steps.
+   * @param turns The number of turns to proceed. If undefined, runs until a conclusion or max turns is reached.
+   * @param onTurn A callback executed at the end of each turn.
+   * @param onStep A callback executed after each agent interaction.
+   * @returns A promise that resolves with the scenario result if a conclusion is reached.
+   */
+  async proceed(turns, onTurn, onStep) {
+    let initialTurn = this.state.currentTurn;
+    while (true) {
+      const goToNextTurn = turns === void 0 || initialTurn === null || this.state.currentTurn != null && this.state.currentTurn + 1 < initialTurn + turns;
+      const nextMessage = await this._step(goToNextTurn, onTurn);
+      if (initialTurn === null)
+        initialTurn = this.state.currentTurn;
+      if (nextMessage === null) {
         return null;
       }
       if (onStep) await onStep(this.state);
@@ -755,10 +928,10 @@ var ScenarioExecution = class {
   async succeed(reasoning) {
     return {
       success: true,
-      messages: this.state.history,
+      messages: this.state.messages,
       reasoning: reasoning || "Scenario marked as successful with Scenario.succeed()",
-      passedCriteria: [],
-      failedCriteria: []
+      metCriteria: [],
+      unmetCriteria: []
     };
   }
   /**
@@ -770,25 +943,147 @@ var ScenarioExecution = class {
   async fail(reasoning) {
     return {
       success: false,
-      messages: this.state.history,
+      messages: this.state.messages,
       reasoning: reasoning || "Scenario marked as failed with Scenario.fail()",
-      passedCriteria: [],
-      failedCriteria: []
+      metCriteria: [],
+      unmetCriteria: []
     };
   }
+  addAgentTime(agentIdx, time) {
+    const currentTime = this.agentTimes.get(agentIdx) || 0;
+    this.agentTimes.set(agentIdx, currentTime + time);
+  }
+  hasResult() {
+    return this.partialResult !== null;
+  }
+  setResult(result) {
+    this.partialResult = result;
+  }
+  async scriptCallAgent(role, content, judgmentRequest = false) {
+    this.consumeUntilRole(role);
+    let index = -1;
+    let agent2 = null;
+    let nextAgent = this.getNextAgentForRole(role);
+    if (!nextAgent) {
+      this.newTurn();
+      this.consumeUntilRole(role);
+      nextAgent = this.getNextAgentForRole(role);
+    }
+    if (!nextAgent) {
+      let roleClass = "";
+      switch (role) {
+        case "User" /* USER */:
+          roleClass = "a scenario.userSimulatorAgent()";
+          break;
+        case "Agent" /* AGENT */:
+          roleClass = "a scenario.agent()";
+          break;
+        case "Judge" /* JUDGE */:
+          roleClass = "a scenario.judgeAgent()";
+          break;
+        default:
+          roleClass = "your agent";
+      }
+      if (content)
+        throw new Error(
+          `Cannot generate a message for role \`${role}\` with content \`${content}\` because no agent with this role was found, please add ${roleClass} to the scenario \`agents\` list`
+        );
+      throw new Error(
+        `Cannot generate a message for role \`${role}\` because no agent with this role was found, please add ${roleClass} to the scenario \`agents\` list`
+      );
+    }
+    index = nextAgent.index;
+    agent2 = nextAgent.agent;
+    this.removePendingAgent(agent2);
+    if (content) {
+      const message2 = typeof content === "string" ? { role: role === "User" /* USER */ ? "user" : "assistant", content } : content;
+      this.state.addMessage(message2);
+      this.broadcastMessage(message2, index);
+      return null;
+    }
+    const result = await this.callAgent(index, role, judgmentRequest);
+    if (result && typeof result === "object" && "success" in result) {
+      return result;
+    }
+    return null;
+  }
   reset() {
-    this.state = new ScenarioExecutionState();
-    this.state.setThreadId(this.config.threadId || generateThreadId());
-    this.state.setAgents(this.config.agents);
-    this.state.newTurn();
-    this.state.turn = 0;
-  }
-  // =====================================================
-  // Event Emission Methods
-  // =====================================================
-  // These methods handle the creation and emission of
-  // scenario events for external consumption and monitoring
-  // =====================================================
+    this.state = new ScenarioExecutionState(this.config);
+    this.state.threadId = this.config.threadId || generateThreadId();
+    this.setAgents(this.config.agents);
+    this.newTurn();
+    this.state.currentTurn = 0;
+    this.totalStartTime = Date.now();
+    this.pendingMessages.clear();
+  }
+  nextAgentForRole(role) {
+    for (const agent2 of this.agents) {
+      if (agent2.role === role && this.pendingAgentsOnTurn.has(agent2) && this.pendingRolesOnTurn.includes(role)) {
+        return { idx: this.agents.indexOf(agent2), agent: agent2 };
+      }
+    }
+    return { idx: -1, agent: null };
+  }
+  newTurn() {
+    this.pendingAgentsOnTurn = new Set(this.agents);
+    this.pendingRolesOnTurn = [
+      "User" /* USER */,
+      "Agent" /* AGENT */,
+      "Judge" /* JUDGE */
+    ];
+    if (this.state.currentTurn === null) {
+      this.state.currentTurn = 1;
+    } else {
+      this.state.currentTurn++;
+    }
+  }
+  removePendingRole(role) {
+    const index = this.pendingRolesOnTurn.indexOf(role);
+    if (index > -1) {
+      this.pendingRolesOnTurn.splice(index, 1);
+    }
+  }
+  removePendingAgent(agent2) {
+    this.pendingAgentsOnTurn.delete(agent2);
+  }
+  getNextAgentForRole(role) {
+    for (let i = 0; i < this.agents.length; i++) {
+      const agent2 = this.agents[i];
+      if (agent2.role === role && this.pendingAgentsOnTurn.has(agent2)) {
+        return { index: i, agent: agent2 };
+      }
+    }
+    return null;
+  }
+  setAgents(agents) {
+    this.agents = agents;
+    this.agentTimes.clear();
+  }
+  consumeUntilRole(role) {
+    while (this.pendingRolesOnTurn.length > 0) {
+      const nextRole = this.pendingRolesOnTurn[0];
+      if (nextRole === role) break;
+      this.pendingRolesOnTurn.pop();
+    }
+  }
+  reachedMaxTurns(errorMessage) {
+    var _a;
+    const agentRoleAgentsIdx = this.agents.map((agent2, i) => ({ agent: agent2, idx: i })).filter(({ agent: agent2 }) => agent2.role === "Agent" /* AGENT */).map(({ idx }) => idx);
+    const agentTimes = agentRoleAgentsIdx.map((i) => this.agentTimes.get(i) || 0);
+    const totalAgentTime = agentTimes.reduce((sum, time) => sum + time, 0);
+    return {
+      success: false,
+      messages: this.state.messages,
+      reasoning: errorMessage || `Reached maximum turns (${this.config.maxTurns || 10}) without conclusion`,
+      metCriteria: [],
+      unmetCriteria: ((_a = this.getJudgeAgent()) == null ? void 0 : _a.criteria) ?? [],
+      totalTime: this.totalTime,
+      agentTime: totalAgentTime
+    };
+  }
+  getJudgeAgent() {
+    return this.agents.find((agent2) => agent2 instanceof JudgeAgentAdapter) ?? null;
+  }
   /**
    * Emits an event to the event stream for external consumption.
    */
@@ -800,11 +1095,13 @@ var ScenarioExecution = class {
    */
   makeBaseEvent({ scenarioRunId }) {
     return {
+      type: "placeholder",
+      // This will be replaced by the specific event type
+      timestamp: Date.now(),
       batchRunId: batchRunId2,
       scenarioId: this.config.id,
       scenarioRunId,
-      timestamp: Date.now(),
-      rawEvent: void 0
+      scenarioSetId: this.config.setId
     };
   }
   /**
@@ -827,7 +1124,7 @@ var ScenarioExecution = class {
     this.emitEvent({
       ...this.makeBaseEvent({ scenarioRunId }),
       type: "SCENARIO_MESSAGE_SNAPSHOT" /* MESSAGE_SNAPSHOT */,
-      messages: this.state.history
+      messages: this.state.messages
       // Add any other required fields from MessagesSnapshotEventSchema
     });
   }
@@ -836,53 +1133,60 @@ var ScenarioExecution = class {
    */
   emitRunFinished({
     scenarioRunId,
-    status
+    status,
+    result
   }) {
-    this.emitEvent({
+    const event = {
       ...this.makeBaseEvent({ scenarioRunId }),
+      scenarioSetId: this.config.setId ?? "default",
       type: "SCENARIO_RUN_FINISHED" /* RUN_FINISHED */,
-      status
-      // Add error/metrics fields if needed
-    });
-  }
-};
-
-// src/config/load.ts
-var import_promises = __toESM(require("fs/promises"));
-var import_node_path = __toESM(require("path"));
-var import_node_url = require("url");
-async function loadScenarioProjectConfig() {
-  const cwd = process.cwd();
-  const configNames = [
-    "scenario.config.js",
-    "scenario.config.mjs"
-  ];
-  for (const name of configNames) {
-    const fullPath = import_node_path.default.join(cwd, name);
-    try {
-      await import_promises.default.access(fullPath);
-      const configModule = await import((0, import_node_url.pathToFileURL)(fullPath).href);
-      const config2 = configModule.default || configModule;
-      const parsed = scenarioProjectConfigSchema.safeParse(config2);
-      if (!parsed.success) {
-        throw new Error(
-          `Invalid config file ${name}: ${JSON.stringify(parsed.error.format(), null, 2)}`
-        );
+      status,
+      results: {
+        verdict: (result == null ? void 0 : result.success) ? "success" /* SUCCESS */ : "failure" /* FAILURE */,
+        metCriteria: (result == null ? void 0 : result.metCriteria) ?? [],
+        unmetCriteria: (result == null ? void 0 : result.unmetCriteria) ?? [],
+        reasoning: result == null ? void 0 : result.reasoning,
+        error: result == null ? void 0 : result.error
       }
-      return parsed.data;
-    } catch (error) {
-      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-        continue;
+    };
+    this.emitEvent(event);
+    this.eventSubject.complete();
+  }
+  /**
+   * Distributes a message to all other agents in the scenario.
+   *
+   * @param message - The message to broadcast.
+   * @param fromAgentIdx - The index of the agent that sent the message, to avoid echoing.
+   */
+  broadcastMessage(message2, fromAgentIdx) {
+    for (let idx = 0; idx < this.agents.length; idx++) {
+      if (idx === fromAgentIdx) continue;
+      if (!this.pendingMessages.has(idx)) {
+        this.pendingMessages.set(idx, []);
       }
-      throw error;
+      this.pendingMessages.get(idx).push(message2);
     }
   }
-  return await scenarioProjectConfigSchema.parseAsync({});
-}
-
-// src/events/event-bus.ts
-var import_rxjs2 = require("rxjs");
-
+};
+function convertAgentReturnTypesToMessages(response, role) {
+  if (typeof response === "string")
+    return [{ role, content: response }];
+  if (Array.isArray(response))
+    return response;
+  if (typeof response === "object" && "role" in response)
+    return [response];
+  return [];
+}
+
+// src/runner/index.ts
+var runner_exports = {};
+__export(runner_exports, {
+  run: () => run
+});
+
+// src/events/event-bus.ts
+var import_rxjs2 = require("rxjs");
+
 // src/events/event-reporter.ts
 var EventReporter = class {
   eventsEndpoint;
@@ -892,16 +1196,16 @@ var EventReporter = class {
     this.eventsEndpoint = new URL("/api/scenario-events", config2.endpoint);
     this.apiKey = config2.apiKey ?? "";
     if (!process.env.SCENARIO_DISABLE_SIMULATION_REPORT_INFO) {
-      console.log("=== Scenario Simulation Reporting ===");
       if (!this.apiKey) {
-        console.warn("LangWatch API key not configured, simulations will be local");
-        console.warn(`To enable simulation reporting in the LangWatch dashboard, configure your LangWatch API key (via LANGWATCH_API_KEY, or scenario.config.js)`);
+        console.log(
+          "\u27A1\uFE0F  LangWatch API key not configured, simulations will only output the final result"
+        );
+        console.log(
+          "To visualize the conversations in real time, configure your LangWatch API key (via LANGWATCH_API_KEY, or scenario.config.js)"
+        );
       } else {
-        console.log("Simulation reporting is enabled");
-        console.log(`Endpoint: ${config2.endpoint} -> ${this.eventsEndpoint.href}`);
-        console.log(`API Key: ${!this.apiKey ? "not configured" : "configured"}`);
+        console.log(`simulation reporting is enabled, endpoint:(${this.eventsEndpoint}) api_key_configured:(${this.apiKey.length > 0 ? "true" : "false"})`);
       }
-      console.log("=== Scenario Simulation Reporting ===");
     }
   }
   /**
@@ -953,13 +1257,25 @@ var EventReporter = class {
 };
 
 // src/events/event-bus.ts
-var EventBus = class {
+var EventBus = class _EventBus {
+  static registry = /* @__PURE__ */ new Set();
   events$ = new import_rxjs2.Subject();
   eventReporter;
   processingPromise = null;
   logger = new Logger("scenario.events.EventBus");
+  static globalListeners = [];
   constructor(config2) {
     this.eventReporter = new EventReporter(config2);
+    _EventBus.registry.add(this);
+    for (const listener of _EventBus.globalListeners) {
+      listener(this);
+    }
+  }
+  static getAllBuses() {
+    return _EventBus.registry;
+  }
+  static addGlobalListener(listener) {
+    _EventBus.globalListeners.push(listener);
   }
   /**
    * Publishes an event into the processing pipeline.
@@ -1014,7 +1330,7 @@ var EventBus = class {
    */
   async drain() {
     this.logger.debug("Draining event stream");
-    this.events$.unsubscribe();
+    this.events$.complete();
     if (this.processingPromise) {
       await this.processingPromise;
     }
@@ -1027,6 +1343,45 @@ var EventBus = class {
     this.logger.debug("Subscribing to event stream");
     return source$.subscribe(this.events$);
   }
+  /**
+   * Expose the events$ observable for external subscription (read-only).
+   */
+  get eventsObservable() {
+    return this.events$.asObservable();
+  }
+};
+
+// src/script/index.ts
+var script_exports = {};
+__export(script_exports, {
+  agent: () => agent,
+  fail: () => fail,
+  judge: () => judge,
+  message: () => message,
+  proceed: () => proceed,
+  succeed: () => succeed,
+  user: () => user
+});
+var message = (message2) => {
+  return (_state, executor) => executor.message(message2);
+};
+var agent = (content) => {
+  return (_state, executor) => executor.agent(content);
+};
+var judge = (content) => {
+  return (_state, executor) => executor.judge(content);
+};
+var user = (content) => {
+  return (_state, executor) => executor.user(content);
+};
+var proceed = (turns, onTurn, onStep) => {
+  return (_state, executor) => executor.proceed(turns, onTurn, onStep);
+};
+var succeed = (reasoning) => {
+  return (_state, executor) => executor.succeed(reasoning);
+};
+var fail = (reasoning) => {
+  return (_state, executor) => executor.fail(reasoning);
 };
 
 // src/runner/run.ts
@@ -1071,8 +1426,8 @@ async function run(cfg) {
       console.log(`Scenario failed: ${cfg.name}`);
       console.log(`Reasoning: ${result.reasoning}`);
       console.log("--------------------------------");
-      console.log(`Passed criteria: ${result.passedCriteria.join("\n- ")}`);
-      console.log(`Failed criteria: ${result.failedCriteria.join("\n- ")}`);
+      console.log(`Met criteria: ${result.metCriteria.join("\n- ")}`);
+      console.log(`Unmet criteria: ${result.unmetCriteria.join("\n- ")}`);
       console.log(result.messages.map(formatMessage).join("\n"));
     }
     return result;
@@ -1125,301 +1480,15 @@ function formatPart(part) {
   }
 }
 
-// src/agents/judge-agent.ts
-var import_ai = require("ai");
-var import_zod3 = require("zod");
-
-// src/agents/utils.ts
-var toolMessageRole = "tool";
-var assistantMessageRole = "assistant";
-var userMessageRole = "user";
-var groupMessagesByToolBoundaries = (messages) => {
-  const segments = [];
-  let currentSegment = [];
-  for (const message2 of messages) {
-    currentSegment.push(message2);
-    if (message2.role === toolMessageRole) {
-      segments.push(currentSegment);
-      currentSegment = [];
-    }
-  }
-  if (currentSegment.length > 0) {
-    segments.push(currentSegment);
-  }
-  return segments;
-};
-var segmentHasToolMessages = (segment) => {
-  return segment.some((message2) => {
-    if (message2.role === toolMessageRole) return true;
-    if (message2.role === assistantMessageRole && Array.isArray(message2.content)) {
-      return message2.content.some((part) => part.type === "tool-call");
-    }
-    return false;
-  });
-};
-var reverseSegmentRoles = (segment) => {
-  return segment.map((message2) => {
-    const hasStringContent = typeof message2.content === "string";
-    if (!hasStringContent) return message2;
-    const roleMap = {
-      [userMessageRole]: assistantMessageRole,
-      [assistantMessageRole]: userMessageRole
-    };
-    const newRole = roleMap[message2.role];
-    if (!newRole) return message2;
-    return {
-      role: newRole,
-      content: message2.content
-    };
-  });
-};
-var messageRoleReversal = (messages) => {
-  const segments = groupMessagesByToolBoundaries(messages);
-  const processedSegments = segments.map(
-    (segment) => segmentHasToolMessages(segment) ? segment : reverseSegmentRoles(segment)
-  );
-  return processedSegments.flat();
-};
-var criterionToParamName = (criterion) => {
-  return criterion.replace(/"/g, "").replace(/[^a-zA-Z0-9]/g, "_").replace(/ /g, "_").toLowerCase().substring(0, 70);
-};
-
-// src/config/index.ts
-var logger = new Logger("scenario.config");
-var configLoaded = false;
-var config = null;
-var configLoadPromise = null;
-async function loadProjectConfig() {
-  if (configLoaded) {
-    return;
-  }
-  if (configLoadPromise) {
-    return configLoadPromise;
-  }
-  configLoadPromise = (async () => {
-    try {
-      config = await loadScenarioProjectConfig();
-      logger.info("loaded scenario project config", { config });
-    } catch (error) {
-      logger.error("error loading scenario project config", { error });
-    } finally {
-      configLoaded = true;
-    }
-  })();
-  return configLoadPromise;
-}
-async function getProjectConfig() {
-  await loadProjectConfig();
-  return config;
-}
-
-// src/utils/config.ts
-function mergeConfig(config2, projectConfig) {
-  if (!projectConfig) {
-    return config2;
-  }
-  return {
-    ...projectConfig.defaultModel,
-    ...config2
-  };
-}
-function mergeAndValidateConfig(config2, projectConfig) {
-  var _a;
-  const mergedConfig = mergeConfig(config2, projectConfig);
-  mergedConfig.model = mergedConfig.model ?? ((_a = projectConfig == null ? void 0 : projectConfig.defaultModel) == null ? void 0 : _a.model);
-  if (!mergedConfig.model) {
-    throw new Error("Model is required");
-  }
-  return mergedConfig;
-}
-
-// src/agents/judge-agent.ts
-function buildSystemPrompt(criteria, description) {
-  const criteriaList = (criteria == null ? void 0 : criteria.map((criterion, idx) => `${idx + 1}. ${criterion}`).join("\n")) || "No criteria provided";
-  return `
-<role>
-You are an LLM as a judge watching a simulated conversation as it plays out live to determine if the agent under test meets the criteria or not.
-</role>
-
-<goal>
-Your goal is to determine if you already have enough information to make a verdict of the scenario below, or if the conversation should continue for longer.
-If you do have enough information, use the finish_test tool to determine if all the criteria have been met, if not, use the continue_test tool to let the next step play out.
-</goal>
-
-<scenario>
-${description}
-</scenario>
-
-<criteria>
-${criteriaList}
-</criteria>
-
-<rules>
-- Be strict, do not let the conversation continue if the agent already broke one of the "do not" or "should not" criteria.
-- DO NOT make any judgment calls that are not explicitly listed in the success or failure criteria, withhold judgement if necessary
-</rules>
-`.trim();
-}
-function buildContinueTestTool() {
-  return (0, import_ai.tool)({
-    description: "Continue the test with the next step",
-    parameters: import_zod3.z.object({})
-  });
-}
-function buildFinishTestTool(criteria) {
-  const criteriaNames = criteria.map(criterionToParamName);
-  return (0, import_ai.tool)({
-    description: "Complete the test with a final verdict",
-    parameters: import_zod3.z.object({
-      criteria: import_zod3.z.object(
-        Object.fromEntries(
-          criteriaNames.map((name, idx) => [
-            name,
-            import_zod3.z.enum(["true", "false", "inconclusive"]).describe(criteria[idx])
-          ])
-        )
-      ).strict().describe("Strict verdict for each criterion"),
-      reasoning: import_zod3.z.string().describe("Explanation of what the final verdict should be"),
-      verdict: import_zod3.z.enum(["success", "failure", "inconclusive"]).describe("The final verdict of the test")
-    })
-  });
-}
-var judgeAgent = (cfg) => {
-  return {
-    role: "Judge" /* JUDGE */,
-    criteria: cfg.criteria,
-    call: async (input) => {
-      var _a;
-      const systemPrompt = cfg.systemPrompt ?? buildSystemPrompt(cfg.criteria, input.scenarioConfig.description);
-      const messages = [
-        { role: "system", content: systemPrompt },
-        ...input.messages
-      ];
-      const isLastMessage = input.scenarioState.turn == input.scenarioConfig.maxTurns;
-      const projectConfig = await getProjectConfig();
-      const mergedConfig = mergeAndValidateConfig(cfg, projectConfig);
-      if (!mergedConfig.model) {
-        throw new Error("Model is required for the judge agent");
-      }
-      const tools = {
-        continue_test: buildContinueTestTool(),
-        finish_test: buildFinishTestTool(cfg.criteria)
-      };
-      const enforceJudgement = input.judgmentRequest;
-      const hasCriteria = cfg.criteria.length && cfg.criteria.length > 0;
-      if (enforceJudgement && !hasCriteria) {
-        return {
-          success: false,
-          messages: [],
-          reasoning: "JudgeAgent: No criteria was provided to be judged against",
-          passedCriteria: [],
-          failedCriteria: []
-        };
-      }
-      const toolChoice = (isLastMessage || enforceJudgement) && hasCriteria ? { type: "tool", toolName: "finish_test" } : "required";
-      const completion = await (0, import_ai.generateText)({
-        model: mergedConfig.model,
-        messages,
-        temperature: mergedConfig.temperature ?? 0,
-        maxTokens: mergedConfig.maxTokens,
-        tools,
-        toolChoice
-      });
-      let args;
-      if ((_a = completion.toolCalls) == null ? void 0 : _a.length) {
-        const toolCall = completion.toolCalls[0];
-        switch (toolCall.toolName) {
-          case "finish_test": {
-            args = toolCall.args;
-            const verdict = args.verdict || "inconclusive";
-            const reasoning = args.reasoning || "No reasoning provided";
-            const criteria = args.criteria || {};
-            const criteriaValues = Object.values(criteria);
-            const passedCriteria = cfg.criteria.filter((_, i) => criteriaValues[i] === "true");
-            const failedCriteria = cfg.criteria.filter((_, i) => criteriaValues[i] !== "true");
-            return {
-              success: verdict === "success",
-              messages: input.messages,
-              reasoning,
-              passedCriteria,
-              failedCriteria
-            };
-          }
-          case "continue_test":
-            return [];
-          default:
-            return {
-              success: false,
-              messages: input.messages,
-              reasoning: `JudgeAgent: Unknown tool call: ${toolCall.toolName}`,
-              passedCriteria: [],
-              failedCriteria: cfg.criteria
-            };
-        }
-      }
-      return {
-        success: false,
-        messages: input.messages,
-        reasoning: `JudgeAgent: No tool call found in LLM output`,
-        passedCriteria: [],
-        failedCriteria: cfg.criteria
-      };
-    }
-  };
-};
-
-// src/agents/user-simulator-agent.ts
-var import_ai2 = require("ai");
-function buildSystemPrompt2(description) {
-  return `
-<role>
-You are pretending to be a user, you are testing an AI Agent (shown as the user role) based on a scenario.
-Approach this naturally, as a human user would, with very short inputs, few words, all lowercase, imperative, not periods, like when they google or talk to chatgpt.
-</role>
-
-<goal>
-Your goal (assistant) is to interact with the Agent Under Test (user) as if you were a human user to see if it can complete the scenario successfully.
-</goal>
-
-<scenario>
-${description}
-</scenario>
-
-<rules>
-- DO NOT carry over any requests yourself, YOU ARE NOT the assistant today, you are the user
-</rules>
-`.trim();
-}
-var userSimulatorAgent = (config2) => {
-  return {
-    role: "User" /* USER */,
-    call: async (input) => {
-      const systemPrompt = buildSystemPrompt2(input.scenarioConfig.description);
-      const messages = [
-        { role: "system", content: systemPrompt },
-        { role: "assistant", content: "Hello, how can I help you today" },
-        ...input.messages
-      ];
-      const projectConfig = await getProjectConfig();
-      const mergedConfig = mergeAndValidateConfig(config2 ?? {}, projectConfig);
-      if (!mergedConfig.model) {
-        throw new Error("Model is required for the user simulator agent");
-      }
-      const reversedMessages = messageRoleReversal(messages);
-      const completion = await (0, import_ai2.generateText)({
-        model: mergedConfig.model,
-        messages: reversedMessages,
-        temperature: mergedConfig.temperature ?? 0,
-        maxTokens: mergedConfig.maxTokens
-      });
-      const messageContent = completion.text;
-      if (!messageContent) {
-        throw new Error("No response content from LLM");
-      }
-      return { role: "user", content: messageContent };
-    }
-  };
+// src/index.ts
+var scenario = {
+  ...agents_exports,
+  ...domain_exports,
+  ...execution_exports,
+  ...runner_exports,
+  ...script_exports
 };
+var index_default = scenario;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentAdapter,
@@ -1437,6 +1506,7 @@ var userSimulatorAgent = (config2) => {
   message,
   proceed,
   run,
+  scenario,
   scenarioProjectConfigSchema,
   succeed,
   user,