skyloom 1.4.4 → 1.5.0

package/config/default.yaml

@@ -0,0 +1,47 @@
+# Skyloom default configuration
+llm:
+  default_model: gpt-4o
+  language: zh
+  max_retries: 2
+  temperature: 0.7
+  max_tokens: 4096
+
+agents:
+  fog:
+    model: gpt-4o
+    temperature: 0.7
+  rain:
+    model: gpt-4o
+    temperature: 0.7
+  frost:
+    model: gpt-4o
+    temperature: 0.3
+  snow:
+    model: gpt-4o
+    temperature: 0.5
+  dew:
+    model: gpt-4o
+    temperature: 0.3
+  fair:
+    model: gpt-4o
+    temperature: 0.9
+
+memory:
+  db_path: ~/.skyloom/memory.db
+  short_term_limit: 100
+  max_persisted_messages: 2000
+
+workspace:
+  path: auto
+
+cli:
+  default_agent: fog
+  approval_mode: interactive
+
+plugins:
+  enabled: true
+  directories:
+    - ~/.skyloom/plugins
+
+mcp:
+  servers: []

package/config/providers.yaml

@@ -0,0 +1,39 @@
+# Provider catalog — API key env vars, base URLs, docs
+openai:
+  env_var: OPENAI_API_KEY
+  base_url: https://api.openai.com/v1
+  docs_url: https://platform.openai.com/api-keys
+
+anthropic:
+  env_var: ANTHROPIC_API_KEY
+  base_url: https://api.anthropic.com/v1
+  docs_url: https://console.anthropic.com/settings/keys
+
+deepseek:
+  env_var: DEEPSEEK_API_KEY
+  base_url: https://api.deepseek.com/v1
+  docs_url: https://platform.deepseek.com/api_keys
+
+groq:
+  env_var: GROQ_API_KEY
+  base_url: https://api.groq.com/openai/v1
+
+mistral:
+  env_var: MISTRAL_API_KEY
+  base_url: https://api.mistral.ai/v1
+
+cohere:
+  env_var: COHERE_API_KEY
+  base_url: https://api.cohere.ai/v1
+
+openrouter:
+  env_var: OPENROUTER_API_KEY
+  base_url: https://openrouter.ai/api/v1
+
+gemini:
+  env_var: GEMINI_API_KEY
+  base_url: https://generativelanguage.googleapis.com/v1beta
+
+ollama:
+  base_url: http://localhost:11434/v1
+  env_var: OLLAMA_HOST

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skyloom",
-  "version": "1.4.4",
+  "version": "1.5.0",
   "description": "天空织机 Skyloom — 6 weather-themed AI agents: Fog, Rain, Frost, Snow, Dew, Fair",
   "preferGlobal": true,
   "type": "commonjs",

package/src/cli/main.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 /**
  * 天空织机 CLI — Skyloom Terminal Interface
- * Raw-mode input + slash command popup + streaming display
  */
 import { Command } from "commander";
 import * as fs from "fs";
@@ -13,13 +12,8 @@ import { classify } from "../core/router";
 import { InteractiveMode, ModeController } from "./mode";
 
 const MODE = new ModeController();
-const VERSION = "1.4.2";
+const VERSION = "1.4.4";
 
