@vellumai/assistant 0.8.6 → 0.8.7

package/src/daemon/conversation-error.ts

@@ -1,11 +1,11 @@
+import type {
+  ConversationErrorCode,
+  ConversationErrorEvent,
+} from "../api/events/conversation-error.js";
 import { ConnectionResolutionError } from "../providers/connection-resolution.js";
 import { getProviderRoutingSource } from "../providers/registry.js";
 import { isAbortReason } from "../util/abort-reasons.js";
 import { ProviderError, ProviderNotConfiguredError } from "../util/errors.js";
-import type {
-  ConversationErrorCode,
-  ConversationErrorMessage,
-} from "./message-protocol.js";
 
 /**
  * Classified conversation error ready for client emission.
@@ -19,7 +19,7 @@ export interface ClassifiedConversationError {
   errorCategory: string;
   /**
    * Name of the `provider_connections` row in play when the error
-   * occurred. Forwarded to the wire `ConversationErrorMessage` so chat
+   * occurred. Forwarded to the wire `ConversationErrorEvent` so chat
    * banners can point users at the specific slot to fix. Only set by
    * classifiers / callers that have the resolved connection in scope —
    * generic regex fallbacks leave it undefined.
@@ -37,7 +37,7 @@ export interface ClassifiedConversationError {
 
 /**
  * Optional resolved-config context that callers can attach to error
- * classification so the resulting `ConversationErrorMessage` can name the
+ * classification so the resulting `ConversationErrorEvent` can name the
  * exact connection / profile in play. Used in particular by the chat
  * dispatch sites to make `PROVIDER_INVALID_KEY` and `PROVIDER_NOT_CONFIGURED`
  * actionable (the macOS banner reads these to render "Invalid API key for
@@ -826,7 +826,7 @@ export function maxTokensReachedClassification(): ClassifiedConversationError {
 export function buildConversationErrorMessage(
   conversationId: string,
   classified: ClassifiedConversationError,
-): ConversationErrorMessage {
+): ConversationErrorEvent {
   return {
     type: "conversation_error",
     conversationId,

package/src/daemon/conversation-history.ts

@@ -358,8 +358,8 @@ export interface HistoryConversationContext {
   runAgentLoop(
     content: string,
     userMessageId: string,
-    onEvent?: (msg: ServerMessage) => void,
     options?: {
+      onEvent?: (msg: ServerMessage) => void;
       isUserMessage?: boolean;
       titleText?: string;
     },
@@ -418,7 +418,11 @@ export async function regenerate(
   requestId?: string,
 ): Promise<void> {
   if (conversation.processing) {
-    conversation.sendToClient({ type: "error", conversationId: conversation.conversationId, message: "Cannot regenerate while processing" });
+    conversation.sendToClient({
+      type: "error",
+      conversationId: conversation.conversationId,
+      message: "Cannot regenerate while processing",
+    });
     if (requestId) {
       conversation.traceEmitter.emit(
         "request_error",
@@ -437,7 +441,11 @@ export async function regenerate(
   // assistant's exchange that we want to regenerate.
   const lastUserIdx = findLastUndoableUserMessageIndex(conversation.messages);
   if (lastUserIdx === -1) {
-    conversation.sendToClient({ type: "error", conversationId: conversation.conversationId, message: "No messages to regenerate" });
+    conversation.sendToClient({
+      type: "error",
+      conversationId: conversation.conversationId,
+      message: "No messages to regenerate",
+    });
     if (requestId) {
       conversation.traceEmitter.emit(
         "request_error",
@@ -454,7 +462,11 @@ export async function regenerate(
 
   // There must be at least one message after the user message (the assistant reply).
   if (lastUserIdx >= conversation.messages.length - 1) {
-    conversation.sendToClient({ type: "error", conversationId: conversation.conversationId, message: "No assistant response to regenerate" });
+    conversation.sendToClient({
+      type: "error",
+      conversationId: conversation.conversationId,
+      message: "No assistant response to regenerate",
+    });
     if (requestId) {
       conversation.traceEmitter.emit(
         "request_error",
@@ -497,7 +509,11 @@ export async function regenerate(
   }
 
   if (dbUserMsgIdx === -1) {
-    conversation.sendToClient({ type: "error", conversationId: conversation.conversationId, message: "No user message found in DB" });
+    conversation.sendToClient({
+      type: "error",
+      conversationId: conversation.conversationId,
+      message: "No user message found in DB",
+    });
     if (requestId) {
       conversation.traceEmitter.emit(
         "request_error",
@@ -572,7 +588,7 @@ export async function regenerate(
   // not await the agent loop. Emit a structured trace event so the
   // observability contract is preserved on those paths too.
   void conversation
-    .runAgentLoop(content, existingUserMessageId, undefined, {
+    .runAgentLoop(content, existingUserMessageId, {
       isUserMessage: true,
     })
     .catch((err) => {

package/src/daemon/conversation-launch.ts

@@ -87,14 +87,10 @@ export async function launchConversation(
     ),
   );
 
-  processMessageInBackground(
-    conversationId,
-    params.seedPrompt,
-    undefined,
-    undefined,
-    "vellum",
-    "cli",
-  ).catch((err) => {
+  processMessageInBackground(conversationId, params.seedPrompt, {
+    sourceChannel: "vellum",
+    sourceInterface: "cli",
+  }).catch((err) => {
     log.error(
       { err, conversationId },
       "Seed turn failed for launched conversation (non-fatal)",

package/src/daemon/conversation-lifecycle.ts

@@ -11,16 +11,13 @@ import type { AssistantDomainEvents } from "../events/domain-events.js";
 import type { ToolProfiler } from "../events/tool-profiling-listener.js";
 import { enqueueAutoAnalysisIfEnabled } from "../memory/auto-analysis-enqueue.js";
 import { isAutoAnalysisConversation } from "../memory/auto-analysis-guard.js";
-import {
-  getConversation,
-  getMessages,
-  type MessageRow,
-} from "../memory/conversation-crud.js";
+import { getConversation, getMessages } from "../memory/conversation-crud.js";
 import { enqueueMemoryJob, isMemoryEnabled } from "../memory/jobs-store.js";
 import { enqueueMemoryRetrospectiveIfEnabled } from "../memory/memory-retrospective-enqueue.js";
 import { shouldExposePersonalMemory } from "../memory/v2/static-context.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
+import { repairHistory } from "../plugins/defaults/history-repair/terminal.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 import {
   isUntrustedTrustClass,
@@ -34,48 +31,16 @@ import type { MessageQueue } from "./conversation-queue-manager.js";
 import { stripInjectionsForCompaction } from "./conversation-runtime-assembly.js";
 import { resetSkillToolProjection } from "./conversation-skill-tools.js";
 import { resolveTrustClass } from "./conversation-tool-setup.js";
-import { repairHistory } from "./history-repair.js";
 import type {
   SurfaceData,
   SurfaceType,
   UsageStats,
 } from "./message-protocol.js";
+import { filterMessagesForUntrustedActor } from "./message-provenance.js";
 import type { TrustContext } from "./trust-context.js";
 
 const log = getLogger("conversation-lifecycle");
 
-function parseProvenanceTrustClass(
-  metadata: string | null,
-): TrustClass | undefined {
-  if (!metadata) return undefined;
-  try {
-    const parsed = JSON.parse(metadata) as { provenanceTrustClass?: unknown };
-    const trustClass = parsed?.provenanceTrustClass;
-    if (
-      trustClass === "guardian" ||
-      trustClass === "trusted_contact" ||
-      trustClass === "unknown"
-    ) {
-      return trustClass;
-    }
-  } catch {
-    // Ignore malformed metadata and treat as unknown provenance.
-  }
-  return undefined;
-}
-
-export function filterMessagesForUntrustedActor(
-  messages: MessageRow[],
-): MessageRow[] {
-  return messages.filter((m) => {
-    const provenanceTrustClass = parseProvenanceTrustClass(m.metadata);
-    return (
-      provenanceTrustClass === "trusted_contact" ||
-      provenanceTrustClass === "unknown"
-    );
-  });
-}
-
 /**
  * Re-inject image source path annotations into message content blocks.
  *
@@ -350,6 +315,13 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
           ...parsedMessages.slice(preStrippedCount),
         ];
 
+  // Normalize the canonical persisted history once at load. Every consumer
+  // of `ctx.messages` outside the agent loop (history edit/undo, PKB context
+  // tracking, surfaces) reads this list directly, so it must satisfy the
+  // provider pairing/alternation rules before any of them run. The agent
+  // loop's pre-run repair only repairs the transient per-turn message list it
+  // sends to the provider and never writes back here, so this pass is not
+  // redundant with it.
   const { messages: repairedMessages, stats } =
     repairHistory(messagesBeforeRepair);
   if (

package/src/daemon/conversation-messaging.ts

@@ -519,9 +519,7 @@ export async function persistQueuedMessageBody(
       ctx.conversationId,
       "user",
       contentToPersist,
-      mergedMetadata,
-      undefined,
-      clientMessageId,
+      { metadata: mergedMetadata, clientMessageId },
     );
 
     if (persistedUserMessage.deduplicated) {

package/src/daemon/conversation-notifiers.ts

@@ -57,11 +57,13 @@ export function registerConversationNotifiers(
         "assistant",
         JSON.stringify([{ type: "text", text: questionText }]),
         {
-          ...provenanceFromTrustContext(ctx.trustContext),
-          userMessageChannel: "phone",
-          assistantMessageChannel: "phone",
-          userMessageInterface: "phone",
-          assistantMessageInterface: "phone",
+          metadata: {
+            ...provenanceFromTrustContext(ctx.trustContext),
+            userMessageChannel: "phone",
+            assistantMessageChannel: "phone",
+            userMessageInterface: "phone",
+            assistantMessageInterface: "phone",
+          },
         },
       );
 

package/src/daemon/conversation-process.ts

@@ -164,8 +164,8 @@ export interface ProcessConversationContext {
   runAgentLoop(
     content: string,
     userMessageId: string,
-    onEvent?: (msg: ServerMessage) => void,
     options?: {
+      onEvent?: (msg: ServerMessage) => void;
       isInteractive?: boolean;
       isUserMessage?: boolean;
       titleText?: string;
@@ -196,9 +196,11 @@ export interface ProcessConversationContext {
       | "error_terminal"
       | "preview_start"
       | "context_compacting",
-    anchor?: "assistant_turn" | "user_turn" | "global",
-    requestId?: string,
-    statusText?: string,
+    options?: {
+      anchor?: "assistant_turn" | "user_turn" | "global";
+      requestId?: string;
+      statusText?: string;
+    },
   ): void;
   /** Force context compaction regardless of threshold/cooldown. */
   forceCompact(options?: {
@@ -227,7 +229,10 @@ export interface ProcessConversationContext {
    * without a proxy). Called from drain paths before preactivation so skills
    * are only activated when the proxy that services them is present.
    */
-  ensureHostProxiesForTurn(sourceInterface: InterfaceId | undefined): void;
+  ensureHostProxiesForTurn(
+    sourceInterface: InterfaceId | undefined,
+    sourceActorPrincipalId?: string,
+  ): void;
 }
 
 function resolveQueuedTurnContext(
@@ -512,12 +517,9 @@ async function drainSingleMessage(
     conversationId: conversation.conversationId,
     requestId: next.requestId,
   });
-  conversation.emitActivityState(
-    "thinking",
-    "message_dequeued",
-    "assistant_turn",
-    next.requestId,
-  );
+  conversation.emitActivityState("thinking", "message_dequeued", {
+    requestId: next.requestId,
+  });
 
   const queuedTurnCtx = resolveQueuedTurnContext(
     next,
@@ -560,8 +562,17 @@ async function drainSingleMessage(
     const interfaceCtx =
       queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
     const sourceInterface = interfaceCtx?.userMessageInterface;
-    conversation.ensureHostProxiesForTurn(sourceInterface);
-    preactivateHostProxySkills(conversation, sourceInterface);
+    const sourceActorPrincipalId =
+      conversation.trustContext?.guardianPrincipalId;
+    conversation.ensureHostProxiesForTurn(
+      sourceInterface,
+      sourceActorPrincipalId,
+    );
+    preactivateHostProxySkills(
+      conversation,
+      sourceInterface,
+      sourceActorPrincipalId,
+    );
   }
 
   // Snapshot persona context at turn start so later tool turns can't pick up
@@ -625,12 +636,9 @@ async function drainSingleMessage(
         next.attachments,
         next.displayContent,
       );
-      await addMessage(
-        conversation.conversationId,
-        "user",
-        contentToPersist,
-        drainChannelMeta,
-      );
+      await addMessage(conversation.conversationId, "user", contentToPersist, {
+        metadata: drainChannelMeta,
+      });
       conversation.messages.push(llmUserMsg);
 
       const assistantMsg = createAssistantMessage(slashResult.message);
@@ -638,7 +646,7 @@ async function drainSingleMessage(
         conversation.conversationId,
         "assistant",
         JSON.stringify(assistantMsg.content),
-        { ...drainChannelMeta, sentAt: Date.now() },
+        { metadata: { ...drainChannelMeta, sentAt: Date.now() } },
       );
       conversation.messages.push(assistantMsg);
 
@@ -741,17 +749,14 @@ async function drainSingleMessage(
           next.attachments,
           next.displayContent,
         ),
-        drainChannelMeta,
+        { metadata: drainChannelMeta },
       );
       persistedCompactMessage = true;
       conversation.messages.push(cleanUserMsg);
 
-      conversation.emitActivityState(
-        "thinking",
-        "context_compacting",
-        "assistant_turn",
-        next.requestId,
-      );
+      conversation.emitActivityState("thinking", "context_compacting", {
+        requestId: next.requestId,
+      });
       const result = await conversation.forceCompact({
         targetInputTokensOverride: slashResult.targetInputTokensOverride,
       });
@@ -762,7 +767,7 @@ async function drainSingleMessage(
         conversation.conversationId,
         "assistant",
         JSON.stringify(assistantMsg.content),
-        { ...drainChannelMeta, sentAt: Date.now() },
+        { metadata: { ...drainChannelMeta, sentAt: Date.now() } },
       );
       conversation.messages.push(assistantMsg);
 
@@ -837,7 +842,7 @@ async function drainSingleMessage(
           next.attachments,
           next.displayContent,
         ),
-        drainChannelMeta,
+        { metadata: drainChannelMeta },
       );
       persistedCleanMessage = true;
       conversation.messages.push(cleanUserMsg);
