@sovant/sdk 1.0.4 → 1.1.0

package/dist/index.mjs

@@ -0,0 +1,809 @@
+// 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 = {
+      "Authorization": `Bearer ${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
+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
+  };
+}
+
+// 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;
+export {
+  NetworkError,
+  Sovant,
+  SovantError,
+  TimeoutError,
+  index_default as default
+};