talon-agent 1.3.0 → 1.5.0

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

@@ -9,7 +9,6 @@ import {
   setSessionName,
 } from "../../storage/sessions.js";
 import { getChatSettings, setChatModel } from "../../storage/chat-settings.js";
-import { getRecentHistory } from "../../storage/history.js";
 import { resolve } from "node:path";
 import { classify } from "../../core/errors.js";
 import {
@@ -19,7 +18,7 @@ import {
 import { rebuildSystemPrompt } from "../../util/config.js";
 import { log, logError, logWarn } from "../../util/log.js";
 import { traceMessage } from "../../util/trace.js";
-import { formatSmartTimestamp, formatFullDatetime } from "../../util/time.js";
+import { formatFullDatetime } from "../../util/time.js";
 
 import type { QueryParams, QueryResult } from "../../core/types.js";
 
@@ -42,34 +41,15 @@ export function initAgent(
   delete process.env.CLAUDECODE;
 }
 
-// ── Main handler ─────────────────────────────────────────────────────────────
+/** Update the system prompt on the live config. Used by plugin hot-reload
+ *  so the next message picks up new plugin tool descriptions. */
+export function updateSystemPrompt(prompt: string): void {
+  if (config) config.systemPrompt = prompt;
+}
 
-export async function handleMessage(
-  params: QueryParams,
-  _retried = false,
-): Promise<QueryResult> {
-  if (!config)
-    throw new Error("Agent not initialized. Call initAgent() first.");
+// ── Shared options builder ───────────────────────────────────────────────────
 
-  const {
-    chatId,
-    text,
-    senderName,
-    isGroup,
-    onTextBlock,
-    onStreamDelta,
-    onToolUse,
-  } = params;
-  const session = getSession(chatId);
-  const t0 = Date.now();
-
-  // Rebuild system prompt on first turn of a new/reset session so identity,
-  // memory, and workspace listing are fresh
-  if (session.turns === 0) {
-    rebuildSystemPrompt(config, getPluginPromptAdditions());
-  }
-
-  // Per-chat settings override global config
+function buildSdkOptions(chatId: string) {
   const chatSettings = getChatSettings(chatId);
   const activeModel = chatSettings.model ?? config.model;
   const activeEffort = chatSettings.effort ?? "adaptive";
@@ -91,13 +71,18 @@ export async function handleMessage(
     thinking: { type: "adaptive" as const },
   };
 
+  const supports1m =
+    !activeModel.includes("haiku") && !activeModel.includes("[1m]");
+  const sdkModel = supports1m ? `${activeModel}[1m]` : activeModel;
+
+  const session = getSession(chatId);
+
   const options = {
-    model: activeModel,
+    model: sdkModel,
     systemPrompt: config.systemPrompt,
     cwd: config.workspace,
     permissionMode: "bypassPermissions" as const,
     allowDangerouslySkipPermissions: true,
-    betas: ["context-1m-2025-08-07"],
     ...(config.claudeBinary
       ? { pathToClaudeCodeExecutable: config.claudeBinary }
       : {}),
@@ -115,93 +100,172 @@ export async function handleMessage(
       "TaskOutput",
       "TaskStop",
       "AskUserQuestion",
+      "WebSearch",
+      "WebFetch",
     ],
     ...thinkingConfig,
     mcpServers: {
-      // Register frontend-specific MCP tools based on active frontend
       ...(() => {
-        const frontends = Array.isArray(config.frontend)
+        const allFrontends = Array.isArray(config.frontend)
           ? config.frontend
           : [config.frontend];
+        const frontends = allFrontends.filter((f) => f !== "terminal");
         const bridgeUrl = `http://127.0.0.1:${bridgePortFn()}`;
-        const mcpEnv = { TALON_BRIDGE_URL: bridgeUrl, TALON_CHAT_ID: chatId };
         const servers: Record<
           string,
           { command: string; args: string[]; env: Record<string, string> }
         > = {};
-        // Resolve tsx from Talon's node_modules (cwd may be ~/.talon/workspace/ which has no node_modules)
-        // Resolve tsx from the package root (3 levels up from src/backend/claude-sdk/)
         const tsxImport = resolve(
           import.meta.dirname ?? ".",
           "../../../node_modules/tsx/dist/esm/index.mjs",
         );
+        const mcpServerPath = resolve(
+          import.meta.dirname ?? ".",
+          "../../core/tools/mcp-server.ts",
+        );
 
-        if (frontends.includes("telegram")) {
-          servers["telegram-tools"] = {
-            command: process.platform === "win32" ? "npx" : "node",
-            args:
-              process.platform === "win32"
-                ? ["tsx", resolve(import.meta.dirname ?? ".", "tools.ts")]
-                : [
-                    "--import",
-                    tsxImport,
-                    resolve(import.meta.dirname ?? ".", "tools.ts"),
-                  ],
-            env: mcpEnv,
+        for (const frontend of frontends) {
+          const serverName = `${frontend}-tools`;
+          const mcpEnv = {
+            TALON_BRIDGE_URL: bridgeUrl,
+            TALON_CHAT_ID: chatId,
+            TALON_FRONTEND: frontend,
           };
-        }
-        if (frontends.includes("teams")) {
-          servers["teams-tools"] = {
+          servers[serverName] = {
             command: process.platform === "win32" ? "npx" : "node",
             args:
               process.platform === "win32"
-                ? [
-                    "tsx",
-                    resolve(
-                      import.meta.dirname ?? ".",
-                      "../../frontend/teams/tools.ts",
-                    ),
-                  ]
-                : [
-                    "--import",
-                    tsxImport,
-                    resolve(
-                      import.meta.dirname ?? ".",
-                      "../../frontend/teams/tools.ts",
-                    ),
-                  ],
+                ? ["tsx", mcpServerPath]
+                : ["--import", tsxImport, mcpServerPath],
             env: mcpEnv,
           };
         }
         return servers;
       })(),
+      ...(config.braveApiKey
+        ? {
+            "brave-search": {
+              command: resolve(
+                import.meta.dirname ?? ".",
+                "../../../node_modules/.bin/brave-search-mcp-server",
+              ),
+              args: [],
+              env: { BRAVE_API_KEY: config.braveApiKey },
+            },
+          }
+        : {}),
       ...getPluginMcpServers(`http://127.0.0.1:${bridgePortFn()}`, chatId),
     },
     ...(session.sessionId ? { resume: session.sessionId } : {}),
   };
 
-  const msgIdHint = params.messageId ? ` [msg_id:${params.messageId}]` : "";
-  const nowTag = `[${formatFullDatetime()}]`;
+  return { options, activeModel, session };
+}
 
-  // Session continuity: when resuming a session that has history but no active
-  // SDK session (after restart or /resume), prepend recent messages for context.
-  let continuityPrefix = "";
-  if (!session.sessionId && session.turns > 0) {
-    const recentMsgs = getRecentHistory(chatId, 10);
-    if (recentMsgs.length > 0) {
-      const contextLines = recentMsgs
-        .map((m) => {
-          const time = formatSmartTimestamp(m.timestamp);
-          return `[${time}] ${m.senderName}: ${m.text.slice(0, 300)}`;
-        })
-        .join("\n");
-      continuityPrefix = `[Session resumed — recent conversation context:\n${contextLines}]\n\n`;
-    }
+// ── Session warm-up ─────────────────────────────────────────────────────────
+
+/**
+ * Cold-start a session by spawning an SDK subprocess in streaming input mode,
+ * calling getContextUsage() to populate contextWindow and baseline contextTokens,
+ * then tearing it down. Fire-and-forget — does not block the caller.
+ */
+export async function warmSession(chatId: string): Promise<void> {
+  if (!config) return;
+  const abort = new AbortController();
+  try {
+    rebuildSystemPrompt(config, getPluginPromptAdditions());
+    const { options } = buildSdkOptions(chatId);
+
+    // Streaming input mode: pass an async iterable that never yields a user message
+    const neverYield = async function* (): AsyncGenerator<never> {
+      await new Promise<never>((_, reject) => {
+        abort.signal.addEventListener("abort", () =>
+          reject(new Error("aborted")),
+        );
+      });
+    };
+
+    const q = query({
+      prompt: neverYield(),
+      options: {
+        ...options,
+        abortController: abort,
+      } as Parameters<typeof query>[0]["options"],
+    });
+
+    // Drain the stream in the background so the SDK's internal message loop
+    // doesn't stall — control responses are processed in readMessages() which
+    // needs the inputStream consumer to not back-pressure.
+    const drainPromise = (async () => {
+      try {
+        for await (const _ of q) {
+          // discard SDK messages; we only care about the control response
+        }
+      } catch {
+        // expected: abort causes the stream to end with an error
+      }
+    })();
+
+    // Race getContextUsage against a timeout so /reset doesn't hang
+    const timeout = new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error("warm-up timed out")), 15_000),
+    );
+    const ctx = await Promise.race([q.getContextUsage(), timeout]);
+    const session = getSession(chatId);
+    if (ctx.maxTokens > 0) session.usage.contextWindow = ctx.maxTokens;
+    if (ctx.totalTokens > 0) session.usage.contextTokens = ctx.totalTokens;
+    log(
+      "agent",
+      `[${chatId}] warm-up: context ${ctx.totalTokens}/${ctx.maxTokens} (${ctx.percentage.toFixed(1)}%) model=${ctx.model}`,
+    );
+
+    abort.abort();
+    await drainPromise;
+  } catch (err) {
+    abort.abort();
+    // Non-fatal — /status will just show 0 until first real message
+    logWarn(
+      "agent",
+      `[${chatId}] warm-up failed: ${err instanceof Error ? err.message : err}`,
+    );
+  }
+}
+
+// ── Main handler ─────────────────────────────────────────────────────────────
+
+export async function handleMessage(
+  params: QueryParams,
+  _retried = false,
+): Promise<QueryResult> {
+  if (!config)
+    throw new Error("Agent not initialized. Call initAgent() first.");
+
+  const {
+    chatId,
+    text,
+    senderName,
+    isGroup,
+    onTextBlock,
+    onStreamDelta,
+    onToolUse,
+  } = params;
+  const session = getSession(chatId);
+  const t0 = Date.now();
+
+  // Rebuild system prompt on first turn of a new/reset session so identity,
+  // memory, and workspace listing are fresh
+  if (session.turns === 0) {
+    rebuildSystemPrompt(config, getPluginPromptAdditions());
   }
 
+  const { options, activeModel } = buildSdkOptions(chatId);
+
+  const msgIdHint = params.messageId ? ` [msg_id:${params.messageId}]` : "";
+  const nowTag = `[${formatFullDatetime()}]`;
+
   const prompt = isGroup
-    ? `${continuityPrefix}${nowTag} [${senderName}]${msgIdHint}: ${text}`
-    : `${continuityPrefix}${nowTag}${msgIdHint} ${text}`;
+    ? `${nowTag} [${senderName}]${msgIdHint}: ${text}`
+    : `${nowTag}${msgIdHint} ${text}`;
   log("agent", `[${chatId}] <- (${text.length} chars)`);
   traceMessage(chatId, "in", text, { senderName, isGroup });
 
@@ -214,11 +278,16 @@ export async function handleMessage(
   let currentBlockText = "";
   let allResponseText = "";
   let newSessionId: string | undefined;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let cacheRead = 0;
-  let cacheWrite = 0;
   let toolCalls = 0;
+  // Populated from SDK result message
+  let contextTokens = 0; // actual context fill from last iteration
+  let contextWindow: number | undefined;
+  let numApiCalls = 0;
+  // Cumulative token counts from SDK modelUsage (aggregated across models)
+  let sdkInputTokens = 0;
+  let sdkOutputTokens = 0;
+  let sdkCacheRead = 0;
+  let sdkCacheWrite = 0;
 
   // Streaming throttle
   let lastStreamUpdate = 0;
@@ -313,15 +382,64 @@ export async function handleMessage(
         }
       }
 
-      // Final result
+      // Final result — read all data from SDK result fields
       if (type === "result") {
-        const usage = msg.usage as Record<string, number> | undefined;
-        if (usage) {
-          inputTokens = usage.input_tokens ?? 0;
-          outputTokens = usage.output_tokens ?? 0;
-          cacheRead = usage.cache_read_input_tokens ?? 0;
-          cacheWrite = usage.cache_creation_input_tokens ?? 0;
+        numApiCalls =
+          ((msg as Record<string, unknown>).num_turns as number) ?? 0;
+
+        // Context fill from last API iteration (only available in raw usage)
+        const usage = msg.usage as
+          | {
+              iterations?: Array<{
+                input_tokens: number;
+                cache_read_input_tokens: number;
+                cache_creation_input_tokens: number;
+              }>;
+            }
+          | undefined;
+        if (
+          usage &&
+          Array.isArray(usage.iterations) &&
+          usage.iterations.length > 0
+        ) {
+          const last = usage.iterations[usage.iterations.length - 1];
+          contextTokens =
+            (last.input_tokens ?? 0) +
+            (last.cache_read_input_tokens ?? 0) +
+            (last.cache_creation_input_tokens ?? 0);
+        }
+
+        // Token counts, context window from SDK modelUsage (aggregated per model)
+        type MU = {
+          inputTokens?: number;
+          outputTokens?: number;
+          cacheReadInputTokens?: number;
+          cacheCreationInputTokens?: number;
+          contextWindow?: number;
+        };
+        const modelUsage = (msg as Record<string, unknown>).modelUsage as
+          | Record<string, MU>
+          | undefined;
+        if (modelUsage) {
+          for (const mu of Object.values(modelUsage)) {
+            sdkInputTokens += mu.inputTokens ?? 0;
+            sdkOutputTokens += mu.outputTokens ?? 0;
+            sdkCacheRead += mu.cacheReadInputTokens ?? 0;
+            sdkCacheWrite += mu.cacheCreationInputTokens ?? 0;
+            if (
+              mu.contextWindow &&
+              mu.contextWindow > 0 &&
+              contextWindow === undefined
+            ) {
+              contextWindow = mu.contextWindow;
+            }
+          }
         }
+        log(
+          "agent",
+          `SDK result: modelUsage=${JSON.stringify(modelUsage)}, contextWindow=${contextWindow}, contextTokens=${contextTokens}, numApiCalls=${numApiCalls}`,
+        );
+
         // If we still have unsent text and no streaming captured it
         if (
           !allResponseText &&
@@ -383,12 +501,15 @@ export async function handleMessage(
   if (newSessionId) setSessionId(chatId, newSessionId);
   incrementTurns(chatId);
   recordUsage(chatId, {
-    inputTokens,
-    outputTokens,
-    cacheRead,
-    cacheWrite,
+    inputTokens: sdkInputTokens,
+    outputTokens: sdkOutputTokens,
+    cacheRead: sdkCacheRead,
+    cacheWrite: sdkCacheWrite,
     durationMs,
     model: activeModel,
+    contextTokens,
+    contextWindow,
+    numApiCalls,
   });
 
   // Set a descriptive session name from the first message
@@ -408,21 +529,21 @@ export async function handleMessage(
   // The remaining currentBlockText is the final response text
   allResponseText += currentBlockText;
 
-  const totalPrompt = inputTokens + cacheRead + cacheWrite;
+  const totalPrompt = sdkInputTokens + sdkCacheRead + sdkCacheWrite;
   const cacheHitPct =
-    totalPrompt > 0 ? Math.round((cacheRead / totalPrompt) * 100) : 0;
+    totalPrompt > 0 ? Math.round((sdkCacheRead / totalPrompt) * 100) : 0;
 
   log(
     "agent",
-    `[${chatId}] -> (${durationMs}ms, in=${inputTokens} out=${outputTokens} cache=${cacheHitPct}%` +
+    `[${chatId}] -> (${durationMs}ms, in=${sdkInputTokens} out=${sdkOutputTokens} cache=${cacheHitPct}%` +
       `${toolCalls > 0 ? ` tools=${toolCalls}` : ""})`,
   );
   traceMessage(chatId, "out", allResponseText, {
     durationMs,
-    inputTokens,
-    outputTokens,
-    cacheRead,
-    cacheWrite,
+    inputTokens: sdkInputTokens,
+    outputTokens: sdkOutputTokens,
+    cacheRead: sdkCacheRead,
+    cacheWrite: sdkCacheWrite,
     toolCalls,
     model: activeModel,
   });
@@ -430,9 +551,9 @@ export async function handleMessage(
   return {
     text: allResponseText.trim(),
     durationMs,
-    inputTokens,
-    outputTokens,
-    cacheRead,
-    cacheWrite,
+    inputTokens: sdkInputTokens,
+    outputTokens: sdkOutputTokens,
+    cacheRead: sdkCacheRead,
+    cacheWrite: sdkCacheWrite,
   };
 }

package/src/backend/opencode/index.ts

@@ -17,7 +17,6 @@ import {
   resetSession,
 } from "../../storage/sessions.js";
 import { getChatSettings } from "../../storage/chat-settings.js";
-import { getRecentHistory } from "../../storage/history.js";
 import { classify } from "../../core/errors.js";
 import { log, logError, logWarn } from "../../util/log.js";
 import { traceMessage } from "../../util/trace.js";
@@ -53,7 +52,7 @@ async function ensureServer(): Promise<OpencodeClient> {
 
   // Register our MCP tools server with OpenCode
   try {
-    const toolsPath = new URL("../claude-sdk/tools.ts", import.meta.url)
+    const toolsPath = new URL("../../core/tools/mcp-server.ts", import.meta.url)
       .pathname;
     await client.mcp.add({
       body: {
@@ -63,6 +62,7 @@ async function ensureServer(): Promise<OpencodeClient> {
           command: ["node", "--import", "tsx", toolsPath],
           environment: {
             TALON_BRIDGE_URL: `http://127.0.0.1:${gatewayPortFn()}`,
+            TALON_FRONTEND: "telegram",
           },
         },
       },
@@ -149,24 +149,9 @@ export async function handleMessage(
 
   // Build prompt with group context
   const msgIdHint = params.messageId ? ` [msg_id:${params.messageId}]` : "";
-  let continuityPrefix = "";
-  const session = getSession(chatId);
-  if (!session.sessionId && session.turns > 0) {
-    const recent = getRecentHistory(chatId, 3);
-    if (recent.length > 0) {
-      const ctx = recent
-        .map(
-          (m) =>
-            `[${new Date(m.timestamp).toISOString().slice(11, 16)}] ${m.senderName}: ${m.text.slice(0, 300)}`,
-        )
-        .join("\n");
-      continuityPrefix = `[Session resumed — recent context:\n${ctx}]\n\n`;
-    }
-  }
-
   const prompt = isGroup
-    ? `${continuityPrefix}[${senderName}]${msgIdHint}: ${text}`
-    : `${continuityPrefix}${text}${msgIdHint}`;
+    ? `[${senderName}]${msgIdHint}: ${text}`
+    : `${text}${msgIdHint}`;
 
   log("agent", `[${chatId}] <- (${text.length} chars)`);
   traceMessage(chatId, "in", text, { senderName, isGroup });
@@ -211,7 +196,7 @@ export async function handleMessage(
       model: activeModel,
     });
 
-    if (session.turns === 0 && text) {
+    if (getSession(chatId).turns === 0 && text) {
       const cleanText = text
         .replace(/^\[.*?\]\s*/g, "")
         .replace(/\[msg_id:\d+\]\s*/g, "")

package/src/bootstrap.ts

@@ -58,15 +58,14 @@ export async function bootstrap(
 ): Promise<BootstrapResult> {
   const config = loadConfig();
 
-  // Expose search config as env vars for gateway-actions
-  if (config.braveApiKey) process.env.TALON_BRAVE_API_KEY = config.braveApiKey;
-  if (config.searxngUrl) process.env.TALON_SEARXNG_URL = config.searxngUrl;
-
-  // Load plugins (external tool packages + built-in mempalace)
+  // Load plugins (external tool packages + built-in GitHub, MemPalace, Playwright)
   const hasPlugins =
-    config.plugins.length > 0 || config.mempalace?.enabled === true;
+    config.plugins.length > 0 ||
+    config.github?.enabled === true ||
+    config.mempalace?.enabled === true ||
+    config.playwright?.enabled === true;
   if (hasPlugins) {
-    const { loadPlugins, getPluginPromptAdditions, registerPlugin } =
+    const { loadPlugins, loadBuiltinPlugins, getPluginPromptAdditions } =
       await import("./core/plugin.js");
 
     // External plugins
@@ -77,43 +76,8 @@ export async function bootstrap(
       await loadPlugins(config.plugins, frontends);
     }
 
-    // Built-in: MemPalace
-    if (config.mempalace?.enabled) {
-      const { createMempalacePlugin } =
-        await import("./plugins/mempalace/index.js");
-      const { getPlugin } = await import("./core/plugin.js");
-      const { dirs, files: pathFiles } = await import("./util/paths.js");
-      const pythonPath =
-        config.mempalace.pythonPath ?? pathFiles.mempalacePython;
-      const palacePath = config.mempalace.palacePath ?? dirs.palace;
-      const mempalaceConfig = config.mempalace as unknown as Record<
-        string,
-        unknown
-      >;
-      const mp = createMempalacePlugin({ pythonPath, palacePath });
-      registerPlugin(mp, mempalaceConfig);
-
-      // Only call init if registration succeeded (validation passed)
-      if (getPlugin("mempalace")) {
-        try {
-          const MEMPALACE_INIT_TIMEOUT_MS = 30_000;
-          await Promise.race([
-            mp.init?.(mempalaceConfig),
-            new Promise((_, reject) =>
-              setTimeout(
-                () => reject(new Error("MemPalace init timed out after 30s")),
-                MEMPALACE_INIT_TIMEOUT_MS,
-              ),
-            ),
-          ]);
-        } catch (err) {
-          log(
-            "mempalace",
-            `Init warning: ${err instanceof Error ? err.message : err}`,
-          );
-        }
-      }
-    }
+    // Built-in plugins (GitHub, MemPalace, Playwright) — shared with hot-reload
+    await loadBuiltinPlugins(config);
 
     rebuildSystemPrompt(config, getPluginPromptAdditions());
   }