@vellumai/assistant 0.6.3 → 0.6.4

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,10 @@ 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,
@@ -261,13 +267,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 +312,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);

package/src/daemon/conversation-messaging.ts

@@ -287,6 +287,42 @@ export async function persistUserMessage(
   ctx.processing = true;
   ctx.abortController = new AbortController();
 
+  try {
+    return await persistQueuedMessageBody(
+      ctx,
+      content,
+      attachments,
+      reqId,
+      metadata,
+      displayContent,
+    );
+  } catch (err) {
+    ctx.processing = false;
+    ctx.abortController = null;
+    ctx.currentRequestId = undefined;
+    throw err;
+  }
+}
+
+// ── persistQueuedMessageBody ─────────────────────────────────────────
+
+/**
+ * Persists a user message body (DB row, attachment indexing, origin
+ * channel/interface updates, meta file write) without touching the
+ * `ctx.processing` flag or request-id bookkeeping.
+ *
+ * Used by `persistUserMessage` (which sets the processing flag first) and
+ * by the batched drain path, which persists multiple sibling messages
+ * under a single in-flight turn.
+ */
+export async function persistQueuedMessageBody(
+  ctx: MessagingConversationContext,
+  content: string,
+  attachments: UserMessageAttachment[],
+  requestId: string,
+  metadata: Record<string, unknown> | undefined,
+  displayContent: string | undefined,
+): Promise<string> {
   const attachmentInputs = attachments.map((attachment) => ({
     id: attachment.id,
     filename: attachment.filename,
@@ -302,6 +338,7 @@ export async function persistUserMessage(
   );
   log.info(
     {
+      requestId,
       contentBlockTypes: Array.isArray(llmMessage.content)
         ? llmMessage.content.map((b) => b.type)
         : typeof llmMessage.content,
@@ -443,9 +480,6 @@ export async function persistUserMessage(
     return persistedUserMessage.id;
   } catch (err) {
     ctx.messages.pop();
-    ctx.processing = false;
-    ctx.abortController = null;
-    ctx.currentRequestId = undefined;
     throw err;
   }
 }

package/src/daemon/conversation-notifiers.ts

@@ -100,6 +100,7 @@ export function registerConversationNotifiers(
           type: "message_complete",
           conversationId: conversationId,
           messageId: msg.id,
+          source: "aux",
         });
       }
     },
@@ -135,6 +136,7 @@ export function registerConversationNotifiers(
           type: "message_complete",
           conversationId: conversationId,
           messageId: msg.id,
+          source: "aux",
         });
       }
     },
@@ -171,6 +173,7 @@ export function registerConversationNotifiers(
         type: "message_complete",
         conversationId: conversationId,
         messageId: msg.id,
+        source: "aux",
       });
     },
   );
@@ -189,6 +192,7 @@ export function registerConversationNotifiers(
       ctx.sendToClient({
         type: "message_complete",
         conversationId: conversationId,
+        source: "aux",
       });
     },
   );
@@ -204,6 +208,7 @@ export function registerConversationNotifiers(
     ctx.sendToClient({
       type: "message_complete",
       conversationId: conversationId,
+      source: "aux",
     });
   });
 }