talon-agent 3.33.0 → 3.33.2

package/src/backend/opencode/sessions.ts

@@ -1,113 +1,35 @@
 /**
- * OpenCode session helpers — thin wrapper around
- * `backend/remote-server/session-helpers.ts`.
- *
- * Kilo is a fork of OpenCode that exposes the same session message shape
- * and question API, so the parsing / summarisation / snapshot logic
- * lives in the shared module. This file binds the OpenCode backend label
- * and re-exports under OpenCode-named symbols for back-compat with the
- * handler and the public OpenCode barrel.
+ * OpenCode session helpers — the shared `remote-server/session-helpers.ts`
+ * bound to the OpenCode client, re-exported under OpenCode-named symbols
+ * for the handler / index / test imports.
  */
 
 import type { OpencodeClient } from "@opencode-ai/sdk/v2";
 import {
   extractPartsSummary as extractPartsSummaryShared,
-  extractAssistantUsage as extractAssistantUsageShared,
   summarizeAssistantMessages,
-  getTurnSummary,
   getSessionSnapshot,
-  rejectPendingQuestions as rejectPendingQuestionsShared,
-  approvePendingPermissions as approvePendingPermissionsShared,
-  type RemoteAssistantInfo,
   type RemoteSessionSnapshot,
   type RemoteSessionClient,
 } from "../remote-server/session-helpers.js";
 import { ensureServer } from "./server.js";
 
-// ── Constants / type aliases (OpenCode-named surface) ──────────────────────
-
-/** Subset of OpenCode's `Message.info` used by Talon for usage accounting. */
-export type OpenCodeAssistantInfo = RemoteAssistantInfo;
-
 /** Snapshot of an OpenCode session's lifetime + last-turn assistant info. */
 export type OpenCodeSessionSnapshot = RemoteSessionSnapshot;
 
-// ── Re-exports of pure helpers ─────────────────────────────────────────────
-
 export const extractPartsSummary = extractPartsSummaryShared;
-export const extractAssistantUsage = extractAssistantUsageShared;
 
-/**
- * Summarise a batch of session messages into per-turn usage totals.
- * Re-exported under the OpenCode-prefixed name for back-compat with
- * existing imports.
- */
+/** Summarise a batch of session messages into per-turn usage totals. */
 export const summarizeOpenCodeAssistantMessages = summarizeAssistantMessages;
 
-// ── Session-messages aggregators ──────────────────────────────────────────
-
-/**
- * Aggregate the most recent turn's assistant messages into a usage
- * summary. Delegates to the shared helper with an OpenCode-typed client.
- */
-export function getOpenCodeTurnSummary(
-  oc: OpencodeClient,
-  sessionId: string,
-  minCreatedAt: number,
-): Promise<ReturnType<typeof summarizeAssistantMessages>> {
-  return getTurnSummary(
-    oc as unknown as RemoteSessionClient,
-    sessionId,
-    minCreatedAt,
-  );
-}
-
 /**
  * Build an {@link OpenCodeSessionSnapshot} for the given session id.
- *
  * Returns `undefined` if no session id was provided.
  */
 export async function getOpenCodeSessionSnapshot(
   sessionId: string | undefined,
 ): Promise<OpenCodeSessionSnapshot | undefined> {
   if (!sessionId) return undefined;
-  const oc = await ensureServer();
+  const oc: OpencodeClient = await ensureServer();
   return getSessionSnapshot(oc as unknown as RemoteSessionClient, sessionId);
 }
