tiger-agent 0.2.0

package/src/llmClient.js

@@ -0,0 +1,147 @@
+'use strict';
+
+/**
+ * llmClient.js
+ *
+ * Multi-provider LLM client.  Drop-in replacement for kimiClient.js.
+ *
+ * Exported API (identical to kimiClient):
+ *   chatCompletion(messages, options) → message object
+ *   embedText(input, model?)          → number[]
+ *
+ * Auto-switch behaviour:
+ *   - Before each request:  skip providers that are over their token limit.
+ *   - On 429 rate-limit:    immediately switch to next provider and retry.
+ *   - After each response:  record token usage; if limit now exceeded, queue
+ *     an auto-switch so the next request uses a fresh provider.
+ */
+
+const { getProvider } = require('./apiProviders');
+const tokenManager = require('./tokenManager');
+
+// ─── Low-level fetch wrapper ─────────────────────────────────────────────────
+
+async function fetchProvider(provider, endpoint, body) {
+  const key = provider.apiKey;
+  const headers = { 'Content-Type': 'application/json', ...provider.authHeaders(key) };
+  if (provider.userAgent) headers['User-Agent'] = provider.userAgent;
+
+  const timeout = provider.timeout || 30000;
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeout);
+
+  let res;
+  try {
+    res = await fetch(`${provider.baseUrl}${endpoint}`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+      signal: ctrl.signal
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    if (err && err.name === 'AbortError') {
+      throw Object.assign(new Error(`Timeout after ${timeout}ms (${provider.name})`), { status: 0 });
+    }
+    throw Object.assign(new Error(`Network error (${provider.name}): ${err.message}`), { status: 0 });
+  } finally {
+    clearTimeout(timer);
+  }
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw Object.assign(new Error(`HTTP ${res.status} from ${provider.name}: ${text}`), { status: res.status });
+  }
+
+  return res.json();
+}
+
+// ─── chatCompletion ──────────────────────────────────────────────────────────
+
+async function chatCompletion(messages, options = {}) {
+  // Build candidate list: active provider first, then fallbacks
+  const activeId = tokenManager.getCurrentProvider();
+  const candidates = [activeId, ...tokenManager.getNextCandidates(activeId)];
+
+  let lastError = null;
+
+  for (const providerId of candidates) {
+    if (!providerId) continue;
+
+    // Skip if over daily limit
+    if (tokenManager.isOverLimit(providerId)) continue;
+
+    const provider = getProvider(providerId);
+    if (!provider || !provider.apiKey) continue;
+
+    const reqOptions = { ...options, model: options.model || provider.chatModel };
+    const body = provider.formatRequest(messages, reqOptions);
+
+    let data;
+    try {
+      data = await fetchProvider(provider, provider.chatPath, body);
+    } catch (err) {
+      lastError = err;
+
+      // 429 = rate limit, 403 = quota exhausted — both warrant a fallback
+      if (err.status === 429 || err.status === 403) {
+        const reason = err.status === 429 ? 'rate_limit' : 'quota_exceeded';
+        const switched = tokenManager.autoSwitch(reason);
+        if (switched.switched) {
+          process.stderr.write(`[llm] ${reason} on ${providerId} → switched to ${switched.to}\n`);
+        }
+        continue;
+      }
+
+      // Any other error: try next candidate silently; surface only if all fail
+      lastError = err;
+      continue;
+    }
+
+    const { message, tokens } = provider.parseResponse(data);
+
+    // Record usage
+    tokenManager.recordTokens(providerId, tokens || 0);
+
+    // Queue auto-switch if this request pushed us over the limit
+    if (tokenManager.isOverLimit(providerId)) {
+      const switched = tokenManager.autoSwitch('token_limit');
+      if (switched.switched) {
+        process.stderr.write(`[llm] Token limit reached for ${providerId} → next request will use ${switched.to}\n`);
+      }
+    }
+
+    return message;
+  }
+
+  throw lastError || new Error('All providers failed or exhausted.');
+}
+
+// ─── embedText ───────────────────────────────────────────────────────────────
+
+async function embedText(input, model) {
+  // Find first provider in order that supports embeddings and has a key
+  const candidates = [tokenManager.getCurrentProvider(), ...tokenManager.getNextCandidates(tokenManager.getCurrentProvider())];
+  let provider = null;
+  let providerId = null;
+  for (const id of candidates) {
+    const p = getProvider(id);
+    if (p && p.apiKey && p.embedPath && (model || p.embedModel)) { provider = p; providerId = id; break; }
+  }
+  if (!provider) throw new Error('No provider with embeddings support and a configured API key.');
+
+  const embedModel = model || provider.embedModel;
+  if (!embedModel) throw new Error(`No embedding model configured for "${provider.name}".`);
+
+  const data = await fetchProvider(provider, provider.embedPath, { model: embedModel, input });
+
+  const vector = data.data?.[0]?.embedding;
+  if (!vector || !Array.isArray(vector)) {
+    throw new Error(`Invalid embedding response from ${provider.name}.`);
+  }
+
+  tokenManager.recordTokens(providerId, data.usage?.total_tokens || 0);
+  return vector;
+}
+
+module.exports = { chatCompletion, embedText };

