teleton 0.8.1 → 0.8.3

package/dist/chunk-ALKAAG4O.js

@@ -0,0 +1,487 @@
+import {
+  getErrorMessage
+} from "./chunk-3UFPFWYP.js";
+import {
+  ADAPTIVE_CHUNK_RATIO_BASE,
+  ADAPTIVE_CHUNK_RATIO_MIN,
+  ADAPTIVE_CHUNK_RATIO_TRIGGER,
+  CHARS_PER_TOKEN_ESTIMATE,
+  DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_MAX_SUMMARY_TOKENS,
+  DEFAULT_SUMMARY_FALLBACK_TOKENS,
+  OVERSIZED_MESSAGE_RATIO,
+  SESSION_SLUG_MAX_TOKENS,
+  SESSION_SLUG_RECENT_MESSAGES,
+  TOKEN_ESTIMATE_SAFETY_MARGIN
+} from "./chunk-C4NKJT2Z.js";
+import {
+  getUtilityModel
+} from "./chunk-LVTKJQ7O.js";
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.js";
+
+// src/session/memory-hook.ts
+import { writeFile, mkdir, readdir, readFile, unlink } from "fs/promises";
+import { join } from "path";
+import { complete as complete2 } from "@mariozechner/pi-ai";
+
+// src/memory/ai-summarization.ts
+import {
+  complete
+} from "@mariozechner/pi-ai";
+var log = createLogger("Memory");
+function estimateMessageTokens(content) {
+  return Math.ceil(content.length / CHARS_PER_TOKEN_ESTIMATE * TOKEN_ESTIMATE_SAFETY_MARGIN);
+}
+function splitMessagesByTokens(messages, maxChunkTokens) {
+  if (messages.length === 0) {
+    return [];
+  }
+  const chunks = [];
+  let currentChunk = [];
+  let currentTokens = 0;
+  for (const message of messages) {
+    const content = extractMessageContent(message);
+    const messageTokens = estimateMessageTokens(content);
+    if (currentChunk.length > 0 && currentTokens + messageTokens > maxChunkTokens) {
+      chunks.push(currentChunk);
+      currentChunk = [];
+      currentTokens = 0;
+    }
+    currentChunk.push(message);
+    currentTokens += messageTokens;
+    if (messageTokens > maxChunkTokens && currentChunk.length === 1) {
+      chunks.push(currentChunk);
+      currentChunk = [];
+      currentTokens = 0;
+    }
+  }
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk);
+  }
+  return chunks;
+}
+function extractMessageContent(message) {
+  if (message.role === "user") {
+    return typeof message.content === "string" ? message.content : "[complex content]";
+  } else if (message.role === "assistant") {
+    return message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+  }
+  return "";
+}
+function formatMessagesForSummary(messages) {
+  const formatted = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      const content = typeof msg.content === "string" ? msg.content : "[complex]";
+      const bodyMatch = content.match(/\] (.+)/s);
+      const body = bodyMatch ? bodyMatch[1] : content;
+      formatted.push(`User: ${body}`);
+    } else if (msg.role === "assistant") {
+      const textBlocks = msg.content.filter((b) => b.type === "text");
+      if (textBlocks.length > 0) {
+        const text = textBlocks.map((b) => b.text).join("\n");
+        formatted.push(`Assistant: ${text}`);
+      }
+      const toolCalls = msg.content.filter((b) => b.type === "toolCall");
+      if (toolCalls.length > 0) {
+        const toolNames = toolCalls.map((b) => b.name).join(", ");
+        formatted.push(`[Used tools: ${toolNames}]`);
+      }
+    } else if (msg.role === "toolResult") {
+      formatted.push(`[Tool result: ${msg.toolName}]`);
+    }
+  }
+  return formatted.join("\n\n");
+}
+function isOversizedForSummary(message, contextWindow) {
+  const content = extractMessageContent(message);
+  const tokens = estimateMessageTokens(content);
+  return tokens > contextWindow * OVERSIZED_MESSAGE_RATIO;
+}
+function computeAdaptiveChunkRatio(messages, contextWindow) {
+  const BASE_CHUNK_RATIO = ADAPTIVE_CHUNK_RATIO_BASE;
+  const MIN_CHUNK_RATIO = ADAPTIVE_CHUNK_RATIO_MIN;
+  if (messages.length === 0) {
+    return BASE_CHUNK_RATIO;
+  }
+  let totalTokens = 0;
+  for (const msg of messages) {
+    const content = extractMessageContent(msg);
+    totalTokens += estimateMessageTokens(content);
+  }
+  const avgTokens = totalTokens / messages.length;
+  const avgRatio = avgTokens / contextWindow;
+  if (avgRatio > ADAPTIVE_CHUNK_RATIO_TRIGGER) {
+    const reduction = Math.min(avgRatio * 2, BASE_CHUNK_RATIO - MIN_CHUNK_RATIO);
+    return Math.max(MIN_CHUNK_RATIO, BASE_CHUNK_RATIO - reduction);
+  }
+  return BASE_CHUNK_RATIO;
+}
+async function summarizeViaClaude(params) {
+  const provider = params.provider || "anthropic";
+  const model = getUtilityModel(provider, params.utilityModel);
+  const maxTokens = params.maxSummaryTokens ?? DEFAULT_SUMMARY_FALLBACK_TOKENS;
+  const formatted = formatMessagesForSummary(params.messages);
+  if (!formatted.trim()) {
+    return "No conversation content to summarize.";
+  }
+  const defaultInstructions = `Summarize this conversation concisely. Focus on:
+- Key decisions made
+- Action items and TODOs
+- Open questions
+- Important context and constraints
+- Technical details that matter
+
+Be specific but concise. Preserve critical information.`;
+  const instructions = params.customInstructions ? `${defaultInstructions}
+
+Additional focus:
+${params.customInstructions}` : defaultInstructions;
+  try {
+    const context = {
+      messages: [
+        {
+          role: "user",
+          content: `${instructions}
+
+Conversation:
+${formatted}`,
+          timestamp: Date.now()
+        }
+      ]
+    };
+    const response = await complete(model, context, {
+      apiKey: params.apiKey,
+      maxTokens
+    });
+    const textContent = response.content.find((block) => block.type === "text");
+    const summary = textContent?.type === "text" ? textContent.text : "";
+    return summary.trim() || "Unable to generate summary.";
+  } catch (error) {
+    log.error({ err: error }, "Summarization error");
+    throw new Error(`Summarization failed: ${getErrorMessage(error)}`);
+  }
+}
+async function summarizeInChunks(params) {
+  if (params.messages.length === 0) {
+    return {
+      summary: "No messages to summarize.",
+      tokensUsed: 0,
+      chunksProcessed: 0
+    };
+  }
+  const chunks = splitMessagesByTokens(params.messages, params.maxChunkTokens);
+  log.info(`Splitting into ${chunks.length} chunks for summarization`);
+  if (chunks.length === 1) {
+    const summary = await summarizeViaClaude({
+      messages: chunks[0],
+      apiKey: params.apiKey,
+      maxSummaryTokens: params.maxSummaryTokens,
+      customInstructions: params.customInstructions,
+      provider: params.provider,
+      utilityModel: params.utilityModel
+    });
+    return {
+      summary,
+      tokensUsed: estimateMessageTokens(summary),
+      chunksProcessed: 1
+    };
+  }
+  const partialSummaries = [];
+  for (let i = 0; i < chunks.length; i++) {
+    log.info(`Summarizing chunk ${i + 1}/${chunks.length} (${chunks[i].length} messages)`);
+    const partial = await summarizeViaClaude({
+      messages: chunks[i],
+      apiKey: params.apiKey,
+      maxSummaryTokens: Math.floor(
+        (params.maxSummaryTokens ?? DEFAULT_SUMMARY_FALLBACK_TOKENS) / 2
+      ),
+      customInstructions: params.customInstructions,
+      provider: params.provider,
+      utilityModel: params.utilityModel
+    });
+    partialSummaries.push(partial);
+  }
+  log.info(`Merging ${partialSummaries.length} partial summaries`);
+  const provider = params.provider || "anthropic";
+  const model = getUtilityModel(provider, params.utilityModel);
+  const mergeContext = {
+    messages: [
+      {
+        role: "user",
+        content: `Merge these partial conversation summaries into one cohesive summary.
+Preserve all key decisions, action items, open questions, and important context.
+Do not add new information - only synthesize what's provided.
+
+Partial summaries:
+
+${partialSummaries.map((s, i) => `Part ${i + 1}:
+${s}`).join("\n\n---\n\n")}`,
+        timestamp: Date.now()
+      }
+    ]
+  };
+  const mergeResponse = await complete(model, mergeContext, {
+    apiKey: params.apiKey,
+    maxTokens: params.maxSummaryTokens ?? DEFAULT_SUMMARY_FALLBACK_TOKENS
+  });
+  const textContent = mergeResponse.content.find((block) => block.type === "text");
+  const merged = textContent?.type === "text" ? textContent.text : "";
+  return {
+    summary: merged.trim() || "Unable to merge summaries.",
+    tokensUsed: estimateMessageTokens(merged),
+    chunksProcessed: chunks.length
+  };
+}
+async function summarizeWithFallback(params) {
+  if (params.messages.length === 0) {
+    return {
+      summary: "No messages to summarize.",
+      tokensUsed: 0,
+      chunksProcessed: 0
+    };
+  }
+  const chunkRatio = computeAdaptiveChunkRatio(params.messages, params.contextWindow);
+  const maxChunkTokens = Math.floor(params.contextWindow * chunkRatio);
+  log.info(
+    `AI Summarization: ${params.messages.length} messages, chunk ratio: ${(chunkRatio * 100).toFixed(0)}%`
+  );
+  try {
+    return await summarizeInChunks({
+      messages: params.messages,
+      apiKey: params.apiKey,
+      maxChunkTokens,
+      maxSummaryTokens: params.maxSummaryTokens,
+      customInstructions: params.customInstructions,
+      provider: params.provider,
+      utilityModel: params.utilityModel
+    });
+  } catch (fullError) {
+    log.warn(
+      `Full summarization failed: ${fullError instanceof Error ? fullError.message : String(fullError)}`
+    );
+  }
+  const smallMessages = [];
+  const oversizedNotes = [];
+  for (const msg of params.messages) {
+    if (isOversizedForSummary(msg, params.contextWindow)) {
+      const content = extractMessageContent(msg);
+      const tokens = estimateMessageTokens(content);
+      oversizedNotes.push(
+        `[Large ${msg.role} message (~${Math.round(tokens / 1e3)}K tokens) omitted from summary]`
+      );
+    } else {
+      smallMessages.push(msg);
+    }
+  }
+  log.info(
+    `Fallback: Processing ${smallMessages.length} messages, skipping ${oversizedNotes.length} oversized`
+  );
+  if (smallMessages.length > 0) {
+    try {
+      const result = await summarizeInChunks({
+        messages: smallMessages,
+        apiKey: params.apiKey,
+        maxChunkTokens,
+        maxSummaryTokens: params.maxSummaryTokens,
+        customInstructions: params.customInstructions,
+        provider: params.provider,
+        utilityModel: params.utilityModel
+      });
+      const notes = oversizedNotes.length > 0 ? `
+
+${oversizedNotes.join("\n")}` : "";
+      return {
+        summary: result.summary + notes,
+        tokensUsed: result.tokensUsed,
+        chunksProcessed: result.chunksProcessed
+      };
+    } catch (partialError) {
+      log.warn(
+        `Partial summarization also failed: ${partialError instanceof Error ? partialError.message : String(partialError)}`
+      );
+    }
+  }
+  const note = `Context contained ${params.messages.length} messages (${oversizedNotes.length} were oversized). AI summarization unavailable due to size constraints. Recent conversation history was preserved.`;
+  return {
+    summary: note,
+    tokensUsed: estimateMessageTokens(note),
+    chunksProcessed: 0
+  };
+}
+
+// src/session/memory-hook.ts
+var log2 = createLogger("Session");
+async function generateSlugViaClaude(params) {
+  const provider = params.provider || "anthropic";
+  const model = getUtilityModel(provider, params.utilityModel);
+  const formatted = formatMessagesForSummary(params.messages.slice(-SESSION_SLUG_RECENT_MESSAGES));
+  if (!formatted.trim()) {
+    return "empty-session";
+  }
+  try {
+    const context = {
+      messages: [
+        {
+          role: "user",
+          content: `Generate a short, descriptive slug (2-4 words, kebab-case) for this conversation.
+Examples: "gift-transfer-fix", "context-overflow-debug", "telegram-integration"
+
+Conversation:
+${formatted}
+
+Slug:`,
+          timestamp: Date.now()
+        }
+      ]
+    };
+    const response = await complete2(model, context, {
+      apiKey: params.apiKey,
+      maxTokens: SESSION_SLUG_MAX_TOKENS
+    });
+    const textContent = response.content.find((block) => block.type === "text");
+    const slug = textContent?.type === "text" ? textContent.text.trim() : "";
+    return slug.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 50) || "session";
+  } catch (error) {
+    log2.warn({ err: error }, "Slug generation failed, using fallback");
+    const now = /* @__PURE__ */ new Date();
+    return `session-${now.getHours().toString().padStart(2, "0")}${now.getMinutes().toString().padStart(2, "0")}`;
+  }
+}
+async function saveSessionMemory(params) {
+  try {
+    const { TELETON_ROOT } = await import("./paths-XA2RJH4S.js");
+    const memoryDir = join(TELETON_ROOT, "memory");
+    await mkdir(memoryDir, { recursive: true });
+    const now = /* @__PURE__ */ new Date();
+    const dateStr = now.toISOString().split("T")[0];
+    log2.info("Generating semantic slug for session memory...");
+    const slug = await generateSlugViaClaude({
+      messages: params.context.messages,
+      apiKey: params.apiKey,
+      provider: params.provider,
+      utilityModel: params.utilityModel
+    });
+    const filename = `${dateStr}-${slug}.md`;
+    const filepath = join(memoryDir, filename);
+    const timeStr = now.toISOString().split("T")[1].split(".")[0];
+    log2.info("Generating session summary...");
+    let summary;
+    try {
+      summary = await summarizeViaClaude({
+        messages: params.context.messages,
+        apiKey: params.apiKey,
+        maxSummaryTokens: DEFAULT_MAX_SUMMARY_TOKENS,
+        customInstructions: "Summarize this session comprehensively. Include key topics, decisions made, problems solved, and important context.",
+        provider: params.provider,
+        utilityModel: params.utilityModel
+      });
+    } catch (error) {
+      log2.warn({ err: error }, "Session summary generation failed");
+      summary = `Session contained ${params.context.messages.length} messages. Summary generation failed.`;
+    }
+    const content = `# Session Memory: ${dateStr} ${timeStr} UTC
+
+## Metadata
+
+- **Old Session ID**: \`${params.oldSessionId}\`
+- **New Session ID**: \`${params.newSessionId}\`
+- **Chat ID**: \`${params.chatId}\`
+- **Timestamp**: ${now.toISOString()}
+- **Message Count**: ${params.context.messages.length}
+
+## Session Summary
+
+${summary}
+
+## Context
+
+This session was compacted and migrated to a new session ID. The summary above preserves key information for continuity.
+
+---
+
+*Generated automatically by Teleton-AI session memory hook*
+`;
+    await writeFile(filepath, content, "utf-8");
+    const relPath = filepath.replace(TELETON_ROOT, "~/.teleton");
+    log2.info(`Session memory saved: ${relPath}`);
+  } catch (error) {
+    log2.error({ err: error }, "Failed to save session memory");
+  }
+}
+var CONSOLIDATION_THRESHOLD = 20;
+var CONSOLIDATION_BATCH = 10;
+async function consolidateOldMemoryFiles(params) {
+  try {
+    const { TELETON_ROOT } = await import("./paths-XA2RJH4S.js");
+    const memoryDir = join(TELETON_ROOT, "memory");
+    let entries;
+    try {
+      entries = await readdir(memoryDir);
+    } catch {
+      return { consolidated: 0 };
+    }
+    const sessionFiles = entries.filter((f) => /^\d{4}-\d{2}-\d{2}-.+\.md$/.test(f) && !f.startsWith("consolidated-")).sort();
+    if (sessionFiles.length < CONSOLIDATION_THRESHOLD) {
+      return { consolidated: 0 };
+    }
+    const batch = sessionFiles.slice(0, CONSOLIDATION_BATCH);
+    log2.info(`Consolidating ${batch.length} old session memory files...`);
+    const contents = [];
+    for (const file of batch) {
+      const text = await readFile(join(memoryDir, file), "utf-8");
+      contents.push(`--- ${file} ---
+${text}`);
+    }
+    const combined = contents.join("\n\n");
+    let summary;
+    try {
+      const result = await summarizeWithFallback({
+        messages: [{ role: "user", content: combined, timestamp: Date.now() }],
+        apiKey: params.apiKey,
+        contextWindow: DEFAULT_CONTEXT_WINDOW,
+        maxSummaryTokens: DEFAULT_MAX_SUMMARY_TOKENS,
+        customInstructions: "Consolidate these session memories into a single comprehensive summary. Preserve key facts, decisions, patterns, and important context. Remove redundancy. Organize by topic.",
+        provider: params.provider,
+        utilityModel: params.utilityModel
+      });
+      summary = result.summary;
+    } catch (error) {
+      log2.warn({ err: error }, "Consolidation summary failed, skipping");
+      return { consolidated: 0 };
+    }
+    const dateOf = (f) => f.slice(0, 10);
+    const dateRange = `${dateOf(batch[0])}_to_${dateOf(batch[batch.length - 1])}`;
+    const outFile = `consolidated-${dateRange}.md`;
+    const outContent = `# Consolidated Session Memories
+
+## Period
+${batch[0]} \u2192 ${batch[batch.length - 1]}
+
+## Summary
+
+${summary}
+
+---
+
+*Consolidated from ${batch.length} session files by Teleton memory consolidation*
+`;
+    await writeFile(join(memoryDir, outFile), outContent, "utf-8");
+    for (const file of batch) {
+      await unlink(join(memoryDir, file));
+    }
+    log2.info(`Consolidated ${batch.length} files \u2192 ${outFile}`);
+    return { consolidated: batch.length };
+  } catch (error) {
+    log2.error({ err: error }, "Memory consolidation failed");
+    return { consolidated: 0 };
+  }
+}
+
+export {
+  summarizeWithFallback,
+  saveSessionMemory,
+  consolidateOldMemoryFiles
+};

