@vellumai/assistant 0.6.3 → 0.6.4

package/src/runtime/routes/conversation-routes.ts

@@ -1,7 +1,7 @@
 /**
  * Route handlers for conversation messages and suggestions.
  */
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { join, relative } from "node:path";
 
 import { z } from "zod";
@@ -12,8 +12,10 @@ import {
   createUserMessage,
 } from "../../agent/message-types.js";
 import {
+  canServiceRegistryBrowser,
   CHANNEL_IDS,
   INTERFACE_IDS,
+  type InterfaceId,
   isInteractiveInterface,
   parseChannelId,
   parseInterfaceId,
@@ -21,6 +23,7 @@ import {
 } from "../../channels/types.js";
 import { isHttpAuthDisabled } from "../../config/env.js";
 import { getConfig } from "../../config/loader.js";
+import type { Conversation } from "../../daemon/conversation.js";
 import {
   buildModelInfoEvent,
   formatCompactResult,
@@ -45,6 +48,10 @@ import type {
   NonHostProxyTransportMetadata,
 } from "../../daemon/message-types/conversations.js";
 import type { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
+import {
+  writeOnboardingSidecar,
+  writeRelationshipState,
+} from "../../home/relationship-state-writer.js";
 import * as attachmentsStore from "../../memory/attachments-store.js";
 import {
   createCanonicalGuardianRequest,
@@ -74,6 +81,7 @@ import { checkIngressForSecrets } from "../../security/secret-ingress.js";
 import { redactSecrets } from "../../security/secret-scanner.js";
 import { summarizeToolInput } from "../../tools/tool-input-summary.js";
 import { getLogger } from "../../util/logger.js";
+import { getWorkspacePromptPath } from "../../util/platform.js";
 import { silentlyWithLog } from "../../util/silently.js";
 import { buildAssistantEvent } from "../assistant-event.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
@@ -107,7 +115,7 @@ const SUGGESTION_CACHE_MAX = 100;
 function collectCanonicalGuardianRequestHintIds(
   conversationId: string,
   sourceChannel: string,
-  conversation: import("../../daemon/conversation.js").Conversation,
+  conversation: Conversation,
 ): string[] {
   const requests = listPendingRequestsByConversationScope(
     conversationId,
@@ -172,7 +180,7 @@ async function tryConsumeCanonicalGuardianReply(params: {
     data: string;
     filePath?: string;
   }>;
-  conversation: import("../../daemon/conversation.js").Conversation;
+  conversation: Conversation;
   onEvent: (msg: ServerMessage) => void;
   approvalConversationGenerator?: ApprovalConversationGenerator;
   /** Verified actor identity from actor-token middleware. */
@@ -967,7 +975,7 @@ function mergeConsecutiveAssistantMessages(messages: MessageRow[]): {
 function makeHubPublisher(
   deps: SendMessageDeps,
   conversationId: string,
-  conversation: import("../../daemon/conversation.js").Conversation,
+  conversation: Conversation,
 ): (msg: ServerMessage) => void {
   let hubChain: Promise<void> = Promise.resolve();
   return (msg: ServerMessage) => {
@@ -1048,30 +1056,8 @@ function makeHubPublisher(
         conversationId,
         kind: "secret",
       });
-    } else if (msg.type === "host_bash_request") {
-      pendingInteractions.register(msg.requestId, {
-        conversation,
-        conversationId,
-        kind: "host_bash",
-      });
-    } else if (msg.type === "host_browser_request") {
-      pendingInteractions.register(msg.requestId, {
-        conversation,
-        conversationId,
-        kind: "host_browser",
-      });
-    } else if (msg.type === "host_file_request") {
-      pendingInteractions.register(msg.requestId, {
-        conversation,
-        conversationId,
-        kind: "host_file",
-      });
-    } else if (msg.type === "host_cu_request") {
-      pendingInteractions.register(msg.requestId, {
-        conversation,
-        conversationId,
-        kind: "host_cu",
-      });
+    } else {
+      registerHostProxyPendingInteraction(msg, conversation, conversationId);
     }
 
     // ServerMessage is a large union; conversationId exists on most but not all variants.
@@ -1100,6 +1086,202 @@ function makeHubPublisher(
   };
 }
 
+/**
+ * Register pending interactions for host proxy request envelopes so
+ * standalone result endpoints can resolve by requestId.
+ *
+ * Returns the registered requestId when a host proxy request was registered.
+ * Callers that route through non-hub transports (e.g. registry-routed
+ * host_browser sends) can use this to clean up the registration if send fails.
+ */
+function registerHostProxyPendingInteraction(
+  msg: ServerMessage,
+  conversation: Conversation,
+  conversationId: string,
+): string | undefined {
+  if (msg.type === "host_bash_request") {
+    pendingInteractions.register(msg.requestId, {
+      conversation,
+      conversationId,
+      kind: "host_bash",
+    });
+    return msg.requestId;
+  }
+  if (msg.type === "host_browser_request") {
+    pendingInteractions.register(msg.requestId, {
+      conversation,
+      conversationId,
+      kind: "host_browser",
+    });
+    return msg.requestId;
+  }
+  if (msg.type === "host_file_request") {
+    pendingInteractions.register(msg.requestId, {
+      conversation,
+      conversationId,
+      kind: "host_file",
+    });
+    return msg.requestId;
+  }
+  if (msg.type === "host_cu_request") {
+    pendingInteractions.register(msg.requestId, {
+      conversation,
+      conversationId,
+      kind: "host_cu",
+    });
+    return msg.requestId;
+  }
+  return undefined;
+}
+
+/**
+ * Resolve the host_browser sender function for a conversation turn.
+ *
+ * When the guardian has an active extension connection in the
+ * ChromeExtensionRegistry, returns a registry-routed sender that forwards
+ * `host_browser_request` / `host_browser_cancel` frames through the
+ * WebSocket to the connected extension. Otherwise returns the SSE hub
+ * emitter (`onEvent`).
+ *
+ * For `chrome-extension` turns the registry sender is **always** returned
+ * regardless of the POST-time connection check. The chrome-extension
+ * interface has no SSE consumer for `host_browser_request` frames, so
+ * falling back to `onEvent` would cause CDP calls to stall until the proxy
+ * timeout (30 s) instead of failing immediately at send time when the
+ * registry throws on a missing connection.
+ *
+ * This helper is interface-agnostic: both chrome-extension and macOS turns
+ * can obtain a registry-routed sender when extension connectivity exists.
+ * The `isRegistryRouted` flag lets the caller decide whether to set
+ * `hostBrowserSenderOverride` and whether to provision a `HostBrowserProxy`
+ * for interfaces that don't statically support host_browser (e.g. macOS).
+ */
+function resolveHostBrowserSender(
+  conversation: Conversation,
+  conversationId: string,
+  authContext: AuthContext,
+  onEvent: (msg: ServerMessage) => void,
+  sourceInterface: InterfaceId,
+): { sender: (msg: ServerMessage) => void; isRegistryRouted: boolean } {
+  // Check whether the guardian has any active extension connection.
+  const guardianId =
+    conversation.trustContext?.guardianPrincipalId ??
+    authContext.actorPrincipalId;
+  const hasExtensionConnection =
+    !!guardianId && !!getChromeExtensionRegistry().get(guardianId);
+
+  // For chrome-extension, always use the registry sender so that send-time
+  // failures produce immediate errors rather than 30-second proxy timeouts.
+  // The SSE hub has no extension consumer, so falling back to onEvent is
+  // never correct for this interface.
+  if (!hasExtensionConnection && sourceInterface !== "chrome-extension") {
+    return { sender: onEvent, isRegistryRouted: false };
+  }
+
+  // Build a registry-routed sender. The guardian principal ID is resolved
+  // at send time rather than captured here so that queue-drain restores
+  // (which re-fire this closure outside the original POST context) follow
+  // the conversation's bound guardian identity rather than a stale
+  // authContext.actorPrincipalId.
+  const registrySender = (msg: ServerMessage): void => {
+    const requestId = registerHostProxyPendingInteraction(
+      msg,
+      conversation,
+      conversationId,
+    );
+    const gid =
+      conversation.trustContext?.guardianPrincipalId ??
+      authContext.actorPrincipalId;
+    if (!gid) {
+      if (requestId) pendingInteractions.resolve(requestId);
+      throw new Error(
+        "host_browser send skipped: no guardianId on AuthContext",
+      );
+    }
+    const ok = getChromeExtensionRegistry().send(gid, msg);
+    if (!ok) {
+      if (requestId) pendingInteractions.resolve(requestId);
+      throw new Error(
+        `host_browser send failed: no active connection for guardian ${gid}`,
+      );
+    }
+  };
+
+  return { sender: registrySender, isRegistryRouted: true };
+}
+
+/**
+ * Persist the pre-chat onboarding payload to disk.
+ *
+ * Runs only on the very first message of a fresh conversation. Three
+ * artifacts are produced:
+ *
+ *   1. `data/onboarding-context.json` — sidecar read by the
+ *      relationship-state writer so onboarding-sourced facts survive
+ *      the pure-recomputation write cycle (every turn boundary rebuilds
+ *      facts from markdown; the sidecar is the durable source for the
+ *      tool/task/tone chips).
+ *   2. `IDENTITY.md` / `USER.md` — persona seed files, only written
+ *      when missing so we never clobber existing content. These feed
+ *      the system prompt and the relationship-state writer's
+ *      `parseIdentity` / `parseUserName` helpers after a daemon
+ *      restart when the in-memory onboarding context is gone.
+ *   3. `data/relationship-state.json` — kicked off fire-and-forget so
+ *      the Home page can populate immediately on first visit instead
+ *      of waiting for the first agent-turn boundary.
+ *
+ * Never throws: every write is guarded and logged as a warning on
+ * failure. The route handler path must never reject because of a
+ * best-effort persistence step.
+ */
+function persistOnboardingArtifacts(onboarding: {
+  tools: string[];
+  tasks: string[];
+  tone: string;
+  userName?: string;
+  assistantName?: string;
+}): void {
+  writeOnboardingSidecar(onboarding);
+
+  const assistantName = onboarding.assistantName?.trim();
+  if (assistantName) {
+    const identityPath = getWorkspacePromptPath("IDENTITY.md");
+    if (!existsSync(identityPath)) {
+      try {
+        writeFileSync(
+          identityPath,
+          `# Identity\n\n- Name: ${assistantName}\n`,
+          "utf-8",
+        );
+      } catch (err) {
+        log.warn(
+          { err, identityPath },
+          "Failed to seed IDENTITY.md from onboarding",
+        );
+      }
+    }
+  }
+
+  const userName = onboarding.userName?.trim();
+  if (userName) {
+    const userPath = getWorkspacePromptPath("USER.md");
+    if (!existsSync(userPath)) {
+      try {
+        writeFileSync(userPath, `# User\n\n- Name: ${userName}\n`, "utf-8");
+      } catch (err) {
+        log.warn({ err, userPath }, "Failed to seed USER.md from onboarding");
+      }
+    }
+  }
+
+  void writeRelationshipState().catch((err) => {
+    log.warn(
+      { err },
+      "Failed to kick off relationship-state write after onboarding",
+    );
+  });
+}
+
 export async function handleSendMessage(
   req: Request,
   deps: {
@@ -1120,6 +1302,13 @@ export async function handleSendMessage(
     bypassSecretCheck?: boolean;
     hostHomeDir?: string;
     hostUsername?: string;
+    onboarding?: {
+      tools: string[];
+      tasks: string[];
+      tone: string;
+      userName?: string;
+      assistantName?: string;
+    };
   };
 
   const { conversationKey, content, attachmentIds } = body;
@@ -1222,8 +1411,24 @@ export async function handleSendMessage(
   const mapping = getOrCreateConversation(resolvedConversationKey, {
     conversationType,
   });
+
   const smDeps = deps.sendMessageDeps;
 
+  // Notify all connected clients that the conversation list changed when a
+  // new standard conversation is created so sidebars can refresh.
+  if (mapping.created && mapping.conversationType === "standard") {
+    smDeps.assistantEventHub
+      .publish(
+        buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, {
+          type: "conversation_list_invalidated",
+          reason: "created",
+        }),
+      )
+      .catch((err) => {
+        log.warn({ err }, "Failed to publish conversation_list_invalidated");
+      });
+  }
+
   // Build transport metadata from the request so the daemon can inject
   // host environment hints (home directory, username) into the LLM context.
   // The `supportsHostProxy` type predicate narrows `sourceInterface` to
@@ -1247,6 +1452,17 @@ export async function handleSendMessage(
     { transport },
   );
 
+  // Store pre-chat onboarding context on the conversation when this is the
+  // very first message (no prior messages loaded). Also persist the
+  // onboarding selections so the Home page shows onboarding-sourced
+  // chips immediately, and seed IDENTITY.md / USER.md so subsequent
+  // turn-boundary recomputes of relationship-state have a stable
+  // persona source beyond the in-memory conversation object.
+  if (body.onboarding && conversation.messages.length === 0) {
+    conversation.setOnboardingContext(body.onboarding);
+    persistOnboardingArtifacts(body.onboarding);
+  }
+
   // Resolve guardian context from the AuthContext's actorPrincipalId.
   // The JWT-verified principal is used as the sender identity through
   // the same trust resolution pipeline that channel ingress uses.
@@ -1328,66 +1544,44 @@ export async function handleSendMessage(
   } else if (!conversation.isProcessing()) {
     conversation.setHostBashProxy(undefined);
   }
-  // For the chrome-extension interface we route host_browser_request /
-  // host_browser_cancel frames through the in-process ChromeExtensionRegistry
-  // to the WebSocket opened against /v1/browser-relay by the connected
-  // extension, instead of the SSE/onEvent hub used by macOS. The registry
-  // lookup is keyed by the JWT-derived actor principal id, which the
-  // runtime captured at WebSocket upgrade time.
-  //
-  // A single guardian may have multiple parallel extension installs
-  // connected at once (two Chrome profiles, two desktops). The registry
-  // tracks them under (guardianId, clientInstanceId) pairs and the
-  // default `send(guardianId, msg)` path routes to whichever instance
-  // has the most recent activity — typically the one the user is
-  // currently driving. Pinning to a specific instance can be done via
-  // `sendToInstance` if a caller ever needs it.
-  //
-  // macOS (and any other interface that supports host_browser in the
-  // future via the SSE hub) keeps using `onEvent` — see the else branch.
-  const browserProxySendToClient: (msg: ServerMessage) => void =
-    sourceInterface === "chrome-extension"
-      ? (msg) => {
-          // Resolve the guardian principal id at send time rather than
-          // capturing it from the POST-time authContext. This closure can be
-          // re-fired on queue drain — if a different actor's POST lands while
-          // the queue is still draining an earlier turn, a captured
-          // authContext.actorPrincipalId would mis-route the earlier turn's
-          // host_browser frames to the *new* actor. Preferring
-          // conversation.trustContext?.guardianPrincipalId makes the routing
-          // follow the conversation's bound guardian, which is stable across
-          // subsequent POSTs. Falls back to the per-POST authContext for
-          // turns that haven't been bound to a trust context yet.
-          const gid =
-            conversation.trustContext?.guardianPrincipalId ??
-            authContext.actorPrincipalId;
-          if (!gid) {
-            // No guardian identity on this turn — nothing to route to.
-            // The proxy will observe this via its try/catch and surface a
-            // transport error back to the caller.
-            throw new Error(
-              "chrome-extension host_browser send skipped: no guardianId on AuthContext",
-            );
-          }
-          const ok = getChromeExtensionRegistry().send(gid, msg);
-          if (!ok) {
-            throw new Error(
-              `chrome-extension host_browser send failed: no active connection for guardian ${gid}`,
-            );
-          }
-        }
-      : onEvent;
+  // Resolve the host_browser sender — registry-routed when the guardian has
+  // an active extension connection, SSE hub otherwise. This applies to both
+  // chrome-extension and macOS interfaces so that macOS turns can route
+  // browser automation through the user's real Chrome session when available.
+  const { sender: browserProxySendToClient, isRegistryRouted } =
+    resolveHostBrowserSender(
+      conversation,
+      mapping.conversationId,
+      authContext,
+      onEvent,
+      sourceInterface,
+    );
+
   // Stash the registry-routed sender on the conversation so queue-drain
   // restores (which run outside of conversation-routes.ts and only have
   // access to `sendToClient`) can preserve it when calling
-  // `restoreBrowserProxyAvailability()`. For non-chrome-extension
-  // interfaces the override is cleared so the SSE hub sender is used.
-  if (sourceInterface === "chrome-extension") {
+  // `restoreBrowserProxyAvailability()`. The override is set when the
+  // sender is registry-routed (regardless of interface) and cleared when
+  // the SSE hub sender is used, so the drain path always restores the
+  // correct transport.
+  if (isRegistryRouted) {
     conversation.hostBrowserSenderOverride = browserProxySendToClient;
   } else {
     conversation.hostBrowserSenderOverride = undefined;
   }
-  if (supportsHostProxy(sourceInterface, "host_browser")) {
+
+  // Provision the host browser proxy. For interfaces that natively support
+  // host_browser (chrome-extension), always provision it. For macOS, the
+  // static capability check returns false (supportsHostProxy("macos",
+  // "host_browser") === false) because the extension isn't guaranteed to be
+  // attached — but when the registry confirms an active extension
+  // connection, we provision the proxy anyway so macOS turns can drive the
+  // user's real Chrome session. When no extension is connected, macOS skips
+  // provisioning and browser tools fall through to cdp-inspect/local.
+  const shouldProvisionBrowserProxy =
+    supportsHostProxy(sourceInterface, "host_browser") ||
+    (canServiceRegistryBrowser(sourceInterface) && isRegistryRouted);
+  if (shouldProvisionBrowserProxy) {
     if (!conversation.isProcessing() || !conversation.hostBrowserProxy) {
       const browserProxy = new HostBrowserProxy(
         browserProxySendToClient,
@@ -1445,18 +1639,17 @@ export async function handleSendMessage(
   conversation.updateClient(onEvent, !isInteractive, {
     skipProxySenderUpdate: preservingProxies,
   });
-  // For non-interactive interfaces that DO support host_browser
-  // (chrome-extension), explicitly re-enable just the browser proxy. The
-  // helper bypasses the `hasNoClient` gate so the single-capability
-  // chrome-extension turn can drive the browser via CDP without leaking
-  // host_bash/host_file tool availability into tool gating.
+  // Re-enable the browser proxy for turns that provisioned one. This covers:
+  // - chrome-extension: natively supports host_browser (non-interactive but
+  //   has a connected client for host_browser_request events)
+  // - macOS with extension: provisioned above when isRegistryRouted is true
   //
-  // `restoreBrowserProxyAvailability()` reads `hostBrowserSenderOverride`
-  // (set above for chrome-extension) and applies the registry-routed
-  // sender, so the chrome-extension path gets the correct sender here
-  // — including after queue-drain restores run from conversation-process.ts,
-  // which only have access to the conversation instance.
-  if (supportsHostProxy(sourceInterface, "host_browser")) {
+  // The helper bypasses the `hasNoClient` gate so chrome-extension turns can
+  // drive the browser via CDP without leaking host_bash/host_file tool
+  // availability. It reads `hostBrowserSenderOverride` (set above when
+  // registry-routed) and applies the correct sender — including after
+  // queue-drain restores run from conversation-process.ts.
+  if (shouldProvisionBrowserProxy) {
     conversation.restoreBrowserProxyAvailability?.();
   }
 
@@ -1522,6 +1715,12 @@ export async function handleSendMessage(
         // fast path) so the HTTP response reaches the client before SSE
         // events arrive.
         setTimeout(() => {
+          onEvent({
+            type: "user_message_echo",
+            text: rawContent,
+            conversationId,
+            messageId: persisted.id,
+          });
           onEvent({ type: "assistant_text_delta", text: cannedGreeting });
           onEvent({ type: "message_complete", conversationId });
           conversation.processing = false;
@@ -1815,6 +2014,12 @@ export async function handleSendMessage(
       const conversationId = mapping.conversationId;
       const message = slashResult.message;
       setTimeout(() => {
+        onEvent({
+          type: "user_message_echo",
+          text: rawContent,
+          conversationId,
+          messageId: persisted.id,
+        });
         if (modelInfoEvent) {
           onEvent(modelInfoEvent);
         }
@@ -1841,80 +2046,88 @@ export async function handleSendMessage(
 
   if (slashResult.kind === "compact") {
     conversation.processing = true;
-    let cleanupDeferred = false;
-    try {
-      const provenance = provenanceFromTrustContext(conversation.trustContext);
-      const channelMeta = {
-        ...provenance,
-        userMessageChannel: sourceChannel,
-        assistantMessageChannel: sourceChannel,
-        userMessageInterface: sourceInterface,
-        assistantMessageInterface: sourceInterface,
-      };
-      const cleanMsg = createUserMessage(rawContent, attachments);
-      const persisted = await addMessage(
-        mapping.conversationId,
-        "user",
-        JSON.stringify(cleanMsg.content),
-        channelMeta,
-      );
-      conversation.getMessages().push(cleanMsg);
+    const provenance = provenanceFromTrustContext(conversation.trustContext);
+    const channelMeta = {
+      ...provenance,
+      userMessageChannel: sourceChannel,
+      assistantMessageChannel: sourceChannel,
+      userMessageInterface: sourceInterface,
+      assistantMessageInterface: sourceInterface,
+    };
+    const cleanMsg = createUserMessage(rawContent, attachments);
+    const persisted = await addMessage(
+      mapping.conversationId,
+      "user",
+      JSON.stringify(cleanMsg.content),
+      channelMeta,
+    );
+    conversation.getMessages().push(cleanMsg);
 
-      conversation.emitActivityState(
-        "thinking",
-        "context_compacting",
-        "assistant_turn",
-      );
-      const result = await conversation.forceCompact();
-      const responseText = formatCompactResult(result);
+    const conversationId = mapping.conversationId;
 
-      const assistantMsg = createAssistantMessage(responseText);
-      await addMessage(
-        mapping.conversationId,
-        "assistant",
-        JSON.stringify(assistantMsg.content),
-        channelMeta,
-      );
-      conversation.getMessages().push(assistantMsg);
-
-      const response = Response.json(
-        {
-          accepted: true,
+    // Fire-and-forget: return 202 immediately, run compaction async.
+    // forceCompact() makes an LLM call that can exceed the client's
+    // HTTP timeout on large contexts, causing a false "Failed to send".
+    (async () => {
+      try {
+        onEvent({
+          type: "user_message_echo",
+          text: rawContent,
+          conversationId,
           messageId: persisted.id,
-          conversationId: mapping.conversationId,
-        },
-        { status: 202 },
-      );
+        });
+        conversation.emitActivityState(
+          "thinking",
+          "context_compacting",
+          "assistant_turn",
+        );
+        const result = await conversation.forceCompact();
+        const responseText = formatCompactResult(result);
+
+        const assistantMsg = createAssistantMessage(responseText);
+        await addMessage(
+          conversationId,
+          "assistant",
+          JSON.stringify(assistantMsg.content),
+          channelMeta,
+        );
+        conversation.getMessages().push(assistantMsg);
 
-      const conversationId = mapping.conversationId;
-      setTimeout(() => {
         onEvent({ type: "assistant_text_delta", text: responseText });
+        onEvent({ type: "message_complete", conversationId });
+      } catch (err) {
+        log.error({ err, conversationId }, "Compact command failed");
         onEvent({
-          type: "message_complete",
+          type: "conversation_error",
           conversationId,
+          code: "UNKNOWN",
+          userMessage: `Compaction failed: ${err instanceof Error ? err.message : String(err)}`,
+          retryable: true,
         });
+      } finally {
         conversation.processing = false;
         silentlyWithLog(
           conversation.drainQueue(),
           "compact-command queue drain",
         );
-      }, 0);
-
-      cleanupDeferred = true;
-      return response;
-    } finally {
-      if (!cleanupDeferred && conversation.processing) {
-        conversation.processing = false;
-        silentlyWithLog(conversation.drainQueue(), "error-path queue drain");
       }
-    }
+    })();
+
+    return Response.json(
+      {
+        accepted: true,
+        messageId: persisted.id,
+        conversationId,
+      },
+      { status: 202 },
+    );
   }
 
   const resolvedContent = slashResult.content;
 
+  const requestId = crypto.randomUUID();
   let messageId: string;
   try {
-    const requestId = crypto.randomUUID();
     messageId = await conversation.persistUserMessage(
       resolvedContent,
       attachments,
@@ -1925,6 +2138,14 @@ export async function handleSendMessage(
     throw err;
   }
 
+  onEvent({
+    type: "user_message_echo",
+    text: resolvedContent,
+    conversationId: mapping.conversationId,
+    messageId,
+    requestId,
+  });
+
   // Fire-and-forget the agent loop; events flow to the hub via onEvent.
   conversation
     .runAgentLoop(resolvedContent, messageId, onEvent, {