audrey 0.16.1 → 0.20.0

package/src/db.js

@@ -1,370 +0,0 @@
-import Database from 'better-sqlite3';
-import * as sqliteVec from 'sqlite-vec';
-import { join } from 'node:path';
-import { mkdirSync, existsSync } from 'node:fs';
-
-const SCHEMA = `
-  CREATE TABLE IF NOT EXISTS episodes (
-    id TEXT PRIMARY KEY,
-    content TEXT NOT NULL,
-    embedding BLOB,
-    source TEXT NOT NULL CHECK(source IN ('direct-observation','told-by-user','tool-result','inference','model-generated')),
-    source_reliability REAL NOT NULL,
-    salience REAL DEFAULT 0.5,
-    context TEXT DEFAULT '{}',
-    affect TEXT DEFAULT '{}',
-    tags TEXT,
-    causal_trigger TEXT,
-    causal_consequence TEXT,
-    created_at TEXT NOT NULL,
-    embedding_model TEXT,
-    embedding_version TEXT,
-    supersedes TEXT,
-    superseded_by TEXT,
-    consolidated INTEGER DEFAULT 0,
-    private INTEGER DEFAULT 0,
-    FOREIGN KEY (supersedes) REFERENCES episodes(id)
-  );
-
-  CREATE TABLE IF NOT EXISTS semantics (
-    id TEXT PRIMARY KEY,
-    content TEXT NOT NULL,
-    embedding BLOB,
-    state TEXT DEFAULT 'active' CHECK(state IN ('active','disputed','superseded','context_dependent','dormant','rolled_back')),
-    conditions TEXT,
-    evidence_episode_ids TEXT,
-    evidence_count INTEGER DEFAULT 0,
-    supporting_count INTEGER DEFAULT 0,
-    contradicting_count INTEGER DEFAULT 0,
-    source_type_diversity INTEGER DEFAULT 0,
-    consolidation_checkpoint TEXT,
-    embedding_model TEXT,
-    embedding_version TEXT,
-    consolidation_model TEXT,
-    consolidation_prompt_hash TEXT,
-    created_at TEXT NOT NULL,
-    last_reinforced_at TEXT,
-    retrieval_count INTEGER DEFAULT 0,
-    challenge_count INTEGER DEFAULT 0,
-    interference_count INTEGER DEFAULT 0,
-    salience REAL DEFAULT 0.5
-  );
-
-  CREATE TABLE IF NOT EXISTS procedures (
-    id TEXT PRIMARY KEY,
-    content TEXT NOT NULL,
-    embedding BLOB,
-    state TEXT DEFAULT 'active' CHECK(state IN ('active','disputed','superseded','context_dependent','dormant','rolled_back')),
-    trigger_conditions TEXT,
-    evidence_episode_ids TEXT,
-    success_count INTEGER DEFAULT 0,
-    failure_count INTEGER DEFAULT 0,
-    embedding_model TEXT,
-    embedding_version TEXT,
-    created_at TEXT NOT NULL,
-    last_reinforced_at TEXT,
-    retrieval_count INTEGER DEFAULT 0,
-    interference_count INTEGER DEFAULT 0,
-    salience REAL DEFAULT 0.5
-  );
-
-  CREATE TABLE IF NOT EXISTS causal_links (
-    id TEXT PRIMARY KEY,
-    cause_id TEXT NOT NULL,
-    effect_id TEXT NOT NULL,
-    link_type TEXT DEFAULT 'causal' CHECK(link_type IN ('causal','correlational','temporal')),
-    mechanism TEXT,
-    confidence REAL,
-    evidence_count INTEGER DEFAULT 1,
-    created_at TEXT NOT NULL
-  );
-
-  CREATE TABLE IF NOT EXISTS contradictions (
-    id TEXT PRIMARY KEY,
-    claim_a_id TEXT NOT NULL,
-    claim_b_id TEXT NOT NULL,
-    claim_a_type TEXT NOT NULL,
-    claim_b_type TEXT NOT NULL,
-    state TEXT DEFAULT 'open' CHECK(state IN ('open','resolved','context_dependent','reopened')),
-    resolution TEXT,
-    resolved_at TEXT,
-    reopened_at TEXT,
-    reopen_evidence_id TEXT,
-    created_at TEXT NOT NULL
-  );
-
-  CREATE TABLE IF NOT EXISTS consolidation_runs (
-    id TEXT PRIMARY KEY,
-    checkpoint_cursor TEXT,
-    input_episode_ids TEXT,
-    output_memory_ids TEXT,
-    confidence_deltas TEXT,
-    consolidation_model TEXT,
-    consolidation_prompt_hash TEXT,
-    started_at TEXT,
-    completed_at TEXT,
-    status TEXT DEFAULT 'running' CHECK(status IN ('running','completed','failed','rolled_back'))
-  );
-
-  CREATE TABLE IF NOT EXISTS audrey_config (
-    key TEXT PRIMARY KEY,
-    value TEXT NOT NULL
-  );
-
-  CREATE TABLE IF NOT EXISTS consolidation_metrics (
-    id TEXT PRIMARY KEY,
-    run_id TEXT NOT NULL,
-    min_cluster_size INTEGER NOT NULL,
-    similarity_threshold REAL NOT NULL,
-    episodes_evaluated INTEGER NOT NULL,
-    clusters_found INTEGER NOT NULL,
-    principles_extracted INTEGER NOT NULL,
-    created_at TEXT NOT NULL,
-    FOREIGN KEY (run_id) REFERENCES consolidation_runs(id)
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_episodes_created ON episodes(created_at);
-  CREATE INDEX IF NOT EXISTS idx_episodes_consolidated ON episodes(consolidated);
-  CREATE INDEX IF NOT EXISTS idx_episodes_source ON episodes(source);
-  CREATE INDEX IF NOT EXISTS idx_semantics_state ON semantics(state);
-  CREATE INDEX IF NOT EXISTS idx_procedures_state ON procedures(state);
-  CREATE INDEX IF NOT EXISTS idx_contradictions_state ON contradictions(state);
-  CREATE INDEX IF NOT EXISTS idx_consolidation_status ON consolidation_runs(status);
-`;
-
-export function createVec0Tables(db, dimensions) {
-  db.exec(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS vec_episodes USING vec0(
-      id text primary key,
-      embedding float[${dimensions}] distance_metric=cosine,
-      source text,
-      consolidated integer
-    );
-  `);
-  db.exec(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS vec_semantics USING vec0(
-      id text primary key,
-      embedding float[${dimensions}] distance_metric=cosine,
-      state text
-    );
-  `);
-  db.exec(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS vec_procedures USING vec0(
-      id text primary key,
-      embedding float[${dimensions}] distance_metric=cosine,
-      state text
-    );
-  `);
-}
-
-export function dropVec0Tables(db) {
-  db.exec('DROP TABLE IF EXISTS vec_episodes');
-  db.exec('DROP TABLE IF EXISTS vec_semantics');
-  db.exec('DROP TABLE IF EXISTS vec_procedures');
-}
-
-function migrateTable(db, { source, target, selectCols, insertCols, placeholders, transform, dimensions }) {
-  const count = db.prepare(`SELECT COUNT(*) as c FROM ${target}`).get().c;
-  if (count > 0) return;
-
-  const rows = db.prepare(`SELECT ${selectCols} FROM ${source} WHERE embedding IS NOT NULL`).all();
-  if (rows.length === 0) return;
-
-  const expectedBytes = dimensions ? dimensions * 4 : null;
-  const insert = db.prepare(`INSERT INTO ${target}(${insertCols}) VALUES (${placeholders})`);
-  const tx = db.transaction(() => {
-    for (const row of rows) {
-      if (expectedBytes && row.embedding.byteLength !== expectedBytes) continue;
-      insert.run(...transform(row));
-    }
-  });
-  tx();
-}
-
-function migrateEmbeddingsToVec0(db, dimensions) {
-  migrateTable(db, {
-    source: 'episodes',
-    target: 'vec_episodes',
-    selectCols: 'id, embedding, source, consolidated',
-    insertCols: 'id, embedding, source, consolidated',
-    placeholders: '?, ?, ?, ?',
-    transform: (row) => [row.id, row.embedding, row.source, BigInt(row.consolidated ?? 0)],
-    dimensions,
-  });
-
-  migrateTable(db, {
-    source: 'semantics',
-    target: 'vec_semantics',
-    selectCols: 'id, embedding, state',
-    insertCols: 'id, embedding, state',
-    placeholders: '?, ?, ?',
-    transform: (row) => [row.id, row.embedding, row.state],
-    dimensions,
-  });
-
-  migrateTable(db, {
-    source: 'procedures',
-    target: 'vec_procedures',
-    selectCols: 'id, embedding, state',
-    insertCols: 'id, embedding, state',
-    placeholders: '?, ?, ?',
-    transform: (row) => [row.id, row.embedding, row.state],
-    dimensions,
-  });
-}
-
-function getEmbeddingSyncCounts(db) {
-  let vecEpisodes = 0;
-  let vecSemantics = 0;
-  let vecProcedures = 0;
-
-  try {
-    vecEpisodes = db.prepare('SELECT COUNT(*) as c FROM vec_episodes').get().c;
-    vecSemantics = db.prepare('SELECT COUNT(*) as c FROM vec_semantics').get().c;
-    vecProcedures = db.prepare('SELECT COUNT(*) as c FROM vec_procedures').get().c;
-  } catch {
-    // vec tables may not exist yet
-  }
-
-  const episodes = db.prepare('SELECT COUNT(*) as c FROM episodes WHERE embedding IS NOT NULL').get().c;
-  const semantics = db.prepare('SELECT COUNT(*) as c FROM semantics WHERE embedding IS NOT NULL').get().c;
-  const procedures = db.prepare('SELECT COUNT(*) as c FROM procedures WHERE embedding IS NOT NULL').get().c;
-
-  return {
-    episodes,
-    vecEpisodes,
-    semantics,
-    vecSemantics,
-    procedures,
-    vecProcedures,
-  };
-}
-
-function addColumnIfMissing(db, table, column, definition) {
-  const columns = db.pragma(`table_info(${table})`);
-  const exists = columns.some(col => col.name === column);
-  if (!exists) {
-    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
-  }
-}
-
-const SCHEMA_VERSION = 7;
-
-const MIGRATIONS = [
-  { version: 1, up(db) { addColumnIfMissing(db, 'episodes', 'context', "TEXT DEFAULT '{}'"); } },
-  { version: 2, up(db) { addColumnIfMissing(db, 'episodes', 'affect', "TEXT DEFAULT '{}'"); } },
-  { version: 3, up(db) { addColumnIfMissing(db, 'semantics', 'interference_count', 'INTEGER DEFAULT 0'); } },
-  { version: 4, up(db) { addColumnIfMissing(db, 'semantics', 'salience', 'REAL DEFAULT 0.5'); } },
-  { version: 5, up(db) { addColumnIfMissing(db, 'procedures', 'interference_count', 'INTEGER DEFAULT 0'); } },
-  { version: 6, up(db) { addColumnIfMissing(db, 'procedures', 'salience', 'REAL DEFAULT 0.5'); } },
-  { version: 7, up(db) { addColumnIfMissing(db, 'episodes', 'private', 'INTEGER DEFAULT 0'); } },
-];
-
-function runMigrations(db) {
-  const row = db.prepare("SELECT value FROM audrey_config WHERE key = 'schema_version'").get();
-  const currentVersion = row ? Number(row.value) : 0;
-
-  if (currentVersion >= SCHEMA_VERSION) return;
-
-  const pending = MIGRATIONS.filter(m => m.version > currentVersion);
-  for (const migration of pending) {
-    migration.up(db);
-  }
-
-  db.prepare(
-    `INSERT INTO audrey_config (key, value) VALUES ('schema_version', ?)
-     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
-  ).run(String(SCHEMA_VERSION));
-}
-
-/**
- * @param {string} dataDir
- * @param {{ dimensions?: number }} [options]
- * @returns {{ db: import('better-sqlite3').Database, migrated: boolean }}
- */
-export function createDatabase(dataDir, options = {}) {
-  let { dimensions } = options;
-  let migrated = false;
-
-  mkdirSync(dataDir, { recursive: true });
-  const dbPath = join(dataDir, 'audrey.db');
-  const db = new Database(dbPath);
-  db.pragma('journal_mode = WAL');
-  db.pragma('foreign_keys = ON');
-  db.pragma('busy_timeout = 5000');
-  db.exec(SCHEMA);
-  runMigrations(db);
-
-  if (dimensions == null) {
-    const stored = db.prepare("SELECT value FROM audrey_config WHERE key = 'dimensions'").get();
-    if (stored) {
-      dimensions = parseInt(stored.value, 10);
-    }
-  }
-
-  if (dimensions != null) {
-    if (!Number.isInteger(dimensions) || dimensions <= 0) {
-      throw new Error(`dimensions must be a positive integer, got: ${dimensions}`);
-    }
-
-    sqliteVec.load(db);
-
-    const existing = db.prepare(
-      "SELECT value FROM audrey_config WHERE key = 'dimensions'"
-    ).get();
-
-    if (existing) {
-      const storedDims = parseInt(existing.value, 10);
-      if (storedDims !== dimensions) {
-        dropVec0Tables(db);
-        db.prepare(
-          "UPDATE audrey_config SET value = ? WHERE key = 'dimensions'"
-        ).run(String(dimensions));
-        migrated = true;
-      }
-    } else {
-      db.prepare(
-        "INSERT INTO audrey_config (key, value) VALUES ('dimensions', ?)"
-      ).run(String(dimensions));
-    }
-
-    createVec0Tables(db, dimensions);
-
-    if (!migrated) {
-      migrateEmbeddingsToVec0(db, dimensions);
-      const sync = getEmbeddingSyncCounts(db);
-      if (
-        sync.episodes !== sync.vecEpisodes
-        || sync.semantics !== sync.vecSemantics
-        || sync.procedures !== sync.vecProcedures
-      ) {
-        // Legacy blobs exist but could not be copied cleanly into vec0.
-        // Mark the store for lazy re-embedding so the next encode/recall repairs it.
-        migrated = true;
-      }
-    }
-  }
-
-  return { db, migrated };
-}
-
-export function readStoredDimensions(dataDir) {
-  const dbPath = join(dataDir, 'audrey.db');
-  if (!existsSync(dbPath)) return null;
-  const db = new Database(dbPath, { readonly: true });
-  try {
-    const row = db.prepare("SELECT value FROM audrey_config WHERE key = 'dimensions'").get();
-    return row ? parseInt(row.value, 10) : null;
-  } catch (err) {
-    if (err.message?.includes('no such table')) return null;
-    throw err;
-  } finally {
-    db.close();
-  }
-}
-
-export function closeDatabase(db) {
-  if (db && db.open) {
-    db.close();
-  }
-}

