skyloom 1.13.2 → 1.13.4

package/src/core/agent.ts

@@ -29,6 +29,7 @@ import {
   SIG_LOOP_HARDSTOP,
 } from './agent_helpers';
 import { selectRelevantTools } from './tool_router';
+import { getModelInfo } from './catalog';
 
 const log = getLogger('agent');
 
@@ -1069,20 +1070,34 @@ export class BaseAgent {
     return `compressed ${toSummarize.length} messages (${summary.length} char digest)`;
   }
 
+  /** Resolve the model id this agent runs on (mirrors LLMClient.getModel). */
+  protected resolveModelId(): string {
+    const c: any = this.config;
+    return c.agents?.[this.name]?.model || c.default_model || c.llm?.default_model || c.llm?.defaultModel || 'gpt-4o';
+  }
+
+  /** The active model's real context window (tokens), from the catalog. */
+  protected contextWindow(): number {
+    const info = getModelInfo(this.resolveModelId());
+    return info?.context && info.context > 0 ? info.context : 128000;
+  }
+
   contextUsage(): Record<string, any> {
     const usage = this.memory.getContextWindowUsage();
+    const max = this.contextWindow();
     return {
       estimatedTokens: usage.estimatedTokens,
-      maxTokens: 128000,
-      pct: Math.min(100, Math.round((usage.estimatedTokens / 128000) * 100)),
+      maxTokens: max,
+      pct: Math.min(100, Math.round((usage.estimatedTokens / max) * 100)),
       messageCount: usage.messageCount,
-      model: (this.config as any).llm?.defaultModel || 'unknown',
+      model: this.resolveModelId(),
     };
   }
 
   protected shouldAutoCompact(): boolean {
     const usage = this.memory.getContextWindowUsage();
-    return (usage.estimatedTokens / 128000) > 0.92;
+    // Compact before hitting the real window — leave ~20% headroom for the reply.
+    return usage.estimatedTokens > this.contextWindow() * 0.8;
   }
 
   protected activeToolNames(): string[] {

package/src/core/memory.ts

@@ -78,6 +78,7 @@ export class Memory {
   private loaded = false;
   private pendingPersists: Set<Promise<void>> = new Set();
   private activeSession: string | null = null;
+  private saveTimer: ReturnType<typeof setTimeout> | null = null;
 
   // short_term is mutated from both main chat loop and handlers
   // All mutations go through a short critical section
@@ -232,6 +233,18 @@ export class Memory {
     }
   }
 
+  /**
+   * Debounced save to disk. sql.js is in-memory, so without this the database
+   * file is never written and sessions / long-term memory would not survive a
+   * restart. Coalesces bursts of writes; the timer is unref'd so it never keeps
+   * the process alive (close() does the final synchronous save).
+   */
+  private scheduleSave(): void {
+    if (!this.db || this.saveTimer) return;
+    this.saveTimer = setTimeout(() => { this.saveTimer = null; this.persistDb(); }, 300);
+    if (typeof (this.saveTimer as any).unref === 'function') (this.saveTimer as any).unref();
+  }
+
   /**
    * Execute a SELECT query and return array of row objects.
    */
@@ -279,6 +292,7 @@ export class Memory {
       // Sql.js rejects `undefined` in bind arrays; normalize to `null`
       const safe = params ? params.map((v) => v === undefined ? null : v) : undefined;
       this.db.run(sql, safe);
+      this.scheduleSave(); // every write goes through here — persist (debounced)
     } catch (err) {
       logger.warn('db_run_failed', { sql: sql.slice(0, 80), error: String(err) });
     }
@@ -477,7 +491,9 @@ export class Memory {
    */
   async close(): Promise<void> {
     if (this.db) {
+      if (this.saveTimer) { clearTimeout(this.saveTimer); this.saveTimer = null; }
       await this.flushPending();
+      this.persistDb(); // final synchronous save to disk
       this.db.close();
     }
   }

package/tests/agent.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from "vitest";
+import { FogAgent } from "../src/agents/fog";
+import { MessageBus } from "../src/core/bus";
+import { ToolRegistry } from "../src/core/tool";
+import { SkillRegistry } from "../src/core/skill";
+
+/**
+ * Characterization tests for the agent chat/tool loop, driven by a scripted
+ * mock LLM (no network). These lock in the behavior of the ~275-line hot path
+ * (chatStreamImpl / llmLoop / tool execution / anti-loop guard) so it can be
+ * refactored safely (Phase 3) — and they guard against regressions like the
+ * first-message crash.
+ */
+
+interface Turn { content?: string; toolCalls?: { name: string; args?: any }[]; reasoning?: string }
+
+class MockLLM {
+  calls = 0;
+  constructor(private turns: Turn[]) {}
+  private turn(): Turn { const t = this.turns[Math.min(this.calls, this.turns.length - 1)]; this.calls++; return t || {}; }
+  private toolCallObjs(t: Turn) {
+    return (t.toolCalls || []).map((tc, i) => ({
+      id: `call_${this.calls}_${i}`, type: "function",
+      function: { name: tc.name, arguments: JSON.stringify(tc.args || {}) },
+    }));
+  }
+  async *streamWithTools(): AsyncGenerator<any> {
+    const t = this.turn();
+    if (t.reasoning) yield { type: "reasoning", text: t.reasoning };
+    if (t.content) yield { type: "content", text: t.content };
+    for (const tc of this.toolCallObjs(t)) yield { type: "tool_call", toolCall: tc };
+    yield { type: "done", usage: { promptTokens: 1, completionTokens: 1 } };
+  }
+  async complete(): Promise<any> {
+    const t = this.turn();
+    return { content: t.content || "", toolCalls: this.toolCallObjs(t), model: "mock", usage: { promptTokens: 1, completionTokens: 1 }, cost: 0, truncated: false };
+  }
+  getTotalCost() { return 0; }
+  getModel() { return "mock"; }
+  setLogger() { /* noop */ }
+}
+
+function makeAgent(turns: Turn[], tools: { name: string; handler: (a: any) => Promise<string> }[] = []) {
+  const reg = new ToolRegistry();
+  for (const t of tools) reg.register({ name: t.name, description: t.name, handler: t.handler });
+  const config = { agents: { fog: {} }, llm: { language: "zh" }, memory: { shortTermLimit: 100, dbPath: "/tmp/sky-test" } };
+  const agent = new FogAgent(config as any, new MockLLM(turns) as any, new MessageBus(), reg, new SkillRegistry());
+  return agent;
+}
+
+async function collect(gen: AsyncGenerator<any>, cap = 500): Promise<any[]> {
+  const evs: any[] = [];
+  for await (const ev of gen) { evs.push(ev); if (evs.length > cap) break; }
+  return evs;
+}
+
+describe("agent · chat loop (mock LLM)", () => {
+  it("streams a simple reply and records both messages", async () => {
+    const agent = makeAgent([{ content: "你好，我是雾。" }]);
+    const evs = await collect(agent.chatStream("你好"));
+    const text = evs.filter((e) => e.type === "content").map((e) => e.text).join("");
+    expect(text).toContain("你好，我是雾。");
+
+    const msgs = agent.memory.getMessages();
+    expect(msgs[0]).toMatchObject({ role: "user", content: "你好" });   // regression: user msg present
+    expect(msgs.some((m) => m.role === "assistant" && String(m.content).includes("雾"))).toBe(true);
+  });
+
+  it("blocking chat() returns the reply", async () => {
+    const agent = makeAgent([{ content: "答案是 42" }]);
+    const reply = await agent.chat("问题？");
+    expect(reply).toContain("42");
+  });
+
+  it("streams reasoning before content", async () => {
+    const agent = makeAgent([{ reasoning: "先想一下…", content: "结论。" }]);
+    const evs = await collect(agent.chatStream("?"));
+    expect(evs.some((e) => e.type === "reasoning")).toBe(true);
+    expect(evs.filter((e) => e.type === "content").map((e) => e.text).join("")).toContain("结论。");
+  });
+
+  it("executes a tool call then produces the final answer", async () => {
+    let received: any = null;
+    const agent = makeAgent(
+      [{ toolCalls: [{ name: "echo", args: { text: "hi" } }] }, { content: "工具回显: hi" }],
+      [{ name: "echo", handler: async (a) => { received = a; return `echo:${a.text}`; } }],
+    );
+    const evs = await collect(agent.chatStream("用 echo 工具"));
+    expect(received).toEqual({ text: "hi" });                       // tool actually ran with parsed args
+    expect(evs.some((e) => e.type === "tool_status" && e.tool_name === "echo")).toBe(true);
+    expect(evs.some((e) => e.type === "tool_done" && e.tool_name === "echo" && e.success)).toBe(true);
+    expect(evs.filter((e) => e.type === "content").map((e) => e.text).join("")).toContain("工具回显");
+    // tool result recorded to memory
+    expect(agent.memory.getMessages().some((m) => m.role === "tool" && String(m.content).includes("echo:hi"))).toBe(true);
+  });
+
+  it("terminates (does not loop forever) when the model repeats the same tool call", async () => {
+    // Script the same tool call far beyond the round cap; the anti-loop guard must stop it.
+    const turns: Turn[] = Array.from({ length: 60 }, () => ({ toolCalls: [{ name: "spin", args: { n: 1 } }] }));
+    const llm = new MockLLM(turns);
+    const reg = new ToolRegistry();
+    reg.register({ name: "spin", description: "spin", handler: async () => "still spinning" });
+    const config = { agents: { fog: {} }, llm: {}, memory: { shortTermLimit: 200, dbPath: "/tmp/sky-test" } };
+    const agent = new FogAgent(config as any, llm as any, new MessageBus(), reg, new SkillRegistry());
+
+    const evs = await collect(agent.chatStream("loop please"), 2000);
+    // It must finish (the generator returns), not hang, and not call the model unboundedly.
+    expect(evs.some((e) => e.type === "done")).toBe(true);
+    expect(llm.calls).toBeLessThan(50); // bounded by the round cap / guard, not 60+
+  }, 15000);
+});
+
+describe("agent · context window (catalog-aware compaction)", () => {
+  it("contextUsage uses the active model's real window from the catalog", () => {
+    const agent = makeAgent([{ content: "x" }]);
+    (agent as any).config.agents.fog.model = "mixtral-8x7b"; // 32768
+    expect(agent.contextUsage().maxTokens).toBe(32768);
+    expect(agent.contextUsage().model).toBe("mixtral-8x7b");
+    (agent as any).config.agents.fog.model = "gemini-2.5-pro"; // 1048576
+    expect(agent.contextUsage().maxTokens).toBe(1048576);
+  });
+
+  it("auto-compaction triggers for a small window but not a large one (same history)", () => {
+    const agent = makeAgent([{ content: "x" }]);
+    const big = "字".repeat(800); // CJK ~2 tokens/char
+    for (let i = 0; i < 20; i++) agent.memory.addMessage("user", big); // ~32k tokens
+
+    (agent as any).config.agents.fog.model = "mixtral-8x7b"; // 32768 window -> over budget
+    expect((agent as any).shouldAutoCompact()).toBe(true);
+
+    (agent as any).config.agents.fog.model = "gemini-2.5-pro"; // 1M window -> fine
+    expect((agent as any).shouldAutoCompact()).toBe(false);
+  });
+});

package/tests/memory.test.ts

@@ -132,6 +132,29 @@ describe("Memory · long-term (SQLite)", () => {
     }
   });
 
+  it("persists sessions + messages to disk and reloads across instances (regression)", async () => {
+    // Previously persistDb() was never called, so nothing survived a restart and
+    // session resume was impossible. close() must save; a fresh instance must reload.
+    const cfg = tmpConfig(); // shared dbPath for both instances
+    const a = new Memory(cfg, "fog");
+    await a.initDb();
+    const sid = await a.createSession("s1");
+    a.addMessage("user", "the sky is blue");
+    a.addMessage("assistant", "noted: sky is blue");
+    await a.remember("fact1", "value1", "auto");
+    await a.close(); // must flush to disk
+
+    const b = new Memory(cfg, "fog");
+    await b.initDb();
+    const sessions = await b.listSessions();
+    expect(sessions.some((s) => s.id === sid)).toBe(true);
+    expect(await b.loadSession(sid)).toBe(true);
+    const msgs = b.getMessages().filter((m) => m.role !== "system");
+    expect(msgs.some((m) => String(m.content).includes("sky is blue"))).toBe(true);
+    expect((await b.recall("fact1"))[0]?.value).toBe("value1"); // long-term memory survived too
+    await b.close();
+  });
+
   it("getMemoryStats returns a populated object", async () => {
     const mem = new Memory(tmpConfig(), "fog");
     await mem.initDb();