tiger-agent 0.2.0

package/src/apiProviders.js

@@ -0,0 +1,217 @@
+'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 (Zhipu)',
+      baseUrl: (env.ZAI_BASE_URL || 'https://open.bigmodel.cn/api/paas/v4').replace(/\/$/, ''),
+      chatModel: env.ZAI_MODEL || 'glm-5',
+      embedModel: env.ZAI_EMBED_MODEL || '',
+      apiKey: env.ZAI_API_KEY || '',
+      userAgent: '',
+      authHeaders: (key) => ({ Authorization: `Bearer ${zhipuJwt(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

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { spawn } = require('child_process');
+const os = require('os');
+const { ensureContextFiles } = require('./agent/contextFiles');
+const { startReflectionScheduler } = require('./agent/reflectionScheduler');
+const { initVectorMemory } = require('./agent/db');
+const { startTelegramBot } = require('./telegram/bot');
+const { handleMessage } = require('./agent/mainAgent');
+
+// 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');
+
+process.on('unhandledRejection', (reason) => {
+  const msg = reason && reason.stack ? reason.stack : String(reason);
+  process.stderr.write(`[process] unhandledRejection: ${msg}\n`);
+});
+
+process.on('uncaughtException', (err) => {
+  process.stderr.write(`[process] uncaughtException: ${err.stack || err.message}\n`);
+});
+
+function isTelegramMode(argv) {
+  return argv.includes('--telegram');
+}
+
+function hasFlag(argv, flag) {
+  return argv.includes(flag);
+}
+
+function isPidRunning(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+function getExistingSupervisorPid() {
+  if (!fs.existsSync(supervisorPidPath)) return null;
+  const pid = Number(fs.readFileSync(supervisorPidPath, 'utf8').trim());
+  return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+
+function startTelegramInBackground() {
+  ensureContextFiles();
+  const existingPid = getExistingSupervisorPid();
+  if (existingPid && isPidRunning(existingPid)) {
+    process.stdout.write(`Telegram background bot is already running (PID ${existingPid}).\n`);
+    return;
+  }
+
+  fs.mkdirSync(path.resolve(rootDir, 'logs'), { recursive: true });
+  const supervisorLogPath = path.resolve(rootDir, 'logs', 'telegram-supervisor.log');
+  const logFd = fs.openSync(supervisorLogPath, 'a');
+  const supervisorScript = path.resolve(srcRoot, 'src', 'telegram', 'supervisor.js');
+  const child = spawn(process.execPath, [supervisorScript], {
+    cwd: rootDir,
+    env: process.env,
+    detached: true,
+    stdio: ['ignore', logFd, logFd]
+  });
+  child.unref();
+  fs.closeSync(logFd);
+
+  fs.writeFileSync(supervisorPidPath, `${child.pid}\n`, 'utf8');
+  process.stdout.write(`Telegram background bot started (supervisor PID ${child.pid}).\n`);
+}
+
+function stopTelegramBackground() {
+  const pid = getExistingSupervisorPid();
+  if (!pid || !isPidRunning(pid)) {
+    if (fs.existsSync(supervisorPidPath)) fs.unlinkSync(supervisorPidPath);
+    process.stdout.write('Telegram background bot is not running.\n');
+    return;
+  }
+
+  process.kill(pid, 'SIGTERM');
+  fs.unlinkSync(supervisorPidPath);
+  const workerPidPath = path.resolve(rootDir, 'tiger-telegram-worker.pid');
+  if (fs.existsSync(workerPidPath)) fs.unlinkSync(workerPidPath);
+  process.stdout.write(`Stopped Telegram background bot (supervisor PID ${pid}).\n`);
+}
+
+function printVectorMemoryStatus(vectorStatus) {
+  if (vectorStatus.ok) {
+    const vecMode = vectorStatus.sqliteVecLoaded ? 'enabled' : 'not loaded';
+    const count = Number(vectorStatus?.counts?.memories || 0);
+    process.stdout.write(
+      `Vector memory: sqlite (${vectorStatus.dbPath}) | sqlite-vec: ${vecMode} | memories: ${count}\n`
+    );
+    if (String(vectorStatus.dbPath || '').startsWith(`${os.tmpdir()}${path.sep}`)) {
+      process.stdout.write(
+        'Warning: VECTOR_DB_PATH is under /tmp and may be wiped after restart. Use ./db/memory.sqlite for persistence.\n'
+      );
+    }
+    if (!vectorStatus.sqliteVecLoaded) {
+      process.stdout.write(
+        'Info: sqlite-vec not loaded. Semantic recall still works using cosine fallback.\n'
+      );
+    }
+    return;
+  }
+  process.stdout.write(`Vector memory: json fallback (${vectorStatus.dbPath})\n`);
+}
+
+async function runCli() {
+  ensureContextFiles();
+  startReflectionScheduler();
+  const vectorStatus = initVectorMemory();
+  printVectorMemoryStatus(vectorStatus);
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: 'you> '
+  });
+
+  const userId = 'local-user';
+  process.stdout.write('Tiger agent ready. Type /exit to quit.\n');
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const text = String(line || '').trim();
+    if (!text) {
+      rl.prompt();
+      return;
+    }
+    if (text === '/exit' || text === '/quit') {
+      rl.close();
+      return;
+    }
+
+    try {
+      const reply = await handleMessage({
+        platform: 'cli',
+        userId,
+        text
+      });
+      process.stdout.write(`tiger> ${reply}\n`);
+    } catch (err) {
+      process.stdout.write(`error> ${err.message}\n`);
+    }
+    rl.prompt();
+  });
+
+  rl.on('close', () => {
+    process.stdout.write('bye\n');
+    process.exit(0);
+  });
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (hasFlag(argv, '--telegram-stop')) {
+    stopTelegramBackground();
+    return;
+  }
+
+  if (isTelegramMode(argv) && hasFlag(argv, '--background')) {
+    startTelegramInBackground();
+    return;
+  }
+
+  if (isTelegramMode(argv)) {
+    ensureContextFiles();
+    startReflectionScheduler();
+    const vectorStatus = initVectorMemory();
+    printVectorMemoryStatus(vectorStatus);
+    startTelegramBot();
+    process.stdout.write('Telegram bot started.\n');
+    return;
+  }
+  await runCli();
+}
+
+main().catch((err) => {
+  process.stderr.write(`${err.stack || err.message}\n`);
+  process.exit(1);
+});

package/src/config.js

@@ -0,0 +1,141 @@
+const path = require('path');
+const dotenv = require('dotenv');
+const fs = require('fs');
+const { decryptToString } = require('../scripts/cryptoEnv');
+
+function loadDotenvIfPresent(p) {
+  const full = path.resolve(process.cwd(), p);
+  if (!fs.existsSync(full)) return;
+  dotenv.config({ path: full, override: false });
+}
+
+function parseEnvText(text) {
+  const out = {};
+  const lines = String(text || '').split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf('=');
+    if (idx === -1) continue;
+    const k = trimmed.slice(0, idx).trim();
+    let v = trimmed.slice(idx + 1).trim();
+    // remove surrounding quotes
+    v = v.replace(/^['"]|['"]$/g, '');
+    if (k) out[k] = v;
+  }
+  return out;
+}
+
+function loadEncryptedSecretsIfPresent() {
+  const encPath = process.env.SECRETS_FILE || '.env.secrets.enc';
+  const passphrase = process.env.SECRETS_PASSPHRASE || '';
+  const full = path.resolve(process.cwd(), encPath);
+  if (!fs.existsSync(full)) return;
+  if (!passphrase) return;
+  const payload = JSON.parse(fs.readFileSync(full, 'utf8'));
+  const plaintext = decryptToString(payload, passphrase);
+  const kv = parseEnvText(plaintext);
+  for (const [k, v] of Object.entries(kv)) {
+    if (process.env[k] == null || process.env[k] === '') {
+      process.env[k] = v;
+    }
+  }
+}
+
+// Load public config first, then local secrets, then encrypted secrets (optional).
+loadDotenvIfPresent('.env');
+loadDotenvIfPresent('.env.secrets');
+loadEncryptedSecretsIfPresent();
+
+function cleanEnvValue(value) {
+  if (value == null) return '';
+  return String(value).trim().replace(/^['"]|['"]$/g, '');
+}
+
+function normalizeModelForProvider(provider, model) {
+  const text = cleanEnvValue(model);
+  if (!text) return text;
+  if (!text.includes('/')) return text;
+
+  if (provider === 'code' && text.toLowerCase().startsWith('kimi-coding/')) {
+    return text.slice('kimi-coding/'.length);
+  }
+  if (provider === 'moonshot' && text.toLowerCase().startsWith('moonshot/')) {
+    return text.slice('moonshot/'.length);
+  }
+  return text;
+}
+
+const providerRaw = cleanEnvValue(process.env.KIMI_PROVIDER || '').toLowerCase();
+const kimiProvider =
+  providerRaw || (cleanEnvValue(process.env.KIMI_CODE_API_KEY) ? 'code' : 'moonshot');
+
+if (!['moonshot', 'code'].includes(kimiProvider)) {
+  throw new Error('Invalid KIMI_PROVIDER. Use "moonshot" or "code".');
+}
+
+const rawApiKey =
+  kimiProvider === 'code'
+    ? process.env.KIMI_CODE_API_KEY || process.env.KIMI_API_KEY || ''
+    : process.env.MOONSHOT_API_KEY || process.env.KIMI_API_KEY || '';
+const kimiApiKey = cleanEnvValue(rawApiKey);
+// Only hard-fail on missing kimi key when kimi/moonshot is the active provider.
+// If ACTIVE_PROVIDER is set to another provider, the key is optional.
+const activeProvider = cleanEnvValue(process.env.ACTIVE_PROVIDER || '').toLowerCase();
+const kimiIsActive = !activeProvider || activeProvider === 'kimi' || activeProvider === 'moonshot';
+if (!kimiApiKey && kimiIsActive) {
+  if (kimiProvider === 'code') {
+    throw new Error('Missing required env: KIMI_CODE_API_KEY (or KIMI_API_KEY)');
+  }
+  throw new Error('Missing required env: MOONSHOT_API_KEY (or KIMI_API_KEY)');
+}
+
+const defaultBaseUrl =
+  kimiProvider === 'code' ? 'https://api.kimi.com/coding/v1' : 'https://api.moonshot.cn/v1';
+const defaultChatModel = kimiProvider === 'code' ? 'k2p5' : 'kimi-k1';
+const defaultEmbedModel = kimiProvider === 'code' ? '' : 'kimi-embedding-v1';
+const defaultUserAgent = kimiProvider === 'code' ? 'KimiCLI/0.77' : '';
+
+const embedFlagRaw = cleanEnvValue(process.env.KIMI_ENABLE_EMBEDDINGS || '');
+const embeddingsEnabled =
+  embedFlagRaw === ''
+    ? kimiProvider !== 'code'
+    : ['1', 'true', 'yes', 'on'].includes(embedFlagRaw.toLowerCase());
+const ownSkillUpdateHours = Math.max(1, Number(process.env.OWN_SKILL_UPDATE_HOURS || 24));
+const ownSkillFile = cleanEnvValue(process.env.OWN_SKILL_FILE) || 'ownskill.md';
+const soulUpdateHours = Math.max(1, Number(process.env.SOUL_UPDATE_HOURS || 24));
+const reflectionUpdateHours = Math.max(1, Number(process.env.REFLECTION_UPDATE_HOURS || 12));
+const vectorDbPath = path.resolve(process.env.VECTOR_DB_PATH || './db/memory.sqlite');
+const sqliteVecExtension = cleanEnvValue(process.env.SQLITE_VEC_EXTENSION || '');
+const memoryIngestEveryTurns = Math.max(1, Number(process.env.MEMORY_INGEST_EVERY_TURNS || 2));
+const memoryIngestMinChars = Math.max(20, Number(process.env.MEMORY_INGEST_MIN_CHARS || 140));
+
+module.exports = {
+  kimiProvider,
+  kimiApiKey,
+  kimiBaseUrl: cleanEnvValue(process.env.KIMI_BASE_URL) || defaultBaseUrl,
+  kimiChatModel: normalizeModelForProvider(
+    kimiProvider,
+    cleanEnvValue(process.env.KIMI_CHAT_MODEL) || defaultChatModel
+  ),
+  kimiEmbedModel: cleanEnvValue(process.env.KIMI_EMBED_MODEL) || defaultEmbedModel,
+  kimiUserAgent: cleanEnvValue(process.env.KIMI_USER_AGENT) || defaultUserAgent,
+  kimiTimeoutMs: Number(process.env.KIMI_TIMEOUT_MS || 30000),
+  embeddingsEnabled,
+  telegramBotToken: process.env.TELEGRAM_BOT_TOKEN || '',
+  allowShell: String(process.env.ALLOW_SHELL || 'false').toLowerCase() === 'true',
+  allowSkillInstall: String(process.env.ALLOW_SKILL_INSTALL || 'false').toLowerCase() === 'true',
+  dataDir: path.resolve(process.env.DATA_DIR || './data'),
+  ownSkillPath: path.resolve(process.env.DATA_DIR || './data', ownSkillFile),
+  ownSkillUpdateHours,
+  soulPath: path.resolve(process.env.DATA_DIR || './data', 'soul.md'),
+  soulUpdateHours,
+  reflectionUpdateHours,
+  vectorDbPath,
+  sqliteVecExtension,
+  memoryIngestEveryTurns,
+  memoryIngestMinChars,
+  dbPath: path.resolve(process.env.DB_PATH || './db/agent.json'),
+  maxMessages: Number(process.env.MAX_MESSAGES || 200),
+  recentMessages: Number(process.env.RECENT_MESSAGES || 40)
+};

package/src/kimiClient.js

@@ -0,0 +1,88 @@
+const {
+  kimiApiKey,
+  kimiBaseUrl,
+  kimiChatModel,
+  kimiEmbedModel,
+  kimiUserAgent,
+  kimiTimeoutMs,
+  embeddingsEnabled,
+  kimiProvider
+} = require('./config');
+
+async function kimiRequest(path, body) {
+  const headers = {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${kimiApiKey}`
+  };
+  if (kimiUserAgent) {
+    headers['User-Agent'] = kimiUserAgent;
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), Math.max(1000, kimiTimeoutMs || 30000));
+  let res;
+  try {
+    res = await fetch(`${kimiBaseUrl}${path}`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (err && err.name === 'AbortError') {
+      throw new Error(`Kimi API timeout after ${Math.max(1000, kimiTimeoutMs || 30000)}ms`);
+    }
+    throw new Error(`Kimi API network error: ${err.message}`);
+  } finally {
+    clearTimeout(timer);
+  }
+
+  if (!res.ok) {
+    const text = await res.text();
+    if (res.status === 401) {
+      const keyHint =
+        kimiProvider === 'code'
+          ? 'KIMI_CODE_API_KEY (Kimi Code token)'
+          : 'MOONSHOT_API_KEY/KIMI_API_KEY (Moonshot Open Platform key)';
+      throw new Error(
+        `Kimi API auth failed (401). Verify ${keyHint}, base URL (${kimiBaseUrl}), and extra quotes/spaces. Raw response: ${text}`
+      );
+    }
+    throw new Error(`Kimi API error ${res.status}: ${text}`);
+  }
+
+  return res.json();
+}
+
+async function chatCompletion(messages, options = {}) {
+  const payload = {
+    model: options.model || kimiChatModel,
+    messages,
+    temperature: options.temperature ?? 0.3
+  };
+  if (options.tools) payload.tools = options.tools;
+  if (options.tool_choice) payload.tool_choice = options.tool_choice;
+
+  const data = await kimiRequest('/chat/completions', payload);
+  return data.choices?.[0]?.message || {};
+}
+
+async function embedText(input, model = kimiEmbedModel) {
+  if (!embeddingsEnabled || !model) {
+    throw new Error('Embeddings are disabled for the current Kimi provider/config.');
+  }
+  const data = await kimiRequest('/embeddings', {
+    model,
+    input
+  });
+  const vector = data.data?.[0]?.embedding;
+  if (!vector || !Array.isArray(vector)) {
+    throw new Error('Invalid embedding response from Kimi');
+  }
+  return vector;
+}
+
+module.exports = {
+  chatCompletion,
+  embedText
+};