tiger-agent 0.2.5 → 0.3.2

package/scripts/onboard.js

@@ -60,6 +60,19 @@ function envLine(k, v) {
   return `${k}=${s}`;
 }
 
+const KNOWN_PROVIDERS = ['minimax', 'zai', 'claude', 'kimi', 'moonshot'];
+
+function parseProviderList(input, fallback = []) {
+  const raw = String(input || '').trim();
+  const values = (raw ? raw : fallback.join(','))
+    .split(',')
+    .map((s) => s.trim().toLowerCase())
+    .filter(Boolean);
+  const unique = [...new Set(values)];
+  const invalid = unique.filter((p) => !KNOWN_PROVIDERS.includes(p));
+  return { providers: unique, invalid };
+}
+
 // ─── Daemon helpers ───────────────────────────────────────────────────────────
 
 function nodeBin() {
@@ -180,32 +193,87 @@ Config will be saved to: ${TIGER_HOME}
     if (!yn(ow, false)) { console.log('Cancelled.'); rl.close(); return; }
   }
 
-  // ── Active provider ────────────────────────────────────────────────────────
-  console.log('\nAvailable providers: kimi, zai (Zhipu GLM-4.7), minimax, claude, moonshot');
-  const activeProv = (await ask('Active provider (zai): ')).trim() || 'zai';
-  const provOrder = (await ask(`Provider fallback order (${activeProv},claude,kimi,minimax,moonshot): `)).trim()
-    || `${activeProv},claude,kimi,minimax,moonshot`;
+  // ── Provider selection / routing ──────────────────────────────────────────
+  console.log('\nAvailable providers: minimax, zai (Zhipu GLM-4.7), claude, kimi, moonshot');
+  console.log('Choose only providers you want to configure. Others will be omitted from .env.');
+
+  let selectedProviders = [];
+  while (!selectedProviders.length) {
+    const picked = await ask('Providers to configure (comma-separated, default: minimax): ');
+    const parsed = parseProviderList(picked, ['minimax']);
+    if (parsed.invalid.length) {
+      console.log(`Invalid provider(s): ${parsed.invalid.join(', ')}. Try again.`);
+      continue;
+    }
+    if (!parsed.providers.length) {
+      console.log('Pick at least one provider.');
+      continue;
+    }
+    selectedProviders = parsed.providers;
+  }
+
+  const activeDefault = selectedProviders[0];
+  let activeProv = '';
+  while (!activeProv) {
+    const candidate = (await ask(`Active provider (${activeDefault}): `)).trim().toLowerCase() || activeDefault;
+    if (!selectedProviders.includes(candidate)) {
+      console.log(`Active provider must be one of: ${selectedProviders.join(', ')}`);
+      continue;
+    }
+    activeProv = candidate;
+  }
 
-  // ── API keys ───────────────────────────────────────────────────────────────
-  console.log('\nEnter API keys (press Enter to skip a provider):');
+  const orderDefault = [activeProv, ...selectedProviders.filter((p) => p !== activeProv)].join(',');
+  let provOrder = '';
+  while (!provOrder) {
+    const input = await ask(`Provider fallback order (${orderDefault}): `);
+    const parsed = parseProviderList(input, [activeProv, ...selectedProviders.filter((p) => p !== activeProv)]);
+    if (parsed.invalid.length) {
+      console.log(`Invalid provider(s): ${parsed.invalid.join(', ')}. Try again.`);
+      continue;
+    }
+    const outsideSelection = parsed.providers.filter((p) => !selectedProviders.includes(p));
+    if (outsideSelection.length) {
+      console.log(`Order can only include selected providers: ${selectedProviders.join(', ')}`);
+      continue;
+    }
+    if (!parsed.providers.includes(activeProv)) {
+      console.log(`Order must include active provider: ${activeProv}`);
+      continue;
+    }
+    provOrder = parsed.providers.join(',');
+  }
 
