@vellumai/assistant 0.6.6 → 0.7.0

package/src/daemon/daemon-skill-host.ts

@@ -0,0 +1,262 @@
+/**
+ * `DaemonSkillHost` — in-process concretion of the neutral `SkillHost`
+ * interface defined in `@vellumai/skill-host-contracts`.
+ *
+ * `createDaemonSkillHost(skillId)` returns a plain object whose nine facets
+ * (`logger`, `config`, `identity`, `platform`, `providers`, `memory`,
+ * `events`, `registries`, `speakers`) delegate to the daemon's existing
+ * singleton modules. First-party skills that live in-process receive this
+ * host via the bootstrap path instead of reaching into `assistant/` with
+ * relative imports.
+ *
+ * Where a delegate's signature does not line up exactly with the contract
+ * — pino's `(meta, msg)` log methods vs the contract's `(msg, meta)`,
+ * `getAssistantName()` returning `null` vs the contract's `undefined`,
+ * `getProviderKeyAsync()` returning `undefined` vs the contract's `null`,
+ * `buildAssistantEvent()` taking an assistantId first arg, etc. — the
+ * adaptation happens inside this file so the contract stays narrow and the
+ * underlying daemon APIs stay unchanged.
+ */
+
+import type {
+  AssistantEvent,
+  AssistantEventCallback,
+  ConfigFacet,
+  EventsFacet,
+  Filter,
+  IdentityFacet,
+  InsertMessageFn,
+  LlmProvidersFacet,
+  Logger,
+  LoggerFacet,
+  MemoryFacet,
+  PlatformFacet,
+  Provider,
+  ProvidersFacet,
+  RegistriesFacet,
+  SecureKeysFacet,
+  ServerMessage,
+  SkillHost,
+  SkillRoute,
+  SkillRouteHandle,
+  SpeakersFacet,
+  StreamingTranscriber,
+  SttProvidersFacet,
+  Subscription,
+  ToolUse,
+  TtsConfig,
+  TtsProvider,
+  TtsProvidersFacet,
+  UserMessage,
+} from "@vellumai/skill-host-contracts";
+
+import { SpeakerIdentityTracker } from "../calls/speaker-identification.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import { getConfig, getNestedValue } from "../config/loader.js";
+import type { LLMCallSite } from "../config/schemas/llm.js";
+import { addMessage } from "../memory/conversation-crud.js";
+import {
+  createTimeout,
+  extractToolUse,
+  getConfiguredProvider,
+  userMessage,
+} from "../providers/provider-send-message.js";
+import {
+  listProviderIds as sttListProviderIds,
+  supportsBoundary as sttSupportsBoundary,
+} from "../providers/speech-to-text/provider-catalog.js";
+import { resolveStreamingTranscriber as sttResolveStreamingTranscriber } from "../providers/speech-to-text/resolve.js";
+import { wakeAgentForOpportunity } from "../runtime/agent-wake.js";
+import { buildAssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { getDaemonRuntimeMode } from "../runtime/runtime-mode.js";
+import { registerSkillRoute } from "../runtime/skill-route-registry.js";
+import { getProviderKeyAsync } from "../security/secure-keys.js";
+import { registerExternalTools } from "../tools/registry.js";
+import { getTtsProvider } from "../tts/provider-registry.js";
+import { resolveTtsConfig } from "../tts/tts-config-resolver.js";
+import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir, vellumRoot } from "../util/platform.js";
+import { getAssistantName } from "./identity-helpers.js";
+import { registerShutdownHook } from "./shutdown-registry.js";
+
+/**
+ * Adapt pino's `(meta, msg)` call shape to the contract's `(msg, meta?)`
+ * shape so skills can use `host.logger.get(...).info("msg", { ... })`
+ * without knowing about pino.
+ */
+function adaptLogger(name: string): Logger {
+  const pino = getLogger(name);
+  return {
+    debug: (msg, meta) => pino.debug(meta ?? {}, msg),
+    info: (msg, meta) => pino.info(meta ?? {}, msg),
+    warn: (msg, meta) => pino.warn(meta ?? {}, msg),
+    error: (msg, meta) => pino.error(meta ?? {}, msg),
+  };
+}
+
+function buildLoggerFacet(skillId: string): LoggerFacet {
+  return {
+    get: (name) => adaptLogger(`${skillId}:${name}`),
+  };
+}
+
+function buildConfigFacet(): ConfigFacet {
+  return {
+    isFeatureFlagEnabled: (key) =>
+      isAssistantFeatureFlagEnabled(key, getConfig()),
+    getSection: <T>(path: string): T | undefined =>
+      getNestedValue(
+        getConfig() as unknown as Record<string, unknown>,
+        path,
+      ) as T | undefined,
+  };
+}
+
+function buildIdentityFacet(): IdentityFacet {
+  return {
+    // Contract uses `undefined`; delegate returns `null`. Normalize here.
+    getAssistantName: () => getAssistantName() ?? undefined,
+    internalAssistantId: DAEMON_INTERNAL_ASSISTANT_ID,
+  };
+}
+
+function buildPlatformFacet(): PlatformFacet {
+  return {
+    workspaceDir: () => getWorkspaceDir(),
+    vellumRoot: () => vellumRoot(),
+    runtimeMode: () => getDaemonRuntimeMode(),
+  };
+}
+
+function buildLlmProvidersFacet(): LlmProvidersFacet {
+  return {
+    getConfigured: async (callSite) =>
+      (await getConfiguredProvider(callSite as LLMCallSite)) as Provider | null,
+    userMessage: (text) => userMessage(text) as unknown as UserMessage,
+    extractToolUse: (response) =>
+      (extractToolUse(response as Parameters<typeof extractToolUse>[0]) ??
+        null) as ToolUse | null,
+    createTimeout,
+  };
+}
+
+function buildSttProvidersFacet(): SttProvidersFacet {
+  return {
+    listProviderIds: () => [...sttListProviderIds()],
+    // Contract asks whether a provider id is usable; we check against the
+    // daemon-streaming boundary which is the only boundary skills currently
+    // care about. Passes the id through to the daemon helper.
+    supportsBoundary: (id) =>
+      sttSupportsBoundary(
+        id as Parameters<typeof sttSupportsBoundary>[0],
+        "daemon-streaming",
+      ),
+    resolveStreamingTranscriber: async (spec) =>
+      (await sttResolveStreamingTranscriber(
+        spec as Parameters<typeof sttResolveStreamingTranscriber>[0],
+      )) as StreamingTranscriber | null,
+  };
+}
+
+function buildTtsProvidersFacet(): TtsProvidersFacet {
+  return {
+    get: (id) => getTtsProvider(id as never) as unknown as TtsProvider,
+    // `resolveTtsConfig` needs the current config; the contract takes no
+    // args, so we fetch `getConfig()` at call time and pass it through.
+    resolveConfig: () => resolveTtsConfig(getConfig()) as unknown as TtsConfig,
+  };
+}
+
+function buildSecureKeysFacet(): SecureKeysFacet {
+  return {
+    // Daemon returns `undefined`; contract returns `null`. Normalize.
+    getProviderKey: async (id) => (await getProviderKeyAsync(id)) ?? null,
+  };
+}
+
+function buildProvidersFacet(): ProvidersFacet {
+  return {
+    llm: buildLlmProvidersFacet(),
+    stt: buildSttProvidersFacet(),
+    tts: buildTtsProvidersFacet(),
+    secureKeys: buildSecureKeysFacet(),
+  };
+}
+
+function buildMemoryFacet(): MemoryFacet {
+  return {
+    addMessage: addMessage as InsertMessageFn,
+    wakeAgentForOpportunity: async (req) => {
+      // Contract returns `void`; daemon returns a `WakeResult` that
+      // in-process callers don't need through the host surface.
+      await wakeAgentForOpportunity(req as never);
+    },
+  };
+}
+
+function buildEventsFacet(): EventsFacet {
+  return {
+    // Contract types events/messages as opaque supersets of the daemon's
+    // narrower discriminated unions; cast at the boundary so
+    // `assistantEventHub` continues to accept its existing type.
+    publish: (event: AssistantEvent) =>
+      assistantEventHub.publish(event as never),
+    subscribe: (filter: Filter, cb: AssistantEventCallback): Subscription =>
+      assistantEventHub.subscribe(filter, cb as never),
+    // `buildAssistantEvent` takes `(assistantId, message, conversationId?)`.
+    // Skills always publish as the internal assistant, so curry that arg.
+    buildEvent: (message: ServerMessage, conversationId?: string) =>
+      buildAssistantEvent(
+        DAEMON_INTERNAL_ASSISTANT_ID,
+        message as never,
+        conversationId,
+      ) as AssistantEvent,
+  };
+}
+
+function buildRegistriesFacet(skillId: string): RegistriesFacet {
+  return {
+    // Contract's `Tool` is structurally independent of the daemon's
+    // overlay (`assistant/src/tools/types.ts`); the assistant-side
+    // registry accepts the daemon flavor. Skills construct tools via
+    // helpers that already produce the daemon shape, so a cast at this
+    // boundary is safe.
+    registerTools: (provider) => registerExternalTools(provider as never),
+    registerSkillRoute: (route: SkillRoute): SkillRouteHandle =>
+      registerSkillRoute(route) as unknown as SkillRouteHandle,
+    // Namespace hook names by skillId so two skills using the same label
+    // (e.g. "cleanup") cannot silently overwrite each other's entries in
+    // the shared shutdown-hook map.
+    registerShutdownHook: (name, hook) =>
+      registerShutdownHook(`${skillId}:${name}`, hook),
+  };
+}
+
+function buildSpeakersFacet(): SpeakersFacet {
+  return {
+    createTracker: () => new SpeakerIdentityTracker(),
+  };
+}
+
+/**
+ * Build a `SkillHost` for the in-process first-party skill identified by
+ * `skillId`. The id prefixes logger names (so cross-cutting diagnostics
+ * carry the owning skill) and namespaces shutdown-hook registrations (so
+ * two skills using the same hook label cannot silently overwrite each
+ * other in the shared shutdown-hook map).
+ */
+export function createDaemonSkillHost(skillId: string): SkillHost {
+  return {
+    logger: buildLoggerFacet(skillId),
+    config: buildConfigFacet(),
+    identity: buildIdentityFacet(),
+    platform: buildPlatformFacet(),
+    providers: buildProvidersFacet(),
+    memory: buildMemoryFacet(),
+    events: buildEventsFacet(),
+    registries: buildRegistriesFacet(skillId),
+    speakers: buildSpeakersFacet(),
+  };
+}

