langwatch 0.11.0 → 0.12.0

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { L as Logger, C as ConsoleLogger, N as NoOpLogger } from './index-D7rKIGrO.mjs';
-export { F as FilterableBatchSpanProcessor, L as LangWatchExporter, S as SpanProcessingExcludeRule, g as getLangWatchLogger, d as getLangWatchTracer } from './implementation-CVrmD0bz.mjs';
-import { p as paths, P as PromptResponse, g as CreatePromptBody, U as UpdatePromptBody, h as PromptData, i as Prompt, F as FetchPolicy, L as LangWatchSpan } from './types-Kts5RGLY.mjs';
+export { F as FilterableBatchSpanProcessor, L as LangWatchExporter, S as SpanProcessingExcludeRule, g as getLangWatchLogger, d as getLangWatchTracer } from './implementation-Ck58nRkT.mjs';
+import { p as paths, P as PromptResponse, g as CreatePromptBody, U as UpdatePromptBody, h as PromptData, i as Prompt, F as FetchPolicy, L as LangWatchSpan } from './types-5h2Im4pl.mjs';
 import openApiCreateClient from 'openapi-fetch';
 import { z } from 'zod';
 export { l as attributes } from './types-DRiQaKFG.mjs';
@@ -810,10 +810,87 @@ declare class Evaluation {
     private getSpanIdFromContext;
 }
 
