alvin-bot 4.18.0 → 4.18.1

package/test/async-agent-parser-staleness.test.ts

@@ -1,412 +0,0 @@
-/**
- * v4.12.4 — parseOutputFileStatus staleness detection.
- *
- * Problem this fixes: when a background sub-agent is interrupted (e.g. by
- * v4.12.3's bypass-abort propagating through the SDK subprocess), its
- * outputFile is left with partial JSONL — real work, real text — but
- * without the `stop_reason: "end_turn"` marker the pre-v4.12.4 parser
- * required for "completed" state.
- *
- * Real-world evidence (2026-04-16):
- *   - Three agents (a03ce829, af61fa6e, ac47c4a2) pending in state file
- *   - Each outputFile has 81-131 lines of REAL work (WebSearch, tool_use,
- *     partial reports like "Here's the summary:\n\n## Critical Bugs")
- *   - Last event is either "[Request interrupted by user for tool use]"
- *     or a mid-streaming assistant text that never got end_turn
- *   - Watcher polls forever, hits 12h giveUpAt, delivers "empty output"
- *   - User sees useless "720m timeout · 0 in / 0 out · (empty output)"
- *     messages hours later, while the actual work is sitting on disk
- *
- * Fix behavior:
- *   - If no end_turn is found, check mtime/size of the file
- *   - If file hasn't been touched for `stalenessMs` (default 5 min) AND
- *     there's usable text content in the tail, mark as "completed"
- *     with the partial output PREFIXED by an "⚠️ interrupted, partial
- *     output" header so the user knows it's not a clean finish
- *   - If file IS fresh or has no text content, stay in "running" state
- *     (normal polling continues)
- *
- * This deliberately biases toward delivering SOMETHING rather than
- * nothing. Worst case: an agent that's still alive but genuinely idle
- * for >5 min gets its partial text delivered early. Best case: dozens
- * of stuck interrupted agents get their real work back to the user.
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "fs";
-import os from "os";
-import { resolve } from "path";
-import { parseOutputFileStatus } from "../src/services/async-agent-parser.js";
-
-const TMP_BASE = resolve(os.tmpdir(), `alvin-parser-stale-${process.pid}`);
-
-beforeEach(() => {
-  fs.mkdirSync(TMP_BASE, { recursive: true });
-});
-afterEach(() => {
-  try {
-    fs.rmSync(TMP_BASE, { recursive: true, force: true });
-  } catch {
-    /* ignore */
-  }
-});
-
-/**
- * Write a JSONL file with a mid-execution interrupted state. No end_turn,
- * but contains real assistant text + tool calls. Last line is the
- * "Request interrupted" marker.
- */
-function writeInterruptedJsonl(name: string): string {
-  const path = resolve(TMP_BASE, name);
-  const lines = [
-    JSON.stringify({
-      type: "user",
-      isSidechain: true,
-      agentId: "x",
-      message: { role: "user", content: "do a report" },
-    }),
-    JSON.stringify({
-      type: "assistant",
-      isSidechain: true,
-      agentId: "x",
-      message: {
-        role: "assistant",
-        content: [{ type: "text", text: "Starting research..." }],
-        stop_reason: "tool_use",
-      },
-    }),
-    JSON.stringify({
-      type: "assistant",
-      isSidechain: true,
-      agentId: "x",
-      message: {
-        role: "assistant",
-        content: [
-          {
-            type: "text",
-            text:
-              "Here's what I found:\n\n## Key Findings\n- Finding A\n- Finding B\n- Finding C",
-          },
-        ],
-        stop_reason: "tool_use",
-      },
-    }),
-    JSON.stringify({
-      type: "user",
-      isSidechain: true,
-      agentId: "x",
-      message: {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            content: "[Request interrupted by user for tool use]",
-          },
-        ],
-      },
-    }),
-  ];
-  fs.writeFileSync(path, lines.join("\n") + "\n", "utf-8");
-  return path;
-}
-
-/** Set file mtime to N ms in the past. */
-function setStale(path: string, ageMs: number): void {
-  const target = Date.now() - ageMs;
-  fs.utimesSync(path, target / 1000, target / 1000);
-}
-
-describe("parseOutputFileStatus — staleness detection (v4.12.4)", () => {
-  it("still returns 'completed' when end_turn is present (staleness is a fallback only)", async () => {
-    const path = resolve(TMP_BASE, "complete.jsonl");
-    fs.writeFileSync(
-      path,
-      JSON.stringify({
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "clean end" }],
-          stop_reason: "end_turn",
-        },
-      }) + "\n",
-      "utf-8",
-    );
-    setStale(path, 3600_000); // 1h old
-    const status = await parseOutputFileStatus(path, {
-      stalenessMs: 300_000,
-    });
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toContain("clean end");
-      // No interrupted banner for clean end_turn
-      expect(status.output).not.toMatch(/interrupt/i);
-    }
-  });
-
-  it("returns 'running' when file is fresh and no end_turn (normal polling)", async () => {
-    const path = writeInterruptedJsonl("fresh-interrupted.jsonl");
-    // File is fresh (just written)
-    const status = await parseOutputFileStatus(path, {
-      stalenessMs: 300_000,
-    });
-    expect(status.state).toBe("running");
-  });
-
-  it("returns 'completed' (partial) when file is stale AND has text content", async () => {
-    const path = writeInterruptedJsonl("stale-interrupted.jsonl");
-    setStale(path, 600_000); // 10 min old
-    const status = await parseOutputFileStatus(path, {
-      stalenessMs: 300_000, // 5 min threshold
-    });
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      // Should contain the real report content
-      expect(status.output).toContain("Key Findings");
-      expect(status.output).toContain("Finding A");
-      // Should be prefixed with an interrupted banner so user knows
-      // (German "unterbrochen" / "partielle" OR English "interrupted"/"partial")
-      expect(status.output).toMatch(/interrupt|partial|unterbroch|partiell|⚠️/i);
-    }
-  });
-
-  it("returns 'running' when file is stale but has NO text content (nothing to deliver)", async () => {
-    // Only tool-use events, no text. Delivery would be useless.
-    const path = resolve(TMP_BASE, "no-text.jsonl");
-    fs.writeFileSync(
-      path,
-      [
-        JSON.stringify({
-          type: "user",
-          agentId: "x",
-          message: { role: "user", content: "go" },
-        }),
-        JSON.stringify({
-          type: "assistant",
-          agentId: "x",
-          message: {
-            content: [
-              { type: "tool_use", name: "Bash", input: { command: "ls" } },
-            ],
-            stop_reason: "tool_use",
-          },
-        }),
-      ].join("\n") + "\n",
-      "utf-8",
-    );
-    setStale(path, 600_000);
-    const status = await parseOutputFileStatus(path, {
-      stalenessMs: 300_000,
-    });
-    expect(status.state).toBe("running");
-  });
-
-  it("default stalenessMs is applied when not provided (no crashes on legacy callers)", async () => {
-    const path = writeInterruptedJsonl("default-cfg.jsonl");
-    setStale(path, 24 * 3600_000); // 24h old — very stale
-    const status = await parseOutputFileStatus(path);
-    // Whatever the default is, 24h should definitely exceed it
-    expect(status.state).toBe("completed");
-  });
-
-  it("stalenessMs: 0 disables the staleness fallback entirely", async () => {
-    const path = writeInterruptedJsonl("disabled.jsonl");
-    setStale(path, 24 * 3600_000);
-    const status = await parseOutputFileStatus(path, { stalenessMs: 0 });
-    // With staleness disabled, we're back to strict end_turn requirement
-    expect(status.state).toBe("running");
-  });
-
-  it("aggregates ALL text blocks from ALL assistant turns when delivering partial", async () => {
-    const path = resolve(TMP_BASE, "multi-turn-interrupted.jsonl");
-    const lines = [
-      { type: "user", agentId: "x", message: { role: "user", content: "go" } },
-      {
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "First thought." }],
-          stop_reason: "tool_use",
-        },
-      },
-      {
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "Second thought." }],
-          stop_reason: "tool_use",
-        },
-      },
-      {
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "Final partial report." }],
-          stop_reason: "tool_use",
-        },
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    setStale(path, 600_000);
-    const status = await parseOutputFileStatus(path, {
-      stalenessMs: 300_000,
-    });
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      // Should contain text from all three turns (bias toward delivering more)
-      expect(status.output).toContain("First thought");
-      expect(status.output).toContain("Second thought");
-      expect(status.output).toContain("Final partial report");
-    }
-  });
-
-  it("ignores thinking blocks in partial delivery (user doesn't want Claude's scratchpad)", async () => {
-    const path = resolve(TMP_BASE, "thinking-filter.jsonl");
-    const lines = [
-      {
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [
-            { type: "thinking", text: "internal reasoning nobody should see" },
-            { type: "text", text: "Actual output text." },
-          ],
-          stop_reason: "tool_use",
-        },
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    setStale(path, 600_000);
-    const status = await parseOutputFileStatus(path, {
-      stalenessMs: 300_000,
-    });
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toContain("Actual output text");
-      expect(status.output).not.toContain("internal reasoning");
-    }
-  });
-
-  it("extracts usage tokens from the last assistant event when available", async () => {
-    const path = resolve(TMP_BASE, "tokens-partial.jsonl");
-    const lines = [
-      {
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "partial text" }],
-          stop_reason: "tool_use",
-          usage: { input_tokens: 500, output_tokens: 200 },
-        },
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    setStale(path, 600_000);
-    const status = await parseOutputFileStatus(path, {
-      stalenessMs: 300_000,
-    });
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.tokensUsed).toEqual({ input: 500, output: 200 });
-    }
-  });
-
-  it("handles file that only has the interruption marker (nothing useful to deliver)", async () => {
-    // Edge case: only interruption, no prior text
-    const path = resolve(TMP_BASE, "only-interrupt.jsonl");
-    const lines = [
-      {
-        type: "user",
-        agentId: "x",
-        message: {
-          role: "user",
-          content: [
-            {
-              type: "tool_result",
-              content: "[Request interrupted by user for tool use]",
-            },
-          ],
-        },
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    setStale(path, 600_000);
-    const status = await parseOutputFileStatus(path, {
-      stalenessMs: 300_000,
-    });
-    // No assistant text content at all → still running (nothing useful)
-    expect(status.state).toBe("running");
-  });
-
-  it("preserves ordering of text across turns (earlier text first, later text last)", async () => {
-    const path = resolve(TMP_BASE, "order.jsonl");
-    const lines = [
-      {
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "ALPHA" }],
-          stop_reason: "tool_use",
-        },
-      },
-      {
-        type: "user",
-        agentId: "x",
-        message: { content: [{ type: "tool_result", content: "..." }] },
-      },
-      {
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "BETA" }],
-          stop_reason: "tool_use",
-        },
-      },
-      {
-        type: "user",
-        agentId: "x",
-        message: { content: [{ type: "tool_result", content: "..." }] },
-      },
-      {
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "GAMMA" }],
-          stop_reason: "tool_use",
-        },
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    setStale(path, 600_000);
-    const status = await parseOutputFileStatus(path, {
-      stalenessMs: 300_000,
-    });
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      const alphaIdx = status.output.indexOf("ALPHA");
-      const betaIdx = status.output.indexOf("BETA");
-      const gammaIdx = status.output.indexOf("GAMMA");
-      expect(alphaIdx).toBeGreaterThan(-1);
-      expect(betaIdx).toBeGreaterThan(alphaIdx);
-      expect(gammaIdx).toBeGreaterThan(betaIdx);
-    }
-  });
-});

