talon-agent 1.7.0 → 1.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",

package/src/__tests__/chat-settings.test.ts

@@ -38,9 +38,13 @@ const { registerClaudeModelsStatic, CLAUDE_MODELS_STATIC } =
   await import("../backend/claude-sdk/models.js");
 registerClaudeModelsStatic(CLAUDE_MODELS_STATIC);
 
+// convertSdkModels collapses base + 1M variants into a single canonical ID
+// per family+version, preferring the 1M variant (and "default" when the SDK
+// marks one canonical). So sonnet/sonnet[1m] → "default", opus/opus[1m] →
+// "opus[1m]", and plain "haiku" stays.
 const SDK_MODEL_IDS = {
   sonnet: "default",
-  opus: "opus",
+  opus: "opus[1m]",
   haiku: "haiku",
 } as const;
 

package/src/__tests__/claude-sdk-models.test.ts

@@ -58,48 +58,40 @@ describe("registerClaudeModels", () => {
     clearModels();
   });
 
-  it("keeps SDK IDs/display names and maps 1M upgrades explicitly", async () => {
+  it("collapses family+version duplicates (base + 1M + claude-*) into a single canonical entry", async () => {
     const { registerClaudeModels } =
       await import("../backend/claude-sdk/models.js");
-    const {
-      get1mContextModelId,
-      getModels,
-      resolveModelId,
-      supports1mContext,
-    } = await import("../core/models.js");
+    const { getModels, resolveModelId } = await import("../core/models.js");
 
     await registerClaudeModels({ model: "default" });
 
+    // sonnet, sonnet[1m], claude-sonnet-4-6 all share family+version and
+    // collapse into "default" (the SDK's recommended canonical). opus/opus[1m]
+    // collapse into opus[1m] (1M-preferred since no "default" exists for that
+    // family). haiku stands alone.
     const anthropicModels = getModels("anthropic");
     expect(anthropicModels.map((model) => model.id)).toEqual([
-      "opus",
-      "opus[1m]",
       "default",
-      "sonnet[1m]",
+      "opus[1m]",
       "haiku",
     ]);
 
     expect(
       anthropicModels.find((model) => model.id === "default")?.displayName,
-    ).toBe("Default (recommended)");
+    ).toBe("Sonnet 4.6");
     expect(
-      anthropicModels.find((model) => model.id === "sonnet[1m]")?.displayName,
-    ).toBe("Sonnet (1M context)");
+      anthropicModels.find((model) => model.id === "opus[1m]")?.displayName,
+    ).toBe("Opus 4.6");
     expect(
-      anthropicModels.some((model) => model.id === "claude-sonnet-4-6"),
-    ).toBe(false);
+      anthropicModels.find((model) => model.id === "haiku")?.displayName,
+    ).toBe("Haiku 4.5");
 
+    expect(resolveModelId("sonnet")).toBe("default");
+    expect(resolveModelId("sonnet[1m]")).toBe("default");
     expect(resolveModelId("claude-sonnet-4-6")).toBe("default");
-    expect(resolveModelId("claude-sonnet-4-6[1m]")).toBe("sonnet[1m]");
-    expect(resolveModelId("claude-opus-4-6")).toBe("opus");
-
-    expect(get1mContextModelId("default")).toBe("sonnet[1m]");
-    expect(get1mContextModelId("claude-sonnet-4-6")).toBe("sonnet[1m]");
-    expect(get1mContextModelId("opus")).toBe("opus[1m]");
-    expect(get1mContextModelId("haiku")).toBeNull();
-
-    expect(supports1mContext("claude-sonnet-4-6")).toBe(true);
-    expect(supports1mContext("haiku")).toBe(false);
+    expect(resolveModelId("claude-sonnet-4-6[1m]")).toBe("default");
+    expect(resolveModelId("opus")).toBe("opus[1m]");
+    expect(resolveModelId("claude-opus-4-6")).toBe("opus[1m]");
   });
 
   it("derives compatibility aliases from SDK metadata instead of hardcoded versions", async () => {
@@ -140,18 +132,15 @@ describe("registerClaudeModels", () => {
 
     const { registerClaudeModels } =
       await import("../backend/claude-sdk/models.js");
-    const { get1mContextModelId, resolveModelId } =
-      await import("../core/models.js");
+    const { resolveModelId } = await import("../core/models.js");
 
     await registerClaudeModels({ model: "default" });
 
     expect(resolveModelId("claude-sonnet-5-0")).toBe("default");
     expect(resolveModelId("claude-sonnet-4-6")).toBe("default");
-    expect(resolveModelId("claude-opus-5-0")).toBe("opus");
-    expect(resolveModelId("claude-opus-4-6")).toBe("opus");
+    expect(resolveModelId("claude-opus-5-0")).toBe("opus[1m]");
+    expect(resolveModelId("claude-opus-4-6")).toBe("opus[1m]");
     expect(resolveModelId("claude-haiku-5-0")).toBe("haiku");
     expect(resolveModelId("claude-haiku-4-5")).toBe("haiku");
-    expect(get1mContextModelId("claude-sonnet-4-6")).toBe("sonnet[1m]");
-    expect(get1mContextModelId("claude-sonnet-5-0")).toBe("sonnet[1m]");
   });
 });

