teleton 0.2.5 → 0.4.0

package/dist/{chunk-DR6WM6B5.js → chunk-7UPH62J2.js}

@@ -1,27 +1,30 @@
 import {
   VOYAGE_API_URL,
   fetchWithTimeout
-} from "./chunk-DAMFGHXV.js";
+} from "./chunk-A64NPEFL.js";
 import {
+  EMBEDDING_CACHE_EVICTION_INTERVAL,
+  EMBEDDING_CACHE_MAX_ENTRIES,
+  EMBEDDING_CACHE_TTL_DAYS,
   KNOWLEDGE_CHUNK_OVERLAP,
   KNOWLEDGE_CHUNK_SIZE,
   SQLITE_CACHE_SIZE_KB,
   SQLITE_MMAP_SIZE,
   VOYAGE_BATCH_SIZE
-} from "./chunk-2X4PCE7V.js";
+} from "./chunk-OA5L7GM6.js";
 import {
   TELETON_ROOT
 } from "./chunk-EYWNOHMJ.js";
 
 // src/memory/database.ts
 import Database2 from "better-sqlite3";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, chmodSync as chmodSync2 } from "fs";
 import { dirname as dirname2 } from "path";
 import * as sqliteVec from "sqlite-vec";
 
 // src/utils/module-db.ts
 import Database from "better-sqlite3";
-import { existsSync, mkdirSync } from "fs";
+import { existsSync, mkdirSync, chmodSync } from "fs";
 import { dirname, join } from "path";
 var JOURNAL_SCHEMA = `
   CREATE TABLE IF NOT EXISTS journal (
@@ -72,6 +75,10 @@ function openModuleDb(path) {
     mkdirSync(dir, { recursive: true });
   }
   const db = new Database(path);
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
   db.pragma("journal_mode = WAL");
   return db;
 }
@@ -92,6 +99,11 @@ function createDbWrapper(getDb, moduleName) {
 var MAIN_DB_PATH = join(TELETON_ROOT, "memory.db");
 function migrateFromMainDb(moduleDb, tables) {
   let totalMigrated = 0;
+  for (const table of tables) {
+    if (!/^[a-z_]+$/.test(table)) {
+      throw new Error(`Invalid table name for migration: "${table}"`);
+    }
+  }
   for (const table of tables) {
     try {
       const row = moduleDb.prepare(`SELECT COUNT(*) as c FROM ${table}`).get();
@@ -362,16 +374,16 @@ function ensureSchema(db) {
     -- ============================================
 
     CREATE TABLE IF NOT EXISTS embedding_cache (
-      hash TEXT PRIMARY KEY,
-      embedding TEXT NOT NULL,
+      hash TEXT NOT NULL,
       model TEXT NOT NULL,
       provider TEXT NOT NULL,
-      dims INTEGER,
+      embedding BLOB NOT NULL,
+      dims INTEGER NOT NULL,
       created_at INTEGER NOT NULL DEFAULT (unixepoch()),
-      accessed_at INTEGER NOT NULL DEFAULT (unixepoch())
+      accessed_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      PRIMARY KEY (hash, model, provider)
     );
 
-    CREATE INDEX IF NOT EXISTS idx_embedding_cache_model ON embedding_cache(provider, model);
     CREATE INDEX IF NOT EXISTS idx_embedding_cache_accessed ON embedding_cache(accessed_at);
 
     -- =====================================================
@@ -416,7 +428,7 @@ function setSchemaVersion(db, version) {
   `
   ).run(version);
 }
