@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091853.fbaa2ae

package/src/daemon/conversation-process.ts

@@ -12,14 +12,12 @@ import {
   createUserMessage,
 } from "../agent/message-types.js";
 import {
-  type InterfaceId,
   parseChannelId,
   parseInterfaceId,
   type TurnChannelContext,
   type TurnInterfaceContext,
 } from "../channels/types.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
-import type { ContextWindowResult } from "../context/window-manager.js";
 import { listPendingRequestsByConversationScope } from "../memory/canonical-guardian-store.js";
 import {
   addMessage,
@@ -29,22 +27,19 @@ import {
 } from "../memory/conversation-crud.js";
 import { extractPreferences } from "../notifications/preference-extractor.js";
 import { createPreference } from "../notifications/preferences-store.js";
-import type { Message } from "../providers/types.js";
+import type { ContextWindowResult } from "../plugins/defaults/compaction/window-manager.js";
 import { routeGuardianReply } from "../runtime/guardian-reply-router.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
-import type { CleanResult } from "./conversation.js";
-import type { PersistMessageOptions } from "./conversation-messaging.js";
+import type { CleanResult, Conversation } from "./conversation.js";
 import {
   persistQueuedMessageBody,
   serializePersistedUserMessageContent,
 } from "./conversation-messaging.js";
 import type {
-  MessageQueue,
   QueuedMessage,
   QueueDrainReason,
 } from "./conversation-queue-manager.js";
-import type { ChannelCapabilities } from "./conversation-runtime-assembly.js";
 import {
   buildSlashContextForContent,
   classifySlash,
@@ -55,13 +50,9 @@ import { getModelInfo } from "./handlers/config-model.js";
 import { preactivateHostProxySkills } from "./host-proxy-preactivation.js";
 import type {
   ServerMessage,
-  UsageStats,
   UserMessageAttachment,
 } from "./message-protocol.js";
-import type { ConversationTransportMetadata } from "./message-types/conversations.js";
-import type { TraceEmitter } from "./trace-emitter.js";
 import { buildTransportHints } from "./transport-hints.js";
-import type { TrustContext } from "./trust-context.js";
 import { resolveVerificationSessionIntent } from "./verification-session-intent.js";
 
 const log = getLogger("conversation-process");
@@ -117,123 +108,6 @@ export function isModelSlashCommand(content: string): boolean {
   return content.trim() === "/models";
 }
 
-// ── Context Interface ────────────────────────────────────────────────
-
-/**
- * Subset of Conversation state that drainQueue / processMessage need access to.
- * The Conversation class implements this interface so its instances can be
- * passed directly to the extracted functions.
- */
-export interface ProcessConversationContext {
-  readonly conversationId: string;
-  messages: Message[];
-  isProcessing(): boolean;
-  setProcessing(value: boolean): void;
-  abortController: AbortController | null;
-  currentRequestId?: string;
-  readonly queue: MessageQueue;
-  readonly traceEmitter: TraceEmitter;
-  /**
-   * Set of requestIds created by surface-action responses. Used to
-   * distinguish surface-action turns from regular user turns (e.g. for
-   * stale-surface auto-dismiss guards and batched-drain exclusion).
-   */
-  readonly surfaceActionRequestIds: Set<string>;
-  currentActiveSurfaceId?: string;
-  currentPage?: string;
-  /** When true, the drain path should inject synthetic tool_result messages
-   *  for any pending tool_use blocks abandoned by a steered abort. */
-  pendingSteerRepair?: boolean;
-  /** Cumulative token usage stats for the conversation. */
-  readonly usageStats: UsageStats;
-  /** Request-scoped skill IDs preactivated via config or programmatic injection. */
-  preactivatedSkillIds?: string[];
-  /** Add a skill ID to the preactivated set without replacing existing entries. */
-  addPreactivatedSkillId(id: string): void;
-  /** Assistant identity — used for scoping notification preferences. */
-  readonly assistantId?: string;
-  trustContext?: TrustContext;
-  channelCapabilities?: ChannelCapabilities;
-  /** Per-turn snapshot of trustContext, frozen at message-processing start. */
-  currentTurnTrustContext?: TrustContext;
-  /** Per-turn snapshot of channelCapabilities, frozen at message-processing start. */
-  currentTurnChannelCapabilities?: ChannelCapabilities;
-  ensureActorScopedHistory(): Promise<void>;
-  persistUserMessage(
-    options: PersistMessageOptions,
-  ): Promise<{ id: string; deduplicated: boolean }>;
-  runAgentLoop(
-    content: string,
-    userMessageId: string,
-    options?: {
-      onEvent?: (msg: ServerMessage) => void;
-      isInteractive?: boolean;
-      isUserMessage?: boolean;
-      titleText?: string;
-      callSite?: LLMCallSite;
-    },
-  ): Promise<void>;
-  getTurnChannelContext(): TurnChannelContext | null;
-  setTurnChannelContext(ctx: TurnChannelContext): void;
-  getTurnInterfaceContext(): TurnInterfaceContext | null;
-  setTurnInterfaceContext(ctx: TurnInterfaceContext): void;
-  emitActivityState(
-    phase:
-      | "idle"
-      | "thinking"
-      | "streaming"
-      | "tool_running"
-      | "awaiting_confirmation",
-    reason:
-      | "message_dequeued"
-      | "thinking_delta"
-      | "first_text_delta"
-      | "tool_use_start"
-      | "tool_result_received"
-      | "confirmation_requested"
-      | "confirmation_resolved"
-      | "message_complete"
-      | "generation_cancelled"
-      | "error_terminal"
-      | "preview_start"
-      | "context_compacting",
-    options?: {
-      anchor?: "assistant_turn" | "user_turn" | "global";
-      requestId?: string;
-      statusText?: string;
-    },
-  ): void;
-  /** Force context compaction regardless of threshold/cooldown. */
-  forceCompact(): Promise<ContextWindowResult>;
-  /** Strip runtime injections and reset memory-injection state. */
-  forceClean(): Promise<CleanResult>;
-  /** Set transport-derived hints for the conversation. */
-  setTransportHints(hints: string[] | undefined): void;
-  /** IANA timezone reported by the active client for the current turn. */
-  clientTimezone?: string;
-  /**
-   * Apply client-reported host env (home dir, username) from transport
-   * metadata, gating on `supportsHostProxy` so non-host-proxy interfaces
-   * clear any stale values. Shared between the create/reuse path in
-   * `DaemonServer.applyTransportMetadata` and the queue-drain path below.
-   */
-  applyHostEnvFromTransport(transport: ConversationTransportMetadata): void;
-  /** Apply the per-turn client timezone reported by transport metadata. */
-  applyClientTimezoneFromTransport(
-    transport: ConversationTransportMetadata,
-  ): void;
-  /**
-   * Instantiate host proxies for capabilities that have become reachable
-   * mid-queue (e.g. a macOS client connected after a web turn was enqueued
-   * 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,
-    sourceActorPrincipalId?: string,
-  ): void;
-}
-
 function resolveQueuedTurnContext(
   queued: {
     turnChannelContext?: TurnChannelContext;
@@ -281,7 +155,7 @@ function resolveQueuedTurnInterfaceContext(
 /** Build a SlashContext from the current conversation state and config. */
 function buildSlashContext(
   content: string,
-  conversation: ProcessConversationContext,
+  conversation: Conversation,
 ): SlashContext | undefined {
   const turnInterface = conversation.getTurnInterfaceContext();
   return buildSlashContextForContent(content, {
@@ -306,7 +180,7 @@ function buildSlashContext(
  * accounting centralized in `MessageQueue` rather than mutating mid-walk.
  */
 async function buildPassthroughBatch(
-  conversation: ProcessConversationContext,
+  conversation: Conversation,
 ): Promise<QueuedMessage[]> {
   const head = conversation.queue.peek(0);
   if (head === undefined) return [];
@@ -348,6 +222,8 @@ async function buildPassthroughBatch(
     // otherwise diverge.
     if (candIf?.userMessageInterface !== headInterface?.userMessageInterface)
       break;
+    if (candidate.sourceActorPrincipalId !== head.sourceActorPrincipalId)
+      break;
     if (classifySlash(candidate.content) !== "passthrough") break;
     if (
       resolveVerificationSessionIntent(candidate.content).kind ===
@@ -379,9 +255,7 @@ async function buildPassthroughBatch(
  * history and injects synthetic error `tool_result` messages for any
  * unmatched `tool_use` blocks.
  */
-function repairPendingToolUseBlocks(
-  conversation: ProcessConversationContext,
-): void {
+function repairPendingToolUseBlocks(conversation: Conversation): void {
   if (!conversation.pendingSteerRepair) return;
   conversation.pendingSteerRepair = false;
 
@@ -452,7 +326,7 @@ function repairPendingToolUseBlocks(
  * remaining queued messages would be stranded.
  */
 export async function drainQueue(
-  conversation: ProcessConversationContext,
+  conversation: Conversation,
   reason: QueueDrainReason = "loop_complete",
 ): Promise<void> {
   // After a steer, drain only the promoted head message — don't batch
@@ -485,7 +359,7 @@ export async function drainQueue(
 }
 
 async function drainSingleMessage(
-  conversation: ProcessConversationContext,
+  conversation: Conversation,
   next: QueuedMessage,
   reason: QueueDrainReason,
 ): Promise<void> {
@@ -550,6 +424,9 @@ async function drainSingleMessage(
     conversation.applyClientTimezoneFromTransport(next.transport);
   }
 
+  conversation.currentTurnAuthContext = next.authContext;
+  conversation.currentTurnSourceActorPrincipalId = next.sourceActorPrincipalId;
+
   // Re-attach and re-preactivate host-proxy skills for interactive turns.
   // The dequeue path reset `preactivatedSkillIds` above; without these
   // re-adds the relevant skill tools won't be projected to the LLM for
@@ -561,8 +438,7 @@ async function drainSingleMessage(
     const interfaceCtx =
       queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
     const sourceInterface = interfaceCtx?.userMessageInterface;
-    const sourceActorPrincipalId =
-      conversation.trustContext?.guardianPrincipalId;
+    const sourceActorPrincipalId = next.sourceActorPrincipalId;
     conversation.ensureHostProxiesForTurn(
       sourceInterface,
       sourceActorPrincipalId,
@@ -1059,7 +935,7 @@ async function drainSingleMessage(
 // runAgentLoop run. Per-message dequeue events and DB persistence are
 // preserved; the agent reply fans out to every batched client.
 async function drainBatch(
-  conversation: ProcessConversationContext,
+  conversation: Conversation,
   batch: QueuedMessage[],
   reason: QueueDrainReason,
 ): Promise<void> {
@@ -1107,14 +983,16 @@ async function drainBatch(
     conversation.applyClientTimezoneFromTransport(head.transport);
   }
 
+  conversation.currentTurnAuthContext = head.authContext;
+  conversation.currentTurnSourceActorPrincipalId = head.sourceActorPrincipalId;
+
   // Re-attach and re-preactivate host-proxy skills for interactive turns.
   // Mirrors the single-message path exactly — sourced from `head`.
   if (head.isInteractive !== false) {
     const interfaceCtx =
       queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
     const sourceInterface = interfaceCtx?.userMessageInterface;
-    const sourceActorPrincipalId =
-      conversation.trustContext?.guardianPrincipalId;
+    const sourceActorPrincipalId = head.sourceActorPrincipalId;
     conversation.ensureHostProxiesForTurn(
       sourceInterface,
       sourceActorPrincipalId,
@@ -1490,7 +1368,7 @@ export interface ProcessMessageOptions {
  * in a single call. Used by the message-handler path where blocking is expected.
  */
 export async function processMessage(
-  conversation: ProcessConversationContext,
+  conversation: Conversation,
   options: ProcessMessageOptions,
 ): Promise<string> {
   const {
@@ -1508,6 +1386,9 @@ export async function processMessage(
   // 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.
   conversation.currentTurnTrustContext = conversation.trustContext;
+  conversation.currentTurnAuthContext = conversation.authContext;
+  conversation.currentTurnSourceActorPrincipalId =
+    conversation.authContext?.actorPrincipalId;
   conversation.currentTurnChannelCapabilities =
     conversation.channelCapabilities;
   conversation.currentActiveSurfaceId = activeSurfaceId;

package/src/daemon/conversation-queue-manager.ts

@@ -9,6 +9,7 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
+import type { AuthContext } from "../runtime/auth/types.js";
 import { getLogger } from "../util/logger.js";
 import type {
   ServerMessage,
@@ -30,6 +31,10 @@ export interface QueuedMessage {
   turnInterfaceContext?: TurnInterfaceContext;
   /** When false, the turn has no interactive user and should skip clarification prompts. */
   isInteractive?: boolean;
+  /** Requester identity captured from the verified auth context at enqueue time. */
+  sourceActorPrincipalId?: string;
+  /** Full auth snapshot captured at enqueue time for turn-scoped authorization decisions. */
+  authContext?: AuthContext;
   /** Transport metadata snapshot captured at enqueue time, applied when this message becomes active. */
   transport?: ConversationTransportMetadata;
   /** Original user message text to persist to DB when recording intent stripping produced a different `content`. */
@@ -204,6 +209,9 @@ function estimateItemBytes(item: QueuedMessage): number {
   if (item.transport) {
     bytes += JSON.stringify(item.transport).length * 2;
   }
+  if (item.sourceActorPrincipalId) {
+    bytes += item.sourceActorPrincipalId.length * 2;
+  }
   // Small fixed overhead for metadata, pointers, etc. (not worth
   // measuring precisely — the content/attachment data dominates).
   bytes += 512;

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