@sovant/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,463 @@
+"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, {
+  AuthenticationError: () => AuthenticationError,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  RateLimitError: () => RateLimitError,
+  SovantClient: () => SovantClient,
+  SovantError: () => SovantError,
+  ValidationError: () => ValidationError,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var SovantError = class extends Error {
+  constructor(message, statusCode, details) {
+    super(message);
+    this.name = "SovantError";
+    this.statusCode = statusCode;
+    this.details = details;
+  }
+};
+var AuthenticationError = class extends SovantError {
+  constructor(message = "Authentication failed") {
+    super(message, 401);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends SovantError {
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, 429);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ValidationError = class extends SovantError {
+  constructor(message = "Validation failed", errors) {
+    super(message, 400);
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+};
+var NotFoundError = class extends SovantError {
+  constructor(message = "Resource not found") {
+    super(message, 404);
+    this.name = "NotFoundError";
+  }
+};
+var NetworkError = class extends SovantError {
+  constructor(message = "Network request failed") {
+    super(message);
+    this.name = "NetworkError";
+  }
+};
+
+// src/client.ts
+var BaseClient = class {
+  constructor(config) {
+    this.config = {
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl || "https://api.sovant.ai/v1",
+      timeout: config.timeout || 3e4,
+      maxRetries: config.maxRetries || 3,
+      retryDelay: config.retryDelay || 1e3
+    };
+    if (!this.config.apiKey) {
+      throw new AuthenticationError("API key is required");
+    }
+    if (!this.config.baseUrl.startsWith("https://")) {
+      throw new SovantError("API base URL must use HTTPS for security");
+    }
+  }
+  async request(method, path, data, retryCount = 0) {
+    const url = `${this.config.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`,
+          "Content-Type": "application/json",
+          "X-SDK-Version": "1.0.0",
+          "X-SDK-Language": "javascript"
+        },
+        body: data ? JSON.stringify(data) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+      const responseData = await response.json();
+      return responseData;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof SovantError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new NetworkError("Request timeout");
+        }
+        if (retryCount < this.config.maxRetries) {
+          await this.delay(this.config.retryDelay * Math.pow(2, retryCount));
+          return this.request(method, path, data, retryCount + 1);
+        }
+        throw new NetworkError(error.message);
+      }
+      throw new SovantError("Unknown error occurred");
+    }
+  }
+  async handleErrorResponse(response) {
+    let errorData;
+    try {
+      errorData = await response.json();
+    } catch {
+      errorData = {
+        error: "unknown_error",
+        message: `HTTP ${response.status} ${response.statusText}`,
+        status_code: response.status
+      };
+    }
+    switch (response.status) {
+      case 401:
+        throw new AuthenticationError(errorData.message);
+      case 404:
+        throw new NotFoundError(errorData.message);
+      case 429:
+        const retryAfter = response.headers.get("Retry-After");
+        throw new RateLimitError(
+          errorData.message,
+          retryAfter ? parseInt(retryAfter, 10) : void 0
+        );
+      case 400:
+      case 422:
+        throw new ValidationError(errorData.message, errorData.details);
+      default:
+        throw new SovantError(
+          errorData.message,
+          response.status,
+          errorData.details
+        );
+    }
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  buildQueryString(params) {
+    const searchParams = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        if (Array.isArray(value)) {
+          value.forEach((v) => searchParams.append(key, String(v)));
+        } else {
+          searchParams.append(key, String(value));
+        }
+      }
+    });
+    const queryString = searchParams.toString();
+    return queryString ? `?${queryString}` : "";
+  }
+};
+
+// src/resources/memories.ts
+var Memories = class extends BaseClient {
+  /**
+   * Create a new memory
+   */
+  async create(data) {
+    return this.request("POST", "/memory", data);
+  }
+  /**
+   * Get a memory by ID
+   */
+  async get(id) {
+    return this.request("GET", `/memory/${id}`);
+  }
+  /**
+   * Update a memory
+   */
+  async update(id, data) {
+    return this.request("PUT", `/memory/${id}`, data);
+  }
+  /**
+   * Delete a memory
+   */
+  async delete(id) {
+    await this.request("DELETE", `/memory/${id}`);
+  }
+  /**
+   * List memories with pagination
+   */
+  async list(options) {
+    const queryString = this.buildQueryString(options || {});
+    return this.request(
+      "GET",
+      `/memory${queryString}`
+    );
+  }
+  /**
+   * Search memories
+   */
+  async search(options) {
+    const queryString = this.buildQueryString({
+      q: options.query,
+      limit: options.limit,
+      offset: options.offset,
+      type: options.type,
+      tags: options.tags,
+      created_after: options.created_after,
+      created_before: options.created_before,
+      search_type: options.search_type,
+      include_archived: options.include_archived,
+      sort_by: options.sort_by,
+      sort_order: options.sort_order
+    });
+    const response = await this.request(
+      "GET",
+      `/memory/search${queryString}`
+    );
+    return response.results;
+  }
+  /**
+   * Batch create memories
+   */
+  async createBatch(memories) {
+    return this.request("POST", "/memory/batch", {
+      memories
+    });
+  }
+  /**
+   * Batch delete memories
+   */
+  async deleteBatch(ids) {
+    return this.request("POST", "/memory/batch/delete", {
+      ids
+    });
+  }
+  /**
+   * Get memory insights and analytics
+   */
+  async getInsights(options) {
+    const queryString = this.buildQueryString(options || {});
+    return this.request("GET", `/memory/insights${queryString}`);
+  }
+  /**
+   * Archive a memory
+   */
+  async archive(id) {
+    return this.update(id, { is_archived: true });
+  }
+  /**
+   * Unarchive a memory
+   */
+  async unarchive(id) {
+    return this.update(id, { is_archived: false });
+  }
+  /**
+   * Pin a memory
+   */
+  async pin(id) {
+    return this.update(id, { is_pinned: true });
+  }
+  /**
+   * Unpin a memory
+   */
+  async unpin(id) {
+    return this.update(id, { is_pinned: false });
+  }
+  /**
+   * Get related memories
+   */
+  async getRelated(id, options) {
+    const queryString = this.buildQueryString(options || {});
+    const response = await this.request(
+      "GET",
+      `/memory/${id}/related${queryString}`
+    );
+    return response.results;
+  }
+};
+
+// src/resources/threads.ts
+var Threads = class extends BaseClient {
+  /**
+   * Create a new thread
+   */
+  async create(data) {
+    return this.request("POST", "/threads", data);
+  }
+  /**
+   * Get a thread by ID
+   */
+  async get(id, includeMemories = false) {
+    const queryString = includeMemories ? "?include_memories=true" : "";
+    return this.request(
+      "GET",
+      `/threads/${id}${queryString}`
+    );
+  }
+  /**
+   * Update a thread
+   */
+  async update(id, data) {
+    return this.request("PUT", `/threads/${id}`, data);
+  }
+  /**
+   * Delete a thread
+   */
+  async delete(id, deleteMemories = false) {
+    const queryString = deleteMemories ? "?delete_memories=true" : "";
+    await this.request("DELETE", `/threads/${id}${queryString}`);
+  }
+  /**
+   * List threads with pagination
+   */
+  async list(options) {
+    const queryString = this.buildQueryString(options || {});
+    return this.request(
+      "GET",
+      `/threads${queryString}`
+    );
+  }
+  /**
+   * Add memories to a thread
+   */
+  async addMemories(id, memoryIds) {
+    return this.request("POST", `/threads/${id}/memories`, {
+      add: memoryIds
+    });
+  }
+  /**
+   * Remove memories from a thread
+   */
+  async removeMemories(id, memoryIds) {
+    return this.request("POST", `/threads/${id}/memories`, {
+      remove: memoryIds
+    });
+  }
+  /**
+   * Get memories in a thread
+   */
+  async getMemories(id, options) {
+    const queryString = this.buildQueryString(options || {});
+    return this.request(
+      "GET",
+      `/threads/${id}/memories${queryString}`
+    );
+  }
+  /**
+   * Get thread statistics
+   */
+  async getStats(id) {
+    return this.request("GET", `/threads/${id}/stats`);
+  }
+  /**
+   * Archive a thread
+   */
+  async archive(id) {
+    return this.update(id, { status: "archived" });
+  }
+  /**
+   * Unarchive a thread
+   */
+  async unarchive(id) {
+    return this.update(id, { status: "active" });
+  }
+  /**
+   * Complete a thread
+   */
+  async complete(id) {
+    return this.update(id, { status: "completed" });
+  }
+  /**
+   * Search threads
+   */
+  async search(options) {
+    const queryString = this.buildQueryString({
+      q: options.query,
+      limit: options.limit,
+      offset: options.offset,
+      status: options.status,
+      tags: options.tags
+    });
+    return this.request(
+      "GET",
+      `/threads/search${queryString}`
+    );
+  }
+  /**
+   * Merge multiple threads into one
+   */
+  async merge(targetId, sourceIds) {
+    return this.request("POST", `/threads/${targetId}/merge`, {
+      source_thread_ids: sourceIds
+    });
+  }
+  /**
+   * Clone a thread
+   */
+  async clone(id, options) {
+    return this.request("POST", `/threads/${id}/clone`, options);
+  }
+};
+
+// src/index.ts
+var SovantClient = class {
+  constructor(apiKeyOrConfig) {
+    if (typeof apiKeyOrConfig === "string") {
+      this.config = { apiKey: apiKeyOrConfig };
+    } else {
+      this.config = apiKeyOrConfig;
+    }
+    this.memories = new Memories(this.config);
+    this.threads = new Threads(this.config);
+  }
+  /**
+   * Test API connection
+   */
+  async ping() {
+    const client = new BaseClient(this.config);
+    return client.request("GET", "/health");
+  }
+  /**
+   * Get current API usage and quota
+   */
+  async getUsage() {
+    const client = new BaseClient(this.config);
+    return client.request("GET", "/usage");
+  }
+};
+var index_default = SovantClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  NetworkError,
+  NotFoundError,
+  RateLimitError,
+  SovantClient,
+  SovantError,
+  ValidationError
+});