talon-agent 1.7.0 → 1.8.0

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

@@ -0,0 +1,94 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("../backend/opencode/index.js", async (importOriginal) => {
+  const mod =
+    await importOriginal<typeof import("../backend/opencode/index.js")>();
+  return {
+    ...mod,
+    getOpenCodeModelSelectionValue: vi.fn(
+      (model: { providerID?: string; id: string }) =>
+        `${model.providerID}/${model.id}`,
+    ),
+  };
+});
+
+const { formatOpenCodeSelectionError } =
+  await import("../backend/opencode/index.js");
+
+function makeEntry(overrides: Record<string, unknown> = {}) {
+  return {
+    id: "m",
+    name: "M",
+    providerID: "p",
+    providerName: "P",
+    providerSource: "api",
+    connected: false,
+    selectable: false,
+    loginRequired: true,
+    envRequired: false,
+    authMethods: ["OAuth"],
+    free: false,
+    status: "active",
+    contextWindow: 400_000,
+    outputWindow: 128_000,
+    reasoning: true,
+    attachment: true,
+    toolcall: true,
+    costInput: 1,
+    costOutput: 2,
+    costCacheRead: 0,
+    costCacheWrite: 0,
+    ...overrides,
+  };
+}
+
+const emptyCatalog = {
+  generatedAt: Date.now(),
+  providers: [],
+  models: [],
+  connectedProviders: [],
+  loginProviders: [],
+  connectedModels: [],
+  connectedFreeModels: [],
+};
+
+describe("formatOpenCodeSelectionError", () => {
+  it("includes provider details for ambiguous matches", () => {
+    const matches = [
+      makeEntry({
+        id: "gpt-5",
+        name: "GPT-5",
+        providerID: "openai",
+        providerName: "OpenAI",
+      }),
+      makeEntry({
+        id: "gpt-5",
+        name: "GPT-5",
+        providerID: "github-copilot",
+        providerName: "GitHub Copilot",
+      }),
+    ];
+
+    const text = formatOpenCodeSelectionError(
+      "gpt-5",
+      { kind: "ambiguous", matches: matches as any },
+      { ...emptyCatalog, models: matches } as any,
+    );
+
+    expect(text).toContain("OpenAI / openai");
+    expect(text).toContain("GitHub Copilot / github-copilot");
+    expect(text).toContain("login required");
+    expect(text).toContain("openai/gpt-5");
+    expect(text).toContain("github-copilot/gpt-5");
+  });
+
+  it("returns missing message for no matches", () => {
+    const text = formatOpenCodeSelectionError(
+      "nonexistent",
+      { kind: "missing", matches: [] } as any,
+      emptyCatalog as any,
+    );
+    expect(text).toContain("nonexistent");
+    expect(text).toContain("No OpenCode model matched");
+  });
+});

package/src/__tests__/plugin.test.ts

@@ -310,15 +310,16 @@ describe("plugin system", () => {
       ]);
 
       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",
-        },
+      expect(servers["standalone-tools"].command).toBe("node");
+      expect(servers["standalone-tools"].args).toEqual(["/tmp/server.js"]);
+      expect(servers["standalone-tools"].env).toMatchObject({
+        API_KEY: "secret",
+        TALON_BRIDGE_URL: "http://localhost:19876",
+        TALON_CHAT_ID: "chat1",
       });
+      expect(servers["standalone-tools"].env.TALON_RELOAD_AT).toMatch(
+        /^\d{4}-\d{2}-\d{2}T/,
+      );
     });
 
     it("skips path plugins that collide with standalone MCP names", async () => {

package/src/__tests__/reload-plugins.test.ts

@@ -25,6 +25,52 @@ vi.mock("cheerio", () => ({
   }),
 }));
 
