@langwatch/scenario 0.2.0-prerelease.0

package/dist/index.js

@@ -0,0 +1,1444 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentAdapter: () => AgentAdapter,
+  AgentRole: () => AgentRole,
+  JudgeAgentAdapter: () => JudgeAgentAdapter,
+  ScenarioExecution: () => ScenarioExecution,
+  ScenarioExecutionState: () => ScenarioExecutionState,
+  UserSimulatorAgentAdapter: () => UserSimulatorAgentAdapter,
+  agent: () => agent,
+  allAgentRoles: () => allAgentRoles,
+  defineConfig: () => defineConfig,
+  fail: () => fail,
+  judge: () => judge,
+  judgeAgent: () => judgeAgent,
+  message: () => message,
+  proceed: () => proceed,
+  run: () => run,
+  scenarioProjectConfigSchema: () => scenarioProjectConfigSchema,
+  succeed: () => succeed,
+  user: () => user,
+  userSimulatorAgent: () => userSimulatorAgent
+});
+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/execution/scenario-execution.ts
+var import_rxjs = require("rxjs");
+
+// src/domain/core/config.ts
+var import_zod = require("zod");
+var scenarioProjectConfigSchema = import_zod.z.object({
+  defaultModel: import_zod.z.object({
+    model: import_zod.z.custom(),
+    temperature: import_zod.z.number().min(0).max(1).optional().default(0),
+    maxTokens: import_zod.z.number().optional()
+  }).optional(),
+  langwatchEndpoint: import_zod.z.string().optional(),
+  langwatchApiKey: import_zod.z.string().optional()
+}).strict();
+function defineConfig(config2) {
+  return config2;
+}
+
+// src/domain/agents/index.ts
+var AgentRole = /* @__PURE__ */ ((AgentRole2) => {
+  AgentRole2["USER"] = "User";
+  AgentRole2["AGENT"] = "Agent";
+  AgentRole2["JUDGE"] = "Judge";
+  return AgentRole2;
+})(AgentRole || {});
+var allAgentRoles = ["User" /* USER */, "Agent" /* AGENT */, "Judge" /* JUDGE */];
+var AgentAdapter = class {
+  role = "Agent" /* AGENT */;
+  constructor(input) {
+    void input;
+  }
+};
+var UserSimulatorAgentAdapter = class {
+  role = "User" /* USER */;
+  constructor(input) {
+    void input;
+  }
+};
+var JudgeAgentAdapter = class {
+  role = "Judge" /* JUDGE */;
+  constructor(input) {
+    void input;
+  }
+};
+
+// 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);
+    }
+  }
+  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++;
+    }
+  }
+  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;
+  }
+  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) });
+
+// src/utils/logger.ts
+var Logger = class _Logger {
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Creates a logger with context (e.g., class name)
+   */
+  static create(context) {
+    return new _Logger(context);
+  }
+  /**
+   * Checks if logging should occur based on LOG_LEVEL env var
+   */
+  shouldLog(level) {
+    const logLevel = (process.env.SCENARIO_LOG_LEVEL || "").toLowerCase();
+    const levels = ["error", "warn", "info", "debug"];
+    const currentLevelIndex = levels.indexOf(logLevel);
+    const requestedLevelIndex = levels.indexOf(level);
+    return currentLevelIndex >= 0 && requestedLevelIndex <= currentLevelIndex;
+  }
+  formatMessage(message2) {
+    return this.context ? `[${this.context}] ${message2}` : message2;
+  }
+  error(message2, data) {
+    if (this.shouldLog("error")) {
+      const formattedMessage = this.formatMessage(message2);
+      if (data) {
+        console.error(formattedMessage, data);
+      } else {
+        console.error(formattedMessage);
+      }
+    }
+  }
+  warn(message2, data) {
+    if (this.shouldLog("warn")) {
+      const formattedMessage = this.formatMessage(message2);
+      if (data) {
+        console.warn(formattedMessage, data);
+      } else {
+        console.warn(formattedMessage);
+      }
+    }
+  }
+  info(message2, data) {
+    if (this.shouldLog("info")) {
+      const formattedMessage = this.formatMessage(message2);
+      if (data) {
+        console.info(formattedMessage, data);
+      } else {
+        console.info(formattedMessage);
+      }
+    }
+  }
+  debug(message2, data) {
+    if (this.shouldLog("debug")) {
+      const formattedMessage = this.formatMessage(message2);
+      if (data) {
+        console.log(formattedMessage, data);
+      } else {
+        console.log(formattedMessage);
+      }
+    }
+  }
+};
+
+// 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;
+  }
+  /**
+   * The unique identifier for the conversation thread.
+   */
+  get threadId() {
+    return this.state.threadId;
+  }
+  /**
+   * 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 */
+          });
+          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) {
+      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);
+    }
+    this.state.removePendingAgent(nextAgent);
+    return await this.callAgent(idx, currentRole);
+  }
+  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;
+  }
+  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 { 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`
+        );
+      }
+      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);
+      }
+      return null;
+    }
+    const result = await this.callAgent(index, role, judgmentRequest);
+    if (Array.isArray(result))
+      return null;
+    return result;
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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.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) {
+        return null;
+      }
+      if (onStep) await onStep(this.state);
+      if (nextMessage !== null && typeof nextMessage === "object" && "success" in nextMessage)
+        return nextMessage;
+    }
+  }
+  /**
+   * Immediately ends the scenario with a success verdict.
+   * This is part of the `ScenarioExecutionLike` interface used by script steps.
+   * @param reasoning An optional explanation for the success.
+   * @returns A promise that resolves with the final successful scenario result.
+   */
+  async succeed(reasoning) {
+    return {
+      success: true,
+      messages: this.state.history,
+      reasoning: reasoning || "Scenario marked as successful with Scenario.succeed()",
+      passedCriteria: [],
+      failedCriteria: []
+    };
+  }
+  /**
+   * Immediately ends the scenario with a failure verdict.
+   * This is part of the `ScenarioExecutionLike` interface used by script steps.
+   * @param reasoning An optional explanation for the failure.
+   * @returns A promise that resolves with the final failed scenario result.
+   */
+  async fail(reasoning) {
+    return {
+      success: false,
+      messages: this.state.history,
+      reasoning: reasoning || "Scenario marked as failed with Scenario.fail()",
+      passedCriteria: [],
+      failedCriteria: []
+    };
+  }
+  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
+  // =====================================================
+  /**
+   * Emits an event to the event stream for external consumption.
+   */
+  emitEvent(event) {
+    this.eventSubject.next(event);
+  }
+  /**
+   * Creates base event properties shared across all scenario events.
+   */
+  makeBaseEvent({ scenarioRunId }) {
+    return {
+      batchRunId: batchRunId2,
+      scenarioId: this.config.id,
+      scenarioRunId,
+      timestamp: Date.now(),
+      rawEvent: void 0
+    };
+  }
+  /**
+   * Emits a run started event to indicate scenario execution has begun.
+   */
+  emitRunStarted({ scenarioRunId }) {
+    this.emitEvent({
+      ...this.makeBaseEvent({ scenarioRunId }),
+      type: "SCENARIO_RUN_STARTED" /* RUN_STARTED */,
+      metadata: {
+        name: this.config.name,
+        description: this.config.description
+      }
+    });
+  }
+  /**
+   * Emits a message snapshot event containing current conversation history.
+   */
+  emitMessageSnapshot({ scenarioRunId }) {
+    this.emitEvent({
+      ...this.makeBaseEvent({ scenarioRunId }),
+      type: "SCENARIO_MESSAGE_SNAPSHOT" /* MESSAGE_SNAPSHOT */,
+      messages: this.state.history
+      // Add any other required fields from MessagesSnapshotEventSchema
+    });
+  }
+  /**
+   * Emits a run finished event with the final execution status.
+   */
+  emitRunFinished({
+    scenarioRunId,
+    status
+  }) {
+    this.emitEvent({
+      ...this.makeBaseEvent({ scenarioRunId }),
+      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)}`
+        );
+      }
+      return parsed.data;
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        continue;
+      }
+      throw error;
+    }
+  }
+  return await scenarioProjectConfigSchema.parseAsync({});
+}
+
+// src/events/event-bus.ts
+var import_rxjs2 = require("rxjs");
+
+// src/events/event-reporter.ts
+var EventReporter = class {
+  eventsEndpoint;
+  apiKey;
+  logger = new Logger("scenario.events.EventReporter");
+  constructor(config2) {
+    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)`);
+      } 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("=== Scenario Simulation Reporting ===");
+    }
+  }
+  /**
+   * Posts an event to the configured endpoint.
+   * Logs success/failure but doesn't throw - event posting shouldn't break scenario execution.
+   */
+  async postEvent(event) {
+    this.logger.debug(`[${event.type}] Posting event`, {
+      event
+    });
+    if (!this.eventsEndpoint) {
+      this.logger.warn(
+        "No LANGWATCH_ENDPOINT configured, skipping event posting"
+      );
+      return;
+    }
+    try {
+      const response = await fetch(this.eventsEndpoint.href, {
+        method: "POST",
+        body: JSON.stringify(event),
+        headers: {
+          "Content-Type": "application/json",
+          "X-Auth-Token": this.apiKey
+        }
+      });
+      this.logger.debug(
+        `[${event.type}] Event POST response status: ${response.status}`
+      );
+      if (response.ok) {
+        const data = await response.json();
+        this.logger.debug(`[${event.type}] Event POST response:`, data);
+      } else {
+        const errorText = await response.text();
+        this.logger.error(`[${event.type}] Event POST failed:`, {
+          status: response.status,
+          statusText: response.statusText,
+          error: errorText,
+          event
+        });
+      }
+    } catch (error) {
+      this.logger.error(`[${event.type}] Event POST error:`, {
+        error,
+        event,
+        endpoint: this.eventsEndpoint
+      });
+    }
+  }
+};
+
+// src/events/event-bus.ts
+var EventBus = class {
+  events$ = new import_rxjs2.Subject();
+  eventReporter;
+  processingPromise = null;
+  logger = new Logger("scenario.events.EventBus");
+  constructor(config2) {
+    this.eventReporter = new EventReporter(config2);
+  }
+  /**
+   * Publishes an event into the processing pipeline.
+   */
+  publish(event) {
+    this.logger.debug(`[${event.type}] Publishing event`, {
+      event
+    });
+    this.events$.next(event);
+  }
+  /**
+   * Begins listening for and processing events.
+   * Returns a promise that resolves when a RUN_FINISHED event is fully processed.
+   */
+  listen() {
+    this.logger.debug("Listening for events");
+    if (this.processingPromise) {
+      return this.processingPromise;
+    }
+    this.processingPromise = new Promise((resolve, reject) => {
+      this.events$.pipe(
+        (0, import_rxjs2.concatMap)(async (event) => {
+          this.logger.debug(`[${event.type}] Processing event`, {
+            event
+          });
+          await this.eventReporter.postEvent(event);
+          return event;
+        }),
+        (0, import_rxjs2.catchError)((error) => {
+          this.logger.error("Error in event stream:", error);
+          return import_rxjs2.EMPTY;
+        })
+      ).subscribe({
+        next: (event) => {
+          this.logger.debug(`[${event.type}] Event processed`, {
+            event
+          });
+          if (event.type === "SCENARIO_RUN_FINISHED" /* RUN_FINISHED */) {
+            resolve();
+          }
+        },
+        error: (error) => {
+          this.logger.error("Error in event stream:", error);
+          reject(error);
+        }
+      });
+    });
+    return this.processingPromise;
+  }
+  /**
+   * Stops accepting new events and drains the processing queue.
+   */
+  async drain() {
+    this.logger.debug("Draining event stream");
+    this.events$.unsubscribe();
+    if (this.processingPromise) {
+      await this.processingPromise;
+    }
+  }
+  /**
+   * Subscribes to an event stream.
+   * @param source$ - The event stream to subscribe to.
+   */
+  subscribeTo(source$) {
+    this.logger.debug("Subscribing to event stream");
+    return source$.subscribe(this.events$);
+  }
+};
+
+// src/runner/run.ts
+async function run(cfg) {
+  if (!cfg.name) {
+    throw new Error("Scenario name is required");
+  }
+  if (!cfg.description) {
+    throw new Error("Scenario description is required");
+  }
+  if ((cfg.maxTurns || 10) < 1) {
+    throw new Error("Max turns must be at least 1");
+  }
+  if (cfg.agents.length === 0) {
+    throw new Error("At least one agent is required");
+  }
+  if (!cfg.agents.find((agent2) => agent2.role === "Agent" /* AGENT */)) {
+    throw new Error("At least one non-user/non-judge agent is required");
+  }
+  cfg.agents.forEach((agent2, i) => {
+    if (!allAgentRoles.includes(agent2.role)) {
+      throw new Error(`Agent ${i} has invalid role: ${agent2.role}`);
+    }
+  });
+  if (!cfg.threadId) {
+    cfg.threadId = generateThreadId();
+  }
+  const steps = cfg.script || [proceed()];
+  const execution = new ScenarioExecution(cfg, steps);
+  let eventBus = null;
+  let subscription = null;
+  try {
+    const projectConfig = await loadScenarioProjectConfig();
+    eventBus = new EventBus({
+      endpoint: projectConfig.langwatchEndpoint ?? process.env.LANGWATCH_ENDPOINT ?? "https://app.langwatch.ai",
+      apiKey: projectConfig.langwatchApiKey ?? process.env.LANGWATCH_API_KEY
+    });
+    eventBus.listen();
+    subscription = eventBus.subscribeTo(execution.events$);
+    const result = await execution.execute();
+    if (cfg.verbose && !result.success) {
+      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(result.messages.map(formatMessage).join("\n"));
+    }
+    return result;
+  } finally {
+    await (eventBus == null ? void 0 : eventBus.drain());
+    subscription == null ? void 0 : subscription.unsubscribe();
+  }
+}
+function formatMessage(m) {
+  switch (m.role) {
+    case "user":
+      return `User: ${m.content}`;
+    case "assistant":
+      return `Assistant: ${formatParts(m.content)}`;
+    case "tool":
+      return `Tool: ${formatParts(m.content)}`;
+    default:
+      return `${m.role}: ${m.content}`;
+  }
+}
+function formatParts(part) {
+  if (typeof part === "string") {
+    return part;
+  }
+  if (Array.isArray(part)) {
+    if (part.length === 1) {
+      return formatPart(part[0]);
+    }
+    return `
+${part.map(formatPart).join("\n")}`;
+  }
+  return "Unknown content: " + JSON.stringify(part);
+}
+function formatPart(part) {
+  switch (part.type) {
+    case "text":
+      return part.text;
+    case "file":
+      return `(file): ${part.filename} ${typeof part.data === "string" ? `url:${part.data}` : "base64:omitted"}`;
+    case "tool-call":
+      return `(tool call): ${part.toolName} id:${part.toolCallId} args:(${JSON.stringify(part.args)})`;
+    case "tool-result":
+      return `(tool result): ${part.toolName} id:${part.toolCallId} result:(${JSON.stringify(part.result)})`;
+    case "reasoning":
+      return `(reasoning): ${part.text}`;
+    case "redacted-reasoning":
+      return `(redacted reasoning): ${part.data}`;
+    default:
+      return `Unknown content: ${JSON.stringify(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 };
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentAdapter,
+  AgentRole,
+  JudgeAgentAdapter,
+  ScenarioExecution,
+  ScenarioExecutionState,
+  UserSimulatorAgentAdapter,
+  agent,
+  allAgentRoles,
+  defineConfig,
+  fail,
+  judge,
+  judgeAgent,
+  message,
+  proceed,
+  run,
+  scenarioProjectConfigSchema,
+  succeed,
+  user,
+  userSimulatorAgent
+});