@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/daemon/conversation-history.ts

@@ -352,7 +352,8 @@ export interface HistoryConversationContext {
   readonly traceEmitter: TraceEmitter;
   /** @internal */ sendToClient: (msg: ServerMessage) => void;
   messages: Message[];
-  processing: boolean;
+  isProcessing(): boolean;
+  setProcessing(value: boolean): void;
   abortController: AbortController | null;
   currentRequestId?: string;
   runAgentLoop(
@@ -371,7 +372,7 @@ export interface HistoryConversationContext {
  * Returns the number of messages removed.
  */
 export function undo(conversation: HistoryConversationContext): number {
-  if (conversation.processing) return 0;
+  if (conversation.isProcessing()) return 0;
 
   const lastUserIdx = findLastUndoableUserMessageIndex(conversation.messages);
   if (lastUserIdx === -1) return 0;
@@ -417,7 +418,7 @@ export async function regenerate(
   conversation: HistoryConversationContext,
   requestId?: string,
 ): Promise<void> {
-  if (conversation.processing) {
+  if (conversation.isProcessing()) {
     conversation.sendToClient({
       type: "error",
       conversationId: conversation.conversationId,
@@ -571,7 +572,7 @@ export async function regenerate(
   // Set up processing state manually and call runAgentLoop directly,
   // bypassing processMessage to avoid duplicating the user message
   // in both this.messages and the DB.
-  conversation.processing = true;
+  conversation.setProcessing(true);
   conversation.abortController = new AbortController();
   const resolvedRequestId = requestId ?? uuid();
   conversation.currentRequestId = resolvedRequestId;

package/src/daemon/conversation-lifecycle.ts

@@ -30,14 +30,13 @@ import { unregisterCallNotifiers } from "./conversation-notifiers.js";
 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 type {
   SurfaceData,
   SurfaceType,
   UsageStats,
 } from "./message-protocol.js";
 import { filterMessagesForUntrustedActor } from "./message-provenance.js";
-import type { TrustContext } from "./trust-context.js";
+import { resolveTrustClass, type TrustContext } from "./trust-context.js";
 
 const log = getLogger("conversation-lifecycle");
 
@@ -89,7 +88,7 @@ export interface LoadFromDbContext {
 
 export interface AbortContext {
   readonly conversationId: string;
-  processing: boolean;
+  isProcessing(): boolean;
   abortController: AbortController | null;
   prompter: PermissionPrompter;
   secretPrompter: SecretPrompter;
@@ -364,7 +363,7 @@ export function abortConversation(
   ctx: AbortContext,
   reason?: AbortReason,
 ): void {
-  if (ctx.processing) {
+  if (ctx.isProcessing()) {
     const effectiveReason =
       reason ??
       createAbortReason(

package/src/daemon/conversation-messaging.ts

@@ -187,7 +187,8 @@ function resolveIngressSecretTarget(
 export interface MessagingConversationContext {
   readonly conversationId: string;
   messages: Message[];
-  processing: boolean;
+  isProcessing(): boolean;
+  setProcessing(value: boolean): void;
   abortController: AbortController | null;
   currentRequestId?: string;
   readonly queue: MessageQueue;
@@ -323,7 +324,7 @@ export function enqueueMessage(
     clientMessageId,
   } = options;
 
-  if (!ctx.processing) {
+  if (!ctx.isProcessing()) {
     return { queued: false, requestId };
   }
 
@@ -384,7 +385,7 @@ export async function persistUserMessage(
 ): Promise<{ id: string; deduplicated: boolean }> {
   const { content, attachments = [] } = options;
 
-  if (ctx.processing) {
+  if (ctx.isProcessing()) {
     throw new Error("Conversation is already processing a message");
   }
 
@@ -394,7 +395,7 @@ export async function persistUserMessage(
 
   const reqId = options.requestId ?? uuid();
   ctx.currentRequestId = reqId;
-  ctx.processing = true;
+  ctx.setProcessing(true);
   ctx.abortController = new AbortController();
 
   try {
@@ -404,13 +405,13 @@ export async function persistUserMessage(
       requestId: reqId,
     });
     if (result.deduplicated) {
-      ctx.processing = false;
+      ctx.setProcessing(false);
       ctx.abortController = null;
       ctx.currentRequestId = undefined;
     }
     return result;
   } catch (err) {
-    ctx.processing = false;
+    ctx.setProcessing(false);
     ctx.abortController = null;
     ctx.currentRequestId = undefined;
     throw err;

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;
@@ -203,9 +204,7 @@ export interface ProcessConversationContext {
     },
   ): 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. */
@@ -757,9 +756,7 @@ async function drainSingleMessage(
       conversation.emitActivityState("thinking", "context_compacting", {
         requestId: next.requestId,
       });
-      const result = await conversation.forceCompact({
-        targetInputTokensOverride: slashResult.targetInputTokensOverride,
-      });
+      const result = await conversation.forceCompact();
       const responseText = formatCompactResult(result);
 
       const assistantMsg = createAssistantMessage(responseText);
@@ -1022,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: {
@@ -1215,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;
@@ -1732,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();
@@ -1773,9 +1770,7 @@ export async function processMessage(
       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);
@@ -1809,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();
@@ -1888,7 +1883,7 @@ export async function processMessage(
       }
       throw err;
     } finally {
-      conversation.processing = false;
+      conversation.setProcessing(false);
       await drainQueue(conversation);
     }
   }

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)
+  );
+}