@poncho-ai/harness 0.53.0 → 0.57.0

package/test/compaction.test.ts

@@ -0,0 +1,274 @@
+import { describe, expect, it } from "vitest";
+import type { LanguageModel } from "ai";
+import { MockLanguageModelV3 } from "ai/test";
+import type { Message } from "@poncho-ai/sdk";
+import {
+  compactMessages,
+  findSafeSplitPoint,
+  resolveCompactionConfig,
+} from "../src/compaction.js";
+
+// ── Fake model ──────────────────────────────────────────────────────────
+// A MockLanguageModelV3 whose doGenerate returns a fixed text and records the
+// prompt it was handed, so tests can assert what was sent to the summarizer.
+function fakeModel(summaryText: string): {
+  model: LanguageModel;
+  prompts: string[];
+} {
+  const prompts: string[] = [];
+  const model = new MockLanguageModelV3({
+    doGenerate: async (options) => {
+      // Flatten the prompt text we were given (the user message content).
+      for (const m of options.prompt) {
+        if (Array.isArray(m.content)) {
+          for (const part of m.content) {
+            if (part.type === "text") prompts.push(part.text);
+          }
+        }
+      }
+      return {
+        content: [{ type: "text", text: summaryText }],
+        finishReason: "stop",
+        usage: { inputTokens: 10, outputTokens: 10, totalTokens: 20 },
+        warnings: [],
+      };
+    },
+  });
+  return { model: model as unknown as LanguageModel, prompts };
+}
+
+const userMsg = (text: string, metadata?: Message["metadata"]): Message => ({
+  role: "user",
+  content: text,
+  ...(metadata ? { metadata } : {}),
+});
+const assistantText = (text: string): Message => ({
+  role: "assistant",
+  content: text,
+});
+const assistantToolCall = (text: string, toolName: string): Message => ({
+  role: "assistant",
+  content: JSON.stringify({
+    text,
+    tool_calls: [{ id: "call_1", name: toolName, arguments: {} }],
+  }),
+});
+const toolResult = (text: string): Message => ({ role: "tool", content: text });
+
+describe("findSafeSplitPoint", () => {
+  it("splits at a normal user-message boundary", () => {
+    const messages: Message[] = [
+      userMsg("u0"),
+      assistantText("a0"),
+      userMsg("u1"),
+      assistantText("a1"),
+      userMsg("u2"), // index 4 — a clean user boundary
+      assistantText("a2"),
+      userMsg("u3"),
+      assistantText("a3"),
+    ];
+    const idx = findSafeSplitPoint(messages, 4);
+    // candidate = 8 - 4 = 4, which is already a user message → split there.
+    expect(idx).toBe(4);
+    expect(messages[idx]!.role).toBe("user");
+  });
+
+  it("returns -1 when there are too few messages", () => {
+    const messages: Message[] = [userMsg("u0"), assistantText("a0")];
+    expect(findSafeSplitPoint(messages, 4)).toBe(-1);
+  });
+
+  it("walks earlier when the split would orphan tool_calls being moved", () => {
+    // The candidate user boundary sits right after an assistant tool-call
+    // message whose tool result is on the preserved side — splitting there
+    // would strand the tool_calls in the summary. Guard must walk earlier to
+    // the next clean user boundary (which is still >= MIN_COMPACTABLE_MESSAGES).
+    const messages: Message[] = [
+      userMsg("u0"), // 0
+      assistantText("a0"), // 1
+      userMsg("u1"), // 2
+      assistantText("a1"), // 3
+      userMsg("u2"), // 4  <- safe earlier boundary (>= MIN_COMPACTABLE_MESSAGES)
+      assistantText("a2"), // 5
+      assistantToolCall("calling tool", "search"), // 6  <- would be last-compacted if split at 7
+      userMsg("u3 (tool result delivered as user)"), // 7  <- candidate boundary
+      toolResult("result"), // 8
+      assistantText("a3"), // 9
+    ];
+    // candidate = 10 - 3 = 7 (a user message), but messages[6] is an assistant
+    // with tool_calls → orphan. Must walk back to index 4.
+    const idx = findSafeSplitPoint(messages, 3);
+    expect(idx).toBe(4);
+    // Confirm the chosen split does NOT end the compacted side on a dangling
+    // assistant-with-tool_calls.
+    const lastCompacted = messages[idx - 1]!;
+    expect(
+      typeof lastCompacted.content === "string" &&
+        lastCompacted.content.includes('"tool_calls"'),
+    ).toBe(false);
+  });
+});
+
+describe("compactMessages", () => {
+  const config = resolveCompactionConfig({ keepRecentMessages: 2 });
+
+  it("compacts older messages into a summary continuation message", async () => {
+    const { model } = fakeModel("SUMMARY TEXT");
+    const messages: Message[] = [
+      userMsg("u0"),
+      assistantText("a0"),
+      userMsg("u1"),
+      assistantText("a1"),
+      userMsg("u2"),
+      assistantText("a2"),
+    ];
+    const res = await compactMessages(model, messages, config);
+    expect(res.compacted).toBe(true);
+    expect(res.messages[0]!.metadata?.isCompactionSummary).toBe(true);
+    expect(res.messages[0]!.content).toContain("SUMMARY TEXT");
+    // No subagents → no ledger block.
+    expect(res.messages[0]!.content).not.toContain("## Subagents");
+  });
+
+  it("appends a verbatim subagent ledger after the LLM summary", async () => {
+    const { model } = fakeModel("SUMMARY TEXT");
+    const messages: Message[] = [
+      userMsg("u0"),
+      assistantText("a0"),
+      userMsg(
+        '[Subagent Result] Subagent "research the API" (sub_abc) completed:\n\nFound that the endpoint returns JSON with a data array. Use /v2/items.',
+        {
+          _subagentCallback: true,
+          subagentId: "sub_abc",
+          task: "research the API",
+        } as Message["metadata"],
+      ),
+      assistantText("a1"),
+      userMsg("u2"),
+      assistantText("a2"),
+    ];
+    const res = await compactMessages(model, messages, config);
+    expect(res.compacted).toBe(true);
+    const content = res.messages[0]!.content as string;
+    expect(content).toContain("## Subagents");
+    expect(content).toContain("sub_abc");
+    expect(content).toContain("research the API");
+    // Digest carries the verbatim result body.
+    expect(content).toContain("endpoint returns JSON");
+    // Ledger comes AFTER the summary text.
+    expect(content.indexOf("SUMMARY TEXT")).toBeLessThan(
+      content.indexOf("## Subagents"),
+    );
+  });
+
+  it("detects subagent callbacks by text marker even without metadata", async () => {
+    const { model } = fakeModel("S");
+    const messages: Message[] = [
+      userMsg("u0"),
+      assistantText("a0"),
+      userMsg(
+        '[Subagent Result] Subagent "compile report" (sub_xyz) completed:\n\nThe report is ready.',
+      ),
+      assistantText("a1"),
+      userMsg("u2"),
+      assistantText("a2"),
+    ];
+    const res = await compactMessages(model, messages, config);
+    const content = res.messages[0]!.content as string;
+    expect(content).toContain("sub_xyz");
+    expect(content).toContain("compile report");
+  });
+
+  it("carries forward a prior ledger and dedupes by subagentId", async () => {
+    const { model } = fakeModel("NEW SUMMARY");
+    // First compacted message is itself a prior compaction summary that
+    // already embeds a ## Subagents block for sub_abc and sub_old.
+    const priorSummary: Message = {
+      role: "user",
+      content: [
+        "[CONTEXT COMPACTION] prior.",
+        "<summary>",
+        "Earlier work done.",
+        "",
+        "## Subagents",
+        "- **research the API** (sub_abc) — completed",
+        "  Old digest about the API.",
+        "- **legacy task** (sub_old) — completed",
+        "  Legacy digest text.",
+        "</summary>",
+      ].join("\n"),
+      metadata: { isCompactionSummary: true },
+    };
+    const messages: Message[] = [
+      priorSummary,
+      assistantText("a0"),
+      // A fresh callback for sub_abc should OVERRIDE the prior entry.
+      userMsg(
+        '[Subagent Result] Subagent "research the API" (sub_abc) completed:\n\nUpdated finding: the endpoint moved to /v3/items.',
+        {
+          _subagentCallback: true,
+          subagentId: "sub_abc",
+          task: "research the API",
+        } as Message["metadata"],
+      ),
+      assistantText("a1"),
+      userMsg("u2"),
+      assistantText("a2"),
+    ];
+    const res = await compactMessages(model, messages, config);
+    const content = res.messages[0]!.content as string;
+    // Both subagents present.
+    expect(content).toContain("sub_abc");
+    expect(content).toContain("sub_old");
+    // sub_abc appears exactly once (deduped).
+    const occurrences = content.split("sub_abc").length - 1;
+    expect(occurrences).toBe(1);
+    // The newer digest won.
+    expect(content).toContain("/v3/items");
+    expect(content).not.toContain("Old digest about the API");
+  });
+
+  it("passes a prior summary in full (no 1200-char truncation) and adds the merge instruction", async () => {
+    const { model, prompts } = fakeModel("MERGED");
+    const longPrior = "PRIOR-STATE ".repeat(200); // ~2400 chars, > 1200
+    const priorSummary: Message = {
+      role: "user",
+      content: longPrior,
+      metadata: { isCompactionSummary: true },
+    };
+    const messages: Message[] = [
+      priorSummary,
+      assistantText("a0"),
+      userMsg("u1"),
+      assistantText("a1"),
+      userMsg("u2"),
+      assistantText("a2"),
+    ];
+    await compactMessages(model, messages, config);
+    const sentPrompt = prompts.join("\n");
+    // The whole prior summary text was sent, untruncated.
+    expect(sentPrompt).toContain(longPrior.trim());
+    expect(sentPrompt).not.toContain("[truncated]");
+    // Tagged as prior-summary, with the merge-and-update instruction.
+    expect(sentPrompt).toContain("[prior-summary]");
+    expect(sentPrompt).toContain("MERGE AND UPDATE");
+  });
+
+  it("still truncates non-prior-summary long messages to 1200 chars", async () => {
+    const { model, prompts } = fakeModel("S");
+    const longUser = "X".repeat(3000);
+    const messages: Message[] = [
+      userMsg(longUser),
+      assistantText("a0"),
+      userMsg("u1"),
+      assistantText("a1"),
+      userMsg("u2"),
+      assistantText("a2"),
+    ];
+    await compactMessages(model, messages, config);
+    const sentPrompt = prompts.join("\n");
+    expect(sentPrompt).toContain("[truncated]");
+    // The first message was NOT a prior summary, so no merge instruction.
+    expect(sentPrompt).not.toContain("MERGE AND UPDATE");
+  });
+});

