@poncho-ai/harness 0.50.3 → 0.50.5

package/test/isolate.test.ts

@@ -1,8 +1,10 @@
 import { describe, expect, it } from "vitest";
 import { createIsolateRuntime } from "../src/isolate/runtime.js";
+import { buildPolyfillPreamble } from "../src/isolate/polyfills.js";
 import type { IsolateBinding } from "../src/config.js";
 
 const DEFAULT_CONFIG = { memoryLimit: 64, timeout: 5000, outputLimit: 65536 };
+const POLYFILLS = buildPolyfillPreamble(false);
 
 describe("IsolateRuntime", () => {
   it("executes basic JavaScript and returns a result", async () => {
@@ -136,6 +138,79 @@ describe("IsolateRuntime", () => {
   });
 });
 
+describe("IsolateRuntime timers + wall-clock", () => {
+  it("resolves a non-zero setTimeout sleep instead of hanging", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const res = await runtime.execute(
+      `await new Promise(r => setTimeout(r, 50)); return "slept";`,
+      {},
+      null,
+      undefined,
+      POLYFILLS,
+    );
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toBe("slept");
+  });
+
+  it("runs awaited timers in delay order against the virtual clock", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const res = await runtime.execute(
+      `const order = [];
+       async function at(ms, label) {
+         await new Promise(r => setTimeout(r, ms));
+         order.push(label);
+       }
+       await Promise.all([at(100, "a"), at(10, "b"), at(50, "c")]);
+       return order;`,
+      {},
+      null,
+      undefined,
+      POLYFILLS,
+    );
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toEqual(["b", "c", "a"]);
+  });
+
+  it("supports setInterval + clearInterval", async () => {
+    const runtime = createIsolateRuntime(DEFAULT_CONFIG);
+    const res = await runtime.execute(
+      `let n = 0;
+       await new Promise(resolve => {
+         const id = setInterval(() => {
+           n += 1;
+           if (n >= 3) { clearInterval(id); resolve(); }
+         }, 10);
+       });
+       return n;`,
+      {},
+      null,
+      undefined,
+      POLYFILLS,
+    );
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toBe(3);
+  });
+
+  it("times out a never-resolving promise via the wall-clock guard", async () => {
+    const runtime = createIsolateRuntime({ ...DEFAULT_CONFIG, timeout: 200 });
+    const start = performance.now();
+    const res = await runtime.execute(
+      `await new Promise(() => {}); return "never";`,
+      {},
+      null,
+    );
+
+    expect(res.error).toBeDefined();
+    expect(res.error!.message).toMatch(/timed out/i);
+    expect(res.error!.name).toBe("TimeoutError");
+    // Bounded by the wall clock, not hanging forever.
+    expect(performance.now() - start).toBeLessThan(2000);
+  });
+});
+
 describe("IsolateRuntime bindings", () => {
   it("calls async bindings and returns results", async () => {
     const runtime = createIsolateRuntime(DEFAULT_CONFIG);

package/test/orchestrator.test.ts

@@ -8,6 +8,9 @@ import {
   createTurnDraftState,
   recordStandardTurnEvent,
   executeConversationTurn,
+  lastAssistantText,
+  realResponseText,
+  abnormalEndResponse,
 } from "../src/orchestrator/index.js";
 import type { Conversation } from "../src/state.js";
 
@@ -174,3 +177,112 @@ describe("orchestrator helpers", () => {
     expect(seenTypes).toEqual(["run:started", "tool:started", "model:chunk", "run:completed"]);
   });
 });
+
+describe("lastAssistantText (subagent result extraction)", () => {
+  it("returns a plain-string assistant message", () => {
+    const messages: Message[] = [
+      { role: "user", content: "find me 3 creators" },
+      { role: "assistant", content: "Here are 3 creators: ..." },
+    ];
+    expect(lastAssistantText(messages)).toBe("Here are 3 creators: ...");
+  });
+
+  it("unwraps the {text,tool_calls} envelope to its text", () => {
+    // How the run loop serializes an assistant turn that also called tools.
+    const envelope = JSON.stringify({
+      text: "Searching for candidates now.",
+      tool_calls: [{ id: "t1", name: "web_search", input: { q: "creators" } }],
+    });
+    const messages: Message[] = [{ role: "assistant", content: envelope }];
+    expect(lastAssistantText(messages)).toBe("Searching for candidates now.");
+  });
+
+  it("walks back past a trailing tool-call turn with no text", () => {
+    // The reported bug: subagent ends on a pure tool call (empty text), but it
+    // produced a real summary the turn before. We must surface that summary,
+    // not an empty string.
+    const toolOnly = JSON.stringify({
+      text: "",
+      tool_calls: [{ id: "t9", name: "web_search", input: { q: "x" } }],
+    });
+    const messages: Message[] = [
+      { role: "user", content: "go" },
+      { role: "assistant", content: "Found 12 candidates, here they are: ..." },
+      { role: "tool", content: "[]" },
+      { role: "assistant", content: toolOnly },
+    ];
+    expect(lastAssistantText(messages)).toBe("Found 12 candidates, here they are: ...");
+  });
+
+  it("extracts text from ContentPart[] content", () => {
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "part one" },
+          { type: "file", data: "Zm9v", mediaType: "image/png" },
+          { type: "text", text: " part two" },
+        ],
+      },
+    ];
+    expect(lastAssistantText(messages)).toBe("part one part two");
+  });
+
+  it("returns empty string when there is genuinely no assistant text", () => {
+    const messages: Message[] = [
+      { role: "user", content: "hi" },
+      {
+        role: "assistant",
+        content: JSON.stringify({ text: "", tool_calls: [{ id: "t1", name: "x", input: {} }] }),
+      },
+    ];
+    expect(lastAssistantText(messages)).toBe("");
+  });
+});
+
+describe("realResponseText (strips run:error placeholder)", () => {
+  it("drops the synthetic [Error: ...] placeholder", () => {
+    expect(realResponseText("[Error: Run exceeded timeout of 300s]")).toBe("");
+  });
+  it("keeps real text and trims", () => {
+    expect(realResponseText("  done, wrote the file  ")).toBe("done, wrote the file");
+  });
+  it("handles undefined", () => {
+    expect(realResponseText(undefined)).toBe("");
+  });
+});
+
+describe("abnormalEndResponse (graceful timeout / error delivery)", () => {
+  it("timeout WITH gathered work: notes the cutoff and includes the work", () => {
+    const out = abnormalEndResponse({
+      subagentId: "sub_1",
+      gathered: "Found 12 competitors: A, B, C...",
+      runError: { code: "TIMEOUT", message: "Run exceeded timeout of 3600s" },
+    });
+    expect(out).toContain("time limit");
+    expect(out).toContain("may not have written its output files");
+    expect(out).toContain("Found 12 competitors: A, B, C...");
+    expect(out).not.toContain("(no result)");
+  });
+
+  it("timeout WITHOUT gathered work: points at read_subagent to recover", () => {
+    const out = abnormalEndResponse({
+      subagentId: "sub_2",
+      gathered: "",
+      runError: { code: "TIMEOUT", message: "Run exceeded timeout of 3600s" },
+    });
+    expect(out).toContain("time limit");
+    expect(out).toContain('read_subagent("sub_2"');
+    expect(out).toContain('mode:"full"');
+  });
+
+  it("non-timeout error: surfaces the error message", () => {
+    const out = abnormalEndResponse({
+      subagentId: "sub_3",
+      gathered: "",
+      runError: { code: "EMPTY_RESPONSE", message: "model returned no content" },
+    });
+    expect(out).toContain("ended before finishing");
+    expect(out).toContain("model returned no content");
+  });
+});