@langwatch/scenario 0.4.1 → 0.4.3

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,359 +30,976 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AgentAdapter: () => AgentAdapter,
-  AgentRole: () => AgentRole,
-  DEFAULT_MAX_TURNS: () => DEFAULT_MAX_TURNS,
-  DEFAULT_VERBOSE: () => DEFAULT_VERBOSE,
-  JudgeAgentAdapter: () => JudgeAgentAdapter,
-  JudgeSpanCollector: () => JudgeSpanCollector,
-  JudgeSpanDigestFormatter: () => JudgeSpanDigestFormatter,
-  RealtimeAgentAdapter: () => RealtimeAgentAdapter,
-  ScenarioExecution: () => ScenarioExecution,
-  ScenarioExecutionState: () => ScenarioExecutionState,
-  StateChangeEventType: () => StateChangeEventType,
-  UserSimulatorAgentAdapter: () => UserSimulatorAgentAdapter,
-  agent: () => agent,
-  allAgentRoles: () => allAgentRoles,
-  default: () => index_default,
-  defineConfig: () => defineConfig,
-  fail: () => fail,
-  judge: () => judge,
-  judgeAgent: () => judgeAgent,
-  judgeSpanCollector: () => judgeSpanCollector,
-  judgeSpanDigestFormatter: () => judgeSpanDigestFormatter,
-  message: () => message,
-  proceed: () => proceed,
-  run: () => run,
-  scenario: () => scenario,
-  scenarioProjectConfigSchema: () => scenarioProjectConfigSchema,
-  succeed: () => succeed,
-  user: () => user,
-  userSimulatorAgent: () => userSimulatorAgent
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
+var _globalThis;
+var init_globalThis = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js"() {
+    "use strict";
+    _globalThis = typeof globalThis === "object" ? globalThis : global;
+  }
 });
-module.exports = __toCommonJS(index_exports);
 
-// src/tracing/setup.ts
-var import_node = require("langwatch/observability/node");
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/platform/node/index.js
+var init_node = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/platform/node/index.js"() {
+    "use strict";
+    init_globalThis();
+  }
+});
 
-// src/agents/judge/judge-span-collector.ts
-var import_observability = require("langwatch/observability");
-var JudgeSpanCollector = class {
-  spans = [];
-  onStart() {
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/platform/index.js
+var init_platform = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/platform/index.js"() {
+    "use strict";
+    init_node();
   }
-  onEnd(span) {
-    this.spans.push(span);
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/version.js
+var VERSION;
+var init_version = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/version.js"() {
+    "use strict";
+    VERSION = "1.9.0";
   }
-  forceFlush() {
-    return Promise.resolve();
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/internal/semver.js
+function _makeCompatibilityCheck(ownVersion) {
+  var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+  var rejectedVersions = /* @__PURE__ */ new Set();
+  var myVersionMatch = ownVersion.match(re);
+  if (!myVersionMatch) {
+    return function() {
+      return false;
+    };
   }
-  shutdown() {
-    this.spans = [];
-    return Promise.resolve();
+  var ownVersionParsed = {
+    major: +myVersionMatch[1],
+    minor: +myVersionMatch[2],
+    patch: +myVersionMatch[3],
+    prerelease: myVersionMatch[4]
+  };
+  if (ownVersionParsed.prerelease != null) {
+    return function isExactmatch(globalVersion) {
+      return globalVersion === ownVersion;
+    };
   }
-  /**
-   * Retrieves all spans associated with a specific thread.
-   * @param threadId - The thread identifier to filter spans by
-   * @returns Array of spans for the given thread
-   */
-  getSpansForThread(threadId) {
-    const spanMap = /* @__PURE__ */ new Map();
-    for (const span of this.spans) {
-      spanMap.set(span.spanContext().spanId, span);
+  function _reject(v) {
+    rejectedVersions.add(v);
+    return false;
+  }
+  function _accept(v) {
+    acceptedVersions.add(v);
+    return true;
+  }
+  return function isCompatible2(globalVersion) {
+    if (acceptedVersions.has(globalVersion)) {
+      return true;
     }
-    const belongsToThread = (span) => {
-      var _a;
-      if (span.attributes[import_observability.attributes.ATTR_LANGWATCH_THREAD_ID] === threadId) {
-        return true;
-      }
-      const parentId = (_a = span.parentSpanContext) == null ? void 0 : _a.spanId;
-      if (parentId && spanMap.has(parentId)) {
-        return belongsToThread(spanMap.get(parentId));
-      }
+    if (rejectedVersions.has(globalVersion)) {
       return false;
+    }
+    var globalVersionMatch = globalVersion.match(re);
+    if (!globalVersionMatch) {
+      return _reject(globalVersion);
+    }
+    var globalVersionParsed = {
+      major: +globalVersionMatch[1],
+      minor: +globalVersionMatch[2],
+      patch: +globalVersionMatch[3],
+      prerelease: globalVersionMatch[4]
     };
-    return this.spans.filter(belongsToThread);
+    if (globalVersionParsed.prerelease != null) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major !== globalVersionParsed.major) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major === 0) {
+      if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+        return _accept(globalVersion);
+      }
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+      return _accept(globalVersion);
+    }
+    return _reject(globalVersion);
+  };
+}
+var re, isCompatible;
+var init_semver = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/internal/semver.js"() {
+    "use strict";
+    init_version();
+    re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+    isCompatible = _makeCompatibilityCheck(VERSION);
   }
-};
-var judgeSpanCollector = new JudgeSpanCollector();
-
-// src/config/env.ts
-var import_v4 = require("zod/v4");
-
-// src/config/log-levels.ts
-var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-  LogLevel2["ERROR"] = "ERROR";
-  LogLevel2["WARN"] = "WARN";
-  LogLevel2["INFO"] = "INFO";
-  LogLevel2["DEBUG"] = "DEBUG";
-  return LogLevel2;
-})(LogLevel || {});
-var LOG_LEVELS = Object.values(LogLevel);
+});
 
-// src/config/env.ts
-var envSchema = import_v4.z.object({
-  /**
-   * LangWatch API key for event reporting.
-   * If not provided, events will not be sent to LangWatch.
-   */
-  LANGWATCH_API_KEY: import_v4.z.string().optional(),
-  /**
-   * LangWatch endpoint URL for event reporting.
-   * Defaults to the production LangWatch endpoint.
-   */
-  LANGWATCH_ENDPOINT: import_v4.z.string().url().optional().default("https://app.langwatch.ai"),
-  /**
-   * Disables simulation report info messages when set to any truthy value.
-   * Useful for CI/CD environments or when you want cleaner output.
-   */
-  SCENARIO_DISABLE_SIMULATION_REPORT_INFO: import_v4.z.string().optional().transform((val) => Boolean(val)),
-  /**
-   * Node environment - affects logging and behavior.
-   * Defaults to 'development' if not specified.
-   */
-  NODE_ENV: import_v4.z.enum(["development", "production", "test"]).default("development"),
-  /**
-   * Case-insensitive log level for the scenario package.
-   * Defaults to 'info' if not specified.
-   */
-  LOG_LEVEL: import_v4.z.string().toUpperCase().pipe(import_v4.z.nativeEnum(LogLevel)).optional().default("INFO" /* INFO */),
-  /**
-   * Scenario batch run ID.
-   * If not provided, a random ID will be generated.
-   */
-  SCENARIO_BATCH_RUN_ID: import_v4.z.string().optional()
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+function registerGlobal(type, instance, diag2, allowOverride) {
+  var _a;
+  if (allowOverride === void 0) {
+    allowOverride = false;
+  }
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+    version: VERSION
+  };
+  if (!allowOverride && api[type]) {
+    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
+    diag2.error(err.stack || err.message);
+    return false;
+  }
+  if (api.version !== VERSION) {
+    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
+    diag2.error(err.stack || err.message);
+    return false;
+  }
+  api[type] = instance;
+  diag2.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
+  return true;
+}
+function getGlobal(type) {
+  var _a, _b;
+  var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+  if (!globalVersion || !isCompatible(globalVersion)) {
+    return;
+  }
+  return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag2) {
+  diag2.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  if (api) {
+    delete api[type];
+  }
+}
+var major, GLOBAL_OPENTELEMETRY_API_KEY, _global;
+var init_global_utils = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/internal/global-utils.js"() {
+    "use strict";
+    init_platform();
+    init_version();
+    init_semver();
+    major = VERSION.split(".")[0];
+    GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
+    _global = _globalThis;
+  }
 });
-function getEnv() {
-  return envSchema.parse(process.env);
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+function logProxy(funcName, namespace, args) {
+  var logger2 = getGlobal("diag");
+  if (!logger2) {
+    return;
+  }
+  args.unshift(namespace);
+  return logger2[funcName].apply(logger2, __spreadArray([], __read(args), false));
 }
+var __read, __spreadArray, DiagComponentLogger;
+var init_ComponentLogger = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js"() {
+    "use strict";
+    init_global_utils();
+    __read = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    __spreadArray = function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    DiagComponentLogger = /** @class */
+    (function() {
+      function DiagComponentLogger2(props) {
+        this._namespace = props.namespace || "DiagComponentLogger";
+      }
+      DiagComponentLogger2.prototype.debug = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("debug", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.error = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("error", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.info = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("info", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.warn = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("warn", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.verbose = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("verbose", this._namespace, args);
+      };
+      return DiagComponentLogger2;
+    })();
+  }
+});
 
-// src/config/load.ts
-var import_promises = __toESM(require("fs/promises"));
-var import_node_path = __toESM(require("path"));
-var import_node_url = require("url");
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag/types.js
+var DiagLogLevel;
+var init_types = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag/types.js"() {
+    "use strict";
+    (function(DiagLogLevel2) {
+      DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+      DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+      DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+      DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+      DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+      DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+      DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+    })(DiagLogLevel || (DiagLogLevel = {}));
+  }
+});
 
-// src/domain/index.ts
-var domain_exports = {};
-__export(domain_exports, {
-  AgentAdapter: () => AgentAdapter,
-  AgentRole: () => AgentRole,
-  DEFAULT_MAX_TURNS: () => DEFAULT_MAX_TURNS,
-  DEFAULT_VERBOSE: () => DEFAULT_VERBOSE,
-  JudgeAgentAdapter: () => JudgeAgentAdapter,
-  UserSimulatorAgentAdapter: () => UserSimulatorAgentAdapter,
-  allAgentRoles: () => allAgentRoles,
-  defineConfig: () => defineConfig,
-  scenarioProjectConfigSchema: () => scenarioProjectConfigSchema
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+function createLogLevelDiagLogger(maxLevel, logger2) {
+  if (maxLevel < DiagLogLevel.NONE) {
+    maxLevel = DiagLogLevel.NONE;
+  } else if (maxLevel > DiagLogLevel.ALL) {
+    maxLevel = DiagLogLevel.ALL;
+  }
+  logger2 = logger2 || {};
+  function _filterFunc(funcName, theLevel) {
+    var theFunc = logger2[funcName];
+    if (typeof theFunc === "function" && maxLevel >= theLevel) {
+      return theFunc.bind(logger2);
+    }
+    return function() {
+    };
+  }
+  return {
+    error: _filterFunc("error", DiagLogLevel.ERROR),
+    warn: _filterFunc("warn", DiagLogLevel.WARN),
+    info: _filterFunc("info", DiagLogLevel.INFO),
+    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+  };
+}
+var init_logLevelLogger = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js"() {
+    "use strict";
+    init_types();
+  }
 });
 
-// src/domain/core/config.ts
-var import_v43 = require("zod/v4");
-
-// src/domain/core/schemas/model.schema.ts
-var import_v42 = require("zod/v4");
-
-// src/domain/core/constants.ts
-var DEFAULT_TEMPERATURE = 0;
-
-// src/domain/core/schemas/model.schema.ts
-var modelSchema = import_v42.z.object({
-  model: import_v42.z.custom((val) => Boolean(val), {
-    message: "A model is required. Configure it in scenario.config.js defaultModel or pass directly to the agent."
-  }).describe("Language model that is used by the AI SDK Core functions."),
-  temperature: import_v42.z.number().min(0).max(1).optional().describe("The temperature for the language model.").default(DEFAULT_TEMPERATURE),
-  maxTokens: import_v42.z.number().optional().describe("The maximum number of tokens to generate.")
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/api/diag.js
+var __read2, __spreadArray2, API_NAME, DiagAPI;
+var init_diag = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/api/diag.js"() {
+    "use strict";
+    init_ComponentLogger();
+    init_logLevelLogger();
+    init_types();
+    init_global_utils();
+    __read2 = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    __spreadArray2 = function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    API_NAME = "diag";
+    DiagAPI = /** @class */
+    (function() {
+      function DiagAPI2() {
+        function _logProxy(funcName) {
+          return function() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments[_i];
+            }
+            var logger2 = getGlobal("diag");
+            if (!logger2)
+              return;
+            return logger2[funcName].apply(logger2, __spreadArray2([], __read2(args), false));
+          };
+        }
+        var self = this;
+        var setLogger = function(logger2, optionsOrLogLevel) {
+          var _a, _b, _c;
+          if (optionsOrLogLevel === void 0) {
+            optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
+          }
+          if (logger2 === self) {
+            var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+            self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+            return false;
+          }
+          if (typeof optionsOrLogLevel === "number") {
+            optionsOrLogLevel = {
+              logLevel: optionsOrLogLevel
+            };
+          }
+          var oldLogger = getGlobal("diag");
+          var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger2);
+          if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+            var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+            oldLogger.warn("Current logger will be overwritten from " + stack);
+            newLogger.warn("Current logger will overwrite one already registered from " + stack);
+          }
+          return registerGlobal("diag", newLogger, self, true);
+        };
+        self.setLogger = setLogger;
+        self.disable = function() {
+          unregisterGlobal(API_NAME, self);
+        };
+        self.createComponentLogger = function(options) {
+          return new DiagComponentLogger(options);
+        };
+        self.verbose = _logProxy("verbose");
+        self.debug = _logProxy("debug");
+        self.info = _logProxy("info");
+        self.warn = _logProxy("warn");
+        self.error = _logProxy("error");
+      }
+      DiagAPI2.instance = function() {
+        if (!this._instance) {
+          this._instance = new DiagAPI2();
+        }
+        return this._instance;
+      };
+      return DiagAPI2;
+    })();
+  }
 });
 
-// src/domain/core/config.ts
-var headless = typeof process !== "undefined" ? process.env.SCENARIO_HEADLESS === "true" : false;
-var scenarioProjectConfigSchema = import_v43.z.object({
-  defaultModel: modelSchema.optional(),
-  headless: import_v43.z.boolean().optional().default(headless)
-}).strict();
-function defineConfig(config2) {
-  return config2;
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/context/context.js
+function createContextKey(description) {
+  return Symbol.for(description);
 }
-
-// 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 {
-  name;
-  role = "Agent" /* AGENT */;
-};
-var UserSimulatorAgentAdapter = class extends AgentAdapter {
-  name = "UserSimulatorAgent";
-  role = "User" /* USER */;
-};
-var JudgeAgentAdapter = class extends AgentAdapter {
-  name = "JudgeAgent";
-  role = "Judge" /* JUDGE */;
-};
-
-// src/domain/scenarios/index.ts
-var DEFAULT_MAX_TURNS = 10;
-var DEFAULT_VERBOSE = false;
-
-// src/config/load.ts
-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;
+var BaseContext, ROOT_CONTEXT;
+var init_context = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/context/context.js"() {
+    "use strict";
+    BaseContext = /** @class */
+    /* @__PURE__ */ (function() {
+      function BaseContext2(parentContext) {
+        var self = this;
+        self._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+        self.getValue = function(key) {
+          return self._currentContext.get(key);
+        };
+        self.setValue = function(key, value) {
+          var context2 = new BaseContext2(self._currentContext);
+          context2._currentContext.set(key, value);
+          return context2;
+        };
+        self.deleteValue = function(key) {
+          var context2 = new BaseContext2(self._currentContext);
+          context2._currentContext.delete(key);
+          return context2;
+        };
       }
-      throw error;
-    }
+      return BaseContext2;
+    })();
+    ROOT_CONTEXT = new BaseContext();
   }
-  return await scenarioProjectConfigSchema.parseAsync({});
-}
+});
 
