@sovant/sdk 1.1.1 → 1.2.0

package/dist/index.mjs

@@ -1,821 +0,0 @@
-// 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...`);
-            }
-            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 = {
-      "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") {
-            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 };
-            }
-          } 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;
-            }
-          }
-        }
-      }
-      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 (/\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;
-export {
-  NetworkError,
-  Sovant,
-  SovantError,
-  TimeoutError,
-  index_default as default
-};