langwatch 0.11.0 → 0.13.0

package/dist/index.mjs

@@ -1,3 +1,6 @@
+import {
+  ensureSetup
+} from "./chunk-OAKQ7UBU.mjs";
 import {
   FetchPolicy,
   LocalPromptsService,
@@ -5,23 +8,23 @@ import {
   PromptsFacade,
   createLangWatchApiClient,
   createTracingProxy
-} from "./chunk-WZ7FYUHN.mjs";
+} from "./chunk-J4HK6XZR.mjs";
 import {
   FilterableBatchSpanProcessor
 } from "./chunk-ZEPKV5YO.mjs";
-import {
-  createLangWatchSpan,
-  getLangWatchTracer
-} from "./chunk-IIUI2XYW.mjs";
 import {
   LangWatchTraceExporter,
   getLangWatchLogger
-} from "./chunk-556ZFJMK.mjs";
+} from "./chunk-SZRV7E6P.mjs";
 import {
   DEFAULT_ENDPOINT,
   LANGWATCH_SDK_NAME_CLIENT,
   LANGWATCH_SDK_VERSION
-} from "./chunk-LKE6DMUP.mjs";
+} from "./chunk-77XIPD42.mjs";
+import {
+  createLangWatchSpan,
+  getLangWatchTracer
+} from "./chunk-IIUI2XYW.mjs";
 import {
   ConsoleLogger,
   NoOpLogger,
@@ -147,11 +150,11 @@ var DatasetsFacade = class {
 };
 _datasetService = new WeakMap();
 
-// src/client-sdk/services/evaluation/evaluation.ts
+// src/client-sdk/services/experiments/experiment.ts
 import { AsyncLocalStorage } from "async_hooks";
 import { trace, SpanStatusCode, ROOT_CONTEXT } from "@opentelemetry/api";
 
-// src/client-sdk/services/evaluation/humanReadableId.ts
+// src/client-sdk/services/experiments/humanReadableId.ts
 var ADJECTIVES = [
   "swift",
   "bright",
@@ -265,29 +268,29 @@ var generateHumanReadableId = (separator = "-") => {
   return `${adjective1}${separator}${adjective2}${separator}${noun}`;
 };
 
-// src/client-sdk/services/evaluation/errors/evaluation.error.ts
-var EvaluationError = class extends Error {
+// src/client-sdk/services/experiments/errors/experiment.error.ts
+var ExperimentError = class extends Error {
   constructor(message) {
     super(message);
-    this.name = "EvaluationError";
+    this.name = "ExperimentError";
   }
 };
-var EvaluationInitError = class extends EvaluationError {
+var ExperimentInitError = class extends ExperimentError {
   constructor(message, cause) {
     super(message);
     this.cause = cause;
-    this.name = "EvaluationInitError";
+    this.name = "ExperimentInitError";
   }
 };
-var EvaluationApiError = class extends EvaluationError {
+var ExperimentApiError = class extends ExperimentError {
   constructor(message, statusCode, cause) {
     super(message);
     this.statusCode = statusCode;
     this.cause = cause;
-    this.name = "EvaluationApiError";
+    this.name = "ExperimentApiError";
   }
 };
-var TargetMetadataConflictError = class extends EvaluationError {
+var TargetMetadataConflictError = class extends ExperimentError {
   constructor(targetName, existingMetadata, newMetadata) {
     super(
       `Target '${targetName}' was previously registered with different metadata.
@@ -301,7 +304,7 @@ If you want to use different metadata, please use a different target name.`
     this.name = "TargetMetadataConflictError";
   }
 };
-var EvaluatorError = class extends EvaluationError {
+var EvaluatorError = class extends ExperimentError {
   constructor(evaluatorSlug, message, cause) {
     super(`Evaluator '${evaluatorSlug}' failed: ${message}`);
     this.evaluatorSlug = evaluatorSlug;
@@ -310,12 +313,12 @@ var EvaluatorError = class extends EvaluationError {
   }
 };
 
-// src/client-sdk/services/evaluation/evaluation.ts
+// src/client-sdk/services/experiments/experiment.ts
 var DEFAULT_CONCURRENCY = 4;
 var DEBOUNCE_INTERVAL_MS = 1e3;
 var iterationContextStorage = new AsyncLocalStorage();
 var targetContextStorage = new AsyncLocalStorage();
-var Evaluation = class _Evaluation {
+var Experiment = class _Experiment {
   constructor(name, options) {
     this.initialized = false;
     this.total = 0;
@@ -352,16 +355,17 @@ var Evaluation = class _Evaluation {
    * Initialize an evaluation session
    */
   static async init(name, options) {
-    const evaluation = new _Evaluation(name, options);
-    await evaluation.initialize();
-    return evaluation;
+    ensureSetup();
+    const experiment = new _Experiment(name, options);
+    await experiment.initialize();
+    return experiment;
   }
   /**
    * Initialize the evaluation by creating/getting the experiment
    */
   async initialize() {
     if (!this.apiKey) {
-      throw new EvaluationInitError(
+      throw new ExperimentInitError(
         "API key is required. Set LANGWATCH_API_KEY or pass apiKey to LangWatch constructor."
       );
     }
@@ -379,11 +383,11 @@ var Evaluation = class _Evaluation {
         })
       });
       if (response.status === 401) {
-        throw new EvaluationInitError("Invalid API key");
+        throw new ExperimentInitError("Invalid API key");
       }
       if (!response.ok) {
         const text = await response.text();
-        throw new EvaluationInitError(`Failed to initialize experiment: ${text}`);
+        throw new ExperimentInitError(`Failed to initialize experiment: ${text}`);
       }
       const data = await response.json();
       this.experimentSlug = data.slug;
@@ -391,10 +395,10 @@ var Evaluation = class _Evaluation {
       console.log(`Follow results at: ${this.endpoint}${data.path}?runId=${encodedRunId}`);
       this.initialized = true;
     } catch (error) {
-      if (error instanceof EvaluationInitError) {
+      if (error instanceof ExperimentInitError) {
         throw error;
       }
-      throw new EvaluationInitError(
+      throw new ExperimentInitError(
         `Failed to initialize evaluation: ${error instanceof Error ? error.message : String(error)}`,
         error instanceof Error ? error : void 0
       );
@@ -841,17 +845,16 @@ var Evaluation = class _Evaluation {
       name: this.name,
       run_id: this.runId,
       dataset: this.batch.dataset.map((entry) => {
-        var _a, _b, _c;
-        return {
+        var _a, _b;
+        return __spreadValues({
           index: entry.index,
           entry: entry.entry,
           duration: entry.duration,
           error: entry.error,
           trace_id: entry.trace_id,
           target_id: (_a = entry.target_id) != null ? _a : null,
-          cost: (_b = entry.cost) != null ? _b : null,
-          predicted: (_c = entry.predicted) != null ? _c : null
-        };
+          cost: (_b = entry.cost) != null ? _b : null
+        }, entry.predicted !== void 0 && entry.predicted !== null ? { predicted: entry.predicted } : {});
       }),
       evaluations: this.batch.evaluations.map((e) => ({
         name: e.name,
@@ -943,37 +946,496 @@ var Evaluation = class _Evaluation {
   }
 };
 
-// src/client-sdk/services/evaluation/evaluation.facade.ts
-var EvaluationFacade = class {
+// src/client-sdk/services/experiments/platformErrors.ts
+var ExperimentsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ExperimentsError";
+  }
+};
+var ExperimentNotFoundError = class extends ExperimentsError {
+  constructor(slug) {
+    super(`Experiment not found: ${slug}`);
+    this.name = "ExperimentNotFoundError";
+  }
+};
+var ExperimentTimeoutError = class extends ExperimentsError {
+  constructor(runId, progress, total) {
+    super(`Experiment run timed out: ${runId} (${progress}/${total} completed)`);
+    this.name = "ExperimentTimeoutError";
+    this.runId = runId;
+    this.progress = progress;
+    this.total = total;
+  }
+};
+var ExperimentRunFailedError = class extends ExperimentsError {
+  constructor(runId, errorMessage) {
+    super(`Experiment run failed: ${errorMessage}`);
+    this.name = "ExperimentRunFailedError";
+    this.runId = runId;
+    this.errorMessage = errorMessage;
+  }
+};
+var ExperimentsApiError = class extends ExperimentsError {
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "ExperimentsApiError";
+    this.statusCode = statusCode;
+  }
+};
+
+// src/client-sdk/services/experiments/experiments.facade.ts
+var DEFAULT_POLL_INTERVAL = 2e3;
+var DEFAULT_TIMEOUT = 6e5;
+var ExperimentsFacade = class {
   constructor(config) {
     this.config = config;
   }
   /**
-   * Initialize a new evaluation session
+   * Initialize a new experiment session (SDK-defined)
    *
    * @param name - Name of the experiment (used as slug)
    * @param options - Optional configuration
-   * @returns An initialized Evaluation instance
+   * @returns An initialized Experiment instance
    *
    * @example
    * ```typescript
-   * const evaluation = await langwatch.evaluation.init('my-experiment');
+   * const experiment = await langwatch.experiments.init('my-experiment');
    *
-   * await evaluation.run(dataset, async ({ item, index }) => {
+   * await experiment.run(dataset, async ({ item, index }) => {
    *   const response = await myAgent(item.question);
-   *   evaluation.log('accuracy', { index, score: 0.95 });
+   *   experiment.log('accuracy', { index, score: 0.95 });
    * });
    * ```
    */
   async init(name, options) {
-    return Evaluation.init(name, __spreadValues({
+    return Experiment.init(name, __spreadValues({
       apiClient: this.config.langwatchApiClient,
       endpoint: this.config.endpoint,
       apiKey: this.config.apiKey,
       logger: this.config.logger
     }, options));
   }
+  /**
+   * Run a platform-configured experiment (Experiments Workbench)
+   *
+   * This runs an experiment that was configured in the LangWatch platform.
+   * The method automatically prints a summary and exits with code 1 on failure
+   * (unless `exitOnFailure: false` is passed).
+   *
+   * @param slug - The slug of the experiment (found in the experiment URL)
+   * @param options - Optional configuration
+   * @returns The experiment results including pass rate and summary
+   *
+   * @example
+   * ```typescript
+   * import { LangWatch } from "langwatch";
+   *
+   * const langwatch = new LangWatch();
+   *
+   * const result = await langwatch.experiments.run("my-experiment-slug");
+   * result.printSummary();
+   * ```
+   */
+  async run(slug, options) {
+    this.config.logger.info(`Running platform experiment: ${slug}`);
+    const result = await this.runWithPolling(slug, options);
+    return result;
+  }
+  /**
+   * Run an experiment and wait for completion using polling
+   */
+  async runWithPolling(slug, options = {}) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const pollInterval = (_a = options.pollInterval) != null ? _a : DEFAULT_POLL_INTERVAL;
+    const timeout = (_b = options.timeout) != null ? _b : DEFAULT_TIMEOUT;
+    const startResponse = await this.startRun(slug);
+    const { runId } = startResponse;
+    const apiRunUrl = (_c = startResponse.runUrl) != null ? _c : "";
+    const runUrl = apiRunUrl ? this.replaceUrlDomain(apiRunUrl, this.config.endpoint) : "";
+    console.log(`Started experiment run: ${runId}`);
+    if (runUrl) {
+      console.log(`Follow live: ${runUrl}`);
+    }
+    const total = startResponse.total;
+    let lastProgress = 0;
+    if (total > 0) {
+      process.stdout.write(`Progress: 0/${total} (0%)`);
+    }
+    (_d = options.onProgress) == null ? void 0 : _d.call(options, 0, total);
+    const startTime = Date.now();
+    while (true) {
+      if (Date.now() - startTime > timeout) {
+        console.log();
+        const finalStatus = await this.getRunStatus(runId);
+        throw new ExperimentTimeoutError(runId, finalStatus.progress, finalStatus.total);
+      }
+      await this.sleep(pollInterval);
+      const status = await this.getRunStatus(runId);
+      const progress = status.progress;
+      if (progress !== lastProgress && status.total > 0) {
+        const percentage = Math.round(progress / status.total * 100);
+        process.stdout.write(`\rProgress: ${progress}/${status.total} (${percentage}%)`);
+        lastProgress = progress;
+      }
+      (_e = options.onProgress) == null ? void 0 : _e.call(options, status.progress, status.total);
+      if (status.status === "completed") {
+        console.log();
+        const summary = status.summary;
+        return this.buildResult(runId, "completed", summary, runUrl != null ? runUrl : "");
+      }
+      if (status.status === "failed") {
+        console.log();
+        throw new ExperimentRunFailedError(runId, (_f = status.error) != null ? _f : "Unknown error");
+      }
+      if (status.status === "stopped") {
+        console.log();
+        return this.buildResult(runId, "stopped", (_g = status.summary) != null ? _g : {
+          runId,
+          totalCells: status.total,
+          completedCells: status.progress,
+          failedCells: 0,
+          duration: Date.now() - startTime
+        }, runUrl != null ? runUrl : "");
+      }
+    }
+  }
+  /**
+   * Start an experiment run
+   */
+  async startRun(slug) {
+    const response = await this.config.langwatchApiClient.POST(
+      "/api/evaluations/v3/{slug}/run",
+      {
+        params: {
+          path: { slug }
+        }
+      }
+    );
+    if (response.error) {
+      const status = response.response.status;
+      if (status === 404) {
+        throw new ExperimentNotFoundError(slug);
+      }
+      if (status === 401) {
+        throw new ExperimentsApiError("Unauthorized - check your API key", 401);
+      }
+      const errorMessage = "error" in response.error ? response.error.error : `Failed to start experiment: ${slug}`;
+      throw new ExperimentsApiError(errorMessage != null ? errorMessage : `HTTP ${status}`, status);
+    }
+    return response.data;
+  }
+  /**
+   * Get the status of a run
+   */
+  async getRunStatus(runId) {
+    const response = await this.config.langwatchApiClient.GET(
+      "/api/evaluations/v3/runs/{runId}",
+      {
+        params: {
+          path: { runId }
+        }
+      }
+    );
+    if (response.error) {
+      const status = response.response.status;
+      if (status === 404) {
+        throw new ExperimentsApiError(`Run not found: ${runId}`, 404);
+      }
+      if (status === 401) {
+        throw new ExperimentsApiError("Unauthorized - check your API key", 401);
+      }
+      const errorMessage = "error" in response.error ? response.error.error : `Failed to get run status: ${runId}`;
+      throw new ExperimentsApiError(errorMessage != null ? errorMessage : `HTTP ${status}`, status);
+    }
+    return response.data;
+  }
+  /**
+   * Build the result object from API response
+   */
+  buildResult(runId, status, summary, runUrl) {
+    var _a, _b, _c, _d, _e, _f;
+    const completedCells = (_a = summary.completedCells) != null ? _a : 0;
+    const failedCells = (_b = summary.failedCells) != null ? _b : 0;
+    const duration = (_c = summary.duration) != null ? _c : 0;
+    const totalPassed = (_d = summary.totalPassed) != null ? _d : completedCells - failedCells;
+    const totalFailed = (_e = summary.totalFailed) != null ? _e : failedCells;
+    const passRate = (_f = summary.passRate) != null ? _f : completedCells > 0 ? totalPassed / completedCells * 100 : 0;
+    return {
+      runId,
+      status,
+      passed: totalPassed,
+      failed: totalFailed,
+      passRate,
+      duration,
+      runUrl,
+      // Always use the endpoint-based URL we constructed
+      summary,
+      printSummary: (exitOnFailure = true) => {
+        var _a2;
+        this.printSummary({
+          runId,
+          status,
+          passed: totalPassed,
+          failed: totalFailed,
+          passRate,
+          duration,
+          runUrl: (_a2 = summary.runUrl) != null ? _a2 : runUrl,
+          summary
+        });
+        if (exitOnFailure && totalFailed > 0) {
+          process.exit(1);
+        }
+      }
+    };
+  }
+  /**
+   * Print a CI-friendly summary of the experiment results
+   */
+  printSummary(result) {
+    const { runId, status, passed, failed, passRate, duration, runUrl, summary } = result;
+    console.log("\n" + "\u2550".repeat(60));
+    console.log("  EXPERIMENT RESULTS");
+    console.log("\u2550".repeat(60));
+    console.log(`  Run ID:     ${runId}`);
+    console.log(`  Status:     ${status.toUpperCase()}`);
+    console.log(`  Duration:   ${(duration / 1e3).toFixed(1)}s`);
+    console.log("\u2500".repeat(60));
+    console.log(`  Passed:     ${passed}`);
+    console.log(`  Failed:     ${failed}`);
+    console.log(`  Pass Rate:  ${passRate.toFixed(1)}%`);
+    if (summary.targets && summary.targets.length > 0) {
+      console.log("\u2500".repeat(60));
+      console.log("  TARGETS:");
+      for (const target of summary.targets) {
+        console.log(`    ${target.name}: ${target.passed} passed, ${target.failed} failed`);
+        if (target.avgLatency) {
+          console.log(`      Avg latency: ${target.avgLatency.toFixed(0)}ms`);
+        }
+        if (target.totalCost) {
+          console.log(`      Total cost: $${target.totalCost.toFixed(4)}`);
+        }
+      }
+    }
+    if (summary.evaluators && summary.evaluators.length > 0) {
+      console.log("\u2500".repeat(60));
+      console.log("  EVALUATORS:");
+      for (const evaluator of summary.evaluators) {
+        console.log(
+          `    ${evaluator.name}: ${evaluator.passRate.toFixed(1)}% pass rate`
+        );
+        if (evaluator.avgScore !== void 0) {
+          console.log(`      Avg score: ${evaluator.avgScore.toFixed(2)}`);
+        }
+      }
+    }
+    console.log("\u2500".repeat(60));
+    console.log(`  View details: ${runUrl}`);
+    console.log("\u2550".repeat(60) + "\n");
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Replace the domain of a URL with a new base URL, preserving the path
+   */
+  replaceUrlDomain(url, newBase) {
+    if (!url) return url;
+    try {
+      const parsedUrl = new URL(url);
+      const parsedNewBase = new URL(newBase);
+      return `${parsedNewBase.origin}${parsedUrl.pathname}${parsedUrl.search}${parsedUrl.hash}`;
+    } catch (e) {
+      return url;
+    }
+  }
+};
+
+// src/client-sdk/services/evaluations/evaluations.facade.ts
+import { trace as trace2, SpanStatusCode as SpanStatusCode2, context as otelContext } from "@opentelemetry/api";
+
+// src/client-sdk/services/evaluations/errors.ts
+var EvaluationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EvaluationError";
+  }
+};
+var EvaluatorCallError = class extends EvaluationError {
+  constructor(evaluatorSlug, message, statusCode) {
+    super(`Evaluator '${evaluatorSlug}' failed: ${message}`);
+    this.name = "EvaluatorCallError";
+    this.evaluatorSlug = evaluatorSlug;
+    this.statusCode = statusCode;
+  }
+};
+var EvaluatorNotFoundError = class extends EvaluationError {
+  constructor(evaluatorSlug) {
+    super(`Evaluator not found: ${evaluatorSlug}`);
+    this.name = "EvaluatorNotFoundError";
+    this.evaluatorSlug = evaluatorSlug;
+  }
+};
+var EvaluationsApiError = class extends EvaluationError {
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "EvaluationsApiError";
+    this.statusCode = statusCode;
+  }
+};
+
+// src/client-sdk/services/evaluations/evaluations.facade.ts
+var _endpoint, _apiKey, _logger;
+var EvaluationsFacade = class {
+  constructor(config) {
+    __privateAdd(this, _endpoint);
+    __privateAdd(this, _apiKey);
+    __privateAdd(this, _logger);
+    /**
+     * Run an evaluator or guardrail against provided data
+     *
+     * Creates an OpenTelemetry span attached to the current trace context,
+     * calls the LangWatch evaluation API, and returns the result.
+     *
+     * @param slug - The evaluator slug (e.g., "presidio/pii_detection", "langevals/llm_boolean")
+     * @param options - Evaluation options including data, name, settings, and asGuardrail flag
+     * @returns The evaluation result with status, passed, score, details, label, and cost
+     *
+     * @example
+     * ```typescript
+     * // Run as a guardrail (synchronous evaluation that can block responses)
+     * const guardrail = await langwatch.evaluations.evaluate("presidio/pii_detection", {
+     *   data: { input: userInput, output: generatedResponse },
+     *   name: "PII Detection Guardrail",
+     *   asGuardrail: true,
+     * });
+     *
+     * if (!guardrail.passed) {
+     *   console.log("PII detected:", guardrail.details);
+     *   return "Sorry, I cannot process that request.";
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Run as an online evaluation (async scoring for monitoring)
+     * const result = await langwatch.evaluations.evaluate("langevals/llm_boolean", {
+     *   data: { input: question, output: response },
+     *   name: "Quality Check",
+     *   settings: { prompt: "Check if the response answers the question." },
+     * });
+     *
+     * console.log("Score:", result.score);
+     * console.log("Details:", result.details);
+     * ```
+     */
+    this.evaluate = async (slug, options) => {
+      var _a;
+      const { data, name, settings, asGuardrail } = options;
+      const spanName = name != null ? name : slug;
+      const spanType = asGuardrail ? "guardrail" : "evaluation";
+      const tracer2 = trace2.getTracer("langwatch-evaluations");
+      const activeSpan = trace2.getActiveSpan();
+      const traceId = activeSpan ? activeSpan.spanContext().traceId : void 0;
+      const parentSpanId = activeSpan ? activeSpan.spanContext().spanId : void 0;
+      const otelSpan = tracer2.startSpan(
+        spanName,
+        {
+          attributes: {
+            "langwatch.span.type": spanType
+          }
+        },
+        otelContext.active()
+      );
+      const langwatchSpan = createLangWatchSpan(otelSpan);
+      langwatchSpan.setType(spanType);
+      langwatchSpan.setInput(__spreadValues({
+        data
+      }, settings && { settings }));
+      try {
+        const requestBody = {
+          trace_id: traceId != null ? traceId : null,
+          span_id: parentSpanId != null ? parentSpanId : null,
+          name: name != null ? name : null,
+          data,
+          settings,
+          as_guardrail: asGuardrail
+        };
+        const url = `${__privateGet(this, _endpoint)}/api/evaluations/${slug}/evaluate`;
+        __privateGet(this, _logger).debug(`Calling evaluation API: ${url}`);
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-Auth-Token": __privateGet(this, _apiKey)
+          },
+          body: JSON.stringify(requestBody)
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          if (response.status === 404) {
+            throw new EvaluatorNotFoundError(slug);
+          }
+          throw new EvaluationsApiError(
+            `Evaluation API returned ${response.status}: ${errorText}`,
+            response.status
+          );
+        }
+        const responseData = await response.json();
+        const result = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
+          status: responseData.status
+        }, responseData.passed !== null && responseData.passed !== void 0 && { passed: responseData.passed }), responseData.score !== null && responseData.score !== void 0 && { score: responseData.score }), responseData.details !== null && responseData.details !== void 0 && { details: responseData.details }), responseData.label !== null && responseData.label !== void 0 && { label: responseData.label }), responseData.cost !== null && responseData.cost !== void 0 && { cost: responseData.cost });
+        langwatchSpan.setOutput({
+          type: asGuardrail ? "guardrail_result" : "evaluation_result",
+          value: result
+        });
+        if (result.status === "error") {
+          otelSpan.setStatus({
+            code: SpanStatusCode2.ERROR,
+            message: (_a = result.details) != null ? _a : "Evaluation failed"
+          });
+        } else {
+          otelSpan.setStatus({ code: SpanStatusCode2.OK });
+        }
+        return result;
+      } catch (error) {
+        const errorResult = {
+          status: "error",
+          details: error instanceof Error ? error.message : String(error)
+        };
+        if (asGuardrail) {
+          errorResult.passed = true;
+        }
+        langwatchSpan.setOutput({
+          type: asGuardrail ? "guardrail_result" : "evaluation_result",
+          value: errorResult
+        });
+        otelSpan.setStatus({
+          code: SpanStatusCode2.ERROR,
+          message: errorResult.details
+        });
+        if (error instanceof Error) {
+          otelSpan.recordException(error);
+        }
+        if (error instanceof EvaluatorNotFoundError || error instanceof EvaluationsApiError || error instanceof EvaluatorCallError) {
+          throw error;
+        }
+        throw new EvaluatorCallError(
+          slug,
+          error instanceof Error ? error.message : String(error)
+        );
+      } finally {
+        otelSpan.end();
+      }
+    };
+    __privateSet(this, _endpoint, config.endpoint);
+    __privateSet(this, _apiKey, config.apiKey);
+    __privateSet(this, _logger, config.logger);
+  }
 };
+_endpoint = new WeakMap();
+_apiKey = new WeakMap();
+_logger = new WeakMap();
 
 // src/client-sdk/services/traces/types.ts
 var TracesError = class extends Error {
@@ -1066,7 +1528,7 @@ var LangWatch = class {
       localPromptsService: new LocalPromptsService()
     }, this.config));
     this.traces = new TracesFacade(this.config);
-    this.evaluation = new EvaluationFacade({
+    this.experiments = new ExperimentsFacade({
       langwatchApiClient: this.config.langwatchApiClient,
       endpoint: this.config.endpoint,
       apiKey: this.config.apiKey,
@@ -1076,6 +1538,11 @@ var LangWatch = class {
       langwatchApiClient: this.config.langwatchApiClient,
       logger: this.config.logger
     });
+    this.evaluations = new EvaluationsFacade({
+      endpoint: this.config.endpoint,
+      apiKey: this.config.apiKey,
+      logger: this.config.logger
+    });
   }
   get apiClient() {
     return this.config.langwatchApiClient;
@@ -1102,12 +1569,17 @@ var logger = {
   NoOpLogger
 };
 export {
-  Evaluation,
-  EvaluationApiError,
   EvaluationError,
-  EvaluationFacade,
-  EvaluationInitError,
+  EvaluationsApiError,
+  EvaluationsFacade,
+  EvaluatorCallError,
   EvaluatorError,
+  EvaluatorNotFoundError,
+  Experiment,
+  ExperimentApiError,
+  ExperimentError,
+  ExperimentInitError,
+  ExperimentsFacade,
   FetchPolicy,
   FilterableBatchSpanProcessor,
   LangWatch,