@memorylayerai/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,709 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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/errors.ts
+var MemoryLayerError, AuthenticationError, RateLimitError, ValidationError, NetworkError, APIError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    MemoryLayerError = class _MemoryLayerError extends Error {
+      constructor(message, statusCode, requestId, details) {
+        super(message);
+        this.statusCode = statusCode;
+        this.requestId = requestId;
+        this.details = details;
+        this.name = "MemoryLayerError";
+        Object.setPrototypeOf(this, _MemoryLayerError.prototype);
+      }
+    };
+    AuthenticationError = class _AuthenticationError extends MemoryLayerError {
+      constructor(message, requestId) {
+        super(message, 401, requestId);
+        this.name = "AuthenticationError";
+        Object.setPrototypeOf(this, _AuthenticationError.prototype);
+      }
+    };
+    RateLimitError = class _RateLimitError extends MemoryLayerError {
+      constructor(message, retryAfter, requestId) {
+        super(message, 429, requestId);
+        this.retryAfter = retryAfter;
+        this.name = "RateLimitError";
+        Object.setPrototypeOf(this, _RateLimitError.prototype);
+      }
+    };
+    ValidationError = class _ValidationError extends MemoryLayerError {
+      constructor(message, errors, requestId) {
+        super(message, 400, requestId);
+        this.errors = errors;
+        this.name = "ValidationError";
+        Object.setPrototypeOf(this, _ValidationError.prototype);
+      }
+    };
+    NetworkError = class _NetworkError extends MemoryLayerError {
+      constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "NetworkError";
+        Object.setPrototypeOf(this, _NetworkError.prototype);
+      }
+    };
+    APIError = class _APIError extends MemoryLayerError {
+      constructor(message, statusCode, requestId, details) {
+        super(message, statusCode, requestId, details);
+        this.name = "APIError";
+        Object.setPrototypeOf(this, _APIError.prototype);
+      }
+    };
+  }
+});
+
+// src/resources/memories.ts
+var memories_exports = {};
+__export(memories_exports, {
+  MemoriesResource: () => MemoriesResource
+});
+var MemoriesResource;
+var init_memories = __esm({
+  "src/resources/memories.ts"() {
+    "use strict";
+    init_errors();
+    MemoriesResource = class {
+      constructor(httpClient) {
+        this.httpClient = httpClient;
+      }
+      /**
+       * Add a new memory
+       * @param request - Memory creation request
+       * @returns The created memory
+       */
+      async add(request) {
+        if (!request.content || request.content.trim().length === 0) {
+          throw new ValidationError(
+            "Memory content cannot be empty",
+            [{ field: "content", message: "Content is required and cannot be empty" }]
+          );
+        }
+        if (!request.projectId || request.projectId.trim().length === 0) {
+          throw new ValidationError(
+            "Project ID is required",
+            [{ field: "projectId", message: "Project ID is required" }]
+          );
+        }
+        return this.httpClient.request({
+          method: "POST",
+          path: "/v1/memories",
+          body: request
+        });
+      }
+      /**
+       * Get a memory by ID
+       * @param id - Memory ID
+       * @returns The memory
+       */
+      async get(id) {
+        if (!id || id.trim().length === 0) {
+          throw new ValidationError(
+            "Memory ID is required",
+            [{ field: "id", message: "Memory ID is required" }]
+          );
+        }
+        return this.httpClient.request({
+          method: "GET",
+          path: `/v1/memories/${id}`
+        });
+      }
+      /**
+       * Update a memory
+       * @param id - Memory ID
+       * @param request - Update request
+       * @returns The updated memory
+       */
+      async update(id, request) {
+        if (!id || id.trim().length === 0) {
+          throw new ValidationError(
+            "Memory ID is required",
+            [{ field: "id", message: "Memory ID is required" }]
+          );
+        }
+        if (!request.content && !request.metadata) {
+          throw new ValidationError(
+            "At least one of content or metadata must be provided",
+            [{ field: "request", message: "Nothing to update" }]
+          );
+        }
+        return this.httpClient.request({
+          method: "PATCH",
+          path: `/v1/memories/${id}`,
+          body: request
+        });
+      }
+      /**
+       * Delete a memory
+       * @param id - Memory ID
+       */
+      async delete(id) {
+        if (!id || id.trim().length === 0) {
+          throw new ValidationError(
+            "Memory ID is required",
+            [{ field: "id", message: "Memory ID is required" }]
+          );
+        }
+        await this.httpClient.request({
+          method: "DELETE",
+          path: `/v1/memories/${id}`
+        });
+      }
+      /**
+       * List memories
+       * @param request - List request with filters
+       * @returns Array of memories
+       */
+      async list(request) {
+        if (!request.projectId || request.projectId.trim().length === 0) {
+          throw new ValidationError(
+            "Project ID is required",
+            [{ field: "projectId", message: "Project ID is required" }]
+          );
+        }
+        const query = {
+          projectId: request.projectId
+        };
+        if (request.limit !== void 0) {
+          query.limit = request.limit.toString();
+        }
+        if (request.offset !== void 0) {
+          query.offset = request.offset.toString();
+        }
+        if (request.filter) {
+          query.filter = JSON.stringify(request.filter);
+        }
+        return this.httpClient.request({
+          method: "GET",
+          path: "/v1/memories",
+          query
+        });
+      }
+    };
+  }
+});
+
+// src/resources/search.ts
+var search_exports = {};
+__export(search_exports, {
+  SearchResource: () => SearchResource
+});
+var SearchResource;
+var init_search = __esm({
+  "src/resources/search.ts"() {
+    "use strict";
+    init_errors();
+    SearchResource = class {
+      constructor(httpClient) {
+        this.httpClient = httpClient;
+      }
+      /**
+       * Search memories
+       * @param request - Search request
+       * @returns Search results
+       */
+      async search(request) {
+        if (!request.query || request.query.trim().length === 0) {
+          throw new ValidationError(
+            "Search query cannot be empty",
+            [{ field: "query", message: "Query is required and cannot be empty" }]
+          );
+        }
+        if (!request.projectId || request.projectId.trim().length === 0) {
+          throw new ValidationError(
+            "Project ID is required",
+            [{ field: "projectId", message: "Project ID is required" }]
+          );
+        }
+        const query = {
+          q: request.query,
+          projectId: request.projectId
+        };
+        if (request.limit !== void 0) {
+          query.limit = request.limit.toString();
+        }
+        if (request.threshold !== void 0) {
+          query.threshold = request.threshold.toString();
+        }
+        if (request.filter) {
+          query.filter = JSON.stringify(request.filter);
+        }
+        return this.httpClient.request({
+          method: "GET",
+          path: "/v1/search",
+          query
+        });
+      }
+    };
+  }
+});
+
+// src/resources/ingest.ts
+var ingest_exports = {};
+__export(ingest_exports, {
+  IngestResource: () => IngestResource
+});
+var IngestResource;
+var init_ingest = __esm({
+  "src/resources/ingest.ts"() {
+    "use strict";
+    init_errors();
+    IngestResource = class {
+      constructor(httpClient) {
+        this.httpClient = httpClient;
+      }
+      /**
+       * Ingest a file
+       * @param request - File ingestion request
+       * @returns Ingestion response with created memory IDs
+       */
+      async file(request) {
+        if (!request.file) {
+          throw new ValidationError(
+            "File is required",
+            [{ field: "file", message: "File is required" }]
+          );
+        }
+        if (!request.projectId || request.projectId.trim().length === 0) {
+          throw new ValidationError(
+            "Project ID is required",
+            [{ field: "projectId", message: "Project ID is required" }]
+          );
+        }
+        const body = {
+          projectId: request.projectId,
+          metadata: request.metadata,
+          chunkSize: request.chunkSize,
+          chunkOverlap: request.chunkOverlap,
+          // In a real implementation, you'd convert the file to base64 or use FormData
+          file: request.file
+        };
+        return this.httpClient.request({
+          method: "POST",
+          path: "/v1/ingest/file",
+          body
+        });
+      }
+      /**
+       * Ingest text
+       * @param request - Text ingestion request
+       * @returns Ingestion response with created memory IDs
+       */
+      async text(request) {
+        if (!request.text || request.text.trim().length === 0) {
+          throw new ValidationError(
+            "Text cannot be empty",
+            [{ field: "text", message: "Text is required and cannot be empty" }]
+          );
+        }
+        if (!request.projectId || request.projectId.trim().length === 0) {
+          throw new ValidationError(
+            "Project ID is required",
+            [{ field: "projectId", message: "Project ID is required" }]
+          );
+        }
+        return this.httpClient.request({
+          method: "POST",
+          path: "/v1/ingest/text",
+          body: request
+        });
+      }
+    };
+  }
+});
+
+// src/resources/router.ts
+var router_exports = {};
+__export(router_exports, {
+  RouterResource: () => RouterResource
+});
+var RouterResource;
+var init_router = __esm({
+  "src/resources/router.ts"() {
+    "use strict";
+    init_errors();
+    RouterResource = class {
+      constructor(httpClient) {
+        this.httpClient = httpClient;
+      }
+      /**
+       * Complete a router request (non-streaming)
+       * @param request - Router request
+       * @returns Router response
+       */
+      async complete(request) {
+        if (!request.messages || request.messages.length === 0) {
+          throw new ValidationError(
+            "Messages array cannot be empty",
+            [{ field: "messages", message: "At least one message is required" }]
+          );
+        }
+        if (!request.projectId || request.projectId.trim().length === 0) {
+          throw new ValidationError(
+            "Project ID is required",
+            [{ field: "projectId", message: "Project ID is required" }]
+          );
+        }
+        return this.httpClient.request({
+          method: "POST",
+          path: "/v1/router/complete",
+          body: {
+            ...request,
+            stream: false
+          }
+        });
+      }
+      /**
+       * Stream a router request
+       * @param request - Router request
+       * @returns Async iterable of stream chunks
+       */
+      async *stream(request) {
+        if (!request.messages || request.messages.length === 0) {
+          throw new ValidationError(
+            "Messages array cannot be empty",
+            [{ field: "messages", message: "At least one message is required" }]
+          );
+        }
+        if (!request.projectId || request.projectId.trim().length === 0) {
+          throw new ValidationError(
+            "Project ID is required",
+            [{ field: "projectId", message: "Project ID is required" }]
+          );
+        }
+        const stream = this.httpClient.stream({
+          method: "POST",
+          path: "/v1/router/complete",
+          body: {
+            ...request,
+            stream: true
+          }
+        });
+        try {
+          for await (const chunk of stream) {
+            yield chunk;
+          }
+        } catch (error) {
+          throw error;
+        }
+      }
+    };
+  }
+});
+
+// src/http-client.ts
+init_errors();
+var HTTPClient = class {
+  constructor(config, retryConfig) {
+    this.config = config;
+    this.baseURL = config.baseURL || "https://api.memorylayer.com";
+    this.retryConfig = {
+      maxRetries: config.maxRetries ?? 3,
+      initialDelay: config.retryDelay ?? 1e3,
+      maxDelay: 3e4,
+      backoffMultiplier: 2,
+      retryableStatusCodes: [429, 500, 502, 503, 504],
+      ...retryConfig
+    };
+  }
+  /**
+   * Make an HTTP request with retry logic
+   */
+  async request(options) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
+      try {
+        return await this.makeRequest(options);
+      } catch (error) {
+        lastError = error;
+        if (!this.shouldRetry(error, attempt)) {
+          throw error;
+        }
+        const delay = this.getRetryDelay(error, attempt);
+        this.config.logger?.debug(`Retrying request after ${delay}ms (attempt ${attempt + 1}/${this.retryConfig.maxRetries})`);
+        await this.sleep(delay);
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * Make a streaming request
+   */
+  async *stream(options) {
+    const url = this.buildURL(options.path, options.query);
+    const headers = this.buildHeaders(options.headers);
+    try {
+      const response = await fetch(url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: AbortSignal.timeout(options.timeout || this.config.timeout || 6e4)
+      });
+      if (!response.ok) {
+        throw await this.handleErrorResponse(response);
+      }
+      if (!response.body) {
+        throw new NetworkError("Response body is null", new Error("No response body"));
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.trim() === "") continue;
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6);
+              if (data === "[DONE]") continue;
+              try {
+                yield JSON.parse(data);
+              } catch (e) {
+                this.config.logger?.warn("Failed to parse streaming chunk:", data);
+              }
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    } catch (error) {
+      if (error instanceof MemoryLayerError) {
+        throw error;
+      }
+      throw new NetworkError("Streaming request failed", error);
+    }
+  }
+  /**
+   * Make the actual HTTP request
+   */
+  async makeRequest(options) {
+    const url = this.buildURL(options.path, options.query);
+    const headers = this.buildHeaders(options.headers);
+    try {
+      const response = await fetch(url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: AbortSignal.timeout(options.timeout || this.config.timeout || 3e4)
+      });
+      if (!response.ok) {
+        throw await this.handleErrorResponse(response);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof MemoryLayerError) {
+        throw error;
+      }
+      throw new NetworkError("Request failed", error);
+    }
+  }
+  /**
+   * Build the full URL with query parameters
+   */
+  buildURL(path, query) {
+    const url = new URL(path, this.baseURL);
+    if (query) {
+      Object.entries(query).forEach(([key, value]) => {
+        url.searchParams.append(key, value);
+      });
+    }
+    return url.toString();
+  }
+  /**
+   * Build request headers
+   */
+  buildHeaders(additionalHeaders) {
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.config.apiKey}`,
+      "X-SDK-Version": "0.1.0",
+      "X-API-Version": "v1",
+      ...this.config.headers,
+      ...additionalHeaders
+    };
+  }
+  /**
+   * Handle error responses from the API
+   */
+  async handleErrorResponse(response) {
+    const requestId = response.headers.get("x-request-id") || void 0;
+    let errorData;
+    try {
+      errorData = await response.json();
+    } catch {
+      errorData = { message: response.statusText };
+    }
+    const message = errorData.error?.message || errorData.message || "Unknown error";
+    const details = errorData.error?.details || errorData.details;
+    switch (response.status) {
+      case 401:
+        return new AuthenticationError(message, requestId);
+      case 429:
+        const retryAfter = parseInt(response.headers.get("retry-after") || "60", 10);
+        return new RateLimitError(message, retryAfter, requestId);
+      case 400:
+        const errors = errorData.error?.errors || [];
+        return new ValidationError(message, errors, requestId);
+      default:
+        return new APIError(message, response.status, requestId, details);
+    }
+  }
+  /**
+   * Determine if an error should be retried
+   */
+  shouldRetry(error, attempt) {
+    if (attempt >= this.retryConfig.maxRetries) {
+      return false;
+    }
+    if (error instanceof NetworkError) {
+      return true;
+    }
+    if (error instanceof RateLimitError) {
+      return true;
+    }
+    if (error.statusCode && this.retryConfig.retryableStatusCodes.includes(error.statusCode)) {
+      return true;
+    }
+    if (error.statusCode && error.statusCode >= 400 && error.statusCode < 500) {
+      return false;
+    }
+    return false;
+  }
+  /**
+   * Calculate retry delay with exponential backoff
+   */
+  getRetryDelay(error, attempt) {
+    if (error instanceof RateLimitError) {
+      return error.retryAfter * 1e3;
+    }
+    const exponentialDelay = this.retryConfig.initialDelay * Math.pow(this.retryConfig.backoffMultiplier, attempt);
+    const jitter = Math.random() * 0.1 * exponentialDelay;
+    const delay = Math.min(exponentialDelay + jitter, this.retryConfig.maxDelay);
+    return delay;
+  }
+  /**
+   * Sleep for a specified duration
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/client.ts
+init_errors();
+var MemoryLayerClient = class {
+  constructor(config = {}) {
+    const apiKey = config.apiKey || process.env.MEMORYLAYER_API_KEY;
+    if (!apiKey) {
+      throw new ValidationError(
+        "API key is required. Provide it via config.apiKey or MEMORYLAYER_API_KEY environment variable.",
+        [{ field: "apiKey", message: "API key is required" }]
+      );
+    }
+    if (typeof apiKey !== "string" || apiKey.trim().length === 0) {
+      throw new ValidationError(
+        "API key must be a non-empty string",
+        [{ field: "apiKey", message: "API key must be a non-empty string" }]
+      );
+    }
+    const httpConfig = {
+      apiKey,
+      baseURL: config.baseURL,
+      timeout: config.timeout,
+      maxRetries: config.maxRetries,
+      retryDelay: config.retryDelay,
+      headers: config.headers,
+      logger: config.logger
+    };
+    this.httpClient = new HTTPClient(httpConfig);
+  }
+  /**
+   * Access memory operations
+   */
+  get memories() {
+    if (!this._memories) {
+      const { MemoriesResource: MemoriesResource2 } = (init_memories(), __toCommonJS(memories_exports));
+      this._memories = new MemoriesResource2(this.httpClient);
+    }
+    return this._memories;
+  }
+  /**
+   * Access search operations
+   */
+  get search() {
+    if (!this._search) {
+      const { SearchResource: SearchResource2 } = (init_search(), __toCommonJS(search_exports));
+      this._search = new SearchResource2(this.httpClient);
+    }
+    return this._search;
+  }
+  /**
+   * Access ingestion operations
+   */
+  get ingest() {
+    if (!this._ingest) {
+      const { IngestResource: IngestResource2 } = (init_ingest(), __toCommonJS(ingest_exports));
+      this._ingest = new IngestResource2(this.httpClient);
+    }
+    return this._ingest;
+  }
+  /**
+   * Access router operations
+   */
+  get router() {
+    if (!this._router) {
+      const { RouterResource: RouterResource2 } = (init_router(), __toCommonJS(router_exports));
+      this._router = new RouterResource2(this.httpClient);
+    }
+    return this._router;
+  }
+};
+
+// src/index.ts
+init_errors();
+init_memories();
+init_search();
+init_ingest();
+init_router();
+export {
+  APIError,
+  AuthenticationError,
+  IngestResource,
+  MemoriesResource,
+  MemoryLayerClient,
+  MemoryLayerError,
+  NetworkError,
+  RateLimitError,
+  RouterResource,
+  SearchResource,
+  ValidationError
+};