@sovant/sdk 1.1.1 → 1.2.0

package/dist/index.js

@@ -1,851 +1,223 @@
-"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, {
-  NetworkError: () => NetworkError,
-  Sovant: () => Sovant,
-  SovantError: () => SovantError,
-  TimeoutError: () => TimeoutError,
-  default: () => index_default
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/errors.ts
-var SovantError = class _SovantError extends Error {
-  constructor(message, code, status, requestId) {
-    super(message);
-    this.name = "SovantError";
-    this.code = code;
-    this.status = status;
-    this.requestId = requestId;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _SovantError);
-    }
-  }
-  static fromResponse(status, body, requestId) {
-    const statusCodeMap = {
-      400: "bad_request",
-      401: "unauthorized",
-      403: "forbidden",
-      404: "not_found",
-      409: "conflict",
-      422: "validation_error",
-      429: "rate_limited",
-      500: "internal_error",
-      502: "bad_gateway",
-      503: "service_unavailable",
-      504: "gateway_timeout"
-    };
-    let message = "An error occurred";
-    let code = statusCodeMap[status] || "unknown_error";
-    if (body?.error) {
-      if (typeof body.error === "string") {
-        message = body.error;
-      } else if (body.error.message) {
-        message = body.error.message;
-        code = body.error.code || code;
-      }
-    } else if (body?.message) {
-      message = body.message;
-    } else if (typeof body === "string") {
-      message = body;
-    }
-    return new _SovantError(message, code, status, requestId);
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      code: this.code,
-      status: this.status,
-      requestId: this.requestId
-    };
-  }
-};
-var NetworkError = class _NetworkError extends SovantError {
-  constructor(message, cause) {
-    super(message, "network_error");
-    this.name = "NetworkError";
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _NetworkError);
-    }
-  }
-};
-var TimeoutError = class _TimeoutError extends SovantError {
-  constructor(message = "Request timed out") {
-    super(message, "timeout");
-    this.name = "TimeoutError";
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _TimeoutError);
-    }
-  }
-};
-
-// src/http.ts
-var RETRY_STATUS_CODES = [429, 502, 503, 504];
-var DEFAULT_TIMEOUT = 3e4;
-var DEFAULT_MAX_RETRIES = 3;
-var IDEMPOTENT_METHODS = ["GET", "DELETE"];
-var HttpClient = class {
-  constructor(baseUrl, apiKey, globalOptions = {}) {
-    this.baseUrl = baseUrl;
-    this.apiKey = apiKey;
-    this.globalOptions = globalOptions;
-  }
-  async request(path, options = {}) {
-    const url = `${this.baseUrl}${path}`;
-    const timeout = options.timeout ?? this.globalOptions.timeout ?? DEFAULT_TIMEOUT;
-    const maxRetries = options.maxRetries ?? this.globalOptions.maxRetries ?? DEFAULT_MAX_RETRIES;
-    const debug = options.debug ?? this.globalOptions.debug ?? false;
-    const method = options.method || "GET";
-    const shouldRetry = IDEMPOTENT_METHODS.includes(method) || method === "GET";
-    let lastError;
-    let attempt = 0;
-    while (attempt <= maxRetries) {
-      try {
-        if (debug && attempt > 0) {
-          console.log(`[Sovant SDK] Retry attempt ${attempt} for ${method} ${url}`);
-        }
-        const response = await this.makeRequest(url, options, timeout, debug);
-        if (shouldRetry && RETRY_STATUS_CODES.includes(response.status) && attempt < maxRetries) {
-          const delay = this.calculateRetryDelay(attempt, response.headers["retry-after"]);
-          if (debug) {
-            console.log(`[Sovant SDK] Got ${response.status}, retrying after ${delay}ms...`);
-          }
-          await this.sleep(delay);
-          attempt++;
-          continue;
-        }
-        if (response.status >= 400) {
-          throw SovantError.fromResponse(response.status, response.data, response.requestId);
-        }
-        return response;
-      } catch (error) {
-        lastError = error;
-        if (error instanceof SovantError) {
-          if (error.status && error.status < 500) {
-            throw error;
-          }
-          if (!shouldRetry || attempt >= maxRetries) {
-            throw error;
-          }
-        }
-        if (error instanceof TimeoutError || error instanceof NetworkError) {
-          if (shouldRetry && attempt < maxRetries) {
-            const delay = this.calculateRetryDelay(attempt);
-            if (debug) {
-              console.log(`[Sovant SDK] Network/Timeout error, retrying after ${delay}ms...`);
+export class Sovant {
+    apiKey;
+    baseUrl;
+    timeout;
+    maxRetries;
+    retryDelay;
+    onRequest;
+    onResponse;
+    onError;
+    constructor(opts) {
+        if (!opts?.apiKey)
+            throw new Error("Missing apiKey");
+        this.apiKey = opts.apiKey;
+        this.baseUrl = (opts.baseUrl ?? process.env.SOVANT_BASE_URL ?? "https://sovant.ai").replace(/\/+$/, "");
+        this.timeout = opts.timeoutMs ?? 30000;
+        this.maxRetries = opts.maxRetries ?? 3;
+        this.retryDelay = opts.retryDelay ?? 1000;
+        this.onRequest = opts.onRequest;
+        this.onResponse = opts.onResponse;
+        this.onError = opts.onError;
+    }
+    async req(path, init) {
+        const method = init.method || 'GET';
+        const startTime = Date.now();
+        // Telemetry: onRequest hook
+        if (this.onRequest) {
+            try {
+                const body = init.body ? JSON.parse(init.body) : undefined;
+                this.onRequest({ method, path, body });
             }
-            await this.sleep(delay);
-            attempt++;
-            continue;
-          }
+            catch { }
         }
-        throw error;
-      }
-    }
-    throw lastError || new NetworkError("Max retries exceeded");
-  }
-  async makeRequest(url, options, timeout, debug) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    const headers = {
-      "x-sovant-api-key": this.apiKey,
-      "Content-Type": "application/json",
-      ...options.headers
-    };
-    const fetchOptions = {
-      method: options.method || "GET",
-      headers,
-      signal: controller.signal
-    };
-    if (options.body !== void 0 && options.method !== "GET" && options.method !== "HEAD") {
-      fetchOptions.body = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
-    }
-    if (debug) {
-      console.log(`[Sovant SDK] ${fetchOptions.method} ${url}`);
-      if (options.body) {
-        console.log("[Sovant SDK] Body:", options.body);
-      }
-    }
-    try {
-      const response = await fetch(url, fetchOptions);
-      clearTimeout(timeoutId);
-      const responseHeaders = {};
-      response.headers.forEach((value, key) => {
-        responseHeaders[key.toLowerCase()] = value;
-      });
-      const requestId = responseHeaders["x-request-id"];
-      let data;
-      const contentType = responseHeaders["content-type"] || "";
-      if (response.status === 204) {
-        data = { ok: true };
-      } else if (contentType.includes("application/json")) {
-        const text = await response.text();
-        try {
-          data = text ? JSON.parse(text) : {};
-        } catch (e) {
-          data = { message: text };
-        }
-      } else {
-        data = await response.text();
-      }
-      if (debug) {
-        console.log(`[Sovant SDK] Response ${response.status}:`, data);
-        if (requestId) {
-          console.log(`[Sovant SDK] Request ID: ${requestId}`);
-        }
-      }
-      return {
-        data,
-        status: response.status,
-        headers: responseHeaders,
-        requestId
-      };
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          throw new TimeoutError(`Request timed out after ${timeout}ms`);
-        }
-        throw new NetworkError(`Network request failed: ${error.message}`, error);
-      }
-      throw error;
-    }
-  }
-  calculateRetryDelay(attempt, retryAfter) {
-    if (retryAfter) {
-      const retryAfterNum = parseInt(retryAfter, 10);
-      if (!isNaN(retryAfterNum)) {
-        return retryAfterNum * 1e3;
-      }
-    }
-    const baseDelay = Math.min(1e3 * Math.pow(2, attempt), 1e4);
-    const jitter = Math.random() * baseDelay * 0.1;
-    return Math.floor(baseDelay + jitter);
-  }
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-};
-
-// src/sse-parser.ts
-var SseParser = class {
-  constructor(onEvent) {
-    this.buffer = "";
-    this.onEvent = onEvent;
-  }
-  feed(chunk) {
-    if (!chunk) return;
-    this.buffer += chunk;
-    this.process();
-  }
-  process() {
-    let boundaryIndex = this.findBoundary(this.buffer);
-    while (boundaryIndex !== -1) {
-      const raw = this.buffer.slice(0, boundaryIndex);
-      this.buffer = this.buffer.slice(boundaryIndex + this.boundaryLength(this.buffer, boundaryIndex));
-      const lines = raw.split(/\r?\n/);
-      let eventName = "";
-      let dataLines = [];
-      let id;
-      for (const line of lines) {
-        if (!line) continue;
-        if (line.startsWith(":")) continue;
-        const idx = line.indexOf(":");
-        const field = idx === -1 ? line : line.slice(0, idx);
-        const value = idx === -1 ? "" : line.slice(idx + 1).replace(/^ /, "");
-        switch (field) {
-          case "event":
-            eventName = value;
-            break;
-          case "data":
-            dataLines.push(value);
-            break;
-          case "id":
-            id = value;
-            break;
-        }
-      }
-      const data = dataLines.join("\n");
-      const ev = { type: "event", event: eventName || "message", data, id };
-      this.onEvent(ev);
-      if (ev.event === "message" || ev.event === "delta" || ev.event === "") {
-        this.onEvent({ type: "delta", data: data ?? "" });
-      }
-      boundaryIndex = this.findBoundary(this.buffer);
-    }
-  }
-  findBoundary(buf) {
-    const n = buf.indexOf("\n\n");
-    const r = buf.indexOf("\r\n\r\n");
-    if (n === -1) return r;
-    if (r === -1) return n;
-    return Math.min(n, r);
-  }
-  boundaryLength(buf, start) {
-    if (buf.slice(start, start + 4) === "\r\n\r\n") return 4;
-    return 2;
-  }
-};
-
-// src/index.ts
-var Sovant = class {
-  constructor(config) {
-    if (!config.apiKey) {
-      throw new Error("API key is required");
-    }
-    const baseUrl = (config.baseUrl || "https://sovant.ai").replace(/\/$/, "");
-    this.http = new HttpClient(baseUrl, config.apiKey, {
-      timeout: config.timeout || 3e4,
-      maxRetries: config.maxRetries || 3,
-      debug: config.debug || false
-    });
-    this.memory = new MemoryNamespace(this.http);
-    this.threads = new ThreadsNamespace(this.http);
-    this.chat = new ChatNamespace(this.http);
-    this.keys = new KeysNamespace(this.http);
-    this.recall = new RecallNamespace(this.http);
-  }
-};
-var MemoryNamespace = class {
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Create a new memory
-   */
-  async create(input) {
-    const response = await this.http.request("/api/v1/memory", {
-      method: "POST",
-      body: input
-    });
-    const { ok, ...memory } = response.data;
-    return memory;
-  }
-  /**
-   * List memories with optional filters
-   */
-  async list(params) {
-    const queryParams = new URLSearchParams();
-    if (params?.limit !== void 0) queryParams.append("limit", params.limit.toString());
-    if (params?.offset !== void 0) queryParams.append("offset", params.offset.toString());
-    if (params?.type) queryParams.append("type", params.type);
-    if (params?.thread_id) queryParams.append("thread_id", params.thread_id);
-    if (params?.is_archived !== void 0) queryParams.append("is_archived", params.is_archived.toString());
-    if (params?.tags && params.tags.length > 0) {
-      params.tags.forEach((tag) => queryParams.append("tags", tag));
-    }
-    const query = queryParams.toString();
-    const path = query ? `/api/v1/memory?${query}` : "/api/v1/memory";
-    const response = await this.http.request(path, {
-      method: "GET"
-    });
-    return response.data;
-  }
-  /**
-   * Get a specific memory by ID
-   */
-  async get(id) {
-    if (!id) throw new Error("Memory ID is required");
-    const response = await this.http.request(`/api/v1/memories/${id}`, {
-      method: "GET"
-    });
-    return response.data;
-  }
-  /**
-   * Update a memory (partial update using PATCH)
-   */
-  async update(id, patch) {
-    if (!id) throw new Error("Memory ID is required");
-    const response = await this.http.request(`/api/v1/memories/${id}`, {
-      method: "PATCH",
-      body: patch
-    });
-    return response.data;
-  }
-  /**
-   * Replace a memory (full update using PUT)
-   */
-  async put(id, body) {
-    if (!id) throw new Error("Memory ID is required");
-    if (!body.content) throw new Error("Content is required for PUT operation");
-    if (!body.type) throw new Error("Type is required for PUT operation");
-    const response = await this.http.request(`/api/v1/memories/${id}`, {
-      method: "PUT",
-      body
-    });
-    return response.data;
-  }
-  /**
-   * Delete a memory
-   */
-  async delete(id) {
-    if (!id) throw new Error("Memory ID is required");
-    const response = await this.http.request(`/api/v1/memories/${id}`, {
-      method: "DELETE"
-    });
-    return response.data;
-  }
-  /**
-   * Search memories using semantic search or filters
-   */
-  async search(params) {
-    const queryParams = new URLSearchParams();
-    if (params.query) queryParams.append("query", params.query);
-    if (params.type) queryParams.append("type", params.type);
-    if (params.limit !== void 0) queryParams.append("limit", params.limit.toString());
-    if (params.thread_id) queryParams.append("thread_id", params.thread_id);
-    if (params.from_date) queryParams.append("from_date", params.from_date);
-    if (params.to_date) queryParams.append("to_date", params.to_date);
-    if (params.tags && params.tags.length > 0) {
-      params.tags.forEach((tag) => queryParams.append("tags", tag));
-    }
-    const query = queryParams.toString();
-    const path = `/api/v1/memory/search${query ? `?${query}` : ""}`;
-    const response = await this.http.request(path, {
-      method: "GET"
-    });
-    return response.data;
-  }
-  /**
-   * Execute batch operations atomically
-   */
-  async batch(body) {
-    if (!body.operations || body.operations.length === 0) {
-      throw new Error("At least one operation is required");
-    }
-    const apiBody = {
-      operations: body.operations.map((op) => ({
-        ...op,
-        operation: op.op,
-        op: void 0
-      }))
-    };
-    const response = await this.http.request("/api/v1/memory/batch", {
-      method: "POST",
-      body: apiBody
-    });
-    return response.data;
-  }
-};
-var ThreadsNamespace = class {
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Create a new thread
-   */
-  async create(input) {
-    const response = await this.http.request("/api/v1/threads", {
-      method: "POST",
-      body: input || {}
-    });
-    if (response.data.thread) {
-      return response.data.thread;
-    } else if (response.data.ok !== void 0) {
-      const { ok, ...thread } = response.data;
-      return thread;
-    } else {
-      return response.data;
-    }
-  }
-  /**
-   * List threads with pagination
-   */
-  async list(params) {
-    const queryParams = new URLSearchParams();
-    if (params?.limit) queryParams.append("limit", params.limit.toString());
-    if (params?.offset) queryParams.append("offset", params.offset.toString());
-    const path = queryParams.toString() ? `/api/v1/threads?${queryParams.toString()}` : "/api/v1/threads";
-    const response = await this.http.request(path, {
-      method: "GET"
-    });
-    return response.data;
-  }
-  /**
-   * Get a thread by ID, optionally with memories
-   */
-  async get(id, options) {
-    const queryParams = new URLSearchParams();
-    if (options?.includeMemories) queryParams.append("include", "memories");
-    if (options?.limit) queryParams.append("limit", options.limit.toString());
-    if (options?.offset) queryParams.append("offset", options.offset.toString());
-    const path = queryParams.toString() ? `/api/v1/threads/${id}?${queryParams.toString()}` : `/api/v1/threads/${id}`;
-    const response = await this.http.request(path, {
-      method: "GET"
-    });
-    return response.data;
-  }
-  /**
-   * Update a thread
-   */
-  async update(id, input) {
-    const response = await this.http.request(`/api/v1/threads/${id}`, {
-      method: "PATCH",
-      body: input
-    });
-    const { ok, ...thread } = response.data;
-    return thread;
-  }
-  /**
-   * Delete a thread (memories are unlinked, not deleted)
-   */
-  async delete(id) {
-    const response = await this.http.request(
-      `/api/v1/threads/${id}`,
-      {
-        method: "DELETE"
-      }
-    );
-    return response.data;
-  }
-  /**
-   * Link a memory to a thread
-   */
-  async linkMemory(threadId, memoryId) {
-    const response = await this.http.request(
-      `/api/v1/threads/${threadId}/link`,
-      {
-        method: "POST",
-        body: { memory_id: memoryId }
-      }
-    );
-    return response.data;
-  }
-};
-var ChatNamespace = class {
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Create a new chat session
-   */
-  async createSession(input) {
-    const response = await this.http.request("/api/v1/chat/sessions", {
-      method: "POST",
-      body: input || {}
-    });
-    return response.data;
-  }
-  /**
-   * Get a chat session by ID
-   */
-  async getSession(sessionId) {
-    const response = await this.http.request(`/api/v1/chat/sessions/${sessionId}`, {
-      method: "GET"
-    });
-    return response.data;
-  }
-  /**
-   * List chat sessions
-   */
-  async listSessions(params) {
-    const queryParams = new URLSearchParams();
-    if (params?.limit) queryParams.append("limit", params.limit.toString());
-    if (params?.offset) queryParams.append("offset", params.offset.toString());
-    const path = queryParams.toString() ? `/api/v1/chat/sessions?${queryParams.toString()}` : "/api/v1/chat/sessions";
-    const response = await this.http.request(path, {
-      method: "GET"
-    });
-    return response.data.sessions;
-  }
-  /**
-   * Get messages for a session
-   */
-  async getMessages(sessionId, limit) {
-    const queryParams = new URLSearchParams();
-    if (limit) queryParams.append("limit", limit.toString());
-    const path = queryParams.toString() ? `/api/v1/chat/sessions/${sessionId}/messages?${queryParams.toString()}` : `/api/v1/chat/sessions/${sessionId}/messages`;
-    const response = await this.http.request(path, {
-      method: "GET"
-    });
-    return response.data.messages;
-  }
-  /**
-   * Send a message with SSE streaming
-   */
-  async *sendMessage(sessionId, message, opts) {
-    const options = typeof message === "string" ? opts : message;
-    const messageText = typeof message === "string" ? message : message.message;
-    if (!messageText) {
-      yield { type: "error", data: "Message is required" };
-      return;
-    }
-    const body = {
-      message: messageText,
-      provider: options?.provider,
-      model: options?.model,
-      useMemory: options?.useMemory ?? true,
-      stream: options?.stream ?? true
-    };
-    const response = await fetch(`${this.http.baseUrl}/api/v1/chat/sessions/${sessionId}/messages`, {
-      method: "POST",
-      headers: {
-        "x-sovant-api-key": this.http.apiKey,
-        "content-type": "application/json",
-        "accept": "text/event-stream"
-      },
-      body: JSON.stringify(body),
-      signal: options?.signal
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ message: "Request failed" }));
-      yield { type: "error", data: error.message || "Request failed" };
-      return;
-    }
-    const reader = response.body?.getReader();
-    if (!reader) {
-      yield { type: "error", data: "No response body" };
-      return;
-    }
-    const decoder = new TextDecoder();
-    const queue = [];
-    const parser = new SseParser((ev) => {
-      queue.push(ev);
-    });
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        const text = decoder.decode(value, { stream: true });
-        parser.feed(text);
-        while (queue.length > 0) {
-          const ev = queue.shift();
-          if (ev.type === "delta") {
+        let lastError = null;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            const ctl = new AbortController();
+            const timeoutId = setTimeout(() => ctl.abort(), this.timeout);
             try {
-              const parsed = JSON.parse(ev.data);
-              if (parsed.text !== void 0) {
-                yield { type: "delta", data: parsed.text };
-              } else if (parsed.data !== void 0) {
-                yield { type: "delta", data: parsed.data };
-              } else {
-                yield { type: "delta", data: ev.data };
-              }
-            } catch {
-              yield { type: "delta", data: ev.data };
+                const res = await fetch(`${this.baseUrl}${path}`, {
+                    ...init,
+                    headers: {
+                        "content-type": "application/json",
+                        "authorization": `Bearer ${this.apiKey}`,
+                        ...(init.headers || {})
+                    },
+                    signal: ctl.signal
+                });
+                clearTimeout(timeoutId);
+                const text = await res.text();
+                let body;
+                try {
+                    body = text ? JSON.parse(text) : undefined;
+                }
+                catch {
+                    body = text;
+                }
+                if (!res.ok) {
+                    const msg = body?.message || res.statusText;
+                    const code = body?.code || `HTTP_${res.status}`;
+                    const error = new SovantError(msg, code, res.status, body);
+                    // Retry on 429 (rate limit) or 5xx errors
+                    if (attempt < this.maxRetries && (res.status === 429 || res.status >= 500)) {
+                        lastError = error;
+                        const delay = this.retryDelay * Math.pow(2, attempt); // Exponential backoff
+                        await new Promise(resolve => setTimeout(resolve, delay));
+                        continue;
+                    }
+                    // Telemetry: onError hook
+                    if (this.onError) {
+                        try {
+                            this.onError(error);
+                        }
+                        catch { }
+                    }
+                    throw error;
+                }
+                // Success - telemetry: onResponse hook
+                const duration = Date.now() - startTime;
+                if (this.onResponse) {
+                    try {
+                        this.onResponse({ method, path, status: res.status, duration });
+                    }
+                    catch { }
+                }
+                return body;
             }
-          } else if (ev.type === "event") {
-            if (ev.event === "done") {
-              yield { type: "done" };
-            } else if (ev.event === "error") {
-              yield { type: "error", data: ev.data };
-            } else if (ev.event === "meta" || ev.event === "provider") {
-              continue;
+            catch (err) {
+                clearTimeout(timeoutId);
+                // Handle abort/timeout errors
+                if (err instanceof Error && err.name === 'AbortError') {
+                    const error = new SovantError('Request timeout', 'TIMEOUT', 408);
+                    if (attempt < this.maxRetries) {
+                        lastError = error;
+                        const delay = this.retryDelay * Math.pow(2, attempt);
+                        await new Promise(resolve => setTimeout(resolve, delay));
+                        continue;
+                    }
+                    throw error;
+                }
+                // Network errors
+                if (err instanceof Error) {
+                    const error = new SovantError(err.message, 'NETWORK_ERROR', 0);
+                    if (attempt < this.maxRetries) {
+                        lastError = error;
+                        const delay = this.retryDelay * Math.pow(2, attempt);
+                        await new Promise(resolve => setTimeout(resolve, delay));
+                        continue;
+                    }
+                    throw error;
+                }
+                throw err;
             }
-          }
         }
-      }
-      yield { type: "done" };
-    } catch (error) {
-      if (error.name === "AbortError") {
-        yield { type: "error", data: "Request cancelled" };
-      } else {
-        yield { type: "error", data: error.message };
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-};
-var KeysNamespace = class {
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * List API keys
-   */
-  async list() {
-    const response = await this.http.request("/api/v1/keys", {
-      method: "GET"
-    });
-    return response.data.keys;
-  }
-  /**
-   * Create a new API key
-   */
-  async create(name) {
-    const response = await this.http.request("/api/v1/keys", {
-      method: "POST",
-      body: { name }
-    });
-    return response.data;
-  }
-  /**
-   * Update an API key
-   */
-  async update(id, patch) {
-    const response = await this.http.request("/api/v1/keys", {
-      method: "PATCH",
-      body: { id, ...patch }
-    });
-    return response.data;
-  }
-  /**
-   * Revoke an API key
-   */
-  async revoke(id) {
-    await this.http.request(`/api/v1/keys/${id}`, {
-      method: "DELETE"
-    });
-  }
-};
-var RecallNamespace = class {
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Extract profile entity from text (client-side)
-   */
-  extractProfile(text) {
-    const s = (text || "").toLowerCase().trim();
-    const sanitized = s.replace(/'/g, "'");
-    if (/\bmy\s+name\s+is\s+([a-z\-.''\s]{2,}?)(?:[.!?\s]|$)/i.test(sanitized)) {
-      const match = sanitized.match(/\bmy\s+name\s+is\s+([a-z\-.''\s]{2,}?)(?:[.!?\s]|$)/i);
-      if (match) {
-        const name = match[1].trim().replace(/\s+/g, " ").replace(/\.$/, "");
-        return { entity: "name", value: name };
-      }
-    }
-    if (/\b(i am|i'm|im)\s+(\d{1,3})\s*(years old)?/i.test(sanitized)) {
-      const match = sanitized.match(/\b(i am|i'm|im)\s+(\d{1,3})/i);
-      if (match) {
-        return { entity: "age", value: match[2] };
-      }
-    }
-    if (/\bmy\s+age\s+is\s+(\d{1,3})/i.test(sanitized)) {
-      const match = sanitized.match(/\bmy\s+age\s+is\s+(\d{1,3})/i);
-      if (match) {
-        return { entity: "age", value: match[1] };
-      }
-    }
-    const locationPatterns = [
-      /\bi\s+live\s+in\s+([a-z\-.''\s]{2,}?)(?:[.!?\s]|$)/i,
-      /\bi\s+am\s+based\s+in\s+([a-z\-.''\s]{2,}?)(?:[.!?\s]|$)/i,
-      /\bi'm\s+from\s+([a-z\-.''\s]{2,}?)(?:[.!?\s]|$)/i,
-      /\bi\s+am\s+from\s+([a-z\-.''\s]{2,}?)(?:[.!?\s]|$)/i,
-      /\bresiding\s+in\s+([a-z\-.''\s]{2,}?)(?:[.!?\s]|$)/i,
-      /\bcurrently\s+in\s+([a-z\-.''\s]{2,}?)(?:[.!?\s]|$)/i,
-      /\bmoved\s+to\s+([a-z\-.''\s]{2,}?)(?:[.!?\s]|$)/i,
-      /\blocated\s+in\s+([a-z\-.''\s]{2,}?)(?:[.!?\s]|$)/i
-    ];
-    for (const pattern of locationPatterns) {
-      if (pattern.test(sanitized)) {
-        const match = sanitized.match(pattern);
-        if (match) {
-          const location = match[1].trim().replace(/\s+/g, " ").replace(/\.$/, "");
-          return { entity: "location", value: location };
+        // If we exhausted retries, throw the last error
+        throw lastError || new SovantError('Max retries exceeded', 'MAX_RETRIES', 0);
+    }
+    memory = {
+        create: (input) => this.req("/api/v1/memory", {
+            method: "POST",
+            body: JSON.stringify({
+                content: typeof input.data === 'string' ? input.data : JSON.stringify(input.data),
+                type: input.type || 'journal',
+                ttl: input.ttl,
+                tags: input.tags,
+                metadata: input.metadata,
+                thread_id: input.thread_id
+            })
+        }),
+        get: (id) => this.req(`/api/v1/memories/${encodeURIComponent(id)}`, {
+            method: "GET"
+        }),
+        search: (q) => {
+            const params = new URLSearchParams();
+            if (q.query)
+                params.append('query', q.query);
+            if (q.type)
+                params.append('type', q.type);
+            if (q.tags)
+                params.append('tags', q.tags.join(','));
+            if (q.thread_id)
+                params.append('thread_id', q.thread_id);
+            if (q.limit)
+                params.append('limit', q.limit.toString());
+            if (q.from_date)
+                params.append('from_date', q.from_date);
+            if (q.to_date)
+                params.append('to_date', q.to_date);
+            return this.req(`/api/v1/memory/search?${params.toString()}`, {
+                method: "GET"
+            });
+        },
+        update: (id, patch) => this.req(`/api/v1/memories/${encodeURIComponent(id)}`, {
+            method: "PATCH",
+            body: JSON.stringify({
+                content: patch.data ? (typeof patch.data === 'string' ? patch.data : JSON.stringify(patch.data)) : undefined,
+                type: patch.type,
+                ttl: patch.ttl,
+                tags: patch.tags,
+                metadata: patch.metadata
+            })
+        }),
+        delete: (id) => this.req(`/api/v1/memories/${encodeURIComponent(id)}`, {
+            method: "DELETE"
+        }),
+        /**
+         * Batch create multiple memories in a single request
+         * @param memories Array of memory objects to create (max 100)
+         * @returns BatchResponse with individual results
+         */
+        createBatch: (memories) => {
+            const operations = memories.map(mem => ({
+                operation: 'create',
+                data: {
+                    content: typeof mem.data === 'string' ? mem.data : JSON.stringify(mem.data),
+                    type: mem.type || 'journal',
+                    tags: mem.tags,
+                    metadata: mem.metadata,
+                    thread_id: mem.thread_id
+                }
+            }));
+            return this.req("/api/v1/memory/batch", {
+                method: "POST",
+                body: JSON.stringify(operations)
+            });
+        },
+        /**
+         * Semantic search alias for search()
+         * Provides a more intuitive name for vector similarity search
+         */
+        recall: (q) => {
+            const params = new URLSearchParams();
+            if (q.query)
+                params.append('query', q.query);
+            if (q.type)
+                params.append('type', q.type);
+            if (q.tags)
+                params.append('tags', q.tags.join(','));
+            if (q.thread_id)
+                params.append('thread_id', q.thread_id);
+            if (q.limit)
+                params.append('limit', q.limit.toString());
+            if (q.from_date)
+                params.append('from_date', q.from_date);
+            if (q.to_date)
+                params.append('to_date', q.to_date);
+            return this.req(`/api/v1/memory/search?${params.toString()}`, {
+                method: "GET"
+            });
         }
-      }
-    }
-    if (/\bi\s+(like|love|prefer)\s+([^.!?]{2,})/i.test(sanitized)) {
-      const match = sanitized.match(/\bi\s+(like|love|prefer)\s+([^.!?]{2,})/i);
-      if (match) {
-        const pref = match[2].trim().replace(/\s+/g, " ").replace(/\.$/, "");
-        return { entity: "preference", value: pref };
-      }
-    }
-    return { entity: null };
-  }
-  /**
-   * Get profile facts from memories
-   */
-  async getProfileFacts() {
-    const response = await this.http.request(
-      "/api/v1/memory/search?query=user%20name%20age%20location&limit=20",
-      { method: "GET" }
-    );
-    const facts = {
-      preferences: []
     };
-    for (const memory of response.data.results) {
-      const content = memory.content.toLowerCase();
-      if (/^user\s+name\s+is\s+(.+)$/i.test(content)) {
-        const match = content.match(/^user\s+name\s+is\s+(.+)$/i);
-        if (match && !facts.name) {
-          facts.name = match[1].trim();
-        }
-      }
-      if (/^user\s+age\s+is\s+(\d+)$/i.test(content)) {
-        const match = content.match(/^user\s+age\s+is\s+(\d+)$/i);
-        if (match && !facts.age) {
-          facts.age = match[1];
-        }
-      }
-      if (/^user\s+location\s+is\s+(.+)$/i.test(content)) {
-        const match = content.match(/^user\s+location\s+is\s+(.+)$/i);
-        if (match && !facts.location) {
-          facts.location = match[1].trim();
-        }
-      }
-      if (/^user\s+(likes|loves|prefers)\s+(.+)$/i.test(content)) {
-        const match = content.match(/^user\s+(likes|loves|prefers)\s+(.+)$/i);
-        if (match) {
-          const pref = match[2].trim();
-          if (!facts.preferences?.includes(pref)) {
-            facts.preferences?.push(pref);
-          }
-        }
-      }
-    }
-    return facts;
-  }
-  /**
-   * Save a profile fact in canonical form
-   */
-  async saveProfileFact(kind, value) {
-    let content;
-    switch (kind) {
-      case "name":
-        content = `user name is ${value}`;
-        break;
-      case "age":
-        content = `user age is ${value}`;
-        break;
-      case "location":
-        content = `user location is ${value}`;
-        break;
-      case "preference":
-        content = `user likes ${value}`;
-        break;
-      default:
-        throw new Error(`Unknown profile entity: ${kind}`);
-    }
-    const response = await this.http.request("/api/v1/memory", {
-      method: "POST",
-      body: {
-        content,
-        type: "preference",
-        tags: ["profile", kind]
-      }
-    });
-    const { ok, ...memory } = response.data;
-    return memory;
-  }
-};
-var index_default = Sovant;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  NetworkError,
-  Sovant,
-  SovantError,
-  TimeoutError
-});
+}
+export class SovantError extends Error {
+    code;
+    status;
+    details;
+    constructor(message, code, status, details) {
+        super(message);
+        this.name = "SovantError";
+        this.code = code;
+        this.status = status;
+        this.details = details;
+    }
+}
+//# sourceMappingURL=index.js.map