skyloom 1.13.5 → 1.13.7

package/tests/agent.test.ts

@@ -1,159 +1,159 @@
-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);
-  });
-});
-
-describe("agent · interrupt (Ctrl-C)", () => {
-  it("stops between rounds on abort and preserves partial output", async () => {
-    const controller = new AbortController();
-    // Round 1 streams some content + a tool call; the tool aborts the signal.
-    // Round 2 must never run.
-    const turns: Turn[] = [
-      { content: "部分内容已生成…", toolCalls: [{ name: "spin", args: {} }] },
-      { content: "不应出现的第二轮" },
-    ];
-    const reg = new ToolRegistry();
-    reg.register({ name: "spin", description: "spin", handler: async () => { controller.abort(); return "spun"; } });
-    const config = { agents: { fog: {} }, llm: {}, memory: { shortTermLimit: 200, dbPath: "/tmp/sky-test" } };
-    const agent = new FogAgent(config as any, new MockLLM(turns) as any, new MessageBus(), reg, new SkillRegistry());
-
-    const evs = await collect(agent.chatStream("go", controller.signal));
-    const text = evs.filter((e) => e.type === "content").map((e) => e.text).join("");
-
-    expect(evs.some((e) => e.type === "interrupted")).toBe(true);
-    expect(text).toContain("部分内容已生成");      // partial output kept
-    expect(text).not.toContain("第二轮");          // round 2 never streamed
-    // partial assistant content is in memory
-    expect(agent.memory.getMessages().some((m) => m.role === "assistant" && String(m.content).includes("部分内容"))).toBe(true);
-  });
-});
+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);
+  });
+});
+
+describe("agent · interrupt (Ctrl-C)", () => {
+  it("stops between rounds on abort and preserves partial output", async () => {
+    const controller = new AbortController();
+    // Round 1 streams some content + a tool call; the tool aborts the signal.
+    // Round 2 must never run.
+    const turns: Turn[] = [
+      { content: "部分内容已生成…", toolCalls: [{ name: "spin", args: {} }] },
+      { content: "不应出现的第二轮" },
+    ];
+    const reg = new ToolRegistry();
+    reg.register({ name: "spin", description: "spin", handler: async () => { controller.abort(); return "spun"; } });
+    const config = { agents: { fog: {} }, llm: {}, memory: { shortTermLimit: 200, dbPath: "/tmp/sky-test" } };
+    const agent = new FogAgent(config as any, new MockLLM(turns) as any, new MessageBus(), reg, new SkillRegistry());
+
+    const evs = await collect(agent.chatStream("go", controller.signal));
+    const text = evs.filter((e) => e.type === "content").map((e) => e.text).join("");
+
+    expect(evs.some((e) => e.type === "interrupted")).toBe(true);
+    expect(text).toContain("部分内容已生成");      // partial output kept
+    expect(text).not.toContain("第二轮");          // round 2 never streamed
+    // partial assistant content is in memory
+    expect(agent.memory.getMessages().some((m) => m.role === "assistant" && String(m.content).includes("部分内容"))).toBe(true);
+  });
+});

package/tests/agent_helpers.test.ts

@@ -1,48 +1,48 @@
-import { describe, it, expect } from "vitest";
-import { parseExtractedFacts, synthesizeDelegationSummary } from "../src/core/agent_helpers";
-
-describe("parseExtractedFacts", () => {
-  it("parses a raw JSON array", () => {
-    const out = parseExtractedFacts('[{"key":"lang","value":"ts"}]');
-    expect(out).toEqual([{ key: "lang", value: "ts" }]);
-  });
-
-  it("parses JSON inside a markdown fence", () => {
-    const out = parseExtractedFacts('```json\n[{"key":"a","value":1}]\n```');
-    expect(out).toEqual([{ key: "a", value: 1 }]);
-  });
-
-  it("extracts a JSON array embedded in prose", () => {
-    const out = parseExtractedFacts('Sure! Here are the facts: [{"key":"x","value":true}] done.');
-    expect(out).toEqual([{ key: "x", value: true }]);
-  });
-
-  it("returns [] for empty or non-JSON input", () => {
-    expect(parseExtractedFacts("")).toEqual([]);
-    expect(parseExtractedFacts("no json here")).toEqual([]);
-    expect(parseExtractedFacts("   ")).toEqual([]);
-  });
-
-  it("returns [] when JSON is an object, not an array", () => {
-    expect(parseExtractedFacts('{"key":"x"}')).toEqual([]);
-  });
-
-  it("filters out non-object array members", () => {
-    const out = parseExtractedFacts('[{"key":"a","value":1}, "junk", 42, null]');
-    // null is typeof 'object' in JS, so it survives the filter — assert the real members
-    expect(out).toContainEqual({ key: "a", value: 1 });
-    expect(out).not.toContain("junk");
-    expect(out).not.toContain(42);
-  });
-});
-
-describe("synthesizeDelegationSummary", () => {
-  it("summarizes successes and failures", () => {
-    expect(synthesizeDelegationSummary([["fog", true], ["rain", false]])).toBe(
-      "[Delegated: fog | Failed: rain]"
-    );
-  });
-  it("returns empty string when no delegations", () => {
-    expect(synthesizeDelegationSummary([])).toBe("");
-  });
-});
+import { describe, it, expect } from "vitest";
+import { parseExtractedFacts, synthesizeDelegationSummary } from "../src/core/agent_helpers";
+
+describe("parseExtractedFacts", () => {
+  it("parses a raw JSON array", () => {
+    const out = parseExtractedFacts('[{"key":"lang","value":"ts"}]');
+    expect(out).toEqual([{ key: "lang", value: "ts" }]);
+  });
+
+  it("parses JSON inside a markdown fence", () => {
+    const out = parseExtractedFacts('```json\n[{"key":"a","value":1}]\n```');
+    expect(out).toEqual([{ key: "a", value: 1 }]);
+  });
+
+  it("extracts a JSON array embedded in prose", () => {
+    const out = parseExtractedFacts('Sure! Here are the facts: [{"key":"x","value":true}] done.');
+    expect(out).toEqual([{ key: "x", value: true }]);
+  });
+
+  it("returns [] for empty or non-JSON input", () => {
+    expect(parseExtractedFacts("")).toEqual([]);
+    expect(parseExtractedFacts("no json here")).toEqual([]);
+    expect(parseExtractedFacts("   ")).toEqual([]);
+  });
+
+  it("returns [] when JSON is an object, not an array", () => {
+    expect(parseExtractedFacts('{"key":"x"}')).toEqual([]);
+  });
+
+  it("filters out non-object array members", () => {
+    const out = parseExtractedFacts('[{"key":"a","value":1}, "junk", 42, null]');
+    // null is typeof 'object' in JS, so it survives the filter — assert the real members
+    expect(out).toContainEqual({ key: "a", value: 1 });
+    expect(out).not.toContain("junk");
+    expect(out).not.toContain(42);
+  });
+});
+
+describe("synthesizeDelegationSummary", () => {
+  it("summarizes successes and failures", () => {
+    expect(synthesizeDelegationSummary([["fog", true], ["rain", false]])).toBe(
+      "[Delegated: fog | Failed: rain]"
+    );
+  });
+  it("returns empty string when no delegations", () => {
+    expect(synthesizeDelegationSummary([])).toBe("");
+  });
+});