@vellumai/assistant 0.7.0 → 0.7.2

package/src/daemon/conversation-process.ts

@@ -12,14 +12,11 @@ import {
   createUserMessage,
 } from "../agent/message-types.js";
 import {
-  canServiceRegistryBrowser,
   parseChannelId,
   parseInterfaceId,
-  supportsHostProxy,
   type TurnChannelContext,
   type TurnInterfaceContext,
 } from "../channels/types.js";
-import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import type { ContextWindowResult } from "../context/window-manager.js";
 import { listPendingRequestsByConversationScope } from "../memory/canonical-guardian-store.js";
@@ -42,12 +39,13 @@ import type {
 } from "./conversation-queue-manager.js";
 import type { ChannelCapabilities } from "./conversation-runtime-assembly.js";
 import {
+  buildSlashContextForContent,
   classifySlash,
   resolveSlash,
   type SlashContext,
 } from "./conversation-slash.js";
 import { getModelInfo } from "./handlers/config-model.js";
-import type { HostBrowserProxy } from "./host-browser-proxy.js";
+import { preactivateHostProxySkills } from "./host-proxy-preactivation.js";
 import type {
   ServerMessage,
   UsageStats,
@@ -63,22 +61,32 @@ const log = getLogger("conversation-process");
 
 /** Format the result of a forced compaction into a user-facing message. */
 export function formatCompactResult(result: ContextWindowResult): string {
-  const fmt = (n: number) => n.toLocaleString("en-US");
+  const fmt = (n: number | undefined) => (n ?? 0).toLocaleString("en-US");
   if (!result.compacted) {
-    return `Context compaction skipped — ${result.reason ?? "nothing to compact"}.`;
+    return [
+      `Context compaction skipped — ${result.reason ?? "nothing to compact"}.`,
+      `Context: ${fmt(result.estimatedInputTokens)} / ${fmt(
+        result.maxInputTokens,
+      )} tokens`,
+    ].join("\n");
   }
   const saved =
     result.previousEstimatedInputTokens - result.estimatedInputTokens;
   return [
     "Context Compacted\n",
     `Tokens:   ${fmt(result.previousEstimatedInputTokens)} → ${fmt(result.estimatedInputTokens)} (${fmt(saved)} saved)`,
+    `Context:  ${fmt(result.estimatedInputTokens)} / ${fmt(
+      result.maxInputTokens,
+    )} tokens`,
     `Messages: ${fmt(result.compactedMessages)} compacted`,
   ].join("\n");
 }
 
 /** Build a model_info event with fresh config data. */
-export async function buildModelInfoEvent(): Promise<ServerMessage> {
-  return { type: "model_info", ...(await getModelInfo()) };
+export async function buildModelInfoEvent(
+  conversationId?: string,
+): Promise<ServerMessage> {
+  return { type: "model_info", conversationId, ...(await getModelInfo()) };
 }
 
 /** True when the trimmed content is the /models slash command. */
@@ -134,7 +142,7 @@ export interface ProcessConversationContext {
   runAgentLoop(
     content: string,
     userMessageId: string,
-    onEvent: (msg: ServerMessage) => void,
+    onEvent?: (msg: ServerMessage) => void,
     options?: {
       isInteractive?: boolean;
       isUserMessage?: boolean;
@@ -146,26 +154,6 @@ export interface ProcessConversationContext {
   setTurnChannelContext(ctx: TurnChannelContext): void;
   getTurnInterfaceContext(): TurnInterfaceContext | null;
   setTurnInterfaceContext(ctx: TurnInterfaceContext): void;
-  /** Mark host proxies as unavailable so tool execution uses local fallback. */
-  clearProxyAvailability(): void;
-  /**
-   * Restore host proxy availability based on whether a real client is connected.
-   * When `skipBrowser` is true, the browser proxy is left untouched — use this
-   * when `restoreBrowserProxyAvailability()` will handle the browser proxy
-   * separately with the correct registry-routed sender.
-   */
-  restoreProxyAvailability(options?: { skipBrowser?: boolean }): void;
-  /** Restore only the host browser proxy (used by chrome-extension and macOS drains). */
-  restoreBrowserProxyAvailability(): void;
-  /**
-   * Registry-routed sender override for the host browser proxy. When set,
-   * `restoreBrowserProxyAvailability()` uses this function instead of
-   * `sendToClient`. Set by the POST /messages handler when the guardian
-   * has an active extension connection (regardless of interface).
-   */
-  hostBrowserSenderOverride?: (msg: ServerMessage) => void;
-  /** Replace or clear the conversation's host browser proxy. */
-  setHostBrowserProxy(proxy: HostBrowserProxy | undefined): void;
   emitActivityState(
     phase:
       | "idle"
@@ -249,20 +237,18 @@ function resolveQueuedTurnInterfaceContext(
 
 /** Build a SlashContext from the current conversation state and config. */
 function buildSlashContext(
+  content: string,
   conversation: ProcessConversationContext,
-): SlashContext {
-  const config = getConfig();
+): SlashContext | undefined {
   const turnInterface = conversation.getTurnInterfaceContext();
-  return {
+  return buildSlashContextForContent(content, {
+    conversationId: conversation.conversationId,
     messageCount: conversation.messages.length,
     inputTokens: conversation.usageStats.inputTokens,
     outputTokens: conversation.usageStats.outputTokens,
-    maxInputTokens: config.llm.default.contextWindow.maxInputTokens,
-    model: config.llm.default.model,
-    provider: config.llm.default.provider,
     estimatedCost: conversation.usageStats.estimatedCost,
     userMessageInterface: turnInterface?.userMessageInterface,
-  };
+  });
 }
 
 /**
@@ -439,87 +425,19 @@ async function drainSingleMessage(
     conversation.applyHostEnvFromTransport(next.transport);
   }
 
-  // Non-interactive queued messages (channel requests) must not execute tools
-  // via the desktop host proxy. Clear proxy availability so isAvailable()
-  // returns false and tool execution falls back to local.
-  if (next.isInteractive === false) {
-    conversation.clearProxyAvailability();
-    // chrome-extension is non-interactive (no SSE prompter UI) but DOES have
-    // a connected client that can service host_browser_request events. The
-    // unconditional clear above turned its hostBrowserProxy off; restore it
-    // here so the queued turn can still drive the browser via CDP.
-    const drainInterfaceCtx =
-      queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
-    const drainInterface = drainInterfaceCtx?.userMessageInterface;
-    if (
-      drainInterface &&
-      !supportsHostProxy(drainInterface) &&
-      supportsHostProxy(drainInterface, "host_browser")
-    ) {
-      conversation.restoreBrowserProxyAvailability();
-    }
-  } else {
-    // Restore proxy availability only for desktop-originating turns (macos)
-    // in case a prior non-interactive drain disabled it. Non-desktop interactive
-    // interfaces (CLI, Vellum) should not re-enable desktop host proxies. The
-    // chrome-extension interface only supports host_browser, not the desktop
-    // proxies or computer-use, so it is excluded by the no-arg form of
-    // supportsHostProxy (which returns false for chrome-extension).
+  // Re-preactivate host-proxy skills for interactive desktop turns. The
+  // dequeue path reset `preactivatedSkillIds` above, so without these
+  // re-adds the relevant skill tools wouldn't be projected to the LLM
+  // for queued messages 2+ even though the underlying proxies (HostCuProxy,
+  // HostAppControlProxy) are still attached. Mirrors the per-message
+  // instantiation block in `conversation-routes.ts` / `process-message.ts`.
+  if (next.isInteractive !== false) {
     const interfaceCtx =
       queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
-    const sourceInterface = interfaceCtx?.userMessageInterface;
-    if (sourceInterface && supportsHostProxy(sourceInterface)) {
-      // When hostBrowserSenderOverride is set, skip the browser proxy here
-      // — restoreBrowserProxyAvailability() below will handle it with the
-      // correct registry-routed sender instead of the SSE hub emitter.
-      // When no override is set (macOS without extension), restoring the
-      // browser proxy via restoreProxyAvailability is correct — it will
-      // use the SSE sender so host_browser_request frames reach the
-      // desktop client directly.
-      conversation.restoreProxyAvailability(
-        conversation.hostBrowserSenderOverride
-          ? { skipBrowser: true }
-          : undefined,
-      );
-      conversation.addPreactivatedSkillId("computer-use");
-    }
-    // Tear down a stale hostBrowserProxy inherited from a prior turn on a
-    // different interface (e.g. chrome-extension or macOS installed one,
-    // then a CLI turn drains). Without this, restoreProxyAvailability()
-    // above would re-enable the proxy and getCdpClient() would route
-    // browser tools through host_browser_request and hang waiting for a
-    // client that this turn's interface can't service.
-    //
-    // Skip teardown only when BOTH conditions hold:
-    //   1. `hostBrowserSenderOverride` is set (live registry-routed sender)
-    //   2. The current turn's interface can service host_browser frames
-    //      (chrome-extension or macOS).
-    // Without the interface check, queued turns from CLI/iOS/Vellum would
-    // inherit a stale override left by a prior extension-connected turn
-    // and keep the proxy alive, causing cross-interface misrouting.
-    //
-    // macOS and chrome-extension both support host_browser natively, so
-    // this teardown only fires for interfaces that do not support
-    // host_browser at all (CLI, iOS, Vellum, channels).
-    const currentTurnCanServiceBrowser =
-      !!sourceInterface && canServiceRegistryBrowser(sourceInterface);
-    if (
-      sourceInterface &&
-      !supportsHostProxy(sourceInterface, "host_browser") &&
-      !(conversation.hostBrowserSenderOverride && currentTurnCanServiceBrowser)
-    ) {
-      conversation.setHostBrowserProxy(undefined);
-    }
-    // When a macOS turn has a registry-routed sender override (active
-    // extension connection), restore the browser proxy so host_browser
-    // tools route through the extension rather than cdp-inspect/local.
-    if (
-      sourceInterface &&
-      supportsHostProxy(sourceInterface) &&
-      conversation.hostBrowserSenderOverride
-    ) {
-      conversation.restoreBrowserProxyAvailability();
-    }
+    preactivateHostProxySkills(
+      conversation,
+      interfaceCtx?.userMessageInterface,
+    );
   }
 
   // Snapshot persona context at turn start so later tool turns can't pick up
@@ -531,7 +449,7 @@ async function drainSingleMessage(
   // Resolve slash commands for queued messages
   const slashResult = await resolveSlash(
     next.content,
-    buildSlashContext(conversation),
+    buildSlashContext(next.content, conversation),
   );
 
   // Unknown slash — persist the exchange and continue draining.
@@ -616,9 +534,13 @@ async function drainSingleMessage(
       // Emit fresh model info before the text delta so the client has
       // up-to-date configuredProviders when rendering /model or /models UI.
       if (isModelSlashCommand(next.content)) {
-        next.onEvent(await buildModelInfoEvent());
+        next.onEvent(await buildModelInfoEvent(conversation.conversationId));
       }
-      next.onEvent({ type: "assistant_text_delta", text: slashResult.message });
+      next.onEvent({
+        type: "assistant_text_delta",
+        text: slashResult.message,
+        conversationId: conversation.conversationId,
+      });
       conversation.traceEmitter.emit(
         "message_complete",
         "Unknown slash command handled",
@@ -650,7 +572,11 @@ async function drainSingleMessage(
           attributes: { reason: "persist_failure" },
         },
       );
-      next.onEvent({ type: "error", message });
+      next.onEvent({
+        type: "error",
+        conversationId: conversation.conversationId,
+        message,
+      });
     }
     // Continue draining regardless of success/failure
     await drainQueue(conversation);
@@ -707,7 +633,11 @@ async function drainSingleMessage(
       );
       conversation.messages.push(assistantMsg);
 
-      next.onEvent({ type: "assistant_text_delta", text: responseText });
+      next.onEvent({
+        type: "assistant_text_delta",
+        text: responseText,
+        conversationId: conversation.conversationId,
+      });
       conversation.traceEmitter.emit(
         "message_complete",
         "Compact slash command handled",
@@ -727,7 +657,11 @@ async function drainSingleMessage(
         },
         "Failed to execute /compact",
       );
-      next.onEvent({ type: "error", message });
+      next.onEvent({
+        type: "error",
+        conversationId: conversation.conversationId,
+        message,
+      });
     }
     await drainQueue(conversation);
     return;
@@ -787,7 +721,11 @@ async function drainSingleMessage(
         attributes: { reason: "persist_failure" },
       },
     );
-    next.onEvent({ type: "error", message });
+    next.onEvent({
+      type: "error",
+      conversationId: conversation.conversationId,
+      message,
+    });
     // runAgentLoop never ran, so its finally block won't clear this
     conversation.preactivatedSkillIds = undefined;
     // Continue draining — don't strand remaining messages
@@ -872,6 +810,7 @@ async function drainSingleMessage(
       );
       next.onEvent({
         type: "error",
+        conversationId: conversation.conversationId,
         message: `Failed to process queued message: ${message}`,
       });
     });
@@ -928,50 +867,15 @@ async function drainBatch(
     conversation.applyHostEnvFromTransport(head.transport);
   }
 
-  // Non-interactive queued messages (channel requests) must not execute tools
-  // via the desktop host proxy. Clear proxy availability so isAvailable()
-  // returns false and tool execution falls back to local. Mirrors the
-  // single-message path exactly — sourced from `head`.
-  if (head.isInteractive === false) {
-    conversation.clearProxyAvailability();
-    const drainInterfaceCtx =
-      queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
-    const drainInterface = drainInterfaceCtx?.userMessageInterface;
-    if (
-      drainInterface &&
-      !supportsHostProxy(drainInterface) &&
-      supportsHostProxy(drainInterface, "host_browser")
-    ) {
-      conversation.restoreBrowserProxyAvailability();
-    }
-  } else {
+  // Re-preactivate host-proxy skills for interactive desktop turns.
+  // Mirrors the single-message path exactly — sourced from `head`.
+  if (head.isInteractive !== false) {
     const interfaceCtx =
       queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
-    const sourceInterface = interfaceCtx?.userMessageInterface;
-    if (sourceInterface && supportsHostProxy(sourceInterface)) {
-      conversation.restoreProxyAvailability(
-        conversation.hostBrowserSenderOverride
-          ? { skipBrowser: true }
-          : undefined,
-      );
-      conversation.addPreactivatedSkillId("computer-use");
-    }
-    const currentTurnCanServiceBrowser =
-      !!sourceInterface && canServiceRegistryBrowser(sourceInterface);
-    if (
-      sourceInterface &&
-      !supportsHostProxy(sourceInterface, "host_browser") &&
-      !(conversation.hostBrowserSenderOverride && currentTurnCanServiceBrowser)
-    ) {
-      conversation.setHostBrowserProxy(undefined);
-    }
-    if (
-      sourceInterface &&
-      supportsHostProxy(sourceInterface) &&
-      conversation.hostBrowserSenderOverride
-    ) {
-      conversation.restoreBrowserProxyAvailability();
-    }
+    preactivateHostProxySkills(
+      conversation,
+      interfaceCtx?.userMessageInterface,
+    );
   }
 
   // Snapshot persona context at turn start so later tool turns can't pick up
@@ -1025,7 +929,7 @@ async function drainBatch(
 
     const qmSlash = await resolveSlash(
       qm.content,
-      buildSlashContext(conversation),
+      buildSlashContext(qm.content, conversation),
     );
     if (qmSlash.kind !== "passthrough") {
       // Defensive recovery. `buildPassthroughBatch` should make this
@@ -1051,7 +955,11 @@ async function drainBatch(
         status: "error",
         attributes: { reason: "batch_invariant_violation" },
       });
-      qm.onEvent({ type: "error", message: invariantMessage });
+      qm.onEvent({
+        type: "error",
+        conversationId: conversation.conversationId,
+        message: invariantMessage,
+      });
       if (i === 0) {
         // Head invariant fired — no in-flight turn yet (the check runs
         // before persistUserMessage, so the head was never persisted).
@@ -1118,7 +1026,11 @@ async function drainBatch(
           attributes: { reason: "persist_failure" },
         },
       );
-      qm.onEvent({ type: "error", message });
+      qm.onEvent({
+        type: "error",
+        conversationId: conversation.conversationId,
+        message,
+      });
 
       if (i === 0) {
         // Head persist failed — processing is not set yet, no in-flight turn
@@ -1279,6 +1191,7 @@ async function drainBatch(
       );
       fanOutOnEvent({
         type: "error",
+        conversationId: conversation.conversationId,
         message: `Failed to process queued messages: ${message}`,
       });
     });
@@ -1415,7 +1328,7 @@ export async function processMessage(
   // Resolve slash commands before persistence
   const slashResult = await resolveSlash(
     content,
-    buildSlashContext(conversation),
+    buildSlashContext(content, conversation),
   );
 
   // Unknown slash command — persist the exchange (user + assistant) so the
@@ -1491,9 +1404,13 @@ export async function processMessage(
     // Emit fresh model info before the text delta so the client has
     // up-to-date configuredProviders when rendering /model or /models UI.
     if (isModelSlashCommand(content)) {
-      onEvent(await buildModelInfoEvent());
+      onEvent(await buildModelInfoEvent(conversation.conversationId));
     }
-    onEvent({ type: "assistant_text_delta", text: slashResult.message });
+    onEvent({
+      type: "assistant_text_delta",
+      text: slashResult.message,
+      conversationId: conversation.conversationId,
+    });
     conversation.traceEmitter.emit(
       "message_complete",
       "Unknown slash command handled",
@@ -1561,7 +1478,11 @@ export async function processMessage(
       );
       conversation.messages.push(assistantMsg);
 
-      onEvent({ type: "assistant_text_delta", text: responseText });
+      onEvent({
+        type: "assistant_text_delta",
+        text: responseText,
+        conversationId: conversation.conversationId,
+      });
       conversation.traceEmitter.emit(
         "message_complete",
         "Compact slash command handled",
@@ -1613,7 +1534,11 @@ export async function processMessage(
     );
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    onEvent({ type: "error", message });
+    onEvent({
+      type: "error",
+      conversationId: conversation.conversationId,
+      message,
+    });
     // runAgentLoop never ran, so its finally block won't clear this
     conversation.preactivatedSkillIds = undefined;
     return "";