-// src/utils/logger.ts
-var Logger = class _Logger {
-  constructor(context2) {
-    this.context = context2;
-  }
-  /**
-   * Creates a logger with context (e.g., class name)
-   */
-  static create(context2) {
-    return new _Logger(context2);
-  }
-  /**
-   * Returns the current log level from environment.
-   * Uses a getter for clarity and idiomatic usage.
-   */
-  get LOG_LEVEL() {
-    return getEnv().LOG_LEVEL;
-  }
-  /**
-   * Returns the index of the given log level in the LOG_LEVELS array.
-   * @param level - The log level to get the index for.
-   * @returns The index of the log level in the LOG_LEVELS array.
-   */
-  getLogLevelIndexFor(level) {
-    return LOG_LEVELS.indexOf(level);
-  }
-  /**
-   * Checks if logging should occur based on LOG_LEVEL env var
-   */
-  shouldLog(level) {
-    const currentLevelIndex = this.getLogLevelIndexFor(this.LOG_LEVEL);
-    const requestedLevelIndex = this.getLogLevelIndexFor(level);
-    return currentLevelIndex >= 0 && requestedLevelIndex <= currentLevelIndex;
-  }
-  formatMessage(message2) {
-    return this.context ? `[${this.context}] ${message2}` : message2;
-  }
-  error(message2, data) {
-    if (this.shouldLog("ERROR" /* ERROR */)) {
-      const formattedMessage = this.formatMessage(message2);
-      if (data) {
-        console.error(formattedMessage, data);
-      } else {
-        console.error(formattedMessage);
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
+var __read3, __spreadArray3, NoopContextManager;
+var init_NoopContextManager = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js"() {
+    "use strict";
+    init_context();
+    __read3 = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
       }
-    }
-  }
-  warn(message2, data) {
-    if (this.shouldLog("WARN" /* WARN */)) {
-      const formattedMessage = this.formatMessage(message2);
-      if (data) {
-        console.warn(formattedMessage, data);
-      } else {
-        console.warn(formattedMessage);
+      return ar;
+    };
+    __spreadArray3 = function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
       }
-    }
-  }
-  info(message2, data) {
-    if (this.shouldLog("INFO" /* INFO */)) {
-      const formattedMessage = this.formatMessage(message2);
-      if (data) {
-        console.info(formattedMessage, data);
-      } else {
-        console.info(formattedMessage);
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    NoopContextManager = /** @class */
+    (function() {
+      function NoopContextManager2() {
       }
-    }
+      NoopContextManager2.prototype.active = function() {
+        return ROOT_CONTEXT;
+      };
+      NoopContextManager2.prototype.with = function(_context, fn, thisArg) {
+        var args = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+          args[_i - 3] = arguments[_i];
+        }
+        return fn.call.apply(fn, __spreadArray3([thisArg], __read3(args), false));
+      };
+      NoopContextManager2.prototype.bind = function(_context, target) {
+        return target;
+      };
+      NoopContextManager2.prototype.enable = function() {
+        return this;
+      };
+      NoopContextManager2.prototype.disable = function() {
+        return this;
+      };
+      return NoopContextManager2;
+    })();
   }
-  debug(message2, data) {
-    if (this.shouldLog("DEBUG" /* DEBUG */)) {
-      const formattedMessage = this.formatMessage(message2);
-      if (data) {
-        console.log(formattedMessage, data);
-      } else {
-        console.log(formattedMessage);
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/api/context.js
+var __read4, __spreadArray4, API_NAME2, NOOP_CONTEXT_MANAGER, ContextAPI;
+var init_context2 = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/api/context.js"() {
+    "use strict";
+    init_NoopContextManager();
+    init_global_utils();
+    init_diag();
+    __read4 = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
       }
-    }
+      return ar;
+    };
+    __spreadArray4 = function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    API_NAME2 = "context";
+    NOOP_CONTEXT_MANAGER = new NoopContextManager();
+    ContextAPI = /** @class */
+    (function() {
+      function ContextAPI2() {
+      }
+      ContextAPI2.getInstance = function() {
+        if (!this._instance) {
+          this._instance = new ContextAPI2();
+        }
+        return this._instance;
+      };
+      ContextAPI2.prototype.setGlobalContextManager = function(contextManager) {
+        return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
+      };
+      ContextAPI2.prototype.active = function() {
+        return this._getContextManager().active();
+      };
+      ContextAPI2.prototype.with = function(context2, fn, thisArg) {
+        var _a;
+        var args = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+          args[_i - 3] = arguments[_i];
+        }
+        return (_a = this._getContextManager()).with.apply(_a, __spreadArray4([context2, fn, thisArg], __read4(args), false));
+      };
+      ContextAPI2.prototype.bind = function(context2, target) {
+        return this._getContextManager().bind(context2, target);
+      };
+      ContextAPI2.prototype._getContextManager = function() {
+        return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
+      };
+      ContextAPI2.prototype.disable = function() {
+        this._getContextManager().disable();
+        unregisterGlobal(API_NAME2, DiagAPI.instance());
+      };
+      return ContextAPI2;
+    })();
   }
-};
+});
 
-// src/config/get-project-config.ts
-var logger = new Logger("scenario.config");
-var configLoaded = false;
-var config = null;
-var configLoadPromise = null;
-async function loadProjectConfig() {
-  if (configLoaded) {
-    return;
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
+var TraceFlags;
+var init_trace_flags = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js"() {
+    "use strict";
+    (function(TraceFlags2) {
+      TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
+      TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
+    })(TraceFlags || (TraceFlags = {}));
   }
-  if (configLoadPromise) {
-    return configLoadPromise;
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
+var INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT;
+var init_invalid_span_constants = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js"() {
+    "use strict";
+    init_trace_flags();
+    INVALID_SPANID = "0000000000000000";
+    INVALID_TRACEID = "00000000000000000000000000000000";
+    INVALID_SPAN_CONTEXT = {
+      traceId: INVALID_TRACEID,
+      spanId: INVALID_SPANID,
+      traceFlags: TraceFlags.NONE
+    };
   }
-  configLoadPromise = (async () => {
-    try {
-      config = await loadScenarioProjectConfig();
-      logger.debug("loaded scenario project config", { config });
-    } catch (error) {
-      logger.error("error loading scenario project config", { error });
-    } finally {
-      configLoaded = true;
-    }
-  })();
-  return configLoadPromise;
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
+var NonRecordingSpan;
+var init_NonRecordingSpan = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js"() {
+    "use strict";
+    init_invalid_span_constants();
+    NonRecordingSpan = /** @class */
+    (function() {
+      function NonRecordingSpan2(_spanContext) {
+        if (_spanContext === void 0) {
+          _spanContext = INVALID_SPAN_CONTEXT;
+        }
+        this._spanContext = _spanContext;
+      }
+      NonRecordingSpan2.prototype.spanContext = function() {
+        return this._spanContext;
+      };
+      NonRecordingSpan2.prototype.setAttribute = function(_key, _value) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.setAttributes = function(_attributes) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.addEvent = function(_name, _attributes) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.addLink = function(_link) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.addLinks = function(_links) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.setStatus = function(_status) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.updateName = function(_name) {
+        return this;
+      };
+      NonRecordingSpan2.prototype.end = function(_endTime) {
+      };
+      NonRecordingSpan2.prototype.isRecording = function() {
+        return false;
+      };
+      NonRecordingSpan2.prototype.recordException = function(_exception, _time) {
+      };
+      return NonRecordingSpan2;
+    })();
+  }
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
+function getSpan(context2) {
+  return context2.getValue(SPAN_KEY) || void 0;
 }
-async function getProjectConfig() {
-  await loadProjectConfig();
-  return config;
+function getActiveSpan() {
+  return getSpan(ContextAPI.getInstance().active());
+}
+function setSpan(context2, span) {
+  return context2.setValue(SPAN_KEY, span);
+}
+function deleteSpan(context2) {
+  return context2.deleteValue(SPAN_KEY);
+}
+function setSpanContext(context2, spanContext) {
+  return setSpan(context2, new NonRecordingSpan(spanContext));
+}
+function getSpanContext(context2) {
+  var _a;
+  return (_a = getSpan(context2)) === null || _a === void 0 ? void 0 : _a.spanContext();
 }
+var SPAN_KEY;
+var init_context_utils = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/context-utils.js"() {
+    "use strict";
+    init_context();
+    init_NonRecordingSpan();
+    init_context2();
+    SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
+  }
+});
 
-// src/tracing/setup.ts
-var envConfig = getEnv();
-var observabilityHandle = (0, import_node.setupObservability)({
-  langwatch: {
-    apiKey: envConfig.LANGWATCH_API_KEY,
-    endpoint: envConfig.LANGWATCH_ENDPOINT
-  },
-  spanProcessors: [judgeSpanCollector]
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
+function isValidTraceId(traceId) {
+  return VALID_TRACEID_REGEX.test(traceId) && traceId !== INVALID_TRACEID;
+}
+function isValidSpanId(spanId) {
+  return VALID_SPANID_REGEX.test(spanId) && spanId !== INVALID_SPANID;
+}
+function isSpanContextValid(spanContext) {
+  return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+}
+function wrapSpanContext(spanContext) {
+  return new NonRecordingSpan(spanContext);
+}
+var VALID_TRACEID_REGEX, VALID_SPANID_REGEX;
+var init_spancontext_utils = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js"() {
+    "use strict";
+    init_invalid_span_constants();
+    init_NonRecordingSpan();
+    VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
+    VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
+  }
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
+function isSpanContext(spanContext) {
+  return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
+}
+var contextApi, NoopTracer;
+var init_NoopTracer = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js"() {
+    "use strict";
+    init_context2();
+    init_context_utils();
+    init_NonRecordingSpan();
+    init_spancontext_utils();
+    contextApi = ContextAPI.getInstance();
+    NoopTracer = /** @class */
+    (function() {
+      function NoopTracer2() {
+      }
+      NoopTracer2.prototype.startSpan = function(name, options, context2) {
+        if (context2 === void 0) {
+          context2 = contextApi.active();
+        }
+        var root = Boolean(options === null || options === void 0 ? void 0 : options.root);
+        if (root) {
+          return new NonRecordingSpan();
+        }
+        var parentFromContext = context2 && getSpanContext(context2);
+        if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
+          return new NonRecordingSpan(parentFromContext);
+        } else {
+          return new NonRecordingSpan();
+        }
+      };
+      NoopTracer2.prototype.startActiveSpan = function(name, arg2, arg3, arg4) {
+        var opts;
+        var ctx;
+        var fn;
+        if (arguments.length < 2) {
+          return;
+        } else if (arguments.length === 2) {
+          fn = arg2;
+        } else if (arguments.length === 3) {
+          opts = arg2;
+          fn = arg3;
+        } else {
+          opts = arg2;
+          ctx = arg3;
+          fn = arg4;
+        }
+        var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+        var span = this.startSpan(name, opts, parentContext);
+        var contextWithSpanSet = setSpan(parentContext, span);
+        return contextApi.with(contextWithSpanSet, fn, void 0, span);
+      };
+      return NoopTracer2;
+    })();
+  }
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
+var NOOP_TRACER, ProxyTracer;
+var init_ProxyTracer = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js"() {
+    "use strict";
+    init_NoopTracer();
+    NOOP_TRACER = new NoopTracer();
+    ProxyTracer = /** @class */
+    (function() {
+      function ProxyTracer2(_provider, name, version, options) {
+        this._provider = _provider;
+        this.name = name;
+        this.version = version;
+        this.options = options;
+      }
+      ProxyTracer2.prototype.startSpan = function(name, options, context2) {
+        return this._getTracer().startSpan(name, options, context2);
+      };
+      ProxyTracer2.prototype.startActiveSpan = function(_name, _options, _context, _fn) {
+        var tracer = this._getTracer();
+        return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
+      };
+      ProxyTracer2.prototype._getTracer = function() {
+        if (this._delegate) {
+          return this._delegate;
+        }
+        var tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
+        if (!tracer) {
+          return NOOP_TRACER;
+        }
+        this._delegate = tracer;
+        return this._delegate;
+      };
+      return ProxyTracer2;
+    })();
+  }
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
+var NoopTracerProvider;
+var init_NoopTracerProvider = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js"() {
+    "use strict";
+    init_NoopTracer();
+    NoopTracerProvider = /** @class */
+    (function() {
+      function NoopTracerProvider2() {
+      }
+      NoopTracerProvider2.prototype.getTracer = function(_name, _version, _options) {
+        return new NoopTracer();
+      };
+      return NoopTracerProvider2;
+    })();
+  }
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
+var NOOP_TRACER_PROVIDER, ProxyTracerProvider;
+var init_ProxyTracerProvider = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js"() {
+    "use strict";
+    init_ProxyTracer();
+    init_NoopTracerProvider();
+    NOOP_TRACER_PROVIDER = new NoopTracerProvider();
+    ProxyTracerProvider = /** @class */
+    (function() {
+      function ProxyTracerProvider2() {
+      }
+      ProxyTracerProvider2.prototype.getTracer = function(name, version, options) {
+        var _a;
+        return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
+      };
+      ProxyTracerProvider2.prototype.getDelegate = function() {
+        var _a;
+        return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
+      };
+      ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
+        this._delegate = delegate;
+      };
+      ProxyTracerProvider2.prototype.getDelegateTracer = function(name, version, options) {
+        var _a;
+        return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
+      };
+      return ProxyTracerProvider2;
+    })();
+  }
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/context-api.js
+var context;
+var init_context_api = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/context-api.js"() {
+    "use strict";
+    init_context2();
+    context = ContextAPI.getInstance();
+  }
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag-api.js
+var diag;
+var init_diag_api = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag-api.js"() {
+    "use strict";
+    init_diag();
+    diag = DiagAPI.instance();
+  }
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/api/trace.js
+var API_NAME3, TraceAPI;
+var init_trace = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/api/trace.js"() {
+    "use strict";
+    init_global_utils();
+    init_ProxyTracerProvider();
+    init_spancontext_utils();
+    init_context_utils();
+    init_diag();
+    API_NAME3 = "trace";
+    TraceAPI = /** @class */
+    (function() {
+      function TraceAPI2() {
+        this._proxyTracerProvider = new ProxyTracerProvider();
+        this.wrapSpanContext = wrapSpanContext;
+        this.isSpanContextValid = isSpanContextValid;
+        this.deleteSpan = deleteSpan;
+        this.getSpan = getSpan;
+        this.getActiveSpan = getActiveSpan;
+        this.getSpanContext = getSpanContext;
+        this.setSpan = setSpan;
+        this.setSpanContext = setSpanContext;
+      }
+      TraceAPI2.getInstance = function() {
+        if (!this._instance) {
+          this._instance = new TraceAPI2();
+        }
+        return this._instance;
+      };
+      TraceAPI2.prototype.setGlobalTracerProvider = function(provider) {
+        var success = registerGlobal(API_NAME3, this._proxyTracerProvider, DiagAPI.instance());
+        if (success) {
+          this._proxyTracerProvider.setDelegate(provider);
+        }
+        return success;
+      };
+      TraceAPI2.prototype.getTracerProvider = function() {
+        return getGlobal(API_NAME3) || this._proxyTracerProvider;
+      };
+      TraceAPI2.prototype.getTracer = function(name, version) {
+        return this.getTracerProvider().getTracer(name, version);
+      };
+      TraceAPI2.prototype.disable = function() {
+        unregisterGlobal(API_NAME3, DiagAPI.instance());
+        this._proxyTracerProvider = new ProxyTracerProvider();
+      };
+      return TraceAPI2;
+    })();
+  }
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace-api.js
+var trace;
+var init_trace_api = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace-api.js"() {
+    "use strict";
+    init_trace();
+    trace = TraceAPI.getInstance();
+  }
+});
+
+// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/index.js
+var init_esm = __esm({
+  "node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/index.js"() {
+    "use strict";
+    init_context();
+    init_trace_flags();
+    init_context_api();
+    init_diag_api();
+    init_trace_api();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentAdapter: () => AgentAdapter,
+  AgentRole: () => AgentRole,
+  DEFAULT_MAX_TURNS: () => DEFAULT_MAX_TURNS,
+  DEFAULT_VERBOSE: () => DEFAULT_VERBOSE,
+  JudgeAgentAdapter: () => JudgeAgentAdapter,
+  JudgeSpanCollector: () => JudgeSpanCollector,
+  JudgeSpanDigestFormatter: () => JudgeSpanDigestFormatter,
+  RealtimeAgentAdapter: () => RealtimeAgentAdapter,
+  ScenarioExecution: () => ScenarioExecution,
+  ScenarioExecutionState: () => ScenarioExecutionState,
+  StateChangeEventType: () => StateChangeEventType,
+  UserSimulatorAgentAdapter: () => UserSimulatorAgentAdapter,
+  agent: () => agent,
+  allAgentRoles: () => allAgentRoles,
+  default: () => index_default,
+  defineConfig: () => defineConfig,
+  fail: () => fail,
+  judge: () => judge,
+  judgeAgent: () => judgeAgent,
+  judgeSpanCollector: () => judgeSpanCollector,
+  judgeSpanDigestFormatter: () => judgeSpanDigestFormatter,
+  message: () => message,
+  proceed: () => proceed,
+  run: () => run,
+  scenario: () => scenario,
+  scenarioOnly: () => scenarioOnly,
+  scenarioProjectConfigSchema: () => scenarioProjectConfigSchema,
+  setupScenarioTracing: () => setupScenarioTracing,
+  succeed: () => succeed,
+  user: () => user,
+  userSimulatorAgent: () => userSimulatorAgent,
+  withCustomScopes: () => withCustomScopes
 });
+module.exports = __toCommonJS(index_exports);
 
 // src/agents/index.ts
 var agents_exports = {};
@@ -466,592 +1086,943 @@ var JudgeUtils = {
   }
 };
 
