talon-agent 3.34.0 → 3.35.0

package/src/backend/opencode/handler/message.ts

@@ -7,6 +7,7 @@ import type { QueryParams, QueryResult } from "../../shared/handler-types.js";
 import { runRemoteChatTurn } from "../../remote-server/chat-turn.js";
 import {
   ensureServer,
+  trackActiveTurn,
   ensureSession,
   ensureChatMcpServer,
   ensurePluginMcpServers,
@@ -26,6 +27,7 @@ export function handleMessage(params: QueryParams): Promise<QueryResult> {
       label: "OpenCode",
       getConfig,
       ensureServer,
+      trackActiveTurn,
       parseModelSelection: parseStoredOpenCodeModelSelection,
       resolveProviderID,
       ensureSession,

package/src/backend/opencode/server.ts

@@ -64,6 +64,7 @@ export const stopOpenCodeServer = opencode.stop;
 export const {
   onServerStop,
   ensureServer,
+  trackActiveTurn,
   ensureChatMcpServer,
   ensurePluginMcpServers,
   buildToolOverrides,

package/src/backend/remote-server/chat-turn.ts

@@ -4,9 +4,9 @@
  *
  * Resolves the active model against the server's catalog, makes sure the
  * server, session, and this chat's MCP servers exist, builds the prompt
- * pair, drives the turn (`./turn.ts`), then does the post-turn accounting:
- * usage fallback from the session summary, metrics, session id/name
- * persistence, and the shared delivery decision.
+ * pair, drives the turn (`./turn.ts`), then runs the shared post-turn
+ * phases (`backend/shared/turn-phases.ts`) with the one family-specific
+ * step in between: the usage fallback from the session summary.
  *
  * Kilo and OpenCode ran byte-for-byte copies of this (modulo the backend
  * name in log lines). The copies are gone; `RemoteChatBindings` is the
@@ -14,13 +14,7 @@
  * already returns.
  */
 
-import {
-  getSession,
-  incrementTurns,
-  recordUsage,
-  setSessionId,
-  setSessionName,
-} from "../../storage/sessions.js";
+import { getSession, incrementTurns } from "../../storage/sessions.js";
 import { getChatSettings } from "../../storage/chat-settings.js";
 import { log, logError } from "../../util/log.js";
 import { traceMessage } from "../../util/trace.js";
@@ -32,13 +26,14 @@ import {
   finalizeResponseText,
   formatUserPrompt,
   prepareSystemPrompt,
-  extractSessionName,
-  summarizeUsage,
   routeDelivery,
   applyRetryDecision,
-  recordTurnMetrics,
-  recordFailedTurnAccounting,
   registerTurnInterrupt,
+  accountTurn,
+  accountFailedTurn,
+  nameSessionFromFirstMessage,
+  finishCallbackTurn,
+  type StreamState,
 } from "../shared/index.js";
 import type { RemoteAgentClient } from "./client.js";
 import type { RemoteServerBindings } from "./server-bindings.js";
@@ -50,6 +45,7 @@ export type RemoteChatBindings<TClient extends RemoteAgentClient> = Pick<
   RemoteServerBindings<TClient>,
   | "getConfig"
   | "ensureServer"
+  | "trackActiveTurn"
   | "parseModelSelection"
   | "resolveProviderID"
   | "ensureSession"
@@ -150,10 +146,12 @@ export async function runRemoteChatTurn<TClient extends RemoteAgentClient>(
     state.turnTerminated = true;
     await turnClient.session.abort({ sessionID: sessionId });
   });
+  // Stopping the backend mid-turn (a `/model` swap, shutdown) aborts this
+  // controller, which rejects the turn promptly instead of leaving it to
+  // the deadline.
+  const stopController = new AbortController();
+  const untrackTurn = bindings.trackActiveTurn(stopController);
   const promptStartedAt = Date.now();
-  const seenQuestionIds = new Set<string>();
-  const seenPermissionIds = new Set<string>();
-  const seenToolCallIds = new Set<string>();
 
   const setupMs = Date.now() - t0;
   let promptMs = 0;
@@ -176,13 +174,14 @@ export async function runRemoteChatTurn<TClient extends RemoteAgentClient>(
       modelID,
       state,
       chatId,
-      seenQuestionIds,
-      seenPermissionIds,
-      seenToolCallIds,
+      seenQuestionIds: new Set<string>(),
+      seenPermissionIds: new Set<string>(),
+      seenToolCallIds: new Set<string>(),
       toolOverrides,
       onStreamDelta: undefined,
       onTextBlock,
       onToolUse,
+      stopSignal: stopController.signal,
     });
     promptMs = Date.now() - turnStart;
   } catch (err) {
@@ -198,31 +197,22 @@ export async function runRemoteChatTurn<TClient extends RemoteAgentClient>(
     if (outcome.retry) return outcome.retry;
 
     // Terminal failure — account for whatever the turn consumed before
-    // dying and drop the live overlay (the retry path above did its own
-    // accounting inside the recursive attempt).
-    recordFailedTurnAccounting({
+    // dying (the retry path above did its own accounting inside the
+    // recursive attempt).
+    accountFailedTurn({
       backend: id,
       chatId,
+      state,
       durationMs: Date.now() - t0,
-      toolCalls: state.toolCalls,
-      apiCalls: state.numApiCalls,
       model: activeModel,
-      usage: {
-        inputTokens: state.sdkInputTokens,
-        outputTokens: state.sdkOutputTokens,
-        cacheRead: state.sdkCacheRead,
-        cacheWrite: state.sdkCacheWrite,
-      },
-      contextTokens: state.contextTokens,
-      contextWindow: state.contextWindow,
     });
-
     logError(
       "agent",
       `[${chatId}] ${label} error: ${outcome.classified.message}`,
     );
     throw outcome.classified;
   } finally {
+    untrackTurn();
     unregisterInterrupt();
     // Note: we deliberately do NOT disconnect the chat MCP server here.
     // The server is named per-chat so it's safe to keep across turns;
@@ -232,71 +222,25 @@ export async function runRemoteChatTurn<TClient extends RemoteAgentClient>(
 
   // ── Post-loop accounting ──────────────────────────────────────────────────
 
-  // If the SSE loop missed any usage info, fall back to the session
-  // summary endpoint (which always reflects the final server state).
-  if (
-    state.sdkInputTokens === 0 &&
-    state.sdkOutputTokens === 0 &&
-    state.sdkCacheRead === 0
-  ) {
-    try {
-      const summary = await getTurnSummary(
-        oc as unknown as RemoteSessionClient,
-        sessionId,
-        promptStartedAt,
-      );
-      if (summary.usage.assistantMessages > 0) {
-        recordTokens(state, {
-          inputTokens: summary.usage.inputTokens,
-          outputTokens: summary.usage.outputTokens,
-          cacheRead: summary.usage.cacheRead,
-          cacheWrite: summary.usage.cacheWrite,
-        });
-      }
-    } catch {
-      // best-effort — session summaries can race on cancellation
-    }
-  }
+  await fillUsageFromSummary(
+    oc as unknown as RemoteSessionClient,
+    sessionId,
+    promptStartedAt,
+    state,
+  );
 
   const responseText = finalizeResponseText(state);
   const durationMs = Date.now() - t0;
-  recordTurnMetrics({
+  accountTurn({
     chatId,
     backend: id,
-    durationMs,
-    toolCalls: state.toolCalls,
-    apiCalls: state.numApiCalls,
-    usage: {
-      inputTokens: state.sdkInputTokens,
-      outputTokens: state.sdkOutputTokens,
-      cacheRead: state.sdkCacheRead,
-      cacheWrite: state.sdkCacheWrite,
-    },
-  });
-
-  if (state.newSessionId) {
-    // setSessionId tolerates "same id" calls — keep it simple.
-    const stored = getSession(chatId).sessionId;
-    if (stored !== state.newSessionId) {
-      setSessionId(chatId, state.newSessionId);
-    }
-  }
-
-  incrementTurns(chatId);
-  recordUsage(chatId, {
-    inputTokens: state.sdkInputTokens,
-    outputTokens: state.sdkOutputTokens,
-    cacheRead: state.sdkCacheRead,
-    cacheWrite: state.sdkCacheWrite,
+    state,
     durationMs,
     model: activeModel,
+    sessionId: state.newSessionId,
   });
-
-  // Set a descriptive session name from the user's first message.
-  if (previousTurns === 0) {
-    const name = extractSessionName(text);
-    if (name) setSessionName(chatId, name);
-  }
+  incrementTurns(chatId);
+  nameSessionFromFirstMessage({ chatId, text, previousTurns });
 
   // ── Delivery — the decision tree shared by every backend ──────────────────
   const delivery = await routeDelivery({
@@ -307,40 +251,50 @@ export async function runRemoteChatTurn<TClient extends RemoteAgentClient>(
     onTextBlock,
   });
 
-  log(
-    "agent",
-    `[${chatId}] delivery: ${delivery.route} (${delivery.chars} chars)`,
-  );
-
-  log(
-    "agent",
-    `[${chatId}] -> (${summarizeUsage(
-      {
-        inputTokens: state.sdkInputTokens,
-        outputTokens: state.sdkOutputTokens,
-        cacheRead: state.sdkCacheRead,
-        cacheWrite: state.sdkCacheWrite,
-      },
-      { durationMs, toolCalls: state.toolCalls },
-    )} terminator=${state.turnTerminated ? "yes" : "no"} ` +
-      `delivered=${state.deliveredTextNorms.length} ` +
-      `respLen=${responseText.length} ` +
-      `setup=${setupMs}ms turn=${promptMs}ms ` +
-      `events=${formatEventCounts(state.eventCounts)})`,
-  );
-  traceMessage(chatId, "out", responseText, {
+  return finishCallbackTurn({
+    chatId,
+    state,
+    responseText,
     durationMs,
-    toolCalls: state.toolCalls,
+    setupMs,
+    turnMs: promptMs,
+    delivery,
+    detail: `events=${formatEventCounts(state.eventCounts)}`,
   });
+}
 
-  return {
-    text: responseText,
-    durationMs,
-    inputTokens: state.sdkInputTokens,
-    outputTokens: state.sdkOutputTokens,
-    cacheRead: state.sdkCacheRead,
-    cacheWrite: state.sdkCacheWrite,
-  };
+/**
+ * If the SSE loop missed the usage info, fall back to the session summary
+ * endpoint (which always reflects the final server state). Best-effort:
+ * session summaries can race on cancellation, so a failure leaves the
+ * counts at zero.
+ */
+async function fillUsageFromSummary(
+  oc: RemoteSessionClient,
+  sessionId: string,
+  promptStartedAt: number,
+  state: ReturnType<typeof createStreamState>,
+): Promise<void> {
+  if (
+    state.sdkInputTokens !== 0 ||
+    state.sdkOutputTokens !== 0 ||
+    state.sdkCacheRead !== 0
+  ) {
+    return;
+  }
+  try {
+    const summary = await getTurnSummary(oc, sessionId, promptStartedAt);
+    if (summary.usage.assistantMessages > 0) {
+      recordTokens(state, {
+        inputTokens: summary.usage.inputTokens,
+        outputTokens: summary.usage.outputTokens,
+        cacheRead: summary.usage.cacheRead,
+        cacheWrite: summary.usage.cacheWrite,
+      });
+    }
+  } catch {
+    // best-effort — session summaries can race on cancellation
+  }
 }
 
 /**

package/src/backend/remote-server/index.ts

@@ -42,7 +42,11 @@ export { stopRemoteServer } from "./lifecycle.js";
 
 export {
   TALON_MCP_SERVER_NAME,
+  TALON_PLUGIN_MCP_SERVER_NAME,
+  PLUGIN_MCP_SERVER_NAME_MAX_LENGTH,
   getChatMcpServerName,
+  getPluginMcpServerName,
+  getPluginMcpServerPrefix,
   isTalonToolID,
   ensureChatMcpServer,
   ensurePluginMcpServers,

package/src/backend/remote-server/lifecycle.ts

@@ -13,11 +13,29 @@
  * reuse machinery.
  */
 
+import { TalonError } from "../../core/errors.js";
 import { log, logWarn } from "../../util/log.js";
 import type { RemoteAgentClient } from "./client.js";
 import type { RemoteServerState } from "./state.js";
 import { errMsg } from "./state.js";
 
+/**
+ * Rejection for a turn whose server was stopped underneath it (a backend
+ * hot-swap or shutdown). Non-retryable on purpose: the chat no longer
+ * points at this backend, so a fallback-model retry against it would be
+ * wrong — the turn fails cleanly and the next message runs on the new
+ * backend.
+ */
+export class RemoteServerStoppedError extends TalonError {
+  constructor(label: string) {
+    super(`${label} server stopped while the turn was in flight`, {
+      reason: "unknown",
+      retryable: false,
+    });
+    this.name = "RemoteServerStoppedError";
+  }
+}
+
 /**
  * Inputs passed to {@link ensureRemoteServer}. The backend supplies its
  * SDK's client/server factories; the shared helper handles the
@@ -180,6 +198,7 @@ export function stopRemoteServer<TClient extends RemoteAgentClient>(
   extraCleanup?: () => void,
 ): void {
   state.clientPromise = null;
+  abortActiveTurns(state);
   state.modelProviderCache.clear();
   state.registeredMcpServers.clear();
   state.registeredMcpTools.clear();
@@ -201,3 +220,21 @@ export function stopRemoteServer<TClient extends RemoteAgentClient>(
   // reused and is intentionally left running for its external owner.
   state.client = null;
 }
+
+/**
+ * Reject every in-flight turn with {@link RemoteServerStoppedError} before
+ * the server goes away. The turn's own cleanup unregisters its controller;
+ * clearing here only covers turns that never reach their `finally`.
+ */
+function abortActiveTurns<TClient extends RemoteAgentClient>(
+  state: RemoteServerState<TClient>,
+): void {
+  if (state.activeTurns.size === 0) return;
+  log(
+    "agent",
+    `${state.label} stopping with ${state.activeTurns.size} turn(s) in flight; aborting them`,
+  );
+  const reason = new RemoteServerStoppedError(state.label);
+  for (const controller of state.activeTurns) controller.abort(reason);
+  state.activeTurns.clear();
+}

package/src/backend/remote-server/mcp.ts

@@ -14,7 +14,9 @@
  *     `talon-tools-<chatId>` MCP server. Returns the registered name so
  *     callers can scope tool overrides to this chat alone.
  *   - {@link ensurePluginMcpServers} — register chat-namespaced plugin MCP
- *     servers (`mempalace-tools`, `brave-search`, `github-tools`, …).
+ *     servers (`mempalace-tools`, `brave-search`, `github-tools`, …) under
+ *     short `tp-<chat hash>-<plugin>` names (see
+ *     {@link getPluginMcpServerName} for the length budget).
  *   - {@link buildToolOverrides} — produce a `tools` map that whitelists
  *     this chat's Talon tools and blacklists every other chat's. Used
  *     as the `tools` field on the prompt payload to constrain the model's
@@ -29,12 +31,15 @@
  * registrations run concurrently through the hub; later turns skip them.
  */
 
+import { createHash } from "node:crypto";
+
 import { log, logDebug, logWarn } from "../../util/log.js";
 import {
   talonHubUrl,
   pluginHubUrl,
   hubPluginServerNames,
   listHubPluginToolNames,
+  describeHubChildExit,
 } from "../../core/mcp-hub/index.js";
 import type { RemoteAgentClient } from "./client.js";
 import type { RemoteServerState } from "./state.js";
@@ -51,8 +56,28 @@ import {
 
 /** Stable name prefix for Talon's per-chat MCP servers. */
 export const TALON_MCP_SERVER_NAME = "talon-tools";
-/** Stable prefix for chat-scoped plugin MCP registrations. */
-export const TALON_PLUGIN_MCP_SERVER_NAME = "talon-plugin";
+/**
+ * Stable prefix for chat-scoped plugin MCP registrations. Deliberately
+ * terse: the upstream agent server composes tool ids as
+ * `<server>_<tool>`, and Anthropic rejects tool names over 64 characters
+ * (`\`name\` must be at most 64 characters`). The old
+ * `talon-plugin-<chatId>-<plugin>` form alone reached ~45 characters and
+ * hard-failed the first call of any long-named plugin tool.
+ */
+export const TALON_PLUGIN_MCP_SERVER_NAME = "tp";
+
+/**
+ * Upper bound on a generated plugin MCP server name. The 64-character
+ * Anthropic tool-name limit must cover `<server>_<tool>`, so this leaves
+ * 31 characters for the plugin's own tool name — comfortably above the
+ * longest ones in the wild (`browser_take_screenshot`, 23).
+ */
+export const PLUGIN_MCP_SERVER_NAME_MAX_LENGTH = 32;
+
+/** Hex characters of the chat-id hash embedded in a plugin server name. */
+const PLUGIN_SERVER_CHAT_HASH_LENGTH = 8;
+/** Hex characters of the plugin-name hash appended when the name is cut. */
+const PLUGIN_SERVER_PLUGIN_HASH_LENGTH = 6;
 
 /**
  * MCP add() calls slower than this get a `[slow]` annotation in the log
@@ -87,13 +112,48 @@ export function getChatMcpServerName(chatId: string): string {
 }
 
 /** Sanitize a component embedded in an upstream MCP registration name. */
-export function safeMcpNamePart(value: string, fallback: string): string {
+function safeMcpNamePart(value: string, fallback: string): string {
   return value.replace(/[^a-zA-Z0-9_-]+/g, "_") || fallback;
 }
 
-/** Per-chat registration name for a plugin-provided MCP server. */
-function getPluginMcpServerName(pluginName: string, chatId: string): string {
-  return `${TALON_PLUGIN_MCP_SERVER_NAME}-${safeMcpNamePart(chatId, "chat")}-${safeMcpNamePart(pluginName, "plugin")}`;
+/** Leading `length` hex characters of the SHA-256 of `value`. */
+function shortHash(value: string, length: number): string {
+  return createHash("sha256").update(value).digest("hex").slice(0, length);
+}
+
+/**
+ * Name prefix shared by every plugin MCP server registered for one chat
+ * (`tp-<8-hex chat hash>-`). The permission ruleset allows this chat's
+ * prefix and denies `tp-*` for everything else, so the prefix must be a
+ * pure function of the chat id — never of the plugin.
+ */
+export function getPluginMcpServerPrefix(chatId: string): string {
+  return `${TALON_PLUGIN_MCP_SERVER_NAME}-${shortHash(chatId, PLUGIN_SERVER_CHAT_HASH_LENGTH)}-`;
+}
+
+/**
+ * Per-chat registration name for a plugin-provided MCP server.
+ *
+ * Deterministic for a given (plugin, chat) pair and never longer than
+ * {@link PLUGIN_MCP_SERVER_NAME_MAX_LENGTH}. The plugin name is kept
+ * verbatim while it fits; an overlong one is cut and suffixed with a short
+ * hash of the full name so two long plugins sharing a head stay distinct.
+ * Nothing parses the name back — `state.pluginMcpServersByChat` is the
+ * reverse map from chat + plugin to registered name.
+ */
+export function getPluginMcpServerName(
+  pluginName: string,
+  chatId: string,
+): string {
+  const prefix = getPluginMcpServerPrefix(chatId);
+  const budget = PLUGIN_MCP_SERVER_NAME_MAX_LENGTH - prefix.length;
+  const safePlugin = safeMcpNamePart(pluginName, "plugin");
+  if (safePlugin.length <= budget) return `${prefix}${safePlugin}`;
+  const head = safePlugin.slice(
+    0,
+    budget - PLUGIN_SERVER_PLUGIN_HASH_LENGTH - 1,
+  );
+  return `${prefix}${head}-${shortHash(pluginName, PLUGIN_SERVER_PLUGIN_HASH_LENGTH)}`;
 }
 
 /** Whether a tool id belongs to one of Talon's MCP servers. */
@@ -257,7 +317,7 @@ export async function ensurePluginMcpServers<TClient extends RemoteAgentClient>(
         const ms = Date.now() - startedAt;
         log(
           "agent",
-          `Registered plugin MCP server: ${serverName} (${ms}ms)` +
+          `Registered plugin MCP server: ${serverName} (${name} for chat ${chatId}, ${ms}ms)` +
             (ms > SLOW_MCP_REGISTRATION_MS ? " [slow]" : ""),
         );
         return serverName;
@@ -271,9 +331,13 @@ export async function ensurePluginMcpServers<TClient extends RemoteAgentClient>(
           ? logDebug
           : logWarn;
         warnedMcpRegistrationFailures.add(serverName);
+        // "Connection closed" alone says nothing; the hub knows how the
+        // child behind this server last died.
+        const exit = describeHubChildExit(name, chatId);
         level(
           "agent",
-          `Plugin MCP registration failed for ${serverName}: ${errMsg(err)}`,
+          `Plugin MCP registration failed for ${serverName}: ${errMsg(err)}` +
+            (exit ? ` (hub child ${exit})` : ""),
         );
         return null;
       }