-var CURRENT_SCHEMA_VERSION = "1.8.0";
+var CURRENT_SCHEMA_VERSION = "1.9.0";
 function runMigrations(db) {
   const currentVersion = getSchemaVersion(db);
   if (!currentVersion || versionLessThan(currentVersion, "1.1.0")) {
@@ -500,6 +512,29 @@ function runMigrations(db) {
       throw error;
     }
   }
+  if (!currentVersion || versionLessThan(currentVersion, "1.9.0")) {
+    console.log("\u{1F504} Running migration 1.9.0: Upgrade embedding_cache to BLOB storage");
+    try {
+      db.exec(`DROP TABLE IF EXISTS embedding_cache`);
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS embedding_cache (
+          hash TEXT NOT NULL,
+          model TEXT NOT NULL,
+          provider TEXT NOT NULL,
+          embedding BLOB NOT NULL,
+          dims INTEGER NOT NULL,
+          created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+          accessed_at INTEGER NOT NULL DEFAULT (unixepoch()),
+          PRIMARY KEY (hash, model, provider)
+        );
+        CREATE INDEX IF NOT EXISTS idx_embedding_cache_accessed ON embedding_cache(accessed_at);
+      `);
+      console.log("\u2705 Migration 1.9.0 complete: embedding_cache upgraded to BLOB storage");
+    } catch (error) {
+      console.error("\u274C Migration 1.9.0 failed:", error);
+      throw error;
+    }
+  }
   setSchemaVersion(db, CURRENT_SCHEMA_VERSION);
 }
 
@@ -517,6 +552,10 @@ var MemoryDatabase = class {
     this.db = new Database2(config.path, {
       verbose: process.env.DEBUG_SQL ? console.log : void 0
     });
+    try {
+      chmodSync2(config.path, 384);
+    } catch {
+    }
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("synchronous = NORMAL");
     this.db.pragma(`cache_size = -${SQLITE_CACHE_SIZE_KB}`);
@@ -541,13 +580,12 @@ var MemoryDatabase = class {
     if (this.config.enableVectorSearch) {
       this.loadVectorExtension();
     }
+    this.db.exec("ANALYZE");
   }
   loadVectorExtension() {
     try {
       sqliteVec.load(this.db);
-      console.log("\u2705 sqlite-vec loaded successfully");
-      const { vec_version } = this.db.prepare("SELECT vec_version() as vec_version").get();
-      console.log(`   Version: ${vec_version}`);
+      this.db.prepare("SELECT vec_version() as vec_version").get();
       const dims = this.config.vectorDimensions ?? 512;
       ensureVectorTables(this.db, dims);
       this.vectorReady = true;
@@ -691,6 +729,9 @@ function closeDatabase() {
   }
 }
 
+// src/memory/embeddings/index.ts
+import { createHash } from "crypto";
+
 // src/memory/embeddings/provider.ts
 var NoopEmbeddingProvider = class {
   id = "noop";
@@ -762,32 +803,159 @@ var AnthropicEmbeddingProvider = class {
 };
 
 // src/memory/embeddings/local.ts
+import { pipeline } from "@huggingface/transformers";
+var extractorPromise = null;
+function getExtractor(model) {
+  if (!extractorPromise) {
+    console.log(`\u{1F4E6} Loading local embedding model: ${model} \u2026`);
+    extractorPromise = pipeline("feature-extraction", model, {
+      dtype: "fp32"
+    }).then((ext) => {
+      console.log(`\u2705 Local embedding model ready`);
+      return ext;
+    });
+  }
+  return extractorPromise;
+}
 var LocalEmbeddingProvider = class {
   id = "local";
   model;
   dimensions;
-  hasWarned = false;
   constructor(config) {
-    this.model = config.model ?? "all-MiniLM-L6-v2";
+    this.model = config.model || "Xenova/all-MiniLM-L6-v2";
     this.dimensions = 384;
   }
   async embedQuery(text) {
-    if (!this.hasWarned) {
-      console.warn(
-        "\u26A0\uFE0F  Local embeddings not yet implemented. Returning zero vectors. This will not work for semantic search. Consider using 'anthropic' embedding provider."
-      );
-      this.hasWarned = true;
+    const extractor = await getExtractor(this.model);
+    const output = await extractor(text, { pooling: "mean", normalize: true });
+    return Array.from(output.data);
+  }
+  async embedBatch(texts) {
+    if (texts.length === 0) return [];
+    const extractor = await getExtractor(this.model);
+    const output = await extractor(texts, { pooling: "mean", normalize: true });
+    const data = output.data;
+    const dims = this.dimensions;
+    const results = [];
+    for (let i = 0; i < texts.length; i++) {
+      results.push(Array.from(data.slice(i * dims, (i + 1) * dims)));
     }
-    return new Array(this.dimensions).fill(0);
+    return results;
+  }
+};
+
+// src/memory/embeddings/cached.ts
+var CachedEmbeddingProvider = class {
+  constructor(inner, db) {
+    this.inner = inner;
+    this.db = db;
+    this.id = inner.id;
+    this.model = inner.model;
+    this.dimensions = inner.dimensions;
+  }
+  id;
+  model;
+  dimensions;
+  hits = 0;
+  misses = 0;
+  ops = 0;
+  cacheGet(hash) {
+    return this.db.prepare(
+      `SELECT embedding FROM embedding_cache WHERE hash = ? AND model = ? AND provider = ?`
+    ).get(hash, this.model, this.id);
+  }
+  cachePut(hash, blob) {
+    this.db.prepare(
+      `INSERT OR REPLACE INTO embedding_cache (hash, embedding, model, provider, dims, created_at, accessed_at)
+         VALUES (?, ?, ?, ?, ?, unixepoch(), unixepoch())`
+    ).run(hash, blob, this.model, this.id, this.dimensions);
+  }
+  cacheTouch(hash) {
+    this.db.prepare(
+      `UPDATE embedding_cache SET accessed_at = unixepoch() WHERE hash = ? AND model = ? AND provider = ?`
+    ).run(hash, this.model, this.id);
+  }
+  async embedQuery(text) {
+    const hash = hashText(text);
+    const row = this.cacheGet(hash);
+    if (row) {
+      this.hits++;
+      this.cacheTouch(hash);
+      this.tick();
+      return deserializeEmbedding(row.embedding);
+    }
+    this.misses++;
+    const embedding = await this.inner.embedQuery(text);
+    this.cachePut(hash, serializeEmbedding(embedding));
+    this.tick();
+    return embedding;
   }
   async embedBatch(texts) {
-    if (!this.hasWarned) {
-      console.warn(
-        "\u26A0\uFE0F  Local embeddings not yet implemented. Returning zero vectors. This will not work for semantic search. Consider using 'anthropic' embedding provider."
+    if (texts.length === 0) return [];
+    const hashes = texts.map(hashText);
+    const results = new Array(texts.length).fill(null);
+    const missIndices = [];
+    const missTexts = [];
+    for (let i = 0; i < texts.length; i++) {
+      const row = this.cacheGet(hashes[i]);
+      if (row) {
+        this.hits++;
+        this.cacheTouch(hashes[i]);
+        results[i] = deserializeEmbedding(row.embedding);
+      } else {
+        this.misses++;
+        missIndices.push(i);
+        missTexts.push(texts[i]);
+      }
+    }
+    if (missTexts.length > 0) {
+      const newEmbeddings = await this.inner.embedBatch(missTexts);
+      for (let j = 0; j < missIndices.length; j++) {
+        const idx = missIndices[j];
+        const embedding = newEmbeddings[j] ?? [];
+        results[idx] = embedding;
+        if (embedding.length > 0) {
+          this.cachePut(hashes[idx], serializeEmbedding(embedding));
+        }
+      }
+    }
+    this.ops += texts.length;
+    this.maybeEvict();
+    this.maybeLogStats();
+    return results;
+  }
+  tick() {
+    this.ops++;
+    this.maybeEvict();
+    this.maybeLogStats();
+  }
+  maybeLogStats() {
+    const total = this.hits + this.misses;
+    if (total > 0 && total % 100 === 0) {
+      const rate = (this.hits / total * 100).toFixed(0);
+      console.log(
+        `\u{1F4CA} Embedding cache: ${this.hits} hits, ${this.misses} misses (${rate}% hit rate)`
       );
-      this.hasWarned = true;
     }
-    return texts.map(() => new Array(this.dimensions).fill(0));
+  }
+  maybeEvict() {
+    if (this.ops % EMBEDDING_CACHE_EVICTION_INTERVAL !== 0) return;
+    try {
+      const cutoff = Math.floor(Date.now() / 1e3) - EMBEDDING_CACHE_TTL_DAYS * 86400;
+      this.db.prepare(`DELETE FROM embedding_cache WHERE accessed_at < ?`).run(cutoff);
+      const count = this.db.prepare(`SELECT COUNT(*) as cnt FROM embedding_cache`).get().cnt;
+      if (count > EMBEDDING_CACHE_MAX_ENTRIES) {
+        const toDelete = Math.ceil(count * 0.1);
+        this.db.prepare(
+          `DELETE FROM embedding_cache WHERE (hash, model, provider) IN (
+              SELECT hash, model, provider FROM embedding_cache ORDER BY accessed_at ASC LIMIT ?
+            )`
+        ).run(toDelete);
+        console.log(`\u{1F9F9} Embedding cache eviction: removed ${toDelete} entries (${count} total)`);
+      }
+    } catch (err) {
+      console.warn("\u26A0\uFE0F Embedding cache eviction error:", err);
+    }
   }
 };
 
@@ -813,27 +981,22 @@ function createEmbeddingProvider(config) {
   }
 }
 function hashText(text) {
-  let hash = 0;
-  for (let i = 0; i < text.length; i++) {
-    const char = text.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
-  }
-  return Math.abs(hash).toString(36);
+  return createHash("sha256").update(text).digest("hex");
 }
 function serializeEmbedding(embedding) {
-  return JSON.stringify(embedding);
+  return Buffer.from(new Float32Array(embedding).buffer);
 }
 function deserializeEmbedding(data) {
   try {
+    if (Buffer.isBuffer(data)) {
+      const floats = new Float32Array(data.buffer, data.byteOffset, data.byteLength / 4);
+      return Array.from(floats);
+    }
     return JSON.parse(data);
   } catch {
     return [];
   }
 }
-function embeddingToBlob(embedding) {
-  return Buffer.from(new Float32Array(embedding).buffer);
-}
 
 // src/memory/agent/knowledge.ts
 import { readFileSync, existsSync as existsSync3, readdirSync, statSync } from "fs";
@@ -876,6 +1039,13 @@ var KnowledgeIndexer = class {
     if (existing?.hash === fileHash) {
       return false;
     }
+    if (this.vectorEnabled) {
+      this.db.prepare(
+        `DELETE FROM knowledge_vec WHERE id IN (
+            SELECT id FROM knowledge WHERE path = ? AND source = 'memory'
+          )`
+      ).run(relPath);
+    }
     this.db.prepare(`DELETE FROM knowledge WHERE path = ? AND source = 'memory'`).run(relPath);
     const chunks = this.chunkMarkdown(content, relPath);
     const texts = chunks.map((c) => c.text);
@@ -898,7 +1068,7 @@ var KnowledgeIndexer = class {
         chunk.hash
       );
       if (insertVec && embedding.length > 0) {
-        insertVec.run(chunk.id, embeddingToBlob(embedding));
+        insertVec.run(chunk.id, serializeEmbedding(embedding));
       }
     }
     return true;
@@ -1095,7 +1265,7 @@ var SessionStore = class {
       const knowledgeId = `session:${sessionId}`;
       const text = `Session from ${session.startedAt.toISOString()}:
 ${session.summary}`;
-      const hash = this.hashText(text);
+      const hash = hashText(text);
       let embedding = null;
       if (this.vectorEnabled) {
         embedding = await this.embedder.embedQuery(text);
@@ -1111,15 +1281,10 @@ ${session.summary}`;
       `
       ).run(knowledgeId, sessionId, text, hash);
       if (embedding && this.vectorEnabled) {
-        const embeddingBuffer = this.serializeEmbedding(embedding);
+        const embeddingBuffer = serializeEmbedding(embedding);
         const rowid = this.db.prepare(`SELECT rowid FROM knowledge WHERE id = ?`).get(knowledgeId);
-        this.db.prepare(
-          `
-          INSERT INTO knowledge_vec (rowid, embedding)
-          VALUES (?, ?)
-          ON CONFLICT(rowid) DO UPDATE SET embedding = excluded.embedding
-        `
-        ).run(rowid.rowid, embeddingBuffer);
+        this.db.prepare(`DELETE FROM knowledge_vec WHERE rowid = ?`).run(rowid.rowid);
+        this.db.prepare(`INSERT INTO knowledge_vec (rowid, embedding) VALUES (?, ?)`).run(rowid.rowid, embeddingBuffer);
       }
       console.log(`Indexed session ${sessionId} to knowledge base`);
     } catch (error) {
@@ -1130,21 +1295,12 @@ ${session.summary}`;
    * Delete a session
    */
   deleteSession(sessionId) {
-    this.db.prepare(`DELETE FROM sessions WHERE id = ?`).run(sessionId);
-    this.db.prepare(`DELETE FROM knowledge WHERE id = ?`).run(`session:${sessionId}`);
-  }
-  hashText(text) {
-    let hash = 0;
-    for (let i = 0; i < text.length; i++) {
-      const char = text.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
+    const knowledgeId = `session:${sessionId}`;
+    if (this.vectorEnabled) {
+      this.db.prepare(`DELETE FROM knowledge_vec WHERE id = ?`).run(knowledgeId);
     }
-    return hash.toString(36);
-  }
-  serializeEmbedding(embedding) {
-    const float32 = new Float32Array(embedding);
-    return Buffer.from(float32.buffer);
+    this.db.prepare(`DELETE FROM sessions WHERE id = ?`).run(sessionId);
+    this.db.prepare(`DELETE FROM knowledge WHERE id = ?`).run(knowledgeId);
   }
 };
 
@@ -1182,7 +1338,8 @@ var MessageStore = class {
     if (message.senderId) {
       this.ensureUser(message.senderId);
     }
-    const embedding = message.text ? await this.embedder.embedQuery(message.text) : [];
+    const embedding = this.vectorEnabled && message.text ? await this.embedder.embedQuery(message.text) : [];
+    const embeddingBuffer = serializeEmbedding(embedding);
     this.db.prepare(
       `
       INSERT OR REPLACE INTO tg_messages (
@@ -1195,7 +1352,7 @@ var MessageStore = class {
       message.chatId,
       message.senderId,
       message.text,
-      serializeEmbedding(embedding),
+      embeddingBuffer,
       message.replyToId,
       message.isFromAgent ? 1 : 0,
       message.hasMedia ? 1 : 0,
@@ -1203,7 +1360,8 @@ var MessageStore = class {
       message.timestamp
     );
     if (this.vectorEnabled && embedding.length > 0 && message.text) {
-      this.db.prepare(`INSERT OR REPLACE INTO tg_messages_vec (id, embedding) VALUES (?, ?)`).run(message.id, embeddingToBlob(embedding));
+      this.db.prepare(`DELETE FROM tg_messages_vec WHERE id = ?`).run(message.id);
+      this.db.prepare(`INSERT INTO tg_messages_vec (id, embedding) VALUES (?, ?)`).run(message.id, embeddingBuffer);
     }
     this.db.prepare(`UPDATE tg_chats SET last_message_at = ?, last_message_id = ? WHERE id = ?`).run(message.timestamp, message.id, message.chatId);
   }
@@ -1571,8 +1729,8 @@ var HybridSearch = class {
     const limit = options.limit ?? 10;
     const vectorWeight = options.vectorWeight ?? 0.7;
     const keywordWeight = options.keywordWeight ?? 0.3;
-    const vectorResults = this.vectorEnabled ? this.vectorSearchKnowledge(queryEmbedding, limit * 2) : [];
-    const keywordResults = this.keywordSearchKnowledge(query, limit * 2);
+    const vectorResults = this.vectorEnabled ? this.vectorSearchKnowledge(queryEmbedding, Math.ceil(limit * 1.5)) : [];
+    const keywordResults = this.keywordSearchKnowledge(query, Math.ceil(limit * 1.5));
     return this.mergeResults(vectorResults, keywordResults, vectorWeight, keywordWeight, limit);
   }
   /**
@@ -1582,22 +1740,27 @@ var HybridSearch = class {
     const limit = options.limit ?? 10;
     const vectorWeight = options.vectorWeight ?? 0.7;
     const keywordWeight = options.keywordWeight ?? 0.3;
-    const vectorResults = this.vectorEnabled ? this.vectorSearchMessages(queryEmbedding, limit * 2, options.chatId) : [];
-    const keywordResults = this.keywordSearchMessages(query, limit * 2, options.chatId);
+    const vectorResults = this.vectorEnabled ? this.vectorSearchMessages(queryEmbedding, Math.ceil(limit * 1.5), options.chatId) : [];
+    const keywordResults = this.keywordSearchMessages(
+      query,
+      Math.ceil(limit * 1.5),
+      options.chatId
+    );
     return this.mergeResults(vectorResults, keywordResults, vectorWeight, keywordWeight, limit);
   }
   vectorSearchKnowledge(embedding, limit) {
     if (!this.vectorEnabled || embedding.length === 0) return [];
     try {
-      const embeddingBuffer = this.serializeEmbedding(embedding);
+      const embeddingBuffer = serializeEmbedding(embedding);
       const rows = this.db.prepare(
         `
         SELECT kv.id, k.text, k.source, kv.distance
-        FROM knowledge_vec kv
+        FROM (
+          SELECT id, distance
+          FROM knowledge_vec
+          WHERE embedding MATCH ? AND k = ?
+        ) kv
         JOIN knowledge k ON k.id = kv.id
-        WHERE kv.embedding MATCH ?
-        ORDER BY kv.distance
-        LIMIT ?
       `
       ).all(embeddingBuffer, limit);
       return rows.map((row) => ({
@@ -1605,7 +1768,6 @@ var HybridSearch = class {
         text: row.text,
         source: row.source,
         score: 1 - row.distance,
-        // Convert distance to similarity
         vectorScore: 1 - row.distance
       }));
     } catch (error) {
@@ -1639,23 +1801,26 @@ var HybridSearch = class {
   vectorSearchMessages(embedding, limit, chatId) {
     if (!this.vectorEnabled || embedding.length === 0) return [];
     try {
-      const embeddingBuffer = this.serializeEmbedding(embedding);
+      const embeddingBuffer = serializeEmbedding(embedding);
       const sql = chatId ? `
         SELECT mv.id, m.text, m.chat_id as source, mv.distance
-        FROM tg_messages_vec mv
+        FROM (
+          SELECT id, distance
+          FROM tg_messages_vec
+          WHERE embedding MATCH ? AND k = ?
+        ) mv
         JOIN tg_messages m ON m.id = mv.id
-        WHERE mv.embedding MATCH ? AND m.chat_id = ?
-        ORDER BY mv.distance
-        LIMIT ?
+        WHERE m.chat_id = ?
       ` : `
         SELECT mv.id, m.text, m.chat_id as source, mv.distance
-        FROM tg_messages_vec mv
+        FROM (
+          SELECT id, distance
+          FROM tg_messages_vec
+          WHERE embedding MATCH ? AND k = ?
+        ) mv
         JOIN tg_messages m ON m.id = mv.id
-        WHERE mv.embedding MATCH ?
-        ORDER BY mv.distance
-        LIMIT ?
       `;
-      const rows = chatId ? this.db.prepare(sql).all(embeddingBuffer, chatId, limit) : this.db.prepare(sql).all(embeddingBuffer, limit);
+      const rows = chatId ? this.db.prepare(sql).all(embeddingBuffer, limit, chatId) : this.db.prepare(sql).all(embeddingBuffer, limit);
       return rows.map((row) => ({
         id: row.id,
         text: row.text ?? "",
@@ -1717,13 +1882,6 @@ var HybridSearch = class {
   bm25ToScore(rank) {
     return 1 / (1 + Math.abs(rank));
   }
-  /**
-   * Serialize embedding (number[]) to Buffer for sqlite-vec
-   */
-  serializeEmbedding(embedding) {
-    const float32 = new Float32Array(embedding);
-    return Buffer.from(float32.buffer);
-  }
 };
 
 // src/memory/search/context.ts
@@ -1808,9 +1966,10 @@ var ContextBuilder = class {
 // src/memory/index.ts
 function initializeMemory(config) {
   const db = getDatabase(config.database);
-  const embedder = createEmbeddingProvider(config.embeddings);
+  const rawEmbedder = createEmbeddingProvider(config.embeddings);
   const vectorEnabled = db.isVectorSearchReady();
   const database = db.getDb();
+  const embedder = rawEmbedder.id === "noop" ? rawEmbedder : new CachedEmbeddingProvider(rawEmbedder, database);
   return {
     db: database,
     embedder,
@@ -1838,11 +1997,11 @@ export {
   NoopEmbeddingProvider,
   AnthropicEmbeddingProvider,
   LocalEmbeddingProvider,
+  CachedEmbeddingProvider,
   createEmbeddingProvider,
   hashText,
   serializeEmbedding,
   deserializeEmbedding,
-  embeddingToBlob,
   KnowledgeIndexer,
   SessionStore,
   MessageStore,

package/dist/{chunk-DAMFGHXV.js → chunk-A64NPEFL.js}

@@ -1,6 +1,6 @@
 import {
   DEFAULT_FETCH_TIMEOUT_MS
-} from "./chunk-LCMHAUNK.js";
+} from "./chunk-67QC5FBN.js";
 
 // src/utils/fetch.ts
 var DEFAULT_TIMEOUT_MS = DEFAULT_FETCH_TIMEOUT_MS;