-// src/agents/llm-invoker.factory.ts
-var import_ai = require("ai");
-var createLLMInvoker = (logger2) => {
-  return async (params) => {
-    try {
-      return await (0, import_ai.generateText)({
-        ...params,
-        experimental_telemetry: { isEnabled: true }
-      });
-    } catch (error) {
-      logger2.error("Error generating text", { error });
-      throw error;
-    }
-  };
-};
-
-// 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/agents/judge/judge-span-digest-formatter.ts
-var import_observability2 = require("langwatch/observability");
+// src/config/env.ts
+var import_v4 = require("zod/v4");
 
-// src/agents/judge/deep-transform.ts
-function deepTransform(value, fn) {
-  const result = fn(value);
-  if (result !== value) return result;
-  if (Array.isArray(value)) {
-    return value.map((v) => deepTransform(v, fn));
-  }
-  if (value !== null && typeof value === "object") {
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-      out[k] = deepTransform(v, fn);
-    }
-    return out;
-  }
-  return value;
-}
+// src/config/log-levels.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2["ERROR"] = "ERROR";
+  LogLevel2["WARN"] = "WARN";
+  LogLevel2["INFO"] = "INFO";
+  LogLevel2["DEBUG"] = "DEBUG";
+  return LogLevel2;
+})(LogLevel || {});
+var LOG_LEVELS = Object.values(LogLevel);
 