-  const kimiKey    = (await askHidden('  KIMI_CODE_API_KEY  : ')).trim();
-  const moonshotKey= (await askHidden('  MOONSHOT_API_KEY   : ')).trim();
-  const zaiKey     = (await askHidden('  ZAI_API_KEY        : ')).trim();
-  const minimaxKey = (await askHidden('  MINIMAX_API_KEY    : ')).trim();
-  const claudeKey  = (await askHidden('  CLAUDE_API_KEY     : ')).trim();
+  // ── API keys ───────────────────────────────────────────────────────────────
+  console.log('\nEnter API keys for selected providers:');
+  const kimiKey = selectedProviders.includes('kimi') ? (await askHidden('  KIMI_CODE_API_KEY  : ')).trim() : '';
+  const moonshotKey = selectedProviders.includes('moonshot') ? (await askHidden('  MOONSHOT_API_KEY   : ')).trim() : '';
+  const zaiKey = selectedProviders.includes('zai') ? (await askHidden('  ZAI_API_KEY        : ')).trim() : '';
+  const minimaxKey = selectedProviders.includes('minimax') ? (await askHidden('  MINIMAX_API_KEY    : ')).trim() : '';
+  const claudeKey = selectedProviders.includes('claude') ? (await askHidden('  CLAUDE_API_KEY     : ')).trim() : '';
 
   // ── Telegram ───────────────────────────────────────────────────────────────
   console.log('');
   const tgToken = (await askHidden('  TELEGRAM_BOT_TOKEN : ')).trim();
 
   // ── Token limits ───────────────────────────────────────────────────────────
-  console.log('\nDaily token limits per provider (0 = unlimited, auto-switch on breach):');
-  const kimiLimit    = (await ask('  KIMI_TOKEN_LIMIT    (100000): ')).trim() || '100000';
-  const moonshotLimit= (await ask('  MOONSHOT_TOKEN_LIMIT(100000): ')).trim() || '100000';
-  const zaiLimit     = (await ask('  ZAI_TOKEN_LIMIT     (100000): ')).trim() || '100000';
-  const minimaxLimit = (await ask('  MINIMAX_TOKEN_LIMIT (100000): ')).trim() || '100000';
-  const claudeLimit  = (await ask('  CLAUDE_TOKEN_LIMIT  (500000): ')).trim() || '500000';
+  const tokenLimits = {};
+  console.log('\nDaily token limits for selected providers (0 = unlimited, auto-switch on breach):');
+  if (selectedProviders.includes('kimi')) {
+    tokenLimits.kimi = (await ask('  KIMI_TOKEN_LIMIT    (100000): ')).trim() || '100000';
+  }
+  if (selectedProviders.includes('moonshot')) {
+    tokenLimits.moonshot = (await ask('  MOONSHOT_TOKEN_LIMIT(100000): ')).trim() || '100000';
+  }
+  if (selectedProviders.includes('zai')) {
+    tokenLimits.zai = (await ask('  ZAI_TOKEN_LIMIT     (100000): ')).trim() || '100000';
+  }
+  if (selectedProviders.includes('minimax')) {
+    tokenLimits.minimax = (await ask('  MINIMAX_TOKEN_LIMIT (100000): ')).trim() || '100000';
+  }
+  if (selectedProviders.includes('claude')) {
+    tokenLimits.claude = (await ask('  CLAUDE_TOKEN_LIMIT  (500000): ')).trim() || '500000';
+  }
 
   // ── Misc ───────────────────────────────────────────────────────────────────
   const allowShell = yn(await ask('\nEnable shell tool? (y/N): '), false);
