skyloom 1.12.0 → 1.13.0

package/src/core/index.ts

@@ -1,37 +1,37 @@
-/**
- * Skyloom Core Module Exports
- */
-
-export * from './constants';
-export * from './schemas';
-export * from './logger';
-export * from './config';
-export * from './tool';
-export * from './circuit_breaker';
-export * from './bus';
-export * from './cache';
-export * from './memory';
-export * from './middleware';
-export * from './llm';
-export * from './mcp';
-export { matchPipeline, buildTasksFromPipeline, listPipelines, getPipelineByName, matchAllPipelines, validateDAG, topologicalSort, type Pipeline, type PipelineStep } from './pipelines';
-export * from './semantic';
-export * from './icons';
-export * from './checkpoint';
-export * from './workspace';
-export * from './profile';
-export * from './tool_router';
-export * from './agent_helpers';
-export * from './skill';
-export * from './router';
-export * from './agent';
-export * from './factory';
-export * from './security';
-export * from './learn';
-export * from './longdoc';
-export * from './filter';
-export * from './estimate';
-export * from './arbitrate';
-
-// Version — read from package.json
-export const VERSION = (() => { try { return require('../../package.json').version; } catch { return '1.6.0'; } })();
+/**
+ * Skyloom Core Module Exports
+ */
+
+export * from './constants';
+export * from './schemas';
+export * from './logger';
+export * from './config';
+export * from './tool';
+export * from './circuit_breaker';
+export * from './bus';
+export * from './cache';
+export * from './memory';
+export * from './middleware';
+export * from './llm';
+export * from './mcp';
+export { matchPipeline, buildTasksFromPipeline, listPipelines, getPipelineByName, matchAllPipelines, validateDAG, topologicalSort, type Pipeline, type PipelineStep } from './pipelines';
+export * from './semantic';
+export * from './icons';
+export * from './checkpoint';
+export * from './workspace';
+export * from './profile';
+export * from './tool_router';
+export * from './agent_helpers';
+export * from './skill';
+export * from './router';
+export * from './agent';
+export * from './factory';
+export * from './security';
+export * from './learn';
+export * from './longdoc';
+export * from './filter';
+export * from './estimate';
+export * from './arbitrate';
+
+// Version — read from package.json
+export const VERSION = (() => { try { return require('../../package.json').version; } catch { return '1.6.0'; } })();

package/src/core/learn.ts