-
-// ── Pending-question guard ─────────────────────────────────────────────────
-
-/**
- * Auto-respond to pending OpenCode questions for this session. Delegates
- * to the shared helper with the OpenCode backend label.
- */
-export function rejectPendingQuestions(
-  oc: OpencodeClient,
-  sessionId: string,
-  chatId: string,
-  seenQuestionIds: Set<string>,
-): Promise<void> {
-  return rejectPendingQuestionsShared(
-    oc as unknown as RemoteSessionClient,
-    sessionId,
-    chatId,
-    seenQuestionIds,
-    "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/chat-turn.ts

@@ -0,0 +1,359 @@
+/**
+ * The chat-turn orchestration for the remote-server family — one message
+ * in, one `QueryResult` out.
+ *
+ * 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.
+ *
+ * Kilo and OpenCode ran byte-for-byte copies of this (modulo the backend
+ * name in log lines). The copies are gone; `RemoteChatBindings` is the
+ * seam a backend supplies, and it is a subset of what `bindRemoteServer`
+ * already returns.
+ */
+
+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 { frontendsForChat, nonTerminalFrontends } from "../shared/frontends.js";
+import {
+  createStreamState,
+  recordTokens,
+  finalizeResponseText,
+  formatUserPrompt,
+  prepareSystemPrompt,
+  extractSessionName,
+  summarizeUsage,
+  routeDelivery,
+  applyRetryDecision,
+  recordTurnMetrics,
+  recordFailedTurnAccounting,
+  registerTurnInterrupt,
+} from "../shared/index.js";
+import type { RemoteAgentClient } from "./client.js";
+import type { RemoteServerBindings } from "./server-bindings.js";
+import { getTurnSummary, type RemoteSessionClient } from "./session-helpers.js";
+import { runRemoteTurn, type RemoteTurnClient } from "./turn.js";
+
+/** What a backend hands the shared handler: its id/label plus server bindings. */
+export type RemoteChatBindings<TClient extends RemoteAgentClient> = Pick<
+  RemoteServerBindings<TClient>,
+  | "getConfig"
+  | "ensureServer"
+  | "parseModelSelection"
+  | "resolveProviderID"
+  | "ensureSession"
+  | "ensureChatMcpServer"
+  | "ensurePluginMcpServers"
+  | "buildToolOverrides"
+  | "systemPromptSuffix"
+> & {
+  /** Registry id — the `backend` column in turn metrics ("kilo"). */
+  id: string;
+  /** Display label for log lines and retry classification ("Kilo"). */
+  label: string;
+};
+
+export async function runRemoteChatTurn<TClient extends RemoteAgentClient>(
+  bindings: RemoteChatBindings<TClient>,
+  params: QueryParams,
+  retried = false,
+): Promise<QueryResult> {
+  const { id, label } = bindings;
+  const config = bindings.getConfig();
+  if (!config) throw new Error(`${label} 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 the server's catalog.
+  const chatSettings = getChatSettings(chatId);
+  const activeModel = params.model ?? chatSettings.model ?? config.model;
+  const { providerID: selectedProviderID, modelID } =
+    bindings.parseModelSelection(activeModel);
+
+  const oc = await bindings.ensureServer();
+  const providerID =
+    selectedProviderID ?? (await bindings.resolveProviderID(oc, modelID));
+  log(
+    "agent",
+    `[${chatId}] ${label} model resolved: provider=${providerID} model=${modelID}` +
+      (selectedProviderID ? "" : " (provider via catalog lookup)"),
+  );
+  const sessionId = await bindings.ensureSession(oc, chatId);
+  const chatMcpServerName = await bindings.ensureChatMcpServer(oc, chatId);
+  const pluginMcpServerNames = await bindings.ensurePluginMcpServers(
+    oc,
+    chatId,
+  );
+  const toolOverrides = await bindings.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 + this backend's delivery suffix.
+  const { text: systemPrompt } = prepareSystemPrompt({
+    config,
+    previousTurns,
+    backendSuffix: bindings.systemPromptSuffix(
+      frontendsForChat(chatId, nonTerminalFrontends(config.frontend))[0] ??
+        "telegram",
+    ),
+    chatId,
+    sessionEpoch: session.createdAt,
+  });
+
+  log("agent", `[${chatId}] <- (${text.length} chars)`);
+  traceMessage(chatId, "in", text, { senderName, isGroup });
+
+  // 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;
+  const turnClient = oc as unknown as RemoteTurnClient;
+  // 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 turnClient.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 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 — the frontend contract is "send the final reply once", not
+    // live edit_message updates. Final delivery happens through
+    // `end_turn` / `send`.
+    const turnStart = Date.now();
+    await runRemoteTurn({
+      label,
+      oc: turnClient,
+      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,
+      params,
+      recurseWithRetried: (p) => runRemoteChatTurn(bindings, p, true),
+      backendLabel: label,
+    });
+    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: id,
+      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}] ${label} error: ${outcome.classified.message}`,
+    );
+    throw outcome.classified;
+  } finally {
+    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;
+    // 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 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
+    }
+  }
+
+  const responseText = finalizeResponseText(state);
+  const durationMs = Date.now() - t0;
+  recordTurnMetrics({
+    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,
+    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 — the decision tree shared by every backend ──────────────────
+  const delivery = await routeDelivery({
+    backendLabel: label,
+    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)})`,
+  );
+  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 (itself a useful diagnostic — the SSE socket dropped or never
+ * matched our session id). 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";
+  // Trim the noisy `message.` / `session.` prefixes so the line stays
+  // readable in the live log tail.
+  return entries
+    .map(([type, n]) => `${type.replace(/^(message|session)\./, "")}×${n}`)
+    .join(",");
+}

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

@@ -0,0 +1,150 @@
+/**
+ * Compose a registry `BackendFactory` for a remote-server backend.
+ *
+ * The capability wiring is identical for every member of the family:
+ * chat through the shared handler, one-shot through the shared runner, the
+ * catalog-driven model slots, session snapshots off the server, plugin-MCP
+ * refresh, warm-after-reset, and the system-prompt control. A backend
+ * supplies its id/label/SDK name and the bound functions; this returns the
+ * factory for `registerBackend`.
+ */
+
+import type {
+  BackendFactory,
+  FrontendName,
+} from "../../core/agent-runtime/backend-registry.js";
+import type { BackendId } from "../../core/agent-runtime/model-ref.js";
+import {
+  composeBackend,
+  type BackgroundRunner,
+  type ChatBackend,
+  type ModelCatalog,
+  type SessionBackend,
+  type SystemControl,
+  type ToolRuntime,
+  type UsageTelemetry,
+} from "../../core/agent-runtime/capabilities.js";
+import type { OneShotAgentParams, OneShotUsage } from "../../core/types.js";
+import type { TalonConfig } from "../../util/config.js";
+import { log } from "../../util/log.js";
+import { handlerToEvents } from "../shared/handler-to-events.js";
+import type { QueryParams, QueryResult } from "../shared/handler-types.js";
+import { interruptChatTurn } from "../shared/turn-interrupt.js";
+import type { RemoteModelProvider } from "./model-catalog/provider.js";
+import type { RemoteSessionSnapshot } from "./session-helpers.js";
+
+export interface RemoteBackendFactoryInputs {
+  /** Registry id — matches `config.backend` ("kilo"). */
+  id: BackendId;
+  /** Display label ("Kilo"). */
+  label: string;
+  /** npm package of the SDK, for the startup log line. */
+  sdkPackage: string;
+  init(
+    config: TalonConfig,
+    getGatewayPort?: () => number,
+    frontend?: FrontendName,
+  ): void;
+  stop(): void;
+  handleMessage(params: QueryParams): Promise<QueryResult>;
+  runOneShotAgent(params: OneShotAgentParams): Promise<OneShotUsage | void>;
+  getSessionSnapshot(
+    sessionId: string | undefined,
+  ): Promise<RemoteSessionSnapshot | undefined>;
+  models: RemoteModelProvider;
+  refreshPluginMcpServers: ToolRuntime["refreshTools"];
+  warmSession(chatId: string): Promise<void>;
+  updateSystemPrompt(prompt: string): void;
+}
+
+export function createRemoteBackendFactory(
+  inputs: RemoteBackendFactoryInputs,
+): BackendFactory {
+  const { id, label } = inputs;
+  return {
+    id,
+    label,
+    async init(config, ctx) {
+      inputs.init(config, ctx.getBridgePort, ctx.frontendName);
+      log("bot", `Backend: ${label} (${inputs.sdkPackage})`);
+
+      const chat: ChatBackend = {
+        runChatTurn: (params) =>
+          handlerToEvents((p) => inputs.handleMessage(p), params),
+        interruptChatTurn: (chatId) => interruptChatTurn(chatId),
+      };
+
+      const background: BackgroundRunner = {
+        runOneShotAgent: (p) => inputs.runOneShotAgent(p),
+        // A long-lived HTTP server — no per-query subprocesses, so
+        // `evictOrphanSubprocesses` is intentionally not implemented.
+      };
+
+      const m = inputs.models;
+      const models: ModelCatalog = {
+        resolveModelInfo: (q) => m.resolveModel(q),
+        // Catalog-driven backend with no canonical default — fall through
+        // to `config.backendDefaults.<id>`.
+        getDefaultModelId: () => undefined,
+        getRawModelInfo: (modelId) => m.getModelInfo(modelId),
+        getSettingsPresentation: (activeModel, options) =>
+          m.getSettingsPresentation(activeModel, options),
+        getProviders: () => m.getProviders(),
+        getProviderModels: (p, pg, ps) => m.getProviderModels(p, pg, ps),
+        formatModelError: (q, r) => m.formatModelError(q, r),
+        listModels: (f) => m.listModels(f),
+      };
+
+      const usage: UsageTelemetry = {
+        getSessionSnapshot: async (sessionId) => {
+          const snap = await inputs.getSessionSnapshot(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) => inputs.refreshPluginMcpServers(chatId),
+      };
+
+      // Session state lives on the 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) => inputs.warmSession(chatId),
+      };
+
+      const control: SystemControl = {
+        updateSystemPrompt: (prompt) => inputs.updateSystemPrompt(prompt),
+      };
+
+      const backend = composeBackend({
+        id,
+        label,
+        cacheMetrics: "readwrite",
+        chat,
+        background,
+        models,
+        sessions,
+        tools,
+        usage,
+        control,
+      });
+
+      return {
+        backend,
+        cleanup: () => {
+          inputs.stop();
+        },
+      };
+    },
+  };
+}

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

@@ -6,7 +6,7 @@
  * for MCP registration, session lifecycle, tool listing, and provider
  * resolution).
  *
- * Architecture in three layers:
+ * Architecture in four layers:
  *
  *   - {@link RemoteServerState} (state.ts) — per-backend mutable container.
  *     Each concrete backend owns one instance, holding the cached client,
@@ -16,29 +16,29 @@
  *   - Lifecycle / MCP / sessions / providers — pure helpers that take a
  *     `RemoteAgentClient` + `RemoteServerState` and act on them.
  *
- *   - Concrete backends (`backend/opencode`, `backend/kilo`) — supply
- *     the SDK-specific client and server factories, the prompt /
- *     promptAsync drivers, and the system-prompt suffix.
+ *   - Bindings (server-bindings.ts, chat-turn.ts, turn.ts, factory.ts) —
+ *     the helpers closed over one backend's state, the SSE-driven turn,
+ *     the chat-turn orchestration, and the registry factory composition.
+ *     This is where the code that used to be copied per backend lives.
+ *
+ *   - Concrete backends (`backend/opencode`, `backend/kilo`) — a
+ *     `RemoteBackendProfile` (SDK constructors, port, delivery contract,
+ *     model-selection parser) plus re-exports under historical names.
  *
  * What's NOT here (intentionally):
  *
- *   - SDK-specific event types (Kilo's SSE events, OpenCode's sync
- *     `prompt` parts list) — those stay in each backend.
- *   - Per-backend model catalog logic (`models.ts`) — Kilo and OpenCode
- *     have different bucket priorities, fuzzy-match weights, etc.
  *   - Tool definitions, frontend prompt format — those are backend-
  *     agnostic and live in `core/` and `backend/shared/`.
+ *
+ * This barrel exposes the helper layer for tests and the conformance
+ * suite; the bindings modules import from the concrete files directly.
  */
 
 export type { RemoteAgentClient } from "./client.js";
 
-export {
-  type RemoteServerState,
-  createRemoteServerState,
-  errMsg,
-} from "./state.js";
+export { type RemoteServerState, createRemoteServerState } from "./state.js";
 
-export { ensureRemoteServer, stopRemoteServer } from "./lifecycle.js";
+export { stopRemoteServer } from "./lifecycle.js";
 
 export {
   TALON_MCP_SERVER_NAME,
@@ -48,10 +48,5 @@ export {
   ensurePluginMcpServers,
   buildToolOverrides,
   disconnectChatMcpServer,
-  refreshPluginMcpServers,
   getRegisteredMcpServerNames,
 } from "./mcp.js";
-
-export { ensureRemoteSession, warmRemoteSession } from "./sessions.js";
-
-export { resolveProviderID } from "./providers.js";