package/src/telegram/bot.js

@@ -0,0 +1,182 @@
+'use strict';
+
+const TelegramBot = require('node-telegram-bot-api');
+const { telegramBotToken } = require('../config');
+const { handleMessage } = require('../agent/mainAgent');
+const tokenManager = require('../tokenManager');
+const { getProvider } = require('../apiProviders');
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+async function safeSend(bot, chatId, text, opts = {}) {
+  try {
+    const chunks = [];
+    for (let i = 0; i < text.length; i += 4000) chunks.push(text.slice(i, i + 4000));
+    for (const chunk of chunks) {
+      await bot.sendMessage(chatId, chunk, opts).catch(async () => {
+        // If parse_mode causes an error, retry as plain text
+        await bot.sendMessage(chatId, chunk);
+      });
+    }
+  } catch (err) {
+    process.stderr.write(`[telegram] sendMessage failed: ${err.message}\n`);
+  }
+}
+
+async function safeSendTyping(bot, chatId) {
+  try {
+    await bot.sendChatAction(chatId, 'typing');
+  } catch (err) {
+    process.stderr.write(`[telegram] sendChatAction failed: ${err.message}\n`);
+  }
+}
+
+// ─── /api command ─────────────────────────────────────────────────────────────
+
+const KNOWN_PROVIDERS = ['kimi', 'moonshot', 'zai', 'minimax', 'claude'];
+
+function buildApiStatus() {
+  const status = tokenManager.getStatus();
+  const lines = ['📊 *API Provider Status* (today)'];
+  lines.push('');
+  for (const s of status) {
+    const active = s.active ? '✅ *active*' : '  ';
+    const limitStr = s.limit > 0 ? `/ ${s.limit.toLocaleString()}` : '/ ∞';
+    const over = s.over ? ' ⚠️ LIMIT' : '';
+    const p = getProvider(s.id);
+    const modelStr = p ? ` (${p.chatModel})` : '';
+    lines.push(`${active} \`${s.id}\`${modelStr}`);
+    lines.push(`   tokens: ${s.tokens.toLocaleString()} ${limitStr}${over}  |  requests: ${s.requests}`);
+  }
+  lines.push('');
+  lines.push('Use `/api <name>` to switch provider.');
+  lines.push('Names: ' + KNOWN_PROVIDERS.map((n) => `\`${n}\``).join(', '));
+  return lines.join('\n');
+}
+
+function handleApiCommand(arg) {
+  if (!arg) {
+    return buildApiStatus();
+  }
+
+  const target = arg.trim().toLowerCase();
+  if (!KNOWN_PROVIDERS.includes(target)) {
+    return `❌ Unknown provider: \`${target}\`\nAvailable: ${KNOWN_PROVIDERS.map((n) => `\`${n}\``).join(', ')}`;
+  }
+
+  const provider = getProvider(target);
+  if (!provider || !provider.apiKey) {
+    return `⚠️ Provider \`${target}\` has no API key configured.\nSet ${target.toUpperCase()}_API_KEY in .env and restart.`;
+  }
+
+  const result = tokenManager.setProvider(target);
+  if (!result.ok) return `❌ Switch failed: ${result.error}`;
+
+  const p = getProvider(target);
+  return `✅ Switched to *${p.name}* (\`${target}\`)\nModel: \`${p.chatModel}\``;
+}
+
+// ─── /tokens command ──────────────────────────────────────────────────────────
+
+function handleTokensCommand() {
+  const status = tokenManager.getStatus();
+  const lines = ['📈 *Token Usage Today*', ''];
+  for (const s of status) {
+    const limitStr = s.limit > 0 ? `${s.tokens.toLocaleString()} / ${s.limit.toLocaleString()} (${Math.round((s.tokens / s.limit) * 100)}%)` : `${s.tokens.toLocaleString()} / unlimited`;
+    const flag = s.over ? ' 🔴 OVER LIMIT' : s.active ? ' 🟢 active' : '';
+    lines.push(`\`${s.id}\`: ${limitStr}${flag}`);
+  }
+  return lines.join('\n');
+}
+
+// ─── Bot startup ──────────────────────────────────────────────────────────────
+
+function startTelegramBot() {
+  if (!telegramBotToken) {
+    throw new Error('TELEGRAM_BOT_TOKEN is empty.');
+  }
+
+  const bot = new TelegramBot(telegramBotToken, { polling: true });
+
+  // Register commands so Telegram shows the list when user types /
+  bot.setMyCommands([
+    { command: 'api',    description: 'Show or switch active API provider' },
+    { command: 'tokens', description: 'Show token usage for today' },
+    { command: 'help',   description: 'Show all available commands' }
+  ]).catch((err) => {
+    process.stderr.write(`[telegram] setMyCommands failed: ${err.message}\n`);
+  });
+
+  bot.on('polling_error', (err) => {
+    process.stderr.write(`[telegram] polling_error: ${err.message}\n`);
+  });
+
+  bot.on('error', (err) => {
+    process.stderr.write(`[telegram] error: ${err.message}\n`);
+  });
+
+  bot.on('message', async (msg) => {
+    const chatId = String(msg.chat.id);
+    const userId = String(msg.from?.id || msg.chat.id);
+    // Strip @botname suffix that Telegram appends in group chats (e.g. /api@MyBot → /api)
+    const rawText = String(msg.text || '').trim();
+    const text = rawText.replace(/^(\/\w+)@\S+/, '$1');
+
+    if (!text) return;
+
+    const MD = { parse_mode: 'Markdown' };
+
+    // ── Slash commands ────────────────────────────────────────────────────
+    if (text.startsWith('/api')) {
+      const arg = text.slice(4).trim() || null;
+      await safeSend(bot, chatId, handleApiCommand(arg), MD);
+      return;
+    }
+
+    if (text === '/tokens' || text === '/token') {
+      await safeSend(bot, chatId, handleTokensCommand(), MD);
+      return;
+    }
+
+    if (text === '/help' || text === '/start') {
+      const helpText = [
+        '🤖 *Tiger Bot Commands*',
+        '',
+        '/api \\- Show current provider & token stats',
+        '/api `<name>` \\- Switch active API provider',
+        '/tokens \\- Show token usage for today',
+        '/help \\- Show this message',
+        '',
+        '*Available providers:* ' + KNOWN_PROVIDERS.join(', '),
+        '',
+        '_Token limits & auto\\-switch configured in .env_'
+      ].join('\n');
+      await safeSend(bot, chatId, helpText, { parse_mode: 'MarkdownV2' });
+      return;
+    }
+
+    // Unknown slash command — show hint instead of sending to agent
+    if (text.startsWith('/')) {
+      await safeSend(bot, chatId, `Unknown command. Type /help to see available commands.`);
+      return;
+    }
+
+    // ── Regular messages → agent ──────────────────────────────────────────
+    let typingTimer = null;
+    try {
+      await safeSendTyping(bot, chatId);
+      typingTimer = setInterval(() => safeSendTyping(bot, chatId), 4500);
+
+      const reply = await handleMessage({ platform: 'telegram', userId, text });
+      clearInterval(typingTimer);
+      await safeSend(bot, chatId, reply);
+    } catch (err) {
+      if (typingTimer) clearInterval(typingTimer);
+      await safeSend(bot, chatId, `⚠️ Error: ${err.message}`);
+    }
+  });
+
+  return bot;
+}
+
+module.exports = { startTelegramBot };

