@openanonymity/nanomem 0.1.0 → 0.1.2

package/src/index.js

@@ -11,16 +11,33 @@
  *                                           rebuildTree, exportAll }
  *   Utilities  (portability): mem.serialize(), mem.toZip()
  */
-/** @import { LLMClient, MemoryBank, MemoryBankConfig, MemoryBankLLMConfig, Message, IngestOptions, RetrievalResult, StorageBackend } from './types.js' */
+/** @import { LLMClient, MemoryBank, MemoryBankConfig, MemoryBankLLMConfig, Message, IngestOptions, RetrievalResult, AugmentQueryResult, StorageBackend } from './types.js' */
 
 import { createOpenAIClient } from './llm/openai.js';
 import { createAnthropicClient } from './llm/anthropic.js';
+import { createTinfoilClient } from './llm/tinfoil.js';
 import { MemoryBulletIndex } from './bullets/bulletIndex.js';
 import { MemoryRetriever } from './engine/retriever.js';
 import { MemoryIngester } from './engine/ingester.js';
+import { MemoryDeleter } from './engine/deleter.js';
 import { MemoryCompactor } from './engine/compactor.js';
 import { InMemoryStorage } from './backends/ram.js';
+import { importData as importMemoryData } from './imports/importData.js';
 import { serialize, toZip } from './utils/portability.js';
+import { buildOmfExport, previewOmfImport, importOmf } from './omf.js';
+
+/**
+ * Remove review-only [[user_data]] markers before sending the final prompt to
+ * the frontier model.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function stripUserDataTags(text) {
+    return String(text ?? '')
+        .replace(/\[\[user_data\]\]/g, '')
+        .replace(/\[\[\/user_data\]\]/g, '');
+}
 
 /**
  * Create a memory instance.
@@ -44,6 +61,7 @@ export function createMemoryBank(config = {}) {
         onToolCall: config.onToolCall,
     });
     const compactor = new MemoryCompactor({ backend, bulletIndex, llmClient, model, onProgress: config.onCompactProgress });
+    const deleter = new MemoryDeleter({ backend, bulletIndex, llmClient, model, onToolCall: config.onToolCall });
 
     async function write(path, content) {
         await backend.write(path, content);
@@ -75,6 +93,14 @@ export function createMemoryBank(config = {}) {
          */
         retrieve: (query, conversationText) => retrieval.retrieveForQuery(query, conversationText),
 
+        /**
+         * Build a reviewable prompt that augments the user query with memory.
+         * @param {string} query
+         * @param {string} [conversationText]
+         * @returns {Promise<AugmentQueryResult | null>}
+         */
+        augmentQuery: (query, conversationText) => retrieval.augmentQueryForPrompt(query, conversationText),
+
         /**
          * Ingest facts from a conversation into memory.
          * @param {Message[]} messages
@@ -82,13 +108,74 @@ export function createMemoryBank(config = {}) {
          */
         ingest: (messages, options) => ingester.ingest(messages, options),
 
+        /**
+         * Import supported conversation/document formats into memory.
+         */
+        importData: (input, options) => importMemoryData({
+            init: () => backend.init(),
+            ingest: (messages, ingestOptions) => ingester.ingest(messages, ingestOptions)
+        }, input, options),
+        exportOmf: async () => {
+            await backend.init();
+            return buildOmfExport({
+                read: (path) => backend.read(path),
+                write: (path, content) => write(path, content),
+                delete: (path) => remove(path),
+                exists: (path) => backend.exists(path),
+                search: (query) => backend.search(query),
+                ls: (dirPath) => backend.ls(dirPath),
+                getTree: () => backend.getTree(),
+                rebuildTree: () => rebuildTree(),
+                exportAll: () => backend.exportAll(),
+                clear: () => backend.clear(),
+            }, { sourceApp: 'nanomem' });
+        },
+        previewOmfImport: async (doc, options) => {
+            await backend.init();
+            return previewOmfImport({
+                read: (path) => backend.read(path),
+                write: (path, content) => write(path, content),
+                delete: (path) => remove(path),
+                exists: (path) => backend.exists(path),
+                search: (query) => backend.search(query),
+                ls: (dirPath) => backend.ls(dirPath),
+                getTree: () => backend.getTree(),
+                rebuildTree: () => rebuildTree(),
+                exportAll: () => backend.exportAll(),
+                clear: () => backend.clear(),
+            }, doc, options);
+        },
+        importOmf: async (doc, options) => {
+            await backend.init();
+            return importOmf({
+                read: (path) => backend.read(path),
+                write: (path, content) => write(path, content),
+                delete: (path) => remove(path),
+                exists: (path) => backend.exists(path),
+                search: (query) => backend.search(query),
+                ls: (dirPath) => backend.ls(dirPath),
+                getTree: () => backend.getTree(),
+                rebuildTree: () => rebuildTree(),
+                exportAll: () => backend.exportAll(),
+                clear: () => backend.clear(),
+            }, doc, options);
+        },
+
         /** Compact all memory files (dedup, archive stale facts). */
         compact: () => compactor.compactAll(),
 
