talon-agent 3.32.1 → 3.33.1

package/src/backend/opencode/factory.ts

@@ -1,130 +1,53 @@
 /**
  * OpenCode backend factory — wires OpenCode into the registry.
  *
- * Mirrors the Kilo factory in structure. OpenCode and Kilo share the
- * same protocol shape (Kilo is a fork) so the adapter logic is nearly
- * identical — only the SDK import and a few constant names differ.
- *
- * Returns a composed `Backend` with capability slots for chat,
- * background, models, and usage.
+ * Side-effect import (`import "./factory.js"` from `bootstrap.ts`) calls
+ * `registerBackend(...)` at module load, making OpenCode available under
+ * `config.backend === "opencode"`. The capability wiring is the shared
+ * remote-server composition; only the bound functions are OpenCode's.
  */
 
 import { registerBackend } from "../../core/agent-runtime/backend-registry.js";
-import type { BackendFactory } from "../../core/agent-runtime/backend-registry.js";
-import { log } from "../../util/log.js";
-import { handlerToEvents } from "../shared/handler-to-events.js";
-import { interruptChatTurn } from "../shared/turn-interrupt.js";
-import {
-  composeBackend,
-  type ChatBackend,
-  type BackgroundRunner,
-  type ModelCatalog,
-  type SessionBackend,
-  type SystemControl,
-  type ToolRuntime,
-  type UsageTelemetry,
-} from "../../core/agent-runtime/capabilities.js";
-
+import { createRemoteBackendFactory } from "../remote-server/factory.js";
 import {
   initOpenCodeAgent,
   stopOpenCodeServer,
-  handleMessage as ocHandleMessage,
-  runOneShotAgent as ocRunOneShotAgent,
+  handleMessage,
+  runOneShotAgent,
   getOpenCodeSessionSnapshot,
-  resolveModel as ocResolveModel,
-  getModelInfo as ocGetModelInfo,
-  getSettingsPresentation as ocGetSettingsPresentation,
-  getProviders as ocGetProviders,
-  getProviderModels as ocGetProviderModels,
-  formatModelError as ocFormatModelError,
-  listModels as ocListModels,
-  refreshPluginMcpServers as ocRefreshPluginMcpServers,
-  updateSystemPrompt as ocUpdateSystemPrompt,
-  warmSession as ocWarmSession,
+  resolveModel,
+  getModelInfo,
+  getSettingsPresentation,
+  getProviders,
+  getProviderModels,
+  formatModelError,
+  listModels,
+  refreshPluginMcpServers,
+  updateSystemPrompt,
+  warmSession,
 } from "./index.js";
 
-const opencodeFactory: BackendFactory = {
-  id: "opencode",
-  label: "OpenCode",
-
-  async init(config, ctx) {
-    initOpenCodeAgent(config, ctx.getBridgePort, ctx.frontendName);
-    log("bot", "Backend: OpenCode (@opencode-ai/sdk)");
-
-    const chat: ChatBackend = {
-      runChatTurn: (params) =>
-        handlerToEvents((p) => ocHandleMessage(p), params),
-      interruptChatTurn: (chatId) => interruptChatTurn(chatId),
-    };
-
-    const background: BackgroundRunner = {
-      runOneShotAgent: (p) => ocRunOneShotAgent(p),
-    };
-
-    const models: ModelCatalog = {
-      resolveModelInfo: (q) => ocResolveModel(q),
-      // Catalog-driven backend with no canonical default.
-      getDefaultModelId: () => undefined,
-      getRawModelInfo: (id) => ocGetModelInfo(id),
-      getSettingsPresentation: (m, options) =>
-        ocGetSettingsPresentation(m, options),
-      getProviders: () => ocGetProviders(),
-      getProviderModels: (p, pg, ps) => ocGetProviderModels(p, pg, ps),
-      formatModelError: (q, r) => ocFormatModelError(q, r),
-      listModels: (f) => ocListModels(f),
-    };
-
-    const usage: UsageTelemetry = {
-      getSessionSnapshot: async (sessionId) => {
-        const snap = await getOpenCodeSessionSnapshot(sessionId);
-        if (!snap) return undefined;
-        return {
-          inputTokens: snap.usage?.totalInputTokens,
-          outputTokens: snap.usage?.totalOutputTokens,
-          cacheRead: snap.usage?.totalCacheRead,
-          cacheWrite: snap.usage?.totalCacheWrite,
-          contextModelId: snap.assistant?.modelID,
-        };
-      },
-    };
-
-    const tools: ToolRuntime = {
-      refreshTools: (chatId) => ocRefreshPluginMcpServers(chatId),
-    };
-
-    // Session state lives on the OpenCode server, and `/reset` already
-    // clears Talon's stored id centrally (storage/sessions.ts), so the
-    // next turn creates a fresh one — no `resetChat` needed. `warmSession`
-    // front-loads that creation plus the plugin-MCP sweep, matching what
-    // the Claude backend does after a reset.
-    const sessions: SessionBackend = {
-      warmSession: (chatId) => ocWarmSession(chatId),
-    };
-
-    const control: SystemControl = {
-      updateSystemPrompt: (prompt) => ocUpdateSystemPrompt(prompt),
-    };
-
-    const backend = composeBackend({
-      id: "opencode",
-      label: "OpenCode",
-      cacheMetrics: "readwrite",
-      chat,
-      background,
-      models,
-      sessions,
-      tools,
-      usage,
-      control,
-    });
-
-    return {
-      backend,
-      cleanup: () => {
-        stopOpenCodeServer();
-      },
-    };
-  },
-};
-
-registerBackend(opencodeFactory);
+registerBackend(
+  createRemoteBackendFactory({
+    id: "opencode",
+    label: "OpenCode",
+    sdkPackage: "@opencode-ai/sdk",
+    init: initOpenCodeAgent,
+    stop: stopOpenCodeServer,
+    handleMessage,
+    runOneShotAgent,
+    getSessionSnapshot: getOpenCodeSessionSnapshot,
+    models: {
+      resolveModel,
+      getModelInfo,
+      getSettingsPresentation,
+      getProviders,
+      getProviderModels,
+      formatModelError,
+      listModels,
+    },
+    refreshPluginMcpServers,
+    warmSession,
+    updateSystemPrompt,
+  }),
+);

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

@@ -1,12 +1,2 @@
-/**
- * OpenCode message handler.
- *
- * Split by responsibility (parallel to the kilo handler/ layout):
- *   - `state`   — in-flight session registry (activeSessions)
- *   - `turn`    — runOpenCodeTurn + SSE subscription + last-assistant lookup
- *   - `message` — the handleMessage entry point + post-loop accounting
- *
- * Re-exports the same public surface the old single-file module exposed.
- */
-
+/** OpenCode message handler barrel. */
 export { handleMessage } from "./message.js";

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/index.ts

@@ -9,10 +9,6 @@
  */
 
 export {
-  type OpenCodeModelCatalogEntry,
-  type OpenCodeModelCatalog,
-  type OpenCodeModelResolution,
-  type ModelButton,
   getOpenCodeModelSelectionValue,
   resolveOpenCodeModelInput,
   formatOpenCodeSelectionError,