talon-agent 3.33.0 → 3.33.2

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

@@ -1,24 +1,10 @@
 /**
- * OpenCode main message handler.
- *
- * Orchestrates the full turn lifecycle on top of OpenCode's HTTP API + SSE
- * event stream. Behaviour mirrors the Kilo backend and shares its
- * non-SDK-specific primitives via `../../shared/` and `../../remote-server/`.
- * The OpenCode-specific turn driver + SSE subscription live in `turn.ts`.
+ * OpenCode main message handler — the shared remote-server chat turn
+ * bound to OpenCode's server bindings.
  */
 
-import {
-  getSession,
-  incrementTurns,
-  recordUsage,
-  setSessionId,
-  setSessionName,
-} from "../../../storage/sessions.js";
-import { getChatSettings } from "../../../storage/chat-settings.js";
-import { log, logError } from "../../../util/log.js";
-import { traceMessage } from "../../../util/trace.js";
 import type { QueryParams, QueryResult } from "../../shared/handler-types.js";
-
+import { runRemoteChatTurn } from "../../remote-server/chat-turn.js";
 import {
   ensureServer,
   ensureSession,
@@ -30,311 +16,24 @@ import {
   getConfig,
   opencodeSystemPromptSuffix,
 } from "../server.js";
-import {
-  frontendsForChat,
-  nonTerminalFrontends,
-} from "../../shared/frontends.js";
-import { getOpenCodeTurnSummary } from "../sessions.js";
-import {
-  createStreamState,
-  recordTokens,
-  finalizeResponseText,
-  formatUserPrompt,
-  prepareSystemPrompt,
-  extractSessionName,
-  summarizeUsage,
-  routeDelivery,
-  applyRetryDecision,
-  recordTurnMetrics,
-  recordFailedTurnAccounting,
-  registerTurnInterrupt,
-} from "../../shared/index.js";
-import { activeSessions } from "./state.js";
-import { runOpenCodeTurn } from "./turn.js";
-
-export async function handleMessage(
-  params: QueryParams,
-  _retried = false,
-): Promise<QueryResult> {
-  const config = getConfig();
-  if (!config) throw new Error("OpenCode agent not initialized");
-
-  const {
-    chatId,
-    text,
-    senderName,
-    senderHandle,
-    isGroup,
-    messageId,
-    onTextBlock,
-    onToolUse,
-  } = params;
-  const t0 = Date.now();
-  const session = getSession(chatId);
-  const previousTurns = session.turns;
-
-  // Resolve active model + provider lookup against OpenCode's catalog
-  const chatSettings = getChatSettings(chatId);
-  const activeModel = params.model ?? chatSettings.model ?? config.model;
-  const { providerID: selectedProviderID, modelID } =
-    parseStoredOpenCodeModelSelection(activeModel);
-
-  const oc = await ensureServer();
-  const providerID =
-    selectedProviderID ?? (await resolveProviderID(oc, modelID));
-  log(
-    "agent",
-    `[${chatId}] OpenCode model resolved: provider=${providerID} model=${modelID}` +
-      (selectedProviderID ? "" : " (provider via catalog lookup)"),
-  );
-  const sessionId = await ensureSession(oc, chatId);
-  const chatMcpServerName = await ensureChatMcpServer(oc, chatId);
-  const pluginMcpServerNames = await ensurePluginMcpServers(oc, chatId);
-  const toolOverrides = await buildToolOverrides(
-    oc,
-    chatMcpServerName,
-    pluginMcpServerNames,
-  );
-
-  // Build the prompt (time tag + sender + msg_id reference)
-  const prompt = formatUserPrompt({
-    text,
-    senderName: senderName ?? "user",
-    senderHandle,
-    isGroup,
-    messageId,
-  });
-
-  // Per-session frozen prompt + OpenCode-specific delivery suffix
-  const { text: systemPrompt } = prepareSystemPrompt({
-    config,
-    previousTurns,
-    backendSuffix: opencodeSystemPromptSuffix(
-      frontendsForChat(chatId, nonTerminalFrontends(config.frontend))[0] ??
-        "telegram",
-    ),
-    chatId,
-    sessionEpoch: session.createdAt,
-  });
-
-  log("agent", `[${chatId}] <- (${text.length} chars)`);
-  traceMessage(chatId, "in", text, { senderName, isGroup });
-  activeSessions.set(chatId, sessionId);
-
-  // Bind the stream state to the chat so token mutators mirror counts
-  // into the live-turn overlay — /status updates while the turn runs.
-  const state = createStreamState(chatId);
-  state.newSessionId = sessionId;
-  // A user interrupt is a synthetic turn terminator: marking the flag
-  // before aborting the session routes the close through the same clean
-  // path a model-fired end_turn takes (MessageAborted swallowed as the
-  // expected close, no retry), settling with whatever the turn produced.
-  const unregisterInterrupt = registerTurnInterrupt(chatId, async () => {
-    state.turnTerminated = true;
-    await oc.session.abort({ sessionID: sessionId });
-  });
-  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;
-
-  try {
-    // Drive the OpenCode turn: subscribe to SSE events in parallel with
-    // promptAsync, surface tool calls + terminator into shared state, and
-    // exit when the turn closes / goes idle. `onStreamDelta` is
-    // intentionally NOT forwarded — Telegram's contract is "send the final
-    // reply once", not live edit_message updates. Final delivery happens
-    // through `end_turn` / `send`.
-    const turnStart = Date.now();
-    await runOpenCodeTurn({
-      oc,
-      sessionId,
-      prompt,
-      systemPrompt,
-      providerID,
-      modelID,
-      state,
-      chatId,
-      seenQuestionIds,
-      seenPermissionIds,
-      seenToolCallIds,
-      toolOverrides,
-      onStreamDelta: undefined,
-      onTextBlock,
-      onToolUse,
-    });
-    promptMs = Date.now() - turnStart;
-  } catch (err) {
-    const outcome = await applyRetryDecision({
-      err,
-      chatId,
-      activeModel,
-      retried: _retried,
-      params,
-      recurseWithRetried: (p) => handleMessage(p, true),
-      backendLabel: "OpenCode",
-    });
-    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({
-      backend: "opencode",
-      chatId,
-      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}] OpenCode error: ${outcome.classified.message}`,
-    );
-    throw outcome.classified;
-  } finally {
-    unregisterInterrupt();
-    if (activeSessions.get(chatId) === sessionId) {
-      activeSessions.delete(chatId);
-    }
-    // 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;
-    // re-spawning the subprocess each turn cost ~800ms per message.
-    // Per-prompt overrides isolate visibility across concurrent chats.
-  }
-
-  // ── 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 getOpenCodeTurnSummary(
-        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
-    }
-  }
-
-  const responseText = finalizeResponseText(state);
-  const durationMs = Date.now() - t0;
-  recordTurnMetrics({
-    chatId,
-    backend: "opencode",
-    durationMs,
-    toolCalls: state.toolCalls,
-    apiCalls: state.numApiCalls,
-    usage: {
-      inputTokens: state.sdkInputTokens,
-      outputTokens: state.sdkOutputTokens,
-      cacheRead: state.sdkCacheRead,
-      cacheWrite: state.sdkCacheWrite,
+export function handleMessage(params: QueryParams): Promise<QueryResult> {
+  // Assembled per call, not at module load: tests mock `../server.js`
+  // with a partial surface and only touch the members they need.
+  return runRemoteChatTurn(
+    {
+      id: "opencode",
+      label: "OpenCode",
+      getConfig,
+      ensureServer,
+      parseModelSelection: parseStoredOpenCodeModelSelection,
+      resolveProviderID,
+      ensureSession,
+      ensureChatMcpServer,
+      ensurePluginMcpServers,
+      buildToolOverrides,
+      systemPromptSuffix: opencodeSystemPromptSuffix,
     },
-  });
-
-  if (state.newSessionId) {
-    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,
-    durationMs,
-    model: activeModel,
-  });
-
-  // Set a descriptive session name from the user's first message
-  if (previousTurns === 0) {
-    const name = extractSessionName(text);
-    if (name) setSessionName(chatId, name);
-  }
-
-  // ── Delivery — decision tree shared with the Kilo backend ──────────────────
-  const delivery = await routeDelivery({
-    backendLabel: "OpenCode",
-    chatId,
-    state,
-    responseText,
-    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)})`,
+    params,
   );
-  traceMessage(chatId, "out", responseText, {
-    durationMs,
-    toolCalls: state.toolCalls,
-  });
-
-  return {
-    text: responseText,
-    durationMs,
-    inputTokens: state.sdkInputTokens,
-    outputTokens: state.sdkOutputTokens,
-    cacheRead: state.sdkCacheRead,
-    cacheWrite: state.sdkCacheWrite,
-  };
-}
-
-/**
- * Compact summary of which SSE event types fired this turn. `none` for a
- * silent turn. Otherwise renders as `delta×42,part.updated×1`.
- */
-function formatEventCounts(counts: Record<string, number>): string {
-  const entries = Object.entries(counts);
-  if (entries.length === 0) return "none";
-  return entries
-    .map(([type, n]) => `${type.replace(/^(message|session)\./, "")}×${n}`)
-    .join(",");
 }

package/src/backend/opencode/server.ts

@@ -1,19 +1,14 @@
 /**
- * OpenCode server lifecycle — thin wrapper around `backend/remote-server/`.
+ * OpenCode server lifecycle — the OpenCode profile bound through
+ * `backend/remote-server/server-bindings.ts`.
  *
- * The MCP / session / provider plumbing is identical to Kilo (Kilo is a
- * fork of OpenCode that exposes the same HTTP API), so this module
- * keeps only the OpenCode-specific bits:
- *
- *   - Constants (port 4096, system-prompt suffix wording).
- *   - SDK-specific client factory (`createOpencodeClient` +
- *     `createOpencodeServer`).
- *   - Backend-specific model parser (the fuzzy `provider/model` splitter
- *     from `./models.ts`).
- *   - Pre-warm hook that triggers immediately at init.
- *
- * The shared machinery (server spawn, MCP registration, session creation,
- * provider resolution) lives in `backend/remote-server/`.
+ * The server spawn, MCP registration, session creation, and provider
+ * resolution are the shared remote-server family implementation (Kilo is
+ * a fork with the same HTTP API). This module holds only what is
+ * OpenCode's: the SDK constructors, port 4096, the text-preferred
+ * delivery contract, and the fuzzy `provider/model` parser. The exports
+ * keep their historical names — the models module, one-shot runner,
+ * tests, and `vi.mock("../backend/opencode/server.js")` all address them.
  */
 
 import {
@@ -21,219 +16,64 @@ import {
   createOpencodeServer,
   type OpencodeClient,
 } from "@opencode-ai/sdk/v2";
-import type { TalonConfig } from "../../util/config.js";
-import type { FrontendName } from "../../core/agent-runtime/backend-registry.js";
-import { buildDeliveryContract } from "../shared/delivery-contract.js";
 import {
-  guessProviderID,
-  getBucketPriority,
   normalizeModelLookup,
-  parseRemoteModelQuery as parseOpenCodeModelQuery,
+  parseRemoteModelQuery,
 } from "../remote-server/model-catalog/index.js";
 import {
-  createRemoteServerState,
-  ensureRemoteServer as ensureRemoteServerShared,
-  stopRemoteServer,
-  ensureChatMcpServer as ensureChatMcpServerShared,
-  ensurePluginMcpServers as ensurePluginMcpServersShared,
-  buildToolOverrides as buildToolOverridesShared,
-  disconnectChatMcpServer as disconnectChatMcpServerShared,
-  refreshPluginMcpServers as refreshPluginMcpServersShared,
-  ensureRemoteSession,
-  warmRemoteSession,
-  resolveProviderID as resolveProviderIDShared,
-  getRegisteredMcpServerNames as getRegisteredMcpServerNamesShared,
-  errMsg as sharedErrMsg,
-  type RemoteServerState,
-} from "../remote-server/index.js";
-
-// ── Constants ───────────────────────────────────────────────────────────────
-
-const OPENCODE_HOSTNAME = "127.0.0.1";
-// Overridable via `OPENCODE_PORT` env so integration tests can spawn an
-// isolated server alongside a running production Talon (which holds 4096).
-const OPENCODE_PORT = Number(process.env.OPENCODE_PORT ?? 4096);
-const OPENCODE_BASE_URL = `http://${OPENCODE_HOSTNAME}:${OPENCODE_PORT}`;
-// Text-preferred delivery: plain assistant text is the reply; tools
-// only for genuine side effects. Single-sourced from the shared
-// contract templates (prompts/system/contract-text-preferred.md).
-export function opencodeSystemPromptSuffix(frontend: string): string {
-  return `\n\n${buildDeliveryContract("text-preferred", frontend)}\n`;
-}
-
-/** Telegram-shaped default, kept for one-shot (cross-surface) paths. */
-const OPENCODE_SYSTEM_PROMPT_SUFFIX = opencodeSystemPromptSuffix("telegram");
-
-// ── State ───────────────────────────────────────────────────────────────────
-
-const state: RemoteServerState<OpencodeClient> =
-  createRemoteServerState<OpencodeClient>({
-    label: "OpenCode",
-    hostname: OPENCODE_HOSTNAME,
-    port: OPENCODE_PORT,
-  });
-
-function createStrictOpencodeClient(baseUrl: string): OpencodeClient {
-  return createOpencodeClient({
-    baseUrl,
-    throwOnError: true,
-  });
-}
-
-// ── Init / teardown ─────────────────────────────────────────────────────────
-
-export function initOpenCodeAgent(
-  cfg: TalonConfig,
-  getGatewayPort?: () => number,
-  frontend?: FrontendName,
-): void {
-  state.config = cfg;
-  if (getGatewayPort) state.gatewayPortFn = getGatewayPort;
-  if (frontend) state.frontendName = frontend;
-}
+  bindRemoteServer,
+  type RemoteModelSelection,
+} from "../remote-server/server-bindings.js";
 
 /**
- * Callbacks run when the server stops — cache invalidation lives with the
- * caches. The models module registers its clear here at load time, so the
- * server never has to import it (which would be a cycle).
+ * Parse the stored model-selection string into a `{providerID?, modelID}`
+ * pair. The parser is fuzzy — it tries to extract a provider hint from the
+ * prefix while preserving the full model id when ambiguous. See
+ * `remote-server/model-catalog/` for the underlying `parseRemoteModelQuery`.
  */
-const stopHooks = new Set<() => void>();
-
-/** Register a callback to run whenever the OpenCode server is stopped. */
-export function onServerStop(hook: () => void): void {
-  stopHooks.add(hook);
-}
-
-export function stopOpenCodeServer(): void {
-  stopRemoteServer(state, () => {
-    for (const hook of stopHooks) hook();
-  });
-}
-
-// ── Server lifecycle ────────────────────────────────────────────────────────
-
-export function ensureServer(): Promise<OpencodeClient> {
-  return ensureRemoteServerShared({
-    state,
-    createClient: createStrictOpencodeClient,
-    createServer: ({ hostname, port, timeout }) =>
-      createOpencodeServer({ hostname, port, timeout }),
-  });
-}
-
-// ── MCP server registration ─────────────────────────────────────────────────
-
-export function ensureChatMcpServer(
-  oc: OpencodeClient,
-  chatId: string,
-): Promise<string> {
-  return ensureChatMcpServerShared(oc, state, chatId);
-}
-
-export function ensurePluginMcpServers(
-  oc: OpencodeClient,
-  chatId: string,
-): Promise<string[]> {
-  return ensurePluginMcpServersShared(oc, state, chatId);
-}
-
-export function buildToolOverrides(
-  oc: OpencodeClient,
-  chatServerName: string,
-  pluginServerNames: readonly string[] = [],
-): Promise<Record<string, boolean> | undefined> {
-  return buildToolOverridesShared(oc, state, chatServerName, pluginServerNames);
-}
-
-export function disconnectChatMcpServer(
-  oc: OpencodeClient,
-  serverName: string,
-): Promise<void> {
-  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(
-  oc: OpencodeClient,
-  chatId: string,
-): Promise<string> {
-  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(
-  oc: OpencodeClient,
-  modelID: string,
-): Promise<string> {
-  return resolveProviderIDShared(oc, state, modelID, {
-    guessProviderID,
-    getBucketPriority,
-  });
-}
-
-/**
- * Parse the stored model-selection string into a `{providerID?, modelID}` pair.
- *
- * OpenCode model ids occasionally encode the provider as a `provider/model`
- * prefix (e.g. `openrouter/anthropic/claude-3.5-sonnet`). The parser here
- * is fuzzy — it tries to extract a provider hint from the prefix while
- * preserving the full model id when ambiguous. See `./models.ts` for the
- * underlying `parseOpenCodeModelQuery` logic.
- */
-export function parseStoredOpenCodeModelSelection(value: string): {
-  providerID?: string;
-  modelID: string;
-} {
-  const { providerQuery, modelQuery } = parseOpenCodeModelQuery(value);
+export function parseStoredOpenCodeModelSelection(
+  value: string,
+): RemoteModelSelection {
+  const { providerQuery, modelQuery } = parseRemoteModelQuery(value);
   return {
     providerID: providerQuery ? normalizeModelLookup(providerQuery) : undefined,
     modelID: modelQuery,
   };
 }
 
-// ── Internal accessors ─────────────────────────────────────────────────────
-
-export function getConfig(): TalonConfig {
-  if (!state.config) {
-    throw new Error(
-      "OpenCode agent not initialized — call initOpenCodeAgent first",
-    );
-  }
-  return state.config;
-}
-
-/**
- * Snapshot of the locally-cached MCP server registrations. Test-only.
- */
-export function getRegisteredMcpServerNames(): string[] {
-  return getRegisteredMcpServerNamesShared(state);
-}
-
-const errMsg = sharedErrMsg;
-
-export { OPENCODE_BASE_URL, OPENCODE_SYSTEM_PROMPT_SUFFIX, errMsg };
+// Text-preferred delivery: plain assistant text is the reply; tools only
+// for genuine side effects. Single-sourced from the shared contract
+// templates (prompts/system/contract-text-preferred.md).
+const opencode = bindRemoteServer<OpencodeClient>({
+  label: "OpenCode",
+  defaultPort: 4096,
+  portEnv: "OPENCODE_PORT",
+  deliveryContract: "text-preferred",
+  createClient: (baseUrl) =>
+    createOpencodeClient({ baseUrl, throwOnError: true }),
+  createServer: ({ hostname, port, timeout }) =>
+    createOpencodeServer({ hostname, port, timeout }),
+  parseModelSelection: parseStoredOpenCodeModelSelection,
+});
+
+export const OPENCODE_BASE_URL = opencode.baseUrl;
+export const opencodeSystemPromptSuffix = opencode.systemPromptSuffix;
+export const OPENCODE_SYSTEM_PROMPT_SUFFIX = opencode.defaultSystemPromptSuffix;
+export const initOpenCodeAgent = opencode.init;
+export const stopOpenCodeServer = opencode.stop;
+export const {
+  onServerStop,
+  ensureServer,
+  ensureChatMcpServer,
+  ensurePluginMcpServers,
+  buildToolOverrides,
+  disconnectChatMcpServer,
+  refreshPluginMcpServers,
+  updateSystemPrompt,
+  ensureSession,
+  warmSession,
+  resolveProviderID,
+  getConfig,
+  getRegisteredMcpServerNames,
+  errMsg,
+} = opencode;