package/src/__tests__/claude-sdk-options.test.ts

@@ -55,11 +55,6 @@ describe("buildSdkOptions", () => {
         description: "Sonnet 4.6 · Best for everyday tasks",
         aliases: ["claude-sonnet-4-6"],
         provider: "anthropic",
-        capabilities: {
-          supports1mContext: true,
-          oneMillionContextModelId: "sonnet[1m]",
-        },
-        tier: "balanced",
         fallback: "haiku",
       },
       {
@@ -69,8 +64,6 @@ describe("buildSdkOptions", () => {
           "Sonnet 4.6 with 1M context · Billed as extra usage · $3/$15 per Mtok",
         aliases: ["claude-sonnet-4-6[1m]"],
         provider: "anthropic",
-        capabilities: { supports1mContext: true },
-        tier: "balanced",
         fallback: "haiku",
       },
       {
@@ -79,23 +72,22 @@ describe("buildSdkOptions", () => {
         description: "Haiku 4.5 · Fastest for quick answers",
         aliases: ["claude-haiku-4-5"],
         provider: "anthropic",
-        capabilities: { supports1mContext: false },
-        tier: "economy",
       },
     ]);
   });
 
-  it("uses the exact mapped 1M SDK model for legacy Sonnet IDs", async () => {
+  it("resolves legacy aliases to canonical model ID and passes through", async () => {
     const { buildSdkOptions } =
       await import("../backend/claude-sdk/options.js");
 
     const { activeModel, options } = buildSdkOptions("chat-1");
 
     expect(activeModel).toBe("claude-sonnet-4-6");
-    expect(options.model).toBe("sonnet[1m]");
+    // Model is passed through as resolved — SDK handles context window
+    expect(options.model).toBe("default");
   });
 
-  it("leaves models without a mapped 1M variant unchanged", async () => {
+  it("passes model through unchanged when no alias resolution needed", async () => {
     mockGetChatSettings.mockReturnValue({ model: "haiku" });
 
     const { buildSdkOptions } =
@@ -105,7 +97,7 @@ describe("buildSdkOptions", () => {
     expect(options.model).toBe("haiku");
   });
 
-  it("resolves legacy 1M aliases to canonical SDK model IDs", async () => {
+  it("resolves 1M aliases to their canonical SDK model ID", async () => {
     mockGetChatSettings.mockReturnValue({ model: "claude-sonnet-4-6[1m]" });
 
     const { buildSdkOptions } =

package/src/__tests__/fixtures/test-mcp-server.ts

@@ -0,0 +1,37 @@
+/**
+ * Minimal MCP server fixture for lifecycle integration tests.
+ *
+ * Uses the same McpServer + StdioServerTransport + stdin-close pattern
+ * as the real src/core/tools/mcp-server.ts, but without Talon tool
+ * composition so it starts fast and has no external dependencies.
+ *
+ * Signals readiness by writing "READY\n" to stderr.
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+const server = new McpServer({ name: "test-mcp", version: "1.0.0" });
+
+// Register a trivial tool so the server has something to serve
+server.tool("ping", "health check", {}, async () => ({
+  content: [{ type: "text", text: "pong" }],
+}));
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  // Same graceful self-termination as the real mcp-server.ts
+  process.stdin.on("end", () => {
+    server.close().finally(() => process.exit(0));
+  });
+
+  // Signal readiness to the test harness
+  process.stderr.write("READY\n");
+}
+
+main().catch((err) => {
+  process.stderr.write(`test-mcp-server error: ${err}\n`);
+  process.exit(1);
+});

package/src/__tests__/fuzz.test.ts

@@ -327,13 +327,13 @@ describe("fuzz: resolveModelName()", () => {
   it("known aliases resolve to the expected SDK model IDs", () => {
     const aliasMappings = [
       ["sonnet", "default"],
-      ["opus", "opus"],
+      ["opus", "opus[1m]"],
       ["haiku", "haiku"],
       ["sonnet-4.6", "default"],
-      ["opus-4.6", "opus"],
+      ["opus-4.6", "opus[1m]"],
       ["haiku-4.5", "haiku"],
       ["sonnet-4-6", "default"],
-      ["opus-4-6", "opus"],
+      ["opus-4-6", "opus[1m]"],
       ["haiku-4-5", "haiku"],
     ] as const;
     fc.assert(

package/src/__tests__/handlers.test.ts

@@ -1816,6 +1816,49 @@ describe("createStreamCallbacks — onTextBlock delivers message via sendHtml",
 
     expect(sendMsgCount()).toBeGreaterThan(before);
   }, 3000);
+
+  it("does not send the same OpenCode response twice when onTextBlock already delivered it", async () => {
+    const sendMsgCount = () =>
+      (mockBot.api.sendMessage as ReturnType<typeof vi.fn>).mock.calls.length;
+
+    executeMock.mockImplementationOnce(
+      async (params: Record<string, unknown>) => {
+        const onTextBlock = params.onTextBlock as (
+          text: string,
+        ) => Promise<void>;
+        await onTextBlock?.("Hi! 👋");
+        return {
+          text: "Hi! 👋",
+          durationMs: 5,
+          inputTokens: 1,
+          outputTokens: 2,
+          cacheRead: 0,
+          cacheWrite: 0,
+          bridgeMessageCount: 0,
+        };
+      },
+    );
+
+    const before = sendMsgCount();
+    const ctx = {
+      chat: { id: 96003, type: "private" },
+      message: {
+        text: "test duplicate suppression",
+        message_id: 952,
+        reply_to_message: null,
+      },
+      me: { id: 999, username: "testbot" },
+      from: { id: 94, first_name: "Mika" },
+    } as any;
+
+    await handleTextMessage(ctx, mockBot, {
+      ...mockConfig,
+      backend: "opencode",
+    });
+    await new Promise((r) => setTimeout(r, 700));
+
+    expect(sendMsgCount() - before).toBe(1);
+  }, 3000);
 });
 
 describe("sendHtml — falls back to plain text on HTML send failure", () => {
@@ -1874,6 +1917,61 @@ describe("sendHtml — falls back to plain text on HTML send failure", () => {
     // Restore sendMessage mock for other tests
     mockBot.api.sendMessage = vi.fn(async () => ({ message_id: 1 }));
   }, 3000);
+
+  it("fallback iterates to strip nested tag sequences", async () => {
+    executeMock.mockResolvedValue({
+      text: "",
+      durationMs: 10,
+      inputTokens: 1,
+      outputTokens: 1,
+      cacheRead: 0,
+      cacheWrite: 0,
+      bridgeMessageCount: 0,
+    });
+
+    let callCount = 0;
+    mockBot.api.sendMessage = vi.fn(async () => {
+      callCount++;
+      if (callCount === 1) throw new Error("Bad Request: can't parse entities");
+      return { message_id: callCount };
+    });
+
+    const { classify, friendlyMessage } = await import("../core/errors.js");
+    executeMock.mockRejectedValueOnce(new Error("some error"));
+    (classify as ReturnType<typeof vi.fn>).mockReturnValueOnce({
+      reason: "error",
+      message: "some error",
+      retryable: false,
+    });
+    // A single-pass regex leaves a `<script>` survivor after one removal
+    // of the inner placeholder — the iterative loop must keep going.
+    (friendlyMessage as ReturnType<typeof vi.fn>).mockReturnValueOnce(
+      "<scr<script>ipt>alert(1)</script> tail",
+    );
+
+    const ctx = {
+      chat: { id: 97002, type: "private" },
+      message: {
+        text: "nested tag fallback",
+        message_id: 961,
+        reply_to_message: null,
+      },
+      me: { id: 999, username: "testbot" },
+      from: { id: 95, first_name: "Zoe" },
+    } as any;
+
+    await handleTextMessage(ctx, mockBot, mockConfig);
+    await new Promise((r) => setTimeout(r, 700));
+
+    expect(mockBot.api.sendMessage).toHaveBeenCalledTimes(2);
+    const plain = (mockBot.api.sendMessage as ReturnType<typeof vi.fn>).mock
+      .calls[1][1];
+    expect(plain).not.toMatch(/<[^<>]*>/); // no complete tag remains
+    expect(plain).not.toContain("<");
+    expect(plain).toContain("alert(1)");
+
+    mockBot.api.sendMessage = vi.fn(async () => ({ message_id: 1 }));
+  }, 3000);
 });
 
 describe("createStreamCallbacks — onStreamDelta streaming path", () => {

package/src/__tests__/mcp-lifecycle.test.ts

@@ -0,0 +1,165 @@
+/**
+ * Integration tests for MCP server subprocess lifecycle.
+ *
+ * Spawns real MCP server processes (using the same SDK transport as
+ * production) and verifies that closing stdin causes graceful exit.
+ * This is the OS-agnostic teardown mechanism used during hot-reload.
+ */
+
+import { describe, it, expect, afterEach } from "vitest";
+import { spawn, type ChildProcess } from "node:child_process";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const FIXTURE = resolve(__dirname, "fixtures/test-mcp-server.ts");
+const TSX_LOADER = pathToFileURL(
+  resolve(__dirname, "../../node_modules/tsx/dist/esm/index.mjs"),
+).href;
+const STARTUP_TIMEOUT = 15_000;
+const EXIT_TIMEOUT = 10_000;
+
+// Track spawned processes for cleanup
+const spawned: ChildProcess[] = [];
+
+afterEach(() => {
+  for (const child of spawned) {
+    if (child.exitCode === null && child.signalCode === null) {
+      child.kill("SIGKILL");
+    }
+  }
+  spawned.length = 0;
+});
+
+function spawnMcpServer(env?: Record<string, string>): ChildProcess {
+  const child = spawn(process.execPath, ["--import", TSX_LOADER, FIXTURE], {
+    env: { ...process.env, ...env },
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  spawned.push(child);
+  return child;
+}
+
+/** Wait for the server to write "READY\n" on stderr. */
+function waitForReady(child: ChildProcess): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error("MCP server did not become ready in time")),
+      STARTUP_TIMEOUT,
+    );
+    let buf = "";
+    child.stderr!.on("data", (chunk: Buffer) => {
+      buf += chunk.toString();
+      if (buf.includes("READY")) {
+        clearTimeout(timer);
+        resolve();
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      if (!buf.includes("READY")) {
+        reject(new Error(`MCP server exited early (code=${code}): ${buf}`));
+      }
+    });
+  });
+}
+
+/** Wait for the process to exit, with a timeout. Returns exit code or null on timeout. */
+function waitForExit(
+  child: ChildProcess,
+  timeoutMs = EXIT_TIMEOUT,
+): Promise<number | null> {
+  return new Promise((resolve) => {
+    if (child.exitCode !== null) {
+      resolve(child.exitCode);
+      return;
+    }
+    const timer = setTimeout(() => resolve(null), timeoutMs);
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve(code);
+    });
+  });
+}
+
+function isRunning(child: ChildProcess): boolean {
+  return child.exitCode === null && child.signalCode === null;
+}
+
+describe("MCP server subprocess lifecycle", () => {
+  it(
+    "exits gracefully when stdin is closed",
+    async () => {
+      const server = spawnMcpServer();
+      await waitForReady(server);
+
+      expect(isRunning(server)).toBe(true);
+
+      // Close stdin — this is what the SDK does when setMcpServers({}) is called
+      server.stdin!.end();
+
+      const exitCode = await waitForExit(server);
+      expect(exitCode).toBe(0);
+    },
+    STARTUP_TIMEOUT + EXIT_TIMEOUT,
+  );
+
+  it(
+    "old server exits while new server keeps running (reload simulation)",
+    async () => {
+      // Spawn "old" MCP server (as if loaded with first plugin config)
+      const oldServer = spawnMcpServer({
+        TALON_RELOAD_AT: "2024-01-01T00:00:00.000Z",
+      });
+      await waitForReady(oldServer);
+      expect(isRunning(oldServer)).toBe(true);
+
+      // Spawn "new" MCP server (as if reloaded with fresh plugin config)
+      const newServer = spawnMcpServer({
+        TALON_RELOAD_AT: "2024-01-01T00:01:00.000Z",
+      });
+      await waitForReady(newServer);
+      expect(isRunning(newServer)).toBe(true);
+
+      // Simulate two-phase teardown: close old server's stdin
+      oldServer.stdin!.end();
+
+      const oldExitCode = await waitForExit(oldServer);
+      expect(oldExitCode).toBe(0);
+
+      // New server must still be running
+      expect(isRunning(newServer)).toBe(true);
+
+      // Cleanup new server
+      newServer.stdin!.end();
+      await waitForExit(newServer);
+    },
+    2 * STARTUP_TIMEOUT + EXIT_TIMEOUT,
+  );
+
+  it(
+    "multiple old servers all exit when their stdin is closed",
+    async () => {
+      // Spawn 3 servers (simulating accumulated orphans from repeated reloads)
+      const servers = [];
+      for (let i = 0; i < 3; i++) {
+        const s = spawnMcpServer({ TALON_RELOAD_AT: `reload-${i}` });
+        await waitForReady(s);
+        servers.push(s);
+      }
+
+      for (const s of servers) expect(isRunning(s)).toBe(true);
+
+      // Close stdin on all three simultaneously (simulating batch teardown)
+      for (const s of servers) s.stdin!.end();
+
+      // All three should exit cleanly
+      const exits = await Promise.all(servers.map((s) => waitForExit(s)));
+      expect(exits).toEqual([0, 0, 0]);
+    },
+    3 * STARTUP_TIMEOUT + EXIT_TIMEOUT,
+  );
+});

package/src/__tests__/metrics.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  incrementCounter,
+  recordHistogram,
+  getMetrics,
+  resetMetrics,
+} from "../util/metrics.js";
+
+describe("metrics", () => {
+  beforeEach(() => resetMetrics());
+
+  it("increments counters", () => {
+    incrementCounter("test.count");
+    incrementCounter("test.count");
+    incrementCounter("test.count", 3);
+    expect(getMetrics().counters["test.count"]).toBe(5);
+  });
+
+  it("records histograms with percentiles", () => {
+    for (let i = 1; i <= 100; i++) recordHistogram("latency", i);
+    const h = getMetrics().histograms["latency"];
+    expect(h.count).toBe(100);
+    expect(h.p50).toBe(51);
+    expect(h.p95).toBe(96);
+    expect(h.p99).toBe(100);
+    expect(h.avg).toBe(51);
+  });
+
+  it("caps histogram at MAX_HISTOGRAM_SIZE", () => {
+    for (let i = 0; i < 1500; i++) recordHistogram("big", i);
+    expect(getMetrics().histograms["big"].count).toBe(1000);
+  });
+
+  it("resets all metrics", () => {
+    incrementCounter("x");
+    recordHistogram("y", 1);
+    resetMetrics();
+    const m = getMetrics();
+    expect(Object.keys(m.counters)).toHaveLength(0);
+    expect(Object.keys(m.histograms)).toHaveLength(0);
+  });
+
+  it("handles empty histograms", () => {
+    expect(getMetrics().histograms).toEqual({});
+  });
+
+  it("drops NaN, Infinity, and -Infinity from histograms", () => {
+    recordHistogram("clean", 10);
+    recordHistogram("clean", NaN);
+    recordHistogram("clean", Infinity);
+    recordHistogram("clean", -Infinity);
+    recordHistogram("clean", 20);
+    const h = getMetrics().histograms["clean"];
+    expect(h.count).toBe(2);
+    expect(h.avg).toBe(15);
+  });
+
+  it("caps counter keys at MAX_METRIC_KEYS", () => {
+    // Fill up to the cap (500)
+    for (let i = 0; i < 500; i++) incrementCounter(`key_${i}`);
+    expect(Object.keys(getMetrics().counters)).toHaveLength(500);
+    // New key beyond cap is silently dropped
+    incrementCounter("overflow_key");
+    expect(getMetrics().counters["overflow_key"]).toBeUndefined();
+    // Existing keys still work
+    incrementCounter("key_0", 5);
+    expect(getMetrics().counters["key_0"]).toBe(6);
+  });
+
+  it("caps histogram keys at MAX_METRIC_KEYS", () => {
+    for (let i = 0; i < 500; i++) recordHistogram(`h_${i}`, i);
+    expect(Object.keys(getMetrics().histograms)).toHaveLength(500);
+    recordHistogram("overflow_hist", 42);
+    expect(getMetrics().histograms["overflow_hist"]).toBeUndefined();
+  });
+});