-/* ── Agent colors ── */
-const AGENT_COLORS: Record<string, string> = {
-  fog: "#b8c6db", rain: "#4a90d9", frost: "#2cd4d4",
-  snow: "#e8ecf1", dew: "#7bed9f", fair: "#f7b733",
-};
 const AGENT_DISPLAY: Record<string, string> = {
   fog: "≋ 雾 Fog", rain: "⸽ 雨 Rain", frost: "✱ 霜 Frost",
   snow: "❉ 雪 Snow", dew: "∘ 露 Dew", fair: "☼ 晴 Fair",
@@ -27,555 +21,242 @@ const AGENT_DISPLAY: Record<string, string> = {
 const AGENT_NAMES = ["fog", "rain", "frost", "snow", "dew", "fair"] as const;
 
 /* ═══════════════════════════════════════
-   Commander program
+   Slash commands registry
    ═══════════════════════════════════════ */
-const program = new Command()
-  .name("sky").description("天空织机 Skyloom — 6 weather-themed AI agents").version(VERSION);
-
-program.command("chat").description("Start interactive chat")
-  .argument("[agent]", "agent name", "fog")
-  .option("-m,--model <model>", "Model override")
-  .action(async (a: string, o: { model?: string }) => { await chat(a, o.model); });
-
-program.command("task").description("Multi-agent orchestration")
-  .argument("[goal]", "task goal")
-  .option("-r,--resume", "resume from checkpoint")
-  .action(async (g?: string, o?: { resume?: boolean }) => { if (g) await runTask(g, o?.resume); });
-
-program.command("web").description("Start web server")
-  .option("-p,--port <port>", "port", "3000")
-  .action(async (o: { port?: string }) => { const { startWebServer } = await import("../web/server"); await startWebServer(parseInt(o.port || "3000", 10)); });
-
-program.command("mcp").description("Start MCP server")
-  .action(async () => { const { startMCPServer } = await import("../core/mcp_server"); await startMCPServer(); });
-
-program.command("config").description("Show configuration")
-  .action(() => { const c = loadConfig(); logLine(chalk.cyan("Config dir: ") + USER_CONFIG_DIR); logLine(chalk.cyan("Agent models:")); for (const [n, a] of Object.entries(c.agents || {})) logLine(`  ${chalk.bold(n)}: ${(a as any).model || "default"}`); });
-
-program.command("init").description("Initialize config directory")
-  .action(() => { const d = USER_CONFIG_DIR; if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true }); logLine(chalk.green("✓ ") + d); });
-
-program.command("version").description("Show version")
-  .action(() => logLine(`Skyloom v${VERSION}`));
-
-/* ═══════════════════════════════════════
-   Interactive Chat — raw-mode input + popup
-   ═══════════════════════════════════════ */
-const SLASH_CMDS: [string, string, boolean, string][] = [
-  ["/help", "Show all commands", false, ""],
-  ["/clear", "Clear screen", false, ""],
-  ["/status", "Agent overview", false, ""],
-  ["/cost", "Usage & cost", false, ""],
-  ["/cost reset", "Reset usage stats", false, ""],
-  ["/compact", "Compress context", false, ""],
-  ["/retry", "Resend last message", false, ""],
-  ["/mcp", "MCP server status", false, ""],
-  ["/memory", "Memory stats", false, ""],
-  ["/sessions", "Session list", false, ""],
-  ["/workspace", "Workspace info", false, ""],
-  ["/model", "Model info", false, ""],
-  ["/version", "Version info", false, ""],
-  ["/task <goal>", "Multi-agent orchestrate", true, ""],
-  ["/quiz", "Export chat as quiz", false, ""],
-  ["/fog", "≋ Fog — research", false, "fog"],
-  ["/rain", "⸽ Rain — codegen", false, "rain"],
-  ["/frost", "✱ Frost — review", false, "frost"],
-  ["/snow", "❉ Snow — planning", false, "snow"],
-  ["/dew", "∘ Dew — devops", false, "dew"],
-  ["/fair", "☼ Fair — companion", false, "fair"],
-  ["/quit", "Exit chat", false, ""],
-  ["/exit", "Exit chat", false, ""],
+const SLASH_CMDS: [string, string][] = [
+  ["/help", "Show all commands"],
+  ["/clear", "Clear screen"],
+  ["/status", "Agent overview"],
+  ["/cost", "Usage & cost"],
+  ["/cost reset", "Reset usage stats"],
+  ["/compact", "Compress context"],
+  ["/retry", "Resend last msg"],
+  ["/memory", "Memory stats"],
+  ["/memory clear", "Clear short-term memory"],
+  ["/sessions", "Session list"],
+  ["/workspace", "Workspace info"],
+  ["/model", "Model info"],
+  ["/mcp", "MCP server status"],
+  ["/version", "Version info"],
+  ["/task <goal>", "Multi-agent orchestrate"],
+  ["/fog", "≋ Fog — research insight"],
+  ["/rain", "⸽ Rain — creation codegen"],
+  ["/frost", "✱ Frost — review quality"],
+  ["/snow", "❉ Snow — planning architect"],
+  ["/dew", "∘ Dew — devops reliability"],
+  ["/fair", "☼ Fair — companion warmth"],
+  ["/quit", "Exit chat"],
+  ["/exit", "Exit chat"],
 ];
 
-function logLine(s: string) { process.stdout.write(s + "\n"); }
-
-/* ── Stream response with spinner ── */
-async function chatWithSpinner(
-  agent: any, ctx: any, message: string
-): Promise<string> {
-  let frame = 0;
-  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-  const spinner = setInterval(() => {
-    readline.cursorTo(process.stdout, 0);
-    process.stdout.write(chalk.cyan(`  ${frames[frame % frames.length]} ${agent.displayName} thinking...`));
-    frame++;
-  }, 80);
-
-  try {
-    const response = await agent.chat(message);
-    clearInterval(spinner);
-    readline.cursorTo(process.stdout, 0);
-    process.stdout.write(" ".repeat(50) + "\r");
-    return response;
-  } catch (e) {
-    clearInterval(spinner);
-    throw e;
-  }
-}
-
-/* ── Render response ── */
-function renderResponse(text: string): string[] {
-  const lines: string[] = [];
+function showPopup(cmds: [string, string][], selIdx: number) {
   const w = process.stdout.columns || 80;
-  const maxW = Math.min(w - 6, 76);
-  for (const block of text.split("\n\n")) {
-    const trimmed = block.trim();
-    if (!trimmed) continue;
-    // Code blocks
-    if (trimmed.startsWith("```")) {
-      const codeLines = trimmed.split("\n");
-      lines.push(chalk.dim("  ┌─ code ──────────────"));
-      for (let i = 1; i < codeLines.length - 1; i++) {
-        const cl = codeLines[i];
-        lines.push(`  ${chalk.dim("│")} ${chalk.white(cl.slice(0, maxW - 4))}`);
-      }
-      lines.push(chalk.dim("  └────────────────────"));
-      continue;
-    }
-    // Wrap long lines
-    for (const line of trimmed.split("\n")) {
-      if (line.startsWith("#")) {
-        lines.push("  " + chalk.bold(line));
-      } else if (line.startsWith("- ") || line.startsWith("* ")) {
-        lines.push("  " + chalk.dim("• ") + line.slice(2));
-      } else {
-        let remaining = line;
-        while (remaining.length > maxW) {
-          const cut = remaining.lastIndexOf(" ", maxW);
-          const idx = cut > 0 ? cut : maxW;
-          lines.push("  " + remaining.slice(0, idx));
-          remaining = remaining.slice(idx).trimStart();
-        }
-        if (remaining) lines.push("  " + remaining);
-      }
-    }
+  const start = Math.max(0, Math.min(selIdx - 4, cmds.length - 8));
+  const end = Math.min(cmds.length, start + 8);
+  process.stdout.write(chalk.dim("  ┌─ commands (↑↓ pick · type letter to filter · tab/enter select) ─┐\n"));
+  for (let i = start; i < end; i++) {
+    const [cmd, desc] = cmds[i];
+    const marker = i === selIdx ? chalk.cyan(" ▶ ") : "   ";
+    process.stdout.write(`  │${marker}${chalk.cyan(cmd.padEnd(24))}${chalk.dim(desc)}${" ".repeat(Math.max(0, 50 - desc.length))}│\n`);
   }
-  return lines;
+  process.stdout.write(chalk.dim(`  └${"─".repeat(60)}┘\n`));
 }
 
-/* ── Welcome banner ── */
-function printWelcome(agent: any, model: string) {
+/* ═══════════════════════════════════════
+   Commander
+   ═══════════════════════════════════════ */
+const program = new Command()
+  .name("sky").description("天空织机 Skyloom").version(VERSION);
+
+program.command("chat").argument("[agent]", "agent name", "fog")
+  .option("-m,--model <m>", "model").action(async (a: string, o: { model?: string }) => { await chat(a, o.model); });
+program.command("task").argument("[goal]", "task goal")
+  .action(async (g?: string) => { if (g) await runTask(g); });
+program.command("web").option("-p,--port <p>", "port", "3000")
+  .action((o: { port?: string }) => { import("../web/server").then(m => m.startWebServer(parseInt(o.port || "3000"))); });
+program.command("mcp").action(() => { import("../core/mcp_server").then(m => m.startMCPServer()); });
+program.command("config").action(() => { const c = loadConfig(); process.stdout.write(chalk.cyan("\nConfig: ") + USER_CONFIG_DIR + "\n"); for (const [n, a] of Object.entries(c.agents || {})) process.stdout.write(`  ${chalk.bold(n)}: ${(a as any).model || "default"}\n`); });
+program.command("init").action(() => { if (!fs.existsSync(USER_CONFIG_DIR)) fs.mkdirSync(USER_CONFIG_DIR, { recursive: true }); process.stdout.write(chalk.green("✓ ") + USER_CONFIG_DIR + "\n"); });
+program.command("version").action(() => { process.stdout.write(`Skyloom v${VERSION}\n`); });
+
+/* ═══════════════════════════════════════
+   Welcome
+   ═══════════════════════════════════════ */
+function welcome(agent: any) {
   const w = process.stdout.columns || 80;
-  logLine("");
-  logLine(" ".repeat(Math.max(0, Math.floor((w - 40) / 2))) + chalk.cyan("✦    天 空 织 机    ✦"));
-  logLine(" ".repeat(Math.max(0, Math.floor((w - 36) / 2))) + chalk.dim("S K Y L O O M"));
-  logLine("");
-  const agentLine: string[] = [];
-  for (const name of AGENT_NAMES) {
-    const active = name === agent.name;
-    const prefix = active ? chalk.bold(AGENT_DISPLAY[name].split(" ").slice(0, 2).join(" ")) : chalk.dim(AGENT_DISPLAY[name].split(" ")[0] + " " + AGENT_DISPLAY[name].split(" ")[1]);
-    agentLine.push(prefix);
+  const pad = " ".repeat(Math.max(0, Math.floor((w - 34) / 2)));
+  process.stdout.write("\n" + pad + chalk.cyan("✦    天 空 织 机    ✦\n"));
+  process.stdout.write(pad + chalk.dim("S K Y L O O M\n\n"));
+  const parts: string[] = [];
+  for (const n of AGENT_NAMES) {
+    const a = n === agent.name;
+    const s = `${AGENT_DISPLAY[n].split(" ")[0]} ${AGENT_DISPLAY[n].split(" ")[1]}`;
+    parts.push(a ? chalk.bold.cyan(s) : chalk.dim(s));
   }
-  logLine("  " + agentLine.join(chalk.dim("  ·  ")));
-  logLine("");
-  logLine(chalk.dim(`  Model: ${model}  ·  /help for commands  ·  /quit to exit`));
-  logLine("");
+  process.stdout.write("  " + parts.join(chalk.dim("  ·  ")) + "\n\n");
+  process.stdout.write(chalk.dim("  /help for commands  ·  /quit to exit\n\n"));
 }
 
-/* ── Status bar ── */
 function statusBar(agent: any, ctx: any): string {
-  let ctxStr = "";
-  let costStr = "$0";
-  let modelStr = "default";
   try {
     const cu = agent.contextUsage();
-    modelStr = cu.model || "?";
     const pct = cu.pct || 0;
-    const barColor = pct < 50 ? chalk.green : pct < 80 ? chalk.yellow : chalk.red;
-    const barLen = Math.round(pct / 10);
-    ctxStr = `${barColor("█".repeat(barLen) + "░".repeat(10 - barLen))} ${pct}%`;
-    costStr = formatCost(ctx.llm.getTotalCost());
-  } catch { /* ignore */ }
-  const w = process.stdout.columns || 80;
-  return chalk.dim(`┤ ${ctxStr}  ·  ${costStr}  ·  ${modelStr}  ├${"─".repeat(Math.max(0, w - 60))}`);
+    const bar = pct < 50 ? chalk.green : pct < 80 ? chalk.yellow : chalk.red;
+    const filled = Math.round(pct / 10);
+    const ctxBar = `${bar("█".repeat(filled) + "░".repeat(10 - filled))} ${pct}%`;
+    const cost = formatCost(ctx.llm.getTotalCost());
+    return chalk.dim(`${ctxBar}  ·  ${cost}  ·  ${cu.model || "?"}`);
+  } catch { return ""; }
 }
 
-function formatCost(cost: number): string {
-  if (cost >= 1) return chalk.yellow(`$${cost.toFixed(2)}`);
-  if (cost >= 0.01) return chalk.yellow(`$${cost.toFixed(4)}`);
-  if (cost > 0) return chalk.green(`${(cost * 100).toFixed(2)}¢`);
+function formatCost(c: number): string {
+  if (c >= 1) return chalk.yellow(`$${c.toFixed(2)}`);
+  if (c >= 0.01) return chalk.yellow(`$${c.toFixed(4)}`);
+  if (c > 0) return chalk.green(`${(c * 100).toFixed(2)}¢`);
   return "$0";
 }
 
-/* ── Slash-command popup ── */
-async function readWithPopup(agent: any, ctx: any): Promise<string> {
-  if (!process.stdin.isTTY) {
-    return new Promise<string>(resolve => {
-      const rl = readline.createInterface({ input: process.stdin });
-      rl.on("line", (line) => { rl.close(); resolve(line.trim()); });
-    });
-  }
-
-  return new Promise<string>(resolve => {
-    const stdin = process.stdin;
-    try { stdin.setRawMode?.(true); } catch { /* non-TTY */ }
-    stdin.resume();
-
-    let buf = "";
-    let cursor = 0;
-    let popup = false;
-    let selIdx = 0;
-    const _history: string[] = (readWithPopup as any)._popupHistory || [];
-    let histIdx = _history.length;
-
-    function render() {
-      const w = process.stdout.columns || 80;
-      readline.cursorTo(process.stdout, 0);
-
-      // Clear current line area
-      const promptLine = `  ${chalk.cyan(agent.displayName)} ${chalk.dim("❯")} `;
-
-      // Build filtered commands
-      const filtered = popup ? SLASH_CMDS.filter(c => c[0].toLowerCase().includes(buf.toLowerCase())) : [];
-      if (filtered.length && selIdx >= filtered.length) selIdx = filtered.length - 1;
-
-      const popupH = Math.min(filtered.length, 10);
-      const totalH = popup ? popupH + 3 : 1;
-
-      // Move cursor up
-      if (popup) {
-        for (let i = 0; i < popupH + 2; i++) process.stdout.write("\x1b[1A\x1b[2K");
-      } else {
-        process.stdout.write("\x1b[2K\r");
-      }
-
-      // Input line
-      const before = buf.slice(0, cursor);
-      const after = buf.slice(cursor);
-      const cursorChar = after[0] || " ";
-      process.stdout.write(promptLine + before + chalk.inverse(cursorChar) + after.slice(1) + "\n");
-
-      // Popup
-      if (popup && filtered.length) {
-        const maxW = Math.min(w - 4, 60);
-        const start = Math.max(0, Math.min(selIdx - 4, filtered.length - 8));
-        const end = Math.min(filtered.length, start + 8);
-        process.stdout.write(chalk.dim(`  ┌─ commands (↑↓ pick · type to filter · tab/enter select · esc close)${"─".repeat(Math.max(0, maxW - 58))}┐\n`));
-        for (let i = start; i < end; i++) {
-          const [cmd, desc] = filtered[i];
-          const marker = i === selIdx ? chalk.cyan(" ▶ ") : "   ";
-          const cmdColored = i === selIdx ? chalk.bold(cmd) : chalk.cyan(cmd);
-          const line = `  │${marker}${cmdColored.padEnd(24)}${chalk.dim(desc)}`;
-          process.stdout.write(line + " ".repeat(Math.max(0, maxW - line.length + 6)) + "│\n");
-        }
-        process.stdout.write(chalk.dim(`  └${"─".repeat(maxW + 1)}┘\n`));
+/* ═══════════════════════════════════════
+   Response render
+   ═══════════════════════════════════════ */
+function render(text: string): string[] {
+  const out: string[] = [];
+  for (const para of text.split("\n\n")) {
+    const t = para.trim();
+    if (!t) continue;
+    if (t.startsWith("```")) {
+      const lines = t.split("\n");
+      out.push(chalk.dim("  ╭─ code ──"));
+      for (let i = 1; i < lines.length - 1; i++) out.push(`  ${chalk.dim("│")} ${chalk.gray(lines[i].slice(0, 72))}`);
+      out.push(chalk.dim("  ╰────────"));
+    } else {
+      for (const line of t.split("\n")) {
+        if (line.startsWith("# ")) out.push("  " + chalk.bold(line));
+        else if (line.startsWith("- ") || line.startsWith("* ")) out.push("  " + chalk.dim("• ") + line.slice(2));
+        else out.push("  " + line);
       }
-
-      // Status bar
-      process.stdout.write(statusBar(agent, ctx) + (popup ? "" : "\n"));
-    }
-
-    function accept(line: string) {
-      try { stdin.setRawMode?.(false); } catch { }
-      stdin.pause();
-      resolve(line);
     }
-
-    stdin.on("data", (data: Buffer) => {
-      const seq = data.toString();
-      for (const ch of seq) {
-        // Esc
-        if (ch === "\x1b") {
-          if (popup) { popup = false; render(); return; }
-          accept(""); return;
-        }
-        // Enter
-        if (ch === "\r" || ch === "\n") {
-          if (popup && SLASH_CMDS.filter(c => c[0].toLowerCase().includes(buf.toLowerCase())).length) {
-            const filtered = SLASH_CMDS.filter(c => c[0].toLowerCase().includes(buf.toLowerCase()));
-            buf = filtered[selIdx]?.[0] || buf;
-            popup = false;
-          }
-          accept(buf.trim()); return;
-        }
-        // Tab
-        if (ch === "\t") {
-          if (popup && SLASH_CMDS.filter(c => c[0].toLowerCase().includes(buf.toLowerCase())).length) {
-            const filtered = SLASH_CMDS.filter(c => c[0].toLowerCase().includes(buf.toLowerCase()));
-            buf = filtered[selIdx]?.[0] || buf;
-            cursor = buf.length;
-            popup = false;
-            render(); return;
-          }
-          // Insert 2 spaces
-          buf = buf.slice(0, cursor) + "  " + buf.slice(cursor);
-          cursor += 2;
-          render(); return;
-        }
-        // Backspace
-        if (ch === "\x7f" || ch === "\b") {
-          if (cursor > 0) { buf = buf.slice(0, cursor - 1) + buf.slice(cursor); cursor--; }
-          if (!buf) { popup = false; }
-          render(); return;
-        }
-        // Ctrl+C
-        if (ch === "\x03") { accept("/quit"); return; }
-        // Printable
-        if (ch >= " ") {
-          buf = buf.slice(0, cursor) + ch + buf.slice(cursor);
-          cursor++;
-          if (buf === "/") { popup = true; selIdx = 0; }
-          else if (popup) { selIdx = 0; }
-          render(); return;
-        }
-      }
-    });
-
-    // Arrow keys come as escape sequences — handle via process.stdin
-    // For simplicity, arrow keys in raw mode are: \x1b[A (up), \x1b[B (down), \x1b[C (right), \x1b[D (left)
-    // We handle them in the data handler above by checking for escape sequences
-    // Actually the raw mode data comes byte by byte — let me use a state machine approach
-    // For now, let me handle the common case: the full escape sequence arrives in one data event
-
-    // Note: Arrow keys are 3 bytes: \x1b [ A/B/C/D. They may arrive in one or multiple data events.
-    // In practice on Windows they arrive as one event. Let me add a simple buffered approach.
-
-    stdin.removeAllListeners("data");
-
-    let escBuf = "";
-    stdin.on("data", (data: Buffer) => {
-      const str = data.toString();
-      escBuf += str;
-
-      // If we have an escape sequence, process it
-      if (escBuf.startsWith("\x1b[")) {
-        if (escBuf.length >= 3) {
-          const code = escBuf[2];
-          escBuf = "";
-          if (code === "A") {
-            if (popup) { selIdx = Math.max(0, selIdx - 1); } else if (_history.length) { histIdx = Math.max(0, histIdx - 1); buf = _history[histIdx] || ""; cursor = buf.length; }
-            render(); return;
-          }
-          if (code === "B") {
-            if (popup) { const f = SLASH_CMDS.filter(c => c[0].toLowerCase().includes(buf.toLowerCase())); selIdx = Math.min(f.length - 1, selIdx + 1); }
-            else if (_history.length && histIdx < _history.length) { histIdx++; buf = _history[histIdx] || ""; cursor = buf.length; }
-            render(); return;
-          }
-          if (code === "C") { if (cursor < buf.length) cursor++; if (popup) popup = false; render(); return; }
-          if (code === "D") { if (cursor > 0) cursor--; if (popup) popup = false; render(); return; }
-        } else { return; /* wait for more bytes */ }
-      }
-
-      // Not an escape sequence — process normally
-      for (const ch of escBuf) {
-        escBuf = "";
-        if (ch === "\x1b") { if (popup) { popup = false; render(); } return; }
-        if (ch === "\r" || ch === "\n") {
-          if (popup && SLASH_CMDS.filter(c => c[0].toLowerCase().includes(buf.toLowerCase())).length) {
-            buf = SLASH_CMDS.filter(c => c[0].toLowerCase().includes(buf.toLowerCase()))[selIdx]?.[0] || buf;
-            popup = false;
-          }
-          accept(buf.trim()); return;
-        }
-        if (ch === "\t") {
-          if (popup && SLASH_CMDS.filter(c => c[0].toLowerCase().includes(buf.toLowerCase())).length) {
-            const filtered = SLASH_CMDS.filter(c => c[0].toLowerCase().includes(buf.toLowerCase()));
-            buf = filtered[selIdx]?.[0] || buf;
-            cursor = buf.length; popup = false;
-            render(); return;
-          }
-          buf = buf.slice(0, cursor) + "  " + buf.slice(cursor); cursor += 2;
-          render(); return;
-        }
-        if (ch === "\x7f" || ch === "\b") { if (cursor > 0) { buf = buf.slice(0, cursor - 1) + buf.slice(cursor); cursor--; } if (!buf) popup = false; render(); return; }
-        if (ch === "\x03") { accept("/quit"); return; }
-        if (ch >= " ") {
-          buf = buf.slice(0, cursor) + ch + buf.slice(cursor); cursor++;
-          if (buf === "/") { popup = true; selIdx = 0; }
-          else if (popup) selIdx = 0;
-          render(); return;
-        }
-      }
-    });
-
-    render();
-  });
+  }
+  return out;
 }
 
 /* ═══════════════════════════════════════
-   Main chat loop
+   Chat loop
    ═══════════════════════════════════════ */
 async function chat(agentName: string, modelOverride?: string): Promise<void> {
   const ctx = createSystemContext();
   let agent = ctx.agentMap.get(agentName);
-  if (!agent) { logLine(chalk.red(`Unknown agent: ${agentName}`)); return; }
+  if (!agent) { process.stdout.write(chalk.red(`Unknown agent: ${agentName}\n`)); return; }
   await agent.init();
+  welcome(agent);
 
-  const model = modelOverride || "default";
-  printWelcome(agent, model);
-
-  const inputHistory: string[] = [];
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+  const history: string[] = [];
 
-  while (true) {
-    /* ── Read input ── */
-    const inp = await readWithPopup(agent, ctx);
-    if (!inp) { logLine(""); continue; }
+  for await (const line of rl) {
+    const inp = line.trim();
+    if (!inp) continue;
 
-    // Save to history
-    if (!inputHistory[inputHistory.length - 1] || inputHistory[inputHistory.length - 1] !== inp) {
-      inputHistory.push(inp);
-      if (inputHistory.length > 50) inputHistory.shift();
+    if (inp[0] !== "/" && !history.includes(inp)) {
+      history.push(inp);
+      if (history.length > 50) history.shift();
     }
-    (readWithPopup as any)._popupHistory = inputHistory;
 
-    const cmd = inp.trim();
-    const cmdLower = cmd.toLowerCase();
-
-    /* ── Slash commands ── */
+    const cmdLower = inp.toLowerCase();
     let handled = false;
 
-    // Agent switching
+    // Agent switch
     for (const n of AGENT_NAMES) {
       if (cmdLower === `/${n}`) {
-        const newAgent = ctx.agentMap.get(n);
-        if (newAgent) {
-          await newAgent.init();
-          // Switch agent reference (mutate closure)
-          logLine(chalk.dim(`\n  ⟳  ${AGENT_DISPLAY[n]}\n`));
-          // We can't reassign the outer `agent` const, so use a workaround
-          (chat as any)._currentAgent = newAgent;
-          (chat as any)._currentCtx = ctx;
-          // Actually, let me handle this differently — replace the agent in the closure
-          agent = newAgent;
-        }
+        const a = ctx.agentMap.get(n);
+        if (a) { await a.init(); agent = a; process.stdout.write(chalk.dim(`  ⟳ ${AGENT_DISPLAY[n]}\n`)); }
         handled = true; break;
       }
     }
 
+    if (handled) continue;
     if (cmdLower === "/quit" || cmdLower === "/exit") break;
-    if (cmdLower === "/help") { printHelp(); handled = true; }
-    if (cmdLower === "/clear") { console.clear(); handled = true; }
-    if (cmdLower === "/version") { logLine(`  Skyloom v${VERSION}`); handled = true; }
-    if (cmdLower === "/status") {
-      logLine(chalk.bold(`\n  ${agent.displayName} (${agent.name})`));
-      logLine(chalk.dim(`  State: ${agent.state}  ·  Specialty: ${agent.specialty}`));
-      logLine(chalk.dim(`  Memory: ${agent.memory.shortTerm.length} messages  ·  ${Object.keys(agent.memory.working).length} working keys`));
-      handled = true;
-    }
-    if (cmdLower === "/cost") {
-      logLine(chalk.bold("\n  Usage & Cost"));
-      logLine(chalk.dim("  ─".repeat(24)));
-      logLine(`  Total: ${formatCost(ctx.llm.getTotalCost())}`);
-      handled = true;
-    }
-    if (cmdLower === "/cost reset") { (ctx.llm as any).resetUsageStats?.(); logLine(chalk.dim("  Stats reset")); handled = true; }
-    if (cmdLower === "/compact") {
-      logLine(chalk.dim("  Compacting..."));
-      const r = await agent.compact();
-      logLine(chalk.green(`  ✓ ${r}`));
-      handled = true;
-    }
-    if (cmdLower === "/memory") {
-      logLine(chalk.bold("\n  Memory"));
-      logLine(chalk.dim(`  Short-term: ${agent.memory.shortTerm.length} msgs  ·  Working: ${Object.keys(agent.memory.working).length} keys`));
-      handled = true;
-    }
-    if (cmdLower === "/workspace") {
-      logLine(chalk.dim(`\n  Workspace: ${ctx.workspacePath || "default"}`));
-      handled = true;
-    }
-    if (cmdLower === "/mcp") {
-      logLine(chalk.dim(`\n  MCP servers: ${ctx.mcpStatus?.length ? ctx.mcpStatus.join(", ") : "none configured"}`));
-      handled = true;
-    }
-    if (cmdLower === "/sessions") {
-      const sessions = await agent.memory.listSessions();
-      if (sessions.length) {
-        logLine(chalk.bold("\n  Sessions"));
-        for (const s of sessions.slice(0, 10)) {
-          logLine(chalk.dim(`  ${s.id?.slice(0, 10)}... ${s.preview || ""} (${s.messageCount || 0} msgs)`));
-        }
-      } else { logLine(chalk.dim("  No saved sessions")); }
-      handled = true;
-    }
-    if (cmdLower.startsWith("/model")) { logLine(chalk.dim(`  Model: ${modelOverride || "default"}. Configure in ~/.skyloom/config.yaml`)); handled = true; }
-    if (cmdLower.startsWith("/task ")) {
-      const goal = cmd.slice(6).trim();
-      if (goal) { logLine(chalk.cyan(`\n  ✦ Orchestrating: ${goal}\n`)); await runTask(goal); }
-      handled = true;
-    }
-
-    if (handled) { logLine(""); continue; }
-
-    /* ── Route message ── */
-    const mode = MODE.current;
-    if (mode === InteractiveMode.PLAN) {
-      await runTask(cmd); logLine(""); continue;
-    }
+    if (cmdLower === "/help") { process.stdout.write(helpText()); handled = true; }
+    if (cmdLower === "/clear") { console.clear(); welcome(agent); handled = true; }
+    if (cmdLower === "/version") { process.stdout.write(`  Skyloom v${VERSION}\n`); handled = true; }
+    if (cmdLower === "/status") { process.stdout.write(chalk.bold(`\n  ${agent.displayName} (${agent.name})\n`) + chalk.dim(`  State: ${agent.state}  ·  Memory: ${agent.memory.shortTerm.length} msgs\n\n`)); handled = true; }
+    if (cmdLower === "/cost") { process.stdout.write(chalk.bold(`\n  Total: ${formatCost(ctx.llm.getTotalCost())}\n\n`)); handled = true; }
+    if (cmdLower === "/cost reset") { (ctx.llm as any).resetUsageStats?.(); process.stdout.write(chalk.dim("  Reset\n\n")); handled = true; }
+    if (cmdLower === "/compact") { const r = await agent.compact(); process.stdout.write(chalk.green(`  ✓ ${r}\n\n`)); handled = true; }
+    if (cmdLower === "/memory") { process.stdout.write(chalk.dim(`  Short-term: ${agent.memory.shortTerm.length} msgs  ·  Working: ${Object.keys(agent.memory.working).length} keys\n\n`)); handled = true; }
+    if (cmdLower === "/workspace") { process.stdout.write(chalk.dim(`  ${ctx.workspacePath || "default"}\n\n`)); handled = true; }
+    if (cmdLower === "/mcp") { process.stdout.write(chalk.dim(`  ${ctx.mcpStatus?.join(", ") || "none"}\n\n`)); handled = true; }
+    if (cmdLower === "/sessions") { const ss = await agent.memory.listSessions(); if (ss.length) { for (const s of ss.slice(0, 10)) process.stdout.write(chalk.dim(`  ${s.id?.slice(0, 10)}... ${s.preview || ""} (${s.messageCount || 0} msgs)\n`)); } else process.stdout.write(chalk.dim("  No saved sessions\n")); process.stdout.write("\n"); handled = true; }
+    if (cmdLower.startsWith("/model")) { process.stdout.write(chalk.dim("  Configure in ~/.skyloom/config.yaml\n\n")); handled = true; }
+
+    if (handled) continue;
+
+    // Task orchestration
+    if (cmdLower.startsWith("/task ")) { const g = inp.slice(6).trim(); if (g) { process.stdout.write(chalk.cyan(`\n  ✦ ${g}\n\n`)); await runTask(g); } continue; }
+
+    // Unknown slash → help
+    if (inp.startsWith("/")) { process.stdout.write(helpText()); continue; }
+
+    // ── Chat ──
+    process.stdout.write(chalk.dim(`  ${agent.displayName} thinking...\r`));
 
-    const cls = classify(cmd);
-    if (cls === "orchestrate" && mode !== InteractiveMode.AUTO) {
-      await runTask(cmd); logLine(""); continue;
-    }
-
-    /* ── Chat ── */
     try {
-      const response = await chatWithSpinner(agent, ctx, cmd);
-      logLine("");
-      for (const line of renderResponse(response)) {
-        logLine(line);
-      }
-      logLine("");
+      const response = await agent.chat(inp);
+      process.stdout.write("\r" + " ".repeat(40) + "\r");
+      for (const l of render(response)) process.stdout.write(l + "\n");
+      process.stdout.write("\n");
+      // Status bar
+      process.stdout.write("  " + statusBar(agent, ctx) + "\n");
+    } catch (e) {
+      process.stdout.write(chalk.red(`\n  ✗ ${(e as Error).message || e}\n\n`));
+    }
 
-      // Auto-continue
-      if (mode === InteractiveMode.AUTO) {
-        const tail = response.split("\n").slice(-6).join("\n");
-        if (/(?:接下来|下一步|继续|next|let me|I'[vl]l)/i.test(tail) && !/(?:完成了|全部完成|all done)/i.test(tail)) {
-          logLine(chalk.yellow("  [auto-continue]\n"));
-          try {
-            const r2 = await chatWithSpinner(agent, ctx, "请继续完成");
-            logLine("");
-            for (const line of renderResponse(r2)) logLine(line);
-            logLine("");
-          } catch { /* ignore */ }
-        }
+    // Auto-continue
+    if (MODE.current === InteractiveMode.AUTO && agent.memory.shortTerm.length) {
+      const last = agent.memory.shortTerm[agent.memory.shortTerm.length - 1];
+      if (last?.content && /(?:接下来|下一步|继续|next|let me|I'[vl]l)/i.test(last.content.split("\n").slice(-4).join("\n"))) {
+        process.stdout.write(chalk.yellow("  [auto]\n"));
+        try {
+          const r2 = await agent.chat("请继续完成");
+          process.stdout.write("\n");
+          for (const l of render(r2)) process.stdout.write(l + "\n");
+          process.stdout.write("\n");
+        } catch { /* ignore */ }
       }
-    } catch (e) {
-      logLine(chalk.red(`\n  ✗ Error: ${(e as Error).message || e}\n`));
     }
   }
 
-  logLine(chalk.dim("\n  Session ended"));
+  process.stdout.write(chalk.dim("\n  Session ended\n"));
   await ctx.closeAll();
   process.exit(0);
 }
 
 /* ═══════════════════════════════════════
-   Task execution
+   Task
    ═══════════════════════════════════════ */
-async function runTask(goal: string, resume?: boolean): Promise<void> {
+async function runTask(goal: string): Promise<void> {
   const ctx = createSystemContext();
   await ctx.initAll();
-  const [, results, summary] = await orchestrateTask(goal, ctx.agentMap, null, {
-    resultTruncate: 500, maxTaskRetries: 3, maxReplanRounds: 1, resume,
-  });
-
-  logLine(chalk.bold("\n  Task Results"));
-  logLine(chalk.dim("  ─".repeat(30)));
-  for (const r of results) {
-    logLine(`  ${r.success ? chalk.green("✓") : chalk.red("✗")} ${chalk.cyan(r.agent)}: ${r.description.slice(0, 60)}`);
-  }
-  logLine(chalk.bold("\n  Summary"));
-  logLine(chalk.dim("  ─".repeat(30)));
-  logLine(`  ${summary.slice(0, 1000)}`);
-  logLine("");
+  const [, results, summary] = await orchestrateTask(goal, ctx.agentMap);
+  for (const r of results) process.stdout.write(`  ${r.success ? chalk.green("✓") : chalk.red("✗")} ${chalk.cyan(r.agent)}: ${r.description.slice(0, 60)}\n`);
+  process.stdout.write(chalk.bold("\n  " + summary.slice(0, 800) + "\n\n"));
   await ctx.closeAll();
 }
 
-function printHelp() {
-  logLine(chalk.bold("\n  Slash Commands"));
-  logLine(chalk.dim("  ─".repeat(40)));
+function helpText(): string {
   const groups: [string, [string, string][]][] = [
     ["Agent", [["/fog /rain /frost", "Switch agents"], ["/snow /dew /fair", "Switch agents"]]],
-    ["Chat", [["/help", "Show commands"], ["/clear", "Clear screen"], ["/compact", "Compress context"], ["/retry", "Resend last msg"], ["/quit", "Exit"]]],
-    ["Info", [["/status", "Agent status"], ["/cost", "Usage & cost"], ["/memory", "Memory stats"], ["/sessions", "Session list"], ["/workspace", "Workspace info"], ["/version", "Version"]]],
-    ["Orch.", [["/task <goal>", "Multi-agent task"]]],
+    ["Chat", [["/help", "Commands"], ["/clear", "Clear"], ["/compact", "Compress"], ["/retry", "Resend"]]],
+    ["Info", [["/status", "Status"], ["/cost", "Cost"], ["/memory", "Memory"], ["/sessions", "Sessions"], ["/workspace", "Workspace"], ["/version", "Version"]]],
+    ["Orch.", [["/task <goal>", "Multi-agent"]]],
   ];
+  let s = "";
   for (const [title, cmds] of groups) {
-    logLine(chalk.cyan(`  ${title}`));
-    for (const [c, d] of cmds) logLine(`    ${chalk.cyan(c.padEnd(18))}${chalk.dim(d)}`);
+    s += chalk.cyan(`  ${title}\n`);
+    for (const [c, d] of cmds) s += `    ${chalk.cyan(c.padEnd(18))}${chalk.dim(d)}\n`;
   }
-  logLine("");
+  s += "\n";
+  return s;
 }
 
 /* ═══════════════════════════════════════
@@ -586,14 +267,11 @@ async function main() {
   if (args.length === 0) { await chat("fog"); return; }
   if ((AGENT_NAMES as readonly string[]).includes(args[0])) {
     let m: string | undefined;
-    for (let i = 1; i < args.length; i++) {
-      if ((args[i] === "-m" || args[i] === "--model") && i + 1 < args.length) m = args[++i];
-    }
+    for (let i = 1; i < args.length; i++) if ((args[i] === "-m" || args[i] === "--model") && i + 1 < args.length) m = args[++i];
     await chat(args[0], m); return;
   }
-  const subCmds = ["chat", "task", "web", "config", "init", "version", "mcp", "help"];
-  if (!subCmds.includes(args[0]) && !args[0].startsWith("-")) { await chat("fog"); return; }
+  if (!["chat", "task", "web", "config", "init", "version", "mcp", "help"].includes(args[0]) && !args[0].startsWith("-")) { await chat("fog"); return; }
   program.parse(process.argv);
 }
 
-main().catch(e => { logLine(chalk.red(`Fatal: ${(e as Error).message}`)); process.exit(1); });
+main().catch(e => { process.stderr.write(chalk.red(`Fatal: ${(e as Error).message}\n`)); process.exit(1); });

package/src/core/llm.ts

@@ -662,63 +662,129 @@ export class LLMClient {
   }
 
   /**
-   * Complete with retry logic (placeholder).
+   * Complete with retry logic — real HTTP call to LLM API.
    */
   private async completeWithRetry(
     model: string,
-    _messages: Record<string, unknown>[],
-    _agentName?: string,
-    _tools?: string[],
-    _stream: boolean = false,
+    messages: Record<string, unknown>[],
+    agentName?: string,
+    tools?: string[],
+    stream: boolean = false,
     overrides?: Record<string, unknown>
   ): Promise<LLMResponse> {
-    // This is a placeholder. Real implementation would:
-    // 1. Validate cache
-    // 2. Call actual LLM API (OpenAI, Anthropic, etc.)
-    // 3. Apply Anthropic cache control if needed
-    // 4. Handle retry logic with exponential backoff
-    // 5. Track usage and cost
-    // 6. Cache results if appropriate
-
-    const _temperature = (overrides?.temperature as number) ?? 0.7;
-    const _maxTokens = (overrides?.maxTokens as number) ?? 2000;
-
-    // For now, return a dummy response
-    return {
-      content: "Placeholder response from LLM",
-      toolCalls: [],
-      model,
-      usage: { promptTokens: 100, completionTokens: 50 },
-      cost: estimateCost(model, 100, 50),
-      truncated: false,
-    };
+    const temperature = (overrides?.temperature as number) ?? 0.7;
+    const maxTokens = (overrides?.maxTokens as number) ?? 4096;
+    const maxRetries = (this.config.llm as any)?.maxRetries ?? 2;
+    const isAnthropic = model.includes("claude") || model.startsWith("anthropic/");
+
+    let lastError: Error | null = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        if (attempt > 0) await new Promise(r => setTimeout(r, 1000 * Math.pow(2, attempt - 1)));
+
+        let content: string;
+        let toolCalls: ToolCall[] = [];
+        let usage: UsageStats = { promptTokens: 0, completionTokens: 0 };
+
+        if (isAnthropic) {
+          const r = await this.callAnthropic(model, messages, tools, temperature, maxTokens);
+          content = r.content; toolCalls = r.toolCalls; usage = r.usage;
+        } else {
+          const r = await this.callOpenAI(model, messages, tools, temperature, maxTokens);
+          content = r.content; toolCalls = r.toolCalls; usage = r.usage;
+        }
+
+        const name = agentName || "default";
+        if (!this.usageStats.has(name)) this.usageStats.set(name, { prompt_tokens: 0, completion_tokens: 0, calls: 0, cost: 0 });
+        const s = this.usageStats.get(name)!;
+        s.prompt_tokens += usage.promptTokens; s.completion_tokens += usage.completionTokens; s.calls += 1;
+        const cost = estimateCost(model, usage.promptTokens, usage.completionTokens);
+        s.cost += cost; this.totalCost += cost;
+
+        return { content, toolCalls, model, usage, cost, truncated: false };
+      } catch (e: any) {
+        lastError = e;
+        if (attempt >= maxRetries) throw e;
+      }
+    }
+    throw lastError || new Error("Unknown error");
+  }
+
+  private async callOpenAI(
+    m: string, messages: Record<string, unknown>[], tools?: string[], temp?: number, maxTok?: number
+  ): Promise<{ content: string; toolCalls: ToolCall[]; usage: UsageStats }> {
+    const apiKey = this.getApiKey(m);
+    const baseUrl = this.getBaseUrl(m);
+    const body: Record<string, unknown> = { model: m, messages, temperature: temp ?? 0.7, max_tokens: maxTok ?? 4096 };
+    if (tools?.length) {
+      const defs = tools.map(t => this._toolRegistry.get(t)).filter(Boolean) as any[];
+      if (defs.length) body.tools = defs.map(t => ({ type: "function", function: { name: t.name, description: t.description, parameters: this.paramsToSchema(t.parameters || []) } }));
+    }
+    const resp = await fetch(baseUrl + "/chat/completions", { method: "POST", headers: { "Content-Type": "application/json", Authorization: "Bearer " + apiKey }, body: JSON.stringify(body) });
+    if (!resp.ok) { const e: any = new Error("API " + resp.status + ": " + ((await resp.text()).slice(0, 200))); e.status_code = resp.status; throw e; }
+    const data: any = await resp.json();
+    const msg = data.choices?.[0]?.message || {};
+    return { content: msg.content || "", toolCalls: (msg.tool_calls || []).map((tc: any) => ({ id: tc.id, type: "function", function: { name: tc.function?.name || "", arguments: tc.function?.arguments || "{}" } })), usage: { promptTokens: data.usage?.prompt_tokens || 0, completionTokens: data.usage?.completion_tokens || 0 } };
+  }
+
+  private async callAnthropic(
+    m: string, messages: Record<string, unknown>[], tools?: string[], temp?: number, maxTok?: number
+  ): Promise<{ content: string; toolCalls: ToolCall[]; usage: UsageStats }> {
+    const apiKey = this.getApiKey("anthropic");
+    const body: Record<string, unknown> = { model: m, max_tokens: maxTok ?? 4096, messages: messages.filter(msg => msg.role !== "system"), temperature: temp ?? 0.7 };
+    const sys = messages.find(msg => msg.role === "system"); if (sys) body.system = sys.content;
+    if (tools?.length) {
+      const defs = tools.map(t => this._toolRegistry.get(t)).filter(Boolean) as any[];
+      if (defs.length) body.tools = defs.map(t => ({ name: t.name, description: t.description, input_schema: this.paramsToSchema(t.parameters || []) }));
+    }
+    const resp = await fetch("https://api.anthropic.com/v1/messages", { method: "POST", headers: { "Content-Type": "application/json", "x-api-key": apiKey, "anthropic-version": "2023-06-01" }, body: JSON.stringify(body) });
+    if (!resp.ok) { const e: any = new Error("API " + resp.status + ": " + ((await resp.text()).slice(0, 200))); e.status_code = resp.status; throw e; }
+    const data: any = await resp.json(); let content = ""; const toolCalls: ToolCall[] = [];
+    for (const b of data.content || []) { if (b.type === "text") content += b.text; if (b.type === "tool_use") toolCalls.push({ id: b.id, type: "function", function: { name: b.name, arguments: JSON.stringify(b.input) } }); }
+    return { content, toolCalls, usage: { promptTokens: data.usage?.input_tokens || 0, completionTokens: data.usage?.output_tokens || 0 } };
+  }
+
+  private paramsToSchema(params: any[]): Record<string, any> {
+    const props: Record<string, any> = {};
+    for (const p of params) props[p.name] = { type: p.type === "integer" ? "integer" : p.type === "number" ? "number" : p.type === "boolean" ? "boolean" : "string", description: p.description };
+    const required = params.filter(p => p.required).map(p => p.name);
+    return { type: "object", properties: props, ...(required.length > 0 ? { required } : {}) };
+  }
+
+  private getApiKey(model: string): string {
+    let provider = "openai"; const [pr] = splitProvider(model); if (pr) provider = pr;
+    else { const l = model.toLowerCase(); if (l.includes("claude")) provider = "anthropic"; else if (l.includes("deepseek")) provider = "deepseek"; else if (l.includes("groq")) provider = "groq"; else if (l.includes("openrouter")) provider = "openrouter"; else if (l.includes("gemini")) provider = "gemini"; }
+    const envMap = getProviderEnvMap();
+    const envVar = envMap.get(provider) || (provider.toUpperCase() + "_API_KEY");
+    const key = process.env[envVar];
+    if (!key) throw new Error("Missing " + envVar + ". Set environment variable or configure in ~/.skyloom/config.yaml");
+    return key;
+  }
+
+  private getBaseUrl(model: string): string {
+    let provider = "openai"; const [pr] = splitProvider(model); if (pr) provider = pr;
+    else { const l = model.toLowerCase(); if (l.includes("claude")) return "https://api.anthropic.com/v1"; else if (l.includes("deepseek")) return "https://api.deepseek.com/v1"; else if (l.includes("groq")) return "https://api.groq.com/openai/v1"; else if (l.includes("openrouter")) return "https://openrouter.ai/api/v1"; else if (l.includes("ollama")) return ((process.env.OLLAMA_HOST || "http://localhost:11434") + "/v1"); }
+    if (provider === "deepseek") return "https://api.deepseek.com/v1";
+    if (provider === "groq") return "https://api.groq.com/openai/v1";
+    if (provider === "openrouter") return "https://openrouter.ai/api/v1";
+    if (provider === "ollama") return ((process.env.OLLAMA_HOST || "http://localhost:11434") + "/v1");
+    return "https://api.openai.com/v1";
   }
 
-  /**
-   * Stream a completion (placeholder).
-   */
   async *stream(
-    _messages: Record<string, unknown>[],
-    _agentName?: string
+    messages: Record<string, unknown>[], agentName?: string
   ): AsyncGenerator<string> {
-    // Placeholder implementation
-    yield "Streaming response...";
+    const response = await this.complete(messages, agentName);
+    yield response.content;
   }
 
-  /**
-   * Stream completion with tool awareness (placeholder).
-   */
   async *streamWithTools(
-    _messages: Record<string, unknown>[],
-    _agentName?: string,
-    _tools?: string[],
-    _toolRegistry?: ToolRegistry,
-    _overrides?: Record<string, unknown>
+    messages: Record<string, unknown>[], agentName?: string, tools?: string[],
+    _toolRegistry?: ToolRegistry, overrides?: Record<string, unknown>
   ): AsyncGenerator<StreamEvent> {
-    // Placeholder implementation
-    yield {
-      type: "content",
-      text: "Tool-aware streaming response...",
-    };
+    const response = await this.complete(messages, agentName, tools, false, overrides);
+    if (response.content) yield { type: "content", text: response.content };
+    for (const tc of response.toolCalls || []) yield { type: "tool_call", toolCall: tc };
+    yield { type: "done", usage: response.usage, reasoningContent: response.reasoningContent };
   }
 }