@@ -850,7 +855,7 @@ async function drainSingleMessage(
         conversation.conversationId,
         "assistant",
         JSON.stringify(assistantMsg.content),
-        { ...drainChannelMeta, sentAt: Date.now() },
+        { metadata: { ...drainChannelMeta, sentAt: Date.now() } },
       );
       conversation.messages.push(assistantMsg);
 
@@ -1031,12 +1036,10 @@ async function drainSingleMessage(
     drainLoopOptions.titleText = resolvedContent;
 
   conversation
-    .runAgentLoop(
-      agentLoopContent,
-      userMessageId,
-      next.onEvent,
-      drainLoopOptions,
-    )
+    .runAgentLoop(agentLoopContent, userMessageId, {
+      ...drainLoopOptions,
+      onEvent: next.onEvent,
+    })
     .catch((err) => {
       const message = err instanceof Error ? err.message : String(err);
       log.error(
@@ -1113,8 +1116,17 @@ async function drainBatch(
     const interfaceCtx =
       queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
     const sourceInterface = interfaceCtx?.userMessageInterface;
-    conversation.ensureHostProxiesForTurn(sourceInterface);
-    preactivateHostProxySkills(conversation, sourceInterface);
+    const sourceActorPrincipalId =
+      conversation.trustContext?.guardianPrincipalId;
+    conversation.ensureHostProxiesForTurn(
+      sourceInterface,
+      sourceActorPrincipalId,
+    );
+    preactivateHostProxySkills(
+      conversation,
+      sourceInterface,
+      sourceActorPrincipalId,
+    );
   }
 
   // Snapshot persona context at turn start so later tool turns can't pick up
@@ -1128,12 +1140,9 @@ async function drainBatch(
   // connected SSE client (via activityVersion increments), whipsawing the
   // client-side thinking indicator. The single-message path emits exactly
   // one such event per turn; match it here.
-  conversation.emitActivityState(
-    "thinking",
-    "message_dequeued",
-    "assistant_turn",
-    head.requestId,
-  );
+  conversation.emitActivityState("thinking", "message_dequeued", {
+    requestId: head.requestId,
+  });
 
   // Per-message dequeue events and persistence loop. Track the last
   // SUCCESSFUL persist separately from the batch tail — a failed tail
@@ -1438,12 +1447,10 @@ async function drainBatch(
   // Fire-and-forget: runAgentLoop's finally block recursively calls drainQueue
   // when this run completes. Mirrors drainSingleMessage.
   conversation
-    .runAgentLoop(
-      lastSuccessfulContent,
-      lastUserMessageId,
-      fanOutOnEvent,
-      drainLoopOptions,
-    )
+    .runAgentLoop(lastSuccessfulContent, lastUserMessageId, {
+      ...drainLoopOptions,
+      onEvent: fanOutOnEvent,
+    })
     .catch((err) => {
       const message = err instanceof Error ? err.message : String(err);
       log.error(
@@ -1463,6 +1470,22 @@ async function drainBatch(
     });
 }
 
+// ── ProcessMessageOptions ────────────────────────────────────────────
+
+/** Options for `processMessage`. Only `content` and `attachments` are
+ *  required; everything else has a sensible default or is genuinely optional. */
+export interface ProcessMessageOptions {
+  content: string;
+  attachments: UserMessageAttachment[];
+  onEvent?: (msg: ServerMessage) => void;
+  requestId?: string;
+  activeSurfaceId?: string;
+  currentPage?: string;
+  isInteractive?: boolean;
+  callSite?: LLMCallSite;
+  displayContent?: string;
+}
+
 // ── processMessage ───────────────────────────────────────────────────
 
 /**
@@ -1471,15 +1494,19 @@ async function drainBatch(
  */
 export async function processMessage(
   conversation: ProcessConversationContext,
-  content: string,
-  attachments: UserMessageAttachment[],
-  onEvent: (msg: ServerMessage) => void,
-  requestId?: string,
-  activeSurfaceId?: string,
-  currentPage?: string,
-  options?: { isInteractive?: boolean; callSite?: LLMCallSite },
-  displayContent?: string,
+  options: ProcessMessageOptions,
 ): Promise<string> {
+  const {
+    content,
+    attachments,
+    onEvent = () => {},
+    requestId,
+    activeSurfaceId,
+    currentPage,
+    isInteractive,
+    callSite,
+    displayContent,
+  } = options;
   await conversation.ensureActorScopedHistory();
   // Snapshot persona context at turn start so later tool turns can't pick up
   // a different actor's context if a concurrent request mutates the live fields.
@@ -1558,7 +1585,7 @@ export async function processMessage(
           attachments,
           displayContent,
         ),
-        routerChannelMeta,
+        { metadata: routerChannelMeta },
       );
       conversation.messages.push(llmUserMsg);
 
@@ -1572,7 +1599,7 @@ export async function processMessage(
         conversation.conversationId,
         "assistant",
         JSON.stringify(assistantMsg.content),
-        routerChannelMeta,
+        { metadata: routerChannelMeta },
       );
       conversation.messages.push(assistantMsg);
 
@@ -1651,7 +1678,7 @@ export async function processMessage(
       conversation.conversationId,
       "user",
       contentToPersist,
-      pmChannelMeta,
+      { metadata: pmChannelMeta },
     );
     conversation.messages.push(llmUserMsg);
 
@@ -1660,7 +1687,7 @@ export async function processMessage(
       conversation.conversationId,
       "assistant",
       JSON.stringify(assistantMsg.content),
-      pmChannelMeta,
+      { metadata: pmChannelMeta },
     );
     conversation.messages.push(assistantMsg);
 
@@ -1738,17 +1765,14 @@ export async function processMessage(
           attachments,
           displayContent,
         ),
-        pmChannelMeta,
+        { metadata: pmChannelMeta },
       );
       persistedCompactMessage = true;
       conversation.messages.push(cleanUserMsg);
 
-      conversation.emitActivityState(
-        "thinking",
-        "context_compacting",
-        "assistant_turn",
+      conversation.emitActivityState("thinking", "context_compacting", {
         requestId,
-      );
+      });
       const result = await conversation.forceCompact({
         targetInputTokensOverride: slashResult.targetInputTokensOverride,
       });
@@ -1759,7 +1783,7 @@ export async function processMessage(
         conversation.conversationId,
         "assistant",
         JSON.stringify(assistantMsg.content),
-        pmChannelMeta,
+        { metadata: pmChannelMeta },
       );
       conversation.messages.push(assistantMsg);
 
@@ -1825,7 +1849,7 @@ export async function processMessage(
           attachments,
           displayContent,
         ),
-        pmChannelMeta,
+        { metadata: pmChannelMeta },
       );
       persistedCleanMessage = true;
       conversation.messages.push(cleanUserMsg);
@@ -1838,7 +1862,7 @@ export async function processMessage(
         conversation.conversationId,
         "assistant",
         JSON.stringify(assistantMsg.content),
-        pmChannelMeta,
+        { metadata: pmChannelMeta },
       );
       conversation.messages.push(assistantMsg);
 
@@ -1953,17 +1977,14 @@ export async function processMessage(
     titleText?: string;
     callSite?: LLMCallSite;
   } = { isUserMessage: true };
-  if (options?.isInteractive !== undefined)
-    loopOptions.isInteractive = options.isInteractive;
+  if (isInteractive !== undefined) loopOptions.isInteractive = isInteractive;
   if (agentLoopContent !== resolvedContent)
     loopOptions.titleText = resolvedContent;
-  if (options?.callSite !== undefined) loopOptions.callSite = options.callSite;
+  if (callSite !== undefined) loopOptions.callSite = callSite;
 
-  await conversation.runAgentLoop(
-    agentLoopContent,
-    userMessageId,
+  await conversation.runAgentLoop(agentLoopContent, userMessageId, {
+    ...loopOptions,
     onEvent,
-    loopOptions,
-  );
+  });
   return userMessageId;
 }