package/test/entries-dual-write.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect } from "vitest";
+import type { Message } from "@poncho-ai/sdk";
+import { createLogger } from "@poncho-ai/sdk";
+import { InMemoryConversationStore } from "../src/state.js";
+import {
+  buildDisplaySnapshot,
+  buildLlmContext,
+  getPendingSubagentResults,
+} from "../src/storage/entries.js";
+import {
+  appendEntriesSafe,
+  assistantMessageEntry,
+  callbackStartedEntry,
+  compactionEntry,
+  harnessMessageEntries,
+  newHarnessMessagesThisTurn,
+  subagentResultEntry,
+  userMessageEntry,
+} from "../src/orchestrator/entries-dual-write.js";
+
+const log = createLogger("test");
+const msg = (role: Message["role"], content: string): Message => ({
+  role,
+  content,
+  metadata: { id: `${role}-${content}` },
+});
+
+const conv = (id: string) => ({
+  conversationId: id,
+  ownerId: "owner-1",
+  tenantId: null as string | null,
+});
+
+describe("entries dual-write", () => {
+  it("rebuilds llm context + display from a simulated chat turn's appends", async () => {
+    const store = new InMemoryConversationStore();
+    const c = conv("c1");
+    const turnId = "turn-1";
+
+    // Turn start: user message.
+    await appendEntriesSafe(store, c, [userMessageEntry(msg("user", "hi"), turnId)], log);
+
+    // During the turn the harness produced two model-visible messages and a
+    // final assistant bubble.
+    const harness1 = msg("user", "hi");
+    const harness2 = msg("assistant", "hello there");
+    const finalAssistant = msg("assistant", "hello there");
+    await appendEntriesSafe(
+      store,
+      c,
+      [
+        ...harnessMessageEntries([harness1, harness2], turnId),
+        assistantMessageEntry(finalAssistant, turnId, "run-1"),
+      ],
+      log,
+    );
+
+    const entries = await store.readEntries("c1");
+
+    // LLM context == the harness messages in order.
+    const llm = buildLlmContext(entries);
+    expect(llm.map((m) => m.content)).toEqual(["hi", "hello there"]);
+
+    // Display == [user, assistant] (final assistant bubble; harness msgs hidden).
+    const snap = buildDisplaySnapshot(entries, 100);
+    expect(snap.messages.map((m) => [m.role, m.content])).toEqual([
+      ["user", "hi"],
+      ["assistant", "hello there"],
+    ]);
+    expect(snap.totalMessages).toBe(2);
+  });
+
+  it("compaction overlay keeps summary + tail at rebuild", async () => {
+    const store = new InMemoryConversationStore();
+    const c = conv("c2");
+
+    await appendEntriesSafe(
+      store,
+      c,
+      harnessMessageEntries(
+        [msg("user", "m1"), msg("assistant", "m2"), msg("user", "m3")],
+        "t",
+      ),
+      log,
+    );
+    const before = await store.readEntries("c2");
+    // Keep only the last harness message (seq 3) after compaction.
+    const firstKeptSeq = before[before.length - 1]!.seq;
+    await appendEntriesSafe(
+      store,
+      c,
+      [compactionEntry(msg("assistant", "SUMMARY"), firstKeptSeq)],
+      log,
+    );
+
+    const llm = buildLlmContext(await store.readEntries("c2"));
+    expect(llm.map((m) => m.content)).toEqual(["SUMMARY", "m3"]);
+  });
+
+  it("subagent_result + callback_started track pending consumption", async () => {
+    const store = new InMemoryConversationStore();
+    const c = conv("c3");
+
+    const stored = await appendEntriesSafe(
+      store,
+      c,
+      [
+        subagentResultEntry({
+          subagentId: "sa-1",
+          task: "do thing",
+          status: "completed",
+          timestamp: 1,
+        }),
+      ],
+      log,
+    );
+    const resultSeq = stored[0]!.seq;
+
+    // Before consumption: pending.
+    expect(getPendingSubagentResults(await store.readEntries("c3"))).toHaveLength(1);
+
+    // The callback consumes it + injects a hidden user message.
+    await appendEntriesSafe(
+      store,
+      c,
+      [
+        callbackStartedEntry([resultSeq]),
+        userMessageEntry(msg("user", "[Subagent Result] ..."), "cb-1", { hidden: true }),
+      ],
+      log,
+    );
+
+    const after = await store.readEntries("c3");
+    expect(getPendingSubagentResults(after)).toHaveLength(0);
+    // Hidden injected message does not appear in the display transcript.
+    expect(buildDisplaySnapshot(after, 100).messages).toHaveLength(0);
+  });
+
+  it("newHarnessMessagesThisTurn diffs the suffix and flags shrinks", () => {
+    const a = msg("user", "a");
+    const b = msg("assistant", "b");
+    const cc = msg("user", "c");
+
+    expect(newHarnessMessagesThisTurn(undefined, [a, b])).toEqual({
+      messages: [a, b],
+      approximate: false,
+    });
+    expect(newHarnessMessagesThisTurn([a], [a, b, cc])).toEqual({
+      messages: [b, cc],
+      approximate: false,
+    });
+    // Shrink (compaction reshaped the array) → approximate, returns full next.
+    const shrink = newHarnessMessagesThisTurn([a, b, cc], [a]);
+    expect(shrink.approximate).toBe(true);
+    expect(shrink.messages).toEqual([a]);
+  });
+
+  it("appendEntriesSafe swallows store errors and returns []", async () => {
+    const brokenStore = {
+      appendEntries: async () => {
+        throw new Error("boom");
+      },
+    } as unknown as InMemoryConversationStore;
+    const result = await appendEntriesSafe(
+      brokenStore,
+      conv("c4"),
+      [userMessageEntry(msg("user", "x"), "t")],
+      log,
+    );
+    expect(result).toEqual([]);
+  });
+});

