@lanonasis/recall-forge 1.1.1

package/dist/client.js

@@ -0,0 +1,643 @@
+/**
+ * @module LanonasisClient
+ *
+ * Privacy-first API client for the LanOnasis memory service.
+ *
+ * SECURITY SCOPE — what this module reads and where it sends data:
+ *
+ *   Credential resolution (read-only, in-process only):
+ *     1. `cfg.apiKey`            — caller-supplied key (constructor argument)
+ *     2. `LANONASIS_API_KEY`     — environment variable (LanOnasis-namespaced)
+ *     3. `LANONASIS_VENDOR_KEY`  — environment variable (LanOnasis-namespaced)
+ *     4. `~/.lanonasis/api-key.enc` — AES-256-GCM encrypted local file (machine-bound key)
+ *     5. `~/.lanonasis/mcp-tokens.enc` — AES-256-GCM encrypted OAuth token store
+ *     6. `~/.maas/config.json`   — CLI session token (written by `lanonasis auth login`)
+ *     7. `keytar` (optional)     — OS native credential store, if installed
+ *
+ *   No other environment variables are read. No credentials are logged,
+ *   forwarded, or stored — they are consumed in-process to produce a single
+ *   `X-API-Key` or `Authorization: Bearer` header.
+ *
+ *   Network destination:
+ *     ALL HTTP requests go exclusively to `cfg.baseUrl` (default: api.lanonasis.com).
+ *     No third-party endpoints, no telemetry calls, no exfiltration paths.
+ *     IPv4 is forced via undici dispatcher to guarantee predictable routing.
+ *
+ *   Secret protection:
+ *     Content sent to the memory API is pre-processed by the secret-redactor
+ *     pipeline (extraction/secret-redactor.ts) which strips 30+ credential
+ *     patterns BEFORE the payload leaves the process. This is the core
+ *     privacy guarantee — credentials never reach memory storage.
+ */
+// Phase 2 - LanOnasis API Client
+import { Agent, fetch as undiciFetch } from "undici";
+import { redactSecrets } from "./extraction/secret-redactor.js";
+// Force IPv4 — Node v24 built-in fetch ignores setGlobalDispatcher; use undici fetch with explicit dispatcher
+const ipv4Agent = new Agent({ connect: { family: 4 } });
+const JWT_PATTERN = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+const API_KEY_ENV_VARS = ["LANONASIS_API_KEY", "LANONASIS_VENDOR_KEY"];
+const TOKEN_ENV_VARS = [
+    "LANONASIS_AUTH_TOKEN",
+    "LANONASIS_BEARER_TOKEN",
+    "MCP_BEARER_TOKEN",
+];
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function sanitizeMemoryText(text) {
+    if (typeof text !== "string")
+        return text;
+    return redactSecrets(text).text;
+}
+class LanonasisHttpError extends Error {
+    status;
+    body;
+    constructor(status, message, body) {
+        super(message);
+        this.name = "LanonasisHttpError";
+        this.status = status;
+        this.body = body;
+    }
+}
+async function tryReadKeytarPassword(service, account) {
+    try {
+        // keytar is an optional native credential store dependency.
+        // Direct import() is used — if the module is absent, the catch silently skips it.
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore — keytar is not in devDependencies; absence is expected
+        const keytarModule = await import("keytar");
+        const keytar = (keytarModule.default ?? keytarModule);
+        if (typeof keytar.getPassword === "function") {
+            return (await keytar.getPassword(service, account)) ?? null;
+        }
+    }
+    catch {
+        // Keytar is optional; fall back to the encrypted file storage below.
+    }
+    return null;
+}
+function parseStoredString(jsonOrString) {
+    const trimmed = jsonOrString.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed.apiKey === "string" && parsed.apiKey.trim()) {
+            return parsed.apiKey.trim();
+        }
+        if (typeof parsed.access_token === "string" && parsed.access_token.trim()) {
+            return parsed.access_token.trim();
+        }
+    }
+    catch {
+        // Plain string payloads are valid in some older fallback formats.
+    }
+    return trimmed;
+}
+async function decryptStoredFile(fileName, salt) {
+    try {
+        const [{ readFile }, os, path, crypto] = await Promise.all([
+            import("node:fs/promises"),
+            import("node:os"),
+            import("node:path"),
+            import("node:crypto"),
+        ]);
+        const filePath = path.join(os.homedir(), ".lanonasis", fileName);
+        const encryptedPayload = await readFile(filePath, "utf8");
+        const parts = encryptedPayload.split(":");
+        const machineId = os.hostname() + os.userInfo().username;
+        const key = crypto.pbkdf2Sync(machineId, salt, 100000, 32, "sha256");
+        if (parts.length === 3) {
+            const [ivHex, authTagHex, encrypted] = parts;
+            if (!ivHex || !authTagHex || !encrypted)
+                return null;
+            const decipher = crypto.createDecipheriv("aes-256-gcm", key, Buffer.from(ivHex, "hex"));
+            decipher.setAuthTag(Buffer.from(authTagHex, "hex"));
+            let decrypted = decipher.update(encrypted, "hex", "utf8");
+            decrypted += decipher.final("utf8");
+            return decrypted;
+        }
+        if (parts.length === 2) {
+            const [ivHex, encrypted] = parts;
+            if (!ivHex || !encrypted)
+                return null;
+            const decipher = crypto.createDecipheriv("aes-256-cbc", key, Buffer.from(ivHex, "hex"));
+            let decrypted = decipher.update(encrypted, "hex", "utf8");
+            decrypted += decipher.final("utf8");
+            return decrypted;
+        }
+    }
+    catch {
+        // Missing file or unreadable file means no stored local credential is available.
+    }
+    return null;
+}
+async function readCliConfigToken() {
+    try {
+        const [{ readFile }, os, path] = await Promise.all([
+            import("node:fs/promises"),
+            import("node:os"),
+            import("node:path"),
+        ]);
+        const configPath = path.join(os.homedir(), ".maas", "config.json");
+        const raw = await readFile(configPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.token === "string" && parsed.token.trim()
+            ? parsed.token.trim()
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+export class LanonasisClient {
+    baseUrl;
+    apiKey;
+    projectId;
+    cache;
+    rateLimit;
+    CACHE_TTL_MS;
+    CACHE_MAX_SIZE;
+    RATE_LIMIT_WINDOW_MS;
+    RATE_LIMIT_MAX_REQ;
+    constructor(cfg) {
+        if (!cfg.projectId) {
+            throw new Error("LanonasisClient: projectId is required");
+        }
+        this.baseUrl = cfg.baseUrl.replace(/\/$/, ""); // trailing slash
+        this.apiKey = cfg.apiKey || "";
+        this.projectId = cfg.projectId;
+        this.cache = new Map();
+        this.rateLimit = { timestamps: [] };
+        this.CACHE_TTL_MS = cfg.cacheTtlMs;
+        this.CACHE_MAX_SIZE = cfg.cacheMaxSize;
+        this.RATE_LIMIT_WINDOW_MS = cfg.rateLimitWindowMs;
+        this.RATE_LIMIT_MAX_REQ = cfg.rateLimitMaxReq;
+    }
+    // LRU Cache helpers
+    cacheKey(method, params) {
+        return `${this.projectId}:${method}:${JSON.stringify(params)}`;
+    }
+    getFromCache(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        if (Date.now() > entry.expiry) {
+            this.cache.delete(key);
+            return null;
+        }
+        return entry.result;
+    }
+    setCache(key, result) {
+        // Evict oldest if at capacity
+        if (this.cache.size >= this.CACHE_MAX_SIZE) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey)
+                this.cache.delete(firstKey);
+        }
+        this.cache.set(key, {
+            result,
+            expiry: Date.now() + this.CACHE_TTL_MS,
+        });
+    }
+    // Rate limiting - wait silently if needed
+    async enforceRateLimit() {
+        const now = Date.now();
+        // Remove timestamps outside the window
+        this.rateLimit.timestamps = this.rateLimit.timestamps.filter((ts) => now - ts < this.RATE_LIMIT_WINDOW_MS);
+        if (this.rateLimit.timestamps.length >= this.RATE_LIMIT_MAX_REQ) {
+            const oldest = this.rateLimit.timestamps[0];
+            const waitMs = this.RATE_LIMIT_WINDOW_MS - (now - oldest) + 100;
+            if (waitMs > 0) {
+                await new Promise((resolve) => setTimeout(resolve, waitMs));
+            }
+        }
+        this.rateLimit.timestamps.push(Date.now());
+    }
+    // HTTP request wrapper
+    async request(method, path, body) {
+        await this.enforceRateLimit();
+        const url = this.buildRequestUrl(path);
+        const authHeader = await this.resolveAuthHeader();
+        const options = {
+            method,
+            headers: {
+                "Content-Type": "application/json",
+                "X-Project-Scope": this.projectId,
+                [authHeader.name]: authHeader.value,
+            },
+        };
+        if (body) {
+            options.body = JSON.stringify(body);
+        }
+        try {
+            const response = await undiciFetch(url, { ...options, dispatcher: ipv4Agent });
+            // Handle 429 - retry once
+            if (response.status === 429) {
+                const retryAfter = response.headers.get("Retry-After");
+                const waitMs = retryAfter ? parseInt(retryAfter, 10) * 1000 : 2000;
+                await new Promise((resolve) => setTimeout(resolve, waitMs));
+                const retryResponse = await undiciFetch(url, { ...options, dispatcher: ipv4Agent });
+                return this.handleResponse(retryResponse);
+            }
+            return this.handleResponse(response);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Unknown error";
+            const cause = err?.cause;
+            const causeMsg = cause?.message
+                ? ` (cause: ${cause.message}${cause.code ? ` ${cause.code}` : ""})`
+                : "";
+            throw new Error(`LanOnasis unreachable: ${message}${causeMsg} [url=${url}]`);
+        }
+    }
+    async handleResponse(response) {
+        const status = response.status;
+        const body = await response.text();
+        if (status === 401) {
+            throw new LanonasisHttpError(status, "LanOnasis authentication failed — refresh with `lanonasis auth login` or set LANONASIS_API_KEY", body);
+        }
+        if (status >= 500) {
+            throw new LanonasisHttpError(status, `LanOnasis server error (${status}): ${body}`, body);
+        }
+        if (!response.ok) {
+            throw new LanonasisHttpError(status, `LanOnasis error (${status}): ${body}`, body);
+        }
+        // Issue 4 fix: empty body (e.g. 204 No Content) — return undefined safely
+        const trimmed = body.trim();
+        if (!trimmed)
+            return undefined;
+        return JSON.parse(trimmed);
+    }
+    buildRequestUrl(path) {
+        return `${this.baseUrl}${path}`;
+    }
+    shouldUseCompatibilityFallback(error) {
+        if (error instanceof LanonasisHttpError &&
+            (error.status === 404 || error.status === 405)) {
+            return true;
+        }
+        const message = error instanceof Error ? error.message : String(error ?? "");
+        return /\b404\b/.test(message) || /\b405\b/.test(message);
+    }
+    shouldUseLegacyGetFallback(error) {
+        if (this.shouldUseCompatibilityFallback(error)) {
+            return true;
+        }
+        if (error instanceof LanonasisHttpError && error.status === 400) {
+            return /Memory ID is required/i.test(error.body);
+        }
+        const message = error instanceof Error ? error.message : String(error ?? "");
+        return /\b400\b/.test(message) && /Memory ID is required/i.test(message);
+    }
+    normalizeMemory(payload) {
+        const unwrapped = this.unwrap(payload);
+        if (!unwrapped || typeof unwrapped !== "object") {
+            return unwrapped;
+        }
+        const memory = { ...unwrapped };
+        const normalizedType = typeof memory.memory_type === "string"
+            ? memory.memory_type
+            : typeof memory.type === "string"
+                ? memory.type
+                : undefined;
+        if (normalizedType) {
+            memory.type = normalizedType;
+            memory.memory_type = normalizedType;
+        }
+        return memory;
+    }
+    normalizeMemoryListResult(raw) {
+        const envelope = raw;
+        const payload = this.unwrap(raw);
+        const items = Array.isArray(payload)
+            ? payload
+            : Array.isArray(envelope?.data)
+                ? envelope.data
+                : [];
+        const memories = items.map((item) => this.normalizeMemory(item));
+        const total = envelope?.pagination?.total ?? memories.length;
+        return { memories, total };
+    }
+    getEnvCredential(names) {
+        for (const envName of names) {
+            const value = process.env[envName];
+            if (typeof value === "string" && value.trim()) {
+                return value.trim();
+            }
+        }
+        return undefined;
+    }
+    toAuthHeader(credential, kind = "auto") {
+        const trimmed = credential.trim();
+        if (!trimmed) {
+            throw new Error("LanOnasis authentication required — run `lanonasis auth login` or set LANONASIS_API_KEY");
+        }
+        if (kind === "token") {
+            return {
+                name: "Authorization",
+                value: trimmed.startsWith("Bearer ") ? trimmed : `Bearer ${trimmed}`,
+            };
+        }
+        if (kind === "api_key") {
+            return {
+                name: "X-API-Key",
+                value: trimmed,
+            };
+        }
+        if (trimmed.startsWith("Bearer ") || JWT_PATTERN.test(trimmed)) {
+            return {
+                name: "Authorization",
+                value: trimmed.startsWith("Bearer ") ? trimmed : `Bearer ${trimmed}`,
+            };
+        }
+        return {
+            name: "X-API-Key",
+            value: trimmed,
+        };
+    }
+    async getStoredAuthHeader() {
+        const storedApiKey = parseStoredString((await tryReadKeytarPassword("lanonasis-mcp", "lanonasis_api_key")) ??
+            (await decryptStoredFile("api-key.enc", "lanonasis-mcp-api-key-2024")) ??
+            "");
+        if (storedApiKey) {
+            return this.toAuthHeader(storedApiKey, "api_key");
+        }
+        const storedAccessToken = parseStoredString((await tryReadKeytarPassword("lanonasis-mcp", "tokens")) ??
+            (await decryptStoredFile("mcp-tokens.enc", "lanonasis-mcp-oauth-2024")) ??
+            (await readCliConfigToken()) ??
+            "");
+        if (storedAccessToken) {
+            return this.toAuthHeader(storedAccessToken, "token");
+        }
+        return null;
+    }
+    async resolveAuthHeader() {
+        const configuredApiKey = typeof this.apiKey === "string" && this.apiKey.trim()
+            ? this.apiKey.trim()
+            : "";
+        if (configuredApiKey) {
+            return this.toAuthHeader(configuredApiKey, "auto");
+        }
+        const envApiKey = this.getEnvCredential(API_KEY_ENV_VARS);
+        if (envApiKey) {
+            return this.toAuthHeader(envApiKey, "api_key");
+        }
+        const storedAuthHeader = await this.getStoredAuthHeader();
+        if (storedAuthHeader) {
+            return storedAuthHeader;
+        }
+        const envToken = this.getEnvCredential(TOKEN_ENV_VARS);
+        if (envToken) {
+            return this.toAuthHeader(envToken, "token");
+        }
+        throw new Error("LanOnasis authentication required — run `lanonasis auth login` or set LANONASIS_API_KEY");
+    }
+    // Issue 1 fix: unwrap { success, data } envelope — defensive, handles both
+    // wrapped ({ data: T }) and direct (T) responses
+    unwrap(response) {
+        if (response !== null &&
+            typeof response === "object" &&
+            "data" in response) {
+            return response.data;
+        }
+        return response;
+    }
+    // Issue 3 fix: clear all search/list cache entries on any write
+    invalidateSearchCache() {
+        for (const key of this.cache.keys()) {
+            if (key.includes(":search:") || key.includes(":list:")) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    isUuid(value) {
+        return UUID_PATTERN.test(value);
+    }
+    async resolveMemoryId(idOrPrefix) {
+        const candidate = idOrPrefix.trim();
+        if (!candidate) {
+            throw new Error("Memory ID is required.");
+        }
+        if (this.isUuid(candidate)) {
+            return candidate;
+        }
+        if (candidate.length < 8) {
+            throw new Error("Memory ID prefix must be at least 8 characters or a full UUID.");
+        }
+        const matches = [];
+        const limit = 100;
+        let page = 1;
+        while (true) {
+            const result = await this.listMemories({ limit, page });
+            if (!result.memories || result.memories.length === 0) {
+                break;
+            }
+            for (const memory of result.memories) {
+                if (memory.id.startsWith(candidate)) {
+                    matches.push(memory.id);
+                }
+            }
+            if (result.total <= page * limit) {
+                break;
+            }
+            page += 1;
+        }
+        if (matches.length === 0) {
+            throw new Error(`Memory not found for ID/prefix: ${candidate}`);
+        }
+        if (matches.length > 1) {
+            throw new Error(`Memory ID prefix is ambiguous: ${candidate}. Matches: ${matches.slice(0, 5).join(", ")}`);
+        }
+        return matches[0];
+    }
+    async searchMemories(params) {
+        const cacheKey = this.cacheKey("search", params);
+        const cached = this.getFromCache(cacheKey);
+        if (cached)
+            return cached;
+        const requestBody = {
+            query: params.query,
+            threshold: params.threshold,
+            limit: params.limit,
+        };
+        if (params.type)
+            requestBody.type = params.type;
+        if (params.tags)
+            requestBody.tags = params.tags;
+        if (params.topic_key)
+            requestBody.topic_key = params.topic_key;
+        if (params.include_deleted !== undefined) {
+            requestBody.include_deleted = params.include_deleted;
+        }
+        if (params.response_mode)
+            requestBody.response_mode = params.response_mode;
+        if (params.metadata)
+            requestBody.metadata = params.metadata;
+        let raw;
+        try {
+            raw = await this.request("POST", "/api/v1/memories/search", requestBody);
+        }
+        catch (error) {
+            if (!this.shouldUseCompatibilityFallback(error))
+                throw error;
+            raw = await this.request("POST", "/api/v1/memory/search", requestBody);
+        }
+        const unwrapped = this.unwrap(raw);
+        const result = Array.isArray(unwrapped)
+            ? unwrapped.map((item) => this.normalizeMemory(item))
+            : [];
+        this.setCache(cacheKey, result);
+        return result;
+    }
+    async createMemory(params) {
+        const requestBody = {
+            title: params.title,
+            content: params.content,
+            type: params.type,
+        };
+        if (params.tags)
+            requestBody.tags = params.tags;
+        if (params.topic_key)
+            requestBody.topic_key = params.topic_key;
+        if (params.metadata)
+            requestBody.metadata = params.metadata;
+        if (params.idempotency_key)
+            requestBody.idempotency_key = params.idempotency_key;
+        if (params.continuity_key)
+            requestBody.continuity_key = params.continuity_key;
+        if (params.write_intent)
+            requestBody.write_intent = params.write_intent;
+        let raw;
+        try {
+            raw = await this.request("POST", "/api/v1/memories", requestBody);
+        }
+        catch (error) {
+            if (!this.shouldUseCompatibilityFallback(error))
+                throw error;
+            raw = await this.request("POST", "/api/v1/memory", requestBody);
+        }
+        // Issue 3 fix: invalidate stale search results
+        this.invalidateSearchCache();
+        return this.normalizeMemory(raw);
+    }
+    async getMemory(id) {
+        const resolvedId = await this.resolveMemoryId(id);
+        let raw;
+        try {
+            raw = await this.request("GET", `/api/v1/memories/${encodeURIComponent(resolvedId)}`);
+        }
+        catch (error) {
+            if (!this.shouldUseLegacyGetFallback(error))
+                throw error;
+            raw = await this.request("GET", `/api/v1/memory/get?id=${encodeURIComponent(resolvedId)}`);
+        }
+        return this.normalizeMemory(raw);
+    }
+    async listMemories(params) {
+        const cacheKey = this.cacheKey("list", params ?? {});
+        const cached = this.getFromCache(cacheKey);
+        if (cached)
+            return cached;
+        const queryParams = new URLSearchParams();
+        if (params?.limit)
+            queryParams.set("limit", params.limit.toString());
+        if (params?.page)
+            queryParams.set("page", params.page.toString());
+        if (params?.type)
+            queryParams.set("type", params.type);
+        if (params?.tags) {
+            params.tags.forEach((tag) => queryParams.append("tags", tag));
+        }
+        if (params?.topic_key)
+            queryParams.set("topic_key", params.topic_key);
+        if (params?.include_deleted !== undefined) {
+            queryParams.set("include_deleted", String(params.include_deleted));
+        }
+        if (params?.sort)
+            queryParams.set("sort", params.sort);
+        if (params?.order)
+            queryParams.set("order", params.order);
+        const query = queryParams.toString();
+        const canonicalPath = `/api/v1/memories${query ? `?${query}` : ""}`;
+        let raw;
+        try {
+            raw = await this.request("GET", canonicalPath);
+        }
+        catch (error) {
+            if (!this.shouldUseCompatibilityFallback(error))
+                throw error;
+            const listPayload = {};
+            if (params?.limit)
+                listPayload.limit = params.limit;
+            if (params?.page) {
+                listPayload.page = params.page;
+                listPayload.offset = Math.max(0, (params.page - 1) * (params.limit ?? 20));
+            }
+            if (params?.type)
+                listPayload.memory_type = params.type;
+            if (params?.tags)
+                listPayload.tags = params.tags;
+            if (params?.topic_key)
+                listPayload.topic_key = params.topic_key;
+            if (params?.include_deleted !== undefined) {
+                listPayload.include_deleted = params.include_deleted;
+            }
+            if (params?.sort)
+                listPayload.sort_by = params.sort;
+            if (params?.order)
+                listPayload.sort_order = params.order;
+            raw = await this.request("POST", "/api/v1/memories/list", listPayload);
+        }
+        const result = this.normalizeMemoryListResult(raw);
+        this.setCache(cacheKey, result);
+        return result;
+    }
+    async updateMemory(id, updates) {
+        const resolvedId = await this.resolveMemoryId(id);
+        const sanitizedUpdates = Object.fromEntries(Object.entries({
+            ...updates,
+            title: sanitizeMemoryText(updates.title),
+            content: sanitizeMemoryText(updates.content),
+        }).filter(([, value]) => value !== undefined));
+        let raw;
+        try {
+            raw = await this.request("PUT", `/api/v1/memories/${encodeURIComponent(resolvedId)}`, sanitizedUpdates);
+        }
+        catch (error) {
+            if (!this.shouldUseCompatibilityFallback(error))
+                throw error;
+            raw = await this.request("POST", `/api/v1/memory/update`, { id: resolvedId, ...sanitizedUpdates });
+        }
+        // Issue 3 fix: invalidate stale search/list results
+        this.invalidateSearchCache();
+        return this.normalizeMemory(raw);
+    }
+    async deleteMemory(id) {
+        const resolvedId = await this.resolveMemoryId(id);
+        try {
+            await this.request("DELETE", `/api/v1/memories/${encodeURIComponent(resolvedId)}`);
+        }
+        catch (error) {
+            if (!this.shouldUseCompatibilityFallback(error))
+                throw error;
+            await this.request("DELETE", `/api/v1/memory/delete?id=${encodeURIComponent(resolvedId)}`);
+        }
+        // Issue 3 fix: invalidate stale search/list results
+        this.invalidateSearchCache();
+    }
+    async getHealth() {
+        // Health endpoint returns direct object, no data envelope
+        return this.request("GET", "/api/v1/health");
+    }
+    async getStats() {
+        let raw;
+        try {
+            raw = await this.request("GET", "/api/v1/memories/stats");
+        }
+        catch (error) {
+            if (!this.shouldUseCompatibilityFallback(error))
+                throw error;
+            raw = await this.request("GET", "/api/v1/memory/stats");
+        }
+        return this.unwrap(raw);
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,41 @@
+export type CaptureMode = "auto" | "explicit" | "hybrid";
+export type MemoryMode = "remote" | "local" | "hybrid";
+export type SyncMode = "realtime" | "batch" | "manual";
+export type RecallMode = "auto" | "ondemand";
+export type PrivacyMode = "off" | "detect" | "mask";
+export type LanonasisConfig = {
+    apiKey: string;
+    baseUrl: string;
+    projectId: string;
+    agentId: string;
+    autoRecall: boolean;
+    recallMode: RecallMode;
+    maxRecallChars: number;
+    captureMode: CaptureMode;
+    localFallback: boolean;
+    searchThreshold: number;
+    dedupeThreshold: number;
+    maxRecallResults: number;
+    memoryMode: MemoryMode;
+    sharedNamespace: string;
+    syncMode: SyncMode;
+    queueOnFailure: boolean;
+    autoIndexOnFirstUse: boolean;
+    extractSourceFormats: string[];
+    embeddingProvider: string;
+    embeddingModel: string;
+    queryEmbeddingModel: string;
+    embeddingDimensions: number;
+    embeddingProfileId: string;
+    privacyMode: PrivacyMode;
+    privacyLocale: string;
+    privacyNotifyUrl: string;
+    defaultChannel: string;
+    cacheTtlMs: number;
+    cacheMaxSize: number;
+    rateLimitMaxReq: number;
+    rateLimitWindowMs: number;
+};
+export declare const lanonasisConfigSchema: {
+    parse: (value: unknown) => LanonasisConfig;
+};