package/src/telegram/supervisor.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+// Source root (where cli.js lives) — always inside the npm package
+const srcRoot = path.resolve(__dirname, '..', '..');
+// Runtime root (where logs/pids go) — inside TIGER_HOME when installed globally
+const runtimeDir = process.env.TIGER_HOME || process.cwd();
+const logsDir = path.resolve(runtimeDir, 'logs');
+const botLogPath = path.resolve(logsDir, 'telegram.out.log');
+const supervisorPidPath = path.resolve(runtimeDir, 'tiger-telegram.pid');
+const workerPidPath = path.resolve(runtimeDir, 'tiger-telegram-worker.pid');
+const restartDelayMs = 5000;
+
+let worker = null;
+let stopping = false;
+
+function appendLog(line) {
+  fs.appendFileSync(botLogPath, `[${new Date().toISOString()}] ${line}\n`, 'utf8');
+}
+
+function writeBufferToLog(buffer) {
+  fs.appendFileSync(botLogPath, buffer);
+}
+
+function startWorker() {
+  if (stopping) return;
+
+  const cliPath = path.resolve(srcRoot, 'src', 'cli.js');
+  worker = spawn(process.execPath, [cliPath, '--telegram', '--worker'], {
+    cwd: runtimeDir,
+    env: process.env,
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+
+  fs.writeFileSync(workerPidPath, `${worker.pid}\n`, 'utf8');
+  appendLog(`worker started (PID ${worker.pid})`);
+
+  if (worker.stdout) {
+    worker.stdout.on('data', writeBufferToLog);
+  }
+  if (worker.stderr) {
+    worker.stderr.on('data', writeBufferToLog);
+  }
+
+  worker.on('exit', (code, signal) => {
+    if (fs.existsSync(workerPidPath)) fs.unlinkSync(workerPidPath);
+    if (stopping) return;
+    appendLog(`worker exited (code=${code}, signal=${signal || 'none'}), restarting in 5s`);
+    setTimeout(startWorker, restartDelayMs);
+  });
+}
+
+function shutdown(signal) {
+  if (stopping) return;
+  stopping = true;
+  appendLog(`supervisor stopping (${signal})`);
+
+  if (worker && worker.pid) {
+    try {
+      process.kill(worker.pid, 'SIGTERM');
+    } catch (err) {
+      // Worker may already be dead.
+    }
+  }
+
+  if (fs.existsSync(workerPidPath)) fs.unlinkSync(workerPidPath);
+  if (fs.existsSync(supervisorPidPath)) fs.unlinkSync(supervisorPidPath);
+  process.exit(0);
+}
+
+function main() {
+  fs.mkdirSync(logsDir, { recursive: true });
+  fs.writeFileSync(supervisorPidPath, `${process.pid}\n`, 'utf8');
+  appendLog(`supervisor started (PID ${process.pid})`);
+
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGINT', () => shutdown('SIGINT'));
+
+  startWorker();
+}
+
+main();

package/src/tokenManager.js

@@ -0,0 +1,223 @@
+'use strict';
+
+/**
+ * tokenManager.js
+ *
+ * Tracks daily token usage per provider, enforces per-provider limits, and
+ * handles auto-switching when a limit or rate-limit is hit.
+ *
+ * Config (read from .env via config.js on init):
+ *   ACTIVE_PROVIDER       – starting provider id (default: kimi)
+ *   PROVIDER_ORDER        – comma-separated priority list (default: kimi,zai,minimax,claude,moonshot)
+ *   KIMI_TOKEN_LIMIT      – daily token cap for kimi     (0 = unlimited)
+ *   MOONSHOT_TOKEN_LIMIT  – daily token cap for moonshot (0 = unlimited)
+ *   ZAI_TOKEN_LIMIT       – daily token cap for zai      (0 = unlimited)
+ *   MINIMAX_TOKEN_LIMIT   – daily token cap for minimax  (0 = unlimited)
+ *   CLAUDE_TOKEN_LIMIT    – daily token cap for claude   (0 = unlimited)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const USAGE_FILE = path.resolve('./db/token_usage.json');
+
+// ─── In-memory state ────────────────────────────────────────────────────────
+
+const state = {
+  activeProvider: '',
+  providerOrder: [],
+  limits: {},          // { providerId: number }
+  usage: {}            // { providerId: { tokens, requests, date } }
+};
+
+let _initialized = false;
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function todayStr() {
+  return new Date().toISOString().slice(0, 10); // 'YYYY-MM-DD'
+}
+
+function cleanEnv(v) {
+  return String(v || '').trim().replace(/^['"]|['"]$/g, '');
+}
+
+// ─── Persistence ────────────────────────────────────────────────────────────
+
+function loadUsageFile() {
+  try {
+    if (!fs.existsSync(USAGE_FILE)) return {};
+    return JSON.parse(fs.readFileSync(USAGE_FILE, 'utf8')) || {};
+  } catch (_) {
+    return {};
+  }
+}
+
+function saveUsageFile() {
+  try {
+    fs.mkdirSync(path.dirname(USAGE_FILE), { recursive: true });
+    fs.writeFileSync(USAGE_FILE, JSON.stringify(state.usage, null, 2), 'utf8');
+  } catch (_) {}
+}
+
+// ─── Init ────────────────────────────────────────────────────────────────────
+
+function init() {
+  if (_initialized) return;
+  _initialized = true;
+
+  const env = process.env;
+  const today = todayStr();
+
+  // Provider order
+  const orderRaw = cleanEnv(env.PROVIDER_ORDER) || 'kimi,zai,minimax,claude,moonshot';
+  state.providerOrder = orderRaw.split(',').map((s) => s.trim()).filter(Boolean);
+
+  // Active provider
+  const active = cleanEnv(env.ACTIVE_PROVIDER) || state.providerOrder[0] || 'kimi';
+  state.activeProvider = active;
+
+  // Token limits per provider (0 = unlimited)
+  state.limits = {
+    kimi: Number(env.KIMI_TOKEN_LIMIT || 0),
+    moonshot: Number(env.MOONSHOT_TOKEN_LIMIT || 0),
+    zai: Number(env.ZAI_TOKEN_LIMIT || 0),
+    minimax: Number(env.MINIMAX_TOKEN_LIMIT || 0),
+    claude: Number(env.CLAUDE_TOKEN_LIMIT || 0)
+  };
+
+  // Load persisted daily usage; discard stale days
+  const persisted = loadUsageFile();
+  state.usage = {};
+  for (const [id, record] of Object.entries(persisted)) {
+    if (record && record.date === today) {
+      state.usage[id] = { tokens: Number(record.tokens || 0), requests: Number(record.requests || 0), date: today };
+    }
+  }
+}
+
+function ensureInit() {
+  if (!_initialized) init();
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+function getCurrentProvider() {
+  ensureInit();
+  return state.activeProvider;
+}
+
+/**
+ * Manually switch to a named provider.
+ * Returns { ok, provider } or { ok: false, error }
+ */
+function setProvider(id) {
+  ensureInit();
+  if (!state.providerOrder.includes(id) && !['kimi', 'moonshot', 'zai', 'minimax', 'claude'].includes(id)) {
+    return { ok: false, error: `Unknown provider: ${id}` };
+  }
+  const prev = state.activeProvider;
+  state.activeProvider = id;
+  saveUsageFile();
+  return { ok: true, from: prev, to: id };
+}
+
+/**
+ * Record token usage for a provider after a successful response.
+ */
+function recordTokens(providerId, tokens) {
+  ensureInit();
+  const today = todayStr();
+  if (!state.usage[providerId] || state.usage[providerId].date !== today) {
+    state.usage[providerId] = { tokens: 0, requests: 0, date: today };
+  }
+  state.usage[providerId].tokens += Math.max(0, tokens || 0);
+  state.usage[providerId].requests += 1;
+  saveUsageFile();
+}
+
+/**
+ * True if the provider has exceeded its daily token limit.
+ */
+function isOverLimit(providerId) {
+  ensureInit();
+  const limit = state.limits[providerId] || 0;
+  if (limit === 0) return false;
+  const rec = state.usage[providerId];
+  if (!rec || rec.date !== todayStr()) return false;
+  return rec.tokens >= limit;
+}
+
+/**
+ * Returns all providers in priority order that are not over-limit,
+ * excluding the specified provider.
+ */
+function getNextCandidates(excludeId) {
+  ensureInit();
+  return state.providerOrder.filter((p) => p !== excludeId && !isOverLimit(p));
+}
+
+/**
+ * Auto-switch to the next available provider.
+ * Returns { switched, from, to, reason }
+ */
+function autoSwitch(reason) {
+  ensureInit();
+  const current = state.activeProvider;
+  const candidates = getNextCandidates(current);
+  if (!candidates.length) {
+    return { switched: false, from: current, reason };
+  }
+  const next = candidates[0];
+  state.activeProvider = next;
+  saveUsageFile();
+  return { switched: true, from: current, to: next, reason };
+}
+
+/**
+ * Full status for all known providers.
+ */
+function getStatus() {
+  ensureInit();
+  const today = todayStr();
+  const all = ['kimi', 'moonshot', 'zai', 'minimax', 'claude'];
+  return all.map((id) => {
+    const rec = state.usage[id];
+    const tokens = rec && rec.date === today ? rec.tokens : 0;
+    const requests = rec && rec.date === today ? rec.requests : 0;
+    const limit = state.limits[id] || 0;
+    return {
+      id,
+      active: id === state.activeProvider,
+      tokens,
+      requests,
+      limit,
+      over: isOverLimit(id)
+    };
+  });
+}
+
+/**
+ * Reset daily usage for a provider (or all if no id given).
+ */
+function resetUsage(providerId) {
+  ensureInit();
+  if (providerId) {
+    delete state.usage[providerId];
+  } else {
+    state.usage = {};
+  }
+  saveUsageFile();
+}
+
+module.exports = {
+  init,
+  getCurrentProvider,
+  setProvider,
+  recordTokens,
+  isOverLimit,
+  getNextCandidates,
+  autoSwitch,
+  getStatus,
+  resetUsage
+};

package/src/utils.js

@@ -0,0 +1,30 @@
+const fs = require('fs');
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function cosineSimilarity(a, b) {
+  if (!a || !b || a.length !== b.length || a.length === 0) {
+    return 0;
+  }
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  if (!na || !nb) {
+    return 0;
+  }
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+
+module.exports = {
+  ensureDir,
+  cosineSimilarity
+};