@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/daemon/conversation-process.ts

@@ -127,7 +127,8 @@ export function isModelSlashCommand(content: string): boolean {
 export interface ProcessConversationContext {
   readonly conversationId: string;
   messages: Message[];
-  processing: boolean;
+  isProcessing(): boolean;
+  setProcessing(value: boolean): void;
   abortController: AbortController | null;
   currentRequestId?: string;
   readonly queue: MessageQueue;
@@ -164,8 +165,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,14 +197,14 @@ 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?: {
-    targetInputTokensOverride?: number;
-  }): Promise<ContextWindowResult>;
+  forceCompact(): Promise<ContextWindowResult>;
   /** Strip runtime injections and reset memory-injection state. */
   forceClean(): Promise<CleanResult>;
   /** Set transport-derived hints for the conversation. */
@@ -227,7 +228,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 +516,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 +561,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 +635,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 +645,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,20 +748,15 @@ 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,
-      );
-      const result = await conversation.forceCompact({
-        targetInputTokensOverride: slashResult.targetInputTokensOverride,
+      conversation.emitActivityState("thinking", "context_compacting", {
+        requestId: next.requestId,
       });
+      const result = await conversation.forceCompact();
       const responseText = formatCompactResult(result);
 
       const assistantMsg = createAssistantMessage(responseText);
@@ -762,7 +764,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 +839,7 @@ async function drainSingleMessage(
           next.attachments,
           next.displayContent,
         ),
-        drainChannelMeta,
+        { metadata: drainChannelMeta },
       );
       persistedCleanMessage = true;
       conversation.messages.push(cleanUserMsg);
@@ -850,7 +852,7 @@ async function drainSingleMessage(
         conversation.conversationId,
         "assistant",
         JSON.stringify(assistantMsg.content),
-        { ...drainChannelMeta, sentAt: Date.now() },
+        { metadata: { ...drainChannelMeta, sentAt: Date.now() } },
       );
       conversation.messages.push(assistantMsg);
 
@@ -1017,7 +1019,7 @@ async function drainSingleMessage(
       });
   }
 