package/src/daemon/external-plugins-bootstrap.ts

@@ -14,8 +14,11 @@
  * 3. For each plugin, consults `manifest.requiresFlag` against
  *    {@link isAssistantFeatureFlagEnabled}. If any listed flag is disabled,
  *    the plugin is skipped wholesale — no `init()`, no tool/route/skill
- *    contributions, and no entry in the shutdown hook. This is the primary
- *    mechanism for shipping experimental plugins behind a feature flag.
+ *    contributions, no entry in the shutdown hook, and the plugin is also
+ *    dropped from the registry via {@link unregisterPlugin} so its middleware
+ *    and injectors stop participating in pipeline runs and system-prompt
+ *    assembly. This is the primary mechanism for shipping experimental
+ *    plugins behind a feature flag.
  * 4. Resolves the plugin's `manifest.requiresCredential` entries via the
  *    credential store helper ({@link getSecureKeyAsync}). In Docker mode
  *    that helper goes through the CES HTTP API transparently; in local mode
@@ -24,7 +27,7 @@
  *    `manifest.config` if the manifest supplies a parser-like validator
  *    (Zod schemas with `.parse()` are supported; anything else is passed
  *    through untouched).
- * 6. Creates `~/.vellum/plugins-data/<plugin>/` on demand for per-plugin
+ * 6. Creates `<workspaceDir>/plugins-data/<plugin>/` on demand for per-plugin
  *    writable state and exposes it via {@link PluginInitContext.pluginStorageDir}.
  * 7. Awaits `plugin.init(ctx)` sequentially. One init failure surfaces as a
  *    {@link PluginExecutionError} naming the offending plugin and aborts
