@vellumai/assistant 0.8.5 → 0.8.6

package/src/daemon/conversation-process.ts

@@ -34,6 +34,7 @@ import { routeGuardianReply } from "../runtime/guardian-reply-router.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
 import type { CleanResult } from "./conversation.js";
+import type { PersistMessageOptions } from "./conversation-messaging.js";
 import {
   persistQueuedMessageBody,
   serializePersistedUserMessageContent,
@@ -158,12 +159,8 @@ export interface ProcessConversationContext {
   currentTurnChannelCapabilities?: ChannelCapabilities;
   ensureActorScopedHistory(): Promise<void>;
   persistUserMessage(
-    content: string,
-    attachments: UserMessageAttachment[],
-    requestId?: string,
-    metadata?: Record<string, unknown>,
-    displayContent?: string,
-  ): Promise<string>;
+    options: PersistMessageOptions,
+  ): Promise<{ id: string; deduplicated: boolean }>;
   runAgentLoop(
     content: string,
     userMessageId: string,
@@ -921,15 +918,16 @@ async function drainSingleMessage(
   // succeeds, runAgentLoop is called and its finally block will drain
   // the next message. If persistUserMessage fails, processMessage
   // resolves early (no runAgentLoop call), so we must continue draining.
-  let userMessageId: string;
+  let persistResult: { id: string; deduplicated: boolean };
   try {
-    userMessageId = await conversation.persistUserMessage(
-      resolvedContent,
-      next.attachments,
-      next.requestId,
-      { ...next.metadata, sentAt: next.sentAt },
-      next.displayContent,
-    );
+    persistResult = await conversation.persistUserMessage({
+      content: resolvedContent,
+      attachments: next.attachments,
+      requestId: next.requestId,
+      metadata: { ...next.metadata, sentAt: next.sentAt },
+      displayContent: next.displayContent,
+      clientMessageId: next.clientMessageId,
+    });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     log.error(
@@ -961,6 +959,18 @@ async function drainSingleMessage(
     return;
   }
 
+  const userMessageId = persistResult.id;
+
+  if (persistResult.deduplicated) {
+    log.info(
+      { conversationId: conversation.conversationId, userMessageId },
+      "Skipping agent loop for deduplicated queued message",
+    );
+    conversation.preactivatedSkillIds = undefined;
+    await drainQueue(conversation);
+    return;
+  }
+
   // Broadcast the user message to all hub subscribers so passive devices
   // see the user turn before the assistant reply starts streaming.
   next.onEvent({
@@ -1217,24 +1227,43 @@ async function drainBatch(
     const qmContent = qmSlash.content;
 
     try {
+      let batchPersistResult: { id: string; deduplicated: boolean };
+      const persistOptions = {
+        content: qmContent,
+        attachments: qm.attachments,
+        requestId: qm.requestId,
+        metadata: { ...qm.metadata, sentAt: qm.sentAt },
+        displayContent: qm.displayContent,
+        clientMessageId: qm.clientMessageId,
+      };
       if (i === 0) {
-        lastUserMessageId = await conversation.persistUserMessage(
-          qmContent,
-          qm.attachments,
-          qm.requestId,
-          { ...qm.metadata, sentAt: qm.sentAt },
-          qm.displayContent,
-        );
+        batchPersistResult =
+          await conversation.persistUserMessage(persistOptions);
       } else {
-        lastUserMessageId = await persistQueuedMessageBody(
+        batchPersistResult = await persistQueuedMessageBody(
           conversation,
-          qmContent,
-          qm.attachments,
-          qm.requestId,
-          { ...qm.metadata, sentAt: qm.sentAt },
-          qm.displayContent,
+          persistOptions,
         );
       }
+      if (batchPersistResult.deduplicated) {
+        if (i === 0) {
+          // Head was deduplicated — persistUserMessage cleared the
+          // processing flag. Recursively drain remaining items so the
+          // first non-duplicate becomes the new batch head and sets
+          // processing via persistUserMessage.
+          const remaining = batch.slice(1);
+          if (remaining.length >= 2) {
+            await drainBatch(conversation, remaining, reason);
+          } else if (remaining.length === 1) {
+            await drainSingleMessage(conversation, remaining[0], reason);
+          } else {
+            await drainQueue(conversation);
+          }
+          return;
+        }
+        continue;
+      }
+      lastUserMessageId = batchPersistResult.id;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       log.error(
@@ -1377,12 +1406,19 @@ async function drainBatch(
   conversation.currentActiveSurfaceId = lastSuccessfulActiveSurfaceId;
   conversation.currentPage = lastSuccessfulCurrentPage;
 
-  // Broadcast agent-loop events only to members whose persist succeeded.
-  // Members whose persist failed already received an error event in the
-  // catch block above; sending them the assistant's streaming response
-  // would surface a reply for a user message that isn't in their DB.
+  // Broadcast agent-loop events only to unique sinks whose persist succeeded.
+  // Multiple web-queued messages share the same broadcastMessage callback; if
+  // we call it once per queued message, every text delta is published N times
+  // to the same SSE stream and the client renders duplicated text.
+  //
+  // Members whose persist failed already received an error event in the catch
+  // block above; sending them the assistant's streaming response would surface
+  // a reply for a user message that isn't in their DB.
+  const successfulEventSinks = Array.from(
+    new Set(successfulBatch.map((qm) => qm.onEvent)),
+  );
   const fanOutOnEvent = (msg: ServerMessage) => {
-    for (const qm of successfulBatch) qm.onEvent(msg);
+    for (const onEvent of successfulEventSinks) onEvent(msg);
   };
 
   const drainLoopOptions: {
@@ -1857,15 +1893,14 @@ export async function processMessage(
     }
   }
 
-  let userMessageId: string;
+  let pmResult: { id: string; deduplicated: boolean };
   try {
-    userMessageId = await conversation.persistUserMessage(
-      resolvedContent,
+    pmResult = await conversation.persistUserMessage({
+      content: resolvedContent,
       attachments,
       requestId,
-      undefined,
       displayContent,
-    );
+    });
     publishConversationMessagesChanged(conversation.conversationId);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1879,6 +1914,8 @@ export async function processMessage(
     return "";
   }
 
+  const userMessageId = pmResult.id;
+
   // Fire-and-forget: detect notification preferences in the user message
   // and persist any that are found. Runs in the background so it doesn't
   // block the main conversation flow.

package/src/daemon/conversation-runtime-assembly.ts

@@ -997,23 +997,38 @@ export function buildUnifiedTurnContextBlock(
 // ---------------------------------------------------------------------------
 
 /**
- * Remove text blocks from user messages whose text starts with any of the
- * given prefixes.  If stripping removes all content blocks from a message,
- * the message itself is dropped.
+ * A matcher for an injected text block. A plain string matches by prefix
+ * (`startsWith`). A `{ prefix, suffix }` wrapper requires BOTH the opening
+ * prefix and the closing suffix, so user-authored content that merely begins
+ * with an injection-like opening tag (e.g. a message discussing `<info>`
+ * markup) is not mistaken for an injected block and dropped. This mirrors
+ * `countMemoryPrefixBlocks`, which only treats `<memory>…</memory>` /
+ * `<info>…</info>` blocks as injected when the full wrapper is present.
+ */
+type InjectionMatcher = string | { prefix: string; suffix: string };
+
+/**
+ * Remove text blocks from user messages that match any of the given matchers.
+ * If stripping removes all content blocks from a message, the message itself
+ * is dropped.
  *
  * This is the shared primitive behind the individual strip* functions and
  * the `stripInjectionsForCompaction` pipeline.
  */
 function stripUserTextBlocksByPrefix(
   messages: Message[],
-  prefixes: string[],
+  matchers: InjectionMatcher[],
 ): Message[] {
   return messages
     .map((message) => {
       if (message.role !== "user") return message;
       const nextContent = message.content.filter((block) => {
         if (block.type !== "text") return true;
-        return !prefixes.some((p) => block.text.startsWith(p));
+        return !matchers.some((m) =>
+          typeof m === "string"
+            ? block.text.startsWith(m)
+            : block.text.startsWith(m.prefix) && block.text.endsWith(m.suffix),
+        );
       });
       if (nextContent.length === message.content.length) return message;
       if (nextContent.length === 0) return null;
@@ -1720,8 +1735,8 @@ export function loadSlackActiveThreadFocusBlock(
   return assembleSlackActiveThreadFocusBlock(rows, capabilities);
 }
 
-/** Prefixes stripped by the pipeline (order doesn't matter — single pass). */
-const RUNTIME_INJECTION_PREFIXES = [
+/** Matchers stripped by the pipeline (order doesn't matter — single pass). */
+const RUNTIME_INJECTION_PREFIXES: InjectionMatcher[] = [
   "<channel_capabilities>",
   "<channel_command_context>",
   "<disk_pressure_warning>",
@@ -1742,8 +1757,13 @@ const RUNTIME_INJECTION_PREFIXES = [
   // cadence. The activation pipeline dedupes via `everInjected`, and
   // compaction handles aggregate growth, so accumulation does not cause
   // unbounded context growth. Both wrappers may appear in persisted rows.
-  "<memory>\n",
-  "<info>\n",
+  //
+  // These two use the full `{ prefix, suffix }` wrapper shape (not a bare
+  // prefix) so that user-authored text merely starting with `<memory>\n` or
+  // `<info>\n` is never silently dropped during compaction/`/clean`. This
+  // matches the full-wrapper requirement in `countMemoryPrefixBlocks`.
+  { prefix: "<memory>\n", suffix: "\n</memory>" },
+  { prefix: "<info>\n", suffix: "\n</info>" },
   "<voice_call_control>",
   "<workspace_top_level>", // backward-compat: strip legacy workspace blocks
   // NOTE: <workspace> is intentionally NOT stripped — workspace context

package/src/daemon/conversation-skill-tools.ts

@@ -23,6 +23,7 @@ import { parseToolManifestFile } from "../skills/tool-manifest.js";
 import { computeSkillVersionHash } from "../skills/version-hash.js";
 import {
   getTool,
+  getToolOwner,
   registerSkillTools,
   unregisterSkillTools,
 } from "../tools/registry.js";
@@ -313,7 +314,6 @@ export function projectSkillTools(
     // Create runtime Tool objects
     const tools = createSkillToolsFromManifest(
       manifest.tools,
-      skillId,
       skill.directoryPath,
       currentHash,
       skill.bundled,
@@ -324,7 +324,7 @@ export function projectSkillTools(
       const prevHash = prevActive.get(skillId);
       if (prevHash === undefined) {
         // Newly active skill — register for the first time
-        accepted = registerSkillTools(tools);
+        accepted = registerSkillTools(skillId, tools);
       } else if (prevHash !== currentHash) {
         // Hash changed — unregister stale tools, then re-register with new definitions
         log.info(
@@ -334,7 +334,7 @@ export function projectSkillTools(
         unregisterSkillTools(skillId);
         alreadyUnregistered.add(skillId);
         try {
-          accepted = registerSkillTools(tools);
+          accepted = registerSkillTools(skillId, tools);
         } catch (err) {
           log.error(
             { err, skillId },
@@ -344,33 +344,17 @@ export function projectSkillTools(
           continue;
         }
       } else {
-        // Hash unchanged — check if the bundled status drifted (e.g. a
-        // managed skill override was added/removed with identical content).
-        // Re-register so the ownerSkillBundled flag stays accurate.
-        const existing = getTool(tools[0].name);
-        if (
-          existing &&
-          existing.ownerSkillBundled !== (skill.bundled ?? undefined)
-        ) {
-          log.info(
-            { skillId, bundled: skill.bundled },
-            "Skill bundled status changed, re-registering tools",
-          );
-          unregisterSkillTools(skillId);
-          accepted = registerSkillTools(tools);
-        } else {
-          // Filter to only tools that are actually registered for this skill.
-          // Some tools may have been skipped during initial registration due
-          // to core-name collisions — don't let them leak back in.
-          accepted = tools.filter((t) => {
-            const reg = getTool(t.name);
-            return (
-              reg !== undefined &&
-              reg.origin === "skill" &&
-              reg.ownerSkillId === skillId
-            );
-          });
-        }
+        // Hash unchanged — filter to only tools that are actually registered
+        // for this skill. Some tools may have been skipped during initial
+        // registration due to core-name collisions — don't let them leak
+        // back in. Bundled-status drift no longer requires re-registration
+        // because the permission checker derives bundled state from the
+        // live catalog instead of a stamped tool field.
+        accepted = tools.filter((t) => {
+          if (getTool(t.name) === undefined) return false;
+          const owner = getToolOwner(t.name);
+          return owner?.kind === "skill" && owner.id === skillId;
+        });
       }
 
       successfulEntries.set(skillId, currentHash);

package/src/daemon/conversation-surfaces.ts

@@ -28,6 +28,7 @@ import { getLogger } from "../util/logger.js";
 import { isPlainObject } from "../util/object.js";
 import { buildConversationErrorMessage } from "./conversation-error.js";
 import { launchConversation } from "./conversation-launch.js";
+import type { EnqueueMessageOptions } from "./conversation-messaging.js";
 import type { HostAppControlProxy } from "./host-app-control-proxy.js";
 import type { HostCuProxy } from "./host-cu-proxy.js";
 import type {
@@ -45,7 +46,6 @@ import type {
   UiSurfaceShow,
 } from "./message-protocol.js";
 import { INTERACTIVE_SURFACE_TYPES } from "./message-protocol.js";
-import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 import type { HostAppControlInput } from "./message-types/host-app-control.js";
 import type { UserMessageAttachment } from "./message-types/shared.js";
 import type { TrustContext } from "./trust-context.js";
@@ -518,18 +518,11 @@ export interface SurfaceConversationContext {
   /** True when no interactive client is connected (headless / channel-only). */
   readonly hasNoClient?: boolean;
   isProcessing(): boolean;
-  enqueueMessage(
-    content: string,
-    attachments: UserMessageAttachment[],
-    onEvent?: (msg: ServerMessage) => void,
-    requestId?: string,
-    activeSurfaceId?: string,
-    currentPage?: string,
-    metadata?: Record<string, unknown>,
-    options?: { isInteractive?: boolean },
-    displayContent?: string,
-    transport?: ConversationTransportMetadata,
-  ): { queued: boolean; requestId: string; rejected?: boolean };
+  enqueueMessage(options: EnqueueMessageOptions): {
+    queued: boolean;
+    requestId: string;
+    rejected?: boolean;
+  };
   getQueueDepth(): number;
   processMessage(
     content: string,
@@ -1142,6 +1135,34 @@ export type SurfaceActionResult =
   | { accepted: false; error: string }
   | void;
 
+const SURFACE_COMPLETE_FLAG = "_completeSurface";
+const SURFACE_COMPLETION_SUMMARY_FIELD = "_completionSummary";
+
+function getRequestedSurfaceCompletionSummary(
+  data?: Record<string, unknown>,
+): string | null {
+  if (data?.[SURFACE_COMPLETE_FLAG] !== true) return null;
+  const summary =
+    typeof data[SURFACE_COMPLETION_SUMMARY_FIELD] === "string"
+      ? data[SURFACE_COMPLETION_SUMMARY_FIELD].trim()
+      : "";
+  return summary || "Completed";
+}
+
+function completeSurfaceFromAction(
+  ctx: SurfaceConversationContext,
+  surfaceId: string,
+  summary: string,
+): void {
+  broadcastMessage({
+    type: "ui_surface_complete",
+    conversationId: ctx.conversationId,
+    surfaceId,
+    summary,
+  });
+  markSurfaceCompleted(ctx, surfaceId, summary);
+}
+
 export async function handleSurfaceAction(
   ctx: SurfaceConversationContext,
   surfaceId: string,
@@ -1318,9 +1339,16 @@ export async function handleSurfaceAction(
     }
 
     // Determine message content from the action.
+    const stored = ctx.surfaceState.get(surfaceId);
+    const actionDef = stored?.actions?.find((a) => a.id === actionId);
+    const mergedData: Record<string, unknown> | undefined =
+      actionDef?.data || data ? { ...actionDef?.data, ...data } : undefined;
+
     const isRelay = actionId === "relay_prompt" || actionId === "agent_prompt";
     const prompt =
-      isRelay && typeof data?.prompt === "string" ? data.prompt.trim() : "";
+      isRelay && typeof mergedData?.prompt === "string"
+        ? mergedData.prompt.trim()
+        : "";
 
     // Read accumulated state once — used by both relay and custom action paths.
     const accState = ctx.accumulatedSurfaceState.get(surfaceId);
@@ -1329,9 +1357,9 @@ export async function handleSurfaceAction(
     // Extract file attachments from action data so they are sent as proper
     // image/file content blocks instead of dumping base64 into the text.
     let attachments: UserMessageAttachment[] = [];
-    let actionDataForText = data;
-    if (data && Array.isArray(data.files)) {
-      const files = data.files as Array<Record<string, unknown>>;
+    let actionDataForText = mergedData;
+    if (mergedData && Array.isArray(mergedData.files)) {
+      const files = mergedData.files as Array<Record<string, unknown>>;
       attachments = files
         .filter(
           (f) =>
@@ -1351,7 +1379,7 @@ export async function handleSurfaceAction(
       // attachments — otherwise preserve the original data so the model still
       // sees the files field (e.g. IDs/paths from dynamic app actions).
       if (attachments.length > 0) {
-        const { files: _files, ...rest } = data;
+        const { files: _files, ...rest } = mergedData;
         actionDataForText = Object.keys(rest).length > 0 ? rest : undefined;
       }
     }
@@ -1414,23 +1442,26 @@ export async function handleSurfaceAction(
       attributes: { source: "surface_action", surfaceId, actionId },
     });
 
-    const result = ctx.enqueueMessage(
+    const result = ctx.enqueueMessage({
       content,
       attachments,
       onEvent,
       requestId,
-      surfaceId,
-      undefined,
-      undefined,
-      undefined,
+      activeSurfaceId: surfaceId,
       displayContent,
-    );
+    });
 
     if (result.rejected) {
       ctx.surfaceActionRequestIds.delete(requestId);
       return;
     }
 
+    const requestedCompletionSummary =
+      getRequestedSurfaceCompletionSummary(mergedData);
+    if (requestedCompletionSummary) {
+      completeSurfaceFromAction(ctx, surfaceId, requestedCompletionSummary);
+    }
+
     // One-shot: clear accumulated state now that the message has been accepted.
     // Deferred until after rejection check so state is preserved for retry on rejection.
     if (hasAccState) {
@@ -1653,22 +1684,22 @@ export async function handleSurfaceAction(
     "Surface action follow-up: preparing to send message to model",
   );
 
-  const result = ctx.enqueueMessage(
+  const result = ctx.enqueueMessage({
     content,
-    pendingAttachments,
+    attachments: pendingAttachments,
     onEvent,
     requestId,
-    surfaceId,
-    undefined,
-    undefined,
-    undefined,
+    activeSurfaceId: surfaceId,
     displayContent,
-  );
+  });
   if (result.rejected) {
     ctx.surfaceActionRequestIds.delete(requestId);
     return;
   }
 
+  const requestedCompletionSummary =
+    getRequestedSurfaceCompletionSummary(mergedData);
+
   // One-shot interactive surfaces — auto-complete now that the message has
   // been accepted. Deferred until after rejection check so the surface stays
   // active and retryable if the queue was full.
@@ -1678,15 +1709,19 @@ export async function handleSurfaceAction(
     "file_upload",
     "task_preferences",
   ];
-  if (ONE_SHOT_SURFACE_TYPES.includes(pending.surfaceType)) {
+  if (
+    requestedCompletionSummary ||
+    ONE_SHOT_SURFACE_TYPES.includes(pending.surfaceType)
+  ) {
+    const completionSummary = requestedCompletionSummary ?? summary;
     broadcastMessage({
       type: "ui_surface_complete",
       conversationId: ctx.conversationId,
       surfaceId,
-      summary,
+      summary: completionSummary,
       submittedData: mergedDataForText,
     });
-    markSurfaceCompleted(ctx, surfaceId, summary);
+    markSurfaceCompleted(ctx, surfaceId, completionSummary);
   }
 
   // One-shot: clear accumulated state now that the message has been accepted.