package/test/async-agent-parser-streamjson.test.ts

@@ -1,273 +0,0 @@
-/**
- * v4.13 — parseOutputFileStatus support for `claude -p --output-format stream-json`.
- *
- * The SDK's built-in Task tool writes its sub-agent output in one JSONL
- * format (events with `message.stop_reason: "end_turn"`). The new v4.13
- * dispatch mechanism spawns `claude -p --output-format stream-json`
- * which writes a DIFFERENT format:
- *
- *   - Assistant messages have `message.stop_reason: null` (streaming shape)
- *   - A final `{"type":"result","subtype":"success","stop_reason":"end_turn",...}`
- *     event marks completion explicitly
- *   - `result.duration_ms`, `total_cost_usd`, `num_turns`, `usage`
- *     are the authoritative completion signals
- *
- * The parser must recognize BOTH formats. v4.13 adds detection for the
- * result-event format while preserving backward compat with the existing
- * SDK-internal format (tested in the sibling test files).
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "fs";
-import os from "os";
-import { resolve } from "path";
-import { parseOutputFileStatus } from "../src/services/async-agent-parser.js";
-
-const TMP_BASE = resolve(
-  os.tmpdir(),
-  `alvin-parser-streamjson-${process.pid}`,
-);
-
-beforeEach(() => {
-  fs.mkdirSync(TMP_BASE, { recursive: true });
-});
-afterEach(() => {
-  try {
-    fs.rmSync(TMP_BASE, { recursive: true, force: true });
-  } catch {
-    /* ignore */
-  }
-});
-
-describe("parseOutputFileStatus — stream-json format (v4.13)", () => {
-  it("returns 'completed' when final event is type:result + subtype:success", async () => {
-    const path = resolve(TMP_BASE, "stream-success.jsonl");
-    const lines = [
-      { type: "system", subtype: "init", session_id: "s1" },
-      {
-        type: "assistant",
-        message: {
-          role: "assistant",
-          content: [{ type: "text", text: "The answer is 42." }],
-          stop_reason: null, // streaming shape — NOT end_turn yet
-        },
-        session_id: "s1",
-      },
-      {
-        type: "result",
-        subtype: "success",
-        stop_reason: "end_turn",
-        session_id: "s1",
-        total_cost_usd: 0.01,
-        duration_ms: 500,
-        usage: { input_tokens: 10, output_tokens: 5 },
-        result: "The answer is 42.",
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toContain("The answer is 42.");
-      expect(status.output).not.toMatch(/interrupted|partial/i);
-    }
-  });
-
-  it("extracts tokens from result.usage when using stream-json format", async () => {
-    const path = resolve(TMP_BASE, "stream-tokens.jsonl");
-    const lines = [
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "x" }],
-          stop_reason: null,
-        },
-      },
-      {
-        type: "result",
-        subtype: "success",
-        stop_reason: "end_turn",
-        usage: { input_tokens: 1234, output_tokens: 567 },
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.tokensUsed).toEqual({ input: 1234, output: 567 });
-    }
-  });
-
-  it("recognises 'failed' state when result.is_error is true", async () => {
-    const path = resolve(TMP_BASE, "stream-failed.jsonl");
-    const lines = [
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "I tried..." }],
-          stop_reason: null,
-        },
-      },
-      {
-        type: "result",
-        subtype: "error_max_turns",
-        is_error: true,
-        stop_reason: "max_turns",
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    // With an is_error result + text content, we still deliver the text
-    // as completed (better to give the user SOMETHING than nothing).
-    // The delivery layer can annotate differently if it chooses.
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toContain("I tried...");
-    }
-  });
-
-  it("returns 'running' when stream-json events are present but no result yet", async () => {
-    const path = resolve(TMP_BASE, "stream-running.jsonl");
-    const lines = [
-      { type: "system", subtype: "init", session_id: "s1" },
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "Thinking..." }],
-          stop_reason: null,
-        },
-      },
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "tool_use", name: "Bash", input: {} }],
-          stop_reason: null,
-        },
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("running");
-  });
-
-  it("aggregates text from ALL assistant messages when result arrives", async () => {
-    const path = resolve(TMP_BASE, "stream-multi-text.jsonl");
-    const lines = [
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "First thought." }],
-          stop_reason: null,
-        },
-      },
-      {
-        type: "user",
-        message: { content: [{ type: "tool_result", content: "ok" }] },
-      },
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "Continuing..." }],
-          stop_reason: null,
-        },
-      },
-      {
-        type: "user",
-        message: { content: [{ type: "tool_result", content: "ok" }] },
-      },
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "Final answer." }],
-          stop_reason: null,
-        },
-      },
-      { type: "result", subtype: "success", stop_reason: "end_turn" },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      // All three text blocks must be present
-      expect(status.output).toContain("First thought");
-      expect(status.output).toContain("Continuing");
-      expect(status.output).toContain("Final answer");
-    }
-  });
-
-  it("prefers result.result field as authoritative output when available", async () => {
-    // The stream-json's result event has a `result` field with the
-    // already-concatenated final answer. Use it directly when present
-    // (more accurate than re-aggregating from streaming chunks).
-    const path = resolve(TMP_BASE, "stream-result-field.jsonl");
-    const lines = [
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "Intermediate chunk" }],
-          stop_reason: null,
-        },
-      },
-      {
-        type: "result",
-        subtype: "success",
-        stop_reason: "end_turn",
-        result: "FINAL AUTHORITATIVE ANSWER",
-      },
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toContain("FINAL AUTHORITATIVE ANSWER");
-    }
-  });
-
-  it("handles result event with only partial fields (defensive)", async () => {
-    const path = resolve(TMP_BASE, "stream-result-minimal.jsonl");
-    const lines = [
-      {
-        type: "assistant",
-        message: {
-          content: [{ type: "text", text: "Some output" }],
-          stop_reason: null,
-        },
-      },
-      { type: "result" }, // no subtype, no result field, no usage
-    ];
-    fs.writeFileSync(
-      path,
-      lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toContain("Some output");
-    }
-  });
-});