@@ -60,6 +63,7 @@ import {
 import {
   ASSISTANT_API_VERSIONS,
   getRegisteredPlugins,
+  unregisterPlugin,
 } from "../plugins/registry.js";
 import {
   type Plugin,
@@ -78,7 +82,7 @@ import {
   unregisterPluginTools,
 } from "../tools/registry.js";
 import { getLogger } from "../util/logger.js";
-import { vellumRoot } from "../util/platform.js";
+import { getWorkspaceDir } from "../util/platform.js";
 import { registerShutdownHook } from "./shutdown-registry.js";
 
 const log = getLogger("plugins-bootstrap");
@@ -157,10 +161,10 @@ function getPluginConfigRaw(
 }
 
 /**
- * Ensure `~/.vellum/plugins-data/<name>/` exists and return its absolute path.
+ * Ensure `<workspaceDir>/plugins-data/<name>/` exists and return its absolute path.
  */
 function ensurePluginStorageDir(pluginName: string): string {
-  const dir = join(vellumRoot(), "plugins-data", pluginName);
+  const dir = join(getWorkspaceDir(), "plugins-data", pluginName);
   mkdirSync(dir, { recursive: true });
   return dir;
 }
@@ -208,6 +212,17 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
   // onShutdown" invariant.
   const activePlugins: ActivePlugin[] = [];
 
+  // Tear down a plugin's contributions AND remove it from the registry. The
+  // two steps always move together on the bootstrap failure path: the former
+  // clears tools/routes/skills (so they stop appearing to the model/HTTP
+  // server), the latter drops the plugin's entry from the Map (so
+  // `getMiddlewaresFor` / `getInjectors` don't re-enter an uninitialized
+  // plugin on the next pipeline invocation).
+  async function rollbackPlugin(active: ActivePlugin): Promise<void> {
+    await teardownPlugin(active, "bootstrap-failed");
+    unregisterPlugin(active.plugin.manifest.name);
+  }
+
   // If one plugin's init or contribution phase throws, tear down any plugins
   // that already fully initialized (in reverse registration order) before
   // re-throwing. Without this, a mid-loop failure would leave earlier plugins
@@ -215,7 +230,7 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
   // hook is only registered once the loop completes successfully.
   async function teardownPartialInit(): Promise<void> {
     for (let i = activePlugins.length - 1; i >= 0; i--) {
-      await teardownPlugin(activePlugins[i]!, "bootstrap-failed");
+      await rollbackPlugin(activePlugins[i]!);
     }
   }
 
@@ -239,9 +254,29 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
         { plugin: name, flag: disabledFlag },
         `skipping plugin ${name}: feature flag ${disabledFlag} is disabled`,
       );
+      // Drop the plugin from the registry too. `registerPlugin()` added it at
+      // import time, and `getMiddlewaresFor()` / `getInjectors()` iterate over
+      // every registered entry — without this call, the gated plugin's
+      // middleware and injectors would still participate in every pipeline
+      // run and system-prompt assembly despite `init()` never firing.
+      unregisterPlugin(name);
       continue;
     }
 
