@langwatch/scenario 0.2.0 → 0.2.2

package/dist/chunk-ORWSJC5F.mjs

@@ -1,309 +0,0 @@
-// src/events/event-bus.ts
-import { concatMap, EMPTY, catchError, Subject } from "rxjs";
-
-// src/utils/logger.ts
-var Logger = class _Logger {
-  constructor(context) {
-    this.context = context;
-  }
-  /**
-   * Creates a logger with context (e.g., class name)
-   */
-  static create(context) {
-    return new _Logger(context);
-  }
-  /**
-   * Checks if logging should occur based on LOG_LEVEL env var
-   */
-  shouldLog(level) {
-    const logLevel = (process.env.SCENARIO_LOG_LEVEL || "").toLowerCase();
-    const levels = ["error", "warn", "info", "debug"];
-    const currentLevelIndex = levels.indexOf(logLevel);
-    const requestedLevelIndex = levels.indexOf(level);
-    return currentLevelIndex >= 0 && requestedLevelIndex <= currentLevelIndex;
-  }
-  formatMessage(message) {
-    return this.context ? `[${this.context}] ${message}` : message;
-  }
-  error(message, data) {
-    if (this.shouldLog("error")) {
-      const formattedMessage = this.formatMessage(message);
-      if (data) {
-        console.error(formattedMessage, data);
-      } else {
-        console.error(formattedMessage);
-      }
-    }
-  }
-  warn(message, data) {
-    if (this.shouldLog("warn")) {
-      const formattedMessage = this.formatMessage(message);
-      if (data) {
-        console.warn(formattedMessage, data);
-      } else {
-        console.warn(formattedMessage);
-      }
-    }
-  }
-  info(message, data) {
-    if (this.shouldLog("info")) {
-      const formattedMessage = this.formatMessage(message);
-      if (data) {
-        console.info(formattedMessage, data);
-      } else {
-        console.info(formattedMessage);
-      }
-    }
-  }
-  debug(message, data) {
-    if (this.shouldLog("debug")) {
-      const formattedMessage = this.formatMessage(message);
-      if (data) {
-        console.log(formattedMessage, data);
-      } else {
-        console.log(formattedMessage);
-      }
-    }
-  }
-};
-
-// src/events/event-reporter.ts
-var EventReporter = class {
-  eventsEndpoint;
-  apiKey;
-  logger = new Logger("scenario.events.EventReporter");
-  constructor(config) {
-    this.eventsEndpoint = new URL("/api/scenario-events", config.endpoint);
-    this.apiKey = config.apiKey ?? "";
-    if (!process.env.SCENARIO_DISABLE_SIMULATION_REPORT_INFO) {
-      if (!this.apiKey) {
-        console.log(
-          "\u27A1\uFE0F  LangWatch API key not configured, simulations will only output the final result"
-        );
-        console.log(
-          "To visualize the conversations in real time, configure your LangWatch API key (via LANGWATCH_API_KEY, or scenario.config.js)"
-        );
-      } else {
-        console.log(`simulation reporting is enabled, endpoint:(${this.eventsEndpoint}) api_key_configured:(${this.apiKey.length > 0 ? "true" : "false"})`);
-      }
-    }
-  }
-  /**
-   * Posts an event to the configured endpoint.
-   * Logs success/failure but doesn't throw - event posting shouldn't break scenario execution.
-   */
-  async postEvent(event) {
-    this.logger.debug(`[${event.type}] Posting event`, {
-      event
-    });
-    if (!this.eventsEndpoint) {
-      this.logger.warn(
-        "No LANGWATCH_ENDPOINT configured, skipping event posting"
-      );
-      return;
-    }
-    try {
-      const response = await fetch(this.eventsEndpoint.href, {
-        method: "POST",
-        body: JSON.stringify(event),
-        headers: {
-          "Content-Type": "application/json",
-          "X-Auth-Token": this.apiKey
-        }
-      });
-      this.logger.debug(
-        `[${event.type}] Event POST response status: ${response.status}`
-      );
-      if (response.ok) {
-        const data = await response.json();
-        this.logger.debug(`[${event.type}] Event POST response:`, data);
-      } else {
-        const errorText = await response.text();
-        this.logger.error(`[${event.type}] Event POST failed:`, {
-          status: response.status,
-          statusText: response.statusText,
-          error: errorText,
-          event
-        });
-      }
-    } catch (error) {
-      this.logger.error(`[${event.type}] Event POST error:`, {
-        error,
-        event,
-        endpoint: this.eventsEndpoint
-      });
-    }
-  }
-};
-
-// src/events/schema.ts
-import { EventType, MessagesSnapshotEventSchema } from "@ag-ui/core";
-import { z } from "zod";
-var Verdict = /* @__PURE__ */ ((Verdict2) => {
-  Verdict2["SUCCESS"] = "success";
-  Verdict2["FAILURE"] = "failure";
-  Verdict2["INCONCLUSIVE"] = "inconclusive";
-  return Verdict2;
-})(Verdict || {});
-var ScenarioRunStatus = /* @__PURE__ */ ((ScenarioRunStatus2) => {
-  ScenarioRunStatus2["SUCCESS"] = "SUCCESS";
-  ScenarioRunStatus2["ERROR"] = "ERROR";
-  ScenarioRunStatus2["CANCELLED"] = "CANCELLED";
-  ScenarioRunStatus2["IN_PROGRESS"] = "IN_PROGRESS";
-  ScenarioRunStatus2["PENDING"] = "PENDING";
-  ScenarioRunStatus2["FAILED"] = "FAILED";
-  return ScenarioRunStatus2;
-})(ScenarioRunStatus || {});
-var baseEventSchema = z.object({
-  type: z.nativeEnum(EventType),
-  timestamp: z.number(),
-  rawEvent: z.any().optional()
-});
-var batchRunIdSchema = z.string();
-var scenarioRunIdSchema = z.string();
-var scenarioIdSchema = z.string();
-var baseScenarioEventSchema = baseEventSchema.extend({
-  batchRunId: batchRunIdSchema,
-  scenarioId: scenarioIdSchema,
-  scenarioRunId: scenarioRunIdSchema,
-  scenarioSetId: z.string().optional().default("default")
-});
-var scenarioRunStartedSchema = baseScenarioEventSchema.extend({
-  type: z.literal("SCENARIO_RUN_STARTED" /* RUN_STARTED */),
-  metadata: z.object({
-    name: z.string().optional(),
-    description: z.string().optional()
-  })
-});
-var scenarioResultsSchema = z.object({
-  verdict: z.nativeEnum(Verdict),
-  reasoning: z.string().optional(),
-  metCriteria: z.array(z.string()),
-  unmetCriteria: z.array(z.string()),
-  error: z.string().optional()
-});
-var scenarioRunFinishedSchema = baseScenarioEventSchema.extend({
-  type: z.literal("SCENARIO_RUN_FINISHED" /* RUN_FINISHED */),
-  status: z.nativeEnum(ScenarioRunStatus),
-  results: scenarioResultsSchema.optional().nullable()
-});
-var scenarioMessageSnapshotSchema = MessagesSnapshotEventSchema.merge(
-  baseScenarioEventSchema.extend({
-    type: z.literal("SCENARIO_MESSAGE_SNAPSHOT" /* MESSAGE_SNAPSHOT */)
-  })
-);
-var scenarioEventSchema = z.discriminatedUnion("type", [
-  scenarioRunStartedSchema,
-  scenarioRunFinishedSchema,
-  scenarioMessageSnapshotSchema
-]);
-var successSchema = z.object({ success: z.boolean() });
-var errorSchema = z.object({ error: z.string() });
-var stateSchema = z.object({
-  state: z.object({
-    messages: z.array(z.any()),
-    status: z.string()
-  })
-});
-var runsSchema = z.object({ runs: z.array(z.string()) });
-var eventsSchema = z.object({ events: z.array(scenarioEventSchema) });
-
-// src/events/event-bus.ts
-var EventBus = class _EventBus {
-  static registry = /* @__PURE__ */ new Set();
-  events$ = new Subject();
-  eventReporter;
-  processingPromise = null;
-  logger = new Logger("scenario.events.EventBus");
-  static globalListeners = [];
-  constructor(config) {
-    this.eventReporter = new EventReporter(config);
-    _EventBus.registry.add(this);
-    for (const listener of _EventBus.globalListeners) {
-      listener(this);
-    }
-  }
-  static getAllBuses() {
-    return _EventBus.registry;
-  }
-  static addGlobalListener(listener) {
-    _EventBus.globalListeners.push(listener);
-  }
-  /**
-   * Publishes an event into the processing pipeline.
-   */
-  publish(event) {
-    this.logger.debug(`[${event.type}] Publishing event`, {
-      event
-    });
-    this.events$.next(event);
-  }
-  /**
-   * Begins listening for and processing events.
-   * Returns a promise that resolves when a RUN_FINISHED event is fully processed.
-   */
-  listen() {
-    this.logger.debug("Listening for events");
-    if (this.processingPromise) {
-      return this.processingPromise;
-    }
-    this.processingPromise = new Promise((resolve, reject) => {
-      this.events$.pipe(
-        concatMap(async (event) => {
-          this.logger.debug(`[${event.type}] Processing event`, {
-            event
-          });
-          await this.eventReporter.postEvent(event);
-          return event;
-        }),
-        catchError((error) => {
-          this.logger.error("Error in event stream:", error);
-          return EMPTY;
-        })
-      ).subscribe({
-        next: (event) => {
-          this.logger.debug(`[${event.type}] Event processed`, {
-            event
-          });
-          if (event.type === "SCENARIO_RUN_FINISHED" /* RUN_FINISHED */) {
-            resolve();
-          }
-        },
-        error: (error) => {
-          this.logger.error("Error in event stream:", error);
-          reject(error);
-        }
-      });
-    });
-    return this.processingPromise;
-  }
-  /**
-   * Stops accepting new events and drains the processing queue.
-   */
-  async drain() {
-    this.logger.debug("Draining event stream");
-    this.events$.complete();
-    if (this.processingPromise) {
-      await this.processingPromise;
-    }
-  }
-  /**
-   * Subscribes to an event stream.
-   * @param source$ - The event stream to subscribe to.
-   */
-  subscribeTo(source$) {
-    this.logger.debug("Subscribing to event stream");
-    return source$.subscribe(this.events$);
-  }
-  /**
-   * Expose the events$ observable for external subscription (read-only).
-   */
-  get eventsObservable() {
-    return this.events$.asObservable();
-  }
-};
-
-export {
-  Logger,
-  EventBus
-};