@sovant/sdk 1.0.5 → 1.1.0

package/dist/index.js

@@ -1,106 +1,839 @@
-export class Sovant {
-    apiKey;
-    baseUrl;
-    timeout;
-    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;
-    }
-    async req(path, init) {
-        const ctl = new AbortController();
-        const id = setTimeout(() => ctl.abort(), this.timeout);
-        try {
-            const res = await fetch(`${this.baseUrl}${path}`, {
-                ...init,
-                headers: {
-                    "content-type": "application/json",
-                    "authorization": `Bearer ${this.apiKey}`,
-                    ...(init.headers || {})
-                },
-                signal: ctl.signal
-            });
-            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}`;
-                throw new SovantError(msg, code, res.status, body);
+"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...`);
             }
-            return body;
-        }
-        finally {
-            clearTimeout(id);
-        }
-    }
-    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"
-        })
+            await this.sleep(delay);
+            attempt++;
+            continue;
+          }
+        }
+        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 = {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      ...options.headers
     };
-}
-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;
+    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
+function parseSSE(buffer) {
+  const events = [];
+  const lines = buffer.split("\n");
+  let currentEvent = {};
+  let remaining = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (i === lines.length - 1 && !buffer.endsWith("\n")) {
+      remaining = line;
+      break;
+    }
+    if (line.trim() === "") {
+      if (currentEvent.data !== void 0) {
+        events.push({
+          event: currentEvent.event,
+          data: currentEvent.data,
+          id: currentEvent.id,
+          retry: currentEvent.retry
+        });
+        currentEvent = {};
+      }
+      continue;
+    }
+    if (line.startsWith(":")) {
+      continue;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      const field2 = line.trim();
+      if (field2 === "data") {
+        currentEvent.data = "";
+      }
+      continue;
+    }
+    const field = line.substring(0, colonIndex).trim();
+    let value = line.substring(colonIndex + 1);
+    if (value.startsWith(" ")) {
+      value = value.substring(1);
     }
+    switch (field) {
+      case "event":
+        currentEvent.event = value;
+        break;
+      case "data":
+        if (currentEvent.data === void 0) {
+          currentEvent.data = value;
+        } else {
+          currentEvent.data += "\n" + value;
+        }
+        break;
+      case "id":
+        currentEvent.id = value;
+        break;
+      case "retry":
+        const retryTime = parseInt(value, 10);
+        if (!isNaN(retryTime)) {
+          currentEvent.retry = retryTime;
+        }
+        break;
+    }
+  }
+  return {
+    events,
+    buffer: remaining
+  };
 }
-//# sourceMappingURL=index.js.map
+
+// 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.session;
+  }
+  /**
+   * 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 body = {
+      message,
+      provider: opts?.provider,
+      model: opts?.model,
+      useMemory: opts?.useMemory ?? true,
+      captureToMemory: opts?.captureToMemory ?? true
+    };
+    const response = await fetch(`${this.http.baseUrl}/api/v1/chat/sessions/${sessionId}/messages`, {
+      method: "POST",
+      headers: {
+        "authorization": `Bearer ${this.http.apiKey}`,
+        "content-type": "application/json",
+        "accept": "text/event-stream"
+      },
+      body: JSON.stringify(body),
+      signal: opts?.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();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const events = parseSSE(buffer);
+        buffer = events.buffer;
+        for (const event of events.events) {
+          if (event.data === "[DONE]") {
+            yield { type: "done" };
+            return;
+          }
+          try {
+            const parsed = JSON.parse(event.data);
+            if (parsed.content) {
+              yield { type: "delta", data: parsed.content };
+            }
+          } catch {
+            yield { type: "delta", data: event.data };
+          }
+        }
+      }
+    } 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 (/\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
+});