@@ -1,146 +1,146 @@
-/**
- * 持续学习模块 — post-task review + experience recording.
- *
- * After each task, the agent writes a structured review.
- * Failed attempts are indexed for similarity search to avoid repetition.
- */
-
-import * as fs from "fs";
-import * as path from "path";
-import { USER_CONFIG_DIR } from "./config";
-import { getLogger } from "./logger";
-
-const log = getLogger("learn");
-
-/* ── Data types ── */
-export interface TaskReview {
-  ts: string;
-  agent: string;
-  goal: string;
-  success: boolean;
-  durationMs: number;
-  toolCalls: string[];
-  errorMsg?: string;
-  rootCause?: string;
-  improvement?: string;
-}
-
-export interface ExperienceEntry {
-  id: string;
-  pattern: string;       // What went wrong (key for similarity search)
-  solution: string;      // What fixed it
-  frequency: number;     // How often this pattern repeats
-  lastSeen: string;
-}
-
-/* ── Persistence ── */
-const reviewDir = path.join(USER_CONFIG_DIR, "reviews");
-const expFile = path.join(USER_CONFIG_DIR, "experiences.json");
-const reviewDir_ = reviewDir; // for closure
-
-function ensureDir() { if (!fs.existsSync(reviewDir_)) fs.mkdirSync(reviewDir_, { recursive: true }); }
-
-/* ═══════════════════════════════════════
-   Task Review Recording
-   ═══════════════════════════════════════ */
-export function recordReview(review: TaskReview): void {
-  ensureDir();
-  const file = path.join(reviewDir_, `${review.ts.slice(0, 10)}_${review.agent}.jsonl`);
-  const line = JSON.stringify(review);
-  fs.appendFileSync(file, line + "\n");
-  log.debug("review_recorded", { agent: review.agent, success: review.success });
-
-  // If failed, also record as experience
-  if (!review.success && review.errorMsg) {
-    recordExperience(review.errorMsg, review.rootCause || "unknown", review.improvement || "no improvement noted");
-  }
-}
-
-/* ═══════════════════════════════════════
-   Experience Recording (for failure patterns)
-   ═══════════════════════════════════════ */
-function loadExperiences(): ExperienceEntry[] {
-  try {
-    if (fs.existsSync(expFile)) return JSON.parse(fs.readFileSync(expFile, "utf-8"));
-  } catch { /* ignore */ }
-  return [];
-}
-
-function saveExperiences(entries: ExperienceEntry[]): void {
-  ensureDir();
-  fs.writeFileSync(expFile, JSON.stringify(entries, null, 2), "utf-8");
-}
-
-export function recordExperience(errorPattern: string, rootCause: string, solution: string): void {
-  const entries = loadExperiences();
-  const normalized = errorPattern.toLowerCase().slice(0, 200);
-
-  // Check for existing similar pattern (simple substring match)
-  const existing = entries.find(e => e.pattern.toLowerCase().includes(normalized.slice(0, 50)) || normalized.includes(e.pattern.toLowerCase().slice(0, 50)));
-  if (existing) {
-    existing.frequency++;
-    existing.lastSeen = new Date().toISOString();
-    if (solution && solution !== "no improvement noted") existing.solution = solution;
-  } else {
-    entries.push({
-      id: Math.random().toString(36).slice(2, 10),
-      pattern: errorPattern.slice(0, 200),
-      solution,
-      frequency: 1,
-      lastSeen: new Date().toISOString(),
-    });
-  }
-
-  // Keep top 100 experiences, sorted by frequency
-  entries.sort((a, b) => b.frequency - a.frequency);
-  if (entries.length > 100) entries.splice(100);
-  saveExperiences(entries);
-}
-
-/* ═══════════════════════════════════════
-   Query experiences
-   ═══════════════════════════════════════ */
-export function queryExperiences(problem: string, limit: number = 3): ExperienceEntry[] {
-  const entries = loadExperiences();
-  const lower = problem.toLowerCase();
-  return entries
-    .filter(e => {
-      const plow = e.pattern.toLowerCase();
-      // Simple token overlap scoring
-      const tokens = lower.split(/\s+/).filter(t => t.length > 2);
-      const matches = tokens.filter(t => plow.includes(t));
-      return matches.length >= 2;
-    })
-    .sort((a, b) => b.frequency - a.frequency)
-    .slice(0, limit);
-}
-
-/* ═══════════════════════════════════════
-   Format experiences for system prompt injection
-   ═══════════════════════════════════════ */
-export function formatExperiencesForPrompt(problem: string): string {
-  const exps = queryExperiences(problem);
-  if (!exps.length) return "";
-  const lines = ["## 历史教训（从经验库检索）", "以下是与当前任务相关的过往失败案例，请避免重复："];
-  for (const e of exps) {
-    lines.push(`- **模式**: ${e.pattern.slice(0, 120)}`);
-    lines.push(`  **解决**: ${e.solution.slice(0, 200)} (出现 ${e.frequency} 次)`);
-  }
-  return lines.join("\n");
-}
-
-/* ═══════════════════════════════════════
-   Generate a structured review after task completion
-   ═══════════════════════════════════════ */
-export function generateReview(
-  agent: string, goal: string, success: boolean, durationMs: number,
-  toolCalls: string[], errorMsg?: string
-): TaskReview {
-  return {
-    ts: new Date().toISOString(),
-    agent, goal, success, durationMs, toolCalls,
-    errorMsg,
-    rootCause: errorMsg ? "auto-detected failure" : undefined,
-    improvement: errorMsg ? "review error and adjust approach" : undefined,
-  };
-}
+/**
+ * 持续学习模块 — post-task review + experience recording.
+ *
+ * After each task, the agent writes a structured review.
+ * Failed attempts are indexed for similarity search to avoid repetition.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { USER_CONFIG_DIR } from "./config";
+import { getLogger } from "./logger";
+
+const log = getLogger("learn");
+
+/* ── Data types ── */
+export interface TaskReview {
+  ts: string;
+  agent: string;
+  goal: string;
+  success: boolean;
+  durationMs: number;
+  toolCalls: string[];
+  errorMsg?: string;
+  rootCause?: string;
+  improvement?: string;
+}
+
+export interface ExperienceEntry {
+  id: string;
+  pattern: string;       // What went wrong (key for similarity search)
+  solution: string;      // What fixed it
+  frequency: number;     // How often this pattern repeats
+  lastSeen: string;
+}
+
+/* ── Persistence ── */
+const reviewDir = path.join(USER_CONFIG_DIR, "reviews");
+const expFile = path.join(USER_CONFIG_DIR, "experiences.json");
+const reviewDir_ = reviewDir; // for closure
+
+function ensureDir() { if (!fs.existsSync(reviewDir_)) fs.mkdirSync(reviewDir_, { recursive: true }); }
+
+/* ═══════════════════════════════════════
+   Task Review Recording
+   ═══════════════════════════════════════ */
+export function recordReview(review: TaskReview): void {
+  ensureDir();
+  const file = path.join(reviewDir_, `${review.ts.slice(0, 10)}_${review.agent}.jsonl`);
+  const line = JSON.stringify(review);
+  fs.appendFileSync(file, line + "\n");
+  log.debug("review_recorded", { agent: review.agent, success: review.success });
+
+  // If failed, also record as experience
+  if (!review.success && review.errorMsg) {
+    recordExperience(review.errorMsg, review.rootCause || "unknown", review.improvement || "no improvement noted");
+  }
+}
+
+/* ═══════════════════════════════════════
+   Experience Recording (for failure patterns)
+   ═══════════════════════════════════════ */
+function loadExperiences(): ExperienceEntry[] {
+  try {
+    if (fs.existsSync(expFile)) return JSON.parse(fs.readFileSync(expFile, "utf-8"));
+  } catch { /* ignore */ }
+  return [];
+}
+
+function saveExperiences(entries: ExperienceEntry[]): void {
+  ensureDir();
+  fs.writeFileSync(expFile, JSON.stringify(entries, null, 2), "utf-8");
+}
+
+export function recordExperience(errorPattern: string, rootCause: string, solution: string): void {
+  const entries = loadExperiences();
+  const normalized = errorPattern.toLowerCase().slice(0, 200);
+
+  // Check for existing similar pattern (simple substring match)
+  const existing = entries.find(e => e.pattern.toLowerCase().includes(normalized.slice(0, 50)) || normalized.includes(e.pattern.toLowerCase().slice(0, 50)));
+  if (existing) {
+    existing.frequency++;
+    existing.lastSeen = new Date().toISOString();
+    if (solution && solution !== "no improvement noted") existing.solution = solution;
+  } else {
+    entries.push({
+      id: Math.random().toString(36).slice(2, 10),
+      pattern: errorPattern.slice(0, 200),
+      solution,
+      frequency: 1,
+      lastSeen: new Date().toISOString(),
+    });
+  }
+
+  // Keep top 100 experiences, sorted by frequency
+  entries.sort((a, b) => b.frequency - a.frequency);
+  if (entries.length > 100) entries.splice(100);
+  saveExperiences(entries);
+}
+
+/* ═══════════════════════════════════════
+   Query experiences
+   ═══════════════════════════════════════ */
+export function queryExperiences(problem: string, limit: number = 3): ExperienceEntry[] {
+  const entries = loadExperiences();
+  const lower = problem.toLowerCase();
+  return entries
+    .filter(e => {
+      const plow = e.pattern.toLowerCase();
+      // Simple token overlap scoring
+      const tokens = lower.split(/\s+/).filter(t => t.length > 2);
+      const matches = tokens.filter(t => plow.includes(t));
+      return matches.length >= 2;
+    })
+    .sort((a, b) => b.frequency - a.frequency)
+    .slice(0, limit);
+}
+
+/* ═══════════════════════════════════════
+   Format experiences for system prompt injection
+   ═══════════════════════════════════════ */
+export function formatExperiencesForPrompt(problem: string): string {
+  const exps = queryExperiences(problem);
+  if (!exps.length) return "";
+  const lines = ["## 历史教训（从经验库检索）", "以下是与当前任务相关的过往失败案例，请避免重复："];
+  for (const e of exps) {
+    lines.push(`- **模式**: ${e.pattern.slice(0, 120)}`);
+    lines.push(`  **解决**: ${e.solution.slice(0, 200)} (出现 ${e.frequency} 次)`);
+  }
+  return lines.join("\n");
+}
+
+/* ═══════════════════════════════════════
+   Generate a structured review after task completion
+   ═══════════════════════════════════════ */
+export function generateReview(
+  agent: string, goal: string, success: boolean, durationMs: number,
+  toolCalls: string[], errorMsg?: string
+): TaskReview {
+  return {
+    ts: new Date().toISOString(),
+    agent, goal, success, durationMs, toolCalls,
+    errorMsg,
+    rootCause: errorMsg ? "auto-detected failure" : undefined,
+    improvement: errorMsg ? "review error and adjust approach" : undefined,
+  };
+}