package/dist/{chunk-UP55PXFH.js → chunk-C4NKJT2Z.js}

@@ -23,6 +23,9 @@ var CONTEXT_MAX_RECENT_MESSAGES = 10;
 var CONTEXT_MAX_RELEVANT_CHUNKS = 5;
 var FEED_MESSAGE_MAX_CHARS = 2e3;
 var HYBRID_SEARCH_MIN_SCORE = 0.15;
+var RECENCY_DECAY_FACTOR = 0.05;
+var RECENCY_WEIGHT = 0.15;
+var EMBEDDING_QUERY_MAX_CHARS = 1e3;
 var CONTEXT_OVERFLOW_SUMMARY_MESSAGES = 15;
 var RATE_LIMIT_MAX_RETRIES = 3;
 var SERVER_ERROR_MAX_RETRIES = 3;
@@ -56,6 +59,7 @@ var RESULT_TRUNCATION_KEEP_CHARS = 500;
 var EMBEDDING_CACHE_EVICTION_RATIO = 0.1;
 var WEB_FETCH_MAX_TEXT_LENGTH = 2e4;
 var WEB_SEARCH_MAX_RESULTS = 10;
+var TOOL_CONCURRENCY_LIMIT = 2;
 var TOOL_RAG_MIN_SCORE = 0.1;
 var TOOL_RAG_VECTOR_WEIGHT = 0.6;
 var TOOL_RAG_KEYWORD_WEIGHT = 0.4;