@@ -215,51 +283,80 @@ Config will be saved to: ${TIGER_HOME}
   const lines = [
     '# Tiger Agent config — generated by `tiger onboard`',
     '',
-    '# ── Legacy Kimi compat (used if ACTIVE_PROVIDER=kimi)',
-    envLine('KIMI_PROVIDER', 'code'),
-    envLine('KIMI_CODE_API_KEY', kimiKey),
-    envLine('KIMI_BASE_URL', 'https://api.kimi.com/coding/v1'),
-    envLine('KIMI_CHAT_MODEL', 'kimi-coding/k2p5'),
-    envLine('KIMI_EMBED_MODEL', ''),
-    envLine('KIMI_USER_AGENT', 'KimiCLI/0.77'),
-    envLine('KIMI_ENABLE_EMBEDDINGS', 'false'),
-    envLine('KIMI_TIMEOUT_MS', '30000'),
-    '',
     '# ── Multi-provider',
     envLine('ACTIVE_PROVIDER', activeProv),
     envLine('PROVIDER_ORDER', provOrder),
-    '',
-    '# ── Z.ai (Zhipu GLM)',
-    envLine('ZAI_API_KEY', zaiKey),
-    envLine('ZAI_BASE_URL', 'https://api.z.ai/api/coding/paas/v4'),
-    envLine('ZAI_MODEL', 'glm-4.7'),
-    envLine('ZAI_TIMEOUT_MS', '30000'),
-    '',
-    '# ── MiniMax',
-    envLine('MINIMAX_API_KEY', minimaxKey),
-    envLine('MINIMAX_BASE_URL', 'https://api.minimax.chat/v1'),
-    envLine('MINIMAX_MODEL', 'abab6.5s-chat'),
-    envLine('MINIMAX_TIMEOUT_MS', '30000'),
-    '',
-    '# ── Claude (Anthropic)',
-    envLine('CLAUDE_API_KEY', claudeKey),
-    envLine('CLAUDE_MODEL', 'claude-sonnet-4-6'),
-    envLine('CLAUDE_TIMEOUT_MS', '60000'),
-    '',
-    '# ── Moonshot',
-    envLine('MOONSHOT_API_KEY', moonshotKey),
-    envLine('MOONSHOT_BASE_URL', 'https://api.moonshot.cn/v1'),
-    envLine('MOONSHOT_MODEL', 'kimi-k1'),
-    '',
-    '# ── Token limits (daily, 0 = unlimited)',
-    envLine('KIMI_TOKEN_LIMIT', kimiLimit),
-    envLine('MOONSHOT_TOKEN_LIMIT', moonshotLimit),
-    envLine('ZAI_TOKEN_LIMIT', zaiLimit),
-    envLine('MINIMAX_TOKEN_LIMIT', minimaxLimit),
-    envLine('CLAUDE_TOKEN_LIMIT', claudeLimit),
+    ''
+  ];
+
+  if (selectedProviders.includes('kimi')) {
+    lines.push(
+      '# ── Legacy Kimi compat (used if ACTIVE_PROVIDER=kimi)',
+      envLine('KIMI_PROVIDER', 'code'),
+      envLine('KIMI_CODE_API_KEY', kimiKey),
+      envLine('KIMI_BASE_URL', 'https://api.kimi.com/coding/v1'),
+      envLine('KIMI_CHAT_MODEL', 'kimi-coding/k2p5'),
+      envLine('KIMI_EMBED_MODEL', ''),
+      envLine('KIMI_USER_AGENT', 'KimiCLI/0.77'),
+      envLine('KIMI_ENABLE_EMBEDDINGS', 'false'),
+      envLine('KIMI_TIMEOUT_MS', '30000'),
+      ''
+    );
+  }
+
+  if (selectedProviders.includes('zai')) {
+    lines.push(
+      '# ── Z.ai (Zhipu GLM)',
+      envLine('ZAI_API_KEY', zaiKey),
+      envLine('ZAI_BASE_URL', 'https://api.z.ai/api/coding/paas/v4'),
+      envLine('ZAI_MODEL', 'glm-4.7'),
+      envLine('ZAI_TIMEOUT_MS', '30000'),
+      ''
+    );
+  }
+
+  if (selectedProviders.includes('minimax')) {
+    lines.push(
+      '# ── MiniMax (Coding / OpenAI-compatible)',
+      envLine('MINIMAX_API_KEY', minimaxKey),
+      envLine('MINIMAX_BASE_URL', 'https://api.minimax.io/v1'),
+      envLine('MINIMAX_MODEL', 'MiniMax-M2.5'),
+      envLine('MINIMAX_TIMEOUT_MS', '30000'),
+      ''
+    );
+  }
+
+  if (selectedProviders.includes('claude')) {
+    lines.push(
+      '# ── Claude (Anthropic)',
+      envLine('CLAUDE_API_KEY', claudeKey),
+      envLine('CLAUDE_MODEL', 'claude-sonnet-4-6'),
+      envLine('CLAUDE_TIMEOUT_MS', '60000'),
+      ''
+    );
+  }
+
+  if (selectedProviders.includes('moonshot')) {
+    lines.push(
+      '# ── Moonshot',
+      envLine('MOONSHOT_API_KEY', moonshotKey),
+      envLine('MOONSHOT_BASE_URL', 'https://api.moonshot.cn/v1'),
+      envLine('MOONSHOT_MODEL', 'kimi-k1'),
+      ''
+    );
+  }
+
+  lines.push('# ── Token limits (daily, 0 = unlimited)');
+  if (tokenLimits.kimi != null) lines.push(envLine('KIMI_TOKEN_LIMIT', tokenLimits.kimi));
+  if (tokenLimits.moonshot != null) lines.push(envLine('MOONSHOT_TOKEN_LIMIT', tokenLimits.moonshot));
+  if (tokenLimits.zai != null) lines.push(envLine('ZAI_TOKEN_LIMIT', tokenLimits.zai));
+  if (tokenLimits.minimax != null) lines.push(envLine('MINIMAX_TOKEN_LIMIT', tokenLimits.minimax));
+  if (tokenLimits.claude != null) lines.push(envLine('CLAUDE_TOKEN_LIMIT', tokenLimits.claude));
+  lines.push(
     '',
     '# ── Telegram',
     envLine('TELEGRAM_BOT_TOKEN', tgToken),
+    envLine('SWARM_ENABLED', 'false'),
     '',
     '# ── Permissions',
     envLine('ALLOW_SHELL', allowShell ? 'true' : 'false'),
@@ -280,7 +377,7 @@ Config will be saved to: ${TIGER_HOME}
     'MEMORY_INGEST_EVERY_TURNS=2',
     'MEMORY_INGEST_MIN_CHARS=140',
     ''
-  ];
+  );
 
   fs.writeFileSync(ENV_PATH, lines.join('\n'), { mode: 0o600 });
   console.log(`\n✅  Config written to ${ENV_PATH}`);