+    // Collected as routes are accepted so the catch block can revoke exactly
+    // the routes this plugin contributed if a later contribution step throws.
+    // Hoisted above the try so it's in scope for the error path.
+    const routeHandles: SkillRouteHandle[] = [];
+
+    // Tracks whether `plugin.init()` ran to completion (or the plugin has no
+    // init at all). The catch block consults this to decide whether the
+    // currently-failing plugin's `onShutdown()` may run: onShutdown is paired
+    // with init, so a plugin that never completed init never set up the state
+    // onShutdown is meant to tear down. Calling onShutdown in that case would
+    // surprise plugin authors (their teardown runs against an uninitialized
+    // self) and breaks the documented lifecycle contract.
+    let initCompleted = false;
+
     try {
       // Credential resolution — gather every entry in `requiresCredential`
       // before calling `init()` so the plugin receives a fully-populated map.
@@ -287,6 +322,9 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
           );
         }
       }
+      // Reached when init() succeeded or the plugin has no init hook. The
+      // catch block reads this to decide whether onShutdown may run.
+      initCompleted = true;
 
       // After init succeeds, wire in the plugin's model-visible capabilities.
       // Tool contributions (PR 31) register only after `init()` succeeds so a
@@ -319,7 +357,6 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
       // teardown path unregisters by identity rather than pattern text — two
       // plugins (or a plugin and a skill) that happen to register the same
       // regex must not evict each other's routes during shutdown.