@@ -85,6 +89,9 @@ export {
   CONTEXT_MAX_RELEVANT_CHUNKS,
   FEED_MESSAGE_MAX_CHARS,
   HYBRID_SEARCH_MIN_SCORE,
+  RECENCY_DECAY_FACTOR,
+  RECENCY_WEIGHT,
+  EMBEDDING_QUERY_MAX_CHARS,
   CONTEXT_OVERFLOW_SUMMARY_MESSAGES,
   RATE_LIMIT_MAX_RETRIES,
   SERVER_ERROR_MAX_RETRIES,
@@ -118,6 +125,7 @@ export {
   EMBEDDING_CACHE_EVICTION_RATIO,
   WEB_FETCH_MAX_TEXT_LENGTH,
   WEB_SEARCH_MAX_RESULTS,
+  TOOL_CONCURRENCY_LIMIT,
   TOOL_RAG_MIN_SCORE,
   TOOL_RAG_VECTOR_WEIGHT,
   TOOL_RAG_KEYWORD_WEIGHT

package/dist/chunk-CUE4UZXR.js

@@ -0,0 +1,129 @@
+import {
+  TELETON_ROOT
+} from "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.js";
+
+// src/memory/embeddings/local.ts
+import { pipeline, env } from "@huggingface/transformers";
+import { join, dirname } from "path";
+import { mkdirSync, writeFileSync, renameSync, statSync, unlinkSync } from "fs";
+var log = createLogger("Memory");
+var modelCacheDir = join(TELETON_ROOT, "models");
+try {
+  mkdirSync(modelCacheDir, { recursive: true });
+} catch {
+}
+env.cacheDir = modelCacheDir;
+var MIN_FILE_SIZES = { "onnx/model.onnx": 1e6 };
+function isCacheFileValid(filePath, fileName) {
+  try {
+    return statSync(filePath).size >= (MIN_FILE_SIZES[fileName] ?? 1);
+  } catch {
+    return false;
+  }
+}
+async function ensureModelCached(model) {
+  const files = ["config.json", "tokenizer_config.json", "tokenizer.json", "onnx/model.onnx"];
+  const baseUrl = `https://huggingface.co/${model}/resolve/main`;
+  for (const file of files) {
+    const localPath = join(modelCacheDir, model, file);
+    if (isCacheFileValid(localPath, file)) continue;
+    try {
+      unlinkSync(localPath);
+    } catch {
+    }
+    log.info(`Downloading ${model}/${file}...`);
+    mkdirSync(dirname(localPath), { recursive: true });
+    const res = await fetch(`${baseUrl}/${file}`, { redirect: "follow" });
+    if (!res.ok) {
+      throw new Error(`Failed to download ${model}/${file}: ${res.status} ${res.statusText}`);
+    }
+    const buffer = Buffer.from(await res.arrayBuffer());
+    const tmpPath = localPath + ".tmp";
+    writeFileSync(tmpPath, buffer);
+    renameSync(tmpPath, localPath);
+  }
+}
+var extractorPromise = null;
+function getExtractor(model) {
+  if (!extractorPromise) {
+    log.info(`Loading local embedding model: ${model} (cache: ${modelCacheDir})`);
+    extractorPromise = pipeline("feature-extraction", model, {
+      dtype: "fp32",
+      // Explicit cache_dir to avoid any env race condition
+      cache_dir: modelCacheDir,
+      // Prevent pthread_setaffinity_np EINVAL on VPS/containers with restricted CPU sets.
+      // ONNX Runtime skips thread affinity when thread counts are explicit.
+      session_options: { intraOpNumThreads: 1, interOpNumThreads: 1 }
+    }).then((ext) => {
+      log.info(`Local embedding model ready`);
+      return ext;
+    }).catch((err) => {
+      log.error(`Failed to load embedding model: ${err.message}`);
+      extractorPromise = null;
+      throw err;
+    });
+  }
+  return extractorPromise;
+}
+var LocalEmbeddingProvider = class {
+  id = "local";
+  model;
+  dimensions;
+  _disabled = false;
+  constructor(config) {
+    this.model = config.model || "Xenova/all-MiniLM-L6-v2";
+    this.dimensions = 384;
+  }
+  /**
+   * Pre-download and load the model at startup.
+   * If loading fails, retries once then marks provider as disabled (FTS5-only).
+   * Call this once during app init — avoids retry spam on every message.
+   */
+  async warmup() {
+    for (let attempt = 1; attempt <= 2; attempt++) {
+      try {
+        await ensureModelCached(this.model);
+        await getExtractor(this.model);
+        return true;
+      } catch {
+        if (attempt === 1) {
+          log.warn(`Embedding model load failed (attempt 1), retrying...`);
+          await new Promise((r) => setTimeout(r, 1e3));
+        } else {
+          log.warn(
+            `Local embedding model unavailable \u2014 falling back to FTS5-only search (no vector embeddings)`
+          );
+          this._disabled = true;
+          return false;
+        }
+      }
+    }
+    return false;
+  }
+  async embedQuery(text) {
+    if (this._disabled) return [];
+    const extractor = await getExtractor(this.model);
+    const output = await extractor(text, { pooling: "mean", normalize: true });
+    return Array.from(output.data);
+  }
+  async embedBatch(texts) {
+    if (this._disabled) return [];
+    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 results;
+  }
+};
+
+export {
+  LocalEmbeddingProvider
+};