@layerum-team/rag-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,447 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LayerumApiError: () => LayerumApiError,
+  LayerumClient: () => LayerumClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/error.ts
+var LayerumApiError = class extends Error {
+  status;
+  details;
+  path;
+  method;
+  constructor(message, status, details, method, path) {
+    super(message);
+    this.name = "LayerumApiError";
+    this.status = status;
+    this.details = details;
+    this.method = method;
+    this.path = path;
+  }
+};
+
+// src/http.ts
+function normalizeErrorMessage(payload, status) {
+  const fallback = `Request failed (${status})`;
+  if (!payload || typeof payload !== "object") return fallback;
+  const message = payload.message;
+  if (Array.isArray(message)) {
+    return message.map((item) => typeof item === "string" ? item : JSON.stringify(item)).join(", ");
+  }
+  if (typeof message === "string") return message;
+  if (message && typeof message === "object") {
+    const nested = message.message;
+    if (typeof nested === "string") return nested;
+  }
+  return fallback;
+}
+function shouldRetry(status, method, attempt, maxRetries) {
+  if (attempt >= maxRetries) return false;
+  if (method === "POST" || method === "PATCH" || method === "DELETE") return false;
+  return status === 429 || status >= 500;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var HttpClient = class {
+  baseUrl;
+  apiKey;
+  timeoutMs;
+  maxRetries;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.apiKey = options.apiKey;
+    this.timeoutMs = options.timeoutMs;
+    this.maxRetries = options.maxRetries;
+  }
+  async request(path, options = {}) {
+    const method = options.method ?? "GET";
+    let attempt = 0;
+    while (true) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+      try {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+          method,
+          headers: options.isFormData ? { Authorization: `Bearer ${this.apiKey}` } : {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: options.body === void 0 ? void 0 : options.isFormData ? options.body : JSON.stringify(options.body),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const payload = await response.json().catch(() => null);
+          const message = normalizeErrorMessage(payload, response.status);
+          if (shouldRetry(response.status, method, attempt, this.maxRetries)) {
+            attempt += 1;
+            await sleep(250 * attempt);
+            continue;
+          }
+          throw new LayerumApiError(
+            message,
+            response.status,
+            payload?.details,
+            method,
+            path
+          );
+        }
+        if (response.status === 204) return void 0;
+        return await response.json();
+      } catch (error) {
+        if (error instanceof LayerumApiError) throw error;
+        const message = error instanceof Error ? error.message : "Unknown network error";
+        throw new LayerumApiError(
+          `Network error while ${method} ${path}: ${message}`,
+          0,
+          error,
+          method,
+          path
+        );
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+  }
+};
+
+// src/client.ts
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function toBlob(file) {
+  if (typeof Blob !== "undefined" && file instanceof Blob) return file;
+  if (file instanceof ArrayBuffer) return new Blob([file]);
+  if (file instanceof Uint8Array) {
+    return new Blob([file]);
+  }
+  return new Blob([file]);
+}
+function unwrapItems(payload) {
+  if (!payload) return [];
+  if (Array.isArray(payload)) return payload;
+  return payload.items ?? [];
+}
+var EntitiesApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(parentId) {
+    const payload = await this.http.request("/v1/entities");
+    const items = unwrapItems(payload);
+    if (!parentId) return items;
+    return items.filter(
+      (item) => (item.parentId ?? item.parent_id ?? null) === parentId
+    );
+  }
+  async tree() {
+    const payload = await this.http.request("/v1/entities/tree");
+    return unwrapItems(payload);
+  }
+  create(input) {
+    return this.http.request("/v1/entities", {
+      method: "POST",
+      body: {
+        entity_type_id: input.entityTypeId,
+        name: input.name,
+        description: input.description,
+        parent_id: input.parentId,
+        metadata: input.metadata
+      }
+    });
+  }
+  remove(entityId) {
+    return this.http.request(`/v1/entities/${entityId}`, {
+      method: "DELETE"
+    });
+  }
+};
+var EntityTypesApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const payload = await this.http.request(
+      "/v1/entity-types"
+    );
+    return unwrapItems(payload);
+  }
+  get(entityTypeId) {
+    return this.http.request(`/v1/entity-types/${entityTypeId}`);
+  }
+  create(input) {
+    return this.http.request("/v1/entity-types", {
+      method: "POST",
+      body: {
+        name: input.name,
+        label: input.label
+      }
+    });
+  }
+  remove(entityTypeId) {
+    return this.http.request(
+      `/v1/entity-types/${entityTypeId}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+};
+var DocumentsApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(input) {
+    const path = input.allInWorkspace ? "/v1/documents" : `/v1/entities/${input.entityId}/documents`;
+    const payload = await this.http.request(path);
+    return unwrapItems(payload);
+  }
+  get(entityId, sourceId) {
+    return this.http.request(
+      `/v1/entities/${entityId}/documents/${sourceId}`
+    );
+  }
+  upload(input) {
+    const form = new FormData();
+    form.set("file", toBlob(input.file), input.fileName);
+    if (input.visibility) form.set("visibility", input.visibility);
+    if (input.modelConfigId) form.set("model_config_id", input.modelConfigId);
+    return this.http.request(
+      `/v1/entities/${input.entityId}/documents/upload`,
+      {
+        method: "POST",
+        body: form,
+        isFormData: true
+      }
+    );
+  }
+  uploadInit(input) {
+    return this.http.request(
+      `/v1/entities/${input.entityId}/documents/upload/init`,
+      {
+        method: "POST",
+        body: {
+          file_name: input.fileName,
+          file_size_bytes: input.fileSizeBytes,
+          content_type: input.contentType,
+          visibility: input.visibility,
+          model_config_id: input.modelConfigId
+        }
+      }
+    );
+  }
+  uploadComplete(input) {
+    return this.http.request(
+      `/v1/entities/${input.entityId}/documents/upload/complete`,
+      {
+        method: "POST",
+        body: {
+          upload_id: input.uploadId,
+          display_name: input.displayName,
+          visibility: input.visibility,
+          model_config_id: input.modelConfigId,
+          checksum: input.checksum
+        }
+      }
+    );
+  }
+  async uploadDirect(input) {
+    const blob = toBlob(input.file);
+    const contentType = input.contentType || blob.type || "application/octet-stream";
+    const initialized = await this.uploadInit({
+      entityId: input.entityId,
+      fileName: input.fileName,
+      fileSizeBytes: blob.size,
+      contentType,
+      visibility: input.visibility,
+      modelConfigId: input.modelConfigId
+    });
+    const form = new FormData();
+    for (const [key, value] of Object.entries(initialized.fields ?? {})) {
+      form.set(key, value);
+    }
+    form.set("file", blob, input.fileName);
+    const uploadRes = await fetch(initialized.uploadUrl, {
+      method: initialized.method ?? "POST",
+      body: form
+    });
+    if (!uploadRes.ok) {
+      throw new Error(`Direct upload failed with status ${uploadRes.status}`);
+    }
+    return this.uploadComplete({
+      entityId: input.entityId,
+      uploadId: initialized.uploadId,
+      displayName: input.fileName,
+      visibility: input.visibility,
+      modelConfigId: input.modelConfigId
+    });
+  }
+  createText(input) {
+    return this.http.request(`/v1/entities/${input.entityId}/documents`, {
+      method: "POST",
+      body: {
+        source_type: "text",
+        display_name: input.displayName,
+        raw_text: input.rawText,
+        visibility: input.visibility ?? "self_and_descendants",
+        model_config_id: input.modelConfigId
+      }
+    });
+  }
+  createUrl(input) {
+    return this.http.request(`/v1/entities/${input.entityId}/documents`, {
+      method: "POST",
+      body: {
+        source_type: "url",
+        display_name: input.displayName,
+        source_url: input.sourceUrl,
+        visibility: input.visibility ?? "self_and_descendants",
+        model_config_id: input.modelConfigId
+      }
+    });
+  }
+  remove(input) {
+    return this.http.request(
+      `/v1/entities/${input.entityId}/documents/${input.sourceId}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+};
+var IngestionApi = class {
+  constructor(http, documentsApi) {
+    this.http = http;
+    this.documentsApi = documentsApi;
+  }
+  retry(input) {
+    return this.http.request(
+      `/v1/entities/${input.entityId}/documents/${input.sourceId}/retry`,
+      {
+        method: "POST"
+      }
+    );
+  }
+  error(input) {
+    return this.http.request(
+      `/v1/entities/${input.entityId}/documents/${input.sourceId}/error`
+    );
+  }
+  async waitUntilReady(input) {
+    const timeoutMs = input.timeoutMs ?? 12e4;
+    const intervalMs = input.intervalMs ?? 2e3;
+    const start = Date.now();
+    while (true) {
+      const source = await this.documentsApi.get(input.entityId, input.sourceId);
+      if (source.status === "completed") return source;
+      if (source.status === "failed") {
+        const details = await this.error({
+          entityId: input.entityId,
+          sourceId: input.sourceId
+        }).catch(() => null);
+        throw new Error(
+          `Ingestion failed for source ${input.sourceId}${details?.latestJob?.error_message ? `: ${details.latestJob.error_message}` : ""}`
+        );
+      }
+      if (Date.now() - start >= timeoutMs) {
+        throw new Error(
+          `Timed out waiting for source ${input.sourceId} to complete ingestion`
+        );
+      }
+      await sleep2(intervalMs);
+    }
+  }
+};
+var QueryApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  run(input) {
+    return this.http.request("/v1/query", {
+      method: "POST",
+      body: {
+        entityId: input.entityId,
+        modelConfigId: input.modelConfigId,
+        query: input.query,
+        topK: input.topK,
+        includeParentScopes: input.includeParentScopes
+      }
+    });
+  }
+  runDebug(input) {
+    return this.http.request("/v1/query/debug", {
+      method: "POST",
+      body: {
+        entityId: input.entityId,
+        modelConfigId: input.modelConfigId,
+        query: input.query,
+        topK: input.topK,
+        includeParentScopes: input.includeParentScopes
+      }
+    });
+  }
+};
+var ModelsApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async listConfigs() {
+    const payload = await this.http.request("/v1/models");
+    return unwrapItems(payload);
+  }
+  async listDefinitions(input) {
+    const query = input?.type ? `?type=${encodeURIComponent(input.type)}` : "";
+    const payload = await this.http.request(
+      `/v1/model-definitions${query}`
+    );
+    return unwrapItems(payload);
+  }
+};
+var LayerumClient = class {
+  entities;
+  entityTypes;
+  documents;
+  ingestion;
+  query;
+  models;
+  constructor(options) {
+    const http = new HttpClient({
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl ?? "http://localhost:4000",
+      timeoutMs: options.timeoutMs ?? 3e4,
+      maxRetries: options.maxRetries ?? 2
+    });
+    this.entities = new EntitiesApi(http);
+    this.entityTypes = new EntityTypesApi(http);
+    this.documents = new DocumentsApi(http);
+    this.ingestion = new IngestionApi(http, this.documents);
+    this.query = new QueryApi(http);
+    this.models = new ModelsApi(http);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LayerumApiError,
+  LayerumClient
+});