teleton 0.8.2 → 0.8.4

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
+};

package/dist/{chunk-XBSCYMKM.js → chunk-G7PCW63M.js}

@@ -2,25 +2,20 @@ import {
   getModelsForProvider
 } from "./chunk-WFTC3JJW.js";
 import {
-  CONFIGURABLE_KEYS,
   TonProxyManager,
   WorkspaceSecurityError,
   adaptPlugin,
   clearPromptCache,
-  deleteNestedValue,
   deletePluginSecret,
   ensurePluginDeps,
   getBlocklistConfig,
-  getNestedValue,
   getPluginPriorities,
   getTokenUsage,
   getTonProxyManager,
   getTriggersConfig,
   listPluginSecretKeys,
-  readRawConfig,
   resetPluginPriority,
   setBlocklistConfig,
-  setNestedValue,
   setPluginPriority,
   setTonProxyManager,
   setTriggersConfig,
@@ -28,24 +23,29 @@ import {
   validatePath,
   validateReadPath,
   validateWritePath,
-  writePluginSecret,
-  writeRawConfig
-} from "./chunk-GGXJLMOH.js";
+  writePluginSecret
+} from "./chunk-LZQOX6YY.js";
 import {
+  CONFIGURABLE_KEYS,
+  deleteNestedValue,
+  getNestedValue,
   invalidateEndpointCache,
   invalidateTonClientCache,
-  setToncenterApiKey
-} from "./chunk-7YKSXOQQ.js";
+  readRawConfig,
+  setNestedValue,
+  setToncenterApiKey,
+  writeRawConfig
+} from "./chunk-JROBTXWY.js";
 import {
   getErrorMessage
 } from "./chunk-3UFPFWYP.js";
-import {
-  getProviderMetadata,
-  validateApiKeyFormat
-} from "./chunk-YOSUPUAJ.js";
 import {
   setTonapiKey
 } from "./chunk-VFA7QMCZ.js";
+import {
+  getProviderMetadata,
+  validateApiKeyFormat
+} from "./chunk-6OOHHJ4N.js";
 import {
   WORKSPACE_PATHS,
   WORKSPACE_ROOT

package/dist/{chunk-VYKW7FMV.js → chunk-GHMXWAXI.js}

@@ -3,7 +3,7 @@ import {
   createEmbeddingProvider,
   hashText,
   serializeEmbedding
-} from "./chunk-HEDJCLA6.js";
+} from "./chunk-35MX4ZUI.js";
 import {
   FEED_MESSAGE_MAX_CHARS,
   HYBRID_SEARCH_MIN_SCORE,