teleton 0.5.1 → 0.6.0

package/dist/chunk-D5I7GBV7.js

@@ -0,0 +1,322 @@
+import {
+  VOYAGE_API_URL,
+  fetchWithTimeout
+} from "./chunk-GDCODBNO.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 {
+  TELETON_ROOT
+} from "./chunk-EYWNOHMJ.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";
+env.cacheDir = join(TELETON_ROOT, "models");
+var extractorPromise = null;
+function getExtractor(model) {
+  if (!extractorPromise) {
+    console.log(`\u{1F4E6} Loading local embedding model: ${model} (cache: ${env.cacheDir})`);
+    extractorPromise = pipeline("feature-extraction", model, {
+      dtype: "fp32"
+    }).then((ext) => {
+      console.log(`\u2705 Local embedding model ready`);
+      return ext;
+    }).catch((err) => {
+      console.error(`\u274C 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) {
+      console.warn(
+        `\u26A0\uFE0F 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 {
+  constructor(inner, db) {
+    this.inner = inner;
+    this.db = db;
+    this.id = inner.id;
+    this.model = inner.model;
+    this.dimensions = inner.dimensions;
+  }
+  id;
+  model;
+  dimensions;
+  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);
+      console.log(
+        `\u{1F4CA} 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);
+        console.log(`\u{1F9F9} Embedding cache eviction: removed ${toDelete} entries (${count} total)`);
+      }
+    } catch (err) {
+      console.warn("\u26A0\uFE0F Embedding cache eviction error:", err);
+    }
+  }
+};
+
+export {
+  NoopEmbeddingProvider,
+  AnthropicEmbeddingProvider,
+  LocalEmbeddingProvider,
+  CachedEmbeddingProvider,
+  createEmbeddingProvider,
+  hashText,
+  serializeEmbedding,
+  deserializeEmbedding
+};

package/dist/chunk-ECSCVEQQ.js

@@ -0,0 +1,139 @@
+import {
+  TELETON_ROOT
+} from "./chunk-EYWNOHMJ.js";
+
+// src/utils/module-db.ts
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync, chmodSync } from "fs";
+import { dirname, join } from "path";
+var JOURNAL_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS journal (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp INTEGER NOT NULL DEFAULT (unixepoch()),
+    type TEXT NOT NULL CHECK(type IN ('trade', 'gift', 'middleman', 'kol')),
+    action TEXT NOT NULL,
+    asset_from TEXT,
+    asset_to TEXT,
+    amount_from REAL,
+    amount_to REAL,
+    price_ton REAL,
+    counterparty TEXT,
+    platform TEXT,
+    reasoning TEXT,
+    outcome TEXT CHECK(outcome IN ('pending', 'profit', 'loss', 'neutral', 'cancelled')),
+    pnl_ton REAL,
+    pnl_pct REAL,
+    tx_hash TEXT,
+    tool_used TEXT,
+    chat_id TEXT,
+    user_id INTEGER,
+    closed_at INTEGER,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_journal_type ON journal(type);
+  CREATE INDEX IF NOT EXISTS idx_journal_timestamp ON journal(timestamp DESC);
+  CREATE INDEX IF NOT EXISTS idx_journal_asset_from ON journal(asset_from);
+  CREATE INDEX IF NOT EXISTS idx_journal_outcome ON journal(outcome);
+  CREATE INDEX IF NOT EXISTS idx_journal_type_timestamp ON journal(type, timestamp DESC);
+`;
+var USED_TRANSACTIONS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS used_transactions (
+    tx_hash TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    amount REAL NOT NULL,
+    game_type TEXT NOT NULL,
+    used_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_used_tx_user ON used_transactions(user_id);
+  CREATE INDEX IF NOT EXISTS idx_used_tx_used_at ON used_transactions(used_at);
+`;
+function openModuleDb(path) {
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const db = new Database(path);
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+  db.pragma("journal_mode = WAL");
+  return db;
+}
+function createDbWrapper(getDb, moduleName) {
+  return function withDb(executor) {
+    return (params, context) => {
+      const moduleDb = getDb();
+      if (!moduleDb) {
+        return Promise.resolve({
+          success: false,
+          error: `${moduleName} module not started`
+        });
+      }
+      return executor(params, { ...context, db: moduleDb });
+    };
+  };
+}
+var MAIN_DB_PATH = join(TELETON_ROOT, "memory.db");
+function migrateFromMainDb(moduleDb, tables) {
+  let totalMigrated = 0;
+  for (const table of tables) {
+    if (!/^[a-z_]+$/.test(table)) {
+      throw new Error(`Invalid table name for migration: "${table}"`);
+    }
+  }
+  for (const table of tables) {
+    try {
+      const row = moduleDb.prepare(`SELECT COUNT(*) as c FROM ${table}`).get();
+      if (row.c > 0) return 0;
+    } catch {
+      continue;
+    }
+  }
+  if (!existsSync(MAIN_DB_PATH)) return 0;
+  try {
+    moduleDb.exec(`ATTACH DATABASE '${MAIN_DB_PATH}' AS main_db`);
+    for (const table of tables) {
+      try {
+        const exists = moduleDb.prepare(`SELECT name FROM main_db.sqlite_master WHERE type='table' AND name=?`).get(table);
+        if (!exists) continue;
+        const src = moduleDb.prepare(`SELECT COUNT(*) as c FROM main_db.${table}`).get();
+        if (src.c === 0) continue;
+        const dstCols = moduleDb.prepare(`PRAGMA table_info(${table})`).all().map((r) => r.name);
+        const srcCols = moduleDb.prepare(`PRAGMA main_db.table_info(${table})`).all().map((r) => r.name);
+        const shared = dstCols.filter((c) => srcCols.includes(c));
+        if (shared.length === 0) continue;
+        const cols = shared.join(", ");
+        moduleDb.exec(
+          `INSERT OR IGNORE INTO ${table} (${cols}) SELECT ${cols} FROM main_db.${table}`
+        );
+        totalMigrated += src.c;
+        try {
+          moduleDb.exec(`DROP TABLE main_db.${table}`);
+        } catch {
+        }
+        console.log(`  \u{1F4E6} Migrated ${src.c} rows from memory.db \u2192 ${table} (source dropped)`);
+      } catch (e) {
+        console.warn(`  \u26A0\uFE0F Could not migrate table ${table}:`, e);
+      }
+    }
+    moduleDb.exec(`DETACH DATABASE main_db`);
+  } catch (e) {
+    console.warn(`\u26A0\uFE0F Migration from memory.db failed:`, e);
+    try {
+      moduleDb.exec(`DETACH DATABASE main_db`);
+    } catch {
+    }
+  }
+  return totalMigrated;
+}
+
+export {
+  JOURNAL_SCHEMA,
+  USED_TRANSACTIONS_SCHEMA,
+  openModuleDb,
+  createDbWrapper,
+  migrateFromMainDb
+};

package/dist/chunk-GDCODBNO.js

@@ -0,0 +1,72 @@
+import {
+  DEFAULT_FETCH_TIMEOUT_MS
+} from "./chunk-4DU3C27M.js";
+
+// src/utils/fetch.ts
+var DEFAULT_TIMEOUT_MS = DEFAULT_FETCH_TIMEOUT_MS;
+function fetchWithTimeout(url, init) {
+  const { timeoutMs = DEFAULT_TIMEOUT_MS, ...fetchInit } = init ?? {};
+  if (fetchInit.signal) {
+    return fetch(url, fetchInit);
+  }
+  return fetch(url, {
+    ...fetchInit,
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+}
+
+// src/constants/api-endpoints.ts
+var TONAPI_BASE_URL = "https://tonapi.io/v2";
+var _tonapiKey;
+function setTonapiKey(key) {
+  _tonapiKey = key;
+}
+function tonapiHeaders() {
+  const headers = { Accept: "application/json" };
+  if (_tonapiKey) {
+    headers["Authorization"] = `Bearer ${_tonapiKey}`;
+  }
+  return headers;
+}
+var TONAPI_MAX_RPS = 5;
+var _tonapiTimestamps = [];
+async function waitForTonapiSlot() {
+  const clean = () => {
+    const cutoff = Date.now() - 1e3;
+    while (_tonapiTimestamps.length > 0 && _tonapiTimestamps[0] <= cutoff) {
+      _tonapiTimestamps.shift();
+    }
+  };
+  clean();
+  if (_tonapiTimestamps.length >= TONAPI_MAX_RPS) {
+    const waitMs = _tonapiTimestamps[0] + 1e3 - Date.now() + 50;
+    if (waitMs > 0) await new Promise((r) => setTimeout(r, waitMs));
+    clean();
+  }
+  _tonapiTimestamps.push(Date.now());
+}
+async function tonapiFetch(path, init) {
+  await waitForTonapiSlot();
+  return fetchWithTimeout(`${TONAPI_BASE_URL}${path}`, {
+    ...init,
+    headers: { ...tonapiHeaders(), ...init?.headers }
+  });
+}
+var STONFI_API_BASE_URL = "https://api.ston.fi/v1";
+var GECKOTERMINAL_API_URL = "https://api.geckoterminal.com/api/v2";
+var COINGECKO_API_URL = "https://api.coingecko.com/api/v3";
+var OPENAI_TTS_URL = "https://api.openai.com/v1/audio/speech";
+var ELEVENLABS_TTS_URL = "https://api.elevenlabs.io/v1/text-to-speech";
+var VOYAGE_API_URL = "https://api.voyageai.com/v1";
+
+export {
+  fetchWithTimeout,
+  setTonapiKey,
+  tonapiFetch,
+  STONFI_API_BASE_URL,
+  GECKOTERMINAL_API_URL,
+  COINGECKO_API_URL,
+  OPENAI_TTS_URL,
+  ELEVENLABS_TTS_URL,
+  VOYAGE_API_URL
+};

package/dist/{chunk-O4R7V5Y2.js → chunk-RO62LO6Z.js}

@@ -50,6 +50,11 @@ var SESSION_SLUG_RECENT_MESSAGES = 10;
 var SESSION_SLUG_MAX_TOKENS = 50;
 var MASKING_KEEP_RECENT_COUNT = 10;
 var EMBEDDING_CACHE_EVICTION_RATIO = 0.1;
+var WEB_FETCH_MAX_TEXT_LENGTH = 2e4;
+var WEB_SEARCH_MAX_RESULTS = 10;
+var TOOL_RAG_MIN_SCORE = 0.1;
+var TOOL_RAG_VECTOR_WEIGHT = 0.6;
+var TOOL_RAG_KEYWORD_WEIGHT = 0.4;
 
 export {
   MAX_TOOL_RESULT_SIZE,
@@ -102,5 +107,10 @@ export {
   SESSION_SLUG_RECENT_MESSAGES,
   SESSION_SLUG_MAX_TOKENS,
   MASKING_KEEP_RECENT_COUNT,
-  EMBEDDING_CACHE_EVICTION_RATIO
+  EMBEDDING_CACHE_EVICTION_RATIO,
+  WEB_FETCH_MAX_TEXT_LENGTH,
+  WEB_SEARCH_MAX_RESULTS,
+  TOOL_RAG_MIN_SCORE,
+  TOOL_RAG_VECTOR_WEIGHT,
+  TOOL_RAG_KEYWORD_WEIGHT
 };