talon-agent 3.14.0 → 3.15.1

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

@@ -4,7 +4,7 @@
  * `runOpenCodeTurn` subscribes to SSE before issuing the prompt (so no early
  * events are lost), fires `promptAsync`, awaits the SSE close, then reads the
  * authoritative parts list. `subscribeToTurnEvents` translates relevant SSE
- * events into shared stream-state mutations and fires the terminator abort.
+ * events into shared stream-state mutations and observes natural turn idle.
  *
  * The streaming + event-processing logic is shared with the Kilo backend via
  * `backend/remote-server/events.ts`.
@@ -14,6 +14,7 @@ import type { OpencodeClient } from "@opencode-ai/sdk/v2";
 import { logWarn } from "../../../util/log.js";
 import { errMsg } from "../server.js";
 import {
+  approvePendingPermissions,
   extractPartsSummary,
   extractAssistantUsage,
   rejectPendingQuestions,
@@ -25,6 +26,7 @@ import {
   finalizePartsIntoState,
 } from "../../remote-server/events.js";
 import { subscribeSseStream } from "../../remote-server/sse-stream.js";
+import { awaitRemoteTurn } from "../../remote-server/turn-timeout.js";
 import { findLastAssistantMessage as findLastAssistantMessageShared } from "../../remote-server/messages.js";
 
 export interface RunOpenCodeTurnInputs {
@@ -37,7 +39,9 @@ export interface RunOpenCodeTurnInputs {
   state: ReturnType<typeof createStreamState>;
   chatId: string;
   seenQuestionIds: Set<string>;
+  seenPermissionIds: Set<string>;
   seenToolCallIds: Set<string>;
+  toolOverrides?: Record<string, boolean>;
   onStreamDelta?: (accumulated: string, phase?: "thinking" | "text") => void;
   onTextBlock?: (text: string) => Promise<void>;
   onToolUse?: (toolName: string, input: Record<string, unknown>) => void;
@@ -62,7 +66,9 @@ export async function runOpenCodeTurn(
     state,
     chatId,
     seenQuestionIds,
+    seenPermissionIds,
     seenToolCallIds,
+    toolOverrides,
     onStreamDelta,
     onTextBlock,
     onToolUse,
@@ -81,26 +87,18 @@ export async function runOpenCodeTurn(
     onStreamDelta,
     onTextBlock,
     onToolUse,
-    onTerminator: async () => {
-      // End_turn fired — abort the in-flight session so OpenCode doesn't
-      // burn another round-trip "wrapping up" after the model declared
-      // done. session.idle then fires for our session and the SSE
-      // iterator exits cleanly.
-      try {
-        await oc.session.abort({ sessionID: sessionId });
-      } catch (err) {
-        logWarn("agent", `[${chatId}] session.abort failed: ${errMsg(err)}`);
-      }
-    },
     abortSignal: sseAbort.signal,
   });
 
-  // Question watchdog: Talon manages its own tool permissions, so any
-  // upstream-side question (tool approval, clarification) is auto-handled.
+  // Headless-interaction watchdog: resolve upstream questions and any
+  // permission requests that escaped the session ruleset.
   const questionWatchdog = (async () => {
     while (!sseAbort.signal.aborted) {
       try {
-        await rejectPendingQuestions(oc, sessionId, chatId, seenQuestionIds);
+        await Promise.all([
+          rejectPendingQuestions(oc, sessionId, chatId, seenQuestionIds),
+          approvePendingPermissions(oc, sessionId, chatId, seenPermissionIds),
+        ]);
       } catch (err) {
         logWarn(
           "agent",
@@ -114,15 +112,21 @@ export async function runOpenCodeTurn(
   try {
     // Fire and forget — promptAsync returns immediately. The await below
     // is on the SSE close event.
-    await oc.session.promptAsync({
-      sessionID: sessionId,
-      parts: [{ type: "text", text: prompt }],
-      model: { providerID, modelID },
-      system: systemPrompt,
-    });
+    await awaitRemoteTurn(
+      (async () => {
+        await oc.session.promptAsync({
+          sessionID: sessionId,
+          parts: [{ type: "text", text: prompt }],
+          model: { providerID, modelID },
+          system: systemPrompt,
+          ...(toolOverrides ? { tools: toolOverrides } : {}),
+        });
 
-    // Await turn completion via SSE.
-    await sseDone;
+        // Await turn completion via SSE.
+        await sseDone;
+      })(),
+      { client: oc, sessionId, chatId, label: "OpenCode" },
+    );
 
     // Read authoritative final state from the messages endpoint.
     const messagesResp = await oc.session.messages({ sessionID: sessionId });
@@ -153,17 +157,23 @@ export async function runOpenCodeTurn(
       }
     }
   } catch (err) {
-    // If the model called end_turn we aborted intentionally — swallow.
+    // Explicit user interrupts abort intentionally — swallow that close path.
     if (state.turnTerminated && /abort/i.test(errMsg(err))) {
       return;
     }
     throw err;
   } finally {
     sseAbort.abort();
-    await sseDone.catch(() => {});
+    // A dead SSE socket may ignore the local abort flag until another event
+    // arrives. Bound cleanup so a timed-out turn cannot wedge its caller in
+    // the finally block it was meant to escape.
+    await Promise.race([sseDone.catch(() => {}), sleep(1_000)]);
     await questionWatchdog.catch(() => {});
     try {
-      await rejectPendingQuestions(oc, sessionId, chatId, seenQuestionIds);
+      await Promise.all([
+        rejectPendingQuestions(oc, sessionId, chatId, seenQuestionIds),
+        approvePendingPermissions(oc, sessionId, chatId, seenPermissionIds),
+      ]);
     } catch {
       /* noop */
     }
@@ -191,7 +201,6 @@ interface SubscribeInputs {
   onStreamDelta?: (accumulated: string, phase?: "thinking" | "text") => void;
   onTextBlock?: (text: string) => Promise<void>;
   onToolUse?: (toolName: string, input: Record<string, unknown>) => void;
-  onTerminator: () => Promise<void>;
   abortSignal: AbortSignal;
 }
 
@@ -211,14 +220,13 @@ async function subscribeToTurnEvents(inputs: SubscribeInputs): Promise<void> {
     onStreamDelta,
     onTextBlock,
     onToolUse,
-    onTerminator,
     abortSignal,
   } = inputs;
 
   // `subscribeSseStream` handles the narrowing with a runtime guard + the
   // subscribe-failed warning.
   const stream = await subscribeSseStream(oc, chatId);
-  if (!stream) return;
+  if (!stream) throw new Error("OpenCode SSE connection unavailable");
 
   try {
     for await (const evt of stream) {
@@ -254,8 +262,7 @@ async function subscribeToTurnEvents(inputs: SubscribeInputs): Promise<void> {
               data?: Record<string, unknown>;
             }
           | undefined;
-        // MessageAbortedError is our own abort signal when a terminator
-        // tool fired; expected close path, not an upstream failure.
+        // MessageAbortedError is expected for an explicit user interrupt.
         const isOurAbort =
           state.turnTerminated &&
           (errProp?.name === "MessageAbortedError" ||
@@ -288,7 +295,9 @@ async function subscribeToTurnEvents(inputs: SubscribeInputs): Promise<void> {
       });
 
       if (outcome.kind === "terminator_fired") {
-        onTerminator().catch(() => {});
+        // Aborting here can race with a prompt accepted immediately after
+        // this turn settles and cancel that next turn on the reused session.
+        // Delivery is already complete, so wait for natural idle instead.
         continue;
       }
 

package/src/backend/opencode/index.ts

@@ -23,7 +23,13 @@ export {
   getOpenCodeSessionSnapshot,
 } from "./sessions.js";
 
-export { initOpenCodeAgent, stopOpenCodeServer } from "./server.js";
+export {
+  initOpenCodeAgent,
+  stopOpenCodeServer,
+  refreshPluginMcpServers,
+  updateSystemPrompt,
+  warmSession,
+} from "./server.js";
 
 export { handleMessage } from "./handler/index.js";
 

package/src/backend/opencode/server.ts

@@ -23,7 +23,6 @@ import {
 } from "@opencode-ai/sdk/v2";
 import type { TalonConfig } from "../../util/config.js";
 import type { FrontendName } from "../../core/agent-runtime/backend-registry.js";
-import { logWarn } from "../../util/log.js";
 import { buildDeliveryContract } from "../shared/delivery-contract.js";
 import {
   guessProviderID,
@@ -39,7 +38,9 @@ import {
   ensurePluginMcpServers as ensurePluginMcpServersShared,
   buildToolOverrides as buildToolOverridesShared,
   disconnectChatMcpServer as disconnectChatMcpServerShared,
+  refreshPluginMcpServers as refreshPluginMcpServersShared,
   ensureRemoteSession,
+  warmRemoteSession,
   resolveProviderID as resolveProviderIDShared,
   getRegisteredMcpServerNames as getRegisteredMcpServerNamesShared,
   errMsg as sharedErrMsg,
@@ -91,20 +92,6 @@ export function initOpenCodeAgent(
   state.config = cfg;
   if (getGatewayPort) state.gatewayPortFn = getGatewayPort;
   if (frontend) state.frontendName = frontend;
-
-  // Pre-warm plugin MCP servers in the background. Same rationale as
-  // the Kilo backend's init pre-warm.
-  prewarmPluginMcpServers().catch((err) => {
-    logWarn(
-      "agent",
-      `Plugin MCP pre-warm failed (non-fatal): ${sharedErrMsg(err)}`,
-    );
-  });
-}
-
-async function prewarmPluginMcpServers(): Promise<void> {
-  const client = await ensureServer();
-  await ensurePluginMcpServers(client, "prewarm");
 }
 
 /**
@@ -155,8 +142,9 @@ export function ensurePluginMcpServers(
 export function buildToolOverrides(
   oc: OpencodeClient,
   chatServerName: string,
+  pluginServerNames: readonly string[] = [],
 ): Promise<Record<string, boolean> | undefined> {
-  return buildToolOverridesShared(oc, state, chatServerName);
+  return buildToolOverridesShared(oc, state, chatServerName, pluginServerNames);
 }
 
 export function disconnectChatMcpServer(
@@ -166,6 +154,15 @@ export function disconnectChatMcpServer(
   return disconnectChatMcpServerShared(oc, state, serverName);
 }
 
+export async function refreshPluginMcpServers(chatId: string) {
+  const oc = await ensureServer();
+  return refreshPluginMcpServersShared(oc, state, chatId);
+}
+
+export function updateSystemPrompt(prompt: string): void {
+  if (state.config) state.config.systemPrompt = prompt;
+}
+
 // ── Session management ─────────────────────────────────────────────────────
 
 export function ensureSession(
@@ -175,6 +172,20 @@ export function ensureSession(
   return ensureRemoteSession(oc, state, chatId);
 }
 
+/**
+ * Front-load a chat's cold start after `/reset`. Mirrors the Claude
+ * backend's `warmSession` so the `sessions` capability slot behaves the
+ * same across backends. Never throws — see `warmRemoteSession`.
+ */
+export function warmSession(chatId: string): Promise<void> {
+  return warmRemoteSession(state, chatId, {
+    ensureServer,
+    ensureSession,
+    ensureChatMcpServer,
+    ensurePluginMcpServers,
+  });
+}
+
 // ── Provider resolution ────────────────────────────────────────────────────
 
 export function resolveProviderID(

package/src/backend/opencode/sessions.ts

@@ -18,6 +18,7 @@ import {
   getTurnSummary,
   getSessionSnapshot,
   rejectPendingQuestions as rejectPendingQuestionsShared,
+  approvePendingPermissions as approvePendingPermissionsShared,
   type RemoteAssistantInfo,
   type RemoteSessionSnapshot,
   type RemoteSessionClient,
@@ -97,3 +98,19 @@ export function rejectPendingQuestions(
     "OpenCode",
   );
 }
+
+/** Auto-approve pending OpenCode permissions for this headless session. */
+export function approvePendingPermissions(
+  oc: OpencodeClient,
+  sessionId: string,
+  chatId: string,
+  seenPermissionIds: Set<string>,
+): Promise<void> {
+  return approvePendingPermissionsShared(
+    oc as unknown as RemoteSessionClient,
+    sessionId,
+    chatId,
+    seenPermissionIds,
+    "OpenCode",
+  );
+}

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

@@ -35,7 +35,7 @@ export type RemoteMcpServerConfig =
 
 /** Permission-rule shape both SDKs share. */
 export interface RemotePermissionRule {
-  permission: "tool" | "edit" | "bash";
+  permission: "tool" | "edit" | "bash" | "external_directory";
   pattern: string;
   action: "allow" | "deny" | "ask";
 }

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

@@ -108,9 +108,21 @@ export async function processStreamEvent(
 ): Promise<ProcessEventOutcome> {
   if (!event || typeof event !== "object") return { kind: "continue" };
   const props = event.properties ?? {};
-  // Scope to our session only
+  // Scope to our session only. OpenCode/Kilo use three wire shapes:
+  // session events put sessionID on properties, part events put it inside
+  // properties.part, and message events put it inside properties.info.
+  // Missing the nested part shape lets a concurrent heartbeat/dream tool
+  // event terminate the active chat turn.
+  const part = props.part as Record<string, unknown> | undefined;
+  const info = props.info as Record<string, unknown> | undefined;
   const evtSessionID =
-    typeof props.sessionID === "string" ? props.sessionID : undefined;
+    typeof props.sessionID === "string"
+      ? props.sessionID
+      : typeof part?.sessionID === "string"
+        ? part.sessionID
+        : typeof info?.sessionID === "string"
+          ? info.sessionID
+          : undefined;
   if (evtSessionID && evtSessionID !== ctx.sessionId) {
     return { kind: "stop", reason: "out_of_scope" };
   }
@@ -246,11 +258,12 @@ async function processPartUpdate(
   const stateObj = part.state as
     { status?: string; input?: Record<string, unknown> } | undefined;
 
-  // Fire onToolUse ONCE when the tool transitions to running or completed
-  // with input available. Subsequent state changes don't re-fire.
+  // Record a tool only after the upstream reports successful completion.
+  // Treating `running` as delivery made failed MCP calls flip end_turn and
+  // suppress fallback text even though nothing reached the user.
   if (
     !stateObj ||
-    (stateObj.status !== "running" && stateObj.status !== "completed") ||
+    stateObj.status !== "completed" ||
     !callID ||
     ctx.seenToolCallIds.has(callID)
   ) {
@@ -436,7 +449,7 @@ export function finalizePartsIntoState(inputs: FinalizePartsInputs): {
     const callID = typeof part.callID === "string" ? part.callID : "";
     const toolName = typeof part.tool === "string" ? part.tool : "tool";
     if (callID && seenToolCallIds.has(callID)) continue;
-    if (stateObj?.input) {
+    if (stateObj?.status === "completed" && stateObj.input) {
       if (callID) seenToolCallIds.add(callID);
       recordToolUse(state, toolName, stateObj.input);
       toolsProcessed++;

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

@@ -51,15 +51,30 @@ export {
 
 export {
   TALON_MCP_SERVER_NAME,
+  TALON_PLUGIN_MCP_SERVER_NAME,
   getChatMcpServerName,
+  getPluginMcpServerName,
+  safeMcpNamePart,
   isTalonToolID,
   ensureChatMcpServer,
   ensurePluginMcpServers,
   buildToolOverrides,
   disconnectChatMcpServer,
+  refreshPluginMcpServers,
   getRegisteredMcpServerNames,
 } from "./mcp.js";
 
-export { buildPermissionRuleset, ensureRemoteSession } from "./sessions.js";
+export {
+  buildPermissionRuleset,
+  ensureRemoteSession,
+  warmRemoteSession,
+  type RemoteWarmDeps,
+} from "./sessions.js";
 
 export { type ProviderResolverHooks, resolveProviderID } from "./providers.js";
+
+export {
+  RemoteTurnTimeoutError,
+  remoteTurnTimeoutMs,
+  awaitRemoteTurn,
+} from "./turn-timeout.js";

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

@@ -182,6 +182,8 @@ export function stopRemoteServer<TClient extends RemoteAgentClient>(
   state.clientPromise = null;
   state.modelProviderCache.clear();
   state.registeredMcpServers.clear();
+  state.registeredMcpTools.clear();
+  state.pluginMcpServersByChat.clear();
   try {
     extraCleanup?.();
   } catch (err) {
@@ -193,7 +195,9 @@ export function stopRemoteServer<TClient extends RemoteAgentClient>(
   if (state.serverHandle) {
     state.serverHandle.close();
     state.serverHandle = null;
-    state.client = null;
     log("agent", `${state.label} server stopped`);
   }
+  // Always discard this process's client, including when the server was
+  // reused and is intentionally left running for its external owner.
+  state.client = null;
 }