skyloom 1.4.5 → 1.5.1

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.5",
+  "version": "1.5.1",
   "description": "天空织机 Skyloom — 6 weather-themed AI agents: Fog, Rain, Frost, Snow, Dew, Fair",
   "preferGlobal": true,
   "type": "commonjs",

package/src/cli/main.ts

@@ -143,92 +143,73 @@ function render(text: string): string[] {
 /* ═══════════════════════════════════════
    Chat loop
    ═══════════════════════════════════════ */
+/* Check for API key availability */
+function checkApiKeys(): string | null {
+  const keys = ["DEEPSEEK_API_KEY","OPENAI_API_KEY","ANTHROPIC_API_KEY","GROQ_API_KEY","OPENROUTER_API_KEY"];
+  for (const k of keys) { if (process.env[k]) return k; }
+  return null;
+}
+
 async function chat(agentName: string, modelOverride?: string): Promise<void> {
+  const haveKey = checkApiKeys();
+  if (!haveKey) {
+    process.stdout.write("\n" + chalk.yellow("  ⚠ No API key configured.\n"));
+    process.stdout.write(chalk.dim("  Set one:  $env:DEEPSEEK_API_KEY = \"sk-your-key\"  (PowerShell)\n"));
+    process.stdout.write(chalk.dim("            export DEEPSEEK_API_KEY=sk-your-key    (Bash)\n\n"));
+    process.stdout.write(chalk.dim("  Then run: sky\n\n"));
+    process.exit(1);
+  }
+
   const ctx = createSystemContext();
   let agent = ctx.agentMap.get(agentName);
-  if (!agent) { process.stdout.write(chalk.red(`Unknown agent: ${agentName}\n`)); return; }
+  if (!agent) { process.stdout.write(chalk.red("Unknown agent: " + agentName) + "\n"); return; }
   await agent.init();
+  // eslint-disable-next-line prefer-const
+  let currentAgent = agent; // mutable for agent switching
   welcome(agent);
 
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
-  const history: string[] = [];
+  process.stdout.write(chalk.dim("  Key: " + haveKey + "\n\n"));
 
-  for await (const line of rl) {
-    const inp = line.trim();
-    if (!inp) continue;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 
-    if (inp[0] !== "/" && !history.includes(inp)) {
-      history.push(inp);
-      if (history.length > 50) history.shift();
-    }
+  function ask() { rl.question(chalk.cyan("  " + currentAgent.displayName + " ❯ "), handler); }
+  async function handler(inp: string) {
+    inp = inp.trim();
+    if (!inp) { ask(); return; }
 
-    const cmdLower = inp.toLowerCase();
-    let handled = false;
+    const cmdL = inp.toLowerCase();
 
     // Agent switch
     for (const n of AGENT_NAMES) {
-      if (cmdLower === `/${n}`) {
-        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 (cmdL === "/" + n) { const a = ctx.agentMap.get(n); if (a) { await a.init(); currentAgent = a; } process.stdout.write(chalk.dim("  ⟳ " + AGENT_DISPLAY[n] + "\n")); ask(); return; }
     }
 
-    if (handled) continue;
-    if (cmdLower === "/quit" || cmdLower === "/exit") break;
-    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; }
+    if (cmdL === "/quit" || cmdL === "/exit") { process.stdout.write(chalk.dim("\n  Session ended\n")); rl.close(); await ctx.closeAll(); process.exit(0); return; }
+    if (cmdL === "/help") { process.stdout.write(helpText()); ask(); return; }
+    if (cmdL === "/clear") { console.clear(); welcome(agent); process.stdout.write(chalk.dim("  Key: " + haveKey + "\n\n")); ask(); return; }
+    if (cmdL === "/status") { process.stdout.write(chalk.bold("\n  " + currentAgent.displayName + " (" + currentAgent.name + ")\n") + chalk.dim("  State: " + currentAgent.state + "  ·  Memory: " + currentAgent.memory.shortTerm.length + " msgs\n\n")); ask(); return; }
+    if (cmdL === "/cost") { process.stdout.write(chalk.bold("\n  Total: " + formatCost(ctx.llm.getTotalCost()) + "\n\n")); ask(); return; }
+    if (cmdL === "/compact") { const r = await currentAgent.compact(); process.stdout.write(chalk.green("  ✓ " + r + "\n\n")); ask(); return; }
+    if (cmdL === "/version") { process.stdout.write("  Skyloom v" + VERSION + "\n"); ask(); return; }
+    if (cmdL.startsWith("/task ")) { const g = inp.slice(6); process.stdout.write(chalk.cyan("\n  ✦ " + g + "\n\n")); await runTask(g); ask(); return; }
+    if (inp.startsWith("/")) { process.stdout.write(helpText()); ask(); return; }
 
     // ── Chat ──
-    process.stdout.write(chalk.dim(`  ${agent.displayName} thinking...\r`));
-
+    process.stdout.write(chalk.dim("  " + currentAgent.displayName + " thinking...\r"));
     try {
-      const response = await agent.chat(inp);
-      process.stdout.write("\r" + " ".repeat(40) + "\r");
-      for (const l of render(response)) process.stdout.write(l + "\n");
+      const response = await currentAgent.chat(inp);
+      process.stdout.write("\r" + " ".repeat(40) + "\r\n");
+      const lines = render(response);
+      for (const l of lines) 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.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: any) {
+      process.stdout.write("\r" + " ".repeat(40) + "\r");
+      process.stdout.write(chalk.red("  ✗ " + (e.message || e) + "\n\n"));
     }
+    ask();
   }
 
-  process.stdout.write(chalk.dim("\n  Session ended\n"));
-  await ctx.closeAll();
-  process.exit(0);
+  ask();
 }
 
 /* ═══════════════════════════════════════

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 };
   }
 }