package/src/core/llm.ts

@@ -499,7 +499,10 @@ export class LLMClient {
         return String(agentCfg.model);
       }
     }
-    return this.config.llm?.defaultModel || "gpt-4o";
+    // Honor the user's configured default (set by the /setup wizard). YAML uses
+    // snake_case; the legacy camelCase read is kept as a last resort.
+    const c: any = this.config;
+    return c.default_model || c.llm?.default_model || c.llm?.defaultModel || "gpt-4o";
   }
 
   /**
@@ -792,13 +795,113 @@ export class LLMClient {
     yield response.content;
   }
 
+  /**
+   * Real SSE token streaming for OpenAI-compatible providers (openai, deepseek,
+   * groq, openrouter, mistral, xai, ollama). Content + reasoning deltas are
+   * yielded as they arrive; tool-call deltas are accumulated by index and
+   * emitted once complete. Usage comes from the final `stream_options` chunk.
+   */
+  private async *callOpenAIStream(
+    m: string, messages: Record<string, unknown>[], tools?: string[], temp?: number, maxTok?: number
+  ): AsyncGenerator<StreamEvent> {
+    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,
+      stream: true, stream_options: { include_usage: true },
+    };
+    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 || !resp.body) { const e: any = new Error("API " + resp.status + ": " + ((await resp.text()).slice(0, 200))); e.status_code = resp.status; throw e; }
+
+    const reader = (resp.body as any).getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    const toolAcc = new Map<number, { id: string; name: string; args: string }>();
+    let usage: UsageStats = { promptTokens: 0, completionTokens: 0 };
+    let reasoning = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop() || "";
+      for (const line of lines) {
+        const t = line.trim();
+        if (!t.startsWith("data:")) continue;
+        const data = t.slice(5).trim();
+        if (data === "[DONE]") continue;
+        let json: any; try { json = JSON.parse(data); } catch { continue; }
+        if (json.usage) usage = { promptTokens: json.usage.prompt_tokens || 0, completionTokens: json.usage.completion_tokens || 0 };
+        const delta = json.choices?.[0]?.delta;
+        if (!delta) continue;
+        if (delta.content) yield { type: "content", text: delta.content };
+        if (delta.reasoning_content) { reasoning += delta.reasoning_content; yield { type: "reasoning", text: delta.reasoning_content }; }
+        if (Array.isArray(delta.tool_calls)) {
+          for (const tc of delta.tool_calls) {
+            const idx = tc.index ?? 0;
+            const acc = toolAcc.get(idx) || { id: "", name: "", args: "" };
+            if (tc.id) acc.id = tc.id;
+            if (tc.function?.name) acc.name = tc.function.name;
+            if (tc.function?.arguments) acc.args += tc.function.arguments;
+            toolAcc.set(idx, acc);
+          }
+        }
+      }
+    }
+    for (const acc of toolAcc.values()) {
+      if (acc.name) yield { type: "tool_call", toolCall: { id: acc.id || ("call_" + acc.name), type: "function", function: { name: acc.name, arguments: acc.args || "{}" } } };
+    }
+    yield { type: "done", usage, reasoningContent: reasoning || undefined };
+  }
+
   async *streamWithTools(
     messages: Record<string, unknown>[], agentName?: string, tools?: string[],
     _toolRegistry?: ToolRegistry, overrides?: Record<string, unknown>
   ): AsyncGenerator<StreamEvent> {
-    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 };
+    this.checkBudget();
+    const ov = overrides || {};
+    const model: string = typeof ov.model === "string" ? ov.model : this.getModel(agentName);
+    const temperature = (ov.temperature as number) ?? 0.7;
+    const maxTokens = (ov.maxTokens as number) ?? 4096;
+    const isAnthropic = model.includes("claude") || model.startsWith("anthropic/");
+
+    // Blocking fallback used for Anthropic (different wire format) and on
+    // failures before any content has streamed (preserves fallback chain + retry).
+    const blockingFallback = async function* (this: LLMClient): AsyncGenerator<StreamEvent> {
+      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 };
+    }.bind(this);
+
+    if (isAnthropic) { yield* blockingFallback(); return; }
+
+    let started = false;
+    let usage: UsageStats = { promptTokens: 0, completionTokens: 0 };
+    try {
+      for await (const ev of this.callOpenAIStream(model, messages, tools, temperature, maxTokens)) {
+        if (ev.type === "content" || ev.type === "tool_call") started = true;
+        if (ev.type === "done" && ev.usage) usage = ev.usage;
+        yield ev;
+      }
+    } catch (e: any) {
+      if (started) { yield { type: "error", text: String(e?.message || e) }; yield { type: "done", usage }; return; }
+      this.log?.warn("stream_failed_fallback", { model, error: String(e?.message || e) });
+      yield* blockingFallback();
+      return;
+    }
+
+    // Usage + cost bookkeeping (mirrors completeWithRetry).
+    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;
   }
 }