langwatch 0.32.0 → 0.33.0

package/dist/chunk-ZJ2OCF6J.mjs

@@ -1,663 +0,0 @@
-import {
-  createTracingProxy
-} from "./chunk-FG3JQBJB.mjs";
-import {
-  getLangWatchTracer
-} from "./chunk-Y4VNZ6M4.mjs";
-import {
-  buildAuthHeaders
-} from "./chunk-SIXSSID3.mjs";
-import {
-  LANGWATCH_SDK_NAME_CLIENT,
-  LANGWATCH_SDK_VERSION
-} from "./chunk-QMULACG7.mjs";
-import {
-  formatApiErrorMessage
-} from "./chunk-J3KM7ZO7.mjs";
-import {
-  __privateAdd,
-  __privateGet,
-  __privateSet
-} from "./chunk-BAX4W3AY.mjs";
-
-// src/client-sdk/services/datasets/errors.ts
-var DatasetError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "DatasetError";
-  }
-};
-var DatasetNotFoundError = class extends DatasetError {
-  constructor(slugOrId) {
-    super(`Dataset not found: ${slugOrId}`);
-    this.name = "DatasetNotFoundError";
-  }
-};
-var DatasetApiError = class extends DatasetError {
-  constructor(message, status, operation, originalError) {
-    super(message);
-    this.name = "DatasetApiError";
-    this.status = status;
-    this.operation = operation;
-    this.originalError = originalError;
-  }
-};
-var DatasetValidationError = class extends DatasetError {
-  constructor(message) {
-    super(message);
-    this.name = "DatasetValidationError";
-  }
-};
-var DatasetPlanLimitError = class extends DatasetError {
-  constructor(message, originalError) {
-    super(message);
-    this.name = "DatasetPlanLimitError";
-    if (originalError != null && typeof originalError === "object") {
-      const err = originalError;
-      this.limitType = typeof err.limitType === "string" ? err.limitType : "datasets";
-      this.current = typeof err.current === "number" ? err.current : void 0;
-      this.max = typeof err.max === "number" ? err.max : void 0;
-    } else {
-      this.limitType = "datasets";
-    }
-  }
-};
-
-// src/client-sdk/services/datasets/tracing/tracer.ts
-var tracer = getLangWatchTracer(`${LANGWATCH_SDK_NAME_CLIENT}.datasets`, LANGWATCH_SDK_VERSION);
-
-// src/client-sdk/services/datasets/dataset.service.ts
-var DatasetService = class {
-  constructor(config) {
-    this.config = config;
-    return createTracingProxy(this, tracer);
-  }
-  /**
-   * Handles API errors by mapping status codes to appropriate error types.
-   * @param operation - Description of the operation being performed
-   * @param error - The error object from the API response
-   * @param status - The HTTP status code
-   * @param slugOrId - The dataset identifier (only passed for operations targeting an existing resource)
-   */
-  handleApiError(operation, error, status, slugOrId) {
-    if (status === 404 && slugOrId) {
-      throw new DatasetNotFoundError(slugOrId);
-    }
-    if (status === 403) {
-      const errorMessage2 = this.extractErrorMessage(error, status);
-      throw new DatasetPlanLimitError(errorMessage2, error);
-    }
-    const errorMessage = this.extractErrorMessage(error, status);
-    throw new DatasetApiError(
-      `Failed to ${operation}: ${errorMessage}`,
-      status,
-      operation,
-      error
-    );
-  }
-  /**
-   * Extracts a human-readable error message from an API error response.
-   */
-  extractErrorMessage(error, status) {
-    return formatApiErrorMessage({ error, options: { status } });
-  }
-  /**
-   * Wrapper for API calls to endpoints not yet in the generated OpenAPI types.
-   * Quarantines `as any` casts to a single location.
-   */
-  untypedRequest(method, path, options) {
-    return this.config.langwatchApiClient[method](path, options);
-  }
-  /**
-   * Unwraps an API response, throwing a mapped error if the response contains an error.
-   * Centralizes the repeated `if (error) handleApiError; return data` pattern.
-   */
-  unwrapResponse(response, operation, slugOrId) {
-    if (response.error) {
-      this.handleApiError(operation, response.error, response.response.status, slugOrId);
-    }
-    return response.data;
-  }
-  /**
-   * Fetches a dataset by its slug or ID, returning metadata and entries.
-   *
-   * @param slugOrId - The slug or ID of the dataset
-   * @param _options - Optional configuration
-   * @returns The dataset with metadata and entries
-   */
-  async getDataset(slugOrId, _options) {
-    this.config.logger.debug(`Fetching dataset: ${slugOrId}`);
-    const response = await this.config.langwatchApiClient.GET(
-      "/api/dataset/{slugOrId}",
-      {
-        params: {
-          path: {
-            slugOrId
-          }
-        }
-      }
-    );
-    const data = this.unwrapResponse(
-      response,
-      `fetch dataset "${slugOrId}"`,
-      slugOrId
-    );
-    const entries = data.data.map((item) => ({
-      id: item.id,
-      datasetId: item.datasetId,
-      projectId: item.projectId,
-      entry: item.entry,
-      createdAt: item.createdAt,
-      updatedAt: item.updatedAt
-    }));
-    this.config.logger.debug(
-      `Fetched dataset ${slugOrId} with ${entries.length} entries`
-    );
-    return {
-      id: data.id,
-      name: data.name,
-      slug: data.slug,
-      columnTypes: data.columnTypes,
-      createdAt: data.createdAt,
-      updatedAt: data.updatedAt,
-      entries
-    };
-  }
-  /**
-   * Lists all datasets for the project, with optional pagination.
-   */
-  async listDatasets(options) {
-    this.config.logger.debug("Listing datasets");
-    const response = await this.untypedRequest("GET", "/api/dataset", {
-      params: {
-        query: {
-          page: options == null ? void 0 : options.page,
-          limit: options == null ? void 0 : options.limit
-        }
-      }
-    });
-    return this.unwrapResponse(
-      response,
-      "list datasets"
-    );
-  }
-  /**
-   * Creates a new dataset.
-   */
-  async createDataset(options) {
-    var _a;
-    this.config.logger.debug(`Creating dataset: ${options.name}`);
-    const response = await this.untypedRequest("POST", "/api/dataset", {
-      body: {
-        name: options.name,
-        columnTypes: (_a = options.columnTypes) != null ? _a : []
-      }
-    });
-    return this.unwrapResponse(
-      response,
-      `create dataset "${options.name}"`
-    );
-  }
-  /**
-   * Updates a dataset by its slug or ID.
-   */
-  async updateDataset(slugOrId, options) {
-    this.config.logger.debug(`Updating dataset: ${slugOrId}`);
-    const response = await this.untypedRequest("PATCH", "/api/dataset/{slugOrId}", {
-      params: {
-        path: { slugOrId }
-      },
-      body: options
-    });
-    return this.unwrapResponse(
-      response,
-      `update dataset "${slugOrId}"`,
-      slugOrId
-    );
-  }
-  /**
-   * Deletes (archives) a dataset by its slug or ID.
-   */
-  async deleteDataset(slugOrId) {
-    this.config.logger.debug(`Deleting dataset: ${slugOrId}`);
-    const response = await this.untypedRequest("DELETE", "/api/dataset/{slugOrId}", {
-      params: {
-        path: { slugOrId }
-      }
-    });
-    return this.unwrapResponse(
-      response,
-      `delete dataset "${slugOrId}"`,
-      slugOrId
-    );
-  }
-  /**
-   * Creates records in a dataset in batch.
-   */
-  async createRecords(slugOrId, entries) {
-    this.config.logger.debug(`Creating ${entries.length} records in dataset: ${slugOrId}`);
-    const response = await this.untypedRequest("POST", "/api/dataset/{slugOrId}/records", {
-      params: {
-        path: { slugOrId }
-      },
-      body: { entries }
-    });
-    return this.unwrapResponse(
-      response,
-      `create records in dataset "${slugOrId}"`,
-      slugOrId
-    );
-  }
-  /**
-   * Updates a single record in a dataset.
-   */
-  async updateRecord(slugOrId, recordId, entry) {
-    this.config.logger.debug(`Updating record ${recordId} in dataset: ${slugOrId}`);
-    const response = await this.untypedRequest("PATCH", "/api/dataset/{slugOrId}/records/{recordId}", {
-      params: {
-        path: { slugOrId, recordId }
-      },
-      body: { entry }
-    });
-    return this.unwrapResponse(
-      response,
-      `update record "${recordId}" in dataset "${slugOrId}"`,
-      slugOrId
-    );
-  }
-  /**
-   * Deletes records from a dataset by IDs.
-   */
-  async deleteRecords(slugOrId, recordIds) {
-    this.config.logger.debug(`Deleting ${recordIds.length} records from dataset: ${slugOrId}`);
-    const response = await this.untypedRequest("DELETE", "/api/dataset/{slugOrId}/records", {
-      params: {
-        path: { slugOrId }
-      },
-      body: { recordIds }
-    });
-    return this.unwrapResponse(
-      response,
-      `delete records from dataset "${slugOrId}"`,
-      slugOrId
-    );
-  }
-  /**
-   * 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
-   */
-  async listRecords(slugOrId, options) {
-    this.config.logger.debug(`Listing records for dataset: ${slugOrId}`);
-    const response = await this.untypedRequest("GET", "/api/dataset/{slugOrId}/records", {
-      params: {
-        path: { slugOrId },
-        query: {
-          page: options == null ? void 0 : options.page,
-          limit: options == null ? void 0 : options.limit
-        }
-      }
-    });
-    return this.unwrapResponse(
-      response,
-      `list records in dataset "${slugOrId}"`,
-      slugOrId
-    );
-  }
-  /**
-   * Sends a multipart/form-data request using raw fetch.
-   * openapi-fetch hardcodes content-type: application/json, so file uploads
-   * must bypass it. This helper centralizes URL building, auth headers,
-   * error parsing, and response unwrapping.
-   *
-   * @param path - The API path (appended to the endpoint)
-   * @param formData - The FormData payload
-   * @param operation - Human-readable operation name for error messages
-   * @param slugOrId - Optional dataset identifier (passed to handleApiError for 404 mapping)
-   */
-  async fetchMultipart(path, formData, operation, slugOrId) {
-    const { endpoint, apiKey } = this.config;
-    const url = `${endpoint.replace(/\/$/, "")}${path}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: buildAuthHeaders({ apiKey }),
-      body: formData
-    });
-    if (!response.ok) {
-      const rawBody = await response.text();
-      let errorBody = rawBody;
-      if (rawBody) {
-        try {
-          errorBody = JSON.parse(rawBody);
-        } catch (e) {
-        }
-      }
-      this.handleApiError(operation, errorBody, response.status, slugOrId);
-    }
-    return await response.json();
-  }
-  /**
-   * Creates a new dataset from a file upload.
-   *
-   * @param options - The dataset name and file to upload
-   * @returns The created dataset metadata with record count
-   */
-  async createDatasetFromUpload(options) {
-    this.config.logger.debug(`Creating dataset from upload: ${options.name}`);
-    const formData = new FormData();
-    formData.append("name", options.name);
-    formData.append("file", options.file);
-    return this.fetchMultipart(
-      "/api/dataset/upload",
-      formData,
-      `create dataset from upload "${options.name}"`
-    );
-  }
-  /**
-   * Uploads a file with a strategy for handling existing datasets.
-   *
-   * @param slugOrId - The slug or ID of the dataset
-   * @param file - The file to upload (File or Blob)
-   * @param ifExists - Strategy when dataset exists: "append" (default), "replace", or "error"
-   * @returns The upload result
-   */
-  async uploadWithStrategy(slugOrId, file, ifExists = "append") {
-    switch (ifExists) {
-      case "append":
-        return this._uploadAppend(slugOrId, file);
-      case "replace":
-        return this._uploadReplace(slugOrId, file);
-      case "error":
-        return this._uploadError(slugOrId, file);
-    }
-  }
-  /**
-   * Converts a CreateFromUploadResponse to the unified UploadResponse shape.
-   */
-  toUploadResponse(result) {
-    return {
-      dataset: {
-        id: result.id,
-        name: result.name,
-        slug: result.slug,
-        columnTypes: result.columnTypes,
-        createdAt: result.createdAt,
-        updatedAt: result.updatedAt
-      },
-      recordsCreated: result.recordsCreated,
-      datasetId: result.id
-    };
-  }
-  /**
-   * Append strategy: try uploading to existing dataset; if not found, create from file.
-   */
-  async _uploadAppend(slugOrId, file) {
-    try {
-      return await this.uploadFile(slugOrId, file);
-    } catch (error) {
-      if (error instanceof DatasetNotFoundError) {
-        return this.toUploadResponse(await this.createDatasetFromUpload({ name: slugOrId, file }));
-      }
-      throw error;
-    }
-  }
-  /**
-   * Replace strategy: if dataset exists, delete all records then upload; if not found, create from file.
-   */
-  async _uploadReplace(slugOrId, file) {
-    try {
-      await this.getDataset(slugOrId);
-      await this._deleteAllRecords(slugOrId);
-      return await this.uploadFile(slugOrId, file);
-    } catch (error) {
-      if (error instanceof DatasetNotFoundError) {
-        return this.toUploadResponse(await this.createDatasetFromUpload({ name: slugOrId, file }));
-      }
-      throw error;
-    }
-  }
-  /**
-   * Error strategy: if dataset exists, throw 409; if not found, create from file.
-   */
-  async _uploadError(slugOrId, file) {
-    let datasetExists = false;
-    try {
-      await this.getDataset(slugOrId);
-      datasetExists = true;
-    } catch (error) {
-      if (!(error instanceof DatasetNotFoundError)) {
-        throw error;
-      }
-    }
-    if (datasetExists) {
-      throw new DatasetApiError(
-        `Dataset already exists: ${slugOrId}`,
-        409,
-        "upload"
-      );
-    }
-    return this.toUploadResponse(await this.createDatasetFromUpload({ name: slugOrId, file }));
-  }
-  /**
-   * Deletes all records from a dataset by iterating through pages.
-   * Always fetches page 1 since records shift after deletion.
-   * Includes a safety valve to prevent infinite loops.
-   */
-  async _deleteAllRecords(slugOrId) {
-    const BATCH_SIZE = 1e3;
-    const MAX_DELETE_ITERATIONS = 100;
-    let iteration = 0;
-    while (iteration < MAX_DELETE_ITERATIONS) {
-      const page = await this.listRecords(slugOrId, { page: 1, limit: BATCH_SIZE });
-      if (page.data.length === 0) {
-        return;
-      }
-      const ids = page.data.map((record) => record.id);
-      await this.deleteRecords(slugOrId, ids);
-      iteration++;
-    }
-    throw new DatasetApiError(
-      `Failed to delete all records from dataset "${slugOrId}": exceeded ${MAX_DELETE_ITERATIONS} iterations`,
-      0,
-      `delete all records from dataset "${slugOrId}"`
-    );
-  }
-  /**
-   * Uploads a file to an existing dataset.
-   */
-  async uploadFile(slugOrId, file) {
-    this.config.logger.debug(`Uploading file to dataset: ${slugOrId}`);
-    const formData = new FormData();
-    formData.append("file", file);
-    return this.fetchMultipart(
-      `/api/dataset/${encodeURIComponent(slugOrId)}/upload`,
-      formData,
-      `upload file to dataset "${slugOrId}"`,
-      slugOrId
-    );
-  }
-};
-
-// src/client-sdk/services/datasets/datasets.facade.ts
-var _datasetService;
-var DatasetsFacade = class {
-  constructor(config) {
-    __privateAdd(this, _datasetService);
-    /**
-     * Lists all datasets for the project, with optional pagination.
-     *
-     * @param options - Pagination options (page, limit)
-     * @returns Paginated list of datasets with metadata
-     */
-    this.list = (options) => {
-      return __privateGet(this, _datasetService).listDatasets(options);
-    };
-    /**
-     * Creates a new dataset.
-     *
-     * @param options - Dataset creation options (name, columnTypes)
-     * @returns The created dataset metadata
-     */
-    this.create = (options) => {
-      if (!options.name || options.name.trim().length === 0) {
-        throw new DatasetValidationError("Dataset name must not be empty");
-      }
-      return __privateGet(this, _datasetService).createDataset(options);
-    };
-    /**
-     * 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);
-     * }
-     * ```
-     */
-    this.get = (slugOrId, options) => {
-      return __privateGet(this, _datasetService).getDataset(slugOrId, options);
-    };
-    /**
-     * 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
-     */
-    this.update = (slugOrId, options) => {
-      if (options.name == null && options.columnTypes == null) {
-        throw new DatasetValidationError(
-          "At least one field (name or columnTypes) must be provided for update"
-        );
-      }
-      return __privateGet(this, _datasetService).updateDataset(slugOrId, options);
-    };
-    /**
-     * 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
-     */
-    this.delete = (slugOrId) => {
-      return __privateGet(this, _datasetService).deleteDataset(slugOrId);
-    };
-    /**
-     * 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
-     */
-    this.createRecords = (slugOrId, entries) => {
-      if (!entries || entries.length === 0) {
-        throw new DatasetValidationError("Entries must not be empty");
-      }
-      return __privateGet(this, _datasetService).createRecords(slugOrId, entries);
-    };
-    /**
-     * 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
-     * @returns The updated record
-     */
-    this.updateRecord = (slugOrId, recordId, entry) => {
-      return __privateGet(this, _datasetService).updateRecord(slugOrId, recordId, entry);
-    };
-    /**
-     * 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
-     */
-    this.deleteRecords = (slugOrId, recordIds) => {
-      return __privateGet(this, _datasetService).deleteRecords(slugOrId, recordIds);
-    };
-    /**
-     * 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 });
-     * ```
-     */
-    this.listRecords = (slugOrId, options) => {
-      return __privateGet(this, _datasetService).listRecords(slugOrId, options);
-    };
-    /**
-     * 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.
-     *
-     * @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" });
-     * ```
-     */
-    this.upload = (slugOrId, file, options) => {
-      var _a;
-      if (!file) {
-        throw new DatasetValidationError("File must be provided for upload");
-      }
-      return __privateGet(this, _datasetService).uploadWithStrategy(
-        slugOrId,
-        file,
-        (_a = options == null ? void 0 : options.ifExists) != null ? _a : "append"
-      );
-    };
-    __privateSet(this, _datasetService, new DatasetService(config));
-  }
-};
-_datasetService = new WeakMap();
-
-export {
-  DatasetError,
-  DatasetNotFoundError,
-  DatasetApiError,
-  DatasetValidationError,
-  DatasetPlanLimitError,
-  DatasetService,
-  DatasetsFacade
-};
-//# sourceMappingURL=chunk-ZJ2OCF6J.mjs.map