@vellumai/assistant 0.6.6 → 0.7.1

package/src/daemon/conversation-attachments.ts

@@ -4,20 +4,7 @@ import {
   getFilePathForAttachment,
   setAttachmentThumbnail,
 } from "../memory/attachments-store.js";
-import {
-  check,
-  classifyRisk,
-  generateAllowlistOptions,
-  generateScopeOptions,
-} from "../permissions/checker.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
-import { addRule } from "../permissions/trust-store.js";
-import { isAllowDecision } from "../permissions/types.js";
-import {
-  CONVERSATION_HOST_ACCESS_PROMPT,
-  isConversationHostAccessEnabled,
-  isPermissionControlsV2Enabled,
-} from "../permissions/v2-consent-policy.js";
 import type { ContentBlock } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
 import {
@@ -51,49 +38,6 @@ export async function approveHostAttachmentRead(
   const toolName = "host_file_read";
   const input = { path: filePath };
 
-  if (isPermissionControlsV2Enabled()) {
-    if (isConversationHostAccessEnabled(conversationId)) {
-      return true;
-    }
-
-    // HTTP-created sessions use a no-op sendToClient — prompting would
-    // block for the full permission timeout before auto-denying.
-    if (hasNoClient) {
-      log.info(
-        { filePath },
-        "Denying host attachment read: no interactive client connected",
-      );
-      return false;
-    }
-
-    const response = await prompter.prompt(
-      toolName,
-      input,
-      "low",
-      CONVERSATION_HOST_ACCESS_PROMPT.allowlistOptions,
-      CONVERSATION_HOST_ACCESS_PROMPT.scopeOptions,
-      undefined,
-      conversationId,
-      "host",
-      CONVERSATION_HOST_ACCESS_PROMPT.persistentDecisionsAllowed,
-      undefined,
-      CONVERSATION_HOST_ACCESS_PROMPT.temporaryOptionsAvailable,
-      undefined,
-      true,
-    );
-
-    return response.decision === "allow";
-  }
-
-  const decision = await check(toolName, input, workingDir);
-
-  if (decision.decision === "allow") {
-    return true;
-  }
-  if (decision.decision === "deny") {
-    return false;
-  }
-
   // HTTP-created sessions use a no-op sendToClient — prompting would
   // block for the full permission timeout before auto-denying.
   if (hasNoClient) {
@@ -107,36 +51,16 @@ export async function approveHostAttachmentRead(
   const response = await prompter.prompt(
     toolName,
     input,
-    (await classifyRisk(toolName, input, workingDir)).level,
-    await generateAllowlistOptions(toolName, input),
-    generateScopeOptions(workingDir, toolName),
+    "low",
+    [],
+    [],
     undefined,
     conversationId,
     "host",
+    false,
   );
 
-  if (
-    response.decision === "always_allow" &&
-    response.selectedPattern &&
-    response.selectedScope
-  ) {
-    addRule(
-      toolName,
-      response.selectedPattern,
-      response.selectedScope,
-      "allow",
-      100,
-    );
-  }
-  if (
-    response.decision === "always_deny" &&
-    response.selectedPattern &&
-    response.selectedScope
-  ) {
-    addRule(toolName, response.selectedPattern, response.selectedScope, "deny");
-  }
-
-  return isAllowDecision(response.decision);
+  return response.decision === "allow";
 }
 
 export interface AttachmentResolutionResult {

package/src/daemon/conversation-error.ts

@@ -125,7 +125,10 @@ export interface ErrorContext {
  * 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.
+ * cancellation regardless of error class. The same tagged object can also
+ * surface directly (e.g. when code calls `AbortSignal.throwIfAborted()`,
+ * which throws `signal.reason` verbatim), so a bare `AbortReason` is
+ * recognized as cancellation too.
  */
 export function isUserCancellation(error: unknown, ctx: ErrorContext): boolean {
   if (!ctx.aborted) return false;
@@ -134,6 +137,7 @@ export function isUserCancellation(error: unknown, ctx: ErrorContext): boolean {
   if (error instanceof ProviderError && isAbortReason(error.abortReason)) {
     return true;
   }
+  if (isAbortReason(error)) return true;
   return false;
 }
 
@@ -367,7 +371,7 @@ export function isContextTooLarge(message: string): boolean {
 }
 
 /** Check whether an error message indicates a web-search-specific ordering failure. */
-export function isWebSearchOrderingError(message: string): boolean {
+function isWebSearchOrderingError(message: string): boolean {
   return WEB_SEARCH_ORDERING_PATTERNS.some((p) => p.test(message));
 }
 
@@ -376,17 +380,17 @@ export function isWebSearchOrderingError(message: string): boolean {
  * opaque token in a replayed `web_search_tool_result`. See
  * `stripHistoricalWebSearchResults()` for the proactive mitigation.
  */
-export function isStaleWebSearchContent(message: string): boolean {
+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 {
+function isOrderingError(message: string): boolean {
   return ORDERING_ERROR_PATTERNS.some((p) => p.test(message));
 }
 
 /** Check whether an error message indicates an Anthropic SDK streaming corruption. */
-export function isStreamingError(message: string): boolean {
+function isStreamingError(message: string): boolean {
   return STREAMING_ERROR_PATTERNS.some((p) => p.test(message));
 }
 

package/src/daemon/conversation-history.ts

@@ -73,7 +73,7 @@ export function findLastUndoableUserMessageIndex(messages: Message[]): number {
  * Individual deletion failures are logged and enqueued as retry jobs
  * to prevent silently orphaned vectors.
  */
-export async function cleanupQdrantVectors(
+async function cleanupQdrantVectors(
   conversationId: string,
   segmentIds: string[],
 ): Promise<void> {
@@ -350,6 +350,7 @@ export function consolidateAssistantMessages(
 export interface HistoryConversationContext {
   readonly conversationId: string;
   readonly traceEmitter: TraceEmitter;
+  /** @internal */ sendToClient: (msg: ServerMessage) => void;
   messages: Message[];
   processing: boolean;
   abortController: AbortController | null;
@@ -357,7 +358,7 @@ export interface HistoryConversationContext {
   runAgentLoop(
     content: string,
     userMessageId: string,
-    onEvent: (msg: ServerMessage) => void,
+    onEvent?: (msg: ServerMessage) => void,
     options?: {
       isUserMessage?: boolean;
       titleText?: string;
@@ -414,11 +415,10 @@ export function undo(conversation: HistoryConversationContext): number {
  */
 export async function regenerate(
   conversation: HistoryConversationContext,
-  onEvent: (msg: ServerMessage) => void,
   requestId?: string,
 ): Promise<void> {
   if (conversation.processing) {
-    onEvent({ type: "error", 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 +437,7 @@ export async function regenerate(
   // assistant's exchange that we want to regenerate.
   const lastUserIdx = findLastUndoableUserMessageIndex(conversation.messages);
   if (lastUserIdx === -1) {
-    onEvent({ type: "error", 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 +454,7 @@ export async function regenerate(
 
   // There must be at least one message after the user message (the assistant reply).
   if (lastUserIdx >= conversation.messages.length - 1) {
-    onEvent({ type: "error", 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 +497,7 @@ export async function regenerate(
   }
 
   if (dbUserMsgIdx === -1) {
-    onEvent({ type: "error", 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",
@@ -546,7 +546,7 @@ export async function regenerate(
     .join("");
 
   // Notify client that the old response has been removed.
-  onEvent({
+  conversation.sendToClient({
     type: "undo_complete",
     removedCount: messagesToDelete.length,
     conversationId: conversation.conversationId,
@@ -572,7 +572,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, onEvent, {
+    .runAgentLoop(content, existingUserMessageId, undefined, {
       isUserMessage: true,
     })
     .catch((err) => {

package/src/daemon/conversation-launch.ts

@@ -5,11 +5,6 @@
  * 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";
@@ -18,71 +13,13 @@ 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";
+import { getOrCreateConversation } from "./conversation-store.js";
+import { processMessageInBackground } from "./process-message.js";
+import type { TrustContext } from "./trust-context.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 {
@@ -109,74 +46,37 @@ export interface LaunchConversationParams {
  * 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.
+ * The seed turn runs **fire-and-forget** so this helper returns as soon as
+ * the conversation is created, titled, and the `open_conversation` event has
+ * been published. Errors from the seed turn are logged but not surfaced.
  *
- * Throws if the helper's daemon-side dependencies have not been registered
- * or if conversation creation / titling itself fails.
+ * Throws 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);
+  const conversation = await 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 }
@@ -187,34 +87,19 @@ export async function launchConversation(
     ),
   );
 
-  // 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)",
-      );
-    });
+  processMessageInBackground(
+    conversationId,
+    params.seedPrompt,
+    undefined,
+    undefined,
+    "vellum",
+    "cli",
+  ).catch((err) => {
+    log.error(
+      { err, conversationId },
+      "Seed turn failed for launched conversation (non-fatal)",
+    );
+  });
 
   return { conversationId };
 }

package/src/daemon/conversation-lifecycle.ts

@@ -244,7 +244,7 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
             content = [
               {
                 type: "text" as const,
-                text: `<memory __injected>\n${meta.memoryInjectedBlock}\n</memory>`,
+                text: `<memory>\n${meta.memoryInjectedBlock}\n</memory>`,
               },
               ...content,
             ];

package/src/daemon/conversation-messaging.ts

@@ -40,13 +40,13 @@ import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { Message } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
 import type { MessageQueue } from "./conversation-queue-manager.js";
-import type { TrustContext } from "./conversation-runtime-assembly.js";
 import type { SlackInboundMessageMetadata } from "./handlers/shared.js";
 import type {
   ServerMessage,
   UserMessageAttachment,
 } from "./message-protocol.js";
 import type { ConversationTransportMetadata } from "./message-types/conversations.js";
+import type { TrustContext } from "./trust-context.js";
 
 const log = getLogger("conversation-messaging");
 
@@ -309,6 +309,7 @@ export function enqueueMessage(
   if (!accepted) {
     onEvent({
       type: "error",
+      conversationId: ctx.conversationId,
       message:
         "The assistant is busy and cannot accept more messages right now. Please try again shortly.",
       category: "queue_full",

package/src/daemon/conversation-notifiers.ts

@@ -23,8 +23,8 @@ import {
   provenanceFromTrustContext,
 } from "../memory/conversation-crud.js";
 import type { Message } from "../providers/types.js";
-import type { TrustContext } from "./conversation-runtime-assembly.js";
 import type { ServerMessage } from "./message-protocol.js";
+import type { TrustContext } from "./trust-context.js";
 
 /**
  * Subset of Conversation state that notifier callbacks need to read at