talon-agent 1.7.0 → 1.8.0

package/package.json

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

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

@@ -58,24 +58,19 @@ describe("registerClaudeModels", () => {
     clearModels();
   });
 
-  it("keeps SDK IDs/display names and maps 1M upgrades explicitly", async () => {
+  it("keeps SDK IDs/display names and collapses duplicates", 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" });
 
     const anthropicModels = getModels("anthropic");
     expect(anthropicModels.map((model) => model.id)).toEqual([
-      "opus",
-      "opus[1m]",
       "default",
       "sonnet[1m]",
+      "opus",
+      "opus[1m]",
       "haiku",
     ]);
 
@@ -85,6 +80,7 @@ describe("registerClaudeModels", () => {
     expect(
       anthropicModels.find((model) => model.id === "sonnet[1m]")?.displayName,
     ).toBe("Sonnet (1M context)");
+    // claude-sonnet-4-6 collapsed into "default" as alias
     expect(
       anthropicModels.some((model) => model.id === "claude-sonnet-4-6"),
     ).toBe(false);
@@ -92,14 +88,6 @@ describe("registerClaudeModels", () => {
     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);
   });
 
   it("derives compatibility aliases from SDK metadata instead of hardcoded versions", async () => {
@@ -140,8 +128,7 @@ 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" });
 
@@ -151,7 +138,5 @@ describe("registerClaudeModels", () => {
     expect(resolveModelId("claude-opus-4-6")).toBe("opus");
     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__/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", () => {

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();
+  });
+});

package/src/__tests__/opencode-models.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("../util/log.js", () => ({
+  log: vi.fn(),
+  logError: vi.fn(),
+  logWarn: vi.fn(),
+}));
+
+const { getOpenCodeModelSelectionValue, resolveOpenCodeModelInput } =
+  await import("../backend/opencode/index.js");
+
+const catalog = {
+  generatedAt: Date.now(),
+  providers: [],
+  connectedProviders: [],
+  loginProviders: [],
+  connectedModels: [],
+  connectedFreeModels: [],
+  models: [
+    {
+      id: "gpt-5",
+      name: "GPT-5",
+      providerID: "openai",
+      providerName: "OpenAI",
+      providerSource: "api",
+      connected: false,
+      selectable: false,
+      loginRequired: true,
+      envRequired: false,
+      authMethods: ["OAuth"],
+      free: false,
+      status: "active",
+      contextWindow: 400000,
+      outputWindow: 128000,
+      reasoning: true,
+      attachment: true,
+      toolcall: true,
+      costInput: 1,
+      costOutput: 2,
+      costCacheRead: 0,
+      costCacheWrite: 0,
+    },
+    {
+      id: "gpt-5",
+      name: "GPT-5",
+      providerID: "github-copilot",
+      providerName: "GitHub Copilot",
+      providerSource: "api",
+      connected: true,
+      selectable: true,
+      loginRequired: false,
+      envRequired: false,
+      authMethods: [],
+      free: false,
+      status: "active",
+      contextWindow: 400000,
+      outputWindow: 128000,
+      reasoning: true,
+      attachment: true,
+      toolcall: true,
+      costInput: 1,
+      costOutput: 2,
+      costCacheRead: 0,
+      costCacheWrite: 0,
+    },
+    {
+      id: "big-pickle",
+      name: "Big Pickle",
+      providerID: "opencode",
+      providerName: "OpenCode Zen",
+      providerSource: "api",
+      connected: true,
+      selectable: true,
+      loginRequired: false,
+      envRequired: false,
+      authMethods: [],
+      free: true,
+      status: "active",
+      contextWindow: 200000,
+      outputWindow: 128000,
+      reasoning: true,
+      attachment: false,
+      toolcall: true,
+      costInput: 0,
+      costOutput: 0,
+      costCacheRead: 0,
+      costCacheWrite: 0,
+    },
+  ],
+};
+
+describe("OpenCode model resolution", () => {
+  it("resolves provider-qualified model queries exactly", () => {
+    const resolution = resolveOpenCodeModelInput(
+      "github-copilot/gpt-5",
+      catalog,
+    );
+
+    expect(resolution.kind).toBe("exact");
+    if (resolution.kind !== "exact") return;
+    expect(resolution.model.providerID).toBe("github-copilot");
+  });
+
+  it("uses provider-qualified storage values only for colliding model ids", () => {
+    const duplicateValue = getOpenCodeModelSelectionValue(
+      catalog.models[0],
+      catalog,
+    );
+    const uniqueValue = getOpenCodeModelSelectionValue(
+      catalog.models[2],
+      catalog,
+    );
+
+    expect(duplicateValue).toBe("openai/gpt-5");
+    expect(uniqueValue).toBe("big-pickle");
+  });
+});

package/src/__tests__/opencode-summary.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("../util/log.js", () => ({
+  log: vi.fn(),
+  logError: vi.fn(),
+  logWarn: vi.fn(),
+}));
+
+const { summarizeOpenCodeAssistantMessages } =
+  await import("../backend/opencode/index.js");
+
+describe("OpenCode assistant summaries", () => {
+  it("aggregates usage across the full assistant chain for a turn", () => {
+    const summary = summarizeOpenCodeAssistantMessages(
+      [
+        {
+          info: {
+            role: "assistant",
+            modelID: "big-pickle",
+            providerID: "opencode",
+            time: { created: 110, completed: 120 },
+            tokens: {
+              input: 100,
+              output: 20,
+              reasoning: 5,
+              cache: { read: 1, write: 2 },
+            },
+            cost: 0.1,
+          },
+          parts: [{ type: "tool" }],
+        },
+        {
+          info: {
+            role: "assistant",
+            modelID: "big-pickle",
+            providerID: "opencode",
+            time: { created: 121, completed: 140 },
+            tokens: {
+              input: 150,
+              output: 30,
+              reasoning: 7,
+              cache: { read: 3, write: 4 },
+            },
+            cost: 0.2,
+          },
+          parts: [{ type: "text", text: "done" }],
+        },
+      ],
+      100,
+    );
+
+    expect(summary.usage.assistantMessages).toBe(2);
+    expect(summary.usage.inputTokens).toBe(250);
+    expect(summary.usage.outputTokens).toBe(50);
+    expect(summary.usage.reasoningTokens).toBe(12);
+    expect(summary.usage.cacheRead).toBe(4);
+    expect(summary.usage.cacheWrite).toBe(6);
+    expect(summary.usage.costUsd).toBeCloseTo(0.3);
+    expect(summary.latestAssistant?.createdAt).toBe(121);
+  });
+
+  it("ignores incomplete placeholder assistant messages when selecting the latest snapshot", () => {
+    const summary = summarizeOpenCodeAssistantMessages([
+      {
+        info: {
+          role: "assistant",
+          modelID: "nemotron-3-super-free",
+          providerID: "opencode",
+          time: { created: 200, completed: 230 },
+          finish: "stop",
+          tokens: {
+            input: 400,
+            output: 40,
+            reasoning: 10,
+            cache: { read: 0, write: 0 },
+          },
+          cost: 0,
+        },
+        parts: [{ type: "text", text: "final" }],
+      },
+      {
+        info: {
+          role: "assistant",
+          modelID: "nemotron-3-super-free",
+          providerID: "opencode",
+          time: { created: 240, completed: undefined },
+          finish: undefined,
+          tokens: {
+            input: 0,
+            output: 0,
+            reasoning: 0,
+            cache: { read: 0, write: 0 },
+          },
+          cost: 0,
+        },
+        parts: [],
+      },
+    ]);
+
+    expect(summary.latestAssistant?.createdAt).toBe(200);
+    expect(summary.usage.assistantMessages).toBe(1);
+    expect(summary.usage.inputTokens).toBe(400);
+    expect(summary.usage.outputTokens).toBe(40);
+  });
+});