praana 0.5.0

package/dist/memory/db.js

@@ -0,0 +1,283 @@
+// ============================================================
+// ARIA Memory — SQLite Schema
+// ============================================================
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+import { EMBEDDING_DIM } from "./embeddings.js";
+const REEMBED_NEEDED_KEY = "reembed_needed";
+const BASE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS entries (
+  id            TEXT PRIMARY KEY,
+  kind          TEXT NOT NULL,
+  content       TEXT NOT NULL,
+  confidence    REAL NOT NULL DEFAULT 0.5,
+  pinned        INTEGER NOT NULL DEFAULT 0,
+  created_at    INTEGER NOT NULL,
+  last_seen_at  INTEGER NOT NULL,
+  session_id    TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS entry_scopes (
+  entry_id  TEXT NOT NULL REFERENCES entries(id) ON DELETE CASCADE,
+  scope     TEXT NOT NULL,
+  PRIMARY KEY (entry_id, scope)
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id          TEXT PRIMARY KEY,
+  agent       TEXT NOT NULL,
+  user_id     TEXT NOT NULL,
+  context_id  TEXT NOT NULL,
+  started_at  INTEGER NOT NULL,
+  ended_at    INTEGER,
+  reason      TEXT
+);
+
+CREATE TABLE IF NOT EXISTS memory_meta (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS entries_fts
+  USING fts5(content, entry_id UNINDEXED);
+
+CREATE TABLE IF NOT EXISTS pending_reinforcements (
+  entry_id   TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  ts         INTEGER NOT NULL,
+  PRIMARY KEY (entry_id, session_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_entries_kind      ON entries(kind);
+CREATE INDEX IF NOT EXISTS idx_entries_pinned    ON entries(pinned);
+CREATE INDEX IF NOT EXISTS idx_entries_last_seen ON entries(last_seen_at);
+CREATE INDEX IF NOT EXISTS idx_scopes_scope      ON entry_scopes(scope);
+`;
+export function openMemoryDb(path, embeddingDim = EMBEDDING_DIM) {
+    const db = new Database(path);
+    sqliteVec.load(db);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    db.exec(BASE_SCHEMA);
+    ensureLayerColumns(db);
+    ensureFtsBackfill(db);
+    const needsReembed = ensureVectorTable(db, embeddingDim);
+    return { db, needsReembed };
+}
+function ensureLayerColumns(db) {
+    const columns = db
+        .prepare("PRAGMA table_info(entries)")
+        .all();
+    const names = new Set(columns.map((c) => c.name));
+    if (!names.has("layer")) {
+        db.exec("ALTER TABLE entries ADD COLUMN layer INTEGER NOT NULL DEFAULT 1");
+    }
+    if (!names.has("confirmation_count")) {
+        db.exec("ALTER TABLE entries ADD COLUMN confirmation_count INTEGER NOT NULL DEFAULT 0");
+    }
+    if (!names.has("retracted")) {
+        db.exec("ALTER TABLE entries ADD COLUMN retracted INTEGER NOT NULL DEFAULT 0");
+    }
+}
+function ensureFtsBackfill(db) {
+    db.exec(`
+    DELETE FROM entries_fts
+    WHERE entry_id NOT IN (SELECT id FROM entries);
+
+    INSERT INTO entries_fts (content, entry_id)
+    SELECT e.content, e.id
+    FROM entries e
+    WHERE NOT EXISTS (
+      SELECT 1 FROM entries_fts f WHERE f.entry_id = e.id
+    );
+  `);
+}
+function ensureVectorTable(db, dim) {
+    const row = db
+        .prepare("SELECT value FROM memory_meta WHERE key = 'embedding_dim'")
+        .get();
+    const storedDim = row ? parseInt(row.value, 10) : EMBEDDING_DIM;
+    const reembedFlag = db
+        .prepare("SELECT value FROM memory_meta WHERE key = ?")
+        .get(REEMBED_NEEDED_KEY);
+    const vecExists = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_vec'")
+        .get();
+    if (vecExists && storedDim === dim) {
+        return reembedFlag?.value === "1";
+    }
+    if (vecExists) {
+        markReembedNeeded(db);
+        db.exec("DROP TABLE IF EXISTS entries_vec");
+    }
+    db.exec(`
+    CREATE VIRTUAL TABLE entries_vec USING vec0(
+      entry_id TEXT PRIMARY KEY,
+      embedding float[${dim}]
+    )
+  `);
+    db.prepare("INSERT OR REPLACE INTO memory_meta (key, value) VALUES ('embedding_dim', ?)").run(String(dim));
+    return Boolean(vecExists) || reembedFlag?.value === "1";
+}
+export function markReembedNeeded(db) {
+    db.prepare("INSERT OR REPLACE INTO memory_meta (key, value) VALUES (?, '1')").run(REEMBED_NEEDED_KEY);
+}
+export function clearReembedNeeded(db) {
+    db.prepare("DELETE FROM memory_meta WHERE key = ?").run(REEMBED_NEEDED_KEY);
+}
+// ---- Entry CRUD ----
+export function insertEntry(db, e) {
+    const stmt = db.prepare(`INSERT INTO entries (id, kind, content, confidence, pinned, layer, confirmation_count, created_at, last_seen_at, session_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    stmt.run(e.id, e.kind, e.content, e.confidence, e.pinned ? 1 : 0, e.layer, e.confirmation_count, e.created_at, e.last_seen_at, e.session_id);
+    const scopeStmt = db.prepare(`INSERT OR IGNORE INTO entry_scopes (entry_id, scope) VALUES (?, ?)`);
+    for (const scope of e.scopes) {
+        scopeStmt.run(e.id, scope);
+    }
+    db.prepare("INSERT INTO entries_fts (content, entry_id) VALUES (?, ?)").run(e.content, e.id);
+}
+export function touchEntry(db, id, now) {
+    db.prepare("UPDATE entries SET last_seen_at = ? WHERE id = ?").run(now, id);
+}
+export function reinforceEntry(db, id, alpha = 0.15) {
+    db.prepare(`
+    UPDATE entries
+    SET confidence = MIN(1.0, confidence + (1.0 - confidence) * ?), last_seen_at = ?
+    WHERE id = ?
+  `).run(alpha, Date.now(), id);
+}
+// TODO: wire into a scheduled confidence-decay pass (not yet called from production code).
+export function weakenEntry(db, id, beta = 0.3) {
+    db.prepare(`UPDATE entries SET confidence = confidence * (1.0 - ?) WHERE id = ?`).run(beta, id);
+}
+export function stampReinforcement(db, entryId, sessionId) {
+    db.prepare(`
+    INSERT OR IGNORE INTO pending_reinforcements (entry_id, session_id, ts)
+    VALUES (?, ?, ?)
+  `).run(entryId, sessionId, Date.now());
+}
+export function flushReinforcements(db, sessionId) {
+    const rows = db
+        .prepare("SELECT entry_id FROM pending_reinforcements WHERE session_id = ?")
+        .all(sessionId);
+    for (const { entry_id } of rows) {
+        reinforceEntry(db, entry_id);
+    }
+    db.prepare("DELETE FROM pending_reinforcements WHERE session_id = ?").run(sessionId);
+}
+export function getEntryById(db, id) {
+    const row = db.prepare("SELECT * FROM entries WHERE id = ?").get(id);
+    if (!row)
+        return undefined;
+    return rowToEntry(db, row);
+}
+export function getAllEntries(db) {
+    const rows = db
+        .prepare("SELECT * FROM entries ORDER BY created_at DESC")
+        .all();
+    return rows.map((r) => rowToEntry(db, r));
+}
+export function getEntriesByScope(db, scopes) {
+    const placeholders = scopes.map(() => "?").join(",");
+    const sql = `
+    SELECT e.* FROM entries e
+    JOIN entry_scopes es ON e.id = es.entry_id
+    WHERE es.scope IN (${placeholders})
+    GROUP BY e.id
+    HAVING COUNT(DISTINCT es.scope) = ${scopes.length}
+    ORDER BY e.last_seen_at DESC
+  `;
+    const rows = db.prepare(sql).all(...scopes);
+    return rows.map((r) => rowToEntry(db, r));
+}
+export function deleteEntry(db, id) {
+    db.prepare("DELETE FROM entries WHERE id = ?").run(id);
+    db.prepare("DELETE FROM entries_vec WHERE entry_id = ?").run(id);
+    db.prepare("DELETE FROM entries_fts WHERE entry_id = ?").run(id);
+}
+export function retractMemory(db, id) {
+    db.prepare("UPDATE entries SET retracted = 1 WHERE id = ?").run(id);
+}
+function rowToEntry(db, row) {
+    const scopes = db
+        .prepare("SELECT scope FROM entry_scopes WHERE entry_id = ?")
+        .all(row.id);
+    return {
+        id: row.id,
+        kind: row.kind,
+        content: row.content,
+        confidence: row.confidence,
+        pinned: row.pinned === 1,
+        layer: row.layer === 2 ? 2 : 1,
+        confirmation_count: row.confirmation_count ?? 0,
+        created_at: row.created_at,
+        last_seen_at: row.last_seen_at,
+        session_id: row.session_id,
+        scopes: scopes.map((s) => s.scope),
+        retracted: row.retracted === 1,
+    };
+}
+// ---- Sessions ----
+export function startSessionRow(db, s) {
+    db.prepare(`INSERT INTO sessions (id, agent, user_id, context_id, started_at)
+     VALUES (?, ?, ?, ?, ?)`).run(s.id, s.agent, s.user_id, s.context_id, s.started_at);
+}
+export function endSessionRow(db, id, endedAt, reason) {
+    db.prepare("UPDATE sessions SET ended_at = ?, reason = ? WHERE id = ?").run(endedAt, reason, id);
+}
+// ---- Embeddings ----
+export function upsertEmbedding(db, entryId, embedding) {
+    const buf = Buffer.from(embedding.buffer);
+    db.prepare("DELETE FROM entries_vec WHERE entry_id = ?").run(entryId);
+    db.prepare("INSERT INTO entries_vec (entry_id, embedding) VALUES (?, ?)").run(entryId, buf);
+}
+export function searchByVector(db, query, k) {
+    const buf = Buffer.from(query.buffer);
+    return db
+        .prepare(`SELECT entry_id, distance FROM entries_vec
+     WHERE embedding MATCH ? AND k = ?
+     ORDER BY distance`)
+        .all(buf, k);
+}
+export function searchByFts(db, query, k, filters = {}) {
+    const ftsQuery = buildFtsQuery(query);
+    if (!ftsQuery)
+        return [];
+    const params = [ftsQuery];
+    const joins = [];
+    const wheres = ["entries_fts MATCH ?"];
+    if (filters.kinds && filters.kinds.length > 0) {
+        joins.push("JOIN entries e ON e.id = entries_fts.entry_id");
+        wheres.push(`e.kind IN (${filters.kinds.map(() => "?").join(",")})`);
+        params.push(...filters.kinds);
+    }
+    if (filters.scopes && filters.scopes.length > 0) {
+        wheres.push(`
+      entries_fts.entry_id IN (
+        SELECT entry_id
+        FROM entry_scopes
+        WHERE scope IN (${filters.scopes.map(() => "?").join(",")})
+        GROUP BY entry_id
+        HAVING COUNT(DISTINCT scope) = ${filters.scopes.length}
+      )
+    `);
+        params.push(...filters.scopes);
+    }
+    params.push(k);
+    return db
+        .prepare(`SELECT entries_fts.entry_id, bm25(entries_fts) AS rank
+       FROM entries_fts
+       ${joins.join("\n       ")}
+       WHERE ${wheres.join(" AND ")}
+       ORDER BY rank
+       LIMIT ?`)
+        .all(...params);
+}
+function buildFtsQuery(query) {
+    const terms = query
+        .toLowerCase()
+        .match(/[a-z0-9_]+/g);
+    if (!terms || terms.length === 0)
+        return "";
+    return terms.map((term) => `"${term.replaceAll('"', '""')}"`).join(" OR ");
+}

package/dist/memory/dedup.d.ts

@@ -0,0 +1,6 @@
+import type { SummarizerLLM } from "./types.js";
+export declare function heuristicContradiction(existing: string, incoming: string): boolean;
+export declare function isContradiction(existing: string, incoming: string, llm?: SummarizerLLM | null): Promise<boolean>;
+export declare const DUPLICATE_MATCH_THRESHOLD = 0.92;
+export declare const CONTRADICTION_MATCH_THRESHOLD = 0.8;
+export declare function isNearDuplicate(existing: string, incoming: string, score: number): boolean;

package/dist/memory/dedup.js

@@ -0,0 +1,50 @@
+const NEGATION_PATTERN = /\b(not|never|no|without|isn't|aren't|doesn't|don't|won't|cannot|can't|missing|absent|disabled)\b/i;
+function normalize(text) {
+    return text.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+function terms(text) {
+    return normalize(text)
+        .split(" ")
+        .filter((w) => w.length >= 3);
+}
+export function heuristicContradiction(existing, incoming) {
+    const a = normalize(existing);
+    const b = normalize(incoming);
+    const negA = NEGATION_PATTERN.test(a);
+    const negB = NEGATION_PATTERN.test(b);
+    if (negA === negB)
+        return false;
+    const shared = terms(a).filter((t) => terms(b).includes(t));
+    return shared.length >= 2;
+}
+export async function isContradiction(existing, incoming, llm) {
+    if (heuristicContradiction(existing, incoming))
+        return true;
+    if (!llm || !(await llm.available()))
+        return false;
+    try {
+        const raw = await llm.complete({
+            system: "You classify whether two memory statements contradict each other. " +
+                'Output ONLY JSON: {"contradicts": true|false}.',
+            prompt: `Existing: ${existing}\nIncoming: ${incoming}`,
+            temperature: 0,
+            maxTokens: 32,
+            json: true,
+            timeoutMs: 10_000,
+        });
+        const parsed = JSON.parse(raw);
+        return parsed.contradicts === true;
+    }
+    catch {
+        return false;
+    }
+}
+export const DUPLICATE_MATCH_THRESHOLD = 0.92;
+export const CONTRADICTION_MATCH_THRESHOLD = 0.80;
+export function isNearDuplicate(existing, incoming, score) {
+    if (normalize(existing) === normalize(incoming))
+        return true;
+    if (heuristicContradiction(existing, incoming))
+        return false;
+    return score >= DUPLICATE_MATCH_THRESHOLD;
+}

package/dist/memory/embedder-factory.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryConfig } from "../types.js";
+import type { Embedder } from "./types.js";
+export declare function createEmbedder(config: MemoryConfig): Promise<Embedder>;

package/dist/memory/embedder-factory.js

@@ -0,0 +1,81 @@
+// ============================================================
+// ARIA Memory — Embedder factory (auto / ollama / opt-in backends)
+// ============================================================
+import { getAppLogger } from "../logger.js";
+import { envOverride } from "../app-identity.js";
+import { HashEmbedder, OllamaEmbedder } from "./embeddings.js";
+export async function createEmbedder(config) {
+    const log = getAppLogger().child("memory");
+    const strategy = config.embedder ?? "auto";
+    const ollamaUrl = config.ollama_url ?? "http://localhost:11434";
+    if (strategy === "auto" || strategy === "ollama") {
+        const model = config.ollama_model ?? "nomic-embed-text";
+        if (await OllamaEmbedder.isAvailable(ollamaUrl, model)) {
+            log.notice(`embedder: ${model}`);
+            return new OllamaEmbedder(ollamaUrl, model);
+        }
+        if (strategy === "ollama") {
+            log.warn(`Ollama not available or model '${model}' not loaded — falling back to hash embedder. Run: ollama pull ${model}`);
+        }
+    }
+    if (strategy === "transformers") {
+        const embedder = await tryTransformersEmbedder();
+        if (embedder)
+            return embedder;
+        log.warn("@huggingface/transformers not available — falling back to hash embedder. Install with: npm install @huggingface/transformers");
+    }
+    if (strategy === "llama-cpp") {
+        const embedder = await tryLlamaCppEmbedder();
+        if (embedder)
+            return embedder;
+        log.warn("node-llama-cpp not available — falling back to hash embedder. Install with: npm install node-llama-cpp");
+    }
+    if (strategy === "auto") {
+        log.warn("Ollama unavailable — using hash embedder (non-semantic recall). Run `ollama pull nomic-embed-text` for semantic embeddings.");
+    }
+    else if (strategy !== "hash") {
+        log.warn('Semantic recall unavailable — using hash embedder (non-semantic recall). Set embedder = "transformers" in config for local semantic embeddings (no daemon required).');
+    }
+    return new HashEmbedder();
+}
+async function tryTransformersEmbedder() {
+    try {
+        const spec = "@huggingface/transformers";
+        const { pipeline } = await import(/* webpackIgnore: true */ spec);
+        const pipe = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+        return {
+            dim: 384,
+            async embed(text) {
+                const out = await pipe(text, { pooling: "mean", normalize: true });
+                return out.data;
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function tryLlamaCppEmbedder() {
+    try {
+        const spec = "node-llama-cpp";
+        const { getLlama, LlamaEmbeddingContext } = await import(/* webpackIgnore: true */ spec);
+        const llama = await getLlama();
+        const modelPath = envOverride("PRAANA_EMBED_MODEL_PATH", "ARIA_EMBED_MODEL_PATH") ??
+            "models/nomic-embed-text-v1.5.Q8_0.gguf";
+        const model = await llama.loadModel({ modelPath });
+        const ctx = await LlamaEmbeddingContext.create({ model });
+        // Probe actual output dimension rather than assuming 384.
+        const probe = await ctx.getEmbeddingFor("probe");
+        const dim = probe.vector.length;
+        return {
+            dim,
+            async embed(text) {
+                const { vector } = await ctx.getEmbeddingFor(text);
+                return vector;
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/memory/embeddings.d.ts

@@ -0,0 +1,15 @@
+import type { Embedder } from "./types.js";
+export declare const EMBEDDING_DIM = 384;
+export declare class HashEmbedder implements Embedder {
+    readonly dim = 384;
+    embed(text: string): Promise<Float32Array>;
+}
+/** Ollama nomic-embed-text — 768-dim semantic embeddings via local daemon. */
+export declare class OllamaEmbedder implements Embedder {
+    private url;
+    private model;
+    readonly dim = 768;
+    constructor(url?: string, model?: string);
+    static isAvailable(url: string, model?: string): Promise<boolean>;
+    embed(text: string): Promise<Float32Array>;
+}

package/dist/memory/embeddings.js

@@ -0,0 +1,67 @@
+// ============================================================
+// ARIA Memory — Embeddings
+// ============================================================
+export const EMBEDDING_DIM = 384;
+// Deterministic hash-based embedding — fast, offline, zero dependencies.
+// Different text → different vector. Same text → same vector.
+// NOT semantic — just a cheap approximate nearest neighbor.
+export class HashEmbedder {
+    dim = EMBEDDING_DIM;
+    async embed(text) {
+        const vec = new Float32Array(this.dim);
+        let h = 2166136261;
+        for (let i = 0; i < text.length; i++) {
+            h ^= text.charCodeAt(i);
+            h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);
+        }
+        const seed = Math.abs(h);
+        for (let i = 0; i < this.dim; i++) {
+            const x = Math.sin(seed * (i + 1) * 12.9898) * 43758.5453;
+            vec[i] = x - Math.floor(x);
+        }
+        let norm = 0;
+        for (let i = 0; i < this.dim; i++)
+            norm += vec[i] * vec[i];
+        norm = Math.sqrt(norm);
+        for (let i = 0; i < this.dim; i++)
+            vec[i] /= norm;
+        return vec;
+    }
+}
+/** Ollama nomic-embed-text — 768-dim semantic embeddings via local daemon. */
+export class OllamaEmbedder {
+    url;
+    model;
+    dim = 768;
+    constructor(url = "http://localhost:11434", model = "nomic-embed-text") {
+        this.url = url;
+        this.model = model;
+    }
+    static async isAvailable(url, model) {
+        try {
+            const res = await fetch(`${url}/api/tags`, {
+                signal: AbortSignal.timeout(2000),
+            });
+            if (!res.ok)
+                return false;
+            if (!model)
+                return true;
+            const data = (await res.json());
+            return data.models.some((m) => m.name === model || m.name.startsWith(`${model}:`));
+        }
+        catch {
+            return false;
+        }
+    }
+    async embed(text) {
+        const res = await fetch(`${this.url}/api/embeddings`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ model: this.model, prompt: text }),
+        });
+        if (!res.ok)
+            throw new Error(`Ollama embed failed: ${res.status}`);
+        const { embedding } = (await res.json());
+        return new Float32Array(embedding);
+    }
+}

package/dist/memory/index.d.ts

@@ -0,0 +1,9 @@
+export { MemoryStore } from "./store.js";
+export { retractMemory } from "./db.js";
+export { HashEmbedder, OllamaEmbedder, EMBEDDING_DIM } from "./embeddings.js";
+export { createEmbedder } from "./embedder-factory.js";
+export { createSummarizer } from "./summarizer-factory.js";
+export { OpenAISummarizer } from "./openai-summarizer.js";
+export { OllamaSummarizer, listOllamaModelNames, pickDefaultChatModel, } from "./ollama-summarizer.js";
+export { extractLearnings, summarizeTurns } from "./summarizer.js";
+export type { MemoryEntry, MemoryKind, Certainty, SessionContext, SessionEvent, Digest, RecallOptions, RecallResult, RememberOptions, ExtractedLearning, SummarizerLLM, Embedder, } from "./types.js";

package/dist/memory/index.js

@@ -0,0 +1,11 @@
+// ============================================================
+// ARIA Memory — Public API
+// ============================================================
+export { MemoryStore } from "./store.js";
+export { retractMemory } from "./db.js";
+export { HashEmbedder, OllamaEmbedder, EMBEDDING_DIM } from "./embeddings.js";
+export { createEmbedder } from "./embedder-factory.js";
+export { createSummarizer } from "./summarizer-factory.js";
+export { OpenAISummarizer } from "./openai-summarizer.js";
+export { OllamaSummarizer, listOllamaModelNames, pickDefaultChatModel, } from "./ollama-summarizer.js";
+export { extractLearnings, summarizeTurns } from "./summarizer.js";

package/dist/memory/ollama-summarizer.d.ts

@@ -0,0 +1,19 @@
+import type { SummarizerLLM } from "./types.js";
+export declare function listOllamaModelNames(url: string): Promise<string[]>;
+/** First installed model that does not look like an embedding model. */
+export declare function pickDefaultChatModel(names: string[]): string | null;
+export declare class OllamaSummarizer implements SummarizerLLM {
+    private url;
+    private model;
+    readonly name: string;
+    constructor(url: string, model: string);
+    available(): Promise<boolean>;
+    complete(opts: {
+        system?: string;
+        prompt: string;
+        temperature?: number;
+        maxTokens?: number;
+        json?: boolean;
+        timeoutMs?: number;
+    }): Promise<string>;
+}

package/dist/memory/ollama-summarizer.js

@@ -0,0 +1,72 @@
+// ============================================================
+// ARIA Memory — Ollama Summarizer Adapter
+// ============================================================
+import { OllamaEmbedder } from "./embeddings.js";
+export async function listOllamaModelNames(url) {
+    try {
+        const res = await fetch(`${url.replace(/\/$/, "")}/api/tags`, {
+            signal: AbortSignal.timeout(2000),
+        });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        return data.models.map((m) => m.name);
+    }
+    catch {
+        return [];
+    }
+}
+/** First installed model that does not look like an embedding model. */
+export function pickDefaultChatModel(names) {
+    const chat = names.filter((n) => !/embed/i.test(n));
+    return chat[0] ?? null;
+}
+export class OllamaSummarizer {
+    url;
+    model;
+    name;
+    constructor(url, model) {
+        this.url = url;
+        this.model = model;
+        this.url = url.replace(/\/$/, "");
+        this.name = `ollama:${model}`;
+    }
+    async available() {
+        return OllamaEmbedder.isAvailable(this.url, this.model);
+    }
+    async complete(opts) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), opts.timeoutMs ?? 60_000);
+        try {
+            const messages = [];
+            if (opts.system)
+                messages.push({ role: "system", content: opts.system });
+            messages.push({ role: "user", content: opts.prompt });
+            const body = {
+                model: this.model,
+                messages,
+                stream: false,
+                options: {
+                    temperature: opts.temperature ?? 0.3,
+                    num_predict: opts.maxTokens ?? 1500,
+                },
+            };
+            if (opts.json)
+                body.format = "json";
+            const res = await fetch(`${this.url}/api/chat`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                throw new Error(`Summarizer ${res.status}: ${await res.text()}`);
+            }
+            const json = (await res.json());
+            return json.message?.content ?? "";
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}

package/dist/memory/openai-summarizer.d.ts

@@ -0,0 +1,21 @@
+import type { SummarizerLLM } from "./types.js";
+export declare class OpenAISummarizer implements SummarizerLLM {
+    readonly name: string;
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly model;
+    constructor(opts: {
+        baseUrl: string;
+        apiKey: string;
+        model: string;
+    });
+    available(): Promise<boolean>;
+    complete(opts: {
+        system?: string;
+        prompt: string;
+        temperature?: number;
+        maxTokens?: number;
+        json?: boolean;
+        timeoutMs?: number;
+    }): Promise<string>;
+}