langwatch 1.19.0 → 2.0.0

package/dist/index.d.ts

@@ -1,18 +1,18 @@
 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, a as getLangWatchTracer } from './implementation-CsQrexpY.js';
+export { F as FilterableBatchSpanProcessor, L as LangWatchExporter, S as SpanProcessingExcludeRule, g as getLangWatchLogger, a as getLangWatchTracer } from './implementation-DJ-JveZl.js';
 import { z } from 'zod';
-import { p as paths, P as PromptResponse, C as CreatePromptBody, U as UpdatePromptBody, T as TagDefinition, a as CreatedTag, o as operations, b as PromptData, F as FetchPolicy, c as Prompt, L as LangWatchSpan, d as components } from './types-wuYJPoFb.js';
 import openApiCreateClient from 'openapi-fetch';
-export { l as attributes } from './types-VOZv9LYO.js';
-import { CliHandledErrorReason, CliHandledError } from '@langwatch/langy/cards/handled-error';
-export { CliHandledErrorReason as LangWatchHandledErrorReason, CliHandledError as LangWatchHandledErrorShape } from '@langwatch/langy/cards/handled-error';
+import { p as paths, P as PromptResponse, C as CreatePromptBody, U as UpdatePromptBody, T as TagDefinition, a as CreatedTag, o as operations, b as PromptData, F as FetchPolicy, c as Prompt, L as LangWatchSpan, d as components } from './types-CpT3iEIj.js';
+export { l as attributes } from './types-CoS5PmeU.js';
+import { LangWatchHandledErrorReason, LangWatchHandledErrorShape } from '@langwatch/handled-error/langwatch-handled-error';
+export { LangWatchHandledErrorReason, LangWatchHandledErrorShape } from '@langwatch/handled-error/langwatch-handled-error';
 import '@opentelemetry/sdk-trace-base';
-import '@opentelemetry/exporter-trace-otlp-http';
 import '@opentelemetry/core';
+import '@opentelemetry/exporter-trace-otlp-proto';
+import '@opentelemetry/otlp-exporter-base';
 import '@opentelemetry/api-logs';
+import './values-1yj9l0Sa.js';
 import '@opentelemetry/api';
-import '@opentelemetry/semantic-conventions';
-import '@opentelemetry/semantic-conventions/incubating';
 
 declare const localPromptConfigSchema: z.ZodObject<{
     model: z.ZodString;
@@ -28,7 +28,7 @@ declare const localPromptConfigSchema: z.ZodObject<{
         }>;
         content: z.ZodString;
     }, z.core.$loose>>;
-    parameters: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>>;
+    parameters: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
 }, z.core.$loose>;
 type LocalPromptConfig = z.infer<typeof localPromptConfigSchema>;
 
@@ -40,10 +40,9 @@ type PromptsConfig = {
     prompts: Record<string, PromptDependency>;
 };
 /**
- * A JSON value: what runtime parameters actually persist and what the API
- * schema declares (the spec's recursive JsonValue component). Structurally
- * identical to the generated client's RecursiveJsonValue, so values flow
- * between hand-written and generated types without casts.
+ * A JSON value: what runtime parameters persist and the API schema declares.
+ * Structurally identical to the generated client's RecursiveJsonValue, so
+ * values flow between hand-written and generated types without casts.
  */
 type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
@@ -55,15 +54,15 @@ type MaterializedPrompt = {
     version: number;
     versionId: string;
     model: string;
-    messages: Array<{
+    messages: {
         role: "system" | "user" | "assistant";
         content: string;
-    }>;
+    }[];
     prompt: string;
     temperature?: number;
     maxTokens?: number;
-    inputs?: any;
-    outputs?: any;
+    inputs?: unknown;
+    outputs?: unknown;
     parameters: RuntimeParameters;
     updatedAt: string;
 };