-  // Fire-and-forget: persistUserMessage set conversation.processing = true
+  // Fire-and-forget: persistUserMessage set the processing flag to true
   // so subsequent messages will still be enqueued.
   // runAgentLoop's finally block will call drainQueue when this run completes.
   const drainLoopOptions: {
@@ -1031,12 +1033,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 +1113,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 +1137,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
@@ -1206,7 +1212,7 @@ async function drainBatch(
         // which were already shifted out of the queue by
         // buildPassthroughBatch and would otherwise be stranded. Mirrors
         // the head persist-failure recovery below.
-        conversation.processing = false;
+        conversation.setProcessing(false);
         conversation.abortController = null;
         conversation.currentRequestId = undefined;
         conversation.preactivatedSkillIds = undefined;
@@ -1438,12 +1444,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 +1467,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 +1491,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 +1582,7 @@ export async function processMessage(
           attachments,
           displayContent,
         ),
-        routerChannelMeta,
+        { metadata: routerChannelMeta },
       );
       conversation.messages.push(llmUserMsg);
 
@@ -1572,7 +1596,7 @@ export async function processMessage(
         conversation.conversationId,
         "assistant",
         JSON.stringify(assistantMsg.content),
-        routerChannelMeta,
+        { metadata: routerChannelMeta },
       );
       conversation.messages.push(assistantMsg);
 
@@ -1651,7 +1675,7 @@ export async function processMessage(
       conversation.conversationId,
       "user",
       contentToPersist,
-      pmChannelMeta,
+      { metadata: pmChannelMeta },
     );
     conversation.messages.push(llmUserMsg);
 
@@ -1660,7 +1684,7 @@ export async function processMessage(
       conversation.conversationId,
       "assistant",
       JSON.stringify(assistantMsg.content),
-      pmChannelMeta,
+      { metadata: pmChannelMeta },
     );
     conversation.messages.push(assistantMsg);
 
@@ -1705,7 +1729,7 @@ export async function processMessage(
 
   // /compact — force context compaction, persist exchange, return message ID.
   if (slashResult.kind === "compact") {
-    conversation.processing = true;
+    conversation.setProcessing(true);
     let persistedCompactMessage = false;
     try {
       const pmTurnCtx = conversation.getTurnChannelContext();
@@ -1738,20 +1762,15 @@ 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,
       });
+      const result = await conversation.forceCompact();
       const responseText = formatCompactResult(result);
 
       const assistantMsg = createAssistantMessage(responseText);
@@ -1759,7 +1778,7 @@ export async function processMessage(
         conversation.conversationId,
         "assistant",
         JSON.stringify(assistantMsg.content),
-        pmChannelMeta,
+        { metadata: pmChannelMeta },
       );
       conversation.messages.push(assistantMsg);
 
@@ -1785,14 +1804,14 @@ export async function processMessage(
       }
       throw err;
     } finally {
-      conversation.processing = false;
+      conversation.setProcessing(false);
       await drainQueue(conversation);
     }
   }
 
   // /clean — strip runtime injections, return message ID. No LLM call.
   if (slashResult.kind === "clean") {
-    conversation.processing = true;
+    conversation.setProcessing(true);
     let persistedCleanMessage = false;
     try {
       const pmTurnCtx = conversation.getTurnChannelContext();
@@ -1825,7 +1844,7 @@ export async function processMessage(
           attachments,
           displayContent,
         ),
-        pmChannelMeta,
+        { metadata: pmChannelMeta },
       );
       persistedCleanMessage = true;
       conversation.messages.push(cleanUserMsg);
@@ -1838,7 +1857,7 @@ export async function processMessage(
         conversation.conversationId,
         "assistant",
         JSON.stringify(assistantMsg.content),
-        pmChannelMeta,
+        { metadata: pmChannelMeta },
       );
       conversation.messages.push(assistantMsg);
 
@@ -1864,7 +1883,7 @@ export async function processMessage(
       }
       throw err;
     } finally {
-      conversation.processing = false;
+      conversation.setProcessing(false);
       await drainQueue(conversation);
     }
   }
@@ -1953,17 +1972,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;
 }

package/src/daemon/conversation-registry.ts