-      const routeHandles: SkillRouteHandle[] = [];
       if (plugin.routes && plugin.routes.length > 0) {
         for (const route of plugin.routes) {
           routeHandles.push(registerSkillRoute(route));
@@ -358,11 +395,28 @@ export async function bootstrapPlugins(ctx: DaemonContext): Promise<void> {
 
       log.info({ plugin: name }, "plugin initialized");
     } catch (err) {
-      // Tear down every plugin that already made it through its full init +
-      // contribution phase, in reverse order, before propagating the error.
-      // Without this, the caller would see a partially-wired registry (tools,
-      // routes, skills all live) with no shutdown hook to clean them up, since
-      // `registerShutdownHook` is only called after the loop completes.
+      // Roll back the currently-failing plugin first — it is not in
+      // `activePlugins` yet (that push happens only after every contribution
+      // step succeeds), so `teardownPartialInit()` alone would leave its
+      // already-registered tools, routes, and skills live.
+      //
+      // Branching on `initCompleted` keeps the init/onShutdown pairing
+      // intact. When init succeeded but a later contribution step (tools,
+      // routes, skills) threw, the plugin has live init-side state that
+      // `onShutdown()` is responsible for cleaning up, so the full
+      // rollbackPlugin() path runs. When init itself failed (or a step
+      // before init — credential resolution, config validation — threw),
+      // onShutdown must not run: calling it would invoke the plugin's
+      // teardown against an uninitialized self, violating the lifecycle
+      // contract documented on `Plugin.onShutdown`. In the init-failed case
+      // there is also nothing to unregister — tools, routes, and skills are
+      // all registered after init — so just drop the plugin from the
+      // registry (idempotent if already removed).
+      if (initCompleted) {
+        await rollbackPlugin({ plugin, routeHandles });
+      } else {
+        unregisterPlugin(name);
+      }
       await teardownPartialInit();
       throw err;
     }

package/src/daemon/handlers/config-channels.ts

@@ -10,7 +10,7 @@ import {
 } from "../../contacts/contact-store.js";
 import { revokeMember } from "../../contacts/contacts-write.js";
 import type { ChannelStatus } from "../../contacts/types.js";
-import * as externalConversationStore from "../../memory/external-conversation-store.js";
+import { getBindingByChannelChat } from "../../memory/external-conversation-store.js";
 import { resolveGuardianName } from "../../prompts/user-reference.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../runtime/assistant-scope.js";
 import {
@@ -127,7 +127,7 @@ export function getVerificationStatus(
   // Resolve username from external conversation store.
   let guardianUsername: string | undefined;
   if (binding?.guardianDeliveryChatId) {
-    const ext = externalConversationStore.getBindingByChannelChat(
+    const ext = getBindingByChannelChat(
       resolvedChannel,
       binding.guardianDeliveryChatId,
     );

package/src/daemon/handlers/config-embeddings.ts

@@ -41,7 +41,7 @@ const EMBEDDING_PROVIDER_CATALOG = [
   {
     id: "gemini",
     displayName: "Gemini",
-    defaultModel: "gemini-embedding-2-preview",
+    defaultModel: "gemini-embedding-2",
     requiresKey: true,
   },
   {

package/src/daemon/handlers/config-ingress.ts

@@ -5,13 +5,15 @@ import {
 } from "../../calls/twilio-rest.js";
 import {
   getGatewayInternalBaseUrl,
+  getPlatformAssistantId,
+  getPlatformBaseUrl,
   setIngressPublicBaseUrl,
 } from "../../config/env.js";
+import { getIsPlatform } from "../../config/env-registry.js";
 import { loadRawConfig, saveRawConfig } from "../../config/loader.js";
 import {
   registerCallbackRoute,
   resolveCallbackUrl,
-  shouldUsePlatformCallbacks,
 } from "../../inbound/platform-callback-registration.js";
 import {
   getTwilioStatusCallbackUrl,
@@ -38,8 +40,27 @@ export function getIngressConfigResult(): {
   enabled: boolean;
   publicBaseUrl: string;
   localGatewayTarget: string;
+  managedCallbacks: boolean;
   success: boolean;
 } {
+  // Platform-managed assistants don't configure ingress.publicBaseUrl —
+  // they receive webhooks through platform callback routing. Surface the
+  // platform callback URL and flag managedCallbacks so consumers (including
+  // the assistant LLM) don't mistakenly try to set up ngrok or a tunnel.
+  if (getIsPlatform()) {
+    const platformBase = getPlatformBaseUrl().replace(/\/+$/, "");
+    const assistantId = getPlatformAssistantId();
+    if (assistantId) {
+      return {
+        enabled: true,
+        publicBaseUrl: `${platformBase}/gateway/callbacks/${assistantId}`,
+        localGatewayTarget: computeGatewayTarget(),
+        managedCallbacks: true,
+        success: true,
+      };
+    }
+  }
+
   const raw = loadRawConfig();
   const ingress = (raw?.ingress ?? {}) as Record<string, unknown>;
   const publicBaseUrl = (ingress.publicBaseUrl as string) ?? "";
@@ -48,6 +69,7 @@ export function getIngressConfigResult(): {
     enabled,
     publicBaseUrl,
     localGatewayTarget: computeGatewayTarget(),
+    managedCallbacks: false,
     success: true,
   };
 }
@@ -166,7 +188,7 @@ export async function handleIngressConfig(
       // This must happen independently of ingress URL — in containerized
       // deployments without ingress.publicBaseUrl, platform callbacks are the
       // only way to receive Telegram webhooks.
-      if (shouldUsePlatformCallbacks()) {
+      if (getIsPlatform()) {
         registerCallbackRoute("webhooks/telegram", "telegram").catch((err) => {
           log.warn(
             { err },

package/src/daemon/handlers/config-model.test.ts

@@ -59,6 +59,23 @@ describe("projectProviderForWire", () => {
     expect(wire.models.length).toBe(anthropic!.models.length);
   });
 
+  test("projects Gemini 3 text models onto the wire catalog", () => {
+    const gemini = PROVIDER_CATALOG.find((p) => p.id === "gemini");
+    expect(gemini).toBeDefined();
+    const wire = projectProviderForWire(gemini!);
+    const modelIds = wire.models.map((model) => model.id);
+    const expectedGemini3ModelIds = [
+      "gemini-3.1-pro-preview",
+      "gemini-3.1-pro-preview-customtools",
+      "gemini-3-flash-preview",
+      "gemini-3.1-flash-lite-preview",
+    ];
+
+    expect(modelIds.filter((id) => id.startsWith("gemini-3"))).toEqual(
+      expectedGemini3ModelIds,
+    );
+  });
+
   test("omits apiKeyUrl/apiKeyPlaceholder when source entry has none (keyless providers)", () => {
     const ollama = PROVIDER_CATALOG.find((p) => p.id === "ollama");
     expect(ollama).toBeDefined();

package/src/daemon/handlers/config-model.ts

@@ -20,18 +20,14 @@ import {
   isProviderAvailable,
 } from "../../providers/provider-availability.js";
 import { initializeProviders } from "../../providers/registry.js";
-import type {
-  ImageGenModelSetRequest,
-  ModelSetRequest,
-} from "../message-protocol.js";
 import {
-  CONFIG_RELOAD_DEBOUNCE_MS,
-  type HandlerContext,
-  log,
-} from "./shared.js";
+  conversationEntries,
+  deleteConversation,
+} from "../conversation-store.js";
+import { CONFIG_RELOAD_DEBOUNCE_MS, log } from "./shared.js";
 
 /** Reverse lookup: model ID → provider, derived from PROVIDER_CATALOG. */
-export const MODEL_TO_PROVIDER: Record<string, string> = Object.fromEntries(
+const MODEL_TO_PROVIDER: Record<string, string> = Object.fromEntries(
   PROVIDER_CATALOG.flatMap((provider) =>
     provider.models.map(({ id }) => [id, provider.id]),
   ),
@@ -107,10 +103,6 @@ export async function getModelInfo(): Promise<ModelInfo> {
  * Keeps the business logic decoupled from transport-specific HandlerContext.
  */
 export interface ModelSetContext {
-  conversations: Map<
-    string,
-    { isProcessing(): boolean; dispose(): void; markStale(): void }
-  >;
   suppressConfigReload: boolean;
   setSuppressConfigReload(value: boolean): void;
   updateConfigFingerprint(): void;
@@ -200,10 +192,10 @@ export async function setModel(
 
   // Evict idle conversations immediately; mark busy ones as stale so they
   // get recreated with the new provider once they finish processing.
-  for (const [id, conversation] of ctx.conversations) {
+  for (const [id, conversation] of conversationEntries()) {
     if (!conversation.isProcessing()) {
       conversation.dispose();
-      ctx.conversations.delete(id);
+      deleteConversation(id);
     } else {
       conversation.markStale();
     }
@@ -253,40 +245,3 @@ export function setImageGenModel(modelId: string, ctx: ModelSetContext): void {
 
 // ---------------------------------------------------------------------------
 // HTTP handlers (delegate to shared logic)
-// ---------------------------------------------------------------------------
-
-export async function handleModelGet(ctx: HandlerContext): Promise<void> {
-  const info = await getModelInfo();
-  ctx.send({
-    type: "model_info",
-    ...info,
-  });
-}
-
-export async function handleModelSet(
-  msg: ModelSetRequest,
-  ctx: HandlerContext,
-): Promise<void> {
-  try {
-    const info = await setModel(msg.model, ctx, msg.provider);
-    ctx.send({ type: "model_info", ...info });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    ctx.send({
-      type: "error",
-      message: `Failed to set model: ${message}`,
-    });
-  }
-}
-
-export function handleImageGenModelSet(
-  msg: ImageGenModelSetRequest,
-  ctx: HandlerContext,
-): void {
-  try {
-    setImageGenModel(msg.model, ctx);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, `Failed to set image gen model: ${message}`);
-  }
-}