+// Mocks needed for handler.ts (getActiveQuery) transitive imports
+vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
+  query: vi.fn(),
+}));
+vi.mock("../storage/sessions.js", () => ({
+  getSession: vi.fn(),
+  incrementTurns: vi.fn(),
+  recordUsage: vi.fn(),
+  resetSession: vi.fn(),
+  setSessionId: vi.fn(),
+  setSessionName: vi.fn(),
+}));
+vi.mock("../storage/chat-settings.js", () => ({
+  getChatSettings: vi.fn(() => ({})),
+  setChatModel: vi.fn(),
+}));
+vi.mock("../core/errors.js", () => ({
+  classify: vi.fn(),
+}));
+vi.mock("../core/models.js", () => ({
+  getFallbackModel: vi.fn(),
+}));
+vi.mock("../util/trace.js", () => ({
+  traceMessage: vi.fn(),
+}));
+vi.mock("../util/time.js", () => ({
+  formatFullDatetime: vi.fn(() => ""),
+}));
+vi.mock("../backend/claude-sdk/state.js", () => ({
+  getConfig: vi.fn(() => ({})),
+}));
+vi.mock("../backend/claude-sdk/options.js", () => ({
+  buildSdkOptions: vi.fn(() => ({})),
+  buildMcpServers: vi.fn(() => ({})),
+}));
+vi.mock("../backend/claude-sdk/stream.js", () => ({
+  createStreamState: vi.fn(),
+  isSystemInit: vi.fn(),
+  isStreamEvent: vi.fn(),
+  isAssistant: vi.fn(),
+  isResult: vi.fn(),
+  processStreamDelta: vi.fn(),
+  processAssistantMessage: vi.fn(),
+  processResultMessage: vi.fn(),
+}));
+
 // Mock storage modules required by gateway-actions
 vi.mock("../storage/history.js", () => ({
   getRecentFormatted: vi.fn(() => ""),
@@ -76,12 +122,26 @@ vi.mock("../util/config.js", () => ({
 }));
 
 // Backend mock — passed as 3rd arg to handleSharedAction
+const mockRefreshMcpServers = vi.fn();
 const mockBackend = {
   query: vi.fn(),
   updateSystemPrompt: (...args: unknown[]) =>
     mockUpdateSystemPrompt(
       ...(args as Parameters<typeof mockUpdateSystemPrompt>),
     ),
+  refreshMcpServers: (...args: unknown[]) =>
+    mockRefreshMcpServers(
+      ...(args as Parameters<typeof mockRefreshMcpServers>),
+    ),
+};
+
+// Backend without refreshMcpServers (e.g. non-Claude backend)
+const mockBackendNoMcp = {
+  query: vi.fn(),
+  updateSystemPrompt: (...args: unknown[]) =>
+    mockUpdateSystemPrompt(
+      ...(args as Parameters<typeof mockUpdateSystemPrompt>),
+    ),
 };
 
 // ── Import after mocks ────────────────────────────────────────────────────
@@ -101,6 +161,7 @@ describe("reload_plugins gateway action", () => {
     mockGetPluginPromptAdditions.mockReturnValue("prompt additions");
     mockRebuildSystemPrompt.mockImplementation(() => {});
     mockUpdateSystemPrompt.mockImplementation(() => {});
+    mockRefreshMcpServers.mockResolvedValue(null);
   });
 
   it("returns loaded plugin names on success", async () => {
@@ -175,6 +236,72 @@ describe("reload_plugins gateway action", () => {
     expect(result!.text).toContain("(0)");
     expect(result!.text).toContain("(none)");
   });
+
+  it("calls refreshMcpServers after plugin reload", async () => {
+    await handleSharedAction({ action: "reload_plugins" }, 12345, mockBackend);
+    expect(mockRefreshMcpServers).toHaveBeenCalledTimes(1);
+    expect(mockRefreshMcpServers).toHaveBeenCalledWith("12345");
+  });
+
+  it("uses body._chatId over numeric chatId when present", async () => {
+    await handleSharedAction(
+      { action: "reload_plugins", _chatId: "teams_chat_abc123" },
+      12345,
+      mockBackend,
+    );
+    expect(mockRefreshMcpServers).toHaveBeenCalledWith("teams_chat_abc123");
+  });
+
+  it("falls back to String(chatId) when body._chatId is absent", async () => {
+    await handleSharedAction({ action: "reload_plugins" }, 99999, mockBackend);
+    expect(mockRefreshMcpServers).toHaveBeenCalledWith("99999");
+  });
+
+  it("includes MCP update info in response", async () => {
+    mockRefreshMcpServers.mockResolvedValue({
+      added: ["foo-tools"],
+      removed: ["old-tools"],
+      errors: {},
+    });
+    const result = await handleSharedAction(
+      { action: "reload_plugins" },
+      12345,
+      mockBackend,
+    );
+    expect(result!.ok).toBe(true);
+    expect(result!.text).toContain("MCP servers updated");
+    expect(result!.text).toContain("added: foo-tools");
+    expect(result!.text).toContain("removed: old-tools");
+  });
+
+  it("handles refreshMcpServers errors gracefully", async () => {
+    mockRefreshMcpServers.mockRejectedValue(
+      new Error("setMcpServers timed out"),
+    );
+    const result = await handleSharedAction(
+      { action: "reload_plugins" },
+      12345,
+      mockBackend,
+    );
+    // Reload still succeeds — MCP failure is a warning, not a hard error
+    expect(result!.ok).toBe(true);
+    expect(result!.text).toContain("Plugins reloaded successfully");
+    expect(result!.text).toContain("Warning: MCP server refresh failed");
+    expect(result!.text).toContain("setMcpServers timed out");
+  });
+
+  it("works when refreshMcpServers is not defined on backend", async () => {
+    const result = await handleSharedAction(
+      { action: "reload_plugins" },
+      12345,
+      mockBackendNoMcp,
+    );
+    expect(result!.ok).toBe(true);
+    expect(result!.text).toContain("Plugins reloaded successfully");
+    // Should not mention MCP at all when the method is absent
+    expect(result!.text).not.toContain("MCP");
+    expect(result!.text).not.toContain("Warning");
+  });
 });
 
 // ── Admin tool description tests ──────────────────────────────────────────
@@ -203,3 +330,13 @@ describe("admin tool description", () => {
     expect(reloadTool!.tag).toBe("admin");
   });
 });
+
+// ── getActiveQuery tests ─────────────────────────────────────────────────────
+
+describe("getActiveQuery", () => {
+  it("is exported and returns undefined when no query is active", async () => {
+    const { getActiveQuery } = await import("../backend/claude-sdk/handler.js");
+    expect(typeof getActiveQuery).toBe("function");
+    expect(getActiveQuery("nonexistent-chat-id")).toBeUndefined();
+  });
+});

package/src/__tests__/sessions.test.ts

@@ -826,11 +826,6 @@ describe("sessions — edge cases for branch coverage", () => {
     expect(session.usage.fastestResponseMs).toBe(500);
   });
 
-  it("placeholder test removed", () => {
-    // placeholder - actual test moved to end of file to avoid module isolation issues
-    expect(true).toBe(true);
-  });
-
   it("saveSessions logs error with non-Error object thrown by writeFileAtomic", async () => {
     const { logError } = await import("../util/log.js");
     // Throw a plain string instead of an Error to cover the `err instanceof Error ? ... : err` false branch

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

@@ -2,10 +2,12 @@ import { beforeEach, describe, expect, it } from "vitest";
 import { clearModels, registerModels } from "../core/models.js";
 import {
   formatCompactModelLabel,
+  formatDuration,
   formatModelLabel,
   formatModelOptionLabel,
   getTelegramModelOptions,
   isSelectedModel,
+  renderMetricsMessages,
   renderSettingsKeyboard,
 } from "../frontend/telegram/helpers.js";
 
@@ -19,11 +21,6 @@ describe("telegram helpers", () => {
         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",
       },
       {
@@ -33,8 +30,6 @@ describe("telegram helpers", () => {
           "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",
       },
       {
@@ -43,11 +38,6 @@ describe("telegram helpers", () => {
         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",
       },
       {
@@ -57,8 +47,6 @@ describe("telegram helpers", () => {
           "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",
       },
       {
@@ -67,8 +55,6 @@ describe("telegram helpers", () => {
         description: "Haiku 4.5 · Fastest for quick answers",
         aliases: ["claude-haiku-4-5"],
         provider: "anthropic",
-        capabilities: { supports1mContext: false },
-        tier: "economy",
       },
     ]);
   });
@@ -84,17 +70,17 @@ describe("telegram helpers", () => {
     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",
+      "Sonnet 4.6",
     );
     expect(formatCompactModelLabel(getTelegramModelOptions()[1]!)).toBe(
-      "Sonnet",
+      "Opus 4.6",
     );
   });
 
   it("shows a single clean option per model family", () => {
     expect(getTelegramModelOptions().map((model) => model.id)).toEqual([
-      "opus",
       "default",
+      "opus",
       "haiku",
     ]);
   });
@@ -108,6 +94,63 @@ describe("telegram helpers", () => {
       .flat()
       .map((button) => button.text);
 
-    expect(buttons).toContain("\u2713 Sonnet");
+    expect(buttons).toContain("\u2713 Sonnet 4.6");
+  });
+});
+
+describe("formatDuration", () => {
+  it("preserves millisecond precision for subsecond values", () => {
+    expect(formatDuration(250)).toBe("250ms");
+    expect(formatDuration(999)).toBe("999ms");
+  });
+
+  it("keeps second-and-up formatting intact", () => {
+    expect(formatDuration(1_500)).toBe("1s");
+    expect(formatDuration(65_000)).toBe("1m 5s");
+  });
+});
+
+describe("renderMetricsMessages", () => {
+  it("formats latency metrics with millisecond precision", () => {
+    const messages = renderMetricsMessages({
+      counters: { queries_total: 7 },
+      histograms: {
+        response_latency_ms: {
+          count: 3,
+          p50: 250,
+          p95: 1_250,
+          p99: 2_000,
+          avg: 900,
+        },
+      },
+    });
+
+    expect(messages).toHaveLength(1);
+    expect(messages[0]).toContain("p50=250ms");
+    expect(messages[0]).toContain("p95=1s");
+    expect(messages[0]).toContain("avg=900ms");
+  });
+
+  it("splits large metrics output into Telegram-safe chunks", () => {
+    const counters = Object.fromEntries(
+      Array.from({ length: 12 }, (_, i) => [`tool_calls.tool_${i}`, i + 1]),
+    );
+
+    const messages = renderMetricsMessages({ counters, histograms: {} }, 160);
+
+    expect(messages.length).toBeGreaterThan(1);
+    for (const message of messages) {
+      expect(message.length).toBeLessThanOrEqual(160);
+    }
+    expect(messages[0]).toContain("<b>📊 Metrics</b>");
+    expect(
+      messages.slice(1).every((message) => message.includes("(cont.)")),
+    ).toBe(true);
+  });
+
+  it("shows an empty-state message when no metrics exist", () => {
+    expect(renderMetricsMessages({ counters: {}, histograms: {} })).toEqual([
+      "<b>📊 Metrics</b>\n\n<i>No metrics recorded yet.</i>",
+    ]);
   });
 });

package/src/__tests__/terminal-commands.test.ts

@@ -90,6 +90,48 @@ vi.mock("../core/plugin.js", () => ({
   getLoadedPlugins: () => mockGetLoadedPlugins(),
 }));
 
+const mockGetOpenCodeModelCatalog = vi.fn(async () => ({
+  generatedAt: Date.now(),
+  providers: [],
+  models: [],
+  connectedProviders: [],
+  loginProviders: [],
+  connectedModels: [],
+  connectedFreeModels: [],
+}));
+const mockGetOpenCodeModelInfo = vi.fn<
+  (modelId: string) => Promise<Record<string, unknown> | undefined>
+>(async (_modelId: string) => undefined);
+const mockGetOpenCodeQuickPickModels = vi.fn<
+  (catalog: unknown, currentModelId?: string) => Array<unknown>
+>(() => []);
+const mockResolveOpenCodeModelInput = vi.fn<
+  (query: string, catalog: unknown) => Record<string, unknown>
+>((_query: string) => ({
+  kind: "missing",
+  matches: [],
+}));
+const mockGetOpenCodeSessionSnapshot = vi.fn<
+  (sessionId: string) => Promise<Record<string, unknown> | undefined>
+>(async (_sessionId: string) => undefined);
+const mockGetOpenCodeModelSelectionValue = vi.fn<
+  (model: Record<string, unknown>, catalog: unknown) => string
+>((model: Record<string, unknown>) => String(model.id ?? ""));
+vi.mock("../backend/opencode/index.js", () => ({
+  getOpenCodeModelCatalog: () => mockGetOpenCodeModelCatalog(),
+  getOpenCodeModelInfo: (modelId: string) => mockGetOpenCodeModelInfo(modelId),
+  getOpenCodeModelSelectionValue: (
+    model: Record<string, unknown>,
+    catalog: unknown,
+  ) => mockGetOpenCodeModelSelectionValue(model, catalog),
+  getOpenCodeQuickPickModels: (catalog: unknown, currentModelId?: string) =>
+    mockGetOpenCodeQuickPickModels(catalog, currentModelId),
+  resolveOpenCodeModelInput: (query: string, catalog: unknown) =>
+    mockResolveOpenCodeModelInput(query, catalog),
+  getOpenCodeSessionSnapshot: (sessionId: string) =>
+    mockGetOpenCodeSessionSnapshot(sessionId),
+}));
+
 import {
   registerCommand,
   tryRunCommand,
@@ -215,6 +257,9 @@ describe("built-in commands", () => {
     clearCommands();
     registerBuiltinCommands();
     vi.clearAllMocks();
+    mockGetOpenCodeModelSelectionValue.mockImplementation(
+      (model: Record<string, unknown>) => String(model.id ?? ""),
+    );
   });
 
   it("registers all expected commands", () => {
@@ -261,12 +306,17 @@ describe("built-in commands", () => {
 
   describe("/model", () => {
     it("shows current model when no arg given", async () => {
-      mockGetChatSettings.mockReturnValueOnce({ model: "claude-opus-4-6" });
+      // getChatSettings is called twice: once at handler entry, once in the
+      // non-opencode branch — use mockReturnValue so both calls see the model.
+      mockGetChatSettings.mockReturnValue({ model: "claude-opus-4-6" });
       const ctx = makeMockContext();
       await tryRunCommand("/model", ctx);
       expect(ctx.renderer.writeSystem).toHaveBeenCalledWith(
         expect.stringContaining("claude-opus-4-6"),
       );
+      mockGetChatSettings.mockImplementation(
+        (_chatId: string): Record<string, unknown> => ({}),
+      );
     });
 
     it("sets model when arg given", async () => {
@@ -277,6 +327,48 @@ describe("built-in commands", () => {
         "claude-opus",
       );
     });
+
+    it("stores provider-qualified OpenCode model selections when needed", async () => {
+      mockGetOpenCodeModelCatalog.mockResolvedValueOnce({
+        generatedAt: Date.now(),
+        providers: [],
+        models: [],
+        connectedProviders: [],
+        loginProviders: [],
+        connectedModels: [],
+        connectedFreeModels: [],
+      });
+      mockResolveOpenCodeModelInput.mockReturnValueOnce({
+        kind: "exact",
+        model: {
+          id: "gpt-5",
+          providerID: "github-copilot",
+          providerName: "GitHub Copilot",
+          free: false,
+          selectable: true,
+          loginRequired: false,
+          envRequired: false,
+          authMethods: [],
+        },
+      });
+      mockGetOpenCodeModelSelectionValue.mockReturnValueOnce(
+        "github-copilot/gpt-5",
+      );
+
+      const ctx = makeMockContext({
+        config: { model: "nemotron-3-super-free", backend: "opencode" } as any,
+      });
+
+      await tryRunCommand("/model github-copilot/gpt-5", ctx);
+
+      expect(mockSetChatModel).toHaveBeenCalledWith(
+        "t_test_123",
+        "github-copilot/gpt-5",
+      );
+      expect(ctx.renderer.writeSystem).toHaveBeenCalledWith(
+        expect.stringContaining("github-copilot/gpt-5"),
+      );
+    });
   });
 
   describe("/rename", () => {
@@ -500,6 +592,88 @@ describe("/status command", () => {
     ).mock.calls.flat();
     expect(calls.join(" ")).toContain("actions only");
   });
+
+  it("/status uses live OpenCode usage totals when backend is opencode", async () => {
+    mockGetSessionInfo.mockReturnValueOnce({
+      turns: 14,
+      sessionId: "ses_live",
+      sessionName: undefined,
+      lastModel: "big-pickle",
+      usage: {
+        totalInputTokens: 100,
+        totalOutputTokens: 50,
+        totalCacheRead: 0,
+        totalCacheWrite: 0,
+        lastPromptTokens: 10,
+        estimatedCostUsd: 0,
+        totalResponseMs: 60_000,
+        lastResponseMs: 6_000,
+        fastestResponseMs: 5_000,
+      },
+    });
+    mockGetChatSettings.mockReturnValueOnce({ model: "big-pickle" });
+    mockGetOpenCodeModelInfo.mockResolvedValueOnce({
+      id: "big-pickle",
+      name: "Big Pickle",
+      providerID: "opencode",
+      providerName: "OpenCode Zen",
+      providerSource: "builtin",
+      connected: true,
+      selectable: true,
+      loginRequired: false,
+      envRequired: false,
+      authMethods: [],
+      free: true,
+      status: "active",
+      contextWindow: 204800,
+      outputWindow: 128000,
+      reasoning: true,
+      attachment: false,
+      toolcall: true,
+      costInput: 0,
+      costOutput: 0,
+      costCacheRead: 0,
+      costCacheWrite: 0,
+    });
+    mockGetOpenCodeSessionSnapshot.mockResolvedValueOnce({
+      sessionId: "ses_live",
+      assistant: {
+        modelID: "big-pickle",
+        providerID: "opencode",
+        inputTokens: 42200,
+        outputTokens: 20,
+        reasoningTokens: 10,
+        cacheRead: 0,
+        cacheWrite: 0,
+        costUsd: 0,
+        totalTokens: 42220,
+      },
+      usage: {
+        assistantMessages: 42,
+        totalInputTokens: 1389045,
+        totalOutputTokens: 3675,
+        totalReasoningTokens: 4717,
+        totalCacheRead: 0,
+        totalCacheWrite: 0,
+        totalCostUsd: 0,
+      },
+    });
+
+    const ctx = makeMockContext({
+      config: {
+        model: "big-pickle",
+        backend: "opencode",
+      } as CommandContext["config"],
+    });
+    await tryRunCommand("/status", ctx);
+
+    const output = (ctx.renderer.writeln as ReturnType<typeof vi.fn>).mock.calls
+      .flat()
+      .join(" ");
+    expect(output).toContain("1,389,045");
+    expect(output).toContain("3,675");
+    expect(output).toContain("204,800");
+  });
 });
 
 describe("/effort command", () => {