teleton 0.5.2 → 0.7.0

package/dist/chunk-FNV5FF35.js

@@ -0,0 +1,331 @@
+import {
+  VOYAGE_API_URL
+} from "./chunk-XBKSS6DM.js";
+import {
+  EMBEDDING_CACHE_EVICTION_INTERVAL,
+  EMBEDDING_CACHE_EVICTION_RATIO,
+  EMBEDDING_CACHE_MAX_ENTRIES,
+  EMBEDDING_CACHE_TTL_DAYS,
+  VOYAGE_BATCH_SIZE
+} from "./chunk-RO62LO6Z.js";
+import {
+  fetchWithTimeout
+} from "./chunk-VAUJSSD3.js";
+import {
+  TELETON_ROOT
+} from "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-RCMD3U65.js";
+
+// src/memory/embeddings/provider.ts
+var NoopEmbeddingProvider = class {
+  id = "noop";
+  model = "none";
+  dimensions = 0;
+  async embedQuery(_text) {
+    return [];
+  }
+  async embedBatch(_texts) {
+    return [];
+  }
+};
+
+// src/memory/embeddings/anthropic.ts
+var AnthropicEmbeddingProvider = class {
+  id = "anthropic";
+  model;
+  dimensions;
+  apiKey;
+  baseUrl = VOYAGE_API_URL;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.model = config.model ?? "voyage-3-lite";
+    const dims = {
+      "voyage-3": 1024,
+      "voyage-3-lite": 512,
+      "voyage-code-3": 1024,
+      "voyage-finance-2": 1024,
+      "voyage-multilingual-2": 1024,
+      "voyage-law-2": 1024
+    };
+    this.dimensions = dims[this.model] ?? 512;
+  }
+  async embedQuery(text) {
+    const result = await this.embed([text]);
+    return result[0] ?? [];
+  }
+  async embedBatch(texts) {
+    if (texts.length === 0) return [];
+    const batchSize = VOYAGE_BATCH_SIZE;
+    const results = [];
+    for (let i = 0; i < texts.length; i += batchSize) {
+      const batch = texts.slice(i, i + batchSize);
+      const embeddings = await this.embed(batch);
+      results.push(...embeddings);
+    }
+    return results;
+  }
+  async embed(texts) {
+    const response = await fetchWithTimeout(`${this.baseUrl}/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        input: texts,
+        model: this.model,
+        input_type: "document"
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Voyage API error: ${response.status} ${error}`);
+    }
+    const data = await response.json();
+    return data.data.map((item) => item.embedding);
+  }
+};
+
+// src/memory/embeddings/local.ts
+import { pipeline, env } from "@huggingface/transformers";
+import { join } from "path";
+var log = createLogger("Memory");
+env.cacheDir = join(TELETON_ROOT, "models");
+var extractorPromise = null;
+function getExtractor(model) {
+  if (!extractorPromise) {
+    log.info(`Loading local embedding model: ${model} (cache: ${env.cacheDir})`);
+    extractorPromise = pipeline("feature-extraction", model, {
+      dtype: "fp32"
+    }).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, marks this provider as disabled (returns empty embeddings).
+   * Call this once during app init — avoids retry spam on every message.
+   * @returns true if model loaded successfully, false if fallback to noop
+   */
+  async warmup() {
+    try {
+      await getExtractor(this.model);
+      return true;
+    } catch (err) {
+      log.warn(
+        `Local embedding model unavailable \u2014 falling back to FTS5-only search (no vector embeddings)`
+      );
+      this._disabled = true;
+      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;
+  }
+};
+
+// src/memory/embeddings/index.ts
+import { createHash } from "crypto";
+function createEmbeddingProvider(config) {
+  switch (config.provider) {
+    case "anthropic":
+      if (!config.apiKey) {
+        throw new Error("API key required for Anthropic embedding provider");
+      }
+      return new AnthropicEmbeddingProvider({
+        apiKey: config.apiKey,
+        model: config.model
+      });
+    case "local":
+      return new LocalEmbeddingProvider({
+        model: config.model
+      });
+    case "none":
+      return new NoopEmbeddingProvider();
+    default:
+      throw new Error(`Unknown embedding provider: ${config.provider}`);
+  }
+}
+function hashText(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+function serializeEmbedding(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 [];
+  }
+}
+
+// src/memory/embeddings/cached.ts
+var CachedEmbeddingProvider = class _CachedEmbeddingProvider {
+  constructor(inner, db) {
+    this.inner = inner;
+    this.db = db;
+    this.id = inner.id;
+    this.model = inner.model;
+    this.dimensions = inner.dimensions;
+  }
+  id;
+  model;
+  dimensions;
+  static log = createLogger("Memory");
+  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 warmup() {
+    return this.inner.warmup?.() ?? true;
+  }
+  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 (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);
+      _CachedEmbeddingProvider.log.info(
+        `Embedding cache: ${this.hits} hits, ${this.misses} misses (${rate}% hit rate)`
+      );
+    }
+  }
+  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 * EMBEDDING_CACHE_EVICTION_RATIO);
+        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);
+        _CachedEmbeddingProvider.log.info(
+          `Embedding cache eviction: removed ${toDelete} entries (${count} total)`
+        );
+      }
+    } catch (err) {
+      _CachedEmbeddingProvider.log.warn({ err }, "Embedding cache eviction error");
+    }
+  }
+};
+
+export {
+  NoopEmbeddingProvider,
+  AnthropicEmbeddingProvider,
+  LocalEmbeddingProvider,
+  CachedEmbeddingProvider,
+  createEmbeddingProvider,
+  hashText,
+  serializeEmbedding,
+  deserializeEmbedding
+};