package/src/decay.js

@@ -1,84 +0,0 @@
-import { computeConfidence, DEFAULT_HALF_LIVES, salienceModifier } from './confidence.js';
-import { interferenceModifier } from './interference.js';
-import { daysBetween } from './utils.js';
-
-/**
- * @param {import('better-sqlite3').Database} db
- * @param {{ dormantThreshold?: number }} [options]
- * @returns {{ totalEvaluated: number, transitionedToDormant: number, timestamp: string }}
- */
-export function applyDecay(db, { dormantThreshold = 0.1, halfLives } = {}) {
-  const now = new Date();
-  let totalEvaluated = 0;
-  let transitionedToDormant = 0;
-
-  const semantics = db.prepare(`
-    SELECT id, supporting_count, contradicting_count, created_at,
-           last_reinforced_at, retrieval_count, interference_count, salience
-    FROM semantics WHERE state = 'active'
-  `).all();
-
-  const markDormantSem = db.prepare('UPDATE semantics SET state = ? WHERE id = ?');
-
-  for (const sem of semantics) {
-    totalEvaluated++;
-    const ageDays = daysBetween(sem.created_at, now);
-    const daysSinceRetrieval = sem.last_reinforced_at
-      ? daysBetween(sem.last_reinforced_at, now)
-      : ageDays;
-
-    let confidence = computeConfidence({
-      sourceType: 'tool-result',
-      supportingCount: sem.supporting_count || 0,
-      contradictingCount: sem.contradicting_count || 0,
-      ageDays,
-      halfLifeDays: halfLives?.semantic ?? DEFAULT_HALF_LIVES.semantic,
-      retrievalCount: sem.retrieval_count || 0,
-      daysSinceRetrieval,
-    });
-    confidence *= interferenceModifier(sem.interference_count || 0);
-    confidence *= salienceModifier(sem.salience ?? 0.5);
-    confidence = Math.max(0, Math.min(1, confidence));
-
-    if (confidence < dormantThreshold) {
-      markDormantSem.run('dormant', sem.id);
-      transitionedToDormant++;
-    }
-  }
-
-  const procedures = db.prepare(`
-    SELECT id, success_count, failure_count, created_at,
-           last_reinforced_at, retrieval_count, interference_count, salience
-    FROM procedures WHERE state = 'active'
-  `).all();
-
-  const markDormantProc = db.prepare('UPDATE procedures SET state = ? WHERE id = ?');
-
-  for (const proc of procedures) {
-    totalEvaluated++;
-    const ageDays = daysBetween(proc.created_at, now);
-    const daysSinceRetrieval = proc.last_reinforced_at
-      ? daysBetween(proc.last_reinforced_at, now)
-      : ageDays;
-
-    let confidence = computeConfidence({
-      sourceType: 'tool-result',
-      supportingCount: proc.success_count || 0,
-      contradictingCount: proc.failure_count || 0,
-      ageDays,
-      halfLifeDays: halfLives?.procedural ?? DEFAULT_HALF_LIVES.procedural,
-      retrievalCount: proc.retrieval_count || 0,
-      daysSinceRetrieval,
-    });
-    confidence *= interferenceModifier(proc.interference_count || 0);
-    confidence *= salienceModifier(proc.salience ?? 0.5);
-    confidence = Math.max(0, Math.min(1, confidence));
-
-    if (confidence < dormantThreshold) {
-      markDormantProc.run('dormant', proc.id);
-      transitionedToDormant++;
-    }
-  }
-
-  return { totalEvaluated, transitionedToDormant, timestamp: now.toISOString() };
-}