package/test/entries-store.test.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { InMemoryConversationStore } from "../src/state.js";
+import type { ConversationStore } from "../src/state.js";
+import type { ConversationEntry, NewConversationEntry } from "../src/storage/entries.js";
+import { SqliteEngine } from "../src/storage/sqlite-engine.js";
+import { createConversationStoreFromEngine } from "../src/storage/store-adapters.js";
+import type { Message } from "@poncho-ai/sdk";
+
+const msg = (role: Message["role"], content: string): Message => ({ role, content });
+
+// Entry factories (without seq/createdAt — those are assigned by the store).
+const userEntry = (id: string, content: string): NewConversationEntry => ({
+  type: "user_message",
+  id,
+  message: msg("user", content),
+  turnId: "t1",
+});
+
+const harnessEntry = (id: string, content: string): NewConversationEntry => ({
+  type: "harness_message",
+  id,
+  message: msg("assistant", content),
+  turnId: "t1",
+});
+
+const compactionEntry = (id: string): NewConversationEntry => ({
+  type: "compaction",
+  id,
+  summaryMessage: msg("user", "summary so far"),
+  firstKeptSeq: 2,
+});
+
+// Shared suite run against both InMemory and SQLite-backed stores.
+function runSuite(name: string, factory: () => Promise<{ store: ConversationStore; cleanup: () => Promise<void> }>) {
+  describe(name, () => {
+    let store: ConversationStore;
+    let cleanup: () => Promise<void>;
+
+    beforeEach(async () => {
+      const ctx = await factory();
+      store = ctx.store;
+      cleanup = ctx.cleanup;
+    });
+
+    afterEach(async () => {
+      await cleanup();
+    });
+
+    it("assigns consecutive per-conversation seqs starting at 1", async () => {
+      const stored = await store.appendEntries("c1", "agent", null, [
+        userEntry("u1", "hi"),
+        harnessEntry("h1", "hello"),
+        harnessEntry("h2", "how can I help?"),
+      ]);
+      expect(stored.map((e) => e.seq)).toEqual([1, 2, 3]);
+      expect(stored.every((e) => typeof e.createdAt === "number")).toBe(true);
+    });
+
+    it("continues seq across multiple appendEntries calls", async () => {
+      await store.appendEntries("c1", "agent", null, [userEntry("u1", "a")]);
+      const second = await store.appendEntries("c1", "agent", null, [
+        harnessEntry("h1", "b"),
+        harnessEntry("h2", "c"),
+      ]);
+      expect(second.map((e) => e.seq)).toEqual([2, 3]);
+    });
+
+    it("keeps seq spaces independent per conversation", async () => {
+      await store.appendEntries("c1", "agent", null, [userEntry("u1", "a")]);
+      const other = await store.appendEntries("c2", "agent", null, [userEntry("u2", "b")]);
+      expect(other[0].seq).toBe(1);
+    });
+
+    it("reads entries ordered by seq ascending", async () => {
+      await store.appendEntries("c1", "agent", null, [
+        userEntry("u1", "one"),
+        harnessEntry("h1", "two"),
+        harnessEntry("h2", "three"),
+      ]);
+      const all = await store.readEntries("c1");
+      expect(all.map((e) => e.seq)).toEqual([1, 2, 3]);
+      expect(all.map((e) => e.id)).toEqual(["u1", "h1", "h2"]);
+    });
+
+    it("filters by type", async () => {
+      await store.appendEntries("c1", "agent", null, [
+        userEntry("u1", "one"),
+        harnessEntry("h1", "two"),
+        harnessEntry("h2", "three"),
+      ]);
+      const harnessOnly = await store.readEntries("c1", { types: ["harness_message"] });
+      expect(harnessOnly.map((e) => e.id)).toEqual(["h1", "h2"]);
+    });
+
+    it("filters by afterSeq", async () => {
+      await store.appendEntries("c1", "agent", null, [
+        userEntry("u1", "one"),
+        harnessEntry("h1", "two"),
+        harnessEntry("h2", "three"),
+      ]);
+      const after1 = await store.readEntries("c1", { afterSeq: 1 });
+      expect(after1.map((e) => e.seq)).toEqual([2, 3]);
+    });
+
+    it("respects limit", async () => {
+      await store.appendEntries("c1", "agent", null, [
+        userEntry("u1", "one"),
+        harnessEntry("h1", "two"),
+        harnessEntry("h2", "three"),
+      ]);
+      const limited = await store.readEntries("c1", { limit: 2 });
+      expect(limited.map((e) => e.seq)).toEqual([1, 2]);
+    });
+
+    it("round-trips distinct entry types with their payloads intact", async () => {
+      await store.appendEntries("c1", "agent", null, [
+        userEntry("u1", "question"),
+        compactionEntry("cmp1"),
+      ]);
+      const all = await store.readEntries("c1");
+
+      const user = all.find((e) => e.id === "u1");
+      expect(user?.type).toBe("user_message");
+      expect(user?.type === "user_message" && user.message.content).toBe("question");
+      expect(user?.type === "user_message" && user.turnId).toBe("t1");
+
+      const cmp = all.find((e) => e.id === "cmp1");
+      expect(cmp?.type).toBe("compaction");
+      expect(cmp?.type === "compaction" && cmp.firstKeptSeq).toBe(2);
+      expect(cmp?.type === "compaction" && cmp.summaryMessage.content).toBe("summary so far");
+    });
+
+    it("returns an empty array for an unknown conversation", async () => {
+      expect(await store.readEntries("nope")).toEqual([]);
+    });
+
+    it("treats an empty append as a no-op", async () => {
+      const stored = await store.appendEntries("c1", "agent", null, []);
+      expect(stored).toEqual([]);
+      expect(await store.readEntries("c1")).toEqual([]);
+    });
+  });
+}
+
+runSuite("InMemoryConversationStore entries", async () => {
+  const store = new InMemoryConversationStore();
+  return { store, cleanup: async () => {} };
+});
+
+runSuite("SqliteEngine entries (via adapter)", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "entries-store-"));
+  const engine = new SqliteEngine({ workingDir: dir, agentId: "agent", dbPath: join(dir, "test.db") });
+  await engine.initialize();
+  const store = createConversationStoreFromEngine(engine);
+  return {
+    store,
+    cleanup: async () => {
+      await engine.close();
+      await rm(dir, { recursive: true, force: true });
+    },
+  };
+});