-// src/agents/judge/string-deduplicator.ts
-var StringDeduplicator = class {
-  seen = /* @__PURE__ */ new Map();
-  threshold;
-  constructor(params) {
-    this.threshold = params.threshold;
-  }
+// src/config/env.ts
+var envSchema = import_v4.z.object({
   /**
-   * Resets seen strings for a new digest.
+   * LangWatch API key for event reporting.
+   * If not provided, events will not be sent to LangWatch.
    */
-  reset() {
-    this.seen.clear();
-  }
+  LANGWATCH_API_KEY: import_v4.z.string().optional(),
   /**
-   * Processes a string, returning duplicate marker if seen before.
-   * @param str - String to process
-   * @returns Original string or duplicate marker
+   * LangWatch endpoint URL for event reporting.
+   * Defaults to the production LangWatch endpoint.
    */
-  process(str) {
-    if (str.length < this.threshold) return str;
-    const key = this.normalize(str);
-    if (this.seen.has(key)) return "[DUPLICATE - SEE ABOVE]";
-    this.seen.set(key, true);
-    return str;
-  }
+  LANGWATCH_ENDPOINT: import_v4.z.string().url().optional().default("https://app.langwatch.ai"),
   /**
-   * Normalizes string for comparison (whitespace, case).
+   * Disables simulation report info messages when set to any truthy value.
+   * Useful for CI/CD environments or when you want cleaner output.
    */
-  normalize(str) {
-    return str.replace(/\\[nrt]/g, " ").replace(/[\n\r\t]/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
-  }
-};
+  SCENARIO_DISABLE_SIMULATION_REPORT_INFO: import_v4.z.string().optional().transform((val) => Boolean(val)),
+  /**
+   * Node environment - affects logging and behavior.
+   * Defaults to 'development' if not specified.
+   */
+  NODE_ENV: import_v4.z.enum(["development", "production", "test"]).default("development"),
+  /**
+   * Case-insensitive log level for the scenario package.
+   * Defaults to 'info' if not specified.
+   */
+  LOG_LEVEL: import_v4.z.string().toUpperCase().pipe(import_v4.z.nativeEnum(LogLevel)).optional().default("INFO" /* INFO */),
+  /**
+   * Scenario batch run ID.
+   * If not provided, a random ID will be generated.
+   */
+  SCENARIO_BATCH_RUN_ID: import_v4.z.string().optional()
+});
+function getEnv() {
+  return envSchema.parse(process.env);
+}
 
-// src/agents/judge/truncate-media.ts
-function truncateMediaUrl(str) {
-  const match = str.match(
-    /^data:((image|audio|video)\/[a-z0-9+.-]+);base64,(.+)$/i
-  );
-  if (!match) return str;
-  const [, mimeType, category, data] = match;
-  return `[${category.toUpperCase()}: ${mimeType}, ~${data.length} bytes]`;
+// src/config/load.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var import_node_url = require("url");
+
+// src/domain/index.ts
+var domain_exports = {};
+__export(domain_exports, {
+  AgentAdapter: () => AgentAdapter,
+  AgentRole: () => AgentRole,
+  DEFAULT_MAX_TURNS: () => DEFAULT_MAX_TURNS,
+  DEFAULT_VERBOSE: () => DEFAULT_VERBOSE,
+  JudgeAgentAdapter: () => JudgeAgentAdapter,
+  UserSimulatorAgentAdapter: () => UserSimulatorAgentAdapter,
+  allAgentRoles: () => allAgentRoles,
+  defineConfig: () => defineConfig,
+  scenarioProjectConfigSchema: () => scenarioProjectConfigSchema
+});
+
+// src/domain/core/config.ts
+var import_v43 = require("zod/v4");
+
+// src/domain/core/schemas/model.schema.ts
+var import_v42 = require("zod/v4");
+
+// src/domain/core/constants.ts
+var DEFAULT_TEMPERATURE = 0;
+
+// src/domain/core/schemas/model.schema.ts
+var modelSchema = import_v42.z.object({
+  model: import_v42.z.custom((val) => Boolean(val), {
+    message: "A model is required. Configure it in scenario.config.js defaultModel or pass directly to the agent."
+  }).describe("Language model that is used by the AI SDK Core functions."),
+  temperature: import_v42.z.number().min(0).max(1).optional().describe("The temperature for the language model.").default(DEFAULT_TEMPERATURE),
+  maxTokens: import_v42.z.number().optional().describe("The maximum number of tokens to generate.")
+});
+
+// src/domain/core/config.ts
+var headless = typeof process !== "undefined" ? process.env.SCENARIO_HEADLESS === "true" : false;
+var scenarioProjectConfigSchema = import_v43.z.object({
+  defaultModel: modelSchema.optional(),
+  headless: import_v43.z.boolean().optional().default(headless),
+  observability: import_v43.z.custom((val) => {
+    return val === void 0 || typeof val === "object" && val !== null && !Array.isArray(val);
+  }).optional()
+}).strict();
+function defineConfig(config2) {
+  return config2;
 }
-function truncateMediaPart(v) {
-  var _a;
-  if (v === null || typeof v !== "object" || Array.isArray(v)) return null;
-  const obj = v;
-  if (obj.type === "file" && typeof obj.mediaType === "string" && typeof obj.data === "string") {
-    const category = ((_a = obj.mediaType.split("/")[0]) == null ? void 0 : _a.toUpperCase()) ?? "FILE";
-    return {
-      ...obj,
-      data: `[${category}: ${obj.mediaType}, ~${obj.data.length} bytes]`
-    };
-  }
-  if (obj.type === "image" && typeof obj.image === "string") {
-    const imageData = obj.image;
-    const dataUrlMatch = imageData.match(
-      /^data:((image)\/[a-z0-9+.-]+);base64,(.+)$/i
-    );
-    if (dataUrlMatch) {
-      return {
-        ...obj,
-        image: `[IMAGE: ${dataUrlMatch[1]}, ~${dataUrlMatch[3].length} bytes]`
-      };
-    }
-    if (imageData.length > 1e3 && /^[A-Za-z0-9+/=]+$/.test(imageData)) {
-      return {
-        ...obj,
-        image: `[IMAGE: unknown, ~${imageData.length} bytes]`
-      };
+
+// 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 {
+  name;
+  role = "Agent" /* AGENT */;
+};
+var UserSimulatorAgentAdapter = class extends AgentAdapter {
+  name = "UserSimulatorAgent";
+  role = "User" /* USER */;
+};
+var JudgeAgentAdapter = class extends AgentAdapter {
+  name = "JudgeAgent";
+  role = "Judge" /* JUDGE */;
+};
+
+// src/domain/scenarios/index.ts
+var DEFAULT_MAX_TURNS = 10;
+var DEFAULT_VERBOSE = false;
+
+// src/config/load.ts
+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;
+  return await scenarioProjectConfigSchema.parseAsync({});
 }
 
-// src/agents/judge/judge-span-digest-formatter.ts
-var JudgeSpanDigestFormatter = class {
-  logger = new Logger("JudgeSpanDigestFormatter");
-  deduplicator = new StringDeduplicator({ threshold: 50 });
+// src/utils/logger.ts
+var Logger = class _Logger {
+  constructor(context2) {
+    this.context = context2;
+  }
   /**
-   * Formats spans into a complete digest with full content and nesting.
-   * @param spans - All spans for a thread
-   * @returns Plain text digest
+   * Creates a logger with context (e.g., class name)
    */
-  format(spans) {
-    this.deduplicator.reset();
-    this.logger.debug("format() called", {
-      spanCount: spans.length,
-      spanNames: spans.map((s) => s.name)
-    });
-    if (spans.length === 0) {
-      this.logger.debug("No spans to format");
-      return "No spans recorded.";
-    }
-    const sortedSpans = this.sortByStartTime(spans);
-    const tree = this.buildHierarchy(sortedSpans);
-    const totalDuration = this.calculateTotalDuration(sortedSpans);
-    this.logger.debug("Hierarchy built", {
-      rootCount: tree.length,
-      totalDuration
-    });
-    const lines = [
-      `Spans: ${spans.length} | Total Duration: ${this.formatDuration(
-        totalDuration
-      )}`,
-      ""
-    ];
-    let sequence = 1;
-    const rootCount = tree.length;
-    tree.forEach((node, idx) => {
-      sequence = this.renderNode(
-        node,
-        lines,
-        0,
-        sequence,
-        idx === rootCount - 1
-      );
-    });
-    const errors = this.collectErrors(spans);
-    if (errors.length > 0) {
-      lines.push("");
-      lines.push("=== ERRORS ===");
-      errors.forEach((e) => lines.push(e));
-    }
-    return lines.join("\n");
+  static create(context2) {
+    return new _Logger(context2);
   }
-  sortByStartTime(spans) {
-    return [...spans].sort((a, b) => {
-      const aTime = this.hrTimeToMs(a.startTime);
-      const bTime = this.hrTimeToMs(b.startTime);
-      return aTime - bTime;
-    });
+  /**
+   * Returns the current log level from environment.
+   * Uses a getter for clarity and idiomatic usage.
+   */
+  get LOG_LEVEL() {
+    return getEnv().LOG_LEVEL;
   }
-  buildHierarchy(spans) {
-    var _a;
-    const spanMap = /* @__PURE__ */ new Map();
-    const roots = [];
-    for (const span of spans) {
-      spanMap.set(span.spanContext().spanId, { span, children: [] });
-    }
-    for (const span of spans) {
-      const node = spanMap.get(span.spanContext().spanId);
-      const parentId = (_a = span.parentSpanContext) == null ? void 0 : _a.spanId;
-      if (parentId && spanMap.has(parentId)) {
-        spanMap.get(parentId).children.push(node);
+  /**
+   * Returns the index of the given log level in the LOG_LEVELS array.
+   * @param level - The log level to get the index for.
+   * @returns The index of the log level in the LOG_LEVELS array.
+   */
+  getLogLevelIndexFor(level) {
+    return LOG_LEVELS.indexOf(level);
+  }
+  /**
+   * Checks if logging should occur based on LOG_LEVEL env var
+   */
+  shouldLog(level) {
+    const currentLevelIndex = this.getLogLevelIndexFor(this.LOG_LEVEL);
+    const requestedLevelIndex = this.getLogLevelIndexFor(level);
+    return currentLevelIndex >= 0 && requestedLevelIndex <= currentLevelIndex;
+  }
+  formatMessage(message2) {
+    return this.context ? `[${this.context}] ${message2}` : message2;
+  }
+  error(message2, data) {
+    if (this.shouldLog("ERROR" /* ERROR */)) {
+      const formattedMessage = this.formatMessage(message2);
+      if (data) {
+        console.error(formattedMessage, data);
       } else {
-        roots.push(node);
+        console.error(formattedMessage);
       }
     }
-    return roots;
   }
-  renderNode(node, lines, depth, sequence, isLast = true) {
-    const span = node.span;
-    const duration = this.calculateSpanDuration(span);
-    const timestamp = this.formatTimestamp(span.startTime);
-    const status = this.getStatusIndicator(span);
-    const prefix = this.getTreePrefix(depth, isLast);
-    lines.push(
-      `${prefix}[${sequence}] ${new Date(timestamp).toISOString()} ${span.name} (${this.formatDuration(duration)})${status}`
-    );
-    const attrIndent = this.getAttrIndent(depth, isLast);
-    const attrs = this.cleanAttributes(span.attributes);
-    if (Object.keys(attrs).length > 0) {
-      for (const [key, value] of Object.entries(attrs)) {
-        lines.push(`${attrIndent}${key}: ${this.formatValue(value)}`);
+  warn(message2, data) {
+    if (this.shouldLog("WARN" /* WARN */)) {
+      const formattedMessage = this.formatMessage(message2);
+      if (data) {
+        console.warn(formattedMessage, data);
+      } else {
+        console.warn(formattedMessage);
       }
     }
-    if (span.events.length > 0) {
-      for (const event of span.events) {
-        lines.push(`${attrIndent}[event] ${event.name}`);
-        if (event.attributes) {
-          const eventAttrs = this.cleanAttributes(event.attributes);
-          for (const [key, value] of Object.entries(eventAttrs)) {
-            lines.push(`${attrIndent}  ${key}: ${this.formatValue(value)}`);
-          }
-        }
+  }
+  info(message2, data) {
+    if (this.shouldLog("INFO" /* INFO */)) {
+      const formattedMessage = this.formatMessage(message2);
+      if (data) {
+        console.info(formattedMessage, data);
+      } else {
+        console.info(formattedMessage);
       }
     }
-    lines.push("");
-    let nextSeq = sequence + 1;
-    const childCount = node.children.length;
-    node.children.forEach((child, idx) => {
-      nextSeq = this.renderNode(
-        child,
-        lines,
-        depth + 1,
-        nextSeq,
-        idx === childCount - 1
-      );
-    });
-    return nextSeq;
-  }
-  getTreePrefix(depth, isLast) {
-    if (depth === 0) return "";
-    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-    return "\u2502   ".repeat(depth - 1) + connector;
-  }
-  getAttrIndent(depth, isLast) {
-    if (depth === 0) return "    ";
-    const continuation = isLast ? "    " : "\u2502   ";
-    return "\u2502   ".repeat(depth - 1) + continuation + "    ";
   }
-  cleanAttributes(attrs) {
-    const cleaned = {};
-    const seen = /* @__PURE__ */ new Set();
-    const excludedKeys = [
-      import_observability2.attributes.ATTR_LANGWATCH_THREAD_ID,
-      "langwatch.scenario.id",
-      "langwatch.scenario.name"
-    ];
-    for (const [key, value] of Object.entries(attrs)) {
-      if (excludedKeys.includes(key)) {
-        continue;
-      }
-      const cleanKey = key.replace(/^(langwatch)\./, "");
-      if (!seen.has(cleanKey)) {
-        seen.add(cleanKey);
-        cleaned[cleanKey] = value;
+  debug(message2, data) {
+    if (this.shouldLog("DEBUG" /* DEBUG */)) {
+      const formattedMessage = this.formatMessage(message2);
+      if (data) {
+        console.log(formattedMessage, data);
+      } else {
+        console.log(formattedMessage);
       }
     }
-    return cleaned;
   }
-  formatValue(value) {
-    const processed = this.transformValue(value);
-    return typeof processed === "string" ? processed : JSON.stringify(processed);
+};
+
+// src/config/get-project-config.ts
+var logger = new Logger("scenario.config");
+var configLoaded = false;
+var config = null;
+var configLoadPromise = null;
+async function loadProjectConfig() {
+  if (configLoaded) {
+    return;
   }
-  transformValue(value) {
-    return deepTransform(value, (v) => {
-      const mediaPart = truncateMediaPart(v);
-      if (mediaPart) return mediaPart;
-      if (typeof v !== "string") return v;
-      return this.transformString(v);
-    });
+  if (configLoadPromise) {
+    return configLoadPromise;
   }
-  transformString(str) {
-    if (this.looksLikeJson(str)) {
-      try {
-        const processed = this.transformValue(JSON.parse(str));
-        return JSON.stringify(processed);
-      } catch {
-      }
+  configLoadPromise = (async () => {
+    try {
+      config = await loadScenarioProjectConfig();
+      logger.debug("loaded scenario project config", { config });
+    } catch (error) {
+      logger.error("error loading scenario project config", { error });
+    } finally {
+      configLoaded = true;
     }
-    const truncated = truncateMediaUrl(str);
-    if (truncated !== str) return truncated;
-    return this.deduplicator.process(str);
+  })();
+  return configLoadPromise;
+}
+async function getProjectConfig() {
+  await loadProjectConfig();
+  return config;
+}
+
+// src/agents/llm-invoker.factory.ts
+var import_ai = require("ai");
+var createLLMInvoker = (logger2) => {
+  return async (params) => {
+    try {
+      return await (0, import_ai.generateText)({
+        ...params,
+        experimental_telemetry: { isEnabled: true }
+      });
+    } catch (error) {
+      logger2.error("Error generating text", { error });
+      throw error;
+    }
+  };
+};
+
+// src/agents/utils.ts
+var toolMessageRole = "tool";
+var assistantMessageRole = "assistant";
+var userMessageRole = "user";
+var hasToolContent = (message2) => {
+  if (message2.role === toolMessageRole) return true;
+  if (!Array.isArray(message2.content)) return false;
+  return message2.content.some((part) => {
+    if (!part || typeof part !== "object") return false;
+    const partType = "type" in part ? part.type : void 0;
+    return partType === "tool-call" || partType === "tool-result";
+  });
+};
+var stringifyValue = (value) => {
+  if (typeof value === "string") return value;
+  if (value === void 0) return "undefined";
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized === void 0 ? String(value) : serialized;
+  } catch {
+    return String(value);
   }
-  looksLikeJson(str) {
-    const t = str.trim();
-    return t.startsWith("{") && t.endsWith("}") || t.startsWith("[") && t.endsWith("]");
+};
+var summarizeToolMessage = (message2) => {
+  if (message2.role === toolMessageRole && !Array.isArray(message2.content)) {
+    return `[Tool message: ${stringifyValue(message2.content)}]`;
+  }
+  if (message2.role === toolMessageRole) {
+    const toolResults = message2.content.filter((part) => part.type === "tool-result").map((part) => {
+      const contentPart = part;
+      const name = contentPart.toolName ?? "unknown tool";
+      const output = contentPart.output;
+      const value = output && typeof output === "object" && "value" in output && typeof output.value === "string" ? output.value : output ?? contentPart.result;
+      return `[Tool result from ${name}: ${stringifyValue(value)}]`;
+    });
+    return toolResults.length > 0 ? toolResults.join("\n") : null;
   }
-  hrTimeToMs(hrTime) {
-    return hrTime[0] * 1e3 + hrTime[1] / 1e6;
+  if (!Array.isArray(message2.content)) return null;
+  const toolCalls = message2.content.filter((part) => part.type === "tool-call").map((part) => {
+    const contentPart = part;
+    const name = contentPart.toolName ?? "unknown tool";
+    return `[Called tool ${name} with: ${stringifyValue(contentPart.input)}]`;
+  });
+  return toolCalls.length > 0 ? toolCalls.join("\n") : null;
+};
+var messageRoleReversal = (messages) => {
+  const roleMap = {
+    [userMessageRole]: assistantMessageRole,
+    [assistantMessageRole]: userMessageRole
+  };
+  return messages.map((message2) => {
+    if (hasToolContent(message2)) {
+      const summary = summarizeToolMessage(message2);
+      if (!summary) return null;
+      return {
+        role: userMessageRole,
+        content: summary
+      };
+    }
+    const newRole = roleMap[message2.role];
+    if (!newRole) return message2;
+    return {
+      ...message2,
+      role: newRole
+    };
+  }).filter((message2) => message2 !== null);
+};
+var criterionToParamName = (criterion) => {
+  return criterion.replace(/"/g, "").replace(/[^a-zA-Z0-9]/g, "_").replace(/ /g, "_").toLowerCase().substring(0, 70);
+};
+
+// src/agents/judge/judge-span-collector.ts
+var import_observability = require("langwatch/observability");
+var JudgeSpanCollector = class {
+  spans = [];
+  onStart() {
   }
-  calculateSpanDuration(span) {
-    return this.hrTimeToMs(span.endTime) - this.hrTimeToMs(span.startTime);
+  onEnd(span) {
+    this.spans.push(span);
   }
-  calculateTotalDuration(spans) {
-    if (spans.length === 0) return 0;
-    const first = this.hrTimeToMs(spans[0].startTime);
-    const last = Math.max(...spans.map((s) => this.hrTimeToMs(s.endTime)));
-    return last - first;
+  forceFlush() {
+    return Promise.resolve();
   }
-  formatDuration(ms) {
-    if (ms < 1e3) return `${Math.round(ms)}ms`;
-    return `${(ms / 1e3).toFixed(2)}s`;
+  shutdown() {
+    this.spans = [];
+    return Promise.resolve();
   }
-  formatTimestamp(hrTime) {
-    const ms = this.hrTimeToMs(hrTime);
-    return new Date(ms).toISOString();
+  /**
+   * Removes all spans associated with a specific thread.
+   * Call this after a scenario run completes to prevent memory growth
+   * in long-lived processes.
+   * @param threadId - The thread identifier whose spans should be cleared
+   */
+  clearSpansForThread(threadId) {
+    const threadSpanIds = new Set(
+      this.getSpansForThread(threadId).map((s) => s.spanContext().spanId)
+    );
+    this.spans = this.spans.filter(
+      (s) => !threadSpanIds.has(s.spanContext().spanId)
+    );
   }
-  getStatusIndicator(span) {
-    if (span.status.code === 2) {
-      return ` \u26A0\uFE0F ERROR: ${span.status.message ?? "unknown"}`;
+  /**
+   * Retrieves all spans associated with a specific thread.
+   * @param threadId - The thread identifier to filter spans by
+   * @returns Array of spans for the given thread
+   */
+  getSpansForThread(threadId) {
+    const spanMap = /* @__PURE__ */ new Map();
+    for (const span of this.spans) {
+      spanMap.set(span.spanContext().spanId, span);
     }
-    return "";
-  }
-  collectErrors(spans) {
-    return spans.filter((s) => s.status.code === 2).map((s) => `- ${s.name}: ${s.status.message ?? "unknown error"}`);
-  }
+    const belongsToThread = (span, visited = /* @__PURE__ */ new Set()) => {
+      const spanId = span.spanContext().spanId;
+      if (visited.has(spanId)) return false;
+      visited.add(spanId);
+      if (span.attributes[import_observability.attributes.ATTR_LANGWATCH_THREAD_ID] === threadId) {
+        return true;
+      }
+      const parentId = getParentSpanId(span);
+      if (parentId && spanMap.has(parentId)) {
+        return belongsToThread(spanMap.get(parentId), visited);
+      }
+      return false;
+    };
+    return this.spans.filter((span) => belongsToThread(span));
+  }
 };
-var judgeSpanDigestFormatter = new JudgeSpanDigestFormatter();
-
-// src/agents/judge/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>
+function getParentSpanId(span) {
+  if (span.parentSpanId) return span.parentSpanId;
+  const legacy = span.parentSpanContext;
+  return legacy == null ? void 0 : legacy.spanId;
+}
+var judgeSpanCollector = new JudgeSpanCollector();
 
-<criteria>
-${criteriaList}
-</criteria>
+// src/agents/judge/judge-span-digest-formatter.ts
+var import_observability2 = require("langwatch/observability");
 
-<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_ai2.tool)({
-    description: "Continue the test with the next step",
-    inputSchema: import_v44.z.object({})
-  });
-}
-function buildFinishTestTool(criteria) {
-  const criteriaNames = criteria.map(criterionToParamName);
-  return (0, import_ai2.tool)({
-    description: "Complete the test with a final verdict",
-    inputSchema: import_v44.z.object({
-      criteria: import_v44.z.object(
-        Object.fromEntries(
-          criteriaNames.map((name, idx) => [
-            name,
-            import_v44.z.enum(["true", "false", "inconclusive"]).describe(criteria[idx])
-          ])
-        )
-      ).strict().describe("Strict verdict for each criterion"),
-      reasoning: import_v44.z.string().describe("Explanation of what the final verdict should be"),
-      verdict: import_v44.z.enum(["success", "failure", "inconclusive"]).describe("The final verdict of the test")
-    })
-  });
+// src/agents/judge/deep-transform.ts
+function deepTransform(value, fn) {
+  const result = fn(value);
+  if (result !== value) return result;
+  if (Array.isArray(value)) {
+    return value.map((v) => deepTransform(v, fn));
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = deepTransform(v, fn);
+    }
+    return out;
+  }
+  return value;
 }
-var JudgeAgent = class extends JudgeAgentAdapter {
-  constructor(cfg) {
-    super();
-    this.cfg = cfg;
-    this.criteria = cfg.criteria;
-    this.spanCollector = cfg.spanCollector ?? judgeSpanCollector;
+
+// src/agents/judge/string-deduplicator.ts
+var StringDeduplicator = class {
+  seen = /* @__PURE__ */ new Map();
+  threshold;
+  constructor(params) {
+    this.threshold = params.threshold;
   }
-  logger = new Logger("JudgeAgent");
-  spanCollector;
-  role = "Judge" /* JUDGE */;
-  criteria;
   /**
-   * LLM invocation function. Can be overridden to customize LLM behavior.
+   * Resets seen strings for a new digest.
    */
-  invokeLLM = createLLMInvoker(this.logger);
-  async call(input) {
-    var _a, _b, _c;
-    this.logger.debug("call() invoked", {
-      threadId: input.threadId,
-      currentTurn: input.scenarioState.currentTurn,
-      maxTurns: input.scenarioConfig.maxTurns,
-      judgmentRequest: input.judgmentRequest
-    });
-    const digest = this.getOpenTelemetryTracesDigest(input.threadId);
-    this.logger.debug("OpenTelemetry traces built", { digest });
-    const transcript = JudgeUtils.buildTranscriptFromMessages(input.messages);
-    const contentForJudge = `
-    <transcript>
-    ${transcript}
-    </transcript>
-    <opentelemetry_traces>
-    ${digest}
-    </opentelemetry_traces>
-    `;
-    const cfg = this.cfg;
-    const systemPrompt = cfg.systemPrompt ?? buildSystemPrompt(cfg.criteria, input.scenarioConfig.description);
-    const messages = [
-      { role: "system", content: systemPrompt },
-      { role: "user", content: contentForJudge }
-    ];
-    const isLastMessage = input.scenarioState.currentTurn === input.scenarioConfig.maxTurns;
-    const projectConfig = await getProjectConfig();
-    const mergedConfig = modelSchema.parse({
-      ...projectConfig == null ? void 0 : projectConfig.defaultModel,
-      ...cfg
-    });
-    const tools = {
-      continue_test: buildContinueTestTool(),
-      finish_test: buildFinishTestTool(cfg.criteria)
+  reset() {
+    this.seen.clear();
+  }
+  /**
+   * Processes a string, returning duplicate marker if seen before.
+   * @param str - String to process
+   * @returns Original string or duplicate marker
+   */
+  process(str) {
+    if (str.length < this.threshold) return str;
+    const key = this.normalize(str);
+    if (this.seen.has(key)) return "[DUPLICATE - SEE ABOVE]";
+    this.seen.set(key, true);
+    return str;
+  }
+  /**
+   * Normalizes string for comparison (whitespace, case).
+   */
+  normalize(str) {
+    return str.replace(/\\[nrt]/g, " ").replace(/[\n\r\t]/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
+  }
+};
+
+// src/agents/judge/truncate-media.ts
+function truncateMediaUrl(str) {
+  const match = str.match(
+    /^data:((image|audio|video)\/[a-z0-9+.-]+);base64,(.+)$/i
+  );
+  if (!match) return str;
+  const [, mimeType, category, data] = match;
+  return `[${category.toUpperCase()}: ${mimeType}, ~${data.length} bytes]`;
+}
+function truncateMediaPart(v) {
+  var _a;
+  if (v === null || typeof v !== "object" || Array.isArray(v)) return null;
+  const obj = v;
+  if (obj.type === "file" && typeof obj.mediaType === "string" && typeof obj.data === "string") {
+    const category = ((_a = obj.mediaType.split("/")[0]) == null ? void 0 : _a.toUpperCase()) ?? "FILE";
+    return {
+      ...obj,
+      data: `[${category}: ${obj.mediaType}, ~${obj.data.length} bytes]`
     };
-    const enforceJudgement = input.judgmentRequest;
-    const hasCriteria = cfg.criteria.length && cfg.criteria.length > 0;
-    if (enforceJudgement && !hasCriteria) {
+  }
+  if (obj.type === "image" && typeof obj.image === "string") {
+    const imageData = obj.image;
+    const dataUrlMatch = imageData.match(
+      /^data:((image)\/[a-z0-9+.-]+);base64,(.+)$/i
+    );
+    if (dataUrlMatch) {
       return {
-        success: false,
-        reasoning: "JudgeAgent: No criteria was provided to be judged against",
-        metCriteria: [],
-        unmetCriteria: []
+        ...obj,
+        image: `[IMAGE: ${dataUrlMatch[1]}, ~${dataUrlMatch[3].length} bytes]`
       };
     }
-    const toolChoice = (isLastMessage || enforceJudgement) && hasCriteria ? { type: "tool", toolName: "finish_test" } : "required";
-    this.logger.debug("Calling LLM", {
-      model: mergedConfig.model,
-      toolChoice,
-      isLastMessage,
-      enforceJudgement
-    });
-    const completion = await this.invokeLLM({
-      model: mergedConfig.model,
-      messages,
-      temperature: mergedConfig.temperature ?? 0,
-      maxOutputTokens: mergedConfig.maxTokens,
-      tools,
-      toolChoice
-    });
-    this.logger.debug("LLM response received", {
-      toolCallCount: ((_a = completion.toolCalls) == null ? void 0 : _a.length) ?? 0,
-      toolCalls: (_b = completion.toolCalls) == null ? void 0 : _b.map((tc) => ({
-        toolName: tc.toolName,
-        args: tc.input
-      }))
-    });
-    let args;
-    if ((_c = completion.toolCalls) == null ? void 0 : _c.length) {
-      const toolCall = completion.toolCalls[0];
-      switch (toolCall.toolName) {
-        case "finish_test": {
-          args = toolCall.input;
-          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"
-          );
-          const result = {
-            success: verdict === "success",
-            reasoning,
-            metCriteria,
-            unmetCriteria
-          };
-          this.logger.debug("finish_test result", result);
-          return result;
-        }
-        case "continue_test":
-          this.logger.debug("continue_test - proceeding to next turn");
-          return null;
-        default:
-          return {
-            success: false,
-            reasoning: `JudgeAgent: Unknown tool call: ${toolCall.toolName}`,
-            metCriteria: [],
-            unmetCriteria: cfg.criteria
-          };
-      }
+    if (imageData.length > 1e3 && /^[A-Za-z0-9+/=]+$/.test(imageData)) {
+      return {
+        ...obj,
+        image: `[IMAGE: unknown, ~${imageData.length} bytes]`
+      };
     }
-    return {
-      success: false,
-      reasoning: `JudgeAgent: No tool call found in LLM output`,
-      metCriteria: [],
-      unmetCriteria: cfg.criteria
-    };
-  }
-  getOpenTelemetryTracesDigest(threadId) {
-    const spans = this.spanCollector.getSpansForThread(threadId);
-    const digest = judgeSpanDigestFormatter.format(spans);
-    return digest;
   }
-};
-var judgeAgent = (cfg) => {
-  return new JudgeAgent(cfg);
-};
+  return null;
+}
 
-// src/agents/user-simulator-agent.ts
-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.
+// src/agents/judge/judge-span-digest-formatter.ts
+var JudgeSpanDigestFormatter = class {
+  logger = new Logger("JudgeSpanDigestFormatter");
+  deduplicator = new StringDeduplicator({ threshold: 50 });
+  /**
+   * Formats spans into a complete digest with full content and nesting.
+   * @param spans - All spans for a thread
+   * @returns Plain text digest
+   */
+  format(spans) {
+    this.deduplicator.reset();
+    this.logger.debug("format() called", {
+      spanCount: spans.length,
+      spanNames: spans.map((s) => s.name)
+    });
+    if (spans.length === 0) {
+      this.logger.debug("No spans to format");
+      return "No spans recorded.";
+    }
+    const sortedSpans = this.sortByStartTime(spans);
+    const tree = this.buildHierarchy(sortedSpans);
+    const totalDuration = this.calculateTotalDuration(sortedSpans);
+    this.logger.debug("Hierarchy built", {
+      rootCount: tree.length,
+      totalDuration
+    });
+    const lines = [
+      `Spans: ${spans.length} | Total Duration: ${this.formatDuration(
+        totalDuration
+      )}`,
+      ""
+    ];
+    let sequence = 1;
+    const rootCount = tree.length;
+    tree.forEach((node, idx) => {
+      sequence = this.renderNode(
+        node,
+        lines,
+        0,
+        sequence,
+        idx === rootCount - 1
+      );
+    });
+    const errors = this.collectErrors(spans);
+    if (errors.length > 0) {
+      lines.push("");
+      lines.push("=== ERRORS ===");
+      errors.forEach((e) => lines.push(e));
+    }
+    return lines.join("\n");
+  }
+  sortByStartTime(spans) {
+    return [...spans].sort((a, b) => {
+      const aTime = this.hrTimeToMs(a.startTime);
+      const bTime = this.hrTimeToMs(b.startTime);
+      return aTime - bTime;
+    });
+  }
+  buildHierarchy(spans) {
+    const spanMap = /* @__PURE__ */ new Map();
+    const roots = [];
+    for (const span of spans) {
+      spanMap.set(span.spanContext().spanId, { span, children: [] });
+    }
+    for (const span of spans) {
+      const node = spanMap.get(span.spanContext().spanId);
+      const parentId = getParentSpanId2(span);
+      if (parentId && spanMap.has(parentId)) {
+        spanMap.get(parentId).children.push(node);
+      } else {
+        roots.push(node);
+      }
+    }
+    return roots;
+  }
+  renderNode(node, lines, depth, sequence, isLast = true) {
+    const span = node.span;
+    const duration = this.calculateSpanDuration(span);
+    const timestamp = this.formatTimestamp(span.startTime);
+    const status = this.getStatusIndicator(span);
+    const prefix = this.getTreePrefix(depth, isLast);
+    lines.push(
+      `${prefix}[${sequence}] ${new Date(timestamp).toISOString()} ${span.name} (${this.formatDuration(duration)})${status}`
+    );
+    const attrIndent = this.getAttrIndent(depth, isLast);
+    const attrs = this.cleanAttributes(span.attributes);
+    if (Object.keys(attrs).length > 0) {
+      for (const [key, value] of Object.entries(attrs)) {
+        lines.push(`${attrIndent}${key}: ${this.formatValue(value)}`);
+      }
+    }
+    if (span.events.length > 0) {
+      for (const event of span.events) {
+        lines.push(`${attrIndent}[event] ${event.name}`);
+        if (event.attributes) {
+          const eventAttrs = this.cleanAttributes(event.attributes);
+          for (const [key, value] of Object.entries(eventAttrs)) {
+            lines.push(`${attrIndent}  ${key}: ${this.formatValue(value)}`);
+          }
+        }
+      }
+    }
+    lines.push("");
+    let nextSeq = sequence + 1;
+    const childCount = node.children.length;
+    node.children.forEach((child, idx) => {
+      nextSeq = this.renderNode(
+        child,
+        lines,
+        depth + 1,
+        nextSeq,
+        idx === childCount - 1
+      );
+    });
+    return nextSeq;
+  }
+  getTreePrefix(depth, isLast) {
+    if (depth === 0) return "";
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    return "\u2502   ".repeat(depth - 1) + connector;
+  }
+  getAttrIndent(depth, isLast) {
+    if (depth === 0) return "    ";
+    const continuation = isLast ? "    " : "\u2502   ";
+    return "\u2502   ".repeat(depth - 1) + continuation + "    ";
+  }
+  cleanAttributes(attrs) {
+    const cleaned = {};
+    const seen = /* @__PURE__ */ new Set();
+    const excludedKeys = [
+      import_observability2.attributes.ATTR_LANGWATCH_THREAD_ID,
+      "langwatch.scenario.id",
+      "langwatch.scenario.name"
+    ];
+    for (const [key, value] of Object.entries(attrs)) {
+      if (excludedKeys.includes(key)) {
+        continue;
+      }
+      const cleanKey = key.replace(/^(langwatch)\./, "");
+      if (!seen.has(cleanKey)) {
+        seen.add(cleanKey);
+        cleaned[cleanKey] = value;
+      }
+    }
+    return cleaned;
+  }
+  formatValue(value) {
+    const processed = this.transformValue(value);
+    return typeof processed === "string" ? processed : JSON.stringify(processed);
+  }
+  transformValue(value) {
+    return deepTransform(value, (v) => {
+      const mediaPart = truncateMediaPart(v);
+      if (mediaPart) return mediaPart;
+      if (typeof v !== "string") return v;
+      return this.transformString(v);
+    });
+  }
+  transformString(str) {
+    if (this.looksLikeJson(str)) {
+      try {
+        const processed = this.transformValue(JSON.parse(str));
+        return JSON.stringify(processed);
+      } catch {
+      }
+    }
+    const truncated = truncateMediaUrl(str);
+    if (truncated !== str) return truncated;
+    return this.deduplicator.process(str);
+  }
+  looksLikeJson(str) {
+    const t = str.trim();
+    return t.startsWith("{") && t.endsWith("}") || t.startsWith("[") && t.endsWith("]");
+  }
+  hrTimeToMs(hrTime) {
+    return hrTime[0] * 1e3 + hrTime[1] / 1e6;
+  }
+  calculateSpanDuration(span) {
+    return this.hrTimeToMs(span.endTime) - this.hrTimeToMs(span.startTime);
+  }
+  calculateTotalDuration(spans) {
+    if (spans.length === 0) return 0;
+    const first = this.hrTimeToMs(spans[0].startTime);
+    const last = Math.max(...spans.map((s) => this.hrTimeToMs(s.endTime)));
+    return last - first;
+  }
+  formatDuration(ms) {
+    if (ms < 1e3) return `${Math.round(ms)}ms`;
+    return `${(ms / 1e3).toFixed(2)}s`;
+  }
+  formatTimestamp(hrTime) {
+    const ms = this.hrTimeToMs(hrTime);
+    return new Date(ms).toISOString();
+  }
+  getStatusIndicator(span) {
+    if (span.status.code === 2) {
+      return ` \u26A0\uFE0F ERROR: ${span.status.message ?? "unknown"}`;
+    }
+    return "";
+  }
+  collectErrors(spans) {
+    return spans.filter((s) => s.status.code === 2).map((s) => `- ${s.name}: ${s.status.message ?? "unknown error"}`);
+  }
+};
+function getParentSpanId2(span) {
+  if (span.parentSpanId) return span.parentSpanId;
+  const legacy = span.parentSpanContext;
+  return legacy == null ? void 0 : legacy.spanId;
+}
+var judgeSpanDigestFormatter = new JudgeSpanDigestFormatter();
+
+// src/agents/judge/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 (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.
+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>
-- DO NOT carry over any requests yourself, YOU ARE NOT the assistant today, you are the user
+- 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();
 }
-var UserSimulatorAgent = class extends UserSimulatorAgentAdapter {
+function buildContinueTestTool() {
+  return (0, import_ai2.tool)({
+    description: "Continue the test with the next step",
+    inputSchema: import_v44.z.object({})
+  });
+}
+function buildFinishTestTool(criteria) {
+  const criteriaNames = criteria.map(criterionToParamName);
+  return (0, import_ai2.tool)({
+    description: "Complete the test with a final verdict",
+    inputSchema: import_v44.z.object({
+      criteria: import_v44.z.object(
+        Object.fromEntries(
+          criteriaNames.map((name, idx) => [
+            name,
+            import_v44.z.enum(["true", "false", "inconclusive"]).describe(criteria[idx])
+          ])
+        )
+      ).strict().describe("Strict verdict for each criterion"),
+      reasoning: import_v44.z.string().describe("Explanation of what the final verdict should be"),
+      verdict: import_v44.z.enum(["success", "failure", "inconclusive"]).describe("The final verdict of the test")
+    })
+  });
+}
+var JudgeAgent = class extends JudgeAgentAdapter {
   constructor(cfg) {
     super();
     this.cfg = cfg;
+    this.criteria = cfg.criteria ?? [];
+    this.spanCollector = cfg.spanCollector ?? judgeSpanCollector;
   }
-  logger = new Logger(this.constructor.name);
+  logger = new Logger("JudgeAgent");
+  spanCollector;
+  role = "Judge" /* JUDGE */;
+  criteria;
+  /**
+   * LLM invocation function. Can be overridden to customize LLM behavior.
+   */
+  invokeLLM = createLLMInvoker(this.logger);
+  async call(input) {
+    var _a, _b, _c, _d;
+    const criteria = ((_a = input.judgmentRequest) == null ? void 0 : _a.criteria) ?? this.criteria;
+    this.logger.debug("call() invoked", {
+      threadId: input.threadId,
+      currentTurn: input.scenarioState.currentTurn,
+      maxTurns: input.scenarioConfig.maxTurns,
+      judgmentRequest: input.judgmentRequest
+    });
+    const digest = this.getOpenTelemetryTracesDigest(input.threadId);
+    this.logger.debug("OpenTelemetry traces built", { digest });
+    const transcript = JudgeUtils.buildTranscriptFromMessages(input.messages);
+    const contentForJudge = `
+    <transcript>
+    ${transcript}
+    </transcript>
+    <opentelemetry_traces>
+    ${digest}
+    </opentelemetry_traces>
+    `;
+    const cfg = this.cfg;
+    const systemPrompt = cfg.systemPrompt ?? buildSystemPrompt(criteria, input.scenarioConfig.description);
+    const messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: contentForJudge }
+    ];
+    const isLastMessage = input.scenarioState.currentTurn === input.scenarioConfig.maxTurns;
+    const projectConfig = await getProjectConfig();
+    const mergedConfig = modelSchema.parse({
+      ...projectConfig == null ? void 0 : projectConfig.defaultModel,
+      ...cfg
+    });
+    const tools = {
+      continue_test: buildContinueTestTool(),
+      finish_test: buildFinishTestTool(criteria)
+    };
+    const enforceJudgement = input.judgmentRequest != null;
+    const hasCriteria = criteria.length && criteria.length > 0;
+    if (enforceJudgement && !hasCriteria) {
+      return {
+        success: false,
+        reasoning: "JudgeAgent: No criteria was provided to be judged against",
+        metCriteria: [],
+        unmetCriteria: []
+      };
+    }
+    const toolChoice = (isLastMessage || enforceJudgement) && hasCriteria ? { type: "tool", toolName: "finish_test" } : "required";
+    this.logger.debug("Calling LLM", {
+      model: mergedConfig.model,
+      toolChoice,
+      isLastMessage,
+      enforceJudgement
+    });
+    const completion = await this.invokeLLM({
+      model: mergedConfig.model,
+      messages,
+      temperature: mergedConfig.temperature ?? 0,
+      maxOutputTokens: mergedConfig.maxTokens,
+      tools,
+      toolChoice
+    });
+    this.logger.debug("LLM response received", {
+      toolCallCount: ((_b = completion.toolCalls) == null ? void 0 : _b.length) ?? 0,
+      toolCalls: (_c = completion.toolCalls) == null ? void 0 : _c.map((tc) => ({
+        toolName: tc.toolName,
+        args: tc.input
+      }))
+    });
+    let args;
+    if ((_d = completion.toolCalls) == null ? void 0 : _d.length) {
+      const toolCall = completion.toolCalls[0];
+      switch (toolCall.toolName) {
+        case "finish_test": {
+          args = toolCall.input;
+          const verdict = args.verdict || "inconclusive";
+          const reasoning = args.reasoning || "No reasoning provided";
+          const criteriaArgs = args.criteria || {};
+          const criteriaValues = Object.values(criteriaArgs);
+          const metCriteria = criteria.filter(
+            (_, i) => criteriaValues[i] === "true"
+          );
+          const unmetCriteria = criteria.filter(
+            (_, i) => criteriaValues[i] !== "true"
+          );
+          const result = {
+            success: verdict === "success",
+            reasoning,
+            metCriteria,
+            unmetCriteria
+          };
+          this.logger.debug("finish_test result", result);
+          return result;
+        }
+        case "continue_test":
+          this.logger.debug("continue_test - proceeding to next turn");
+          return null;
+        default:
+          return {
+            success: false,
+            reasoning: `JudgeAgent: Unknown tool call: ${toolCall.toolName}`,
+            metCriteria: [],
+            unmetCriteria: criteria
+          };
+      }
+    }
+    return {
+      success: false,
+      reasoning: `JudgeAgent: No tool call found in LLM output`,
+      metCriteria: [],
+      unmetCriteria: criteria
+    };
+  }
+  getOpenTelemetryTracesDigest(threadId) {
+    const spans = this.spanCollector.getSpansForThread(threadId);
+    const digest = judgeSpanDigestFormatter.format(spans);
+    return digest;
+  }
+};
+var judgeAgent = (cfg) => {
+  return new JudgeAgent(cfg ?? {});
+};
+
+// src/agents/user-simulator-agent.ts
+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 = class extends UserSimulatorAgentAdapter {
+  constructor(cfg) {
+    super();
+    this.cfg = cfg;
+  }
+  logger = new Logger(this.constructor.name);
   /**
    * LLM invocation function. Can be overridden to customize LLM behavior.
    */
@@ -1379,813 +2350,69 @@ var RealtimeAgentAdapter = class extends AgentAdapter {
     this.audioEvents.emit("audioResponse", response);
     return this.responseFormatter.formatInitialResponse(response);
   }
-  /**
-   * Handles audio input from the user
-   */
-  async handleAudioInput(audioData) {
-    const sessionWithTransport = this.session;
-    const transport = sessionWithTransport.transport;
-    if (!transport) {
-      throw new Error("Realtime transport not available");
-    }
-    transport.sendEvent({
-      type: "input_audio_buffer.append",
-      audio: audioData
-    });
-    transport.sendEvent({
-      type: "input_audio_buffer.commit"
-    });
-    transport.sendEvent({
-      type: "response.create"
-    });
-    const timeout = this.config.responseTimeout ?? 6e4;
-    const response = await this.eventHandler.waitForResponse(timeout);
-    this.audioEvents.emit("audioResponse", response);
-    return this.responseFormatter.formatAudioResponse(response);
-  }
-  /**
-   * Handles text input from the user
-   */
-  async handleTextInput(text) {
-    this.session.sendMessage(text);
-    const timeout = this.config.responseTimeout ?? 3e4;
-    const response = await this.eventHandler.waitForResponse(timeout);
-    this.audioEvents.emit("audioResponse", response);
-    return this.responseFormatter.formatTextResponse(response.transcript);
-  }
-  /**
-   * Subscribe to audio response events
-   *
-   * @param callback - Function called when an audio response completes
-   */
-  onAudioResponse(callback) {
-    this.audioEvents.on("audioResponse", callback);
-  }
-  /**
-   * Remove audio response listener
-   *
-   * @param callback - The callback function to remove
-   */
-  offAudioResponse(callback) {
-    this.audioEvents.off("audioResponse", callback);
-  }
-};
-
-// src/execution/index.ts
-var execution_exports = {};
-__export(execution_exports, {
-  ScenarioExecution: () => ScenarioExecution,
-  ScenarioExecutionState: () => ScenarioExecutionState,
-  StateChangeEventType: () => StateChangeEventType
-});
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
-var _globalThis = typeof globalThis === "object" ? globalThis : global;
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/version.js
-var VERSION = "1.9.0";
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/internal/semver.js
-var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
-function _makeCompatibilityCheck(ownVersion) {
-  var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
-  var rejectedVersions = /* @__PURE__ */ new Set();
-  var myVersionMatch = ownVersion.match(re);
-  if (!myVersionMatch) {
-    return function() {
-      return false;
-    };
-  }
-  var ownVersionParsed = {
-    major: +myVersionMatch[1],
-    minor: +myVersionMatch[2],
-    patch: +myVersionMatch[3],
-    prerelease: myVersionMatch[4]
-  };
-  if (ownVersionParsed.prerelease != null) {
-    return function isExactmatch(globalVersion) {
-      return globalVersion === ownVersion;
-    };
-  }
-  function _reject(v) {
-    rejectedVersions.add(v);
-    return false;
-  }
-  function _accept(v) {
-    acceptedVersions.add(v);
-    return true;
-  }
-  return function isCompatible2(globalVersion) {
-    if (acceptedVersions.has(globalVersion)) {
-      return true;
-    }
-    if (rejectedVersions.has(globalVersion)) {
-      return false;
-    }
-    var globalVersionMatch = globalVersion.match(re);
-    if (!globalVersionMatch) {
-      return _reject(globalVersion);
-    }
-    var globalVersionParsed = {
-      major: +globalVersionMatch[1],
-      minor: +globalVersionMatch[2],
-      patch: +globalVersionMatch[3],
-      prerelease: globalVersionMatch[4]
-    };
-    if (globalVersionParsed.prerelease != null) {
-      return _reject(globalVersion);
-    }
-    if (ownVersionParsed.major !== globalVersionParsed.major) {
-      return _reject(globalVersion);
-    }
-    if (ownVersionParsed.major === 0) {
-      if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
-        return _accept(globalVersion);
-      }
-      return _reject(globalVersion);
-    }
-    if (ownVersionParsed.minor <= globalVersionParsed.minor) {
-      return _accept(globalVersion);
-    }
-    return _reject(globalVersion);
-  };
-}
-var isCompatible = _makeCompatibilityCheck(VERSION);
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
-var major = VERSION.split(".")[0];
-var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
-var _global = _globalThis;
-function registerGlobal(type, instance, diag, allowOverride) {
-  var _a;
-  if (allowOverride === void 0) {
-    allowOverride = false;
-  }
-  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
-    version: VERSION
-  };
-  if (!allowOverride && api[type]) {
-    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
-    diag.error(err.stack || err.message);
-    return false;
-  }
-  if (api.version !== VERSION) {
-    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
-    diag.error(err.stack || err.message);
-    return false;
-  }
-  api[type] = instance;
-  diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
-  return true;
-}
-function getGlobal(type) {
-  var _a, _b;
-  var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
-  if (!globalVersion || !isCompatible(globalVersion)) {
-    return;
-  }
-  return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
-}
-function unregisterGlobal(type, diag) {
-  diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
-  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
-  if (api) {
-    delete api[type];
-  }
-}
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
-var __read = function(o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o), r, ar = [], e;
-  try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  } catch (error) {
-    e = { error };
-  } finally {
-    try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
-    } finally {
-      if (e) throw e.error;
-    }
-  }
-  return ar;
-};
-var __spreadArray = function(to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
-    }
-  }
-  return to.concat(ar || Array.prototype.slice.call(from));
-};
-var DiagComponentLogger = (
-  /** @class */
-  (function() {
-    function DiagComponentLogger2(props) {
-      this._namespace = props.namespace || "DiagComponentLogger";
-    }
-    DiagComponentLogger2.prototype.debug = function() {
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-      }
-      return logProxy("debug", this._namespace, args);
-    };
-    DiagComponentLogger2.prototype.error = function() {
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-      }
-      return logProxy("error", this._namespace, args);
-    };
-    DiagComponentLogger2.prototype.info = function() {
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-      }
-      return logProxy("info", this._namespace, args);
-    };
-    DiagComponentLogger2.prototype.warn = function() {
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-      }
-      return logProxy("warn", this._namespace, args);
-    };
-    DiagComponentLogger2.prototype.verbose = function() {
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-      }
-      return logProxy("verbose", this._namespace, args);
-    };
-    return DiagComponentLogger2;
-  })()
-);
-function logProxy(funcName, namespace, args) {
-  var logger2 = getGlobal("diag");
-  if (!logger2) {
-    return;
-  }
-  args.unshift(namespace);
-  return logger2[funcName].apply(logger2, __spreadArray([], __read(args), false));
-}
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag/types.js
-var DiagLogLevel;
-(function(DiagLogLevel2) {
-  DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
-  DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
-  DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
-  DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
-  DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
-  DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
-  DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
-})(DiagLogLevel || (DiagLogLevel = {}));
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
-function createLogLevelDiagLogger(maxLevel, logger2) {
-  if (maxLevel < DiagLogLevel.NONE) {
-    maxLevel = DiagLogLevel.NONE;
-  } else if (maxLevel > DiagLogLevel.ALL) {
-    maxLevel = DiagLogLevel.ALL;
-  }
-  logger2 = logger2 || {};
-  function _filterFunc(funcName, theLevel) {
-    var theFunc = logger2[funcName];
-    if (typeof theFunc === "function" && maxLevel >= theLevel) {
-      return theFunc.bind(logger2);
-    }
-    return function() {
-    };
-  }
-  return {
-    error: _filterFunc("error", DiagLogLevel.ERROR),
-    warn: _filterFunc("warn", DiagLogLevel.WARN),
-    info: _filterFunc("info", DiagLogLevel.INFO),
-    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
-    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
-  };
-}
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/api/diag.js
-var __read2 = function(o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o), r, ar = [], e;
-  try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  } catch (error) {
-    e = { error };
-  } finally {
-    try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
-    } finally {
-      if (e) throw e.error;
-    }
-  }
-  return ar;
-};
-var __spreadArray2 = function(to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
-    }
-  }
-  return to.concat(ar || Array.prototype.slice.call(from));
-};
-var API_NAME = "diag";
-var DiagAPI = (
-  /** @class */
-  (function() {
-    function DiagAPI2() {
-      function _logProxy(funcName) {
-        return function() {
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-          }
-          var logger2 = getGlobal("diag");
-          if (!logger2)
-            return;
-          return logger2[funcName].apply(logger2, __spreadArray2([], __read2(args), false));
-        };
-      }
-      var self = this;
-      var setLogger = function(logger2, optionsOrLogLevel) {
-        var _a, _b, _c;
-        if (optionsOrLogLevel === void 0) {
-          optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
-        }
-        if (logger2 === self) {
-          var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
-          self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
-          return false;
-        }
-        if (typeof optionsOrLogLevel === "number") {
-          optionsOrLogLevel = {
-            logLevel: optionsOrLogLevel
-          };
-        }
-        var oldLogger = getGlobal("diag");
-        var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger2);
-        if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
-          var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
-          oldLogger.warn("Current logger will be overwritten from " + stack);
-          newLogger.warn("Current logger will overwrite one already registered from " + stack);
-        }
-        return registerGlobal("diag", newLogger, self, true);
-      };
-      self.setLogger = setLogger;
-      self.disable = function() {
-        unregisterGlobal(API_NAME, self);
-      };
-      self.createComponentLogger = function(options) {
-        return new DiagComponentLogger(options);
-      };
-      self.verbose = _logProxy("verbose");
-      self.debug = _logProxy("debug");
-      self.info = _logProxy("info");
-      self.warn = _logProxy("warn");
-      self.error = _logProxy("error");
-    }
-    DiagAPI2.instance = function() {
-      if (!this._instance) {
-        this._instance = new DiagAPI2();
-      }
-      return this._instance;
-    };
-    return DiagAPI2;
-  })()
-);
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/context/context.js
-function createContextKey(description) {
-  return Symbol.for(description);
-}
-var BaseContext = (
-  /** @class */
-  /* @__PURE__ */ (function() {
-    function BaseContext2(parentContext) {
-      var self = this;
-      self._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
-      self.getValue = function(key) {
-        return self._currentContext.get(key);
-      };
-      self.setValue = function(key, value) {
-        var context2 = new BaseContext2(self._currentContext);
-        context2._currentContext.set(key, value);
-        return context2;
-      };
-      self.deleteValue = function(key) {
-        var context2 = new BaseContext2(self._currentContext);
-        context2._currentContext.delete(key);
-        return context2;
-      };
-    }
-    return BaseContext2;
-  })()
-);
-var ROOT_CONTEXT = new BaseContext();
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
-var __read3 = function(o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o), r, ar = [], e;
-  try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  } catch (error) {
-    e = { error };
-  } finally {
-    try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
-    } finally {
-      if (e) throw e.error;
-    }
-  }
-  return ar;
-};
-var __spreadArray3 = function(to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
-    }
-  }
-  return to.concat(ar || Array.prototype.slice.call(from));
-};
-var NoopContextManager = (
-  /** @class */
-  (function() {
-    function NoopContextManager2() {
-    }
-    NoopContextManager2.prototype.active = function() {
-      return ROOT_CONTEXT;
-    };
-    NoopContextManager2.prototype.with = function(_context, fn, thisArg) {
-      var args = [];
-      for (var _i = 3; _i < arguments.length; _i++) {
-        args[_i - 3] = arguments[_i];
-      }
-      return fn.call.apply(fn, __spreadArray3([thisArg], __read3(args), false));
-    };
-    NoopContextManager2.prototype.bind = function(_context, target) {
-      return target;
-    };
-    NoopContextManager2.prototype.enable = function() {
-      return this;
-    };
-    NoopContextManager2.prototype.disable = function() {
-      return this;
-    };
-    return NoopContextManager2;
-  })()
-);
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/api/context.js
-var __read4 = function(o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o), r, ar = [], e;
-  try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  } catch (error) {
-    e = { error };
-  } finally {
-    try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
-    } finally {
-      if (e) throw e.error;
-    }
-  }
-  return ar;
-};
-var __spreadArray4 = function(to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
-    }
-  }
-  return to.concat(ar || Array.prototype.slice.call(from));
-};
-var API_NAME2 = "context";
-var NOOP_CONTEXT_MANAGER = new NoopContextManager();
-var ContextAPI = (
-  /** @class */
-  (function() {
-    function ContextAPI2() {
-    }
-    ContextAPI2.getInstance = function() {
-      if (!this._instance) {
-        this._instance = new ContextAPI2();
-      }
-      return this._instance;
-    };
-    ContextAPI2.prototype.setGlobalContextManager = function(contextManager) {
-      return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
-    };
-    ContextAPI2.prototype.active = function() {
-      return this._getContextManager().active();
-    };
-    ContextAPI2.prototype.with = function(context2, fn, thisArg) {
-      var _a;
-      var args = [];
-      for (var _i = 3; _i < arguments.length; _i++) {
-        args[_i - 3] = arguments[_i];
-      }
-      return (_a = this._getContextManager()).with.apply(_a, __spreadArray4([context2, fn, thisArg], __read4(args), false));
-    };
-    ContextAPI2.prototype.bind = function(context2, target) {
-      return this._getContextManager().bind(context2, target);
-    };
-    ContextAPI2.prototype._getContextManager = function() {
-      return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
-    };
-    ContextAPI2.prototype.disable = function() {
-      this._getContextManager().disable();
-      unregisterGlobal(API_NAME2, DiagAPI.instance());
-    };
-    return ContextAPI2;
-  })()
-);
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
-var TraceFlags;
-(function(TraceFlags2) {
-  TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
-  TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
-})(TraceFlags || (TraceFlags = {}));
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
-var INVALID_SPANID = "0000000000000000";
-var INVALID_TRACEID = "00000000000000000000000000000000";
-var INVALID_SPAN_CONTEXT = {
-  traceId: INVALID_TRACEID,
-  spanId: INVALID_SPANID,
-  traceFlags: TraceFlags.NONE
-};
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
-var NonRecordingSpan = (
-  /** @class */
-  (function() {
-    function NonRecordingSpan2(_spanContext) {
-      if (_spanContext === void 0) {
-        _spanContext = INVALID_SPAN_CONTEXT;
-      }
-      this._spanContext = _spanContext;
-    }
-    NonRecordingSpan2.prototype.spanContext = function() {
-      return this._spanContext;
-    };
-    NonRecordingSpan2.prototype.setAttribute = function(_key, _value) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.setAttributes = function(_attributes) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.addEvent = function(_name, _attributes) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.addLink = function(_link) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.addLinks = function(_links) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.setStatus = function(_status) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.updateName = function(_name) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.end = function(_endTime) {
-    };
-    NonRecordingSpan2.prototype.isRecording = function() {
-      return false;
-    };
-    NonRecordingSpan2.prototype.recordException = function(_exception, _time) {
-    };
-    return NonRecordingSpan2;
-  })()
-);
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
-var SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
-function getSpan(context2) {
-  return context2.getValue(SPAN_KEY) || void 0;
-}
-function getActiveSpan() {
-  return getSpan(ContextAPI.getInstance().active());
-}
-function setSpan(context2, span) {
-  return context2.setValue(SPAN_KEY, span);
-}
-function deleteSpan(context2) {
-  return context2.deleteValue(SPAN_KEY);
-}
-function setSpanContext(context2, spanContext) {
-  return setSpan(context2, new NonRecordingSpan(spanContext));
-}
-function getSpanContext(context2) {
-  var _a;
-  return (_a = getSpan(context2)) === null || _a === void 0 ? void 0 : _a.spanContext();
-}
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
-var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
-var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
-function isValidTraceId(traceId) {
-  return VALID_TRACEID_REGEX.test(traceId) && traceId !== INVALID_TRACEID;
-}
-function isValidSpanId(spanId) {
-  return VALID_SPANID_REGEX.test(spanId) && spanId !== INVALID_SPANID;
-}
-function isSpanContextValid(spanContext) {
-  return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
-}
-function wrapSpanContext(spanContext) {
-  return new NonRecordingSpan(spanContext);
-}
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
-var contextApi = ContextAPI.getInstance();
-var NoopTracer = (
-  /** @class */
-  (function() {
-    function NoopTracer2() {
-    }
-    NoopTracer2.prototype.startSpan = function(name, options, context2) {
-      if (context2 === void 0) {
-        context2 = contextApi.active();
-      }
-      var root = Boolean(options === null || options === void 0 ? void 0 : options.root);
-      if (root) {
-        return new NonRecordingSpan();
-      }
-      var parentFromContext = context2 && getSpanContext(context2);
-      if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
-        return new NonRecordingSpan(parentFromContext);
-      } else {
-        return new NonRecordingSpan();
-      }
-    };
-    NoopTracer2.prototype.startActiveSpan = function(name, arg2, arg3, arg4) {
-      var opts;
-      var ctx;
-      var fn;
-      if (arguments.length < 2) {
-        return;
-      } else if (arguments.length === 2) {
-        fn = arg2;
-      } else if (arguments.length === 3) {
-        opts = arg2;
-        fn = arg3;
-      } else {
-        opts = arg2;
-        ctx = arg3;
-        fn = arg4;
-      }
-      var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
-      var span = this.startSpan(name, opts, parentContext);
-      var contextWithSpanSet = setSpan(parentContext, span);
-      return contextApi.with(contextWithSpanSet, fn, void 0, span);
-    };
-    return NoopTracer2;
-  })()
-);
-function isSpanContext(spanContext) {
-  return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
-}
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
-var NOOP_TRACER = new NoopTracer();
-var ProxyTracer = (
-  /** @class */
-  (function() {
-    function ProxyTracer2(_provider, name, version, options) {
-      this._provider = _provider;
-      this.name = name;
-      this.version = version;
-      this.options = options;
-    }
-    ProxyTracer2.prototype.startSpan = function(name, options, context2) {
-      return this._getTracer().startSpan(name, options, context2);
-    };
-    ProxyTracer2.prototype.startActiveSpan = function(_name, _options, _context, _fn) {
-      var tracer = this._getTracer();
-      return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
-    };
-    ProxyTracer2.prototype._getTracer = function() {
-      if (this._delegate) {
-        return this._delegate;
-      }
-      var tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
-      if (!tracer) {
-        return NOOP_TRACER;
-      }
-      this._delegate = tracer;
-      return this._delegate;
-    };
-    return ProxyTracer2;
-  })()
-);
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
-var NoopTracerProvider = (
-  /** @class */
-  (function() {
-    function NoopTracerProvider2() {
-    }
-    NoopTracerProvider2.prototype.getTracer = function(_name, _version, _options) {
-      return new NoopTracer();
-    };
-    return NoopTracerProvider2;
-  })()
-);
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
-var NOOP_TRACER_PROVIDER = new NoopTracerProvider();
-var ProxyTracerProvider = (
-  /** @class */
-  (function() {
-    function ProxyTracerProvider2() {
-    }
-    ProxyTracerProvider2.prototype.getTracer = function(name, version, options) {
-      var _a;
-      return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
-    };
-    ProxyTracerProvider2.prototype.getDelegate = function() {
-      var _a;
-      return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
-    };
-    ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
-      this._delegate = delegate;
-    };
-    ProxyTracerProvider2.prototype.getDelegateTracer = function(name, version, options) {
-      var _a;
-      return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
-    };
-    return ProxyTracerProvider2;
-  })()
-);
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/context-api.js
-var context = ContextAPI.getInstance();
-
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/api/trace.js
-var API_NAME3 = "trace";
-var TraceAPI = (
-  /** @class */
-  (function() {
-    function TraceAPI2() {
-      this._proxyTracerProvider = new ProxyTracerProvider();
-      this.wrapSpanContext = wrapSpanContext;
-      this.isSpanContextValid = isSpanContextValid;
-      this.deleteSpan = deleteSpan;
-      this.getSpan = getSpan;
-      this.getActiveSpan = getActiveSpan;
-      this.getSpanContext = getSpanContext;
-      this.setSpan = setSpan;
-      this.setSpanContext = setSpanContext;
-    }
-    TraceAPI2.getInstance = function() {
-      if (!this._instance) {
-        this._instance = new TraceAPI2();
-      }
-      return this._instance;
-    };
-    TraceAPI2.prototype.setGlobalTracerProvider = function(provider) {
-      var success = registerGlobal(API_NAME3, this._proxyTracerProvider, DiagAPI.instance());
-      if (success) {
-        this._proxyTracerProvider.setDelegate(provider);
-      }
-      return success;
-    };
-    TraceAPI2.prototype.getTracerProvider = function() {
-      return getGlobal(API_NAME3) || this._proxyTracerProvider;
-    };
-    TraceAPI2.prototype.getTracer = function(name, version) {
-      return this.getTracerProvider().getTracer(name, version);
-    };
-    TraceAPI2.prototype.disable = function() {
-      unregisterGlobal(API_NAME3, DiagAPI.instance());
-      this._proxyTracerProvider = new ProxyTracerProvider();
-    };
-    return TraceAPI2;
-  })()
-);
+  /**
+   * Handles audio input from the user
+   */
+  async handleAudioInput(audioData) {
+    const sessionWithTransport = this.session;
+    const transport = sessionWithTransport.transport;
+    if (!transport) {
+      throw new Error("Realtime transport not available");
+    }
+    transport.sendEvent({
+      type: "input_audio_buffer.append",
+      audio: audioData
+    });
+    transport.sendEvent({
+      type: "input_audio_buffer.commit"
+    });
+    transport.sendEvent({
+      type: "response.create"
+    });
+    const timeout = this.config.responseTimeout ?? 6e4;
+    const response = await this.eventHandler.waitForResponse(timeout);
+    this.audioEvents.emit("audioResponse", response);
+    return this.responseFormatter.formatAudioResponse(response);
+  }
+  /**
+   * Handles text input from the user
+   */
+  async handleTextInput(text) {
+    this.session.sendMessage(text);
+    const timeout = this.config.responseTimeout ?? 3e4;
+    const response = await this.eventHandler.waitForResponse(timeout);
+    this.audioEvents.emit("audioResponse", response);
+    return this.responseFormatter.formatTextResponse(response.transcript);
+  }
+  /**
+   * Subscribe to audio response events
+   *
+   * @param callback - Function called when an audio response completes
+   */
+  onAudioResponse(callback) {
+    this.audioEvents.on("audioResponse", callback);
+  }
+  /**
+   * Remove audio response listener
+   *
+   * @param callback - The callback function to remove
+   */
+  offAudioResponse(callback) {
+    this.audioEvents.off("audioResponse", callback);
+  }
+};
 