package/dist/chunk-LRCPA7SC.js

@@ -0,0 +1,149 @@
+// src/config/providers.ts
+var PROVIDER_REGISTRY = {
+  anthropic: {
+    id: "anthropic",
+    displayName: "Anthropic (Claude)",
+    envVar: "ANTHROPIC_API_KEY",
+    keyPrefix: "sk-ant-",
+    keyHint: "sk-ant-api03-...",
+    consoleUrl: "https://console.anthropic.com/",
+    defaultModel: "claude-opus-4-5-20251101",
+    utilityModel: "claude-3-5-haiku-20241022",
+    toolLimit: null,
+    piAiProvider: "anthropic"
+  },
+  openai: {
+    id: "openai",
+    displayName: "OpenAI (GPT-4o)",
+    envVar: "OPENAI_API_KEY",
+    keyPrefix: "sk-",
+    keyHint: "sk-proj-...",
+    consoleUrl: "https://platform.openai.com/api-keys",
+    defaultModel: "gpt-4o",
+    utilityModel: "gpt-4o-mini",
+    toolLimit: 128,
+    piAiProvider: "openai"
+  },
+  google: {
+    id: "google",
+    displayName: "Google (Gemini)",
+    envVar: "GOOGLE_API_KEY",
+    keyPrefix: null,
+    keyHint: "AIza...",
+    consoleUrl: "https://aistudio.google.com/apikey",
+    defaultModel: "gemini-2.5-flash",
+    utilityModel: "gemini-2.0-flash-lite",
+    toolLimit: 128,
+    piAiProvider: "google"
+  },
+  xai: {
+    id: "xai",
+    displayName: "xAI (Grok)",
+    envVar: "XAI_API_KEY",
+    keyPrefix: "xai-",
+    keyHint: "xai-...",
+    consoleUrl: "https://console.x.ai/",
+    defaultModel: "grok-3",
+    utilityModel: "grok-3-mini-fast",
+    toolLimit: 128,
+    piAiProvider: "xai"
+  },
+  groq: {
+    id: "groq",
+    displayName: "Groq",
+    envVar: "GROQ_API_KEY",
+    keyPrefix: "gsk_",
+    keyHint: "gsk_...",
+    consoleUrl: "https://console.groq.com/keys",
+    defaultModel: "llama-3.3-70b-versatile",
+    utilityModel: "llama-3.1-8b-instant",
+    toolLimit: 128,
+    piAiProvider: "groq"
+  },
+  openrouter: {
+    id: "openrouter",
+    displayName: "OpenRouter",
+    envVar: "OPENROUTER_API_KEY",
+    keyPrefix: "sk-or-",
+    keyHint: "sk-or-v1-...",
+    consoleUrl: "https://openrouter.ai/keys",
+    defaultModel: "anthropic/claude-opus-4.5",
+    utilityModel: "google/gemini-2.5-flash-lite",
+    toolLimit: 128,
+    piAiProvider: "openrouter"
+  },
+  moonshot: {
+    id: "moonshot",
+    displayName: "Moonshot (Kimi K2.5)",
+    envVar: "MOONSHOT_API_KEY",
+    keyPrefix: "sk-",
+    keyHint: "sk-...",
+    consoleUrl: "https://platform.moonshot.ai/",
+    defaultModel: "kimi-k2.5",
+    utilityModel: "kimi-k2.5",
+    toolLimit: 128,
+    piAiProvider: "moonshot"
+  },
+  mistral: {
+    id: "mistral",
+    displayName: "Mistral AI",
+    envVar: "MISTRAL_API_KEY",
+    keyPrefix: null,
+    keyHint: "...",
+    consoleUrl: "https://console.mistral.ai/api-keys",
+    defaultModel: "devstral-small-2507",
+    utilityModel: "ministral-8b-latest",
+    toolLimit: 128,
+    piAiProvider: "mistral"
+  },
+  cocoon: {
+    id: "cocoon",
+    displayName: "Cocoon Network (Decentralized)",
+    envVar: "",
+    keyPrefix: null,
+    keyHint: "No API key needed \u2014 pays in TON",
+    consoleUrl: "https://cocoon.network",
+    defaultModel: "Qwen/Qwen3-32B",
+    utilityModel: "Qwen/Qwen3-32B",
+    toolLimit: 128,
+    piAiProvider: "cocoon"
+  },
+  local: {
+    id: "local",
+    displayName: "Local (Ollama, vLLM, LM Studio...)",
+    envVar: "",
+    keyPrefix: null,
+    keyHint: "No API key needed",
+    consoleUrl: "",
+    defaultModel: "auto",
+    utilityModel: "auto",
+    toolLimit: 128,
+    piAiProvider: "local"
+  }
+};
+function getProviderMetadata(provider) {
+  const meta = PROVIDER_REGISTRY[provider];
+  if (!meta) {
+    throw new Error(`Unknown provider: ${provider}`);
+  }
+  return meta;
+}
+function getSupportedProviders() {
+  return Object.values(PROVIDER_REGISTRY);
+}
+function validateApiKeyFormat(provider, key) {
+  const meta = PROVIDER_REGISTRY[provider];
+  if (!meta) return `Unknown provider: ${provider}`;
+  if (provider === "cocoon" || provider === "local") return void 0;
+  if (!key || key.trim().length === 0) return "API key is required";
+  if (meta.keyPrefix && !key.startsWith(meta.keyPrefix)) {
+    return `Invalid format (should start with ${meta.keyPrefix})`;
+  }
+  return void 0;
+}
+
+export {
+  getProviderMetadata,
+  getSupportedProviders,
+  validateApiKeyFormat
+};