@@ -307,7 +404,7 @@ Setup complete! 🐯
 Start CLI:           tiger start
 Start Telegram:      tiger telegram
 Background daemon:   tiger telegram --background
-Switch provider:     /api claude   (in Telegram chat)
+Switch provider:     /api <provider_id>   (in Telegram chat)
 Token usage:         /tokens       (in Telegram chat)
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
 

package/src/agent/skills.js

@@ -135,7 +135,7 @@ async function clawhubInstall(args = {}) {
   if (force) argv.push('--force');
 
   const res = await runClawhub(argv, {
-    timeout: Number(args.timeout_ms || 120000),
+    timeout: Number(args.timeout_ms || process.env.SWARM_AGENT_TIMEOUT_MS || 720000),
     maxBuffer: 1024 * 1024
   });
   if (res.ok) {

package/src/apiProviders.js

@@ -134,7 +134,7 @@ function buildProviders(env) {
       embedPath: '/embeddings',
       formatRequest: standardFormat,
       parseResponse: standardParse,
-      timeout: Number(env.KIMI_TIMEOUT_MS || 30000)
+      timeout: Number(env.KIMI_TIMEOUT_MS || 180000)
     },
 
     moonshot: {
@@ -150,7 +150,7 @@ function buildProviders(env) {
       embedPath: '/embeddings',
       formatRequest: standardFormat,
       parseResponse: standardParse,
-      timeout: Number(env.KIMI_TIMEOUT_MS || 30000)
+      timeout: Number(env.KIMI_TIMEOUT_MS || 180000)
     },
 
     zai: {
@@ -171,14 +171,14 @@ function buildProviders(env) {
       embedPath: '/embeddings',
       formatRequest: standardFormat,
       parseResponse: standardParse,
-      timeout: Number(env.ZAI_TIMEOUT_MS || 30000)
+      timeout: Number(env.ZAI_TIMEOUT_MS || 180000)
     },
 
     minimax: {
       id: 'minimax',
       name: 'MiniMax',
-      baseUrl: (env.MINIMAX_BASE_URL || 'https://api.minimax.chat/v1').replace(/\/$/, ''),
-      chatModel: env.MINIMAX_MODEL || 'abab6.5s-chat',
+      baseUrl: (env.MINIMAX_BASE_URL || 'https://api.minimax.io/v1').replace(/\/$/, ''),
+      chatModel: env.MINIMAX_MODEL || 'MiniMax-M2.5',
       embedModel: env.MINIMAX_EMBED_MODEL || '',
       apiKey: env.MINIMAX_API_KEY || '',
       userAgent: '',
@@ -187,7 +187,7 @@ function buildProviders(env) {
       embedPath: '/embeddings',
       formatRequest: standardFormat,
       parseResponse: standardParse,
-      timeout: Number(env.MINIMAX_TIMEOUT_MS || 30000)
+      timeout: Number(env.MINIMAX_TIMEOUT_MS || 180000)
     },
 
     claude: {
@@ -203,16 +203,15 @@ function buildProviders(env) {
       embedPath: null, // Claude does not expose an embeddings endpoint
       formatRequest: claudeFormat,
       parseResponse: claudeParse,
-      timeout: Number(env.CLAUDE_TIMEOUT_MS || 60000)
+      timeout: Number(env.CLAUDE_TIMEOUT_MS || 180000)
     }
   };
 }
 
-// Singleton — providers are built once from process.env on first access
-let _providers = null;
+// Always rebuild from current process.env so runtime .env changes take effect
+// (fixes stale timeout after PM2 restart or .env update)
 function getProviders() {
-  if (!_providers) _providers = buildProviders(process.env);
-  return _providers;
+  return buildProviders(process.env);
 }
 
 function getProvider(id) {

package/src/apiProviders.js.bak

@@ -0,0 +1,222 @@
+'use strict';
+
+const crypto = require('crypto');
+
+// ─── Zhipu AI (BigModel) JWT auth ──────────────────────────────────────────
+// Their v4 API requires HS256 JWT derived from the api-key (format: "id.secret")
+function b64url(buf) {
+  return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+function zhipuJwt(apiKey) {
+  const dot = apiKey.indexOf('.');
+  if (dot === -1) return apiKey; // fallback: treat as plain token
+  const id = apiKey.slice(0, dot);
+  const secret = apiKey.slice(dot + 1);
+  const now = Math.floor(Date.now() / 1000);
+  const hdr = b64url(Buffer.from(JSON.stringify({ alg: 'HS256', sign_type: 'SIGN' })));
+  const pay = b64url(Buffer.from(JSON.stringify({ api_key: id, exp: now + 3600, timestamp: now })));
+  const sig = b64url(crypto.createHmac('sha256', secret).update(`${hdr}.${pay}`).digest());
+  return `${hdr}.${pay}.${sig}`;
+}
+
+// ─── OpenAI-compatible adapters ────────────────────────────────────────────
+
+function standardFormat(messages, options) {
+  const payload = {
+    model: options.model,
+    messages,
+    temperature: options.temperature ?? 0.3
+  };
+  if (options.tools && options.tools.length) payload.tools = options.tools;
+  if (options.tool_choice) payload.tool_choice = options.tool_choice;
+  return payload;
+}
+
+function standardParse(data) {
+  const message = data.choices?.[0]?.message || {};
+  const u = data.usage || {};
+  const tokens = (u.prompt_tokens || 0) + (u.completion_tokens || 0);
+  return { message, tokens };
+}
+
+// ─── Claude (Anthropic) adapters ───────────────────────────────────────────
+
+function claudeFormat(messages, options) {
+  const systemMsg = messages.find((m) => m.role === 'system');
+  const rest = messages.filter((m) => m.role !== 'system');
+
+  // Convert tool definitions: OpenAI → Claude
+  let tools;
+  if (options.tools && options.tools.length) {
+    tools = options.tools.map((t) => ({
+      name: t.function.name,
+      description: t.function.description || '',
+      input_schema: t.function.parameters || { type: 'object', properties: {} }
+    }));
+  }
+
+  // Convert message content: tool_calls & tool results
+  const converted = rest.map((m) => {
+    if (m.role === 'assistant' && Array.isArray(m.tool_calls) && m.tool_calls.length) {
+      const content = [];
+      if (m.content) content.push({ type: 'text', text: m.content });
+      for (const tc of m.tool_calls) {
+        let input = {};
+        try { input = JSON.parse(tc.function.arguments || '{}'); } catch (_) {}
+        content.push({ type: 'tool_use', id: tc.id, name: tc.function.name, input });
+      }
+      return { role: 'assistant', content };
+    }
+    if (m.role === 'tool') {
+      return {
+        role: 'user',
+        content: [{ type: 'tool_result', tool_use_id: m.tool_call_id, content: String(m.content || '') }]
+      };
+    }
+    return m;
+  });
+
+  const payload = {
+    model: options.model,
+    max_tokens: options.max_tokens || 8192,
+    messages: converted
+  };
+  if (systemMsg) payload.system = systemMsg.content;
+  if (tools && tools.length) {
+    payload.tools = tools;
+    // Convert OpenAI tool_choice format → Claude format
+    const tc = options.tool_choice;
+    if (tc && tc !== 'none') {
+      if (tc === 'auto' || tc === 'required') {
+        payload.tool_choice = { type: tc === 'required' ? 'any' : 'auto' };
+      } else if (tc && typeof tc === 'object' && tc.type === 'function') {
+        payload.tool_choice = { type: 'tool', name: tc.function.name };
+      }
+    }
+  }
+  return payload;
+}
+
+function claudeParse(data) {
+  const content = Array.isArray(data.content) ? data.content : [];
+  const textBlock = content.find((b) => b.type === 'text');
+  const toolUseBlocks = content.filter((b) => b.type === 'tool_use');
+
+  const message = { role: 'assistant', content: textBlock ? textBlock.text : '' };
+  if (toolUseBlocks.length) {
+    message.tool_calls = toolUseBlocks.map((tb) => ({
+      id: tb.id,
+      type: 'function',
+      function: { name: tb.name, arguments: JSON.stringify(tb.input || {}) }
+    }));
+  }
+
+  const u = data.usage || {};
+  const tokens = (u.input_tokens || 0) + (u.output_tokens || 0);
+  return { message, tokens };
+}
+
+// ─── Provider registry ─────────────────────────────────────────────────────
+
+function buildProviders(env) {
+  return {
+    kimi: {
+      id: 'kimi',
+      name: 'Kimi Code',
+      baseUrl: (env.KIMI_BASE_URL || 'https://api.kimi.com/coding/v1').replace(/\/$/, ''),
+      chatModel: env.KIMI_CHAT_MODEL ? env.KIMI_CHAT_MODEL.replace(/^kimi-coding\//, '') : 'k2p5',
+      embedModel: env.KIMI_EMBED_MODEL || '',
+      apiKey: env.KIMI_CODE_API_KEY || env.KIMI_API_KEY || '',
+      userAgent: env.KIMI_USER_AGENT || 'KimiCLI/0.77',
+      authHeaders: (key) => ({ Authorization: `Bearer ${key}` }),
+      chatPath: '/chat/completions',
+      embedPath: '/embeddings',
+      formatRequest: standardFormat,
+      parseResponse: standardParse,
+      timeout: Number(env.KIMI_TIMEOUT_MS || 30000)
+    },
+
+    moonshot: {
+      id: 'moonshot',
+      name: 'Kimi Moonshot',
+      baseUrl: (env.MOONSHOT_BASE_URL || 'https://api.moonshot.cn/v1').replace(/\/$/, ''),
+      chatModel: env.MOONSHOT_MODEL || 'kimi-k1',
+      embedModel: env.MOONSHOT_EMBED_MODEL || 'kimi-embedding-v1',
+      apiKey: env.MOONSHOT_API_KEY || env.KIMI_API_KEY || '',
+      userAgent: '',
+      authHeaders: (key) => ({ Authorization: `Bearer ${key}` }),
+      chatPath: '/chat/completions',
+      embedPath: '/embeddings',
+      formatRequest: standardFormat,
+      parseResponse: standardParse,
+      timeout: Number(env.KIMI_TIMEOUT_MS || 30000)
+    },
+
+    zai: {
+      id: 'zai',
+      name: 'Z.ai',
+      baseUrl: (env.ZAI_BASE_URL || 'https://api.z.ai/api/coding/paas/v4').replace(/\/$/, ''),
+      chatModel: env.ZAI_MODEL || 'glm-4.7',
+      embedModel: env.ZAI_EMBED_MODEL || '',
+      apiKey: env.ZAI_API_KEY || '',
+      userAgent: '',
+      // api.z.ai uses plain Bearer; old bigmodel.cn used Zhipu JWT
+      authHeaders: (key) => {
+        const baseUrl = (env.ZAI_BASE_URL || '').toLowerCase();
+        if (baseUrl.includes('bigmodel.cn')) return { Authorization: `Bearer ${zhipuJwt(key)}` };
+        return { Authorization: `Bearer ${key}` };
+      },
+      chatPath: '/chat/completions',
+      embedPath: '/embeddings',
+      formatRequest: standardFormat,
+      parseResponse: standardParse,
+      timeout: Number(env.ZAI_TIMEOUT_MS || 30000)
+    },
+
+    minimax: {
+      id: 'minimax',
+      name: 'MiniMax',
+      baseUrl: (env.MINIMAX_BASE_URL || 'https://api.minimax.chat/v1').replace(/\/$/, ''),
+      chatModel: env.MINIMAX_MODEL || 'abab6.5s-chat',
+      embedModel: env.MINIMAX_EMBED_MODEL || '',
+      apiKey: env.MINIMAX_API_KEY || '',
+      userAgent: '',
+      authHeaders: (key) => ({ Authorization: `Bearer ${key}` }),
+      chatPath: '/chat/completions',
+      embedPath: '/embeddings',
+      formatRequest: standardFormat,
+      parseResponse: standardParse,
+      timeout: Number(env.MINIMAX_TIMEOUT_MS || 30000)
+    },
+
+    claude: {
+      id: 'claude',
+      name: 'Claude (Anthropic)',
+      baseUrl: (env.CLAUDE_BASE_URL || 'https://api.anthropic.com').replace(/\/$/, ''),
+      chatModel: env.CLAUDE_MODEL || 'claude-sonnet-4-6',
+      embedModel: '',
+      apiKey: env.CLAUDE_API_KEY || env.ANTHROPIC_API_KEY || '',
+      userAgent: '',
+      authHeaders: (key) => ({ 'x-api-key': key, 'anthropic-version': '2023-06-01' }),
+      chatPath: '/v1/messages',
+      embedPath: null, // Claude does not expose an embeddings endpoint
+      formatRequest: claudeFormat,
+      parseResponse: claudeParse,
+      timeout: Number(env.CLAUDE_TIMEOUT_MS || 60000)
+    }
+  };
+}
+
+// Singleton — providers are built once from process.env on first access
+let _providers = null;
+function getProviders() {
+  if (!_providers) _providers = buildProviders(process.env);
+  return _providers;
+}
+
+function getProvider(id) {
+  return getProviders()[id] || null;
+}
+
+module.exports = { getProviders, getProvider };

package/src/cli.js

@@ -9,12 +9,14 @@ const { startReflectionScheduler } = require('./agent/reflectionScheduler');
 const { initVectorMemory } = require('./agent/db');
 const { startTelegramBot } = require('./telegram/bot');
 const { handleMessage } = require('./agent/mainAgent');
+const { ensureSwarmLayout } = require('./swarm');
 
 // Source root — always inside the npm package
 const srcRoot = path.resolve(__dirname, '..');
 // Runtime root — inside TIGER_HOME when installed globally, otherwise project root
 const rootDir = process.env.TIGER_HOME || process.cwd();
 const supervisorPidPath = path.resolve(rootDir, 'tiger-telegram.pid');
+const workerHeartbeatPath = path.resolve(rootDir, 'tiger-telegram-worker.heartbeat');
 
 process.on('unhandledRejection', (reason) => {
   const msg = reason && reason.stack ? reason.stack : String(reason);
@@ -33,6 +35,14 @@ function hasFlag(argv, flag) {
   return argv.includes(flag);
 }
 
+function writeWorkerHeartbeat() {
+  try {
+    fs.writeFileSync(workerHeartbeatPath, `${Date.now()}\n`, 'utf8');
+  } catch (err) {
+    // Heartbeat is best-effort and must not crash the worker.
+  }
+}
+
 function isPidRunning(pid) {
   if (!pid) return false;
   try {
@@ -51,6 +61,7 @@ function getExistingSupervisorPid() {
 
 function startTelegramInBackground() {
   ensureContextFiles();
+  ensureSwarmLayout();
   const existingPid = getExistingSupervisorPid();
   if (existingPid && isPidRunning(existingPid)) {
     process.stdout.write(`Telegram background bot is already running (PID ${existingPid}).\n`);
@@ -85,7 +96,9 @@ function stopTelegramBackground() {
   process.kill(pid, 'SIGTERM');
   fs.unlinkSync(supervisorPidPath);
   const workerPidPath = path.resolve(rootDir, 'tiger-telegram-worker.pid');
+  const workerHeartbeatPath = path.resolve(rootDir, 'tiger-telegram-worker.heartbeat');
   if (fs.existsSync(workerPidPath)) fs.unlinkSync(workerPidPath);
+  if (fs.existsSync(workerHeartbeatPath)) fs.unlinkSync(workerHeartbeatPath);
   process.stdout.write(`Stopped Telegram background bot (supervisor PID ${pid}).\n`);
 }
 
@@ -113,6 +126,7 @@ function printVectorMemoryStatus(vectorStatus) {
 
 async function runCli() {
   ensureContextFiles();
+  ensureSwarmLayout();
   startReflectionScheduler();
   const vectorStatus = initVectorMemory();
   printVectorMemoryStatus(vectorStatus);
@@ -159,6 +173,7 @@ async function runCli() {
 
 async function main() {
   const argv = process.argv.slice(2);
+  const isWorkerProcess = hasFlag(argv, '--worker');
   if (hasFlag(argv, '--telegram-stop')) {
     stopTelegramBackground();
     return;
@@ -171,9 +186,15 @@ async function main() {
 
   if (isTelegramMode(argv)) {
     ensureContextFiles();
+    ensureSwarmLayout();
     startReflectionScheduler();
     const vectorStatus = initVectorMemory();
     printVectorMemoryStatus(vectorStatus);
+    if (isWorkerProcess) {
+      // NanoClaw-style heartbeat: worker emits liveness every minute.
+      writeWorkerHeartbeat();
+      setInterval(writeWorkerHeartbeat, 60 * 1000);
+    }
     startTelegramBot();
     process.stdout.write('Telegram bot started.\n');
     return;