@@ -0,0 +1,159 @@
+/**
+ * In-memory registry of active {@link Conversation} instances, keyed by
+ * conversation ID, plus the read/write accessors over it.
+ *
+ * This is a leaf module: it imports `Conversation` as a type only, so any
+ * layer — including the memory-retrieval plugin's injectors, which only know a
+ * conversation id — can look up the live conversation and read its state
+ * without pulling in the daemon-core creation graph (providers, system-prompt
+ * assembly, the `Conversation` class value) that `getOrCreateConversation` in
+ * `conversation-store` depends on. Keeping the registry free of those value
+ * imports is what lets the injector chain consume it without forming an import
+ * cycle (`injectors → store → conversation → agent-loop → runtime-assembly →
+ * injector-chain → injectors`).
+ *
+ * `conversation-store` owns the creation/reuse lifecycle and writes top-level
+ * conversations into this map via {@link setConversation}.
+ */
+
+import type { Conversation } from "./conversation.js";
+
+const conversations = new Map<string, Conversation>();
+
+// ── Read helpers ───────────────────────────────────────────────────
+
+export function findConversation(
+  conversationId: string | undefined,
+): Conversation | undefined {
+  if (!conversationId) return undefined;
+  return conversations.get(conversationId);
+}
+
+export function findConversationBySurfaceId(
+  surfaceId: string,
+): Conversation | undefined {
+  // Fast path: exact surfaceId match in surfaceState
+  for (const c of conversations.values()) {
+    if (c.surfaceState.has(surfaceId)) return c;
+  }
+
+  // Fallback: standalone app surfaces use "app-open-{appId}" IDs that
+  // were never part of any conversation.  Extract the appId and find
+  // a conversation whose surfaceState has a surface for that app.
+  const appOpenPrefix = "app-open-";
+  if (surfaceId.startsWith(appOpenPrefix)) {
+    const appId = surfaceId.slice(appOpenPrefix.length);
+    for (const c of conversations.values()) {
+      for (const [, state] of c.surfaceState.entries()) {
+        const data = state.data as unknown as Record<string, unknown>;
+        if (data?.appId === appId) {
+          // Register this surfaceId so subsequent lookups are O(1)
+          c.surfaceState.set(surfaceId, state);
+          return c;
+        }
+      }
+    }
+  }
+
+  return undefined;
+}
+
+export function conversationCount(): number {
+  return conversations.size;
+}
+
+/** Iterate over all active conversations. */
+export function allConversations(): IterableIterator<Conversation> {
+  return conversations.values();
+}
+
+/** Iterate over all [id, conversation] entries. */
+export function conversationEntries(): IterableIterator<
+  [string, Conversation]
+> {
+  return conversations.entries();
+}
+
+/** Iterate over all active conversation IDs. */
+export function conversationIds(): IterableIterator<string> {
+  return conversations.keys();
+}
+
+// ── Write helpers ──────────────────────────────────────────────────
+
+export function setConversation(
+  conversationId: string,
+  conversation: Conversation,
+): void {
+  conversations.set(conversationId, conversation);
+}
+
+export function deleteConversation(conversationId: string): boolean {
+  return conversations.delete(conversationId);
+}
+
+export function clearConversations(): void {
+  conversations.clear();
+}
+
+// ── Underlying Map (for the evictor, which takes a mutable ref) ───
+
+/**
+ * Expose the raw Map for the {@link ConversationEvictor}, which needs
+ * a mutable reference to delete entries during sweeps. No other code
+ * should use this — prefer the named helpers above.
+ */
+export function getConversationMap(): Map<string, Conversation> {
+  return conversations;
+}
+
+// ── Subagent live-conversation index ───────────────────────────────
+//
+// Subagents run their own agent loop — and therefore the injector chain — but
+// are owned by the `SubagentManager` rather than the daemon's eviction-managed
+// store, so they are deliberately absent from `conversations` above. This
+// point-lookup index lets the per-conversation injectors (workspace context,
+// disk-pressure warning) resolve a subagent's live `Conversation` by id and
+// read state off it. It is intentionally excluded from the iteration accessors
+// and the evictor map so subagent lifecycle stays solely with the manager.
+
+const subagentConversations = new Map<string, Conversation>();
+
+/** Register a subagent's live conversation for point lookups. */
+export function setSubagentConversation(
+  conversationId: string,
+  conversation: Conversation,
+): void {
+  subagentConversations.set(conversationId, conversation);
+}
+
+/**
+ * Remove a subagent's conversation from the index. Guards against clobbering a
+ * newer registration for the same id by only deleting when the stored entry
+ * still points at this instance.
+ */
+export function removeSubagentConversation(
+  conversationId: string,
+  conversation: Conversation,
+): void {
+  if (subagentConversations.get(conversationId) === conversation) {
+    subagentConversations.delete(conversationId);
+  }
+}
+
+/**
+ * Resolve a live `Conversation` by id, including subagent conversations.
+ * Top-level conversations are checked first, then subagents. Used by the
+ * per-conversation injectors, which run for subagent turns too; other callers
+ * should use {@link findConversation}, which is scoped to the eviction-managed
+ * top-level conversations.
+ */
+export function findConversationOrSubagent(
+  conversationId: string | undefined,
+): Conversation | undefined {
+  if (!conversationId) return undefined;
+  return (
+    conversations.get(conversationId) ??
+    subagentConversations.get(conversationId)
+  );
+}