@shadowforge0/aquifer-memory 0.6.0 → 0.8.0

package/core/aquifer.js

@@ -36,6 +36,24 @@ function loadSql(filename, schema) {
   return raw.replace(/\$\{schema\}/g, qi(schema));
 }
 
+// ---------------------------------------------------------------------------
+// buildRerankDocument — assemble text for cross-encoder reranking
+// ---------------------------------------------------------------------------
+
+function buildRerankDocument(row, maxChars) {
+  let text = (row.summary_text || row.summary_snippet || '').replace(/\s+/g, ' ').trim();
+  const turn = (row.matched_turn_text || '').replace(/\s+/g, ' ').trim();
+
+  if (!text) {
+    text = turn;
+  } else if (turn && !text.includes(turn)) {
+    text = `${text}\n\nMatched turn:\n${turn}`;
+  }
+
+  if (text.length > maxChars) text = text.slice(0, maxChars);
+  return text;
+}
+
 // ---------------------------------------------------------------------------
 // createAquifer
 // ---------------------------------------------------------------------------
@@ -59,6 +77,7 @@ function createAquifer(config) {
     ownsPool = true;
   } else {
     pool = config.db;
+    ownsPool = !!config.ownsPool;  // allow factory to claim ownership
   }
 
   // Embed config (lazy — only required for recall/enrich)