+        /**
+         * Delete memory content matching a plain-text query.
+         * @param {string} query
+         * @returns {Promise<{ status: string, deleteCalls: number, writes: Array }>}
+         */
+        deleteContent: (query, options) => deleter.deleteForQuery(query, options),
+
         // ─── Low-level (direct storage ops) ──────────────────────
 
         storage: {
             read:         (path)          => backend.read(path),
+            resolvePath:  (path)          => backend.resolvePath ? backend.resolvePath(path) : Promise.resolve(null),
             write:        (path, content) => write(path, content),
             delete:       (path)          => remove(path),
             exists:       (path)          => backend.exists(path),
@@ -128,6 +215,10 @@ function _createLlmClient(llmConfig = /** @type {MemoryBankLLMConfig} */ ({ apiK
         return createAnthropicClient({ apiKey, baseUrl, headers });
     }
 
+    if (detectedProvider === 'tinfoil') {
+        return createTinfoilClient(llmConfig);
+    }
+
     return createOpenAIClient({ apiKey, baseUrl, headers });
 }
 
@@ -135,6 +226,7 @@ function _detectProvider(baseUrl) {
     if (!baseUrl) return 'openai';
     const lower = baseUrl.toLowerCase();
     if (lower.includes('anthropic.com')) return 'anthropic';
+    if (lower.includes('tinfoil.sh')) return 'tinfoil';
     return 'openai';
 }
 
@@ -167,7 +259,7 @@ function _asyncBackend(loader) {
         return _loading;
     }
 
-    const methods = ['init', 'read', 'write', 'delete', 'exists', 'ls', 'search', 'getTree', 'rebuildTree', 'exportAll', 'clear'];
+    const methods = ['init', 'read', 'resolvePath', 'write', 'delete', 'exists', 'ls', 'search', 'getTree', 'rebuildTree', 'exportAll', 'clear'];
     const proxy = {};
     for (const method of methods) {
         proxy[method] = async (...args) => {
@@ -192,6 +284,7 @@ export { MemoryIngester } from './engine/ingester.js';
 export { MemoryCompactor } from './engine/compactor.js';
 export { createRetrievalExecutors, createExtractionExecutors } from './engine/executors.js';
 export { serialize, deserialize, toZip } from './utils/portability.js';
+export { buildOmfExport, previewOmfImport, importOmf, parseOmfText, validateOmf } from './omf.js';
 export {
     extractSessionsFromOAFastchatExport,
     extractConversationFromOAFastchatExport,

package/src/llm/openai.js

@@ -7,6 +7,23 @@
  * Uses `fetch` (built into Node 18+ and browsers).
  */
 /** @import { ChatCompletionParams, ChatCompletionResponse, LLMClient, LLMClientOptions, ToolCall } from '../types.js' */
+/**
+ * @typedef {Error & { status?: number, retryable?: boolean, retryAfterMs?: number | null, _retryFinalized?: boolean }} ApiError
+ */
+
+const RETRYABLE_STATUS = new Set([408, 429, 500, 502, 503, 504]);
+const RETRYABLE_ERROR_CODES = new Set([
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ENOTFOUND',
+    'ETIMEDOUT',
+    'EAI_AGAIN',
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_SOCKET',
+]);
+const MAX_ATTEMPTS = 3;
+const BASE_DELAY_MS = 400;
+const MAX_DELAY_MS = 2500;
 
 /**
  * @param {LLMClientOptions} [options]
@@ -24,21 +41,20 @@ export function createOpenAIClient({ apiKey, baseUrl = 'https://api.openai.com/v
         };
     }
 
+    function buildRequestInit(body) {
+        return {
+            method: 'POST',
+            headers: buildHeaders(),
+            body: JSON.stringify(body),
+        };
+    }
+
     async function createChatCompletion({ model, messages, tools, max_tokens, temperature }) {
         const body = { model, messages, temperature };
         if (max_tokens != null) body.max_tokens = max_tokens;
         if (tools && tools.length > 0) body.tools = tools;
 
-        const response = await fetch(`${base}/chat/completions`, {
-            method: 'POST',
-            headers: buildHeaders(),
-            body: JSON.stringify(body),
-        });
-
-        if (!response.ok) {
-            const text = await response.text().catch(() => '');
-            throw new Error(`OpenAI API error ${response.status}: ${text}`);
-        }
+        const response = await fetchWithRetry(`${base}/chat/completions`, buildRequestInit(body), 'chat completion request');
 
         const data = await response.json();
         const choice = data.choices?.[0]?.message || {};
@@ -62,65 +78,72 @@ export function createOpenAIClient({ apiKey, baseUrl = 'https://api.openai.com/v
         if (max_tokens != null) body.max_tokens = max_tokens;
         if (tools && tools.length > 0) body.tools = tools;
 
-        const response = await fetch(`${base}/chat/completions`, {
-            method: 'POST',
-            headers: buildHeaders(),
-            body: JSON.stringify(body),
-        });
+        return withRetry(async (attempt) => {
+            const response = await fetch(`${base}/chat/completions`, buildRequestInit(body));
+            if (!response.ok) {
+                throw await createHttpError(response, attempt);
+            }
 
-        if (!response.ok) {
-            const text = await response.text().catch(() => '');
-            throw new Error(`OpenAI API error ${response.status}: ${text}`);
-        }
+            // Only retry streaming requests if the connection dies before
+            // any SSE data arrives. Once we have surfaced deltas, replaying
+            // would duplicate partial reasoning/content.
+            let content = '';
+            let sawStreamData = false;
+            const toolCallAccumulator = new Map();
 
-        // Accumulate the full response from SSE deltas
-        let content = '';
-        const toolCallAccumulator = new Map();
+            try {
+                await readSSE(response, (chunk) => {
+                    sawStreamData = true;
 
-        await readSSE(response, (chunk) => {
-            const delta = chunk.choices?.[0]?.delta;
-            if (!delta) return;
+                    const delta = chunk.choices?.[0]?.delta;
+                    if (!delta) return;
 
-            // Content delta
-            if (delta.content) {
-                content += delta.content;
-                onDelta?.(delta.content);
-            }
+                    if (delta.content) {
+                        content += delta.content;
+                        onDelta?.(delta.content);
+                    }
 
-            // Reasoning delta (some providers send this)
-            if (delta.reasoning) {
-                onReasoning?.(delta.reasoning);
-            }
+                    if (delta.reasoning) {
+                        onReasoning?.(delta.reasoning);
+                    }
 
-            // Tool call deltas — accumulate by index
-            if (delta.tool_calls) {
-                for (const tc of delta.tool_calls) {
-                    const idx = tc.index ?? 0;
-                    if (!toolCallAccumulator.has(idx)) {
-                        toolCallAccumulator.set(idx, {
-                            id: tc.id || '',
-                            type: 'function',
-                            function: { name: '', arguments: '' },
-                        });
+                    if (delta.tool_calls) {
+                        for (const tc of delta.tool_calls) {
+                            const idx = tc.index ?? 0;
+                            if (!toolCallAccumulator.has(idx)) {
+                                toolCallAccumulator.set(idx, {
+                                    id: tc.id || '',
+                                    type: 'function',
+                                    function: { name: '', arguments: '' },
+                                });
+                            }
+                            const acc = toolCallAccumulator.get(idx);
+                            if (!acc) continue;
+                            if (tc.id) acc.id = tc.id;
+                            if (tc.function?.name) acc.function.name += tc.function.name;
+                            if (tc.function?.arguments) acc.function.arguments += tc.function.arguments;
+                        }
                     }
-                    const acc = toolCallAccumulator.get(idx);
-                    if (!acc) continue;
-                    if (tc.id) acc.id = tc.id;
-                    if (tc.function?.name) acc.function.name += tc.function.name;
-                    if (tc.function?.arguments) acc.function.arguments += tc.function.arguments;
+                });
+            } catch (error) {
+                if (!sawStreamData && isRetryableNetworkError(error)) {
+                    const retryError = asError(error);
+                    retryError.retryable = true;
+                    throw retryError;
                 }
+                throw error;
             }
-        });
 
-        const tool_calls = [...toolCallAccumulator.entries()]
-            .sort(([a], [b]) => a - b)
-            .map(([, tc]) => tc);
+            const tool_calls = [...toolCallAccumulator.entries()]
+                .sort(([a], [b]) => a - b)
+                .map(([, tc]) => tc);
 
-        return {
-            content,
-            tool_calls,
-            usage: null,
-        };
+            return {
+                content,
+                tool_calls,
+                usage: null,
+            };
+        }, 'streaming chat completion');
     }
 
     return { createChatCompletion, streamChatCompletion };
@@ -128,6 +151,129 @@ export function createOpenAIClient({ apiKey, baseUrl = 'https://api.openai.com/v
 
 // ─── SSE Parser ──────────────────────────────────────────────
 
+async function fetchWithRetry(url, init, context) {
+    return withRetry(async (attempt) => {
+        const response = await fetch(url, init);
+        if (!response.ok) {
+            throw await createHttpError(response, attempt);
+        }
+        return response;
+    }, context);
+}
+
+async function withRetry(fn, context) {
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+        try {
+            return await fn(attempt);
+        } catch (error) {
+            const normalized = asError(error);
+            const shouldRetry = attempt < MAX_ATTEMPTS && isRetryableError(normalized);
+            if (!shouldRetry) {
+                throw finalizeRetryError(normalized, attempt);
+            }
+
+            const delay = getRetryDelay(attempt - 1, normalized.retryAfterMs || null);
+            console.warn(`[nanomem/openai] ${context} attempt ${attempt}/${MAX_ATTEMPTS} failed: ${normalized.message}. Retrying in ${Math.round(delay)}ms.`);
+            await sleep(delay);
+        }
+    }
+
+    throw new Error(`OpenAI API ${context} failed after ${MAX_ATTEMPTS} attempts.`);
+}
+
+function isRetryableError(error) {
+    if (!error) return false;
+    if (error.retryable === true) return true;
+    if (typeof error.status === 'number') {
+        return RETRYABLE_STATUS.has(error.status);
+    }
+    return isRetryableNetworkError(error);
+}
+
+function isRetryableNetworkError(error) {
+    if (!error || error.isUserAbort) return false;
+    if (error.name === 'TypeError' || error.name === 'AbortError') return true;
+
+    const code = String(error.code || error.cause?.code || '').toUpperCase();
+    if (RETRYABLE_ERROR_CODES.has(code)) return true;
+
+    const message = String(error.message || '').toLowerCase();
+    return message.includes('failed to fetch')
+        || message.includes('network')
+        || message.includes('timeout')
+        || message.includes('err_network_changed')
+        || message.includes('econnreset')
+        || message.includes('connection');
+}
+
+/**
+ * @param {number} attempt
+ * @param {number | null} [retryAfterMs]
+ * @returns {number}
+ */
+function getRetryDelay(attempt, retryAfterMs = null) {
+    if (retryAfterMs != null && Number.isFinite(retryAfterMs) && retryAfterMs > 0) {
+        return Math.min(retryAfterMs, MAX_DELAY_MS);
+    }
+
+    const exponential = BASE_DELAY_MS * Math.pow(2, attempt);
+    const jitter = Math.random() * BASE_DELAY_MS;
+    return Math.min(exponential + jitter, MAX_DELAY_MS);
+}
+
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function createHttpError(response, attempt = 1) {
+    const text = await response.text().catch(() => '');
+    const suffix = attempt > 1 ? ` after ${attempt} attempts` : '';
+    const error = /** @type {ApiError} */ (new Error(`OpenAI API error ${response.status}${suffix}: ${text}`));
+    error.status = response.status;
+    error.retryable = RETRYABLE_STATUS.has(response.status);
+    error.retryAfterMs = parseRetryAfterMs(response);
+    return error;
+}
+
+function parseRetryAfterMs(response) {
+    const value = response?.headers?.get?.('Retry-After');
+    if (!value) return null;
+
+    const seconds = Number.parseInt(value, 10);
+    if (Number.isFinite(seconds) && seconds > 0) {
+        return seconds * 1000;
+    }
+
+    const date = Date.parse(value);
+    if (Number.isFinite(date)) {
+        const ms = date - Date.now();
+        return ms > 0 ? ms : null;
+    }
+
+    return null;
+}
+
+function finalizeRetryError(error, attempts) {
+    const normalized = asError(error);
+    if (attempts <= 1 || normalized._retryFinalized) {
+        return normalized;
+    }
+
+    if (!normalized.message.includes('after ')) {
+        normalized.message = `${normalized.message} (after ${attempts} attempts)`;
+    }
+    normalized._retryFinalized = true;
+    return normalized;
+}
+
+/**
+ * @param {unknown} error
+ * @returns {ApiError}
+ */
+function asError(error) {
+    return /** @type {ApiError} */ (error instanceof Error ? error : new Error(String(error)));
+}
+
 async function readSSE(response, onMessage) {
     if (!response.body) {
         throw new Error('Streaming response body is not available.');