+/**
+ * Types for platform-configured evaluations (Evaluations V3)
+ */
+/**
+ * Summary of a completed evaluation run
+ */
+type EvaluationRunSummary = {
+    runId?: string;
+    totalCells?: number;
+    completedCells?: number;
+    failedCells?: number;
+    duration?: number;
+    runUrl?: string;
+    timestamps?: {
+        startedAt: number;
+        finishedAt?: number;
+        stoppedAt?: number;
+    };
+    targets?: Array<{
+        targetId: string;
+        name: string;
+        passed: number;
+        failed: number;
+        avgLatency: number;
+        totalCost: number;
+    }>;
+    evaluators?: Array<{
+        evaluatorId: string;
+        name: string;
+        passed: number;
+        failed: number;
+        passRate: number;
+        avgScore?: number;
+    }>;
+    totalPassed?: number;
+    totalFailed?: number;
+    passRate?: number;
+    totalCost?: number;
+};
+/**
+ * Options for running a platform evaluation
+ */
+type RunEvaluationOptions = {
+    /**
+     * Polling interval in milliseconds (default: 2000)
+     */
+    pollInterval?: number;
+    /**
+     * Maximum time to wait for completion in milliseconds (default: 600000 = 10 minutes)
+     */
+    timeout?: number;
+    /**
+     * Callback for progress updates
+     */
+    onProgress?: (progress: number, total: number) => void;
+};
+/**
+ * Final result of a platform evaluation run
+ */
+type EvaluationRunResult = {
+    runId: string;
+    status: "completed" | "failed" | "stopped";
+    passed: number;
+    failed: number;
+    passRate: number;
+    duration: number;
+    runUrl: string;
+    summary: EvaluationRunSummary;
+    /**
+     * Print a CI-friendly summary of the results
+     * @param exitOnFailure - If true (default), calls process.exit(1) when there are failures
+     */
+    printSummary: (exitOnFailure?: boolean) => void;
+};
+
 /**
  * EvaluationFacade - Entry point for the evaluation API
  *
- * Provides the `init()` method to create evaluation sessions.
+ * Provides:
+ * - `init()` method to create evaluation sessions (SDK-defined evaluations)
+ * - `run()` method to execute platform-configured evaluations (Evaluations V3)
  */
 
 type EvaluationFacadeConfig = {
@@ -823,13 +900,13 @@ type EvaluationFacadeConfig = {
     logger: Logger;
 };
 /**
- * Facade for creating evaluation sessions
+ * Facade for creating evaluation sessions and running platform-configured evaluations
  */
 declare class EvaluationFacade {
     private readonly config;
     constructor(config: EvaluationFacadeConfig);
     /**
-     * Initialize a new evaluation session
+     * Initialize a new evaluation session (SDK-defined)
      *
      * @param name - Name of the experiment (used as slug)
      * @param options - Optional configuration
@@ -846,6 +923,53 @@ declare class EvaluationFacade {
      * ```
      */
     init(name: string, options?: EvaluationInitOptions): Promise<Evaluation>;
+    /**
+     * Run a platform-configured evaluation (Evaluations V3)
+     *
+     * This runs an evaluation 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 evaluation (found in the evaluation URL)
+     * @param options - Optional configuration
+     * @returns The evaluation results including pass rate and summary
+     *
+     * @example
+     * ```typescript
+     * import { LangWatch } from "langwatch";
+     *
+     * const langwatch = new LangWatch();
+     *
+     * const result = await langwatch.evaluation.run("my-evaluation-slug");
+     * result.printSummary();
+     * ```
+     */
+    run(slug: string, options?: RunEvaluationOptions): Promise<EvaluationRunResult>;
+    /**
+     * Run an evaluation and wait for completion using polling
+     */
+    private runWithPolling;
+    /**
+     * Start an evaluation run
+     */
+    private startRun;
+    /**
+     * Get the status of a run
+     */
+    private getRunStatus;
+    /**
+     * Build the result object from API response
+     */
+    private buildResult;
+    /**
+     * Print a CI-friendly summary of the evaluation results
+     */
+    private printSummary;
+    private sleep;
+    /**
+     * Replace the domain of a URL with a new base URL, preserving the path
+     */
+    private replaceUrlDomain;
 }
 
 /**

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { L as Logger, C as ConsoleLogger, N as NoOpLogger } from './index-D7rKIGrO.js';
-export { F as FilterableBatchSpanProcessor, L as LangWatchExporter, S as SpanProcessingExcludeRule, g as getLangWatchLogger, d as getLangWatchTracer } from './implementation-CPxv2BdW.js';
-import { p as paths, P as PromptResponse, g as CreatePromptBody, U as UpdatePromptBody, h as PromptData, i as Prompt, F as FetchPolicy, L as LangWatchSpan } from './types-usU5mTCX.js';
+export { F as FilterableBatchSpanProcessor, L as LangWatchExporter, S as SpanProcessingExcludeRule, g as getLangWatchLogger, d as getLangWatchTracer } from './implementation-Bnc8Aymq.js';
+import { p as paths, P as PromptResponse, g as CreatePromptBody, U as UpdatePromptBody, h as PromptData, i as Prompt, F as FetchPolicy, L as LangWatchSpan } from './types-fo-Ij9pl.js';
 import openApiCreateClient from 'openapi-fetch';
 import { z } from 'zod';
 export { l as attributes } from './types-DRiQaKFG.js';
@@ -810,10 +810,87 @@ declare class Evaluation {
     private getSpanIdFromContext;
 }
 
+/**
+ * Types for platform-configured evaluations (Evaluations V3)
+ */
+/**
+ * Summary of a completed evaluation run
+ */
+type EvaluationRunSummary = {
+    runId?: string;
+    totalCells?: number;
+    completedCells?: number;
+    failedCells?: number;
+    duration?: number;
+    runUrl?: string;
+    timestamps?: {
+        startedAt: number;
+        finishedAt?: number;
+        stoppedAt?: number;
+    };
+    targets?: Array<{
+        targetId: string;
+        name: string;
+        passed: number;
+        failed: number;
+        avgLatency: number;
+        totalCost: number;
+    }>;
+    evaluators?: Array<{
+        evaluatorId: string;
+        name: string;
+        passed: number;
+        failed: number;
+        passRate: number;
+        avgScore?: number;
+    }>;
+    totalPassed?: number;
+    totalFailed?: number;
+    passRate?: number;
+    totalCost?: number;
+};
+/**
+ * Options for running a platform evaluation
+ */
+type RunEvaluationOptions = {
+    /**
+     * Polling interval in milliseconds (default: 2000)
+     */
+    pollInterval?: number;
+    /**
+     * Maximum time to wait for completion in milliseconds (default: 600000 = 10 minutes)
+     */
+    timeout?: number;
+    /**
+     * Callback for progress updates
+     */
+    onProgress?: (progress: number, total: number) => void;
+};
+/**
+ * Final result of a platform evaluation run
+ */
+type EvaluationRunResult = {
+    runId: string;
+    status: "completed" | "failed" | "stopped";
+    passed: number;
+    failed: number;
+    passRate: number;
+    duration: number;
+    runUrl: string;
+    summary: EvaluationRunSummary;
+    /**
+     * Print a CI-friendly summary of the results
+     * @param exitOnFailure - If true (default), calls process.exit(1) when there are failures
+     */
+    printSummary: (exitOnFailure?: boolean) => void;
+};
+
 /**
  * EvaluationFacade - Entry point for the evaluation API
  *
- * Provides the `init()` method to create evaluation sessions.
+ * Provides:
+ * - `init()` method to create evaluation sessions (SDK-defined evaluations)
+ * - `run()` method to execute platform-configured evaluations (Evaluations V3)
  */
 
 type EvaluationFacadeConfig = {
@@ -823,13 +900,13 @@ type EvaluationFacadeConfig = {
     logger: Logger;
 };
 /**
- * Facade for creating evaluation sessions
+ * Facade for creating evaluation sessions and running platform-configured evaluations
  */
 declare class EvaluationFacade {
     private readonly config;
     constructor(config: EvaluationFacadeConfig);
     /**
-     * Initialize a new evaluation session
+     * Initialize a new evaluation session (SDK-defined)
      *
      * @param name - Name of the experiment (used as slug)
      * @param options - Optional configuration
@@ -846,6 +923,53 @@ declare class EvaluationFacade {
      * ```
      */
     init(name: string, options?: EvaluationInitOptions): Promise<Evaluation>;
+    /**
+     * Run a platform-configured evaluation (Evaluations V3)
+     *
+     * This runs an evaluation 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 evaluation (found in the evaluation URL)
+     * @param options - Optional configuration
+     * @returns The evaluation results including pass rate and summary
+     *
+     * @example
+     * ```typescript
+     * import { LangWatch } from "langwatch";
+     *
+     * const langwatch = new LangWatch();
+     *
+     * const result = await langwatch.evaluation.run("my-evaluation-slug");
+     * result.printSummary();
+     * ```
+     */
+    run(slug: string, options?: RunEvaluationOptions): Promise<EvaluationRunResult>;
+    /**
+     * Run an evaluation and wait for completion using polling
+     */
+    private runWithPolling;
+    /**
+     * Start an evaluation run
+     */
+    private startRun;
+    /**
+     * Get the status of a run
+     */
+    private getRunStatus;
+    /**
+     * Build the result object from API response
+     */
+    private buildResult;
+    /**
+     * Print a CI-friendly summary of the evaluation results
+     */
+    private printSummary;
+    private sleep;
+    /**
+     * Replace the domain of a URL with a new base URL, preserving the path
+     */
+    private replaceUrlDomain;
 }
 
 /**

package/dist/index.js

@@ -5,7 +5,7 @@
 
 
 
-var _chunkD4H6PR6Hjs = require('./chunk-D4H6PR6H.js');
+var _chunk6SSCBYJMjs = require('./chunk-6SSCBYJM.js');
 
 
 var _chunkASTAIRXGjs = require('./chunk-ASTAIRXG.js');
@@ -16,12 +16,12 @@ var _chunkONXIZKC6js = require('./chunk-ONXIZKC6.js');
 
 
 
-var _chunkJQYW7RY7js = require('./chunk-JQYW7RY7.js');
+var _chunkBQRUUTN3js = require('./chunk-BQRUUTN3.js');
 
 
 
 
-var _chunkN7PJJMU2js = require('./chunk-N7PJJMU2.js');
+var _chunkC4XUWCQRjs = require('./chunk-C4XUWCQR.js');
 
 
 
@@ -943,13 +943,53 @@ var Evaluation = class _Evaluation {
   }
 };
 
+// src/client-sdk/services/evaluation/platformErrors.ts
+var EvaluationsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EvaluationsError";
+  }
+};
+var EvaluationNotFoundError = class extends EvaluationsError {
+  constructor(slug) {
+    super(`Evaluation not found: ${slug}`);
+    this.name = "EvaluationNotFoundError";
+  }
+};
+var EvaluationTimeoutError = class extends EvaluationsError {
+  constructor(runId, progress, total) {
+    super(`Evaluation run timed out: ${runId} (${progress}/${total} completed)`);
+    this.name = "EvaluationTimeoutError";
+    this.runId = runId;
+    this.progress = progress;
+    this.total = total;
+  }
+};
+var EvaluationRunFailedError = class extends EvaluationsError {
+  constructor(runId, errorMessage) {
+    super(`Evaluation run failed: ${errorMessage}`);
+    this.name = "EvaluationRunFailedError";
+    this.runId = runId;
+    this.errorMessage = errorMessage;
+  }
+};
+var EvaluationsApiError = class extends EvaluationsError {
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "EvaluationsApiError";
+    this.statusCode = statusCode;
+  }
+};
+
 // src/client-sdk/services/evaluation/evaluation.facade.ts
+var DEFAULT_POLL_INTERVAL = 2e3;
+var DEFAULT_TIMEOUT = 6e5;
 var EvaluationFacade = class {
   constructor(config) {
     this.config = config;
   }
   /**
-   * Initialize a new evaluation session
+   * Initialize a new evaluation session (SDK-defined)
    *
    * @param name - Name of the experiment (used as slug)
    * @param options - Optional configuration
@@ -973,6 +1013,240 @@ var EvaluationFacade = class {
       logger: this.config.logger
     }, options));
   }
+  /**
+   * Run a platform-configured evaluation (Evaluations V3)
+   *
+   * This runs an evaluation 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 evaluation (found in the evaluation URL)
+   * @param options - Optional configuration
+   * @returns The evaluation results including pass rate and summary
+   *
+   * @example
+   * ```typescript
+   * import { LangWatch } from "langwatch";
+   *
+   * const langwatch = new LangWatch();
+   *
+   * const result = await langwatch.evaluation.run("my-evaluation-slug");
+   * result.printSummary();
+   * ```
+   */
+  async run(slug, options) {
+    this.config.logger.info(`Running platform evaluation: ${slug}`);
+    const result = await this.runWithPolling(slug, options);
+    return result;
+  }
+  /**
+   * Run an evaluation 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 evaluation 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 EvaluationTimeoutError(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 EvaluationRunFailedError(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 evaluation 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 EvaluationNotFoundError(slug);
+      }
+      if (status === 401) {
+        throw new EvaluationsApiError("Unauthorized - check your API key", 401);
+      }
+      const errorMessage = "error" in response.error ? response.error.error : `Failed to start evaluation: ${slug}`;
+      throw new EvaluationsApiError(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 EvaluationsApiError(`Run not found: ${runId}`, 404);
+      }
+      if (status === 401) {
+        throw new EvaluationsApiError("Unauthorized - check your API key", 401);
+      }
+      const errorMessage = "error" in response.error ? response.error.error : `Failed to get run status: ${runId}`;
+      throw new EvaluationsApiError(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, _g;
+    const totalCells = (_a = summary.totalCells) != null ? _a : 0;
+    const completedCells = (_b = summary.completedCells) != null ? _b : 0;
+    const failedCells = (_c = summary.failedCells) != null ? _c : 0;
+    const duration = (_d = summary.duration) != null ? _d : 0;
+    const totalPassed = (_e = summary.totalPassed) != null ? _e : completedCells - failedCells;
+    const totalFailed = (_f = summary.totalFailed) != null ? _f : failedCells;
+    const passRate = (_g = summary.passRate) != null ? _g : 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 evaluation results
+   */
+  printSummary(result) {
+    const { runId, status, passed, failed, passRate, duration, runUrl, summary } = result;
+    console.log("\n" + "\u2550".repeat(60));
+    console.log("  EVALUATION 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/traces/types.ts
@@ -986,13 +1260,13 @@ var TracesError = class extends Error {
 };
 
 // src/client-sdk/services/traces/tracing/tracer.ts
-var tracer = _chunkONXIZKC6js.getLangWatchTracer.call(void 0, `${_chunkN7PJJMU2js.LANGWATCH_SDK_NAME_CLIENT}.traces`, _chunkN7PJJMU2js.LANGWATCH_SDK_VERSION);
+var tracer = _chunkONXIZKC6js.getLangWatchTracer.call(void 0, `${_chunkC4XUWCQRjs.LANGWATCH_SDK_NAME_CLIENT}.traces`, _chunkC4XUWCQRjs.LANGWATCH_SDK_VERSION);
 
 // src/client-sdk/services/traces/service.ts
 var TracesService = class {
   constructor(config) {
     this.config = config;
-    return _chunkD4H6PR6Hjs.createTracingProxy.call(void 0, 
+    return _chunk6SSCBYJMjs.createTracingProxy.call(void 0, 
       this,
       tracer
     );
@@ -1055,15 +1329,15 @@ var LangWatch = class {
     _chunkOHM7JUMRjs.__privateAdd.call(void 0, this, _LangWatch_instances);
     var _a, _b, _c, _d;
     const apiKey = (_b = (_a = options.apiKey) != null ? _a : process.env.LANGWATCH_API_KEY) != null ? _b : "";
-    const endpoint = (_d = (_c = options.endpoint) != null ? _c : process.env.LANGWATCH_ENDPOINT) != null ? _d : _chunkN7PJJMU2js.DEFAULT_ENDPOINT;
+    const endpoint = (_d = (_c = options.endpoint) != null ? _c : process.env.LANGWATCH_ENDPOINT) != null ? _d : _chunkC4XUWCQRjs.DEFAULT_ENDPOINT;
     this.config = _chunkOHM7JUMRjs.__privateMethod.call(void 0, this, _LangWatch_instances, createInternalConfig_fn).call(this, {
       apiKey,
       endpoint,
       options: options.options
     });
-    this.prompts = new (0, _chunkD4H6PR6Hjs.PromptsFacade)(_chunkOHM7JUMRjs.__spreadValues.call(void 0, {
-      promptsApiService: new (0, _chunkD4H6PR6Hjs.PromptsApiService)(this.config),
-      localPromptsService: new (0, _chunkD4H6PR6Hjs.LocalPromptsService)()
+    this.prompts = new (0, _chunk6SSCBYJMjs.PromptsFacade)(_chunkOHM7JUMRjs.__spreadValues.call(void 0, {
+      promptsApiService: new (0, _chunk6SSCBYJMjs.PromptsApiService)(this.config),
+      localPromptsService: new (0, _chunk6SSCBYJMjs.LocalPromptsService)()
     }, this.config));
     this.traces = new TracesFacade(this.config);
     this.evaluation = new EvaluationFacade({
@@ -1090,7 +1364,7 @@ createInternalConfig_fn = function({
   var _a;
   return {
     logger: (_a = options == null ? void 0 : options.logger) != null ? _a : new (0, _chunk5MQQRSVMjs.NoOpLogger)(),
-    langwatchApiClient: _chunkD4H6PR6Hjs.createLangWatchApiClient.call(void 0, apiKey, endpoint),
+    langwatchApiClient: _chunk6SSCBYJMjs.createLangWatchApiClient.call(void 0, apiKey, endpoint),
     endpoint,
     apiKey
   };
@@ -1117,5 +1391,5 @@ var logger = {
 
 
 
-exports.Evaluation = Evaluation; exports.EvaluationApiError = EvaluationApiError; exports.EvaluationError = EvaluationError; exports.EvaluationFacade = EvaluationFacade; exports.EvaluationInitError = EvaluationInitError; exports.EvaluatorError = EvaluatorError; exports.FetchPolicy = _chunkD4H6PR6Hjs.FetchPolicy; exports.FilterableBatchSpanProcessor = _chunkASTAIRXGjs.FilterableBatchSpanProcessor; exports.LangWatch = LangWatch; exports.LangWatchExporter = _chunkJQYW7RY7js.LangWatchTraceExporter; exports.TargetMetadataConflictError = TargetMetadataConflictError; exports.attributes = _chunk5MQQRSVMjs.attributes_exports; exports.getLangWatchLogger = _chunkJQYW7RY7js.getLangWatchLogger; exports.getLangWatchTracer = _chunkONXIZKC6js.getLangWatchTracer; exports.logger = logger;
+exports.Evaluation = Evaluation; exports.EvaluationApiError = EvaluationApiError; exports.EvaluationError = EvaluationError; exports.EvaluationFacade = EvaluationFacade; exports.EvaluationInitError = EvaluationInitError; exports.EvaluatorError = EvaluatorError; exports.FetchPolicy = _chunk6SSCBYJMjs.FetchPolicy; exports.FilterableBatchSpanProcessor = _chunkASTAIRXGjs.FilterableBatchSpanProcessor; exports.LangWatch = LangWatch; exports.LangWatchExporter = _chunkBQRUUTN3js.LangWatchTraceExporter; exports.TargetMetadataConflictError = TargetMetadataConflictError; exports.attributes = _chunk5MQQRSVMjs.attributes_exports; exports.getLangWatchLogger = _chunkBQRUUTN3js.getLangWatchLogger; exports.getLangWatchTracer = _chunkONXIZKC6js.getLangWatchTracer; exports.logger = logger;
 //# sourceMappingURL=index.js.map