@@ -79,13 +78,8 @@ type PromptsLock = {
 
 /**
  * Creates a new LangWatch API client.
- * @param apiKey - The API key or Personal Access Token used for authentication.
- *                 Defaults to `LANGWATCH_API_KEY`.
- * @param endpoint - The endpoint to use for the API client. Defaults to `LANGWATCH_ENDPOINT`
- *                   or the internal `DEFAULT_ENDPOINT`.
- * @param projectId - Project identifier. Required when `apiKey` is a PAT
- *                    (`pat-lw-*`). Defaults to `LANGWATCH_PROJECT_ID`.
- * @returns A new LangWatch API client.
+ * @param apiKey - The API key or Personal Access Token. Defaults to `LANGWATCH_API_KEY`.
+ * @param endpoint - The API endpoint. Defaults to `LANGWATCH_ENDPOINT` or `DEFAULT_ENDPOINT`.
  */
 declare const createLangWatchApiClient: (apiKey?: string, endpoint?: string, projectId?: string | undefined) => openApiCreateClient.Client<paths, `${string}/${string}`>;
 type LangwatchApiClient = ReturnType<typeof createLangWatchApiClient>;
@@ -103,7 +97,7 @@ declare const syncActionSchema: z.ZodEnum<{
 }>;
 type SyncAction = z.infer<typeof syncActionSchema>;
 type AssignTagResult = NonNullable<operations["putApiPromptsByIdTagsByTag"]["responses"]["200"]["content"]["application/json"]>;
-type ConfigData = NonNullable<paths["/api/prompts/{id}/sync"]["post"]["requestBody"]>["content"]["application/json"]["configData"];
+type ConfigData = NonNullable<paths["/api/v1/prompts/{id}/sync"]["post"]["requestBody"]>["content"]["application/json"]["configData"];
 interface SyncResult {
     action: SyncAction;
     prompt?: PromptResponse;
@@ -116,24 +110,16 @@ interface SyncResult {
     };
 }
 /**
- * Service for managing prompt resources via the Langwatch API.
- * Constructor creates a proxy that wraps the service and traces all methods.
- *
- * Responsibilities:
- * - CRUD operations for prompts
- * - Creating prompt versions
- * - Error handling with contextual information
- *
- * All methods return raw PromptResponse data from the API.
+ * Service for managing prompt resources via the Langwatch API. Constructor creates a proxy
+ * that wraps the service and traces all methods.
  */
 declare class PromptsApiService {
     private readonly apiClient;
     constructor(config?: Pick<InternalConfig, "langwatchApiClient">);
     /**
-     * Handles API errors by throwing a PromptsApiError with operation context.
+     * Handles API errors by throwing a PromptsApiError with operation context. @throws
      * @param operation Description of the operation being performed.
      * @param error The error object returned from the API client.
-     * @throws {PromptsApiError}
      */
     private handleApiError;
     /**
@@ -145,36 +131,28 @@ declare class PromptsApiService {
     /**
      * Fetches a single prompt by its ID.
      * @param id The prompt's unique identifier.
-     * @param options Optional parameters for the request.
-     * @param options.version Specific version to fetch (numeric string or "latest").
-     * @param options.tag Tag to fetch (e.g., "production", "staging", or a custom tag).
-     * @returns Raw PromptResponse data.
-     * @throws {PromptsApiError} If the API call fails.
+     * @param options Optional version or tag to fetch.
      */
     get: (id: string, options?: {
         version?: string;
         tag?: string;
     }) => Promise<PromptResponse>;
     /**
-     * Validates if a prompt exists.
+     * Validates if a prompt exists. @throws {PromptsApiError} If the API call fails (not 404).
      * @param id The prompt's unique identifier.
      * @returns True if prompt exists, false otherwise.
-     * @throws {PromptsApiError} If the API call fails (not 404).
      */
     exists(id: string): Promise<boolean>;
     /**
-     * Creates a new prompt.
+     * Creates a new prompt. @throws {PromptsApiError} If the API call fails.
      * @param params The prompt creation payload, matching the OpenAPI schema.
      * @returns Raw PromptResponse data of the created prompt.
-     * @throws {PromptsApiError} If the API call fails.
      */
     create(params: CreatePromptBody): Promise<PromptResponse>;
     /**
-     * Updates an existing prompt.
      * @param id The prompt's unique identifier.
      * @param params The update payload, matching the OpenAPI schema.
      * @returns Raw PromptResponse data of the updated prompt.
-     * @throws {PromptsApiError} If the API call fails.
      */
     update(id: string, params: UpdatePromptBody): Promise<PromptResponse>;
     /**
@@ -184,10 +162,9 @@ declare class PromptsApiService {
      */
     listTags(): Promise<TagDefinition[]>;
     /**
-     * Creates a custom prompt tag for the organization.
+     * Creates a custom prompt tag for the organization. @throws {PromptsApiError} If the API
      * @param params.name The tag name (must match /^[a-z][a-z0-9_-]*$/).
      * @returns The created tag.
-     * @throws {PromptsApiError} If the API call fails.
      */
     createTag({ name }: {
         name: string;
@@ -199,10 +176,9 @@ declare class PromptsApiService {
      */
     deleteTag(tagName: string): Promise<void>;
     /**
-     * Renames an existing prompt tag.
+     * Renames an existing prompt tag. @throws {PromptsApiError} If the API call fails.
      * @param tag The current tag name.
      * @param name The new tag name.
-     * @throws {PromptsApiError} If the API call fails.
      */
     renameTag({ tag, name }: {
         tag: string;
@@ -222,18 +198,15 @@ declare class PromptsApiService {
         success: boolean;
     }>;
     /**
-     * Fetches all versions for a given prompt.
+     * Fetches all versions for a given prompt. @throws {PromptsApiError} If the API call
      * @param id The prompt's unique identifier.
      * @returns Array of raw PromptResponse data for each version.
-     * @throws {PromptsApiError} If the API call fails.
      */
     getVersions(id: string): Promise<PromptResponse[]>;
     /**
-     * Upserts a prompt with local configuration - creates if doesn't exist, updates version if exists.
      * @param handle The prompt's handle/identifier.
      * @param config Local prompt configuration.
      * @returns Object with created flag and raw PromptResponse data.
-     * @throws {PromptsApiError} If the API call fails.
      */
     upsert(handle: string, config: {
         model: string;
@@ -241,10 +214,10 @@ declare class PromptsApiService {
             temperature?: number;
             max_tokens?: number;
         };
-        messages: Array<{
+        messages: {
             role: "system" | "user" | "assistant";
             content: string;
-        }>;
+        }[];
         parameters?: RuntimeParameters;
     }): Promise<{
         created: boolean;
@@ -269,15 +242,8 @@ declare class FileManager {
     private static readonly PROMPTS_DIR;
     private static readonly MATERIALIZED_DIR;
     private static _projectRoot;
-    /**
-     * The cwd `_projectRoot` was derived from.
-     *
-     * The cache MUST be keyed by it. Memoising a cwd-derived path without that key
-     * is correct only in a process that serves exactly one command and then dies;
-     * in a process that serves many from different directories (the CLI daemon, a
-     * test runner, an embedding host), the second caller silently inherits the
-     * first caller's project root and reads or writes the wrong prompts.json.
-     */
+    /** The cwd `_projectRoot` was derived from. Cache must be keyed by it or
+     * multi-directory processes like daemons will use the wrong root. */
     private static _projectRootCwd;
     /** Reset the cached project root. Tests use this to exercise different cwds. */
     static _resetProjectRootCache(): void;
@@ -320,12 +286,9 @@ interface LocalPromptsServiceConfig {
     logger?: Logger;
 }
 /**
- * Service for retrieving prompts from local filesystem sources.
- *
- * Searches for prompts in the following priority order:
- * 1. Explicit file mapping in prompts.json config
- * 2. Materialized path from prompts-lock.json
- * 3. Direct file scanning in prompts directory
+ * Retrieves prompts from local filesystem sources, in priority order:
+ * explicit prompts.json mapping, materialized prompts-lock.json path,
+ * then direct scanning of the prompts directory.
  */
 declare class LocalPromptsService {
     private readonly fileManager;
@@ -408,11 +371,7 @@ declare class PromptsFacade implements Pick<PromptsApiService, "sync" | "delete"
      */
     create(data: CreatePromptBody): Promise<Prompt>;
     /**
-     * Retrieves a prompt by handle or ID.
-     *
-     * Supports shorthand `handle:tag` syntax — e.g. `get("pizza-prompt:production")`.
-     * Shorthand is parsed server-side; the SDK passes the string through as-is.
-     *
+     * Retrieves a prompt by handle or ID (supports `handle:tag` shorthand, parsed server-side).
      * @param handleOrId The prompt's handle, unique identifier, or `handle:tag` shorthand.
      * @param options Optional parameters for the request.
      * @returns The Prompt instance.
@@ -597,8 +556,8 @@ type DeleteRecordsResponse = {
     deletedCount: number;
 };
 /**
- * API response for uploading a file.
- * Covers both upload-to-existing (records) and create-from-file (recordsCreated, datasetId) responses.
+ * API response for uploading a file. Covers both upload-to-existing
+ * (records) and create-from-file (recordsCreated, datasetId) responses.
  */
 type UploadResponse = {
     dataset?: DatasetMetadata;
@@ -618,7 +577,10 @@ type ListRecordsOptions = {
 /**
  * API response for listing records in a dataset.
  */
-type ListRecordsApiResponse = PaginatedResponse<DatasetRecordResponse>;
+type ListRecordsApiResponse = PaginatedResponse<DatasetRecordResponse> & {
+    /** The dataset the page belongs to. Absent on servers that do not send it. */
+    dataset?: DatasetMetadata;
+};
 /**
  * API response for creating a dataset from a file upload.
  */
@@ -635,91 +597,33 @@ type DatasetsFacadeConfig = {
 };
 /**
  * Facade for dataset operations in the LangWatch SDK.
- * Provides a simplified interface for managing datasets, records, and file uploads.
- *
  * @example
- * ```typescript
- * const langwatch = new LangWatch({ apiKey: "your-api-key" });
- *
- * // List all datasets
  * const datasets = await langwatch.datasets.list();
- *
- * // Get a dataset by slug or ID
- * const dataset = await langwatch.datasets.get("my-dataset");
- *
- * // Create a new dataset
- * const newDataset = await langwatch.datasets.create({
- *   name: "my-dataset",
- *   columnTypes: [{ name: "input", type: "string" }],
- * });
- *
- * // Update a dataset
- * const updated = await langwatch.datasets.update("my-dataset", { name: "new-name" });
- *
- * // Delete a dataset
- * const archived = await langwatch.datasets.delete("my-dataset");
- *
- * // Create records
- * const records = await langwatch.datasets.createRecords("my-dataset", [
- *   { input: "hello", output: "world" },
- * ]);
- *
- * // Update a record
- * const record = await langwatch.datasets.updateRecord("my-dataset", "rec-1", { input: "updated" });
- *
- * // Delete records
- * const result = await langwatch.datasets.deleteRecords("my-dataset", ["rec-1", "rec-2"]);
- *
- * // Upload a file (append to existing or create new)
- * const uploadResult = await langwatch.datasets.upload("my-dataset", file);
- *
- * // Upload with replace strategy (delete all records first)
- * await langwatch.datasets.upload("my-dataset", file, { ifExists: "replace" });
- * ```
  */
 declare class DatasetsFacade {
     #private;
     constructor(config: DatasetsFacadeConfig);
     /**
      * Lists all datasets for the project, with optional pagination.
-     *
      * @param options - Pagination options (page, limit)
      * @returns Paginated list of datasets with metadata
      */
     list: (options?: ListDatasetsOptions) => Promise<ListDatasetsApiResponse>;
     /**
      * Creates a new dataset.
-     *
      * @param options - Dataset creation options (name, columnTypes)
      * @returns The created dataset metadata
      */
     create: (options: CreateDatasetOptions) => Promise<DatasetMetadata>;
     /**
      * Fetches a dataset by its slug or ID, returning metadata and entries.
-     *
      * @param slugOrId - The slug or ID of the dataset to fetch
      * @param options - Optional configuration
      * @returns The dataset with metadata and entries
-     *
-     * @example
-     * ```typescript
-     * // Get dataset by slug
-     * const dataset = await langwatch.datasets.get("product-qa");
-     *
-     * // Typed dataset
-     * type MyDatasetEntry = { input: string; expected_output: string; };
-     * const dataset = await langwatch.datasets.get<MyDatasetEntry>("my-dataset");
-     *
-     * // Iterate over entries
-     * for (const entry of dataset.entries) {
-     *   console.log(entry.entry.input);
-     * }
-     * ```
      */
     get: <T extends Record<string, unknown> = Record<string, unknown>>(slugOrId: string, options?: GetDatasetOptions) => Promise<Dataset<T>>;
     /**
      * Updates a dataset by its slug or ID.
-     *
      * @param slugOrId - The slug or ID of the dataset to update
      * @param options - Fields to update (name, columnTypes)
      * @returns The updated dataset metadata
@@ -727,14 +631,12 @@ declare class DatasetsFacade {
     update: (slugOrId: string, options: UpdateDatasetOptions) => Promise<DatasetMetadata>;
     /**
      * Deletes (archives) a dataset by its slug or ID.
-     *
      * @param slugOrId - The slug or ID of the dataset to delete
      * @returns The archived dataset metadata
      */
     delete: (slugOrId: string) => Promise<DatasetMetadata>;
     /**
      * Creates records in a dataset in batch.
-     *
      * @param slugOrId - The slug or ID of the dataset
      * @param entries - Array of record entries to create
      * @returns The created records with IDs
@@ -742,7 +644,6 @@ declare class DatasetsFacade {
     createRecords: (slugOrId: string, entries: Record<string, unknown>[]) => Promise<BatchCreateRecordsResponse>;
     /**
      * Updates a single record in a dataset.
-     *
      * @param slugOrId - The slug or ID of the dataset
      * @param recordId - The ID of the record to update
      * @param entry - The updated entry data
@@ -751,7 +652,6 @@ declare class DatasetsFacade {
     updateRecord: (slugOrId: string, recordId: string, entry: Record<string, unknown>) => Promise<DatasetRecordResponse>;
     /**
      * Deletes records from a dataset by IDs.
-     *
      * @param slugOrId - The slug or ID of the dataset
      * @param recordIds - Array of record IDs to delete
      * @returns Object with the count of deleted records
@@ -759,47 +659,17 @@ declare class DatasetsFacade {
     deleteRecords: (slugOrId: string, recordIds: string[]) => Promise<DeleteRecordsResponse>;
     /**
      * Lists records in a dataset with optional pagination.
-     *
      * @param slugOrId - The slug or ID of the dataset
      * @param options - Pagination options (page, limit)
      * @returns Paginated list of records
-     *
-     * @example
-     * ```typescript
-     * // List first page of records
-     * const result = await langwatch.datasets.listRecords("my-dataset");
-     *
-     * // With pagination
-     * const page2 = await langwatch.datasets.listRecords("my-dataset", { page: 2, limit: 25 });
-     * ```
      */
     listRecords: (slugOrId: string, options?: ListRecordsOptions) => Promise<ListRecordsApiResponse>;
     /**
-     * Uploads a file to a dataset with a configurable strategy for handling existing datasets.
-     *
-     * Strategies:
-     * - `"append"` (default): Upload to existing dataset; if not found, create a new one.
-     * - `"replace"`: Delete all existing records, then upload; if not found, create a new one.
-     * - `"error"`: Throw a 409 error if the dataset already exists; if not found, create a new one.
-     *
+     * Uploads a file to a dataset with a strategy for existing datasets (default "append").
      * @param slugOrId - The slug or ID of the dataset
      * @param file - The file to upload (File or Blob)
      * @param options - Upload options including the ifExists strategy
      * @returns The upload result
-     *
-     * @example
-     * ```typescript
-     * const file = new File(["input,output\nhello,world"], "data.csv", { type: "text/csv" });
-     *
-     * // Append to existing or create new
-     * await langwatch.datasets.upload("my-dataset", file);
-     *
-     * // Replace all records
-     * await langwatch.datasets.upload("my-dataset", file, { ifExists: "replace" });
-     *
-     * // Fail if dataset already exists
-     * await langwatch.datasets.upload("my-dataset", file, { ifExists: "error" });
-     * ```
      */
     upload: (slugOrId: string, file: File | Blob, options?: {
         ifExists?: "append" | "replace" | "error";
@@ -851,15 +721,12 @@ declare class DatasetPlanLimitError extends DatasetError {
 
 /**
  * Types for the Experiments API
- *
- * These types define the structure for batch experiments, including
- * logging metrics, running evaluators, and managing targets.
  */
 
 /**
  * Status of an evaluation result
  */
-type EvaluationStatus$1 = "processed" | "error" | "skipped";
+type ExperimentEvaluationStatus = "processed" | "error" | "skipped";
 /**
  * Target types for batch evaluations
  */
@@ -872,9 +739,9 @@ declare const targetInfoSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
     type: z.ZodDefault<z.ZodEnum<{
+        prompt: "prompt";
         custom: "custom";
         agent: "agent";
-        prompt: "prompt";
     }>>;
     metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>>;
 }, z.core.$strip>;
@@ -884,8 +751,8 @@ declare const evaluationResultSchema: z.ZodObject<{
     trace_id: z.ZodString;
     status: z.ZodEnum<{
         error: "error";
-        processed: "processed";
         skipped: "skipped";
+        processed: "processed";
     }>;
     data: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
@@ -906,7 +773,7 @@ type TargetInfo = z.infer<typeof targetInfoSchema>;
 /**
  * Result of an evaluation
  */
-type EvaluationResult$1 = z.infer<typeof evaluationResultSchema>;
+type ExperimentEvaluationResult = z.infer<typeof evaluationResultSchema>;
 /**
  * Options for initializing an experiment
  */
@@ -936,7 +803,7 @@ type LogOptions = {
     /** Human-readable description of the result */
     details?: string;
     /** Status of the evaluation */
-    status?: EvaluationStatus$1;
+    status?: ExperimentEvaluationStatus;
     /** Duration in milliseconds */
     duration?: number;
     /** Cost amount in USD */
@@ -954,7 +821,7 @@ type LogOptions = {
 /**
  * Options for the evaluate() method (built-in evaluators)
  */
-type EvaluateOptions$1 = {
+type ExperimentEvaluateOptions = {
     /**
      * Row index in the dataset.
      * Optional when called inside withTarget() - will be auto-inferred from context.
@@ -978,25 +845,10 @@ type EvaluateOptions$1 = {
 };
 /**
  * Per-candidate metric the judge can be asked to weigh alongside quality
- *
- * Duration is the one the SDK measures itself. Cost is not on offer: the
- * platform works a target's cost out from its traces after the run, so there
- * is nothing to show the judge at the moment a verdict is asked for.
  */
 type ComparisonMetric = "duration";
 /**
  * Outcome of a comparison
- *
- * - `decided`: the judge picked a winner
- * - `tie`: the judge judged the candidates and found none clearly better
- * - `inconclusive`: the judge judged the candidates and established no winner,
- *   which under swap-and-reconcile means its two passes disagreed. A finding
- *   about the candidates, and not a tie: a tie is a measurement, this is the
- *   absence of one
- * - `skipped`: fewer than two targets had an output, so no judge ran
- * - `error`: the judge could not be reached or failed, so nothing was measured
- *   about the candidates at all. Never conflated with `inconclusive`, which
- *   says something about them
  */
 type ComparisonStatus = "decided" | "tie" | "inconclusive" | "skipped" | "error";
 /**
@@ -1017,20 +869,10 @@ type ComparisonVerdict = {
 };
 /**
  * Options for the compare() method
- *
- * Every option below is optional because the judge already has a default for
- * it. An option left unset is absent from the request, so the judge's own
- * default applies and there is exactly one place where each default is
- * written down. The defaults are documented here for reference only, and are
- * deliberately not restated in code.
  */
 type ComparisonOptions = {
     /**
-     * Row index in the dataset. Also seeds the judge's deterministic candidate
-     * shuffle.
-     *
-     * compare() takes the row the way log() does: inside a run() callback it is
-     * inferred from the row being processed, and outside one it is required.
+     * Row index in the dataset. Also seeds the judge's deterministic candidate shuffle.
      */
     index?: number;
     /** Name the verdict is recorded under (default: "comparison") */
@@ -1130,13 +972,6 @@ type TargetResult<R> = {
 
 /**
  * Experiment - Main class for running batch experiments
- *
- * Provides a clean API for running experiments over datasets with:
- * - Automatic tracing per iteration
- * - Parallel execution with concurrency control
- * - Batched result sending
- * - Built-in evaluator support
- * - Multi-target comparison with withTarget() context isolation
  */
 
 /**
@@ -1158,6 +993,9 @@ declare class Experiment {
     private batch;
     private lastSentMs;
     private pendingFlush;
+    /** Every row and verdict sent so far, by the identity the platform stores it under. */
+    private readonly sentRows;
+    private readonly sentEvaluations;
     private flushTimeout;
     private cumulativeEvaluations;
     private cumulativeEntries;
@@ -1181,44 +1019,23 @@ declare class Experiment {
      */
     private initialize;
     /**
-     * Run evaluation over a dataset with a callback
-     *
+     * Run evaluation over a dataset with a callback.
      * @param dataset - Array of items to evaluate
      * @param callback - Function called for each item with { item, index, span }
-     * @param options - Concurrency options
-     *
-     * @example
-     * ```typescript
-     * await evaluation.run(dataset, async ({ item, index, span }) => {
-     *   const response = await myAgent(item.question);
-     *   evaluation.log('accuracy', { index, score: 0.95 });
-     * }, { concurrency: 4 });
-     * ```
      */
     run<T>(dataset: T[], callback: RunCallback<T>, options?: RunOptions): Promise<void>;
     /**
      * Execute a single item in the dataset
      */
+    /** Runs one row without a trace of its own: each withTarget() call traces itself. */
+    private runItemUntraced;
+    /** Runs one row inside its own iteration span. */
+    private runItemTraced;
     private executeItem;
     /**
-     * Log a custom metric result
-     *
      * @param metric - Name of the metric
      * @param options - Metric options including index, score, passed, etc.
-     *
-     * If called inside a withTarget() block, the target and index are automatically
-     * inferred from the context and don't need to be specified.
-     *
      * @example
-     * ```typescript
-     * // Explicit target (outside withTarget)
-     * evaluation.log('accuracy', { index, score: 0.95, target: 'gpt-4' });
-     *
-     * // Implicit target (inside withTarget)
-     * await evaluation.withTarget('gpt-4', { model: 'openai/gpt-4' }, async () => {
-     *   evaluation.log('accuracy', { score: 0.95 }); // target and index auto-inferred
-     * });
-     * ```
      */
     log(metric: string, options: LogOptions): void;
     /**
@@ -1226,145 +1043,38 @@ declare class Experiment {
      */
     private pushEvaluation;
     /**
-     * Run a built-in evaluator
-     *
      * @param evaluatorSlug - The evaluator identifier (e.g., 'ragas/faithfulness')
      * @param options - Evaluator options including data and settings
-     *
-     * If called inside a withTarget() block, the target and index are automatically
-     * inferred from the context and don't need to be specified.
-     *
      * @example
-     * ```typescript
-     * // Inside withTarget() - target and index auto-inferred
-     * await evaluation.withTarget('gpt-4', { model: 'openai/gpt-4' }, async () => {
-     *   await evaluation.evaluate('ragas/faithfulness', {
-     *     data: { input, output, contexts },
-     *   });
-     * });
-     *
-     * // Or explicit index/target
-     * await evaluation.evaluate('ragas/faithfulness', {
-     *   index,
-     *   data: { input, output, contexts },
-     *   target: 'gpt-4',
-     * });
-     * ```
-     */
-    evaluate(evaluatorSlug: string, options: EvaluateOptions$1): Promise<void>;
+     */
+    evaluate(evaluatorSlug: string, options: ExperimentEvaluateOptions): Promise<void>;
     /**
      * Call an evaluator and return its raw result
      */
     private callEvaluator;
     /**
-     * Compare a row's targets and pick the best one
-     *
-     * Every target that recorded an output for the row is judged together in a
-     * single call, and the winner comes back named with the target name you
-     * registered. Call it once the row's withTarget() calls have all settled,
-     * which under the usual Promise.all is right after the await.
-     *
-     * The verdict grades no single target, so it is recorded against the row.
-     *
-     * The row is named the way log() names it: inside a run() callback it is
-     * inferred from the row being processed, and outside one it is required.
-     *
-     * A row with fewer than two outputs cannot be compared: it is recorded as
-     * skipped, naming the targets that produced nothing, and the run carries on.
-     * A judge that fails or cannot be reached comes back as an `error` verdict
-     * for the same reason, and stays distinct from `inconclusive`, which is the
-     * judge telling you something about your candidates. Naming a target that
-     * produced no output is a different thing again, and throws, because a
-     * two-way verdict read as the three-way one you asked for is worse than a
-     * failure.
-     *
      * @param options - How the judge should read the row, and which row when
-     *                  it cannot be inferred
      * @returns The verdict, including the candidates it actually saw
-     *
      * @example
-     * ```typescript
-     * await experiment.run(dataset, async ({ item }) => {
-     *   await Promise.all([
-     *     experiment.withTarget('gpt-5-mini', () => askGpt(item.question)),
-     *     experiment.withTarget('claude-sonnet-5', () => askClaude(item.question)),
-     *   ]);
-     *
-     *   const verdict = await experiment.compare({ input: item.question });
-     *   console.log(verdict.winner);
-     * });
-     * ```
      */
     compare(options?: ComparisonOptions): Promise<ComparisonVerdict>;
     /**
      * The row a comparison is about
-     *
-     * Inferred from the row being processed, the same way withTarget() and
-     * log() infer theirs, so a comparison inside a run() callback never repeats
-     * an index the SDK already has. It reads that row from the iteration's own
-     * context, which is what keeps a run of many rows at once from handing one
-     * row's comparison the row a neighbour happens to be on.
-     *
-     * What it deliberately does not do is fall back to a row: judging row 0
-     * because no row was named would hand back a confident verdict about
-     * candidates the caller never asked about.
      */
     private resolveComparisonRow;
     /**
      * Record a comparison verdict against the row
-     *
-     * The verdict the caller is handed is the only input, so the row can never
-     * say one thing while the return value says another.
-     *
-     * Deliberately not routed through log(): a comparison grades no single
-     * target, so it must not pick one up from an ambient withTarget() context,
-     * and it is recorded under the judge's own evaluator id so the results page
-     * can tell it apart from a hand-logged metric.
      */
     private recordComparison;
     /**
-     * Execute code within a target context with automatic tracing
-     *
-     * Creates a new span for this target execution and sets up context
-     * so that log() calls inside the callback automatically use this target.
-     * Duration and output are captured automatically.
-     *
-     * This creates a dataset entry per target (like Evaluations V3), enabling
-     * proper per-target latency and cost tracking.
-     *
+     * Execute code within a target context with automatic tracing.
      * @param targetName - Unique identifier for the target
-     * @param metadata - Optional metadata for comparison (e.g., { model: 'gpt-4' })
      * @param callback - Function to execute within the target context
-     * @returns The callback result along with captured metrics
-     *
-     * @example
-     * ```typescript
-     * await evaluation.run(dataset, async ({ item, index }) => {
-     *   // Compare GPT-4 and Claude on the same input
-     *   const [gpt4Result, claudeResult] = await Promise.all([
-     *     evaluation.withTarget('gpt-4', { model: 'openai/gpt-4' }, async () => {
-     *       const response = await openai.chat(item.question);
-     *       evaluation.log('quality', { score: 0.95 }); // target auto-inferred
-     *       return response;
-     *     }),
-     *     evaluation.withTarget('claude-3', { model: 'anthropic/claude-3' }, async () => {
-     *       const response = await anthropic.messages(item.question);
-     *       evaluation.log('quality', { score: 0.85 }); // target auto-inferred
-     *       return response;
-     *     }),
-     *   ]);
-     * });
-     * ```
      */
     withTarget<R>(targetName: string, metadata: TargetMetadata | null, callback: TargetCallback<R>): Promise<TargetResult<R>>;
     withTarget<R>(targetName: string, callback: TargetCallback<R>): Promise<TargetResult<R>>;
     /**
      * Keep a target's output for the row so compare() can reach it later
-     *
-     * The batch this output also went into is flushed on a timer and cleared, so
-     * a comparison that read its candidates from there would find them missing
-     * whenever the flush landed first. A target that produced nothing is not
-     * captured at all: it has no output to judge.
      */
     private captureTargetOutput;
     /**
@@ -1377,27 +1087,19 @@ declare class Experiment {
     private scheduleSend;
     /**
      * Print a CI-friendly summary and optionally exit with code 1 on failure.
-     *
-     * Mirrors `ExperimentRunResult.printSummary` for parity — SDK-driven experiments
-     * can now fail CI builds the same way platform experiments do.
-     *
      * @param exitOnFailure - If true (default), calls `process.exit(1)` when any evaluation failed.
-     *
      * @example
-     * ```typescript
-     * const experiment = await langwatch.experiments.init("ci-quality-check");
-     * await experiment.run(dataset, async ({ item, index }) => {
-     *   const response = await myLLM(item.input);
-     *   await experiment.evaluate("ragas/faithfulness", { index, data: { input: item.input, output: response } });
-     * });
-     * experiment.printSummary();
-     * ```
      */
     printSummary(exitOnFailure?: boolean): void;
     /**
      * Send current batch to the API
      */
     private sendBatch;
+    /**
+     * Posts one log_results request. A request the server refuses as too large is cut in two
+     * and sent again. When a single entry is refused, the error names it and its size.
+     */
+    private postLogResults;
     /**
      * Flush all pending data
      */
@@ -1434,22 +1136,22 @@ type ExperimentRunSummary = {
         finishedAt?: number;
         stoppedAt?: number;
     };
-    targets?: Array<{
+    targets?: {
         targetId: string;
         name: string;
         passed: number;
         failed: number;
         avgLatency: number;
         totalCost: number;
-    }>;
-    evaluators?: Array<{
+    }[];
+    evaluators?: {
         evaluatorId: string;
         name: string;
         passed: number;
         failed: number;
         passRate: number;
         avgScore?: number;
-    }>;
+    }[];
     totalPassed?: number;
     totalFailed?: number;
     passRate?: number;
@@ -1474,16 +1176,14 @@ type RunExperimentOptions = {
 };
 /**
  * Inputs that override a platform experiment or workflow run on the server.
- *
- * `data` and `datasetId` are mutually exclusive (the backend rejects passing
- * both). `parameters` overrides target parameters (e.g. prompt variables) and
- * `rowIndices` restricts execution to a subset of the configured dataset.
+ * `data`/`datasetId` are mutually exclusive (backend rejects both).
+ * `parameters` overrides target params; `rowIndices` subsets the dataset.
  */
 type RunWithResultsOptions = {
     /**
      * Inline rows to evaluate. Mutually exclusive with `datasetId`.
      */
-    data?: Array<Record<string, unknown>>;
+    data?: Record<string, unknown>[];
     /**
      * Id of a saved dataset to evaluate. Mutually exclusive with `data`.
      */
@@ -1578,10 +1278,6 @@ type ExperimentRunResult = {
 
 /**
  * ExperimentsFacade - Entry point for the experiments API
- *
- * Provides:
- * - `init()` method to create experiment sessions (SDK-defined experiments)
- * - `run()` method to execute platform-configured experiments (Experiments Workbench)
  */
 
 type ExperimentsFacadeConfig = {
@@ -1598,68 +1294,21 @@ declare class ExperimentsFacade {
     private readonly apiService;
     constructor(config: ExperimentsFacadeConfig);
     /**
-     * Initialize a new experiment session (SDK-defined)
-     *
+     * Initialize a new experiment session (SDK-defined).
      * @param name - Name of the experiment (used as slug)
      * @param options - Optional configuration
-     * @returns An initialized Experiment instance
-     *
-     * @example
-     * ```typescript
-     * const experiment = await langwatch.experiments.init('my-experiment');
-     *
-     * await experiment.run(dataset, async ({ item, index }) => {
-     *   const response = await myAgent(item.question);
-     *   experiment.log('accuracy', { index, score: 0.95 });
-     * });
-     * ```
      */
     init(name: string, options?: ExperimentInitOptions): Promise<Experiment>;
     /**
-     * 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).
-     *
+     * Run a platform-configured experiment (Experiments Workbench). Prints a
+     * summary and exits with code 1 on failure, unless `exitOnFailure: false`.
      * @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();
-     * ```
      */
     run(slug: string, options?: RunExperimentOptions): Promise<ExperimentRunResult>;
     /**
      * Run a platform experiment and return per-row structured results.
-     *
-     * Starts the run through the unified evaluations-v3 backend (optionally
-     * overriding the configured inputs via `data` / `datasetId` / `parameters` /
-     * `rowIndices`), polls to completion, fetches the per-row results, and maps
-     * them to the same row structure as the python SDK's results DataFrame.
-     *
      * @param slug - The slug of the experiment (found in the experiment URL)
      * @param options - Optional inputs and polling configuration
-     * @returns The run id, results URL, status, summary, and per-row results
-     *
-     * @example
-     * ```typescript
-     * const langwatch = new LangWatch();
-     * const { rows, runUrl } = await langwatch.experiments.runWithResults(
-     *   "my-experiment-slug",
-     *   { data: [{ question: "What is 2 + 2?" }] },
-     * );
-     * for (const row of rows) {
-     *   console.log(row.output, row.evaluations);
-     * }
-     * ```
      */
     runWithResults(slug: string, options?: RunWithResultsOptions): Promise<ExperimentRunWithResults>;
     /**
@@ -1717,11 +1366,9 @@ declare class TargetMetadataConflictError extends ExperimentError {
     constructor(targetName: string, existingMetadata: Record<string, unknown>, newMetadata: Record<string, unknown>);
 }
 /**
- * Thrown when a comparison cannot produce a verdict the caller asked for
- *
- * A row that is simply too thin to judge is skipped instead, so this is
- * reserved for a mismatch between what the caller named and what the run
- * actually recorded.
+ * Thrown when a comparison cannot produce a verdict the caller asked for.
+ * A too-thin-to-judge row is skipped instead -- this is reserved for a
+ * mismatch between what the caller named and what the run recorded.
  */
 declare class ComparisonError extends ExperimentError {
     readonly missingTargets: string[];
@@ -1736,12 +1383,7 @@ declare class EvaluatorError extends ExperimentError {
     constructor(evaluatorSlug: string, message: string, cause?: Error | undefined);
 }
 
-/**
- * Types for the Evaluations API (Online Evaluations / Guardrails)
- *
- * These types define the structure for running evaluators and guardrails
- * in real-time against LLM inputs/outputs.
- */
+/** Types for the Evaluations API: running evaluators/guardrails in real time against LLM I/O. */
 /**
  * Status of an evaluation result
  */
@@ -1785,26 +1427,9 @@ type EvaluateOptions = {
 };
 
 /**
- * EvaluationsFacade - Entry point for the Evaluations API (Online Evaluations / Guardrails)
- *
- * Provides an API for running evaluators and guardrails in real-time against LLM inputs/outputs.
- *
+ * EvaluationsFacade - Entry point for the Evaluations API (Online Evaluations /
+ * Guardrails)
  * @example
- * ```typescript
- * const langwatch = new LangWatch({ apiKey: "your-api-key" });
- *
- * // Run a guardrail
- * const guardrail = await langwatch.evaluations.evaluate("presidio/pii_detection", {
- *   data: { input: userInput, output: generatedResponse },
- *   name: "PII Detection",
- *   asGuardrail: true,
- *   settings: {},
- * });
- *
- * if (!guardrail.passed) {
- *   return "I'm sorry, I can't do that.";
- * }
- * ```
  */
 
 type EvaluationsFacadeConfig = {
@@ -1816,42 +1441,9 @@ declare class EvaluationsFacade {
     #private;
     constructor(config: EvaluationsFacadeConfig);
     /**
-     * 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.
-     *
+     * Run an evaluator or guardrail against provided data.
      * @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);
-     * ```
      */
     evaluate: (slug: string, options: EvaluateOptions) => Promise<EvaluationResult>;
 }
@@ -1888,14 +1480,14 @@ declare class EvaluationsApiError extends EvaluationError {
     constructor(message: string, statusCode: number);
 }
 
-type EvaluatorResponse = NonNullable<paths["/api/evaluators"]["get"]["responses"]["200"]["content"]["application/json"]>[number] & {
+type EvaluatorResponse = NonNullable<paths["/api/v1/evaluators"]["get"]["responses"]["200"]["content"]["application/json"]>[number] & {
     /** URL to view this evaluator on the LangWatch platform */
     platformUrl?: string;
 };
 type EvaluatorField = EvaluatorResponse["fields"][number];
-type CreateEvaluatorBody = NonNullable<paths["/api/evaluators"]["post"]["requestBody"]>["content"]["application/json"];
-type UpdateEvaluatorBody = NonNullable<paths["/api/evaluators/{id}"]["put"]["requestBody"]>["content"]["application/json"];
-type DeleteEvaluatorResponse = paths["/api/evaluators/{id}"]["delete"]["responses"]["200"]["content"]["application/json"];
+type CreateEvaluatorBody = NonNullable<paths["/api/v1/evaluators"]["post"]["requestBody"]>["content"]["application/json"];
+type UpdateEvaluatorBody = NonNullable<paths["/api/v1/evaluators/{id}"]["put"]["requestBody"]>["content"]["application/json"];
+type DeleteEvaluatorResponse = paths["/api/v1/evaluators/{id}"]["delete"]["responses"]["200"]["content"]["application/json"];
 
 /**
  * Service for retrieving evaluator resources via the LangWatch API.
@@ -1934,15 +1526,15 @@ declare class EvaluatorsApiError extends Error {
     constructor(message: string, operation: string, originalError?: unknown | undefined);
 }
 
-type ScenarioResponse = NonNullable<paths["/api/scenarios"]["get"]["responses"]["200"]["content"]["application/json"]>[number] & {
+type ScenarioResponse = NonNullable<paths["/api/v1/scenarios"]["get"]["responses"]["200"]["content"]["application/json"]>[number] & {
     /** URL to view this scenario on the LangWatch platform */
     platformUrl?: string;
 };
-type CreateScenarioBody = NonNullable<paths["/api/scenarios"]["post"]["requestBody"]>["content"]["application/json"];
-type UpdateScenarioBody = NonNullable<paths["/api/scenarios/{id}"]["put"]["requestBody"]>["content"]["application/json"];
-type DeleteScenarioResponse = paths["/api/scenarios/{id}"]["delete"]["responses"]["200"]["content"]["application/json"];
-type ScenarioVersionListResponse = paths["/api/scenarios/{id}/versions"]["get"]["responses"]["200"]["content"]["application/json"];
-type ScenarioVersionDetail = paths["/api/scenarios/{id}/versions/{version}"]["get"]["responses"]["200"]["content"]["application/json"];
+type CreateScenarioBody = NonNullable<paths["/api/v1/scenarios"]["post"]["requestBody"]>["content"]["application/json"];
+type UpdateScenarioBody = NonNullable<paths["/api/v1/scenarios/{id}"]["put"]["requestBody"]>["content"]["application/json"];
+type DeleteScenarioResponse = paths["/api/v1/scenarios/{id}"]["delete"]["responses"]["200"]["content"]["application/json"];
+type ScenarioVersionListResponse = paths["/api/v1/scenarios/{id}/versions"]["get"]["responses"]["200"]["content"]["application/json"];
+type ScenarioVersionDetail = paths["/api/v1/scenarios/{id}/versions/{version}"]["get"]["responses"]["200"]["content"]["application/json"];
 
 declare class ScenariosApiService {
     private readonly apiClient;
@@ -1962,19 +1554,19 @@ declare class ScenariosApiService {
     delete(id: string): Promise<DeleteScenarioResponse>;
 }
 
-type SuiteResponse = NonNullable<paths["/api/suites"]["get"]["responses"]["200"]["content"]["application/json"]>[number] & {
+type SuiteResponse = NonNullable<paths["/api/v1/suites"]["get"]["responses"]["200"]["content"]["application/json"]>[number] & {
     /** URL to view this suite on the LangWatch platform */
     platformUrl?: string;
 };
-type CreateSuiteBody = NonNullable<paths["/api/suites"]["post"]["requestBody"]>["content"]["application/json"];
-type UpdateSuiteBody = NonNullable<paths["/api/suites/{id}"]["patch"]["requestBody"]>["content"]["application/json"];
-type SuiteRunResult = paths["/api/suites/{id}/run"]["post"]["responses"]["200"]["content"]["application/json"];
-/** Options for `POST /api/suites/{id}/run`. */
+type CreateSuiteBody = NonNullable<paths["/api/v1/suites"]["post"]["requestBody"]>["content"]["application/json"];
+type UpdateSuiteBody = NonNullable<paths["/api/v1/suites/{id}"]["patch"]["requestBody"]>["content"]["application/json"];
+type SuiteRunResult = paths["/api/v1/suites/{id}/run"]["post"]["responses"]["200"]["content"]["application/json"];
+/** Options for `POST /api/v1/suites/{id}/run`. */
 interface SuiteRunOptions {
     /**
-     * Key that makes the request safe to retry. Generated per call when omitted,
-     * so two retries of the same command schedule two runs unless the caller
-     * pins one.
+     * Makes the run safe to retry: the same key on a second call joins the batch
+     * the first started. Omitted, no key is sent and every call schedules its own
+     * run. Pin one per logical run, never per attempt.
      */
     idempotencyKey?: string;
     /**
@@ -1993,7 +1585,7 @@ interface SuiteRunOptions {
 /** Which kind of suite `getAll` returns. Defaults to run plans. */
 type SuiteKind = "custom" | "folder";
 /**
- * @deprecated Use runPlans and testSuites; /api/suites is a frozen alias.
+ * @deprecated Use runPlans and testSuites; /api/v1/suites is a frozen alias.
  */
 declare class SuitesApiService {
     private readonly apiClient;
@@ -2028,12 +1620,6 @@ type RunPlanRunResult = paths["/api/v1/run-plans/run"]["post"]["responses"]["200
 type RunPlanRerunBody = NonNullable<paths["/api/v1/run-plans/{id}/run"]["post"]["requestBody"]>["content"]["application/json"];
 /**
  * Typed client for the run plan family (`/api/v1/run-plans`).
- *
- * A run plan is identified by its NAME. Posting a configuration under a name
- * already in use replaces that plan's configuration and joins its history;
- * posting under a new name creates the plan; posting no name lets the platform
- * derive one from what the run covers and what it runs against.
- *
  * @see specs/typescript-sdk/run-plans-and-test-suites.feature
  */
 declare class RunPlansApiService {
@@ -2047,9 +1633,6 @@ declare class RunPlansApiService {
     get(id: string): Promise<RunPlan>;
     /**
      * Runs a configuration under a name.
-     *
-     * A note of only spaces is no note: sending an empty string would store a
-     * value every reader then has to filter out.
      */
     run(body: RunPlanRunBody): Promise<RunPlanRunResult>;
     /** Runs a plan again with the configuration it already holds. */
@@ -2073,16 +1656,10 @@ type InstantEvalJudgment = InstantEvalResultsPage["judgments"][number];
 /** A few of a run's rows, with the judged text beside the verdict. */
 type InstantEvalSample = paths["/api/v1/instant-evals/{id}/sample"]["get"]["responses"]["200"]["content"]["application/json"];
 /**
- * Typed client for the Instant Evals family (`/api/v1/instant-evals`).
- *
- * A run judges one LangWatchQL statement across the project's history. The
- * statement is the same one the query door runs, so a working query is a
- * working run once it projects `TraceId` and at least one eval function
- * column. Starting one answers the queued run, and its progress is polled.
- *
- * The project comes from the credential, so no method takes a project id.
- *
- * @see specs/instant-evals/instant-eval-api.feature
+ * Typed client for Instant Evals (`/api/v1/instant-evals`): a run judges one LangWatchQL statement
+ * that projects `TraceId` and an eval column. Progress is polled; the project comes from the
+ * credential.
+ * @see modules/instant-eval/specs/instant-eval-api.feature
  */
 declare class InstantEvalsApiService {
     private readonly apiClient;
@@ -2108,10 +1685,8 @@ declare class InstantEvalsApiService {
     /** Asks a run to stop. It stops before its next page. */
     cancel(id: string): Promise<InstantEvalRun>;
     /**
-     * One page of a run's judgements.
-     *
-     * Pass the `nextCursor` a page answers with to read the page after it. The
-     * last page carries none.
+     * One page of a run's judgements. Pass the `nextCursor` a page answers with to read the page
+     * after it. The last page carries none.
      */
     results(id: string, options?: {
         questionId?: string;
@@ -2145,11 +1720,6 @@ type RunTestSuiteBody = NonNullable<paths["/api/v1/test-suites/{id}/run"]["post"
 type TestSuiteRunResult = RunPlanRunResult;
 /**
  * Typed client for the test suite family (`/api/v1/test-suites`).
- *
- * A test suite is a group of scenarios: a name, and the scenarios filed in it.
- * It holds no targets and no configuration, so running one sends its targets with
- * the request and the platform files the run under a run plan.
- *
  * @see specs/typescript-sdk/run-plans-and-test-suites.feature
  */
 declare class TestSuitesApiService {
@@ -2182,8 +1752,8 @@ declare class TestSuitesApiService {
     run(id: string, body: RunTestSuiteBody): Promise<TestSuiteRunResult>;
 }
 
-type WorkflowResponse = NonNullable<paths["/api/workflows"]["get"]["responses"]["200"]["content"]["application/json"]>[number];
-type WorkflowDeleteResponse = paths["/api/workflows/{id}"]["delete"]["responses"]["200"]["content"]["application/json"];
+type WorkflowResponse = NonNullable<paths["/api/v1/workflows"]["get"]["responses"]["200"]["content"]["application/json"]>[number];
+type WorkflowDeleteResponse = paths["/api/v1/workflows/{id}"]["delete"]["responses"]["200"]["content"]["application/json"];
 declare class WorkflowsApiService {
     private readonly apiClient;
     private readonly experimentsApiService;
@@ -2198,25 +1768,8 @@ declare class WorkflowsApiService {
     delete(id: string): Promise<WorkflowDeleteResponse>;
     /**
      * Run a studio workflow evaluation and return per-row structured results.
-     *
-     * Starts the evaluation through the unified evaluations-v3 backend
-     * (`POST /api/workflows/{workflowId}/evaluate`), polls to completion, fetches
-     * the per-row results, and maps them to the same row structure as the python
-     * SDK's results DataFrame.
-     *
      * @param workflowId - The studio workflow id
-     * @param options - Optional inputs, committed version override, and polling
-     *                   configuration. `data` and `datasetId` are mutually
-     *                   exclusive.
-     * @returns The run id, results URL, status, summary, and per-row results
-     *
-     * @example
-     * ```typescript
-     * const langwatch = new LangWatch();
-     * const { rows, runUrl } = await langwatch.workflows.run("workflow_123", {
-     *   data: [{ question: "What is 2 + 2?" }],
-     * });
-     * ```
+     * @param options - Optional inputs and polling configuration
      */
     run(workflowId: string, options?: RunWithResultsOptions & {
         versionId?: string;
@@ -2316,16 +1869,19 @@ declare class AgentsApiService {
      */
     call(id: string, body: AgentCallBody): Promise<AgentCallResponse>;
     /**
-     * Runs one scripted scenario against an agent: the user sends "ping", the
-     * agent answers, and the run succeeds when the answer arrives. The project
-     * gains no scenario, run plan or test suite, and the answer carries the run
-     * ids to follow.
+     * Runs one scripted scenario against an agent: the user sends "ping", the agent answers,
+     * and the run succeeds when the answer arrives. The project gains no scenario, run plan or
+     * test suite, and the answer carries the run ids to follow.
      */
     test(id: string): Promise<AgentTestRunResponse>;
 }
 
 type AnnotationResponse = components["schemas"]["Annotation"];
-type CreateAnnotationBody = NonNullable<paths["/api/annotations/trace/{id}"]["post"]["requestBody"]>["content"]["application/json"];
+type CreateAnnotationBody = NonNullable<paths["/api/v1/annotations/trace/{id}"]["post"]["requestBody"]>["content"]["application/json"];
+type DeleteAnnotationResponse = {
+    status?: string;
+    message?: string;
+};
 declare class AnnotationsApiService {
     private readonly apiClient;
     constructor(config?: Pick<InternalConfig, "langwatchApiClient">);
@@ -2334,13 +1890,76 @@ declare class AnnotationsApiService {
     get(id: string): Promise<AnnotationResponse>;
     getByTrace(traceId: string): Promise<AnnotationResponse[]>;
     create(traceId: string, params: CreateAnnotationBody): Promise<AnnotationResponse>;
-    delete(id: string): Promise<{
-        status?: string;
-        message?: string;
+    delete(id: string): Promise<DeleteAnnotationResponse>;
+}
+
+type Json<T> = T extends {
+    content: {
+        "application/json": infer Body;
+    };
+} ? Body : never;
+/** A dashboard as `/api/v1/dashboards/{dashboardId}` answers it. */
+type Dashboard = Json<paths["/api/v1/dashboards/{dashboardId}"]["get"]["responses"]["200"]>;
+/** One row of the dashboards list, with its widget count. */
+type DashboardListItem = Json<paths["/api/v1/dashboards"]["get"]["responses"]["200"]>["data"][number];
+/** A widget on a dashboard, as the dashboard's widget routes answer it. */
+type DashboardWidget = Json<paths["/api/v1/dashboards/{dashboardId}/widgets/{widgetId}"]["get"]["responses"]["200"]>;
+/** What creating a widget on a dashboard submits. */
+type CreateDashboardWidgetInput = NonNullable<paths["/api/v1/dashboards/{dashboardId}/widgets"]["post"]["requestBody"]>["content"]["application/json"];
+/** What updating a widget on a dashboard submits; a field left out keeps its value. */
+type UpdateDashboardWidgetInput = NonNullable<paths["/api/v1/dashboards/{dashboardId}/widgets/{widgetId}"]["patch"]["requestBody"]>["content"]["application/json"];
+/**
+ * Typed client for `/api/v1/dashboards`: the key's project's dashboards and the widgets on them.
+ * The project comes from the API key; while Dashboards is off the routes answer 404.
+ */
+declare class DashboardsApiService {
+    private readonly apiClient;
+    constructor(config?: Pick<InternalConfig, "langwatchApiClient">);
+    private handleApiError;
+    list(): Promise<{
+        data: DashboardListItem[];
+    }>;
+    get(dashboardId: string): Promise<Dashboard>;
+    create({ name }: {
+        name: string;
+    }): Promise<Dashboard>;
+    /** `description: null` clears it; a field left out keeps its value. */
+    update({ dashboardId, name, description, }: {
+        dashboardId: string;
+        name?: string;
+        description?: string | null;
+    }): Promise<Dashboard>;
+    /** Deletes the dashboard with the widgets on it; answers its id and name. */
+    delete(dashboardId: string): Promise<{
+        id: string;
+        name: string;
+    }>;
+    listWidgets(dashboardId: string): Promise<{
+        data: DashboardWidget[];
     }>;
+    /** Creates a widget placed on this dashboard. */
+    createWidget({ dashboardId, widget, }: {
+        dashboardId: string;
+        widget: CreateDashboardWidgetInput;
+    }): Promise<DashboardWidget>;
+    getWidget({ dashboardId, widgetId, }: {
+        dashboardId: string;
+        widgetId: string;
+    }): Promise<DashboardWidget>;
+    updateWidget({ dashboardId, widgetId, changes, }: {
+        dashboardId: string;
+        widgetId: string;
+        changes: UpdateDashboardWidgetInput;
+    }): Promise<DashboardWidget>;
+    /** The route answers `204` with no body. */
+    deleteWidget({ dashboardId, widgetId, }: {
+        dashboardId: string;
+        widgetId: string;
+    }): Promise<void>;
 }
 
-interface DashboardSummary {
+/** One Analytics Report in the list, with how many graphs it holds. */
+interface AnalyticsReportSummary {
     id: string;
     name: string;
     order: number;
@@ -2349,7 +1968,8 @@ interface DashboardSummary {
     updatedAt: string;
     platformUrl?: string;
 }
-interface DashboardDetail {
+/** One Analytics Report with its graphs. */
+interface AnalyticsReportDetail {
     id: string;
     name: string;
     order: number;
@@ -2358,28 +1978,32 @@ interface DashboardDetail {
     updatedAt: string;
     platformUrl?: string;
 }
-declare class DashboardsApiService {
+/**
+ * Typed client for the Analytics Reports at `/api/v1/analytics/reports`, deprecated by the
+ * platform in favour of the Dashboards API (`DashboardsApiService`, `/api/v1/dashboards`).
+ */
+declare class AnalyticsReportsApiService {
     private readonly apiClient;
     constructor(config?: Pick<InternalConfig, "langwatchApiClient">);
     private handleApiError;
     list(): Promise<{
-        data: DashboardSummary[];
+        data: AnalyticsReportSummary[];
     }>;
-    get(id: string): Promise<DashboardDetail>;
+    get(id: string): Promise<AnalyticsReportDetail>;
     create(params: {
         name: string;
-    }): Promise<DashboardDetail>;
+    }): Promise<AnalyticsReportDetail>;
     rename(id: string, params: {
         name: string;
-    }): Promise<DashboardDetail>;
+    }): Promise<AnalyticsReportDetail>;
     delete(id: string): Promise<{
         id: string;
         name: string;
     }>;
 }
 
-type ModelProvidersListResponse = paths["/api/model-providers"]["get"]["responses"]["200"]["content"]["application/json"];
-type UpdateModelProviderBody = NonNullable<paths["/api/model-providers/{provider}"]["put"]["requestBody"]>["content"]["application/json"];
+type ModelProvidersListResponse = paths["/api/v1/model-providers"]["get"]["responses"]["200"]["content"]["application/json"];
+type UpdateModelProviderBody = NonNullable<paths["/api/v1/model-providers/{provider}"]["put"]["requestBody"]>["content"]["application/json"];
 declare class ModelProvidersApiService {
     private readonly apiClient;
     constructor(config?: Pick<InternalConfig, "langwatchApiClient">);
@@ -2388,8 +2012,8 @@ declare class ModelProvidersApiService {
     set(provider: string, params: UpdateModelProviderBody): Promise<ModelProvidersListResponse>;
 }
 
-type AnalyticsTimeseriesBody = NonNullable<paths["/api/analytics/timeseries"]["post"]["requestBody"]>["content"]["application/json"];
-type AnalyticsTimeseriesResponse = paths["/api/analytics/timeseries"]["post"]["responses"]["200"]["content"]["application/json"];
+type AnalyticsTimeseriesBody = NonNullable<paths["/api/v1/analytics/timeseries"]["post"]["requestBody"]>["content"]["application/json"];
+type AnalyticsTimeseriesResponse = paths["/api/v1/analytics/timeseries"]["post"]["responses"]["200"]["content"]["application/json"];
 declare class AnalyticsApiService {
     private readonly apiClient;
     constructor(config?: Pick<InternalConfig, "langwatchApiClient">);
@@ -2402,42 +2026,18 @@ type QueryRunResult = paths["/api/v1/query"]["post"]["responses"]["200"]["conten
 /** The queryable dataset/column catalog `GET /api/v1/query/schema` answers with. */
 type QuerySchemaResult = paths["/api/v1/query/schema"]["get"]["responses"]["200"]["content"]["application/json"];
 /**
- * Both query languages, as `GET /api/v1/query/reference` describes them.
- *
- * A superset of {@link QuerySchemaResult} in one direction only: it embeds the
- * schema and adds the trace filter language, worked examples and the decision
- * table. Nothing here is tenant data — the values a field holds come from
- * `GET /api/traces/facets`.
+ * Both query languages as `GET /api/v1/query/reference` describes them: {@link QuerySchemaResult}
+ * plus the filter language, examples and decision table. No tenant data; values come from facets.
  */
 type QueryReferenceResult = paths["/api/v1/query/reference"]["get"]["responses"]["200"]["content"]["application/json"];
 /**
  * The body a query request sends.
- *
- * Derived from the generated request body so a contract change to what the
- * endpoint accepts breaks this at compile time rather than drifting silently.
  */
 type QueryRunParams = NonNullable<paths["/api/v1/query"]["post"]["requestBody"]>["content"]["application/json"];
 /**
- * Typed client for the query doors (`POST /api/v1/query`,
- * `GET /api/v1/query/schema` and `GET /api/v1/query/reference`) — the same
- * governed query surface the workbench
- * and saved charts run through, exposed directly rather than only via a saved
- * chart's statement.
- *
- * Unlike the chart family, these routes carry no `projectId` in their path or
- * body — the generated operations declare `path?: never`. Project scope is
- * resolved once, when the underlying `LangwatchApiClient` is built
- * (`createLangWatchApiClient` bakes `scopedProjectId() ?? LANGWATCH_PROJECT_ID`
- * into that client's `Authorization`/`Basic` header at construction time —
- * see `src/internal/api/client.ts` and `src/internal/api/auth.ts`). A
- * per-call `projectId()` resolution the way `ChartsApiService` has one would
- * therefore be dead code here: there is no URL slot to put it in, and it
- * cannot retroactively change a header already baked into an existing
- * client. It would also wrongly force every caller to have a project in
- * scope — legacy `sk-lw-*` project keys carry their own project identity and
- * need none (see `buildAuthHeaders`). So this service takes the plain,
- * project-implicit config `AnalyticsApiService` does, and lets the api
- * client resolve the credential itself.
+ * Typed client for the LangWatchQL query doors (`POST /api/v1/query` and `GET
+ * /api/v1/query/schema`) — the same governed query surface the workbench and saved charts
+ * run through, exposed directly rather than only via a saved chart's statement.
  */
 declare class QueryApiService {
     private readonly apiClient;
@@ -2450,25 +2050,23 @@ declare class QueryApiService {
      */
     query(params: QueryRunParams): Promise<QueryRunResult>;
     /**
-     * Lists the LangWatchQL analytics views this key may query, with each
-     * column's type, description, the permissions that unlock it, and whether
-     * this caller holds them — plus each dataset's grain, join keys,
-     * partition-pruning time column, freshness and a runnable example query.
+     * Lists the LangWatchQL analytics datasets this key may query, with each column's type,
+     * description, the permissions that unlock it, and whether this caller holds them — plus
+     * each dataset's grain, join keys, partition-pruning time column, freshness and a runnable
      */
     schema(): Promise<QuerySchemaResult>;
     /**
-     * Describes both query languages in one payload: the LangWatchQL schema,
-     * limits and endpoints, the trace filter's syntax and fields, worked examples
-     * validated in both, and which language answers which kind of
-     * question.
+     * Describes both query languages in one payload: the LangWatchQL schema, limits and endpoints,
+     * the trace filter's syntax and fields, worked examples validated in both, and which language
+     * answers which kind of question.
      */
     reference(): Promise<QueryReferenceResult>;
 }
 
-type TriggerResponse = NonNullable<paths["/api/triggers"]["get"]["responses"]["200"]["content"]["application/json"]>[number];
-type CreateTriggerBody = NonNullable<paths["/api/triggers"]["post"]["requestBody"]>["content"]["application/json"];
-type UpdateTriggerBody = NonNullable<paths["/api/triggers/{id}"]["patch"]["requestBody"]>["content"]["application/json"];
-type TriggerDeleteResponse = paths["/api/triggers/{id}"]["delete"]["responses"]["200"]["content"]["application/json"];
+type TriggerResponse = NonNullable<paths["/api/v1/triggers"]["get"]["responses"]["200"]["content"]["application/json"]>[number];
+type CreateTriggerBody = NonNullable<paths["/api/v1/triggers"]["post"]["requestBody"]>["content"]["application/json"];
+type UpdateTriggerBody = NonNullable<paths["/api/v1/triggers/{triggerId}"]["patch"]["requestBody"]>["content"]["application/json"];
+type TriggerDeleteResponse = paths["/api/v1/triggers/{triggerId}"]["delete"]["responses"]["200"]["content"]["application/json"];
 declare class TriggersApiService {
     private readonly apiClient;
     constructor(config?: Pick<InternalConfig, "langwatchApiClient">);
@@ -2480,10 +2078,10 @@ declare class TriggersApiService {
     delete(id: string): Promise<TriggerDeleteResponse>;
 }
 
-type GraphResponse = NonNullable<paths["/api/graphs"]["get"]["responses"]["200"]["content"]["application/json"]>[number];
-type CreateGraphBody = NonNullable<paths["/api/graphs"]["post"]["requestBody"]>["content"]["application/json"];
-type UpdateGraphBody = NonNullable<paths["/api/graphs/{id}"]["patch"]["requestBody"]>["content"]["application/json"];
-type GraphDeleteResponse = paths["/api/graphs/{id}"]["delete"]["responses"]["200"]["content"]["application/json"];
+type GraphResponse = NonNullable<paths["/api/v1/graphs"]["get"]["responses"]["200"]["content"]["application/json"]>[number];
+type CreateGraphBody = NonNullable<paths["/api/v1/graphs"]["post"]["requestBody"]>["content"]["application/json"];
+type UpdateGraphBody = NonNullable<paths["/api/v1/graphs/{id}"]["patch"]["requestBody"]>["content"]["application/json"];
+type GraphDeleteResponse = paths["/api/v1/graphs/{id}"]["delete"]["responses"]["200"]["content"]["application/json"];
 declare class GraphsApiService {
     private readonly apiClient;
     constructor(config?: Pick<InternalConfig, "langwatchApiClient">);
@@ -2495,11 +2093,11 @@ declare class GraphsApiService {
     delete(id: string): Promise<GraphDeleteResponse>;
 }
 
-type SimulationRunsListResponse = paths["/api/simulation-runs"]["get"]["responses"]["200"]["content"]["application/json"];
-type SimulationRunResponse = paths["/api/simulation-runs/{scenarioRunId}"]["get"]["responses"]["200"]["content"]["application/json"];
-type SimulationRunsBatchesListResponse = paths["/api/simulation-runs/batches/list"]["get"]["responses"]["200"]["content"]["application/json"];
-type SimulationRunsListParams = NonNullable<paths["/api/simulation-runs"]["get"]["parameters"]["query"]>;
-type SimulationRunsBatchesListParams = paths["/api/simulation-runs/batches/list"]["get"]["parameters"]["query"];
+type SimulationRunsListResponse = paths["/api/v1/simulation-runs"]["get"]["responses"]["200"]["content"]["application/json"];
+type SimulationRunResponse = paths["/api/v1/simulation-runs/{scenarioRunId}"]["get"]["responses"]["200"]["content"]["application/json"];
+type SimulationRunsBatchesListResponse = paths["/api/v1/simulation-runs/batches/list"]["get"]["responses"]["200"]["content"]["application/json"];
+type SimulationRunsListParams = NonNullable<paths["/api/v1/simulation-runs"]["get"]["parameters"]["query"]>;
+type SimulationRunsBatchesListParams = paths["/api/v1/simulation-runs/batches/list"]["get"]["parameters"]["query"];
 declare class SimulationRunsApiService {
     private readonly apiClient;
     constructor(config?: Pick<InternalConfig, "langwatchApiClient">);
@@ -2579,10 +2177,13 @@ interface SecretDeleteResponse {
 declare class SecretsApiService {
     private readonly apiKey;
     private readonly endpoint;
+    private readonly configuredProjectId;
     constructor(config?: {
         apiKey?: string;
         endpoint?: string;
+        projectId?: string;
     });
+    private projectId;
     private request;
     getAll(): Promise<SecretResponse[]>;
     get(id: string): Promise<SecretResponse>;
@@ -2597,17 +2198,9 @@ declare class SecretsApiService {
 }
 
 /**
- * The per-call options every mutating call on the billing surfaces takes.
- *
- * WHERE THEY GO. A call whose arguments already ride in an options bag
- * (`disable(id, { reason })`, `reset(id, { endUserId })`) gains these fields in
- * that same bag: one bag per call is what a caller expects. A call that takes a
- * request BODY (`create(input)`, `update(id, input)`) gets a separate trailing
- * parameter instead, because those body types mirror the wire verbatim and must
- * not grow keys the wire has never heard of.
- *
- * They are an interface rather than a bare `signal` so that the next thing a
- * call needs per invocation is an added field rather than an added parameter.
+ * The per-call options every mutating billing call takes. An options-bag
+ * call gains these fields there; a body call (`create(input)`) gets them as
+ * a trailing param, since body types mirror the wire verbatim.
  */
 /** The request header the control plane deduplicates creates on. */
 declare const IDEMPOTENCY_KEY_HEADER = "Idempotency-Key";
@@ -2626,29 +2219,15 @@ interface MutationOptions {
 }
 interface IdempotentCreateOptions extends MutationOptions {
     /**
-     * Makes the create safe to retry. A dropped connection after the write but
-     * before the response looks exactly like a dropped request, and sending it
-     * again without a key mints a SECOND resource. Send the same key on the
-     * retry and the server answers with the first response instead, byte for
-     * byte, including the one-time secret a create hands back.
-     *
-     * Any string of 8 to 255 characters; a UUID minted per logical create is the
-     * usual choice. Receipts answer for 24 hours, and only successful creates
-     * leave one, so a create that failed is safe to run again either way.
-     *
-     * Reusing a key with a DIFFERENT body is refused with `idempotency_error`
-     * rather than quietly answering for the wrong request.
+     * Makes the create safe to retry: the same key replays the first
+     * response verbatim, while a dropped response with no key would mint a
+     * second resource. A DIFFERENT body under the same key is refused.
      */
     idempotencyKey?: string;
     /**
-     * Called when the response came from a receipt rather than a fresh write,
-     * i.e. this exact create had already succeeded.
-     *
-     * A hook rather than a field on the returned resource: the resource is
-     * identical either way, so nothing about handling it changes, and the
-     * distinction is something a caller logs rather than branches on. Keeping it
-     * off the return type also keeps the wire-shaped entities free of fields the
-     * wire does not have.
+     * Called when the response came from a receipt, not a fresh write. A hook
+     * rather than a resource field, since callers log this rather than branch
+     * on it, keeping wire-shaped entities free of fields the wire lacks.
      */
     onIdempotentReplay?: () => void;
 }
@@ -2677,11 +2256,9 @@ interface VirtualKey {
     display_prefix: string;
     principal_user_id: string | null;
     /**
-     * Where this key's traces and costs land. Not a scope: it grants no
-     * access to the key. Decided when the key is written and stored on it,
-     * so editing what the key is scoped to never moves it. Null only on a
-     * key created before this was stored, in an organization that had no
-     * governance project to fall back to.
+     * Where this key's traces and costs land. Not a scope: it grants no access to the key.
+     * Decided when the key is written and stored on it, so editing what the key is scoped to
+     * never moves it. Null only on a pre-existing key with no governance project fallback.
      */
     trace_project_id: string | null;
     /**
@@ -2700,10 +2277,9 @@ interface VirtualKey {
     last_used_at: string | null;
     revoked_at: string | null;
     /**
-     * When the key stops serving, or null for a key that never expires.
-     * Requests presented after this moment are refused with
-     * `virtual_key_expired`. `status` stays "active" past the date, so read
-     * this field rather than the status to tell an expired key apart.
+     * When the key stops serving, or null for a key that never expires. Requests presented
+     * after this moment are refused with `virtual_key_expired`. `status` stays "active" past
+     * the date, so read this field to tell an expired key apart, not status.
      */
     expires_at: string | null;
 }
@@ -2752,10 +2328,9 @@ interface CreateVirtualKeyInput {
      */
     metadata?: Record<string, string>;
     /**
-     * Withhold the secret from the response and get a one-time reveal id
-     * instead. The secret is parked for 24 hours and served once, to the
-     * person the key is for, through the LangWatch app; the caller never
-     * holds it.
+     * Withhold the secret from the response and get a one-time reveal id instead. The secret is
+     * parked for 24 hours and served once, to the person the key is for, through the LangWatch app;
+     * the caller never holds it.
      */
     reveal_once?: boolean;
 }
@@ -2803,10 +2378,9 @@ interface VirtualKeyWithReveal {
 interface VirtualKeyPage {
     data: VirtualKey[];
     /**
-     * Pass back as `cursor` for the next page. Null means the walk is
-     * exhausted. Neither page length tells you anything here: visibility is
-     * applied to each page AFTER it is read, so a page can hold fewer rows
-     * than `limit` with more still to come.
+     * Pass back as `cursor` for the next page. Null means the walk is exhausted. Neither page
+     * length tells you anything here: visibility is applied to each page AFTER it is read, so
+     * a page can hold fewer rows than `limit` with more still to come.
      */
     next_cursor: string | null;
 }
@@ -2827,32 +2401,29 @@ declare class VirtualKeysApiError extends Error {
     constructor(message: string, operation: string, originalError?: unknown | undefined);
 }
 /**
- * Client for the gateway virtual-key surface (/api/gateway/v1).
- *
- * Entity types and the create/update bodies mirror the wire verbatim, so
- * their fields are lowercase snake_case. Call options this SDK invents (query
- * filters, per-call behaviour, action arguments) are camelCase like the rest
- * of the SDK.
+ * Client for the gateway virtual-key surface (/api/gateway/v1). Entity types and the
+ * create/update bodies mirror the wire verbatim (lowercase snake_case); call options this
+ * SDK invents (filters, per-call behaviour, action arguments) are camelCase like the rest.
  */
 declare class VirtualKeysApiService {
     private readonly endpoint;
     private readonly apiKey;
+    /** The project the caller asked for. Sent on every request, where it narrows what is read. */
     private readonly projectId;
+    /** Where a key created with no scope lands: the project asked for, else the one resolved. */
+    private readonly defaultProjectId;
     constructor(config?: {
         endpoint?: string;
         apiKey?: string;
         projectId?: string;
     });
+    private mergedHeaders;
     private headers;
     private request;
     /**
-     * ONE page of the virtual keys visible to the caller, newest first. Pass
-     * `next_cursor` back as `cursor` for the next page, verbatim: a cursor this
-     * endpoint did not issue answers 400 rather than restarting the walk.
-     *
-     * `limit` is the page size (server default 50, capped at 200), and it caps
-     * the rows READ, not the rows returned: the visibility filter runs on the
-     * page afterwards. Prefer `list()` unless you mean to page deliberately.
+     * ONE page of the virtual keys visible to the caller, newest first. Pass `next_cursor`
+     * back as `cursor` verbatim — an unrecognized cursor answers 400 rather than restarting.
+     * `limit` caps rows READ, not returned. Prefer `list()` unless paging deliberately.
      */
     listPage(options?: {
         cursor?: string;
@@ -2861,17 +2432,9 @@ declare class VirtualKeysApiService {
         externalId?: string;
     }): Promise<VirtualKeyPage>;
     /**
-     * Every virtual key visible to the caller: keys scoped to this project, to
-     * its team, or to the whole organization.
-     *
-     * The endpoint pages; this follows `next_cursor` until it comes back null.
-     * Stopping on a short page would be wrong here specifically, because the
-     * server filters each page for visibility after reading it, so a page can
-     * hold fewer rows than the limit with more still to come.
-     *
-     * `limit` sizes each request in the walk, it does NOT cap what comes back.
-     * `cursor` resumes an interrupted walk. Take a single page with
-     * `listPage()`, or stream the walk with `iterate()`.
+     * Every virtual key visible to the caller (project, team, or org scoped). Follows
+     * `next_cursor` until null — a short page does NOT mean done, since the visibility filter
+     * runs after each page. `limit` sizes each request, it does not cap the total.
      */
     list(options?: {
         cursor?: string;
@@ -2880,11 +2443,9 @@ declare class VirtualKeysApiService {
         externalId?: string;
     }): Promise<VirtualKey[]>;
     /**
-     * Every visible virtual key, one row at a time, fetching each page only
-     * when the consumer reaches it. Stop early and the rest is never read,
-     * which `list()` cannot offer because it materialises the whole listing
-     * first. Raises rather than looping forever on a cursor chain that never
-     * ends, exactly like `list()`.
+     * Every visible virtual key, one row at a time, fetching each page only when the
+     * consumer reaches it — stop early and the rest is never read, unlike `list()` which
+     * materialises the whole listing first. Raises rather than looping forever, like `list()`.
      */
     iterate(options?: {
         cursor?: string;
@@ -2894,10 +2455,9 @@ declare class VirtualKeysApiService {
     }): AsyncGenerator<VirtualKey>;
     get(id: string): Promise<VirtualKey>;
     /**
-     * Mint a key. The response carries the secret ONCE; nothing ever serves it
-     * again, so a create that times out is recovered with `idempotencyKey`
-     * rather than by listing. With `reveal_once` the response carries a reveal
-     * id in place of the secret.
+     * Mint a key. The response carries the secret ONCE; nothing ever serves it again, so a create
+     * that times out is recovered with `idempotencyKey` rather than by listing. With `reveal_once`
+     * the response carries a reveal id in place of the secret.
      */
     create(input: CreateVirtualKeyInput & {
         reveal_once: true;
@@ -2912,10 +2472,9 @@ declare class VirtualKeysApiService {
     } & MutationOptions): Promise<VirtualKey>;
     enable(id: string, options?: MutationOptions): Promise<VirtualKey>;
     /**
-     * Aggregate spend for one key over a window in epoch milliseconds.
-     * Defaults to the current UTC calendar month server-side. Reads the same
-     * cost path the dashboard reads, so this number and the UI agree by
-     * construction.
+     * Aggregate spend for one key over a window in epoch milliseconds. Defaults to the
+     * current UTC calendar month server-side. Reads the same cost path the dashboard reads,
+     * so this number and the UI agree by construction.
      */
     spend(id: string, options?: {
         from?: number;
@@ -2936,11 +2495,9 @@ interface GatewayBudget {
     window: BudgetWindow;
     on_breach: BudgetOnBreach;
     /**
-     * For `group` rows this is the PER-MEMBER allowance, not a group total;
-     * `spent_usd` sums the whole group and `member_count` says how many
-     * members the allowance currently covers. For `attributed_user` rows it is
-     * the PER-PERSON cap, and `end_users_seen` / `end_users_over` carry the
-     * standing instead of `spent_usd`.
+     * For `group` rows, the PER-MEMBER allowance (`member_count` says how many
+     * it covers); for `attributed_user` rows, the PER-PERSON cap, with
+     * `end_users_seen`/`end_users_over` as the standing instead of `spent_usd`.
      */
     limit_usd: string;
     /** Canonical integer limit, nano-USD. Null past the safe integer range. */
@@ -2971,11 +2528,9 @@ interface GatewayBudget {
     end_users_over?: number;
 }
 /**
- * One page of the budget listing, exactly as the wire serves it.
- *
- * Budgets come back in an envelope where virtual keys come back as a bare
- * array because `spend_available` is a correctness flag about the whole page,
- * and an array cannot carry it.
+ * One page of the budget listing, exactly as the wire serves it. An envelope,
+ * not a bare array, because `spend_available` is a correctness flag about the
+ * whole page and an array cannot carry it.
  */
 interface GatewayBudgetPage {
     data: GatewayBudget[];
@@ -3024,10 +2579,9 @@ interface CreateGatewayBudgetInput {
     /** ModelProvider id to pin the budget to one provider. */
     provider_key?: string | null;
     /**
-     * RFC3339 instant that phases the budget's cycle instead of the calendar:
-     * a `month` budget anchored `2026-01-17T09:00:00Z` rolls every 17th at
-     * 09:00 UTC. Omit for calendar alignment. Immutable once created, and
-     * rejected on the windows that never cycle (`total`, `manual`).
+     * RFC3339 instant phasing the cycle instead of the calendar (a `month`
+     * anchored `2026-01-17T09:00:00Z` rolls every 17th at 09:00 UTC). Immutable
+     * once created; rejected on windows that never cycle (`total`, `manual`).
      */
     cycle_anchor_at?: string;
     /**
@@ -3055,12 +2609,9 @@ declare class GatewayBudgetsApiError extends Error {
     constructor(message: string, operation: string, originalError?: unknown | undefined);
 }
 /**
- * Client for the gateway budget surface (/api/gateway/v1).
- *
- * Entity types and the create/update bodies mirror the wire verbatim, so
- * their fields are lowercase snake_case. Call options this SDK invents (query
- * filters, per-call behaviour, action arguments) are camelCase like the rest
- * of the SDK.
+ * Client for the gateway budget surface (/api/gateway/v1). Entity/body fields
+ * mirror the wire verbatim (snake_case); options this SDK invents (filters,
+ * per-call behaviour, actions) are camelCase like the rest.
  */
 declare class GatewayBudgetsApiService {
     private readonly endpoint;
@@ -3074,13 +2625,9 @@ declare class GatewayBudgetsApiService {
     private headers;
     private request;
     /**
-     * ONE page of non-archived budgets, exactly as the wire serves it. Pass
-     * `next_cursor` back as `cursor` for the next page, verbatim: a cursor this
-     * endpoint did not issue answers 400 rather than restarting the walk.
-     *
-     * `limit` is the page size (server default 50, capped at 200). Prefer
-     * `list()` unless you mean to page deliberately: a full page is not a
-     * promise of more, and a null `next_cursor` is the only end of the walk.
+     * ONE page of non-archived budgets. Pass `next_cursor` back as `cursor`
+     * verbatim: an unissued cursor answers 400 rather than restarting the walk.
+     * `limit` is the page size (default 50, capped 200) — prefer `list()`.
      */
     listPage(options?: {
         scopeTypes?: BudgetScopeKind[];
@@ -3090,24 +2637,9 @@ declare class GatewayBudgetsApiService {
         externalId?: string;
     }): Promise<GatewayBudgetPage>;
     /**
-     * Every non-archived budget in the organization across all seven scope
-     * types, optionally filtered by `scopeTypes`.
-     *
-     * The endpoint pages; this follows `next_cursor` until it comes back null,
-     * so the result is the complete listing and carries no cursor of its own.
-     * Callers that count, total, or decide an all-clear on this list need that
-     * completeness for correctness, not just for display.
-     *
-     * `limit` sizes each request in the walk, it does NOT cap what comes back.
-     * `cursor` resumes an interrupted walk. Take a single page with
-     * `listPage()`, or stream the walk with `iterate()`.
-     *
-     * A plain array, like every other exhaustive `list()` in the SDK: a walk
-     * that ran to the end has no cursor left to report. Null `spent_usd` /
-     * `spent_nano_usd` on a row is not by itself "spend unavailable": an
-     * `attributed_user` template row serves null deliberately, because one
-     * allowance per person has no single total. Use `listPage()` when you need
-     * `spend_available` stated outright.
+     * Every non-archived budget across all scope types, following `next_cursor`
+     * to completion — callers that count/total need that. Plain array, no
+     * cursor; `limit` sizes requests but doesn't cap the result.
      */
     list(options?: {
         scopeTypes?: BudgetScopeKind[];
@@ -3118,10 +2650,8 @@ declare class GatewayBudgetsApiService {
     }): Promise<GatewayBudget[]>;
     /**
      * Every non-archived budget, one row at a time, fetching each page only
-     * when the consumer reaches it.
-     *
-     * A null `spent_usd` means spend could not be totalled rather than that
-     * nothing was spent.
+     * when the consumer reaches it. A null `spent_usd` means spend could not
+     * be totalled, not that nothing was spent.
      */
     iterate(options?: {
         scopeTypes?: BudgetScopeKind[];
@@ -3131,12 +2661,9 @@ declare class GatewayBudgetsApiService {
         externalId?: string;
     }): AsyncGenerator<GatewayBudget>;
     /**
-     * One budget by id, in the same row shape the listing serves.
-     *
-     * Archived budgets are not served, so a budget that existed yesterday can
-     * answer 404 today. A null `spent_usd` means spend could not be totalled
-     * rather than that nothing was spent, which is the same signal the listing
-     * carries as `spend_available`.
+     * One budget by id, in the same row shape the listing serves. Archived
+     * budgets are not served, so a budget that existed yesterday can answer
+     * 404 today.
      */
     get(id: string): Promise<GatewayBudget>;
     create(input: CreateGatewayBudgetInput, options?: IdempotentCreateOptions): Promise<GatewayBudget>;
@@ -3153,16 +2680,9 @@ declare class GatewayBudgetsApiService {
 }
 
 /**
- * The quantities one priced request or rollup carries. Every field is always
- * present; a bucket the request never used reports 0.
- *
- * The token buckets are disjoint, not nested. An image generation reports its
- * render under `output_image_tokens` with `output_tokens` at 0, so reading
- * `output_tokens` alone sees none of the image traffic.
- *
- * Every priced quantity is charged once at its own rate. `reasoning_tokens`
- * is a subset of `output_tokens` and `image_count` is a count of images, so
- * no rate prices either and neither belongs in a cost sum.
+ * The quantities one priced request or rollup carries; every field is
+ * always present (0 when unused) and buckets are disjoint, not nested.
+ * `reasoning_tokens` and `image_count` are subsets already priced elsewhere.
  */
 interface SpendUsage {
     input_tokens: number;
@@ -3228,7 +2748,7 @@ interface SpendSummaryRow {
      * two dimensions, two rows can share a key: read `group` to tell them apart.
      */
     key: string;
-    /** Every grouping dimension by name, e.g. `{ model: "gpt-5-mini" }`. */
+    /** Every grouping dimension by name, e.g. `{ model: "gpt-6-luna" }`. */
     group: Record<string, string>;
     /** Start of the time bucket in the requested zone, null when unbucketed. */
     bucket_start: string | null;
@@ -3242,30 +2762,15 @@ interface SpendSummaryRow {
         nano_usd: number;
     };
 }
-/**
- * The states a request can be filtered by, which is more than the two a
- * caller usually thinks in: a request is `admitted` when it starts,
- * `confirmed` or `failed` when it ends, and `settled` once its cost is final.
- * `success` and `error` are the coarse outcome pair over those.
- */
+/** Request states: admitted at start, confirmed/failed/settled at end. */
 type SpendEventStatus = "success" | "error" | "admitted" | "confirmed" | "failed" | "settled";
-/**
- * The states a ROLLUP can be filtered by. A rollup sums the cost of requests
- * past admission, so `admitted` is refused there rather than answered with a
- * zero; list the events to see those. Derived by exclusion so the two stay one
- * vocabulary.
- */
+/** Rollup states: excludes admitted (no cost yet). Use events for those. */
 type SpendSummaryStatus = Exclude<SpendEventStatus, "admitted">;
 /** A dimension a rollup can be grouped by. */
 type SpendGroupBy = "virtual_key" | "end_user" | "project" | "model" | "provider" | "principal" | "request_type";
 /**
- * The filters BOTH spend reads accept. A reconciliation checksums the rollups
- * and diffs the events when a checksum disagrees, so the two take the same
- * vocabulary and a divergence can be walked on exactly the narrowing that
- * produced it.
- *
- * Every field takes one value or many; many means "any of these". Naming two
- * different fields narrows.
+ * Shared filters for spend reads. Every field takes one value or many.
+ * Multiple values widen; multiple fields narrow.
  */
 interface SpendFilterOptions {
     projectId?: string | string[];
@@ -3288,24 +2793,12 @@ interface SpendFilterOptions {
     status?: SpendEventStatus;
 }
 /**
- * What a rollup is grouped by, and over what window.
- *
- * Grouping by `model` or `provider`, or into time buckets, is REFUSED with
- * `gateway_spend_group_by_unstable` over a window recent enough that outcomes
- * can still arrive: until a request settles, the model and provider recorded
- * against it are the ones that were asked for, and they are replaced by the
- * ones that actually served it. A page walk over a group that can move counts
- * some requests twice and misses others.
- *
- * Reconcile closed periods and this never fires. For a live view where an
- * approximate shape is enough, send `allowUnstable`.
+ * Grouping by model/provider/time is unstable: outcomes may arrive and change
+ * the recorded values. Use allowUnstable for approximate live views; reconcile
+ * closed periods to avoid this.
  */
 interface SpendSummariesOptions extends Omit<SpendFilterOptions, "status"> {
-    /**
-     * One lifecycle status, minus `admitted`: a rollup sums the cost of requests
-     * past admission, and an admitted request has none yet. List the events for
-     * those.
-     */
+    /** Lifecycle status; excludes admitted (no cost yet). */
     status?: SpendSummaryStatus;
     /** One or two dimensions. Two rows can share `key`; read `group`. */
     groupBy: SpendGroupBy | SpendGroupBy[];
@@ -3373,29 +2866,8 @@ declare class SpendEventsApiError extends Error {
     constructor(message: string, operation: string, originalError?: unknown | undefined);
 }
 /**
- * Client for the gateway spend reconciliation surface (/api/gateway/v1).
- * Authenticates with an ORGANIZATION API key (sk-lw-*).
- *
- * Entity types mirror the wire verbatim, so their fields are lowercase
- * snake_case. Call options this SDK invents (query filters, per-call
- * behaviour, action arguments) are camelCase like the rest of the SDK.
- *
- * There is no project id here: `/spend-summaries` takes `project_id` as a
- * query filter rather than scoping on a header, so the project belongs to the
- * call, not to the client.
- *
- * The key MUST be an organization API key (`sk-lw-{id}_{secret}`, from
- * Settings > API Keys). A project API key is refused before any permission is
- * consulted, with `credential_class_mismatch`, and no header makes it work:
- * these are organization-scoped routes and a project key names one project.
- * The same organization key also reaches the project-scoped surfaces when
- * given `X-Project-Id`, so one key covers both families and a project key
- * covers only one.
- *
- * Neither collection on this service offers an eager whole-set read. The
- * ledger is unbounded, and materialising a window of it is the very
- * under-counting and out-of-memory footgun the page docstrings warn about:
- * take pages, or stream with `iterate()` / `iterSummaries()`.
+ * Spend reconciliation service (/api/gateway/v1). Requires ORGANIZATION API
+ * key (sk-lw-*). Use iterate/iterSummaries for large windows (no eager read).
  */
 declare class SpendEventsApiService {
     private readonly endpoint;
@@ -3405,15 +2877,7 @@ declare class SpendEventsApiService {
         apiKey?: string;
     });
     private request;
-    /**
-     * ONE page of the per-request spend ledger for a window. Pass `next_cursor`
-     * back as `cursor` for the next page, verbatim.
-     *
-     * A full page does NOT mean there is more and a short page does NOT mean
-     * there is no more: only a null cursor ends the walk. A reconciler that
-     * stops on the first page silently under-counts the window, so read every
-     * page or stream them with `iterate()`.
-     */
+    /** One page of events. Follow next_cursor or use iterate() for the full window. */
     listPage(options: SpendFilterOptions & {
         /** Required: the pull is a ranged read by contract. */
         from: number;
@@ -3421,15 +2885,7 @@ declare class SpendEventsApiService {
         cursor?: string;
         limit?: number;
     }): Promise<SpendEventsPage>;
-    /**
-     * Every spend event in the window, one row at a time, fetching each page
-     * only when the consumer reaches it.
-     *
-     * This is how a reconciler reads a whole window without holding it: the
-     * ledger is unbounded, so there is deliberately no eager `list()` to
-     * collect it into an array. Raises rather than looping forever on a cursor
-     * chain that never ends.
-     */
+    /** Stream events without holding the whole window in memory. */
     iterate(options: SpendFilterOptions & {
         /** Required: the pull is a ranged read by contract. */
         from: number;
@@ -3437,38 +2893,17 @@ declare class SpendEventsApiService {
         cursor?: string;
         limit?: number;
     }): AsyncGenerator<SpendEvent>;
-    /**
-     * ONE page of per-key spend rollups for a window, paged by group key
-     * ascending.
-     *
-     * The page is a step of a walk, not a whole answer: follow `next_cursor`
-     * until it comes back null, or stream the walk with `iterSummaries()`. A
-     * reconciler that reads only the first page silently under-counts every
-     * tenant past the limit.
-     */
+    /** One page of rollups by group key. Use iterSummaries for the full walk. */
     summariesPage(options: SpendSummariesOptions & {
         cursor?: string;
         limit?: number;
     }): Promise<SpendSummariesPage>;
-    /**
-     * Every rollup row for the window, one at a time, fetching each page only
-     * when the consumer reaches it.
-     *
-     * The rollup has one row per tenant seen in the window, which no bound
-     * covers, so there is deliberately no eager whole-set read here either: a
-     * checksum that quietly covers part of the window is worse than none.
-     */
+    /** Stream rollup rows without holding the whole window in memory. */
     iterSummaries(options: SpendSummariesOptions & {
         cursor?: string;
         limit?: number;
     }): AsyncGenerator<SpendSummaryRow>;
-    /**
-     * Re-deliver a window's spend envelopes to ONE endpoint through the
-     * normal delivery path. Envelope ids are unchanged (your consumer's
-     * dedup key); mind your downstream billing system's finite dedup
-     * window before replaying old ranges. The window is capped server-side
-     * at 7 days per call.
-     */
+    /** Re-deliver spend envelopes to an endpoint (max 7 days). */
     replay(options: {
         from: number;
         to: number;
@@ -3547,13 +2982,9 @@ interface CreateWebhookEndpointBase {
     max_in_flight?: number;
 }
 /**
- * The POST body, exactly as the wire takes it.
- *
- * A destination is one kind and one address, so the two are a union rather
- * than independent optional fields: the type refuses `{destination_kind:
- * "sqs"}` with no queue, and `{url, sqs}` together, which is what the server
- * refuses too. `destination_kind` is optional only on the http branch, where
- * absent has always meant http.
+ * The POST body, exactly as the wire takes it. A destination is one kind and
+ * one address, so the two are a union, matching what the server refuses too.
+ * `destination_kind` is optional only on the http branch (absent means http).
  */
 type WebhookDestinationInput = {
     destination_kind?: "http";
@@ -3648,24 +3079,9 @@ declare class WebhooksApiError extends Error {
     constructor(message: string, operation: string, originalError?: unknown | undefined);
 }
 /**
- * Client for the org-anchored webhook platform surface (/api/webhooks/v1).
- * Authenticates with an ORGANIZATION API key (sk-lw-*); project keys are
- * rejected by the server. The surface is anchored on the organization alone,
- * so there is no project id to give this client.
- *
- * The key MUST be an organization API key (`sk-lw-{id}_{secret}`, from
- * Settings > API Keys). A project API key is refused with
- * `credential_class_mismatch` before any permission is consulted, and no
- * header makes it work. The same organization key also reaches the
- * project-scoped surfaces when given `X-Project-Id`, so one key covers both
- * families and a project key covers only one.
- *
- * The endpoint entity and the create/update bodies mirror the wire verbatim,
- * so their fields are lowercase snake_case: virtual keys and gateway budgets
- * already take the wire body as it is, and translating field by field here
- * only made the request bodies of the four billing surfaces disagree. Call
- * options this SDK invents (query filters, per-call behaviour, action
- * arguments) stay camelCase like the rest of the SDK.
+ * Client for the org-anchored webhook platform surface (/api/webhooks/v1) — an ORGANIZATION
+ * API key only; a project key is refused with `credential_class_mismatch`. Fields mirror the
+ * wire verbatim in snake_case, since translating field-by-field made billing surfaces disagree.
  */
 declare class WebhooksApiService {
     private readonly endpoint;
@@ -3685,25 +3101,17 @@ declare class WebhooksApiService {
     create(input: CreateWebhookEndpointInput, options?: IdempotentCreateOptions): Promise<WebhookEndpointWithSecret>;
     update(id: string, input: UpdateWebhookEndpointInput, options?: MutationOptions): Promise<WebhookEndpointSummary>;
     /**
-     * Retire an endpoint: the server soft-archives the row, stamping
-     * `archived_at` and dropping the status to disabled, so the delivery
-     * history stays readable for audit while nothing more is ever sent. The
-     * row is archived, not removed, and `gatewayBudgets.archive()` already
-     * names that operation, so the billing surfaces agree on the verb.
-     *
-     * Nothing comes back: the response body carries only an `archived: true`
-     * acknowledgement, and a non-2xx already raises.
+     * Retire an endpoint: the server soft-archives the row (stamping `archived_at`, disabling
+     * delivery) so history stays readable for audit. Archived, not removed — same verb as
+     * `gatewayBudgets.archive()`, so the billing surfaces agree.
      */
     archive(id: string, options?: MutationOptions): Promise<void>;
     rollSecret(id: string, options?: MutationOptions): Promise<WebhookEndpointWithSecret>;
     test(id: string, options?: MutationOptions): Promise<WebhookTestResult>;
     /**
-     * ONE page of the endpoint's delivery attempts, newest first.
-     *
-     * The cursor is why this is a page: the route has always served one, and
-     * dropping it truncated the delivery log at whatever the first page held,
-     * with nothing in the result to say the rest existed. Pass `next_cursor`
-     * back as `cursor`, or walk the whole log with `iterDeliveries()`.
+     * ONE page of the endpoint's delivery attempts, newest first. Pass
+     * `next_cursor` back as `cursor` for the next page, or walk the whole log
+     * with `iterDeliveries()`.
      */
     deliveriesPage(id: string, options?: {
         cursor?: string;
@@ -3721,10 +3129,8 @@ declare class WebhooksApiService {
     eventTypes(): Promise<WebhookEventType[]>;
     /**
      * ONE page of the organization's emitted-events log, newest first.
-     *
-     * Webhooks are a push over this log, never the only copy of it: a consumer
-     * that missed a delivery reads the window back from here. Walk the whole
-     * window with `iterEvents()`.
+     * Webhooks are a push over this log, never the only copy: a consumer that
+     * missed a delivery reads the window back from here.
      */
     eventsPage(options: {
         type?: string;
@@ -3747,21 +3153,17 @@ declare class WebhooksApiService {
         limit?: number;
     }): AsyncGenerator<EmittedEvent>;
     /**
-     * One emitted event by id, the envelope exactly as it was delivered.
-     *
-     * A 404 covers every reason the log cannot answer: never emitted, past the
-     * retention horizon, or belonging to another organization.
+     * One emitted event by id, the envelope exactly as it was delivered. A 404
+     * covers every reason the log cannot answer: never emitted, past
+     * retention, or belonging to another organization.
      */
     getEvent(id: string): Promise<EmittedEvent>;
 }
 
 /**
- * The vocabulary the management REST families share on the wire.
- *
- * A role binding grants a scoped role, and the same three words appear on
- * roles, role bindings, groups, teams and API keys. Declared once here so the
- * CLI's flag parsers validate against one list rather than five copies that
- * can disagree with the platform.
+ * The vocabulary the management REST families share on the wire: the same
+ * three words appear on roles, bindings, groups, teams and API keys.
+ * Declared once so flag parsers validate against one list, not five.
  */
 /** The role a binding grants at its scope. `CUSTOM` defers to a custom role. */
 declare const MANAGEMENT_ROLES: readonly ["ADMIN", "MEMBER", "VIEWER", "CUSTOM"];
@@ -3814,7 +3216,7 @@ declare class TeamsApiService {
     create(input: {
         name: string;
     }): Promise<Team>;
-    update({ id, input, }: {
+    update({ id, input }: {
         id: string;
         input: {
             name?: string;
@@ -3864,6 +3266,12 @@ interface UpdateProjectInput {
     language?: string;
     framework?: string;
     piiRedactionLevel?: "STRICT" | "ESSENTIAL" | "DISABLED";
+    /**
+     * Moves the project to this team. The platform refuses a team outside the
+     * organization, an archived one, and a move across the personal workspace
+     * boundary.
+     */
+    teamId?: string;
 }
 interface ProjectWithServiceKey extends Project {
     serviceApiKey: string;
@@ -3887,18 +3295,16 @@ declare class ProjectsApiError extends Error {
     readonly operation: string;
     readonly originalError?: unknown | undefined;
     /**
-     * The status the platform answered with. Callers that resolve a
-     * `--project` selector through the listing branch on it: a 401/403 means
-     * the credential cannot see the listing at all, which is a different
-     * answer to the user than "no project of yours matches this name".
+     * The status the platform answered with. A 401/403 means the credential
+     * cannot see the listing at all -- a different answer than "no project
+     * of yours matches this name".
      */
     readonly status?: number | undefined;
     constructor(message: string, operation: string, originalError?: unknown | undefined, 
     /**
-     * The status the platform answered with. Callers that resolve a
-     * `--project` selector through the listing branch on it: a 401/403 means
-     * the credential cannot see the listing at all, which is a different
-     * answer to the user than "no project of yours matches this name".
+     * The status the platform answered with. A 401/403 means the credential
+     * cannot see the listing at all -- a different answer than "no project
+     * of yours matches this name".
      */
     status?: number | undefined);
 }
@@ -3910,11 +3316,9 @@ declare class ProjectsApiService {
         apiKey?: string;
     });
     /**
-     * Bearer, never the project-pinned Basic shape the data routes use. The
-     * listing is the question "which projects can this credential see?", so
-     * naming one project in the header would scope the answer to that project
-     * and defeat the call — including the `--project <slug>` lookup, which reads
-     * the listing precisely because it does not know the id yet.
+     * Bearer, never the project-pinned Basic shape: the listing asks "which
+     * projects can this credential see?", so naming one project in the header
+     * would scope the answer and defeat the call, including `--project <slug>`.
      */
     private headers;
     private request;
@@ -3937,17 +3341,107 @@ declare class ProjectsApiService {
 interface GetTraceParams {
     includeSpans?: boolean;
 }
-type GetTraceResponse = NonNullable<paths["/api/trace/{id}"]["get"]["responses"]["200"]["content"]["application/json"]>;
+/** The error block a trace or one of its parts carries when it failed. */
+interface TraceErrorCapture {
+    stacktrace?: string[];
+    message?: string;
+    has_error?: boolean;
+}
+/** One message in a span's chat input or output. */
+interface TraceChatMessage {
+    role?: string;
+    content?: string;
+}
+/** One span of a trace, as the trace read answers it. */
+interface TraceSpan {
+    trace_id?: string;
+    span_id?: string;
+    project_id?: string;
+    parent_id?: string | null;
+    name?: string | null;
+    type?: string;
+    model?: string;
+    timestamps?: {
+        started_at?: number;
+        first_token_at?: number;
+        finished_at?: number;
+        inserted_at?: number;
+        updated_at?: number;
+    };
+    error?: TraceErrorCapture | null;
+    params?: {
+        stream?: boolean;
+        temperature?: number;
+    };
+    metrics?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        tokens_estimated?: boolean;
+    };
+    input?: {
+        type?: string;
+        value?: TraceChatMessage[];
+    };
+    output?: {
+        type?: string;
+        value?: TraceChatMessage[];
+    };
+}
+/** One evaluation recorded against a trace. */
+interface TraceEvaluation {
+    evaluation_id?: string;
+    name?: string;
+    type?: string;
+    trace_id?: string;
+    project_id?: string;
+    status?: string;
+    timestamps?: {
+        inserted_at?: number;
+        updated_at?: number;
+    };
+    error?: TraceErrorCapture;
+}
+/**
+ * A single trace with its spans and evaluations. Hand-declared because the
+ * served OpenAPI document describes this answer as a free-form object, so the
+ * generated client cannot carry the shape callers read.
+ */
+interface GetTraceResponse {
+    trace_id?: string;
+    project_id?: string;
+    metadata?: {
+        sdk_version?: string;
+        sdk_language?: string;
+    };
+    timestamps?: {
+        started_at?: number;
+        inserted_at?: number;
+        updated_at?: number;
+    };
+    input?: {
+        value?: string;
+    };
+    output?: {
+        value?: string;
+    };
+    error?: TraceErrorCapture | null;
+    indexing_md5s?: string[];
+    spans?: TraceSpan[];
+    evaluations?: TraceEvaluation[];
+}
 
+/** `langwatch.traces`: the CLI's trace read, traced. Failures throw `TracesApiError`. */
 declare class TracesFacade {
     #private;
     constructor(config: InternalConfig);
-    get(traceId: string, params?: GetTraceParams): Promise<GetTraceResponse>;
+    /** `params` stays for compatibility; the endpoint takes no such option and never got one. */
+    get(traceId: string, _params?: GetTraceParams): Promise<GetTraceResponse>;
 }
 
 interface LangWatchConstructorOptions {
     apiKey?: string;
     endpoint?: string;
+    projectId?: string;
     options?: {
         logger?: Logger;
     };
@@ -3960,41 +3454,17 @@ declare class LangWatch {
     readonly datasets: DatasetsFacade;
     /**
      * Run experiments on LangWatch platform or via SDK.
-     *
-     * Platform experiments (CI/CD):
-     * ```typescript
-     * const result = await langwatch.experiments.run("my-experiment-slug");
-     * result.printSummary();
-     * ```
-     *
-     * SDK-defined experiments:
-     * ```typescript
-     * const experiment = await langwatch.experiments.init("my-experiment");
-     * // ... run evaluators using experiment.evaluate()
-     * ```
      */
     readonly experiments: ExperimentsFacade;
     /**
      * Run evaluators and guardrails in real-time (Online Evaluations).
-     *
      * @example
-     * ```typescript
-     * const guardrail = await langwatch.evaluations.evaluate("presidio/pii_detection", {
-     *   data: { input: userInput, output: generatedResponse },
-     *   name: "PII Detection",
-     *   asGuardrail: true,
-     * });
-     *
-     * if (!guardrail.passed) {
-     *   return "I'm sorry, I can't do that.";
-     * }
-     * ```
      */
     readonly evaluations: EvaluationsFacade;
     readonly evaluators: EvaluatorsApiService;
     readonly scenarios: ScenariosApiService;
     /**
-     * @deprecated Use runPlans and testSuites; /api/suites is a frozen alias.
+     * @deprecated Use runPlans and testSuites; /api/v1/suites is a frozen alias.
      */
     readonly suites: SuitesApiService;
     readonly runPlans: RunPlansApiService;
@@ -4004,10 +3474,13 @@ declare class LangWatch {
     readonly workflows: WorkflowsApiService;
     readonly agents: AgentsApiService;
     readonly annotations: AnnotationsApiService;
+    /** The project's dashboards and the widgets on them, over /api/v1/dashboards. */
     readonly dashboards: DashboardsApiService;
+    /** The Analytics Reports, over /api/v1/analytics/reports; the platform deprecates them. */
+    readonly analyticsReports: AnalyticsReportsApiService;
     readonly modelProviders: ModelProvidersApiService;
     readonly analytics: AnalyticsApiService;
-    /** The raw LangWatchQL door — run a governed SELECT or discover the analytics schema directly, outside a saved chart. */
+    /** The raw LangWatchQL door: a governed SELECT or schema discovery outside a saved chart. */
     readonly query: QueryApiService;
     readonly triggers: TriggersApiService;
     readonly graphs: GraphsApiService;
@@ -4021,13 +3494,8 @@ declare class LangWatch {
     constructor(options?: LangWatchConstructorOptions);
     get apiClient(): LangwatchApiClient;
     /**
-     * Teams, which group projects and the members who can reach them. These
-     * routes want an organization API key.
-     *
-     * Built on first use rather than in the constructor: the management
-     * families resolve their credential when constructed and refuse an empty
-     * one, so building this eagerly would make `new LangWatch()` throw for
-     * every caller that never touches a team.
+     * Teams, which group projects and the members who can reach them. These routes want an
+     * organization API key.
      */
     get teams(): TeamsApiService;
     /**
@@ -4039,43 +3507,10 @@ declare class LangWatch {
 
 /**
  * A failure the platform NAMED.
- *
- * The API does not merely fail — when it declines a request it says precisely
- * why, as a `HandledError` with a serialisable `kind` (`dataset_not_found`,
- * `validation_error`), the HTTP status it answers with, and a `meta` bag of the
- * context that makes the failure actionable. Until now the SDK collapsed all of
- * that into an English sentence on a generic error, so a caller could read the
- * failure but never react to it: a 404 "dataset not found" — a fact you can
- * offer to fix — was indistinguishable from a 500.
- *
- * This is that structure, kept. Narrow with {@link isLangWatchHandledError} (or
- * `instanceof`) and switch on `code`; `body` is the escape hatch to whatever the
- * platform sent that this class did not model.
- *
- * ```ts
- * try {
- *   await langwatch.datasets.get("nope");
- * } catch (error) {
- *   if (isLangWatchHandledError(error) && error.code === "dataset_not_found") {
- *     // Actionable: we know WHAT was not found, and can offer the list.
- *     console.error(error.meta.id, error.traceId);
- *   }
- *   throw error;
- * }
- * ```
- *
- * ONLY raised for a failure the platform named. An infrastructure failure — a
- * 5xx, a dead socket, a proxy's HTML error page — still raises the generic
- * service error it always did, because presenting one of those as a domain
- * error would blame the user for our outage.
  */
 declare class LangWatchHandledError extends Error {
     /**
-     * The discriminant. A boolean brand rather than `instanceof` alone because a
-     * bundled CLI and a consumer's `node_modules` copy of the SDK can hold two
-     * different copies of this class, and `instanceof` is false across that seam —
-     * the same reason the platform's own error handler tests for `code` rather
-     * than class identity.
+     * The discriminant.
      */
     readonly isLangWatchHandledError: true;
     /** The platform's serialisable discriminant, e.g. `dataset_not_found`. */
@@ -4096,7 +3531,9 @@ declare class LangWatchHandledError extends Error {
     /** A clickable link to the logs for that trace, when the route sent one. */
     readonly logsUrl: string | undefined;
     /** The failure behind the failure, when the route sent the chain. */
-    readonly reasons: CliHandledErrorReason[] | undefined;
+    readonly reasons: LangWatchHandledErrorReason[] | undefined;
+    /** Whether the platform explicitly marked this failure safe to retry. */
+    readonly retryable: boolean;
     /** What the user can DO about it, when the platform sent next steps. */
     readonly suggestions: string[] | undefined;
     /** The docs page that explains the failure, when the platform sent one. */
@@ -4106,18 +3543,13 @@ declare class LangWatchHandledError extends Error {
     /** What the SDK was doing, e.g. `get dataset "abc"`. */
     readonly operation: string | undefined;
     /**
-     * Alias of {@link httpStatus}, and the raw body again under the name the
-     * per-service `*ApiError` classes use.
-     *
-     * Not redundancy for its own sake: this class is thrown from the SAME code
-     * path that used to throw `TracesApiError` & friends, so anything that reads
-     * `.status` or `.originalError` off a caught SDK error — including the CLI's
-     * own telemetry reader — keeps working unchanged.
+     * Alias of {@link httpStatus}, and the raw body again under the name the per-service
+     * `*ApiError` classes use.
      */
     readonly status: number;
     readonly originalError: unknown;
     constructor({ handled, body, operation, message, }: {
-        handled: CliHandledError;
+        handled: LangWatchHandledErrorShape;
         body: unknown;
         operation?: string;
         message: string;
@@ -4135,43 +3567,22 @@ declare class LangWatchApiError extends Error {
 }
 
 /**
- * Receiver-side verification of a LangWatch webhook delivery.
- *
- * Every delivery carries
- *
- *   X-LangWatch-Signature: t=<unix seconds>,v1=<hex hmac-sha256>[,v1=<hex>]
- *
- * where each `v1` is HMAC-SHA256 over `"<t>.<raw body>"` under one currently
- * valid signing secret. `v1` REPEATS during a secret rotation, newest first,
- * which is what lets a receiver swap secrets on its own schedule instead of
- * dropping deliveries mid-swap.
- *
- * That repetition is the reason this helper exists. A hand-rolled parser that
- * keeps the LAST `v1` it sees, or splits the header into a flat key/value map,
- * rejects every delivery to a receiver that has already moved to the new
- * secret: the signature it kept is the one computed from the OLD secret. The
- * bug only appears during a rotation, which is exactly when a receiver can
- * least afford to be dropping deliveries.
- *
- * The algorithm here is pinned to the sender's by the vectors in
- * `specs/webhooks/signature-vectors.json`, generated from the server's own
- * signing code and asserted by the suite next to this file.
+ * Verify webhook delivery signature in X-LangWatch-Signature header.
+ * Handles secret rotation: v1 repeats with newest first.
+ * Pinned to sender's algorithm by specs/webhooks/signature-vectors.json.
  */
 /** The header a delivery carries its signature in. */
 declare const WEBHOOK_SIGNATURE_HEADER = "X-LangWatch-Signature";
 /**
- * Identifies one delivery ATTEMPT on the webhook platform's endpoints.
- *
- * The natural idempotency key for a receiver: retries of the same batch repeat
- * it, so a receiver that has already processed this id can acknowledge and
- * stop rather than applying the batch twice.
+ * Identifies one delivery ATTEMPT on the webhook platform's endpoints. The
+ * natural idempotency key: retries of the same batch repeat it, so a
+ * receiver that already processed this id can stop, not apply it twice.
  */
 declare const WEBHOOK_DELIVERY_ID_HEADER = "X-LangWatch-Delivery-Id";
 /**
  * The same role on automation deliveries (graph alerts and friends), which
- * group their attempts by the logical fire rather than by the batch.
- *
- * Two names because they are two senders: read whichever the delivery carries.
+ * group attempts by the logical fire rather than the batch. Two names
+ * because they are two senders: read whichever the delivery carries.
  */
 declare const WEBHOOK_EVENT_ID_HEADER = "X-LangWatch-Event-Id";
 /**
@@ -4180,22 +3591,12 @@ declare const WEBHOOK_EVENT_ID_HEADER = "X-LangWatch-Event-Id";
  */
 declare const WEBHOOK_SIGNATURE_DEFAULT_TOLERANCE_SECONDS = 300;
 /**
- * Why a delivery was refused. Switch on this rather than on the message: the
- * message is written for a human reading a log and will change, the code is
- * the contract.
- *
- * The three mean genuinely different things to an operator. `stale_timestamp`
- * is a clock or a replay and is worth alerting on; `invalid_signature` is a
- * wrong secret or a tampered body; `malformed_header` is almost always
- * something other than LangWatch posting to the URL.
+ * Why a delivery was refused: malformed_header, stale_timestamp, invalid_signature.
+ * Switch on code, not message; message is for logs and may change.
  */
 type WebhookSignatureFailureCode = "malformed_header" | "stale_timestamp" | "invalid_signature";
 /**
- * A delivery that did not verify.
- *
- * One class carrying a `code` rather than three classes, because the SDK and
- * the platform both ask callers to branch on a stable code instead of on the
- * error's identity, which does not survive a serialization boundary.
+ * A delivery that did not verify. Use code, not error type, to branch logic.
  */
 declare class WebhookSignatureVerificationError extends Error {
     readonly code: WebhookSignatureFailureCode;
@@ -4203,22 +3604,17 @@ declare class WebhookSignatureVerificationError extends Error {
 }
 interface VerifyWebhookSignatureOptions {
     /**
-     * The EXACT bytes of the request body, as received.
-     *
-     * Not a parsed object, and not the result of re-serializing one: the digest
-     * is over the bytes the sender hashed, and `JSON.parse` followed by
-     * `JSON.stringify` reorders keys, drops insignificant whitespace and
-     * re-escapes non-ASCII, any of which changes the digest. Read the raw body
-     * before your framework's JSON middleware does.
+     * The EXACT bytes of the request body, as received — not a parsed or
+     * re-serialized object: `JSON.stringify` reorders keys and re-escapes
+     * text, changing the digest. Read the raw body before your JSON middleware.
      */
     body: string | Uint8Array;
     /** The `X-LangWatch-Signature` header value, verbatim. */
     header: string;
     /**
      * The signing secret, or every secret this receiver currently accepts.
-     *
-     * Pass both values during a rotation and the delivery verifies under
-     * either, so there is no window where deliveries are refused.
+     * Pass both during a rotation and the delivery verifies under either, so
+     * there is no window where deliveries are refused.
      */
     secret: string | readonly string[];
     /**
@@ -4233,70 +3629,23 @@ interface VerifyWebhookSignatureOptions {
     nowSeconds?: number;
 }
 /**
- * Verify a webhook delivery, or throw explaining which check failed.
- *
- * ```ts
- * app.post("/langwatch", express.raw({ type: "application/json" }), (req, res) => {
- *   try {
- *     verifyWebhookSignature({
- *       body: req.body, // the raw Buffer, before JSON parsing
- *       header: req.header("X-LangWatch-Signature") ?? "",
- *       secret: [process.env.WEBHOOK_SECRET_NEW, process.env.WEBHOOK_SECRET_OLD],
- *     });
- *   } catch (error) {
- *     return res.status(400).send((error as WebhookSignatureVerificationError).code);
- *   }
- *   // Trusted from here.
- * });
- * ```
- *
- * Throws rather than returning false so that a delivery cannot be trusted by
- * forgetting to check a return value. The thrown
- * {@link WebhookSignatureVerificationError} carries a
- * {@link WebhookSignatureFailureCode} saying which check failed.
- *
- * Checks run in a fixed order, so a delivery that is both stale and wrongly
- * signed reports the staleness: a header that did not parse has no
- * trustworthy timestamp to judge, and a timestamp outside the window makes
- * the digest moot.
- *
- * A missing or empty secret is a configuration mistake rather than a bad
- * delivery, and raises `TypeError`. Reporting it as a failed verification
- * would let a receiver that lost its secret quietly refuse every delivery as
- * if the sender were at fault.
+ * Verify a webhook delivery, throwing (not returning false) so a check can't
+ * be skipped by accident. A missing/empty secret throws a plain `TypeError`
+ * instead of a verification failure, so it's never mistaken for sender fault.
  */
 declare function verifyWebhookSignature(options: VerifyWebhookSignatureOptions): void;
 
 /**
- * The one HTTP client every request to the LangWatch API goes through.
- *
- * A LangWatch endpoint configured as `http://app.langwatch.ai` answers with a
- * redirect to https. The global `fetch` follows it on its own and, for a 301
- * or 302, turns the POST into a GET and drops the body, so the event is lost
- * without an error. This client sends with `redirect: "manual"` and applies a
- * rule per method to the 3xx it gets back.
- *
- * GET and HEAD follow a 301, 302, 303, 307 or 308 with the same method, up to
- * five hops. A hop that keeps the origin, or only upgrades http to https on
- * the same host and port, keeps every header; any other hop drops the
- * credential headers first. A hop from https to http and a hop without a
- * Location are refused.
- *
- * Every other method follows exactly one redirect, and only when the target is
- * the same URL with the scheme changed from http to https (same host, port,
- * path and query). The replay uses the same method, headers and body bytes.
- *
- * Every refused redirect throws `LangWatchRedirectError`.
- *
- * This module depends on the SDK logger only, so the CLI boot graph and the
- * `agent` entry can import it without pulling anything else in.
+ * The one HTTP client every LangWatch API request goes through, with
+ * `redirect: "manual"` since the global `fetch` turns a POST into a GET on
+ * a redirect. GET/HEAD follow up to `MAX_FOLLOW_HOPS`; refusal throws.
  */
 
 declare class LangWatchRedirectError extends Error {
     readonly url: string;
     readonly location: string | null;
     readonly status: number;
-    constructor({ url, location, status, }: {
+    constructor({ url, location, status }: {
         url: string;
         location: string | null;
         status: number;
@@ -4323,4 +3672,4 @@ declare const logger: {
     NoOpLogger: typeof NoOpLogger;
 };
 
-export { type ArchivedProject, type ArchivedTeam, type BatchCreateRecordsResponse, type BudgetOnBreach, type BudgetScopeKind, type BudgetWindow, ComparisonError, type ComparisonMetric, type ComparisonOptions, type ComparisonStatus, type ComparisonVerdict, type CreateDatasetOptions, type CreateEvaluatorBody, type CreateFromUploadResponse, type CreateGatewayBudgetInput, type CreateGatewayBudgetScope, type CreateLangWatchFetchOptions, type CreateProjectInput, type CreateVirtualKeyInput, type CreateWebhookEndpointInput, type Dataset, DatasetApiError, type DatasetColumnType, type DatasetEntry, DatasetError, type DatasetListItem, type DatasetMetadata, DatasetNotFoundError, DatasetPlanLimitError, type DatasetRecordResponse, DatasetValidationError, DatasetsFacade, type DeleteRecordsResponse, type EmittedEvent, type EmittedEventsPage, type EndUserCap, type EndUserSpend, type EvaluateOptions, type EvaluationCost, EvaluationError, type EvaluationResult, type EvaluationStatus, EvaluationsApiError, EvaluationsFacade, EvaluatorCallError, EvaluatorError, type EvaluatorField, EvaluatorNotFoundError, type EvaluatorResponse, EvaluatorsApiError, EvaluatorsApiService, Experiment, ExperimentApiError, ExperimentError, type EvaluateOptions$1 as ExperimentEvaluateOptions, type EvaluationResult$1 as ExperimentEvaluationResult, type EvaluationStatus$1 as ExperimentEvaluationStatus, ExperimentInitError, type ExperimentInitOptions, type ExperimentRowResult, type ExperimentRunWithResults, ExperimentsFacade, FetchPolicy, type GatewayBudget, type GatewayBudgetPage, GatewayBudgetsApiError, GatewayBudgetsApiService, type GetDatasetOptions, type GetPromptOptions, IDEMPOTENCY_KEY_HEADER, IDEMPOTENT_REPLAY_HEADER, type IdempotentCreateOptions, LangWatch, LangWatchApiError, type LangWatchFetch, LangWatchHandledError, LangWatchRedirectError, type ListDatasetsApiResponse, type ListDatasetsOptions, type ListRecordsApiResponse, type ListRecordsOptions, type ListTeamsResponse, type LogOptions, type MutationOptions, type PaginatedProjects, type PaginatedResponse, type Pagination, type Project, type ProjectWithServiceKey, ProjectsApiError, ProjectsApiService, type RunCallback, type RunContext, type RunOptions, type RunWithResultsOptions, type SpendEvent, type SpendEventStatus, SpendEventsApiError, SpendEventsApiService, type SpendEventsPage, type SpendFilterOptions, type SpendGroupBy, type SpendReplayResult, type SpendSummariesOptions, type SpendSummariesPage, type SpendSummaryRow, type SpendSummaryStatus, type TargetInfo, type TargetMetadata, TargetMetadataConflictError, type TargetType, type Team, type TeamMember, type TeamPagination, TeamsApiError, TeamsApiService, type UpdateDatasetOptions, type UpdateGatewayBudgetInput, type UpdateProjectInput, type UpdateVirtualKeyInput, type UpdateWebhookEndpointInput, type UploadResponse, type VerifyWebhookSignatureOptions, type VirtualKey, type VirtualKeyBudgetInput, type VirtualKeyPage, type VirtualKeyRoutingMode, type VirtualKeyScope, type VirtualKeyScopeType, type VirtualKeySpendSummary, type VirtualKeyWithSecret, VirtualKeysApiError, VirtualKeysApiService, WEBHOOK_DELIVERY_ID_HEADER, WEBHOOK_EVENT_ID_HEADER, WEBHOOK_SIGNATURE_DEFAULT_TOLERANCE_SECONDS, WEBHOOK_SIGNATURE_HEADER, type WebhookDeliveryPage, type WebhookDeliveryRecord, type WebhookEndpointHealth, type WebhookEndpointSummary, type WebhookEndpointWithSecret, type WebhookEventType, type WebhookSignatureFailureCode, WebhookSignatureVerificationError, type WebhookTestResult, WebhooksApiError, WebhooksApiService, createLangWatchFetch, isLangWatchHandledError, langwatchFetch, logger, verifyWebhookSignature };
+export { type ArchivedProject, type ArchivedTeam, type BatchCreateRecordsResponse, type BudgetOnBreach, type BudgetScopeKind, type BudgetWindow, ComparisonError, type ComparisonMetric, type ComparisonOptions, type ComparisonStatus, type ComparisonVerdict, type CreateDatasetOptions, type CreateEvaluatorBody, type CreateFromUploadResponse, type CreateGatewayBudgetInput, type CreateGatewayBudgetScope, type CreateLangWatchFetchOptions, type CreateProjectInput, type CreateVirtualKeyInput, type CreateWebhookEndpointInput, type Dataset, DatasetApiError, type DatasetColumnType, type DatasetEntry, DatasetError, type DatasetListItem, type DatasetMetadata, DatasetNotFoundError, DatasetPlanLimitError, type DatasetRecordResponse, DatasetValidationError, DatasetsFacade, type DeleteRecordsResponse, type EmittedEvent, type EmittedEventsPage, type EndUserCap, type EndUserSpend, type EvaluateOptions, type EvaluationCost, EvaluationError, type EvaluationResult, type EvaluationStatus, EvaluationsApiError, EvaluationsFacade, EvaluatorCallError, EvaluatorError, type EvaluatorField, EvaluatorNotFoundError, type EvaluatorResponse, EvaluatorsApiError, EvaluatorsApiService, Experiment, ExperimentApiError, ExperimentError, type ExperimentEvaluateOptions, type ExperimentEvaluationResult, type ExperimentEvaluationStatus, ExperimentInitError, type ExperimentInitOptions, type ExperimentRowResult, type ExperimentRunWithResults, ExperimentsFacade, FetchPolicy, type GatewayBudget, type GatewayBudgetPage, GatewayBudgetsApiError, GatewayBudgetsApiService, type GetDatasetOptions, type GetPromptOptions, IDEMPOTENCY_KEY_HEADER, IDEMPOTENT_REPLAY_HEADER, type IdempotentCreateOptions, LangWatch, LangWatchApiError, type LangWatchFetch, LangWatchHandledError, LangWatchRedirectError, type ListDatasetsApiResponse, type ListDatasetsOptions, type ListRecordsApiResponse, type ListRecordsOptions, type ListTeamsResponse, type LogOptions, type MutationOptions, type PaginatedProjects, type PaginatedResponse, type Pagination, type Project, type ProjectWithServiceKey, ProjectsApiError, ProjectsApiService, type RunCallback, type RunContext, type RunOptions, type RunWithResultsOptions, type SpendEvent, type SpendEventStatus, SpendEventsApiError, SpendEventsApiService, type SpendEventsPage, type SpendFilterOptions, type SpendGroupBy, type SpendReplayResult, type SpendSummariesOptions, type SpendSummariesPage, type SpendSummaryRow, type SpendSummaryStatus, type TargetInfo, type TargetMetadata, TargetMetadataConflictError, type TargetType, type Team, type TeamMember, type TeamPagination, TeamsApiError, TeamsApiService, type UpdateDatasetOptions, type UpdateGatewayBudgetInput, type UpdateProjectInput, type UpdateVirtualKeyInput, type UpdateWebhookEndpointInput, type UploadResponse, type VerifyWebhookSignatureOptions, type VirtualKey, type VirtualKeyBudgetInput, type VirtualKeyPage, type VirtualKeyRoutingMode, type VirtualKeyScope, type VirtualKeyScopeType, type VirtualKeySpendSummary, type VirtualKeyWithSecret, VirtualKeysApiError, VirtualKeysApiService, WEBHOOK_DELIVERY_ID_HEADER, WEBHOOK_EVENT_ID_HEADER, WEBHOOK_SIGNATURE_DEFAULT_TOLERANCE_SECONDS, WEBHOOK_SIGNATURE_HEADER, type WebhookDeliveryPage, type WebhookDeliveryRecord, type WebhookEndpointHealth, type WebhookEndpointSummary, type WebhookEndpointWithSecret, type WebhookEventType, type WebhookSignatureFailureCode, WebhookSignatureVerificationError, type WebhookTestResult, WebhooksApiError, WebhooksApiService, createLangWatchFetch, isLangWatchHandledError, langwatchFetch, logger, verifyWebhookSignature };