talon-agent 1.6.0 → 1.7.0

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

@@ -0,0 +1,118 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockGetSession = vi.fn();
+const mockGetChatSettings = vi.fn();
+const mockGetPluginMcpServers = vi.fn();
+const mockGetConfig = vi.fn();
+const mockGetBridgePort = vi.fn();
+
+vi.mock("../storage/sessions.js", () => ({
+  getSession: (...args: unknown[]) =>
+    mockGetSession(...(args as Parameters<typeof mockGetSession>)),
+}));
+
+vi.mock("../storage/chat-settings.js", () => ({
+  getChatSettings: (...args: unknown[]) =>
+    mockGetChatSettings(...(args as Parameters<typeof mockGetChatSettings>)),
+}));
+
+vi.mock("../core/plugin.js", () => ({
+  getPluginMcpServers: (...args: unknown[]) =>
+    mockGetPluginMcpServers(
+      ...(args as Parameters<typeof mockGetPluginMcpServers>),
+    ),
+}));
+
+vi.mock("../backend/claude-sdk/state.js", () => ({
+  getConfig: (...args: unknown[]) =>
+    mockGetConfig(...(args as Parameters<typeof mockGetConfig>)),
+  getBridgePort: (...args: unknown[]) =>
+    mockGetBridgePort(...(args as Parameters<typeof mockGetBridgePort>)),
+}));
+
+describe("buildSdkOptions", () => {
+  beforeEach(async () => {
+    vi.resetModules();
+    vi.clearAllMocks();
+
+    mockGetSession.mockReturnValue({ sessionId: null });
+    mockGetChatSettings.mockReturnValue({});
+    mockGetPluginMcpServers.mockReturnValue({});
+    mockGetConfig.mockReturnValue({
+      model: "claude-sonnet-4-6",
+      frontend: "terminal",
+      systemPrompt: "test prompt",
+      workspace: "/tmp/workspace",
+    });
+    mockGetBridgePort.mockReturnValue(19876);
+
+    const { clearModels, registerModels } = await import("../core/models.js");
+    clearModels();
+    registerModels([
+      {
+        id: "default",
+        displayName: "Default (recommended)",
+        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",
+      },
+      {
+        id: "sonnet[1m]",
+        displayName: "Sonnet (1M context)",
+        description:
+          "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",
+      },
+      {
+        id: "haiku",
+        displayName: "Haiku",
+        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 () => {
+    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]");
+  });
+
+  it("leaves models without a mapped 1M variant unchanged", async () => {
+    mockGetChatSettings.mockReturnValue({ model: "haiku" });
+
+    const { buildSdkOptions } =
+      await import("../backend/claude-sdk/options.js");
+    const { options } = buildSdkOptions("chat-2");
+
+    expect(options.model).toBe("haiku");
+  });
+
+  it("resolves legacy 1M aliases to canonical SDK model IDs", async () => {
+    mockGetChatSettings.mockReturnValue({ model: "claude-sonnet-4-6[1m]" });
+
+    const { buildSdkOptions } =
+      await import("../backend/claude-sdk/options.js");
+    const { activeModel, options } = buildSdkOptions("chat-3");
+
+    expect(activeModel).toBe("claude-sonnet-4-6[1m]");
+    expect(options.model).toBe("sonnet[1m]");
+  });
+});

package/src/__tests__/config.test.ts

@@ -94,7 +94,7 @@ describe("config", () => {
       const { loadConfig } = await import("../util/config.js");
       const config = loadConfig();
       expect(config.frontend).toBe("terminal");
-      expect(config.model).toBe("claude-sonnet-4-6");
+      expect(config.model).toBe("default");
     });
 
     it("throws when telegram frontend has no botToken", async () => {
@@ -118,7 +118,7 @@ describe("config", () => {
 
       const { loadConfig } = await import("../util/config.js");
       const config = loadConfig();
-      expect(config.model).toBe("claude-sonnet-4-6");
+      expect(config.model).toBe("default");
       expect(config.maxMessageLength).toBe(4000);
       expect(config.concurrency).toBe(1);
       expect(config.pulse).toBe(true);
@@ -195,10 +195,91 @@ describe("config", () => {
       const { loadConfig } = await import("../util/config.js");
       const config = loadConfig();
       expect(config.plugins).toHaveLength(2);
-      expect(config.plugins[0].path).toBe("./plugins/my-plugin");
-      expect(config.plugins[0].config).toEqual({ key: "value" });
-      expect(config.plugins[1].path).toBe("./plugins/another");
-      expect(config.plugins[1].config).toBeUndefined();
+      const [firstPlugin, secondPlugin] = config.plugins;
+
+      expect("path" in firstPlugin).toBe(true);
+      if ("path" in firstPlugin) {
+        expect(firstPlugin.path).toBe("./plugins/my-plugin");
+        expect(firstPlugin.config).toEqual({ key: "value" });
+      }
+
+      expect("path" in secondPlugin).toBe(true);
+      if ("path" in secondPlugin) {
+        expect(secondPlugin.path).toBe("./plugins/another");
+        expect(secondPlugin.config).toBeUndefined();
+      }
+    });
+
+    it("parses standalone MCP plugins in config", async () => {
+      mockFs({
+        frontend: "terminal",
+        plugins: [
+          {
+            name: "polymarket",
+            command: "node",
+            args: ["/tmp/polymarket.js"],
+            env: { POLYMARKET_PRIVATE_KEY: "0x123" },
+          },
+        ],
+      });
+
+      const { loadConfig } = await import("../util/config.js");
+      const config = loadConfig();
+
+      expect(config.plugins).toEqual([
+        {
+          name: "polymarket",
+          command: "node",
+          args: ["/tmp/polymarket.js"],
+          env: { POLYMARKET_PRIVATE_KEY: "0x123" },
+        },
+      ]);
+    });
+
+    it("rejects plugin entries that mix path and standalone MCP fields", async () => {
+      mockFs({
+        frontend: "terminal",
+        plugins: [
+          {
+            path: "./plugins/extras",
+            name: "extras",
+            command: "node",
+          },
+        ],
+      });
+
+      const { loadConfig } = await import("../util/config.js");
+      expect(() => loadConfig()).toThrow("exactly one format");
+    });
+
+    it("rejects standalone MCP entries missing required fields", async () => {
+      mockFs({
+        frontend: "terminal",
+        plugins: [{ name: "polymarket" }],
+      });
+
+      const { loadConfig } = await import("../util/config.js");
+      expect(() => loadConfig()).toThrow(
+        "MCP plugin entries must include 'command'",
+      );
+    });
+
+    it("rejects standalone MCP entries with config blocks", async () => {
+      mockFs({
+        frontend: "terminal",
+        plugins: [
+          {
+            name: "polymarket",
+            command: "node",
+            config: { market: "crypto" },
+          },
+        ],
+      });
+
+      const { loadConfig } = await import("../util/config.js");
+      expect(() => loadConfig()).toThrow(
+        "MCP plugin entries cannot include 'config'",
+      );
     });
 
     it("defaults plugins to empty array", async () => {
@@ -235,6 +316,29 @@ describe("config", () => {
       const config = loadConfig();
       expect(config.frontend).toEqual(["terminal"]);
     });
+
+    it("preserves Playwright endpoint settings from config", async () => {
+      mockFs({
+        frontend: "terminal",
+        playwright: {
+          enabled: true,
+          browser: "firefox",
+          endpoint: "ws://127.0.0.1:9222/devtools/browser/test",
+          endpointFile: "/tmp/camoufox-endpoint.txt",
+        },
+      });
+
+      const { loadConfig } = await import("../util/config.js");
+      const config = loadConfig();
+
+      expect(config.playwright).toEqual({
+        enabled: true,
+        browser: "firefox",
+        headless: true,
+        endpoint: "ws://127.0.0.1:9222/devtools/browser/test",
+        endpointFile: "/tmp/camoufox-endpoint.txt",
+      });
+    });
   });
 
   describe("system prompt", () => {
@@ -533,12 +637,12 @@ describe("config", () => {
       expect(() => loadConfig()).toThrow();
     });
 
-    it("default model is exactly claude-sonnet-4-6", async () => {
+    it("defaults the canonical Claude model to default", async () => {
       mockFs({ frontend: "terminal" });
 
       const { loadConfig } = await import("../util/config.js");
       const config = loadConfig();
-      expect(config.model).toBe("claude-sonnet-4-6");
+      expect(config.model).toBe("default");
     });
 
     it("default pulse is exactly true", async () => {

package/src/__tests__/dream.test.ts

@@ -881,7 +881,7 @@ describe("dream error paths", () => {
     );
   });
 
-  it("model defaults to 'claude-sonnet-4-6' when neither dreamModel nor model set (line 135 FALSE??FALSE branch)", async () => {
+  it("model defaults to 'default' when neither dreamModel nor model set (line 135 FALSE??FALSE branch)", async () => {
     vi.doMock("node:fs", () => ({
       existsSync: vi.fn(() => false),
       readFileSync: vi.fn(() => "dream prompt"),
@@ -913,14 +913,14 @@ describe("dream error paths", () => {
     vi.doMock("@anthropic-ai/claude-agent-sdk", () => ({ query: queryMock }));
 
     const mod = await import("../core/dream.js");
-    // No model or dreamModel → falls through to "claude-sonnet-4-6" literal default
+    // No model or dreamModel → falls through to the canonical SDK default model
     mod.initDream({ workspace: "/fake/ws" });
     await mod.forceDream();
 
     const callArgs = (queryMock.mock.calls[0] as unknown[])[0] as {
       options: Record<string, unknown>;
     };
-    expect(callArgs.options).toHaveProperty("model", "claude-sonnet-4-6");
+    expect(callArgs.options).toHaveProperty("model", "default");
   });
 });
 

package/src/__tests__/fuzz.test.ts

@@ -324,25 +324,25 @@ describe("fuzz: resolveModelName()", () => {
     );
   });
 
-  it("known aliases always resolve to claude model names", () => {
-    const aliases = [
-      "sonnet",
-      "opus",
-      "haiku",
-      "sonnet-4.6",
-      "opus-4.6",
-      "haiku-4.5",
-      "sonnet-4-6",
-      "opus-4-6",
-      "haiku-4-5",
-    ];
+  it("known aliases resolve to the expected SDK model IDs", () => {
+    const aliasMappings = [
+      ["sonnet", "default"],
+      ["opus", "opus"],
+      ["haiku", "haiku"],
+      ["sonnet-4.6", "default"],
+      ["opus-4.6", "opus"],
+      ["haiku-4.5", "haiku"],
+      ["sonnet-4-6", "default"],
+      ["opus-4-6", "opus"],
+      ["haiku-4-5", "haiku"],
+    ] as const;
     fc.assert(
       fc.property(
-        fc.constantFrom(...aliases),
+        fc.constantFrom(...aliasMappings),
         fc.constantFrom("", " ", "  "),
-        (alias, padding) => {
+        ([alias, expectedModelId], padding) => {
           const result = resolveModelName(padding + alias + padding);
-          expect(result).toMatch(/^claude-/);
+          expect(result).toBe(expectedModelId);
         },
       ),
       fcParams,

package/src/__tests__/plugin.test.ts

@@ -1,3 +1,4 @@
+import type { TalonConfig } from "../util/config.js";
 import { describe, it, expect, vi, beforeEach } from "vitest";
 
 vi.mock("../util/log.js", () => ({
@@ -27,6 +28,27 @@ describe("plugin system", () => {
     };
   }
 
+  function createTestConfig(overrides: Partial<TalonConfig> = {}): TalonConfig {
+    return {
+      frontend: "terminal",
+      backend: "claude",
+      model: "default",
+      maxMessageLength: 4000,
+      concurrency: 1,
+      pulse: true,
+      pulseIntervalMs: 300000,
+      heartbeat: false,
+      heartbeatIntervalMinutes: 60,
+      plugins: [],
+      botDisplayName: "Talon",
+      teamsWebhookPort: 19878,
+      teamsGraphPollMs: 10000,
+      systemPrompt: "test prompt",
+      workspace: "/tmp/workspace",
+      ...overrides,
+    };
+  }
+
   /** Import fresh plugin module with fs mocked to find entry + dynamic import returning plugin. */
   async function setup(plugin: ReturnType<typeof createMockPlugin>) {
     vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
@@ -247,6 +269,75 @@ describe("plugin system", () => {
       );
     });
 
+    it("does not let plugin env vars override bridge metadata", async () => {
+      const plugin = createMockPlugin({
+        mcpServer: {
+          command: "/usr/bin/python3",
+          args: ["-m", "my_server"],
+        },
+        getEnvVars: () => ({
+          TALON_BRIDGE_URL: "http://malicious.example",
+          TALON_CHAT_ID: "wrong-chat",
+          MY_KEY: "val",
+        }),
+      });
+      delete (plugin as Record<string, unknown>).mcpServerPath;
+      const { loadPlugins, getPluginMcpServers } = await setup(plugin);
+      await loadPlugins([{ path: "/fake/plugin" }]);
+
+      const servers = getPluginMcpServers("http://localhost:19876", "chat1");
+      expect(servers["test-plugin-tools"].env).toMatchObject({
+        TALON_BRIDGE_URL: "http://localhost:19876",
+        TALON_CHAT_ID: "chat1",
+        MY_KEY: "val",
+      });
+    });
+
+    it("builds standalone MCP server entries from config", async () => {
+      const { loadPlugins, getPluginMcpServers } =
+        await setup(createMockPlugin());
+      await loadPlugins([
+        {
+          name: "standalone",
+          command: "node",
+          args: ["/tmp/server.js"],
+          env: {
+            API_KEY: "secret",
+            TALON_BRIDGE_URL: "http://malicious.example",
+            TALON_CHAT_ID: "wrong-chat",
+          },
+        },
+      ]);
+
+      const servers = getPluginMcpServers("http://localhost:19876", "chat1");
+      expect(servers["standalone-tools"]).toEqual({
+        command: "node",
+        args: ["/tmp/server.js"],
+        env: {
+          API_KEY: "secret",
+          TALON_BRIDGE_URL: "http://localhost:19876",
+          TALON_CHAT_ID: "chat1",
+        },
+      });
+    });
+
+    it("skips path plugins that collide with standalone MCP names", async () => {
+      const initFn = vi.fn();
+      const plugin = createMockPlugin({ init: initFn });
+      const { loadPlugins, getPluginCount, getPluginMcpServers } =
+        await setup(plugin);
+      await loadPlugins([
+        { name: "test-plugin", command: "node", args: ["/tmp/server.js"] },
+        { path: "/fake/plugin" },
+      ]);
+
+      expect(getPluginCount()).toBe(0);
+      expect(initFn).not.toHaveBeenCalled();
+      expect(
+        getPluginMcpServers("http://localhost:19876", "chat1"),
+      ).toHaveProperty("test-plugin-tools");
+    });
+
     it("mcpServer takes priority over mcpServerPath when both are set", async () => {
       const plugin = createMockPlugin({
         mcpServerPath: "/fake/tools.ts",
@@ -276,12 +367,42 @@ describe("plugin system", () => {
     });
   });
 
+  describe("reload", () => {
+    it("clears standalone MCP entries on hot reload", async () => {
+      vi.resetModules();
+      vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+      vi.doMock("../util/config.js", () => ({
+        loadConfig: () => ({
+          frontend: "terminal",
+          model: "default",
+          plugins: [],
+          systemPrompt: "test prompt",
+          workspace: "/tmp/workspace",
+        }),
+        getFrontends: () => ["terminal"],
+      }));
+
+      const mod = await import("../core/plugin.js");
+      await mod.loadPlugins([{ name: "standalone", command: "node" }]);
+      expect(
+        mod.getPluginMcpServers("http://localhost:19876", "chat1"),
+      ).toHaveProperty("standalone-tools");
+
+      await mod.reloadPlugins();
+
+      expect(
+        mod.getPluginMcpServers("http://localhost:19876", "chat1"),
+      ).toEqual({});
+    });
+  });
+
   describe("registerPlugin (built-in)", () => {
     it("registers a built-in plugin directly", async () => {
       const plugin = createMockPlugin({ name: "built-in-test" });
       const { registerPlugin, getPlugin } = await setup(createMockPlugin());
 
-      registerPlugin(plugin, { key: "val" });
+      const loaded = registerPlugin(plugin, { key: "val" });
+      expect(loaded?.path).toBe("(built-in)");
       expect(getPlugin("built-in-test")).toBeDefined();
       expect(getPlugin("built-in-test")!.path).toBe("(built-in)");
     });
@@ -306,9 +427,27 @@ describe("plugin system", () => {
       });
       const { registerPlugin, getPlugin } = await setup(createMockPlugin());
 
-      registerPlugin(plugin, {});
+      expect(registerPlugin(plugin, {})).toBeNull();
       expect(getPlugin("builtin-invalid")).toBeUndefined();
     });
+
+    it("does not init a built-in plugin when duplicate registration is skipped", async () => {
+      const init = vi.fn();
+      const githubPlugin = createMockPlugin({ name: "github", init });
+
+      vi.doMock("../plugins/github/index.js", () => ({
+        createGitHubPlugin: () => githubPlugin,
+      }));
+
+      const mod = await import("../core/plugin.js");
+      await mod.loadPlugins([{ name: "github", command: "node" }]);
+      await mod.loadBuiltinPlugins(
+        createTestConfig({ github: { enabled: true } }),
+      );
+
+      expect(init).not.toHaveBeenCalled();
+      expect(mod.getPlugin("github")).toBeUndefined();
+    });
   });
 
   describe("system prompt additions", () => {
@@ -366,6 +505,20 @@ describe("plugin system", () => {
       expect(getPluginCount()).toBe(1);
     });
 
+    it("does not leave an init timeout running for plugins without init", async () => {
+      vi.useFakeTimers();
+      try {
+        const plugin = createMockPlugin();
+        const { loadPlugins } = await setup(plugin);
+
+        await loadPlugins([{ path: "/fake/plugin" }]);
+
+        expect(vi.getTimerCount()).toBe(0);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
     it("catches destroy errors without crashing", async () => {
       const plugin = createMockPlugin({
         destroy: () => {

package/src/__tests__/telegram-helpers.test.ts

@@ -0,0 +1,113 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { clearModels, registerModels } from "../core/models.js";
+import {
+  formatCompactModelLabel,
+  formatModelLabel,
+  formatModelOptionLabel,
+  getTelegramModelOptions,
+  isSelectedModel,
+  renderSettingsKeyboard,
+} from "../frontend/telegram/helpers.js";
+
+describe("telegram helpers", () => {
+  beforeEach(() => {
+    clearModels();
+    registerModels([
+      {
+        id: "default",
+        displayName: "Default (recommended)",
+        description: "Sonnet 4.6 · Best for everyday tasks",
+        aliases: ["sonnet", "claude-sonnet-4-6"],
+        provider: "anthropic",
+        capabilities: {
+          supports1mContext: true,
+          oneMillionContextModelId: "sonnet[1m]",
+        },
+        tier: "balanced",
+        fallback: "haiku",
+      },
+      {
+        id: "sonnet[1m]",
+        displayName: "Sonnet (1M context)",
+        description:
+          "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",
+      },
+      {
+        id: "opus",
+        displayName: "Opus",
+        description: "Opus 4.6 · Most capable for complex work",
+        aliases: ["claude-opus-4-6"],
+        provider: "anthropic",
+        capabilities: {
+          supports1mContext: true,
+          oneMillionContextModelId: "opus[1m]",
+        },
+        tier: "premium",
+        fallback: "default",
+      },
+      {
+        id: "opus[1m]",
+        displayName: "Opus (1M context)",
+        description:
+          "Opus 4.6 with 1M context · Billed as extra usage · $5/$25 per Mtok",
+        aliases: ["claude-opus-4-6[1m]"],
+        provider: "anthropic",
+        capabilities: { supports1mContext: true },
+        tier: "premium",
+        fallback: "default",
+      },
+      {
+        id: "haiku",
+        displayName: "Haiku",
+        description: "Haiku 4.5 · Fastest for quick answers",
+        aliases: ["claude-haiku-4-5"],
+        provider: "anthropic",
+        capabilities: { supports1mContext: false },
+        tier: "economy",
+      },
+    ]);
+  });
+
+  it("matches legacy aliases to the canonical selected model", () => {
+    expect(isSelectedModel("claude-sonnet-4-6", "default")).toBe(true);
+    expect(isSelectedModel("sonnet[1m]", "default")).toBe(true);
+    expect(isSelectedModel("claude-sonnet-4-6", "haiku")).toBe(false);
+  });
+
+  it("formats clean model labels for telegram users", () => {
+    expect(formatModelLabel("default")).toBe("Sonnet 4.6");
+    expect(formatModelLabel("claude-sonnet-4-6")).toBe("Sonnet 4.6");
+    expect(formatModelLabel("sonnet[1m]")).toBe("Sonnet 4.6");
+    expect(formatModelOptionLabel(getTelegramModelOptions()[0]!)).toBe(
+      "Opus 4.6",
+    );
+    expect(formatCompactModelLabel(getTelegramModelOptions()[1]!)).toBe(
+      "Sonnet",
+    );
+  });
+
+  it("shows a single clean option per model family", () => {
+    expect(getTelegramModelOptions().map((model) => model.id)).toEqual([
+      "opus",
+      "default",
+      "haiku",
+    ]);
+  });
+
+  it("marks the canonical model button as selected for legacy aliases", () => {
+    const buttons = renderSettingsKeyboard(
+      "claude-sonnet-4-6",
+      "adaptive",
+      true,
+    )
+      .flat()
+      .map((button) => button.text);
+
+    expect(buttons).toContain("\u2713 Sonnet");
+  });
+});

package/src/backend/claude-sdk/handler.ts

@@ -122,7 +122,7 @@ export async function handleMessage(
 
       // Final result — read token counts and context info
       if (isResult(message)) {
-        processResultMessage(message, state);
+        processResultMessage(message, state, options.model ?? activeModel);
       }
     }
   } catch (err) {