talon-agent 3.32.1 → 3.33.1

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

@@ -20,7 +20,7 @@
  */
 
 /** Minimal MCP server config shapes both SDKs accept on `mcp.add`. */
-export type RemoteMcpServerConfig =
+type RemoteMcpServerConfig =
   | {
       type: "local";
       command: string[];

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

@@ -365,7 +365,7 @@ export function maybeFireStreamDelta(
 // ── Sync-response parts backfill ───────────────────────────────────────────
 
 /** Shape returned by a backend's parts-summary extractor. */
-export interface PartsSummary {
+interface PartsSummary {
   text: string;
   toolCalls: number;
   syntheticErrorText?: string;

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,65 +16,37 @@
  *   - 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,
-  RemoteMcpServerConfig,
-  RemotePermissionRule,
-} from "./client.js";
+export type { RemoteAgentClient } from "./client.js";
 
-export {
-  type RemoteServerState,
-  type RemoteServerStateInputs,
-  createRemoteServerState,
-  errMsg,
-} from "./state.js";
+export { type RemoteServerState, createRemoteServerState } from "./state.js";
 
-export {
-  type EnsureRemoteServerInputs,
-  ensureRemoteServer,
-  stopRemoteServer,
-} from "./lifecycle.js";
+export { stopRemoteServer } from "./lifecycle.js";
 
 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,
-  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/mcp.ts

@@ -92,10 +92,7 @@ export function safeMcpNamePart(value: string, fallback: string): string {
 }
 
 /** Per-chat registration name for a plugin-provided MCP server. */
-export function getPluginMcpServerName(
-  pluginName: string,
-  chatId: string,
-): string {
+function getPluginMcpServerName(pluginName: string, chatId: string): string {
   return `${TALON_PLUGIN_MCP_SERVER_NAME}-${safeMcpNamePart(chatId, "chat")}-${safeMcpNamePart(pluginName, "plugin")}`;
 }
 

package/src/backend/remote-server/model-catalog/catalog.ts

@@ -164,7 +164,7 @@ function extractReasoningLevels(rawModel: RemoteRawModel) {
   ]);
 }
 
-export function buildModelCatalog(
+function buildModelCatalog(
   providersData: RemoteRawProvidersData,
   authMap: Record<string, Array<RemoteAuthMethod>>,
 ): RemoteModelCatalog {

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

@@ -25,20 +25,13 @@ import type {
 
 export type {
   ModelButton,
-  RemoteAuthMethod,
   RemoteModelCatalog,
   RemoteModelCatalogEntry,
   RemoteModelResolution,
-  RemoteProviderCatalogEntry,
-  RemoteProviderClient,
-  RemoteRawModel,
-  RemoteRawProvider,
-  RemoteRawProvidersData,
 } from "./types.js";
-export { buildModelCatalog, sortCatalogModels } from "./catalog.js";
+export { sortCatalogModels } from "./catalog.js";
 export {
   getBucketPriority,
-  getRemoteModelInfo,
   getRemoteModelSelectionValue,
   guessProviderID,
   normalizeModelLookup,
@@ -46,14 +39,7 @@ export {
   resolveRemoteModelInput,
 } from "./resolve.js";
 export { formatRemoteUnavailableModel } from "./presentation.js";
-export type { RemoteModelPresentation } from "./presentation.js";
 export { createRemoteModelProvider } from "./provider.js";
-export type {
-  RemoteModelProvider,
-  RemoteModelProviderDeps,
-} from "./provider.js";
-export type { RemoteModelCatalogStore } from "./catalog.js";
-
 export interface RemoteModelCatalogModuleOptions {
   /** Human label — "OpenCode" / "Kilo" — used in headers and errors. */
   label: string;

package/src/backend/remote-server/model-catalog/provider.ts

@@ -12,7 +12,6 @@ import type {
   UnifiedModelInfo,
   UnifiedModelResolution,
   UnifiedProviderInfo,
-  ModelButton,
 } from "../../../core/types.js";
 import type {
   RemoteModelCatalog,