@vellumai/assistant 0.6.3 → 0.6.5

package/src/daemon/conversation-attachments.ts

@@ -107,7 +107,7 @@ export async function approveHostAttachmentRead(
   const response = await prompter.prompt(
     toolName,
     input,
-    await classifyRisk(toolName, input, workingDir),
+    (await classifyRisk(toolName, input, workingDir)).level,
     await generateAllowlistOptions(toolName, input),
     generateScopeOptions(workingDir, toolName),
     undefined,
@@ -116,8 +116,7 @@ export async function approveHostAttachmentRead(
   );
 
   if (
-    (response.decision === "always_allow" ||
-      response.decision === "always_allow_high_risk") &&
+    response.decision === "always_allow" &&
     response.selectedPattern &&
     response.selectedScope
   ) {
@@ -127,9 +126,6 @@ export async function approveHostAttachmentRead(
       response.selectedScope,
       "allow",
       100,
-      response.decision === "always_allow_high_risk"
-        ? { allowHighRisk: true }
-        : undefined,
     );
   }
   if (

package/src/daemon/conversation-error.ts

@@ -1,4 +1,5 @@
 import { getProviderRoutingSource } from "../providers/registry.js";
+import { isAbortReason } from "../util/abort-reasons.js";
 import { ProviderError, ProviderNotConfiguredError } from "../util/errors.js";
 import type {
   ConversationErrorCode,
@@ -85,6 +86,14 @@ const WEB_SEARCH_ORDERING_PATTERNS = [
   /web_search.*tool_result/i,
 ];
 
+// Stale/invalid opaque `encrypted_content` token in replayed web-search results.
+// Anthropic's tokens have bounded validity; the daemon replaces historical
+// `web_search_tool_result` blocks with text summaries to avoid this, but this
+// classifier remains as defense-in-depth for any path that bypasses the strip.
+const STALE_WEB_SEARCH_CONTENT_PATTERNS = [
+  /invalid\s+`?encrypted_content`?\s+in\s+`?(?:web_)?search_result`?\s+block/i,
+];
+
 // Streaming corruption patterns (Anthropic SDK throws non-HTTP errors for SSE issues)
 const STREAMING_ERROR_PATTERNS = [
   /unexpected event order/i,
@@ -110,11 +119,21 @@ export interface ErrorContext {
  * Returns true if the error looks like a user-initiated cancellation
  * (AbortError or explicit cancel). These should use `generation_cancelled`
  * instead of `conversation_error`.
+ *
+ * Provider SDKs wrap the underlying AbortError in their own error class
+ * (e.g. `ProviderError("Anthropic API error: Request was aborted.")`),
+ * which erases the `AbortError` name. To compensate, the daemon tags every
+ * `controller.abort(reason)` call with an `AbortReason` object — when the
+ * wrapped `ProviderError` carries that tagged reason, we treat it as a user
+ * cancellation regardless of error class.
  */
 export function isUserCancellation(error: unknown, ctx: ErrorContext): boolean {
   if (!ctx.aborted) return false;
   if (error instanceof DOMException && error.name === "AbortError") return true;
   if (error instanceof Error && error.name === "AbortError") return true;
+  if (error instanceof ProviderError && isAbortReason(error.abortReason)) {
+    return true;
+  }
   return false;
 }
 
@@ -291,6 +310,15 @@ function classifyCore(
           errorCategory: "web_search_ordering",
         };
       }
+      if (isStaleWebSearchContent(message)) {
+        return {
+          code: "PROVIDER_WEB_SEARCH",
+          userMessage:
+            "Stale web-search results in conversation history. Please try again.",
+          retryable: true,
+          errorCategory: "stale_web_search_content",
+        };
+      }
       if (isOrderingError(message)) {
         return {
           code: "PROVIDER_ORDERING",
@@ -343,6 +371,15 @@ export function isWebSearchOrderingError(message: string): boolean {
   return WEB_SEARCH_ORDERING_PATTERNS.some((p) => p.test(message));
 }
 
+/**
+ * Check whether an error message indicates a stale/invalid `encrypted_content`
+ * opaque token in a replayed `web_search_tool_result`. See
+ * `stripHistoricalWebSearchResults()` for the proactive mitigation.
+ */
+export function isStaleWebSearchContent(message: string): boolean {
+  return STALE_WEB_SEARCH_CONTENT_PATTERNS.some((p) => p.test(message));
+}
+
 /** Check whether an error message indicates a tool_use/tool_result ordering failure. */
 export function isOrderingError(message: string): boolean {
   return ORDERING_ERROR_PATTERNS.some((p) => p.test(message));
@@ -403,6 +440,15 @@ function classifyByMessage(
       errorCategory: "web_search_ordering",
     };
   }
+  if (isStaleWebSearchContent(message)) {
+    return {
+      code: "PROVIDER_WEB_SEARCH",
+      userMessage:
+        "Stale web-search results in conversation history. Please try again.",
+      retryable: true,
+      errorCategory: "stale_web_search_content",
+    };
+  }
 
   // General tool_use/tool_result ordering errors
   if (isOrderingError(message)) {

package/src/daemon/conversation-history.ts

@@ -15,6 +15,7 @@ import { withQdrantBreaker } from "../memory/qdrant-circuit-breaker.js";
 import { getQdrantClient } from "../memory/qdrant-client.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
+import { truncate } from "../util/truncate.js";
 import type { ServerMessage } from "./message-protocol.js";
 import type { TraceEmitter } from "./trace-emitter.js";
 
@@ -564,10 +565,43 @@ export async function regenerate(
   // in both this.messages and the DB.
   conversation.processing = true;
   conversation.abortController = new AbortController();
-  conversation.currentRequestId = requestId ?? uuid();
-
-  await conversation.runAgentLoop(content, existingUserMessageId, onEvent, {
-    skipPreMessageRollback: true,
-    isUserMessage: true,
-  });
+  const resolvedRequestId = requestId ?? uuid();
+  conversation.currentRequestId = resolvedRequestId;
+
+  // Fire-and-forget: matches the /v1/messages pattern so the HTTP handler
+  // returns 202 immediately rather than blocking on the full agent turn.
+  // Otherwise the client's 15s POST timeout fires on any non-trivial
+  // regenerate and surfaces a misleading "Failed to regenerate message"
+  // banner even though the response streams in normally via SSE.
+  //
+  // runAgentLoop catches most errors internally and emits `request_error`
+  // itself, but anything thrown from its `finally` block (commit, drain,
+  // profiler) would otherwise escape silently because the caller does
+  // 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, onEvent, {
+      skipPreMessageRollback: true,
+      isUserMessage: true,
+    })
+    .catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      log.error(
+        { err, conversationId: conversation.conversationId },
+        "runAgentLoop after regenerate failed",
+      );
+      conversation.traceEmitter.emit(
+        "request_error",
+        truncate(message, 200, ""),
+        {
+          requestId: resolvedRequestId,
+          status: "error",
+          attributes: {
+            errorClass: err instanceof Error ? err.constructor.name : "Error",
+            message: truncate(message, 500, ""),
+            source: "regenerate_fire_and_forget",
+          },
+        },
+      );
+    });
 }

package/src/daemon/conversation-launch.ts

@@ -0,0 +1,220 @@
+/**
+ * Helper that creates, titles, and seeds a fresh conversation for the
+ * conversation-launcher flow.
+ *
+ * Called from `handleSurfaceAction` when a persistent `ui_show` card fires a
+ * `launch_conversation` action — the origin conversation's `TrustContext` is
+ * forwarded so spawned conversations inherit guardian / trust class.
+ *
+ * The helper depends on DaemonServer state (conversation map,
+ * `persistAndProcessMessage`, assistant ID, hub publisher) and is wired via
+ * {@link registerLaunchConversationDeps} at daemon startup. Tests can stub
+ * deps directly via the same registration.
+ */
+
+import { randomUUID } from "node:crypto";
+
+import { updateConversationTitle } from "../memory/conversation-crud.js";
+import { getOrCreateConversation as getOrCreateConversationKey } from "../memory/conversation-key-store.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 { getLogger } from "../util/logger.js";
+import type { Conversation } from "./conversation.js";
+import type { TrustContext } from "./conversation-runtime-assembly.js";
+import type { ConversationCreateOptions } from "./handlers/shared.js";
+import type { ServerMessage } from "./message-protocol.js";
+
+const log = getLogger("conversation-launch");
+
+// ── Dependency registry ─────────────────────────────────────────────
+
+export interface LaunchConversationDeps {
+  /**
+   * Return the live {@link Conversation} instance for the given id,
+   * creating + hydrating it if necessary. Wraps `DaemonServer.getOrCreateConversation`.
+   */
+  getOrCreateConversation: (
+    conversationId: string,
+    options?: ConversationCreateOptions,
+  ) => Promise<Conversation>;
+  /**
+   * Persist the seed message and run the agent loop. Wraps
+   * `DaemonServer.persistAndProcessMessage`.
+   */
+  persistAndProcessMessage: (
+    conversationId: string,
+    content: string,
+    attachmentIds?: string[],
+    options?: ConversationCreateOptions,
+    sourceChannel?: string,
+    sourceInterface?: string,
+  ) => Promise<{ messageId: string }>;
+  /**
+   * Forward a `ServerMessage` to the process-level assistant event hub.
+   * Wraps `DaemonServer.publishAssistantEvent`.
+   */
+  publishAssistantEvent: (msg: ServerMessage, conversationId?: string) => void;
+  /** Assistant id to stamp onto the `open_conversation` event. */
+  getAssistantId: () => string | undefined;
+}
+
+let _deps: LaunchConversationDeps | null = null;
+
+/**
+ * Register the daemon-side dependencies the helper needs. Called once by
+ * `DaemonServer.start()` and (in tests) by unit tests that exercise
+ * {@link launchConversation} directly.
+ */
+export function registerLaunchConversationDeps(
+  deps: LaunchConversationDeps,
+): void {
+  _deps = deps;
+}
+
+/**
+ * Test-only helper: reset the module-level `_deps` between test cases so
+ * accidental coupling between tests can't hide bugs (e.g. a test that does
+ * not register deps but happens to pass because an earlier test in the same
+ * file left deps registered and the validation short-circuit hides the
+ * "deps not registered" throw).
+ */
+export function resetLaunchConversationDeps(): void {
+  _deps = null;
+}
+
+// ── Helper ──────────────────────────────────────────────────────────
+
+export interface LaunchConversationParams {
+  title: string;
+  seedPrompt: string;
+  anchorMessageId?: string;
+  originTrustContext?: TrustContext;
+  /**
+   * Passed through to the `open_conversation` event. Defaults to omitted
+   * (i.e. client-side default of `true`) so direct callers keep their
+   * existing "jump to the new conversation" behavior. Set to `false` for
+   * fan-out launchers that register the conversation in the sidebar but
+   * must not steal focus from the origin.
+   */
+  focus?: boolean;
+}
+
+/**
+ * Create, title, and seed a fresh conversation and notify connected clients
+ * via an `open_conversation` event.
+ *
+ * If `originTrustContext` is provided, it is applied to the new conversation
+ * before seeding so guardian / trust-class state is inherited from the
+ * spawning context. When absent, the conversation runs without an inherited
+ * trust context.
+ *
+ * The seed turn (`persistAndProcessMessage`) runs **fire-and-forget** so this
+ * helper returns as soon as the conversation is created, titled, and the
+ * `open_conversation` event has been published. Callers driving a fan-out
+ * UX (multiple launches from a single click) rely on this: blocking on the
+ * full LLM turn would hold the HTTP request open for tens of seconds.
+ * Errors from the seed turn are logged but not surfaced — the new
+ * conversation still exists in the sidebar so the user can retry from there.
+ *
+ * Throws if the helper's daemon-side dependencies have not been registered
+ * or if conversation creation / titling itself fails.
+ */
+export async function launchConversation(
+  params: LaunchConversationParams,
+): Promise<{ conversationId: string }> {
+  // Belt-and-suspenders validation: callers (handleSurfaceAction) also check
+  // for these, but enforcing here keeps the helper self-contained so future
+  // direct callers can't accidentally emit `open_conversation` events with a
+  // blank title (which would create a blank-titled sidebar entry on macOS).
+  if (!params.title || !params.seedPrompt) {
+    throw new Error("launchConversation: title and seedPrompt are required");
+  }
+  if (!_deps) {
+    throw new Error(
+      "launchConversation dependencies not registered — daemon may not be ready",
+    );
+  }
+  const deps = _deps;
+
+  // Each launch gets a globally unique conversation key so the skill always
+  // creates a fresh conversation rather than reusing any prior mapping.
+  // `getOrCreateConversation` will insert a new row.
+  const conversationKey = `launcher-${randomUUID()}`;
+  const { conversationId } = getOrCreateConversationKey(conversationKey);
+
+  // Hydrate the live Conversation instance so we can apply trust context
+  // before the seed turn begins. persistAndProcessMessage will reuse this
+  // instance from the conversations map.
+  const conversation = await deps.getOrCreateConversation(conversationId);
+
+  // Inherit guardian / trust-class state from the caller when available.
+  // `handleSurfaceAction` passes the origin conversation's trustContext.
+  if (params.originTrustContext) {
+    conversation.setTrustContext(params.originTrustContext);
+  }
+
+  // Set the user-facing title immediately so clients that stub a sidebar
+  // entry from the open_conversation event see the right label even before
+  // the turn completes.
+  if (params.title) {
+    updateConversationTitle(conversationId, params.title, 0);
+  }
+
+  // Tell connected clients about the new conversation BEFORE kicking off the
+  // seed turn so the sidebar entry appears instantly. This helper is the sole
+  // emitter of `open_conversation` for this launch path. Pass through the
+  // caller-specified `focus` so fan-out launchers can avoid stealing focus
+  // from the origin.
+  await assistantEventHub.publish(
+    buildAssistantEvent(
+      deps.getAssistantId() ?? DAEMON_INTERNAL_ASSISTANT_ID,
+      {
+        type: "open_conversation",
+        conversationId,
+        // Conditional spread so an empty / falsy title is omitted entirely
+        // instead of leaking into the Swift handler (`if let title = msg.title`
+        // accepts empty strings and would create a blank-titled sidebar entry).
+        // The validation guard above already rejects empty titles for our
+        // current callers, but this is defense-in-depth for future ones.
+        ...(params.title ? { title: params.title } : {}),
+        ...(params.anchorMessageId
+          ? { anchorMessageId: params.anchorMessageId }
+          : {}),
+        ...(params.focus !== undefined ? { focus: params.focus } : {}),
+      },
+      conversationId,
+    ),
+  );
+
+  // Seed the conversation by running the seed prompt through the same
+  // pipeline POST /v1/messages uses. Publishing to the hub lets any
+  // connected client stream the turn live. Fire-and-forget so callers
+  // aren't blocked on the full LLM turn — errors are logged but swallowed.
+  const hubSender = (msg: ServerMessage) => {
+    const msgConversationId =
+      "conversationId" in msg &&
+      typeof (msg as { conversationId?: unknown }).conversationId === "string"
+        ? (msg as { conversationId: string }).conversationId
+        : undefined;
+    deps.publishAssistantEvent(msg, msgConversationId ?? conversationId);
+  };
+
+  deps
+    .persistAndProcessMessage(
+      conversationId,
+      params.seedPrompt,
+      undefined,
+      { onEvent: hubSender },
+      "vellum",
+      "cli",
+    )
+    .catch((err) => {
+      log.error(
+        { err, conversationId },
+        "Seed turn failed for launched conversation (non-fatal)",
+      );
+    });
+
+  return { conversationId };
+}

package/src/daemon/conversation-lifecycle.ts

@@ -9,6 +9,8 @@ import type { EventBus } from "../events/bus.js";
 import type { AssistantDomainEvents } from "../events/domain-events.js";
 import type { ToolProfiler } from "../events/tool-profiling-listener.js";
 import { getHookManager } from "../hooks/manager.js";
+import { enqueueAutoAnalysisIfEnabled } from "../memory/auto-analysis-enqueue.js";
+import { isAutoAnalysisConversation } from "../memory/auto-analysis-guard.js";
 import {
   getConversation,
   getMessages,
@@ -23,6 +25,7 @@ import {
   type TrustClass,
 } from "../runtime/actor-trust-resolver.js";
 import { unregisterConversationSender } from "../tools/browser/browser-screencast.js";
+import { type AbortReason, createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import {
   unregisterCallNotifiers,
@@ -59,7 +62,9 @@ function parseProvenanceTrustClass(
   return undefined;
 }
 
-function filterMessagesForUntrustedActor(messages: MessageRow[]): MessageRow[] {
+export function filterMessagesForUntrustedActor(
+  messages: MessageRow[],
+): MessageRow[] {
   return messages.filter((m) => {
     const provenanceTrustClass = parseProvenanceTrustClass(m.metadata);
     return (
@@ -185,7 +190,7 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
 
   const parsedMessages: Message[] = dbMessages
     .slice(ctx.contextCompactedMessageCount)
-    .map((m) => {
+    .map((m, index, arr) => {
       const role = m.role as "user" | "assistant";
       let content: ContentBlock[];
       try {
@@ -208,6 +213,24 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
       if (role === "user" && m.metadata) {
         try {
           const meta = JSON.parse(m.metadata);
+          const isTail = index === arr.length - 1;
+
+          // turn_context and system_reminder rehydrate for historical rows
+          // only; the tail gets fresh blocks via applyRuntimeInjections on
+          // the next turn. All three rehydration steps are prepends — the
+          // ordering below (system_reminder first, memory second,
+          // turn_context last) builds the documented shape right-to-left,
+          // since each prepend shifts previously-prepended blocks one slot
+          // right:
+          //   [<turn_context>, <memory __injected>, <system_reminder>, ...original]
+          if (!isTail && typeof meta.pkbSystemReminderBlock === "string") {
+            content = [
+              { type: "text" as const, text: meta.pkbSystemReminderBlock },
+              ...content,
+            ];
+          }
+
+          // Memory remains rehydrated on all rows (existing behavior).
           if (typeof meta.memoryInjectedBlock === "string") {
             content = [
               {
@@ -217,6 +240,13 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
               ...content,
             ];
           }
+
+          if (!isTail && typeof meta.turnContextBlock === "string") {
+            content = [
+              { type: "text" as const, text: meta.turnContextBlock },
+              ...content,
+            ];
+          }
         } catch {
           /* ignore parse errors — metadata may be malformed */
         }
@@ -261,13 +291,23 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
 
 // ── abort ─────────────────────────────────────────────────────────────
 
-export function abortConversation(ctx: AbortContext): void {
+export function abortConversation(
+  ctx: AbortContext,
+  reason?: AbortReason,
+): void {
   if (ctx.processing) {
+    const effectiveReason =
+      reason ??
+      createAbortReason(
+        "preempted_by_new_message",
+        "abortConversation:default",
+        ctx.conversationId,
+      );
     log.info(
-      { conversationId: ctx.conversationId },
+      { conversationId: ctx.conversationId, abortReason: effectiveReason },
       "Aborting in-flight processing",
     );
-    ctx.abortController?.abort();
+    ctx.abortController?.abort(effectiveReason);
     ctx.prompter.dispose();
     ctx.secretPrompter.dispose();
     ctx.pendingSurfaceActions.clear();
@@ -296,20 +336,54 @@ export function disposeConversation(ctx: DisposeContext): void {
   // Only extract from guardian conversations to preserve the memory trust
   // boundary — untrusted content must not influence future memory retrieval.
   if (!isUntrustedTrustClass(ctx.trustContext?.trustClass)) {
+    // Recursion guard: skip graph_extract for auto-analysis conversations.
+    // The analysis agent writes memory directly via tools, so extracting
+    // from its reflective musings would double-write into the memory graph.
+    // Mirrors the same guard applied in `indexer.ts` for the per-message
+    // indexing path.
+    // Fail open: if the guard lookup throws (e.g. DB unavailable during
+    // teardown), default to NOT skipping so the rest of disposal still runs.
+    let isAutoAnalysis = false;
     try {
-      enqueueMemoryJob("graph_extract", {
+      isAutoAnalysis = isAutoAnalysisConversation(ctx.conversationId);
+    } catch {
+      // Best-effort — don't block conversation disposal
+    }
+    if (!isAutoAnalysis) {
+      try {
+        enqueueMemoryJob("graph_extract", {
+          conversationId: ctx.conversationId,
+          scopeId: ctx.memoryScopeId ?? "default",
+          ...(ctx.activeContextNodeIds?.length
+            ? { activeContextNodeIds: ctx.activeContextNodeIds }
+            : {}),
+        });
+      } catch {
+        // Best-effort — don't block conversation disposal
+      }
+    }
+
+    try {
+      // `enqueueAutoAnalysisIfEnabled` has its own internal recursion guard
+      // (it checks `isAutoAnalysisConversation()`), so it's safe to call
+      // unconditionally here.
+      enqueueAutoAnalysisIfEnabled({
         conversationId: ctx.conversationId,
-        scopeId: ctx.memoryScopeId ?? "default",
-        ...(ctx.activeContextNodeIds?.length
-          ? { activeContextNodeIds: ctx.activeContextNodeIds }
-          : {}),
+        trigger: "lifecycle",
       });
     } catch {
       // Best-effort — don't block conversation disposal
     }
   }
 
-  ctx.abort();
+  abortConversation(
+    ctx,
+    createAbortReason(
+      "conversation_disposed",
+      "disposeConversation",
+      ctx.conversationId,
+    ),
+  );
   unregisterCallNotifiers(ctx.conversationId);
   unregisterConversationSender(ctx.conversationId);
   resetSkillToolProjection(ctx.skillProjectionState);