-// node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace-api.js
-var trace = TraceAPI.getInstance();
+// src/execution/index.ts
+var execution_exports = {};
+__export(execution_exports, {
+  ScenarioExecution: () => ScenarioExecution,
+  ScenarioExecutionState: () => ScenarioExecutionState,
+  StateChangeEventType: () => StateChangeEventType
+});
 
 // src/execution/scenario-execution.ts
+init_esm();
+init_esm();
 var import_langwatch = require("langwatch");
 var import_observability3 = require("langwatch/observability");
 var import_rxjs2 = require("rxjs");
@@ -2371,7 +2598,7 @@ var scenarioRunStartedSchema = baseScenarioEventSchema.extend({
   metadata: import_zod.z.object({
     name: import_zod.z.string().optional(),
     description: import_zod.z.string().optional()
-  })
+  }).catchall(import_zod.z.unknown())
 });
 var scenarioResultsSchema = import_zod.z.object({
   verdict: import_zod.z.nativeEnum(Verdict),
@@ -2518,6 +2745,8 @@ var ScenarioExecution = class {
   currentTurnSpan;
   /** Timestamp when execution started (for total time calculation) */
   totalStartTime = 0;
+  /** Accumulated results from inline judge checkpoints */
+  checkpointResults = [];
   /** Event stream for monitoring scenario progress */
   eventSubject = new import_rxjs2.Subject();
   /**
@@ -2530,13 +2759,22 @@ var ScenarioExecution = class {
    * - RUN_FINISHED: When scenario execution completes (success/failure/error)
    */
   events$ = this.eventSubject.asObservable();
+  /** Batch run ID for grouping scenario runs */
+  batchRunId;
+  /** The run ID for the current execution */
+  scenarioRunId;
   /**
    * Creates a new ScenarioExecution instance.
    *
    * @param config - The scenario configuration containing agents, settings, and metadata
    * @param script - The ordered sequence of script steps that define the test flow
+   * @param batchRunId - Batch run ID for grouping scenario runs
    */
-  constructor(config2, script) {
+  constructor(config2, script, batchRunId2) {
+    if (!batchRunId2) {
+      throw new Error("batchRunId is required");
+    }
+    this.batchRunId = batchRunId2;
     this.config = {
       id: config2.id ?? generateScenarioId(),
       name: config2.name,
@@ -2546,7 +2784,8 @@ var ScenarioExecution = class {
       verbose: config2.verbose ?? DEFAULT_VERBOSE,
       maxTurns: config2.maxTurns ?? DEFAULT_MAX_TURNS,
       threadId: config2.threadId ?? generateThreadId(),
-      setId: config2.setId
+      setId: config2.setId,
+      metadata: config2.metadata
     };
     this.state = new ScenarioExecutionState(this.config);
     this.reset();
@@ -2584,12 +2823,16 @@ var ScenarioExecution = class {
    * @param result - The final scenario result (without messages/timing, which will be added automatically)
    */
   setResult(result) {
+    if (!this.scenarioRunId) {
+      throw new Error("Cannot set result: scenarioRunId has not been initialized. This is a bug in ScenarioExecution.");
+    }
     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);
     this._result = {
+      runId: this.scenarioRunId,
       ...result,
       messages: this.state.messages,
       totalTime: this.totalTime,
@@ -2602,6 +2845,7 @@ var ScenarioExecution = class {
       agentTime: totalAgentTime,
       messageCount: this.state.messages.length
     });
+    return this._result;
   }
   /**
    * The total elapsed time for the scenario execution.
@@ -2642,7 +2886,10 @@ var ScenarioExecution = class {
       scriptLength: this.config.script.length
     });
     this.reset();
+    this.newTurn();
+    this.state.currentTurn = 0;
     const scenarioRunId = generateScenarioRunId();
+    this.scenarioRunId = scenarioRunId;
     this.logger.debug(`[${this.config.id}] Generated run ID: ${scenarioRunId}`);
     this.emitRunStarted({ scenarioRunId });
     const subscription = this.state.events$.pipe(
@@ -2655,6 +2902,8 @@ var ScenarioExecution = class {
         const scriptStep = this.config.script[i];
         await this.executeScriptStep(scriptStep, i);
         if (this.result) {
+          const cp = this.compiledCheckpoints;
+          this.result.metCriteria = [...cp.metCriteria, ...this.result.metCriteria];
           this.emitRunFinished({
             scenarioRunId,
             status: this.result.success ? "SUCCESS" /* SUCCESS */ : "FAILED" /* FAILED */,
@@ -2663,7 +2912,22 @@ var ScenarioExecution = class {
           return this.result;
         }
       }
-      this.reachedMaxTurns(
+      if (this.checkpointResults.length > 0) {
+        const cp = this.compiledCheckpoints;
+        const result2 = this.setResult({
+          success: cp.unmetCriteria.length === 0,
+          reasoning: "All inline criteria checkpoints passed",
+          metCriteria: cp.metCriteria,
+          unmetCriteria: cp.unmetCriteria
+        });
+        this.emitRunFinished({
+          scenarioRunId,
+          status: result2.success ? "SUCCESS" /* SUCCESS */ : "FAILED" /* FAILED */,
+          result: result2
+        });
+        return result2;
+      }
+      const result = 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",
@@ -2671,11 +2935,11 @@ var ScenarioExecution = class {
           "- `Scenario.succeed()` or `Scenario.fail()` to end the test with an explicit result"
         ].join("\n")
       );
-      this.emitRunFinished({ scenarioRunId, status: "FAILED" /* FAILED */ });
-      return this.result;
+      this.emitRunFinished({ scenarioRunId, status: "FAILED" /* FAILED */, result });
+      return result;
     } catch (error) {
       const errorInfo = extractErrorInfo(error);
-      this.setResult({
+      const result = this.setResult({
         success: false,
         reasoning: `Scenario failed with error: ${errorInfo.message}`,
         metCriteria: [],
@@ -2685,10 +2949,14 @@ var ScenarioExecution = class {
       this.emitRunFinished({
         scenarioRunId,
         status: "ERROR" /* ERROR */,
-        result: this.result
+        result
       });
       throw error;
     } finally {
+      if (this.currentTurnSpan) {
+        this.currentTurnSpan.end();
+        this.currentTurnSpan = void 0;
+      }
       subscription.unsubscribe();
     }
   }
@@ -2789,7 +3057,7 @@ var ScenarioExecution = class {
    * @param judgmentRequest - Whether this is a judgment request (for judge agents)
    * @throws Error if the agent call fails
    */
-  async callAgent(idx, role, judgmentRequest = false) {
+  async callAgent(idx, role, judgmentRequest) {
     var _a;
     const agent2 = this.agents[idx];
     const agentName = agent2.name ?? agent2.constructor.name;
@@ -2813,69 +3081,72 @@ var ScenarioExecution = class {
     const agentContext = this.currentTurnSpan ? trace.setSpan(context.active(), this.currentTurnSpan) : context.active();
     const agentSpanName = `${agentName !== Object.prototype.constructor.name ? agent2.constructor.name : "Agent"}.call`;
     try {
-      await this.tracer.withActiveSpan(
-        agentSpanName,
-        {
-          attributes: {
-            [import_observability3.attributes.ATTR_LANGWATCH_THREAD_ID]: this.state.threadId
-          }
-        },
+      await context.with(
         agentContext,
-        async (agentSpan) => {
-          agentSpan.setType("agent");
-          agentSpan.setInput("chat_messages", this.state.messages);
-          const agentResponse = await agent2.call(agentInput);
-          const endTime = Date.now();
-          const duration = endTime - startTime;
-          this.logger.debug(`[${this.config.id}] Agent responded`, {
-            agentIdx: idx,
-            duration,
-            responseType: typeof agentResponse,
-            isScenarioResult: agentResponse && typeof agentResponse === "object" && "success" in agentResponse
-          });
-          this.addAgentTime(idx, duration);
-          this.pendingMessages.delete(idx);
-          if (agentResponse && typeof agentResponse === "object" && "success" in agentResponse) {
-            this.logger.debug(
-              `[${this.config.id}] Agent returned ScenarioResult`,
-              {
-                success: agentResponse.success
-              }
-            );
-            this.setResult(agentResponse);
-            return;
-          }
-          const messages = convertAgentReturnTypesToMessages(
-            agentResponse,
-            role === "User" /* USER */ ? "user" : "assistant"
-          );
-          if (messages.length > 0) {
-            agentSpan.setOutput("chat_messages", messages);
-          }
-          const metrics = {
-            duration: endTime - startTime
-          };
-          if (agentResponse && typeof agentResponse === "object") {
-            const usage = agentResponse.usage;
-            if (usage) {
-              if (usage.prompt_tokens !== void 0)
-                metrics.promptTokens = usage.prompt_tokens;
-              if (usage.completion_tokens !== void 0)
-                metrics.completionTokens = usage.completion_tokens;
-              if (usage.total_tokens !== void 0)
-                metrics.totalTokens = usage.total_tokens;
+        () => this.tracer.withActiveSpan(
+          agentSpanName,
+          {
+            attributes: {
+              [import_observability3.attributes.ATTR_LANGWATCH_THREAD_ID]: this.state.threadId
             }
-          }
-          agentSpan.setMetrics(metrics);
-          const traceId = agentSpan.spanContext().traceId.toString();
-          for (const message2 of messages) {
-            this.state.addMessage({
-              ...message2,
-              traceId
+          },
+          agentContext,
+          async (agentSpan) => {
+            agentSpan.setType("agent");
+            agentSpan.setInput("chat_messages", this.state.messages);
+            const agentResponse = await agent2.call(agentInput);
+            const endTime = Date.now();
+            const duration = endTime - startTime;
+            this.logger.debug(`[${this.config.id}] Agent responded`, {
+              agentIdx: idx,
+              duration,
+              responseType: typeof agentResponse,
+              isScenarioResult: agentResponse && typeof agentResponse === "object" && "success" in agentResponse
             });
-            this.broadcastMessage(message2, idx);
+            this.addAgentTime(idx, duration);
+            this.pendingMessages.delete(idx);
+            if (agentResponse && typeof agentResponse === "object" && "success" in agentResponse) {
+              this.logger.debug(
+                `[${this.config.id}] Agent returned ScenarioResult`,
+                {
+                  success: agentResponse.success
+                }
+              );
+              this.setResult(agentResponse);
+              return;
+            }
+            const messages = convertAgentReturnTypesToMessages(
+              agentResponse,
+              role === "User" /* USER */ ? "user" : "assistant"
+            );
+            if (messages.length > 0) {
+              agentSpan.setOutput("chat_messages", messages);
+            }
+            const metrics = {
+              duration: endTime - startTime
+            };
+            if (agentResponse && typeof agentResponse === "object") {
+              const usage = agentResponse.usage;
+              if (usage) {
+                if (usage.prompt_tokens !== void 0)
+                  metrics.promptTokens = usage.prompt_tokens;
+                if (usage.completion_tokens !== void 0)
+                  metrics.completionTokens = usage.completion_tokens;
+                if (usage.total_tokens !== void 0)
+                  metrics.totalTokens = usage.total_tokens;
+              }
+            }
+            agentSpan.setMetrics(metrics);
+            const traceId = agentSpan.spanContext().traceId.toString();
+            for (const message2 of messages) {
+              this.state.addMessage({
+                ...message2,
+                traceId
+              });
+              this.broadcastMessage(message2, idx);
+            }
           }
-        }
+        )
       );
     } catch (error) {
       throw new Error(`[${agentName}] ${error}`, { cause: error });
@@ -2980,25 +3251,26 @@ var ScenarioExecution = class {
    *
    * This method is part of the ScenarioExecutionLike interface used by script steps.
    *
-   * @param content - Optional message to pass to the judge agent for additional context
+   * @param options - Optional options with inline criteria to evaluate as a checkpoint.
    * @returns A promise that resolves with:
    *   - ScenarioResult if the judge makes a final decision, or
    *   - Null if the conversation should continue
    *
    * @example
    * ```typescript
-   * // Let judge evaluate current state
+   * // Let judge evaluate with its configured criteria
    * const result = await execution.judge();
-   * if (result) {
-   *   console.log(`Judge decided: ${result.success ? 'pass' : 'fail'}`);
-   * }
    *
-   * // Provide additional context to judge
-   * const result = await execution.judge("Please consider the user's satisfaction level");
+   * // Evaluate inline criteria as a checkpoint
+   * const result = await execution.judge({ criteria: ["Agent responded helpfully"] });
    * ```
    */
-  async judge(content) {
-    return await this.scriptCallAgent("Judge" /* JUDGE */, content, true);
+  async judge(options) {
+    return await this.scriptCallAgent(
+      "Judge" /* JUDGE */,
+      void 0,
+      { criteria: options == null ? void 0 : options.criteria }
+    );
   }
   /**
    * Lets the scenario proceed automatically for a specified number of turns.
@@ -3083,13 +3355,12 @@ var ScenarioExecution = class {
    * ```
    */
   async succeed(reasoning) {
-    this.setResult({
+    return this.setResult({
       success: true,
       reasoning: reasoning || "Scenario marked as successful with Scenario.succeed()",
       metCriteria: [],
       unmetCriteria: []
     });
-    return this.result;
   }
   /**
    * Immediately ends the scenario with a failure verdict.
@@ -3115,13 +3386,12 @@ var ScenarioExecution = class {
    * ```
    */
   async fail(reasoning) {
-    this.setResult({
+    return this.setResult({
       success: false,
       reasoning: reasoning || "Scenario marked as failed with Scenario.fail()",
       metCriteria: [],
       unmetCriteria: []
     });
-    return this.result;
   }
   /**
    * Adds execution time for a specific agent to the performance tracking.
@@ -3165,15 +3435,14 @@ var ScenarioExecution = class {
    *          decision, or null if the conversation should continue
    * @throws Error if no agent is found for the specified role
    */
-  async scriptCallAgent(role, content, judgmentRequest = false) {
+  async scriptCallAgent(role, content, judgmentRequest) {
     this.logger.debug(`[${this.config.id}] scriptCallAgent`, {
       role,
       hasContent: content !== void 0,
-      judgmentRequest
+      judgmentRequest: judgmentRequest != null,
+      hasInlineCriteria: (judgmentRequest == null ? void 0 : judgmentRequest.criteria) != null
     });
     this.consumeUntilRole(role);
-    let index = -1;
-    let agent2 = null;
     let nextAgent = this.getNextAgentForRole(role);
     if (!nextAgent) {
       this.newTurn();
@@ -3203,8 +3472,8 @@ var ScenarioExecution = class {
         `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;
+    const index = nextAgent.index;
+    const agent2 = nextAgent.agent;
     this.removePendingAgent(agent2);
     if (content) {
       const message2 = typeof content === "string" ? {
@@ -3216,6 +3485,25 @@ var ScenarioExecution = class {
       return null;
     }
     await this.callAgent(index, role, judgmentRequest);
+    if (this.result && (judgmentRequest == null ? void 0 : judgmentRequest.criteria) != null) {
+      this.checkpointResults.push({
+        metCriteria: this.result.metCriteria,
+        unmetCriteria: this.result.unmetCriteria
+      });
+      if (this.result.success) {
+        this._result = void 0;
+        return null;
+      } else {
+        const cp = this.compiledCheckpoints;
+        this.result.metCriteria = cp.metCriteria;
+        this.result.unmetCriteria = cp.unmetCriteria;
+        return this.result;
+      }
+    }
+    if (this.result) {
+      const cp = this.compiledCheckpoints;
+      this.result.metCriteria = [...cp.metCriteria, ...this.result.metCriteria];
+    }
     return this.result ?? null;
   }
   /**
@@ -3229,7 +3517,7 @@ var ScenarioExecution = class {
    * - Creates a new ScenarioExecutionState with the current config
    * - Sets up the thread ID (generates new one if not provided)
    * - Initializes all agents
-   * - Starts the first turn
+   * - Initializes turn state (pending agents/roles) without creating a trace span
    * - Records the start time for performance tracking
    * - Clears any pending messages
    * - Clears the result from any previous execution
@@ -3243,16 +3531,28 @@ var ScenarioExecution = class {
     this.state = new ScenarioExecutionState(this.config);
     this.state.threadId = this.config.threadId || generateThreadId();
     this.setAgents(this.config.agents);
-    this.newTurn();
+    this.pendingAgentsOnTurn = new Set(this.agents);
+    this.pendingRolesOnTurn = ["User" /* USER */, "Agent" /* AGENT */, "Judge" /* JUDGE */];
     this.state.currentTurn = 0;
     this.totalStartTime = Date.now();
     this.pendingMessages.clear();
     this._result = void 0;
+    this.checkpointResults = [];
     this.logger.debug(`[${this.config.id}] Reset complete`, {
       threadId: this.state.threadId,
       agentCount: this.agents.length
     });
   }
+  /** Compiles all accumulated checkpoint results into aggregated met/unmet criteria. */
+  get compiledCheckpoints() {
+    const metCriteria = [];
+    const unmetCriteria = [];
+    for (const cp of this.checkpointResults) {
+      metCriteria.push(...cp.metCriteria);
+      unmetCriteria.push(...cp.unmetCriteria);
+    }
+    return { metCriteria, unmetCriteria };
+  }
   nextAgentForRole(role) {
     for (const agent2 of this.agents) {
       if (agent2.role === role && this.pendingAgentsOnTurn.has(agent2) && this.pendingRolesOnTurn.includes(role)) {
@@ -3349,7 +3649,7 @@ var ScenarioExecution = class {
    */
   reachedMaxTurns(errorMessage) {
     var _a;
-    this.setResult({
+    return this.setResult({
       success: false,
       reasoning: errorMessage || `Reached maximum turns (${this.config.maxTurns || 10}) without conclusion`,
       metCriteria: [],
@@ -3373,7 +3673,7 @@ var ScenarioExecution = class {
       type: "placeholder",
       // This will be replaced by the specific event type
       timestamp: Date.now(),
-      batchRunId: getBatchRunId(),
+      batchRunId: this.batchRunId,
       scenarioId: this.config.id,
       scenarioRunId,
       scenarioSetId: this.config.setId
@@ -3387,6 +3687,7 @@ var ScenarioExecution = class {
       ...this.makeBaseEvent({ scenarioRunId }),
       type: "SCENARIO_RUN_STARTED" /* RUN_STARTED */,
       metadata: {
+        ...this.config.metadata,
         name: this.config.name,
         description: this.config.description
       }
@@ -3850,9 +4151,9 @@ var message = (message2) => {
 var agent = (content) => {
   return (_state, executor) => executor.agent(content);
 };
-var judge = (content) => {
+var judge = (options) => {
   return async (_state, executor) => {
-    await executor.judge(content);
+    await executor.judge(options);
   };
 };
 var user = (content) => {
@@ -3874,8 +4175,429 @@ var fail = (reasoning) => {
   };
 };
 
+// src/tracing/setup.ts
+init_esm();
+var import_node = require("langwatch/observability/node");
+var import_observability4 = require("langwatch/observability");
+
+// node_modules/.pnpm/@opentelemetry+core@1.30.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
+init_esm();
+var SUPPRESS_TRACING_KEY = createContextKey("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+function suppressTracing(context2) {
+  return context2.setValue(SUPPRESS_TRACING_KEY, true);
+}
+
+// node_modules/.pnpm/@opentelemetry+core@1.30.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js
+init_esm();
+function loggingErrorHandler() {
+  return function(ex) {
+    diag.error(stringifyException(ex));
+  };
+}
+function stringifyException(ex) {
+  if (typeof ex === "string") {
+    return ex;
+  } else {
+    return JSON.stringify(flattenException(ex));
+  }
+}
+function flattenException(ex) {
+  var result = {};
+  var current = ex;
+  while (current !== null) {
+    Object.getOwnPropertyNames(current).forEach(function(propertyName) {
+      if (result[propertyName])
+        return;
+      var value = current[propertyName];
+      if (value) {
+        result[propertyName] = String(value);
+      }
+    });
+    current = Object.getPrototypeOf(current);
+  }
+  return result;
+}
+
+// node_modules/.pnpm/@opentelemetry+core@1.30.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js
+var delegateHandler = loggingErrorHandler();
+function globalErrorHandler(ex) {
+  try {
+    delegateHandler(ex);
+  } catch (_a) {
+  }
+}
+
+// node_modules/.pnpm/@opentelemetry+core@1.30.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode;
+(function(ExportResultCode2) {
+  ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
+  ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
+})(ExportResultCode || (ExportResultCode = {}));
+
+// node_modules/.pnpm/@opentelemetry+core@1.30.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/utils/promise.js
+var Deferred = (
+  /** @class */
+  (function() {
+    function Deferred2() {
+      var _this = this;
+      this._promise = new Promise(function(resolve, reject) {
+        _this._resolve = resolve;
+        _this._reject = reject;
+      });
+    }
+    Object.defineProperty(Deferred2.prototype, "promise", {
+      get: function() {
+        return this._promise;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Deferred2.prototype.resolve = function(val) {
+      this._resolve(val);
+    };
+    Deferred2.prototype.reject = function(err) {
+      this._reject(err);
+    };
+    return Deferred2;
+  })()
+);
+
+// node_modules/.pnpm/@opentelemetry+core@1.30.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/utils/callback.js
+var __read5 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray5 = function(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var BindOnceFuture = (
+  /** @class */
+  (function() {
+    function BindOnceFuture2(_callback, _that) {
+      this._callback = _callback;
+      this._that = _that;
+      this._isCalled = false;
+      this._deferred = new Deferred();
+    }
+    Object.defineProperty(BindOnceFuture2.prototype, "isCalled", {
+      get: function() {
+        return this._isCalled;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(BindOnceFuture2.prototype, "promise", {
+      get: function() {
+        return this._deferred.promise;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    BindOnceFuture2.prototype.call = function() {
+      var _a;
+      var _this = this;
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      if (!this._isCalled) {
+        this._isCalled = true;
+        try {
+          Promise.resolve((_a = this._callback).call.apply(_a, __spreadArray5([this._that], __read5(args), false))).then(function(val) {
+            return _this._deferred.resolve(val);
+          }, function(err) {
+            return _this._deferred.reject(err);
+          });
+        } catch (err) {
+          this._deferred.reject(err);
+        }
+      }
+      return this._deferred.promise;
+    };
+    return BindOnceFuture2;
+  })()
+);
+
+// node_modules/.pnpm/@opentelemetry+core@1.30.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/internal/exporter.js
+init_esm();
+function _export(exporter, arg) {
+  return new Promise(function(resolve) {
+    context.with(suppressTracing(context.active()), function() {
+      exporter.export(arg, function(result) {
+        resolve(result);
+      });
+    });
+  });
+}
+
+// node_modules/.pnpm/@opentelemetry+core@1.30.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/index.js
+var internal = {
+  _export
+};
+
+// node_modules/.pnpm/@opentelemetry+sdk-trace-base@1.30.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SimpleSpanProcessor.js
+init_esm();
+var __awaiter = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = function(thisArg, body) {
+  var _ = { label: 0, sent: function() {
+    if (t[0] & 1) throw t[1];
+    return t[1];
+  }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (_) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return { value: op[1], done: false };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
+};
+var SimpleSpanProcessor = (
+  /** @class */
+  (function() {
+    function SimpleSpanProcessor2(_exporter) {
+      this._exporter = _exporter;
+      this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+      this._unresolvedExports = /* @__PURE__ */ new Set();
+    }
+    SimpleSpanProcessor2.prototype.forceFlush = function() {
+      return __awaiter(this, void 0, void 0, function() {
+        return __generator(this, function(_a) {
+          switch (_a.label) {
+            case 0:
+              return [4, Promise.all(Array.from(this._unresolvedExports))];
+            case 1:
+              _a.sent();
+              if (!this._exporter.forceFlush) return [3, 3];
+              return [4, this._exporter.forceFlush()];
+            case 2:
+              _a.sent();
+              _a.label = 3;
+            case 3:
+              return [
+                2
+                /*return*/
+              ];
+          }
+        });
+      });
+    };
+    SimpleSpanProcessor2.prototype.onStart = function(_span, _parentContext) {
+    };
+    SimpleSpanProcessor2.prototype.onEnd = function(span) {
+      var _this = this;
+      var _a, _b;
+      if (this._shutdownOnce.isCalled) {
+        return;
+      }
+      if ((span.spanContext().traceFlags & TraceFlags.SAMPLED) === 0) {
+        return;
+      }
+      var doExport = function() {
+        return internal._export(_this._exporter, [span]).then(function(result) {
+          var _a2;
+          if (result.code !== ExportResultCode.SUCCESS) {
+            globalErrorHandler((_a2 = result.error) !== null && _a2 !== void 0 ? _a2 : new Error("SimpleSpanProcessor: span export failed (status " + result + ")"));
+          }
+        }).catch(function(error) {
+          globalErrorHandler(error);
+        });
+      };
+      if (span.resource.asyncAttributesPending) {
+        var exportPromise_1 = (_b = (_a = span.resource).waitForAsyncAttributes) === null || _b === void 0 ? void 0 : _b.call(_a).then(function() {
+          if (exportPromise_1 != null) {
+            _this._unresolvedExports.delete(exportPromise_1);
+          }
+          return doExport();
+        }, function(err) {
+          return globalErrorHandler(err);
+        });
+        if (exportPromise_1 != null) {
+          this._unresolvedExports.add(exportPromise_1);
+        }
+      } else {
+        void doExport();
+      }
+    };
+    SimpleSpanProcessor2.prototype.shutdown = function() {
+      return this._shutdownOnce.call();
+    };
+    SimpleSpanProcessor2.prototype._shutdown = function() {
+      return this._exporter.shutdown();
+    };
+    return SimpleSpanProcessor2;
+  })()
+);
+
+// src/tracing/setup.ts
+var initialized = false;
+function getConcreteProvider(provider) {
+  if (!provider || typeof provider !== "object") return void 0;
+  if (typeof provider.addSpanProcessor === "function") {
+    return provider;
+  }
+  const p = provider;
+  const delegate = typeof p.getDelegate === "function" ? p.getDelegate() : p.delegate ?? p._delegate;
+  if (delegate && typeof delegate === "object") {
+    if (typeof delegate.addSpanProcessor === "function") {
+      return delegate;
+    }
+  }
+  return void 0;
+}
+function setupScenarioTracing(options) {
+  if (initialized) return;
+  const globalProvider = trace.getTracerProvider();
+  const concrete = getConcreteProvider(globalProvider);
+  if (concrete) {
+    attachToExistingProvider(concrete, options);
+  } else {
+    initializeFullSetup(options);
+  }
+  initialized = true;
+}
+function ensureTracingInitialized(options) {
+  if (initialized) return;
+  setupScenarioTracing(options);
+}
+function attachToExistingProvider(provider, options) {
+  provider.addSpanProcessor(judgeSpanCollector);
+  if (options == null ? void 0 : options.spanProcessors) {
+    for (const processor of options.spanProcessors) {
+      provider.addSpanProcessor(processor);
+    }
+  }
+  if (options == null ? void 0 : options.traceExporter) {
+    provider.addSpanProcessor(new SimpleSpanProcessor(options.traceExporter));
+  }
+  const envConfig = getEnv();
+  if (envConfig.LANGWATCH_API_KEY) {
+    const exporter = new import_observability4.LangWatchTraceExporter({
+      apiKey: envConfig.LANGWATCH_API_KEY,
+      endpoint: envConfig.LANGWATCH_ENDPOINT
+    });
+    provider.addSpanProcessor(new SimpleSpanProcessor(exporter));
+  }
+}
+function initializeFullSetup(options) {
+  const envConfig = getEnv();
+  const spanProcessors = [judgeSpanCollector];
+  if (options == null ? void 0 : options.spanProcessors) {
+    spanProcessors.push(...options.spanProcessors);
+  }
+  (0, import_node.setupObservability)({
+    ...options,
+    langwatch: (options == null ? void 0 : options.langwatch) ?? {
+      apiKey: envConfig.LANGWATCH_API_KEY,
+      endpoint: envConfig.LANGWATCH_ENDPOINT
+    },
+    spanProcessors
+  });
+}
+
 // src/runner/run.ts
-async function run(cfg) {
+async function run(cfg, options) {
+  var _a, _b;
   if (!cfg.name) {
     throw new Error("Scenario name is required");
   }
@@ -3900,14 +4622,17 @@ async function run(cfg) {
     cfg.threadId = generateThreadId();
   }
   const steps = cfg.script || [proceed()];
-  const execution = new ScenarioExecution(cfg, steps);
+  const batchRunId2 = (options == null ? void 0 : options.batchRunId) ?? getBatchRunId();
+  const execution = new ScenarioExecution(cfg, steps, batchRunId2);
   let eventBus = null;
   let subscription = null;
   try {
-    const envConfig2 = getEnv();
+    const projectConfig = await getProjectConfig();
+    ensureTracingInitialized(projectConfig == null ? void 0 : projectConfig.observability);
+    const envConfig = getEnv();
     eventBus = new EventBus({
-      endpoint: envConfig2.LANGWATCH_ENDPOINT,
-      apiKey: envConfig2.LANGWATCH_API_KEY
+      endpoint: ((_a = options == null ? void 0 : options.langwatch) == null ? void 0 : _a.endpoint) ?? envConfig.LANGWATCH_ENDPOINT,
+      apiKey: ((_b = options == null ? void 0 : options.langwatch) == null ? void 0 : _b.apiKey) ?? envConfig.LANGWATCH_API_KEY
     });
     eventBus.listen();
     subscription = eventBus.subscribeTo(execution.events$);
@@ -3924,6 +4649,9 @@ async function run(cfg) {
   } finally {
     await (eventBus == null ? void 0 : eventBus.drain());
     subscription == null ? void 0 : subscription.unsubscribe();
+    if (cfg.threadId) {
+      judgeSpanCollector.clearSpansForThread(cfg.threadId);
+    }
   }
 }
 function formatMessage(m) {
@@ -3968,6 +4696,27 @@ function formatPart(part) {
   }
 }
 
+// src/tracing/filters.ts
+var scenarioOnly = [
+  {
+    include: {
+      instrumentationScopeName: [{ equals: "@langwatch/scenario" }]
+    }
+  }
+];
+function withCustomScopes(...scopes) {
+  return [
+    {
+      include: {
+        instrumentationScopeName: [
+          { equals: "@langwatch/scenario" },
+          ...scopes.map((scope) => ({ equals: scope }))
+        ]
+      }
+    }
+  ];
+}
+
 // src/index.ts
 var scenario = {
   ...agents_exports,
@@ -4003,8 +4752,11 @@ var index_default = scenario;
   proceed,
   run,
   scenario,
+  scenarioOnly,
   scenarioProjectConfigSchema,
+  setupScenarioTracing,
   succeed,
   user,
-  userSimulatorAgent
+  userSimulatorAgent,
+  withCustomScopes
 });