package/src/embedding.js

@@ -1,256 +0,0 @@
-import { createHash } from 'node:crypto';
-
-/**
- * @typedef {Object} EmbeddingProvider
- * @property {number} dimensions
- * @property {string} modelName
- * @property {string} modelVersion
- * @property {(text: string) => Promise<number[]>} embed
- * @property {(texts: string[]) => Promise<number[][]>} embedBatch
- * @property {(vector: number[]) => Buffer} vectorToBuffer
- * @property {(buffer: Buffer) => number[]} bufferToVector
- */
-
-/** @implements {EmbeddingProvider} */
-export class MockEmbeddingProvider {
-  constructor({ dimensions = 64 } = {}) {
-    this.dimensions = dimensions;
-    this.modelName = 'mock-embedding';
-    this.modelVersion = '1.0.0';
-  }
-
-  async embed(text) {
-    const hash = createHash('sha256').update(text).digest();
-    const vector = new Array(this.dimensions);
-    for (let i = 0; i < this.dimensions; i++) {
-      vector[i] = (hash[i % hash.length] / 255) * 2 - 1;
-    }
-    const magnitude = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
-    return vector.map(v => v / magnitude);
-  }
-
-  async embedBatch(texts) {
-    return Promise.all(texts.map(t => this.embed(t)));
-  }
-
-  vectorToBuffer(vector) {
-    return Buffer.from(new Float32Array(vector).buffer);
-  }
-
-  bufferToVector(buffer) {
-    return Array.from(new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4));
-  }
-}
-
-/** @implements {EmbeddingProvider} */
-export class OpenAIEmbeddingProvider {
-  constructor({ apiKey, model = 'text-embedding-3-small', dimensions = 1536, timeout = 30000 } = {}) {
-    this.apiKey = apiKey || process.env.OPENAI_API_KEY;
-    this.model = model;
-    this.dimensions = dimensions;
-    this.timeout = timeout;
-    this.modelName = model;
-    this.modelVersion = 'latest';
-  }
-
-  async embed(text) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch('https://api.openai.com/v1/embeddings', {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${this.apiKey}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ input: text, model: this.model, dimensions: this.dimensions }),
-        signal: controller.signal,
-      });
-      if (!response.ok) throw new Error(`OpenAI embedding failed: ${response.status}`);
-      const data = await response.json();
-      return data.data[0].embedding;
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-
-  async embedBatch(texts) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch('https://api.openai.com/v1/embeddings', {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${this.apiKey}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ input: texts, model: this.model, dimensions: this.dimensions }),
-        signal: controller.signal,
-      });
-      if (!response.ok) throw new Error(`OpenAI embedding failed: ${response.status}`);
-      const data = await response.json();
-      return data.data.map(d => d.embedding);
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-
-  vectorToBuffer(vector) {
-    return Buffer.from(new Float32Array(vector).buffer);
-  }
-
-  bufferToVector(buffer) {
-    return Array.from(new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4));
-  }
-}
-
-/** @implements {EmbeddingProvider} */
-export class LocalEmbeddingProvider {
-  constructor({ model = 'Xenova/all-MiniLM-L6-v2', device = 'gpu', batchSize = 64 } = {}) {
-    this.model = model;
-    this.dimensions = 384;
-    this.modelName = model;
-    this.modelVersion = '1.0.0';
-    this.device = device;
-    this.batchSize = batchSize;
-    this._pipeline = null;
-    this._readyPromise = null;
-    this._actualDevice = null;
-  }
-
-  ready() {
-    if (!this._readyPromise) {
-      this._readyPromise = (async () => {
-        const { pipeline } = await import('@huggingface/transformers');
-        try {
-          this._pipeline = await pipeline('feature-extraction', this.model, {
-            dtype: 'fp32', device: this.device,
-          });
-          this._actualDevice = this.device;
-        } catch {
-          this._pipeline = await pipeline('feature-extraction', this.model, {
-            dtype: 'fp32', device: 'cpu',
-          });
-          this._actualDevice = 'cpu';
-        }
-      })();
-    }
-    return this._readyPromise;
-  }
-
-  async embed(text) {
-    await this.ready();
-    const output = await this._pipeline(text, { pooling: 'mean', normalize: true });
-    return Array.from(output.data);
-  }
-
-  async embedBatch(texts) {
-    if (texts.length === 0) return [];
-    await this.ready();
-    const results = [];
-    for (let i = 0; i < texts.length; i += this.batchSize) {
-      const chunk = texts.slice(i, i + this.batchSize);
-      const output = await this._pipeline(chunk, { pooling: 'mean', normalize: true });
-      results.push(...output.tolist());
-    }
-    return results;
-  }
-
-  vectorToBuffer(vector) {
-    return Buffer.from(new Float32Array(vector).buffer);
-  }
-
-  bufferToVector(buffer) {
-    return Array.from(new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4));
-  }
-}
-
-/** @implements {EmbeddingProvider} */
-export class GeminiEmbeddingProvider {
-  constructor({ apiKey, model = 'gemini-embedding-001', timeout = 30000 } = {}) {
-    this.apiKey = apiKey || process.env.GOOGLE_API_KEY;
-    this.model = model;
-    this.dimensions = 3072;
-    this.timeout = timeout;
-    this.modelName = model;
-    this.modelVersion = 'latest';
-  }
-
-  async embed(text) {
-    if (!this.apiKey) throw new Error('Gemini embedding requires GOOGLE_API_KEY');
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch(
-        `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:embedContent?key=${this.apiKey}`,
-        {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ model: `models/${this.model}`, content: { parts: [{ text }] } }),
-          signal: controller.signal,
-        }
-      );
-      if (!response.ok) throw new Error(`Gemini embedding failed: ${response.status}`);
-      const data = await response.json();
-      return data.embedding.values;
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-
-  async embedBatch(texts) {
-    if (texts.length === 0) return [];
-    if (!this.apiKey) throw new Error('Gemini embedding requires GOOGLE_API_KEY');
-    const results = [];
-    for (let i = 0; i < texts.length; i += 100) {
-      const chunk = texts.slice(i, i + 100);
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), this.timeout);
-      try {
-        const response = await fetch(
-          `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:batchEmbedContents?key=${this.apiKey}`,
-          {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-              requests: chunk.map(text => ({
-                model: `models/${this.model}`,
-                content: { parts: [{ text }] },
-              })),
-            }),
-            signal: controller.signal,
-          }
-        );
-        if (!response.ok) throw new Error(`Gemini batch embedding failed: ${response.status}`);
-        const data = await response.json();
-        results.push(...data.embeddings.map(e => e.values));
-      } finally {
-        clearTimeout(timer);
-      }
-    }
-    return results;
-  }
-
-  vectorToBuffer(vector) {
-    return Buffer.from(new Float32Array(vector).buffer);
-  }
-
-  bufferToVector(buffer) {
-    return Array.from(new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4));
-  }
-}
-
-export function createEmbeddingProvider(config) {
-  switch (config.provider) {
-    case 'mock':
-      return new MockEmbeddingProvider(config);
-    case 'openai':
-      return new OpenAIEmbeddingProvider(config);
-    case 'local':
-      return new LocalEmbeddingProvider(config);
-    case 'gemini':
-      return new GeminiEmbeddingProvider(config);
-    default:
-      throw new Error(`Unknown embedding provider: ${config.provider}. Valid: mock, openai, local, gemini`);
-  }
-}