@sovant/sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,430 @@
+// 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;
+export {
+  AuthenticationError,
+  NetworkError,
+  NotFoundError,
+  RateLimitError,
+  SovantClient,
+  SovantError,
+  ValidationError,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@sovant/sdk",
+  "version": "1.0.0",
+  "description": "Official JavaScript/TypeScript SDK for Sovant Memory API",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "jest",
+    "lint": "eslint src --ext ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "sovant",
+    "memory",
+    "api",
+    "ai",
+    "sdk",
+    "typescript",
+    "javascript"
+  ],
+  "author": "Sovant AI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sovant-ai/javascript-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sovant-ai/javascript-sdk/issues"
+  },
+  "homepage": "https://sovant.ai",
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.0",
+    "@typescript-eslint/eslint-plugin": "^6.18.1",
+    "@typescript-eslint/parser": "^6.18.1",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}