@@ -81,6 +100,19 @@ function createAquifer(config) {
   const entityPromptFn = config.entities && config.entities.prompt ? config.entities.prompt : null;
   const entityScope = (config.entities && config.entities.scope) || 'default';
 
+  // FTS config — locked to 'simple'.
+  // The search_tsv trigger always uses to_tsvector('simple', ...), so query-time
+  // config must match.  Warn and override if someone passes anything else.
+  const _rawFtsConfig = config.ftsConfig || 'simple';
+  if (_rawFtsConfig !== 'simple') {
+    console.warn(
+      `[aquifer] ftsConfig '${_rawFtsConfig}' is not currently supported. ` +
+      `The search_tsv index is built with 'simple'; only 'simple' is valid at query time. ` +
+      `Overriding to 'simple'.`
+    );
+  }
+  const ftsConfig = 'simple';
+
   // Rank weights
   const rankWeights = {
     rrf: 0.65,
@@ -90,6 +122,16 @@ function createAquifer(config) {
     ...(config.rank || {}),
   };
 
+  // Reranker config (optional)
+  const rerankConfig = config.rerank || null;
+  let reranker = null;
+  if (rerankConfig) {
+    const { createReranker } = require('../pipeline/rerank');
+    reranker = createReranker(rerankConfig);
+  }
+  const defaultRerankTopK = rerankConfig ? Math.max(1, rerankConfig.topK || 20) : 0;
+  const rerankMaxChars = rerankConfig ? Math.max(200, rerankConfig.maxChars || 1600) : 0;
+
   // Source registry (in-memory)
   const sources = new Map();
 
@@ -106,7 +148,7 @@ function createAquifer(config) {
 
   // --- Helper: embed search on summaries ---
   async function embeddingSearchSummaries(queryVec, opts) {
-    const { agentId, source, dateFrom, dateTo, limit = 20 } = opts;
+    const { agentIds, source, dateFrom, dateTo, limit = 20 } = opts;
     const where = [`s.tenant_id = $1`];
     const params = [tenantId];
 
@@ -121,9 +163,9 @@ function createAquifer(config) {
       params.push(dateTo);
       where.push(`($${params.length}::date IS NULL OR s.started_at::date <= $${params.length}::date)`);
     }
-    if (agentId) {
-      params.push(agentId);
-      where.push(`s.agent_id = $${params.length}`);
+    if (agentIds && agentIds.length > 0) {
+      params.push(agentIds);
+      where.push(`s.agent_id = ANY($${params.length})`);
     }
     if (source) {
       params.push(source);
@@ -520,10 +562,20 @@ function createAquifer(config) {
 
     async recall(query, opts = {}) {
       if (!query) return [];
-      requireEmbed('recall');
+
+      const VALID_MODES = ['fts', 'hybrid', 'vector'];
+      const mode = opts.mode !== undefined ? opts.mode : 'hybrid';
+      if (!VALID_MODES.includes(mode)) {
+        throw new Error(`Invalid recall mode: "${mode}". Must be one of: ${VALID_MODES.join(', ')}`);
+      }
+
+      if (mode === 'hybrid' || mode === 'vector') {
+        requireEmbed('recall');
+      }
 
       const {
         agentId,
+        agentIds: rawAgentIds,
         source,
         dateFrom,
         dateTo,
@@ -533,6 +585,12 @@ function createAquifer(config) {
         entityMode = 'any',
       } = opts;
 
+      // Normalize agentId/agentIds into a single resolved value
+      // agentIds takes precedence; agentId is sugar for agentIds: [agentId]
+      const resolvedAgentIds = rawAgentIds && rawAgentIds.length > 0
+        ? rawAgentIds
+        : (agentId ? [agentId] : null);
+
       // Validate before touching DB
       if (explicitEntities && explicitEntities.length > 0 && !entitiesEnabled) {
         throw new Error('Entities are not enabled');
@@ -540,12 +598,17 @@ function createAquifer(config) {
 
       await ensureMigrated();
 
-      const fetchLimit = limit * 4;
+      const rerankEnabled = !!reranker && opts.rerank !== false;
+      const rerankTopK = rerankEnabled ? Math.max(limit, opts.rerankTopK || defaultRerankTopK) : limit;
+      const fetchLimit = rerankTopK * 4;
 
-      // 1. Embed query
-      const queryVecResult = await embedFn([query]);
-      const queryVec = queryVecResult[0];
-      if (!queryVec || !queryVec.length) return []; // m3: guard empty array too
+      // 1. Embed query (only needed for hybrid/vector modes)
+      let queryVec = null;
+      if (mode === 'hybrid' || mode === 'vector') {
+        const queryVecResult = await embedFn([query]);
+        queryVec = queryVecResult[0];
+        if (!queryVec || !queryVec.length) return []; // m3: guard empty array too
+      }
 
       // 2. Entity intersection pre-filter (when entityMode === 'all')
       let candidateSessionIds = null; // null = no filter
@@ -621,17 +684,26 @@ function createAquifer(config) {
         } catch (_) { /* entity search failure non-fatal */ }
       }
 
-      // 3. Run 3 search paths in parallel
+      // 3. Run search paths in parallel (conditioned on mode)
+      const runFts = mode === 'fts' || mode === 'hybrid';
+      const runVector = mode === 'vector' || mode === 'hybrid';
+
       const [ftsRows, embRows, turnResult] = await Promise.all([
-        storage.searchSessions(pool, query, {
-          schema, tenantId, agentId, source, dateFrom, dateTo, limit: fetchLimit,
-        }).catch(() => []),
-        embeddingSearchSummaries(queryVec, {
-          agentId, source, dateFrom, dateTo, limit: fetchLimit,
-        }).catch(() => []),
-        storage.searchTurnEmbeddings(pool, {
-          schema, tenantId, queryVec, dateFrom, dateTo, agentId, source, limit: fetchLimit,
-        }).catch(() => ({ rows: [] })),
+        runFts
+          ? storage.searchSessions(pool, query, {
+              schema, tenantId, agentIds: resolvedAgentIds, source, dateFrom, dateTo, limit: fetchLimit, ftsConfig,
+            }).catch(() => [])
+          : Promise.resolve([]),
+        runVector
+          ? embeddingSearchSummaries(queryVec, {
+              agentIds: resolvedAgentIds, source, dateFrom, dateTo, limit: fetchLimit,
+            }).catch(() => [])
+          : Promise.resolve([]),
+        runVector
+          ? storage.searchTurnEmbeddings(pool, {
+              schema, tenantId, queryVec, dateFrom, dateTo, agentIds: resolvedAgentIds, source, limit: fetchLimit,
+            }).catch(() => ({ rows: [] }))
+          : Promise.resolve({ rows: [] }),
       ]);
 
       const turnRows = turnResult.rows || [];
@@ -691,15 +763,45 @@ function createAquifer(config) {
         [...filteredEmb, ...filterFn(externalRows)],
         filteredTurn,
         {
-          limit,
+          limit: rerankTopK,
           weights: mergedWeights,
           entityScoreBySession,
           openLoopSet,
         },
       );
 
+      // 6b. Rerank (optional)
+      let finalRanked = ranked;
+      if (rerankEnabled && ranked.length > 1) {
+        try {
+          const docs = ranked.map(r => buildRerankDocument(r, rerankMaxChars));
+          const rerankResult = await reranker.rerank(query, docs, { topN: ranked.length });
+          const scoreMap = new Map(rerankResult.map(r => [r.index, r.score]));
+
+          finalRanked = ranked.map((r, i) => ({
+            ...r,
+            _hybridScore: r._score,
+            _rerankScore: scoreMap.has(i) ? scoreMap.get(i) : null,
+          }));
+
+          finalRanked.sort((a, b) => {
+            const aR = a._rerankScore ?? -Infinity;
+            const bR = b._rerankScore ?? -Infinity;
+            if (aR !== bR) return bR - aR;
+            return (b._hybridScore || 0) - (a._hybridScore || 0);
+          });
+          finalRanked = finalRanked.slice(0, limit);
+        } catch (rerankErr) {
+          // Fallback: use original hybrid-rank order, flag in debug
+          if (process.env.AQUIFER_DEBUG) console.error('[aquifer] rerank error:', rerankErr.message);
+          finalRanked = ranked.slice(0, limit).map(r => ({ ...r, _rerankFallback: true }));
+        }
+      } else {
+        finalRanked = ranked.slice(0, limit);
+      }
+
       // 7. Record access
-      const sessionRowIds = ranked
+      const sessionRowIds = finalRanked
         .map(r => r.id || r.session_row_id)
         .filter(Boolean);
 
@@ -710,7 +812,7 @@ function createAquifer(config) {
       }
 
       // 8. Format results
-      return ranked.map(r => ({
+      return finalRanked.map(r => ({
         sessionId: r.session_id,
         agentId: r.agent_id,
         source: r.source,
@@ -720,7 +822,7 @@ function createAquifer(config) {
         summarySnippet: r.summary_snippet || null,
         matchedTurnText: r.matched_turn_text || null,
         matchedTurnIndex: r.matched_turn_index || null,
-        score: r._score,
+        score: r._rerankScore ?? r._score,
         trustScore: r._trustScore ?? 0.5,
         _debug: {
           rrf: r._rrf,
@@ -730,6 +832,9 @@ function createAquifer(config) {
           trustScore: r._trustScore,
           trustMultiplier: r._trustMultiplier,
           openLoopBoost: r._openLoopBoost,
+          hybridScore: r._hybridScore ?? r._score,
+          rerankScore: r._rerankScore ?? null,
+          rerankFallback: r._rerankFallback || false,
         },
       }));
     },
@@ -763,6 +868,27 @@ function createAquifer(config) {
       return storage.getSession(pool, sessionId, agentId, opts, { schema, tenantId });
     },
 
+    async skip(sessionId, opts = {}) {
+      const agentId = opts.agentId || 'agent';
+      const reason = opts.reason || null;
+      // Atomic CAS: only skip if still pending (avoids race with concurrent enrich)
+      const result = await pool.query(
+        `UPDATE ${qi(schema)}.sessions
+        SET processing_status = 'skipped', processing_error = $1
+        WHERE session_id = $2 AND agent_id = $3 AND tenant_id = $4
+          AND processing_status = 'pending'
+        RETURNING id`,
+        [reason, sessionId, agentId, tenantId]
+      );
+      if (result.rows.length === 0) {
+        // Check if session exists at all
+        const existing = await storage.getSession(pool, sessionId, agentId, {}, { schema, tenantId });
+        if (!existing) throw new Error(`Session not found: ${sessionId} (agentId=${agentId})`);
+        return null; // exists but not pending — no-op
+      }
+      return { id: result.rows[0].id, sessionId, agentId, status: 'skipped' };
+    },
+
     async getSessionFull(sessionId) {
       // Try to find the session across agents by querying directly
       const result = await pool.query(
@@ -795,6 +921,93 @@ function createAquifer(config) {
         summary: sumResult.rows[0] || null,
       };
     },
+
+    // --- public config accessor ---
+
+    getConfig() {
+      return { schema, tenantId };
+    },
+
+    // --- admin query helpers ---
+
+    async getStats() {
+      const [sessions, summaries, turns, timeRange] = await Promise.all([
+        pool.query(
+          `SELECT processing_status, COUNT(*)::int as count
+          FROM ${qi(schema)}.sessions WHERE tenant_id = $1
+          GROUP BY processing_status`,
+          [tenantId]
+        ),
+        pool.query(
+          `SELECT COUNT(*)::int as count FROM ${qi(schema)}.session_summaries WHERE tenant_id = $1`,
+          [tenantId]
+        ),
+        pool.query(
+          `SELECT COUNT(*)::int as count FROM ${qi(schema)}.turn_embeddings WHERE tenant_id = $1`,
+          [tenantId]
+        ),
+        pool.query(
+          `SELECT MIN(started_at) as earliest, MAX(started_at) as latest
+          FROM ${qi(schema)}.sessions WHERE tenant_id = $1`,
+          [tenantId]
+        ),
+      ]);
+
+      let entityCount = 0;
+      try {
+        const entResult = await pool.query(
+          `SELECT COUNT(*)::int as count FROM ${qi(schema)}.entities WHERE tenant_id = $1`,
+          [tenantId]
+        );
+        entityCount = entResult.rows[0]?.count || 0;
+      } catch (_) { /* entities table may not exist */ }
+
+      return {
+        sessions: Object.fromEntries(sessions.rows.map(r => [r.processing_status, r.count])),
+        sessionTotal: sessions.rows.reduce((s, r) => s + r.count, 0),
+        summaries: summaries.rows[0]?.count || 0,
+        turnEmbeddings: turns.rows[0]?.count || 0,
+        entities: entityCount,
+        earliest: timeRange.rows[0]?.earliest || null,
+        latest: timeRange.rows[0]?.latest || null,
+      };
+    },
+
+    async getPendingSessions(opts = {}) {
+      const limit = opts.limit !== undefined ? opts.limit : 100;
+      const result = await pool.query(
+        `SELECT session_id, agent_id, processing_status
+        FROM ${qi(schema)}.sessions
+        WHERE tenant_id = $1
+          AND processing_status IN ('pending', 'failed')
+        ORDER BY started_at DESC
+        LIMIT $2`,
+        [tenantId, limit]
+      );
+      return result.rows;
+    },
+
+    async exportSessions(opts = {}) {
+      const { agentId, source, limit = 1000 } = opts;
+      const where = [`s.tenant_id = $1`];
+      const params = [tenantId];
+
+      if (agentId) { params.push(agentId); where.push(`s.agent_id = $${params.length}`); }
+      if (source) { params.push(source); where.push(`s.source = $${params.length}`); }
+      params.push(limit);
+
+      const result = await pool.query(
+        `SELECT s.session_id, s.agent_id, s.source, s.started_at, s.msg_count,
+                s.processing_status, ss.summary_text, ss.structured_summary
+        FROM ${qi(schema)}.sessions s
+        LEFT JOIN ${qi(schema)}.session_summaries ss ON ss.session_row_id = s.id
+        WHERE ${where.join(' AND ')}
+        ORDER BY s.started_at DESC
+        LIMIT $${params.length}`,
+        params
+      );
+      return result.rows;
+    },
   };
 
   return aquifer;

package/core/storage.js

@@ -31,7 +31,7 @@ const TURN_NOISE_RE = [
   /^A new session was started via \/new/,
 ];
 
-const VALID_STATUSES = new Set(['pending', 'processing', 'succeeded', 'partial', 'failed']);
+const VALID_STATUSES = new Set(['pending', 'processing', 'succeeded', 'partial', 'failed', 'skipped']);
 
 // ---------------------------------------------------------------------------
 // upsertSession
@@ -331,12 +331,55 @@ async function searchSessions(pool, query, {
   schema,
   tenantId,
   agentId,
+  agentIds: rawAgentIds,
   source,
   dateFrom,  // m1: add date filtering
   dateTo,
   limit = 20,
+  ftsConfig = 'simple',
 } = {}) {
   const clampedLimit = Math.max(1, Math.min(100, limit));
+  // FTS config is locked to 'simple' — the search_tsv trigger always uses
+  // to_tsvector('simple', ...) so query semantics must match.  Warn callers
+  // that pass a different value rather than silently honouring it.
+  if (ftsConfig !== 'simple') {
+    console.warn(
+      `[aquifer/storage] searchSessions: ftsConfig '${ftsConfig}' ignored. ` +
+      `Only 'simple' is supported (index is built with simple tokenizer). ` +
+      `Using 'simple'.`
+    );
+  }
+  const safeFts = 'simple';
+
+  // Normalize agentId/agentIds
+  const agentIds = rawAgentIds && rawAgentIds.length > 0
+    ? rawAgentIds
+    : (agentId ? [agentId] : null);
+
+  const where = [
+    `ss.search_tsv @@ plainto_tsquery('${safeFts}', $1)`,
+    `s.tenant_id = $2`,
+  ];
+  const params = [query, tenantId];
+
+  if (agentIds) {
+    params.push(agentIds);
+    where.push(`s.agent_id = ANY($${params.length})`);
+  }
+  if (source) {
+    params.push(source);
+    where.push(`s.source = $${params.length}`);
+  }
+  if (dateFrom) {
+    params.push(dateFrom);
+    where.push(`s.started_at::date >= $${params.length}::date`);
+  }
+  if (dateTo) {
+    params.push(dateTo);
+    where.push(`s.started_at::date <= $${params.length}::date`);
+  }
+  params.push(clampedLimit);
+
   const result = await pool.query(
     `SELECT
       s.id,
@@ -351,19 +394,14 @@ async function searchSessions(pool, query, {
       ss.access_count,
       ss.last_accessed_at,
       ss.trust_score,
-      ts_headline('simple', COALESCE(ss.summary_text, ''), plainto_tsquery('simple', $1)) AS summary_snippet,
-      ts_rank(ss.search_tsv, plainto_tsquery('simple', $1)) AS fts_rank
+      ts_headline('${safeFts}', COALESCE(ss.summary_text, ''), plainto_tsquery('${safeFts}', $1)) AS summary_snippet,
+      ts_rank(ss.search_tsv, plainto_tsquery('${safeFts}', $1)) AS fts_rank
     FROM ${qi(schema)}.sessions s
     LEFT JOIN ${qi(schema)}.session_summaries ss ON ss.session_row_id = s.id
-    WHERE ss.search_tsv @@ plainto_tsquery('simple', $1)
-      AND s.tenant_id = $2
-      AND ($3::text IS NULL OR s.agent_id = $3)
-      AND ($4::text IS NULL OR s.source = $4)
-      AND ($5::date IS NULL OR s.started_at::date >= $5::date)
-      AND ($6::date IS NULL OR s.started_at::date <= $6::date)
+    WHERE ${where.join(' AND ')}
     ORDER BY fts_rank DESC, s.last_message_at DESC NULLS LAST
-    LIMIT $7`,
-    [query, tenantId, agentId || null, source || null, dateFrom || null, dateTo || null, clampedLimit]
+    LIMIT $${params.length}`,
+    params
   );
   return result.rows;
 }
@@ -479,23 +517,29 @@ async function searchTurnEmbeddings(pool, {
   dateFrom,
   dateTo,
   agentId,
+  agentIds: rawAgentIds,
   source,
   limit = 15,
 }) {
   const where = ['s.tenant_id = $1'];
   const params = [tenantId];
 
+  // Normalize agentId/agentIds
+  const agentIds = rawAgentIds && rawAgentIds.length > 0
+    ? rawAgentIds
+    : (agentId ? [agentId] : null);
+
   if (dateFrom) {
     params.push(dateFrom);
-    where.push(`($${params.length}::date IS NULL OR s.started_at::date >= $${params.length}::date)`);
+    where.push(`s.started_at::date >= $${params.length}::date`);
   }
   if (dateTo) {
     params.push(dateTo);
-    where.push(`($${params.length}::date IS NULL OR s.started_at::date <= $${params.length}::date)`);
+    where.push(`s.started_at::date <= $${params.length}::date`);
   }
-  if (agentId) {
-    params.push(agentId);
-    where.push(`t.agent_id = $${params.length}`);
+  if (agentIds) {
+    params.push(agentIds);
+    where.push(`t.agent_id = ANY($${params.length})`);
   }
   if (source) {
     params.push(source);

package/index.js

@@ -2,5 +2,7 @@
 
 const { createAquifer } = require('./core/aquifer');
 const { createEmbedder } = require('./pipeline/embed');
+const { createReranker } = require('./pipeline/rerank');
+const { normalizeSession, detectClient } = require('./pipeline/normalize');
 
-module.exports = { createAquifer, createEmbedder };
+module.exports = { createAquifer, createEmbedder, createReranker, normalizeSession, detectClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shadowforge0/aquifer-memory",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "PG-native long-term memory for AI agents. Turn-level embedding, hybrid RRF ranking, optional knowledge graph. Includes CLI, MCP server, and OpenClaw plugin.",
   "main": "index.js",
   "files": [
@@ -35,8 +35,8 @@
     "pg": "^8.13.0"
   },
   "optionalDependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0",
-    "zod": "^3.24.0"
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^3.25.76"
   },
   "engines": {
     "node": ">=18.0.0"

package/pipeline/_http.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const http = require('http');
+const https = require('https');
+
+// ---------------------------------------------------------------------------
+// HTTP helpers (shared by embed.js and rerank.js)
+// ---------------------------------------------------------------------------
+
+function httpRequest(url, options, body) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const transport = parsedUrl.protocol === 'https:' ? https : http;
+
+    // M8 fix: settled flag to prevent double-settle on timeout race
+    let settled = false;
+    const finish = (fn, val) => { if (!settled) { settled = true; fn(val); } };
+
+    const req = transport.request(parsedUrl, options, (res) => {
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => {
+        if (timer) clearTimeout(timer);
+        const raw = Buffer.concat(chunks).toString();
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          finish(reject, new Error(`HTTP ${res.statusCode}: ${raw.slice(0, 500)}`));
+          return;
+        }
+        try {
+          finish(resolve, JSON.parse(raw));
+        } catch (e) {
+          finish(reject, new Error(`Invalid JSON response: ${raw.slice(0, 200)}`));
+        }
+      });
+    });
+
+    const timer = options.timeout
+      ? setTimeout(() => { req.destroy(); finish(reject, new Error('Request timeout')); }, options.timeout)
+      : null;
+
+    req.on('error', (err) => { if (timer) clearTimeout(timer); finish(reject, err); });
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Retry wrapper
+// ---------------------------------------------------------------------------
+
+async function withRetry(fn, { maxRetries = 3, initialBackoffMs = 2000 } = {}) {
+  let lastErr;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (attempt < maxRetries - 1) {
+        const delay = initialBackoffMs * Math.pow(2, attempt);
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+  throw lastErr;
+}
+
+module.exports = { httpRequest, withRetry };

package/pipeline/embed.js

@@ -1,68 +1,6 @@
 'use strict';
 
-const http = require('http');
-const https = require('https');
-
-// ---------------------------------------------------------------------------
-// HTTP helpers
-// ---------------------------------------------------------------------------
-
-function httpRequest(url, options, body) {
-  return new Promise((resolve, reject) => {
-    const parsedUrl = new URL(url);
-    const transport = parsedUrl.protocol === 'https:' ? https : http;
-
-    // M8 fix: settled flag to prevent double-settle on timeout race
-    let settled = false;
-    const finish = (fn, val) => { if (!settled) { settled = true; fn(val); } };
-
-    const req = transport.request(parsedUrl, options, (res) => {
-      const chunks = [];
-      res.on('data', (chunk) => chunks.push(chunk));
-      res.on('end', () => {
-        if (timer) clearTimeout(timer);
-        const raw = Buffer.concat(chunks).toString();
-        if (res.statusCode < 200 || res.statusCode >= 300) {
-          finish(reject, new Error(`HTTP ${res.statusCode}: ${raw.slice(0, 500)}`));
-          return;
-        }
-        try {
-          finish(resolve, JSON.parse(raw));
-        } catch (e) {
-          finish(reject, new Error(`Invalid JSON response: ${raw.slice(0, 200)}`));
-        }
-      });
-    });
-
-    const timer = options.timeout
-      ? setTimeout(() => { req.destroy(); finish(reject, new Error('Request timeout')); }, options.timeout)
-      : null;
-
-    req.on('error', (err) => { if (timer) clearTimeout(timer); finish(reject, err); });
-    if (body) req.write(JSON.stringify(body));
-    req.end();
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Retry wrapper
-// ---------------------------------------------------------------------------
-
-async function withRetry(fn, { maxRetries = 3, initialBackoffMs = 2000 } = {}) {
-  let lastErr;
-  for (let attempt = 0; attempt < maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastErr = err;
-      if (attempt < maxRetries - 1) {
-        const delay = initialBackoffMs * Math.pow(2, attempt);
-        await new Promise(r => setTimeout(r, delay));
-      }
-    }
-  }
-  throw lastErr;
-}
+const { httpRequest, withRetry } = require('./_http');
 
 // ---------------------------------------------------------------------------
 // Ollama adapter