@vellumai/assistant 0.4.26 → 0.4.29

package/src/daemon/context-overflow-reducer.ts

@@ -0,0 +1,300 @@
+/**
+ * Deterministic context overflow reducer.
+ *
+ * Given a message history that exceeds the provider's context limit, this
+ * module applies a sequence of monotonically more aggressive reduction tiers
+ * until the estimated token count fits within a target budget.
+ *
+ * Each tier is idempotent: re-applying the same tier to already-reduced
+ * messages is a no-op. Tiers are ordered so that less destructive
+ * transformations are tried first.
+ *
+ * Tier progression:
+ *   1. Forced compaction (emergency keep-boundary options)
+ *   2. Aggressive tool-result text truncation across retained history
+ *   3. Media/file payload stubbing (replace images/files with text stubs)
+ *   4. Runtime injection downgrade to minimal mode
+ */
+
+import type { ContextWindowConfig } from "../config/types.js";
+import { estimatePromptTokens } from "../context/token-estimator.js";
+import { truncateToolResultsAcrossHistory } from "../context/tool-result-truncation.js";
+import type {
+  ContextWindowCompactOptions,
+  ContextWindowResult,
+} from "../context/window-manager.js";
+import type { Message } from "../providers/types.js";
+import {
+  countMediaBlocks,
+  stripMediaPayloadsForRetry,
+} from "./session-media-retry.js";
+import type { InjectionMode } from "./session-runtime-assembly.js";
+
+/**
+ * Identifies which reduction tier was applied in a given step.
+ */
+export type ReducerTier =
+  | "forced_compaction"
+  | "tool_result_truncation"
+  | "media_stubbing"
+  | "injection_downgrade";
+
+/**
+ * Tracks the cumulative state of the reducer across successive calls.
+ * Callers pass this back in on each iteration so the reducer knows
+ * which tiers have already been applied.
+ */
+export interface ReducerState {
+  /** The last tier that was successfully applied. */
+  appliedTiers: ReducerTier[];
+  /** The injection mode to use for the next provider call. */
+  injectionMode: InjectionMode;
+  /** The compaction options used during forced compaction, if any. */
+  compactionOptions?: ContextWindowCompactOptions;
+  /** The max chars used for tool-result truncation, if applied. */
+  toolResultMaxChars?: number;
+  /** Whether the reducer has exhausted all tiers. */
+  exhausted: boolean;
+}
+
+/**
+ * The result of a single reducer step.
+ */
+export interface ReducerStepResult {
+  /** The reduced messages (may be identical to input if tier was a no-op). */
+  messages: Message[];
+  /** The tier that was applied in this step. */
+  tier: ReducerTier;
+  /** Updated state to pass into the next call. */
+  state: ReducerState;
+  /** Estimated prompt tokens after this step's reduction. */
+  estimatedTokens: number;
+  /**
+   * If this step used forced compaction, the compaction result is attached
+   * so the caller can persist summary text and compacted message counts.
+   */
+  compactionResult?: ContextWindowResult;
+}
+
+/**
+ * Configuration for the reducer.
+ */
+export interface ReducerConfig {
+  /** Provider name for token estimation. */
+  providerName: string;
+  /** The system prompt (needed for accurate token estimation). */
+  systemPrompt: string;
+  /** The context window config from the assistant config. */
+  contextWindow: ContextWindowConfig;
+  /** Target token budget — the reducer tries to get below this. */
+  targetTokens: number;
+}
+
+/**
+ * Compaction callback — the reducer does not own the ContextWindowManager
+ * instance, so the caller provides a function that performs compaction.
+ */
+export type CompactFn = (
+  messages: Message[],
+  signal: AbortSignal | undefined,
+  options: ContextWindowCompactOptions,
+) => Promise<ContextWindowResult>;
+
+// Aggressive truncation cap for tool results during overflow recovery.
+// Much tighter than the normal per-result budget.
+const OVERFLOW_TOOL_RESULT_MAX_CHARS = 4_000;
+
+/**
+ * Determine the next reduction step to apply.
+ *
+ * The caller invokes this repeatedly, feeding the returned state back in,
+ * until either the estimated tokens are within budget or `state.exhausted`
+ * is true.
+ */
+export async function reduceContextOverflow(
+  messages: Message[],
+  config: ReducerConfig,
+  state: ReducerState | undefined,
+  compactFn: CompactFn,
+  signal?: AbortSignal,
+): Promise<ReducerStepResult> {
+  const applied = state?.appliedTiers ?? [];
+
+  // Tier 1: forced compaction
+  if (!applied.includes("forced_compaction")) {
+    return applyForcedCompaction(messages, config, applied, compactFn, signal);
+  }
+
+  // Tier 2: aggressive tool-result truncation
+  if (!applied.includes("tool_result_truncation")) {
+    return applyToolResultTruncation(messages, config, applied, state);
+  }
+
+  // Tier 3: media/file payload stubbing
+  if (!applied.includes("media_stubbing")) {
+    return applyMediaStubbing(messages, config, applied, state);
+  }
+
+  // Tier 4: injection downgrade
+  if (!applied.includes("injection_downgrade")) {
+    return applyInjectionDowngrade(messages, config, applied, state);
+  }
+
+  // All tiers exhausted
+  const estimatedTokens = estimatePromptTokens(messages, config.systemPrompt, {
+    providerName: config.providerName,
+  });
+  return {
+    messages,
+    tier: "injection_downgrade",
+    state: {
+      appliedTiers: [...applied],
+      injectionMode: state?.injectionMode ?? "minimal",
+      exhausted: true,
+    },
+    estimatedTokens,
+  };
+}
+
+async function applyForcedCompaction(
+  messages: Message[],
+  config: ReducerConfig,
+  applied: ReducerTier[],
+  compactFn: CompactFn,
+  signal?: AbortSignal,
+): Promise<ReducerStepResult> {
+  const compactionOptions: ContextWindowCompactOptions = {
+    force: true,
+    minKeepRecentUserTurns: 0,
+    targetInputTokensOverride: config.targetTokens,
+  };
+
+  const result = await compactFn(messages, signal, compactionOptions);
+  const nextMessages = result.compacted ? result.messages : messages;
+  const estimatedTokens = result.compacted
+    ? result.estimatedInputTokens
+    : estimatePromptTokens(messages, config.systemPrompt, {
+        providerName: config.providerName,
+      });
+
+  const nextApplied: ReducerTier[] = [...applied, "forced_compaction"];
+  return {
+    messages: nextMessages,
+    tier: "forced_compaction",
+    state: {
+      appliedTiers: nextApplied,
+      injectionMode: "full",
+      compactionOptions,
+      exhausted: false,
+    },
+    estimatedTokens,
+    compactionResult: result,
+  };
+}
+
+function applyToolResultTruncation(
+  messages: Message[],
+  config: ReducerConfig,
+  applied: ReducerTier[],
+  prevState: ReducerState | undefined,
+): ReducerStepResult {
+  const { messages: truncated, truncatedCount } =
+    truncateToolResultsAcrossHistory(messages, OVERFLOW_TOOL_RESULT_MAX_CHARS);
+
+  const nextMessages = truncatedCount > 0 ? truncated : messages;
+  const estimatedTokens = estimatePromptTokens(
+    nextMessages,
+    config.systemPrompt,
+    { providerName: config.providerName },
+  );
+
+  const nextApplied: ReducerTier[] = [...applied, "tool_result_truncation"];
+  return {
+    messages: nextMessages,
+    tier: "tool_result_truncation",
+    state: {
+      appliedTiers: nextApplied,
+      injectionMode: prevState?.injectionMode ?? "full",
+      toolResultMaxChars: OVERFLOW_TOOL_RESULT_MAX_CHARS,
+      compactionOptions: prevState?.compactionOptions,
+      exhausted: false,
+    },
+    estimatedTokens,
+  };
+}
+
+function applyMediaStubbing(
+  messages: Message[],
+  config: ReducerConfig,
+  applied: ReducerTier[],
+  prevState: ReducerState | undefined,
+): ReducerStepResult {
+  const mediaCount = countMediaBlocks(messages);
+  let nextMessages = messages;
+
+  if (mediaCount > 0) {
+    const stripped = stripMediaPayloadsForRetry(messages);
+    if (stripped.modified) {
+      nextMessages = stripped.messages;
+    }
+  }
+
+  const estimatedTokens = estimatePromptTokens(
+    nextMessages,
+    config.systemPrompt,
+    { providerName: config.providerName },
+  );
+
+  const nextApplied: ReducerTier[] = [...applied, "media_stubbing"];
+  return {
+    messages: nextMessages,
+    tier: "media_stubbing",
+    state: {
+      appliedTiers: nextApplied,
+      injectionMode: prevState?.injectionMode ?? "full",
+      toolResultMaxChars: prevState?.toolResultMaxChars,
+      compactionOptions: prevState?.compactionOptions,
+      exhausted: false,
+    },
+    estimatedTokens,
+  };
+}
+
+function applyInjectionDowngrade(
+  messages: Message[],
+  config: ReducerConfig,
+  applied: ReducerTier[],
+  prevState: ReducerState | undefined,
+): ReducerStepResult {
+  // The injection downgrade itself does not modify messages — it signals
+  // to the caller that the next provider call should use minimal injection
+  // mode, which the caller applies via applyRuntimeInjections().
+  const estimatedTokens = estimatePromptTokens(messages, config.systemPrompt, {
+    providerName: config.providerName,
+  });
+
+  const nextApplied: ReducerTier[] = [...applied, "injection_downgrade"];
+  return {
+    messages,
+    tier: "injection_downgrade",
+    state: {
+      appliedTiers: nextApplied,
+      injectionMode: "minimal",
+      toolResultMaxChars: prevState?.toolResultMaxChars,
+      compactionOptions: prevState?.compactionOptions,
+      exhausted: true,
+    },
+    estimatedTokens,
+  };
+}
+
+/**
+ * Create the initial (empty) reducer state.
+ */
+export function createInitialReducerState(): ReducerState {
+  return {
+    appliedTiers: [],
+    injectionMode: "full",
+    exhausted: false,
+  };
+}

package/src/daemon/daemon-control.ts

@@ -1,19 +1,27 @@
-import { execSync, spawn } from 'node:child_process';
-import { closeSync,existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { createConnection } from 'node:net';
-import { join, resolve } from 'node:path';
-
-import { DaemonError } from '../util/errors.js';
-import { getLogger } from '../util/logger.js';
+import { execSync, spawn } from "node:child_process";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { createConnection } from "node:net";
+import { join, resolve } from "node:path";
+
+import { DaemonError } from "../util/errors.js";
+import { getLogger } from "../util/logger.js";
 import {
   getPidPath,
   getRootDir,
   getSocketPath,
   getWorkspaceConfigPath,
   removeSocketFile,
-} from '../util/platform.js';
+} from "../util/platform.js";
 
-const log = getLogger('lifecycle');
+const log = getLogger("lifecycle");
 
 const DAEMON_TIMEOUT_DEFAULTS = {
   startupSocketWaitMs: 5000,
@@ -25,7 +33,7 @@ const SOCKET_HEALTH_TIMEOUT_MS = 1500;
 const STARTUP_LOCK_STALE_MS = 30_000;
 
 function isPositiveInteger(v: unknown): v is number {
-  return typeof v === 'number' && Number.isInteger(v) && v > 0;
+  return typeof v === "number" && Number.isInteger(v) && v > 0;
 }
 
 /**
@@ -36,8 +44,8 @@ function isPositiveInteger(v: unknown): v is number {
  */
 function readDaemonTimeouts(): typeof DAEMON_TIMEOUT_DEFAULTS {
   try {
-    const raw = JSON.parse(readFileSync(getWorkspaceConfigPath(), 'utf-8'));
-    if (raw.daemon && typeof raw.daemon === 'object') {
+    const raw = JSON.parse(readFileSync(getWorkspaceConfigPath(), "utf-8"));
+    if (raw.daemon && typeof raw.daemon === "object") {
       return {
         startupSocketWaitMs: isPositiveInteger(raw.daemon.startupSocketWaitMs)
           ? raw.daemon.startupSocketWaitMs
@@ -73,7 +81,10 @@ function killStaleDaemon(): void {
   // Guard against stale PID reuse: if the PID has been recycled by the OS
   // and now belongs to an unrelated process, we must not signal it.
   if (!isVellumDaemonProcess(pid)) {
-    log.info({ pid }, 'PID file references a non-vellum process (stale PID reuse) — cleaning up PID file only');
+    log.info(
+      { pid },
+      "PID file references a non-vellum process (stale PID reuse) — cleaning up PID file only",
+    );
     cleanupPidFile();
     return;
   }
@@ -82,8 +93,8 @@ function killStaleDaemon(): void {
   // (called earlier in startDaemon) already returns early when the daemon is
   // healthy. If we reach here, the recorded process is alive but non-responsive.
   try {
-    log.info({ pid }, 'Killing stale daemon process from PID file');
-    process.kill(pid, 'SIGKILL');
+    log.info({ pid }, "Killing stale daemon process from PID file");
+    process.kill(pid, "SIGKILL");
   } catch {
     // Process may have exited between the check and the kill.
   }
@@ -107,13 +118,13 @@ function isProcessRunning(pid: number): boolean {
 function isVellumDaemonProcess(pid: number): boolean {
   try {
     const cmd = execSync(`ps -ww -p ${pid} -o command=`, {
-      encoding: 'utf-8',
+      encoding: "utf-8",
       timeout: 3000,
-      stdio: ['ignore', 'pipe', 'ignore'],
+      stdio: ["ignore", "pipe", "ignore"],
     }).trim();
     // The daemon is spawned as `bun run <path>/main.ts` — look for bun
     // running our daemon entry point.
-    return cmd.includes('bun') && cmd.includes('daemon/main.ts');
+    return cmd.includes("bun") && cmd.includes("daemon/main.ts");
   } catch {
     // Process exited or ps failed — treat as not ours.
     return false;
@@ -134,12 +145,12 @@ function isSocketResponsive(): Promise<boolean> {
       resolve(false);
     }, SOCKET_HEALTH_TIMEOUT_MS);
 
-    socket.on('connect', () => {
+    socket.on("connect", () => {
       clearTimeout(timer);
       socket.destroy();
       resolve(true);
     });
-    socket.on('error', () => {
+    socket.on("error", () => {
       clearTimeout(timer);
       socket.destroy();
       resolve(false);
@@ -151,7 +162,7 @@ function readPid(): number | null {
   const pidPath = getPidPath();
   if (!existsSync(pidPath)) return null;
   try {
-    const pid = parseInt(readFileSync(pidPath, 'utf-8').trim(), 10);
+    const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
     return isNaN(pid) ? null : pid;
   } catch {
     return null;
@@ -188,7 +199,10 @@ export function isDaemonRunning(): boolean {
   return true;
 }
 
-export async function getDaemonStatus(): Promise<{ running: boolean; pid?: number }> {
+export async function getDaemonStatus(): Promise<{
+  running: boolean;
+  pid?: number;
+}> {
   const pid = readPid();
   if (pid == null) return { running: false };
   if (!isProcessRunning(pid)) {
@@ -198,7 +212,10 @@ export async function getDaemonStatus(): Promise<{ running: boolean; pid?: numbe
   // Guard against stale PID reuse: if the OS recycled the PID and it now
   // belongs to an unrelated process, discard the stale PID file.
   if (!isVellumDaemonProcess(pid)) {
-    log.info({ pid }, 'PID file references a non-vellum process (stale PID reuse) — cleaning up');
+    log.info(
+      { pid },
+      "PID file references a non-vellum process (stale PID reuse) — cleaning up",
+    );
     cleanupPidFile();
     return { running: false };
   }
@@ -208,14 +225,14 @@ export async function getDaemonStatus(): Promise<{ running: boolean; pid?: numbe
   // killStaleDaemon() can clean it up.
   const responsive = await isSocketResponsive();
   if (!responsive) {
-    log.warn({ pid }, 'Daemon process alive but socket unresponsive');
+    log.warn({ pid }, "Daemon process alive but socket unresponsive");
     return { running: false, pid };
   }
   return { running: true, pid };
 }
 
 function getStartupLockPath(): string {
-  return join(getRootDir(), 'daemon-startup.lock');
+  return join(getRootDir(), "daemon-startup.lock");
 }
 
 /** Attempt to acquire a startup lock. Returns true on success. Stale locks
@@ -230,12 +247,12 @@ function acquireStartupLock(): boolean {
     // "lock already held."
     mkdirSync(getRootDir(), { recursive: true });
     // O_CREAT | O_EXCL — fails atomically if the file already exists.
-    writeFileSync(lockPath, String(Date.now()), { flag: 'wx' });
+    writeFileSync(lockPath, String(Date.now()), { flag: "wx" });
     return true;
   } catch {
     // Lock file exists — check for staleness.
     try {
-      const ts = parseInt(readFileSync(lockPath, 'utf-8').trim(), 10);
+      const ts = parseInt(readFileSync(lockPath, "utf-8").trim(), 10);
       if (!isNaN(ts) && Date.now() - ts > STARTUP_LOCK_STALE_MS) {
         unlinkSync(lockPath);
         return acquireStartupLock();
@@ -248,7 +265,11 @@ function acquireStartupLock(): boolean {
 }
 
 function releaseStartupLock(): void {
-  try { unlinkSync(getStartupLockPath()); } catch { /* already removed */ }
+  try {
+    unlinkSync(getStartupLockPath());
+  } catch {
+    /* already removed */
+  }
 }
 
 // NOTE: startDaemon() is the assistant-side daemon lifecycle manager.
@@ -266,7 +287,7 @@ export async function startDaemon(): Promise<{
   // Serialize concurrent startup attempts. If another caller already holds
   // the lock, wait for it to finish and then re-check daemon status.
   if (!acquireStartupLock()) {
-    log.info('Another startup in progress, waiting for lock');
+    log.info("Another startup in progress, waiting for lock");
     const lockWaitMs = 10_000;
     const lockInterval = 200;
     let lockWaited = 0;
@@ -286,7 +307,9 @@ export async function startDaemon(): Promise<{
       if (recheck.running && recheck.pid) {
         return { pid: recheck.pid, alreadyRunning: true };
       }
-      throw new DaemonError('Timed out waiting for concurrent daemon startup to finish');
+      throw new DaemonError(
+        "Timed out waiting for concurrent daemon startup to finish",
+      );
     }
     // Acquired the lock after waiting — re-check in case the other caller
     // already started the daemon successfully.
@@ -326,21 +349,18 @@ async function startDaemonLocked(): Promise<{
   removeSocketFile(socketPath);
 
   // Spawn the daemon as a detached child process
-  const mainPath = resolve(
-    import.meta.dirname ?? __dirname,
-    'main.ts',
-  );
+  const mainPath = resolve(import.meta.dirname ?? __dirname, "main.ts");
 
   // Redirect the child's stderr to a file instead of piping it back to the
   // parent. A pipe's read end is destroyed when the parent exits, leaving
   // fd 2 broken in the child. Bun (unlike Node.js) does not ignore SIGPIPE,
   // so any later stderr write would silently kill the daemon.
-  const stderrPath = join(rootDir, 'daemon-stderr.log');
-  const stderrFd = openSync(stderrPath, 'w');
+  const stderrPath = join(rootDir, "daemon-stderr.log");
+  const stderrFd = openSync(stderrPath, "w");
 
-  const child = spawn('bun', ['run', mainPath], {
+  const child = spawn("bun", ["run", mainPath], {
     detached: true,
-    stdio: ['ignore', 'ignore', stderrFd],
+    stdio: ["ignore", "ignore", stderrFd],
     env: { ...process.env },
   });
 
@@ -349,7 +369,7 @@ async function startDaemonLocked(): Promise<{
 
   let childExited = false;
   let childExitCode: number | null = null;
-  child.on('exit', (code) => {
+  child.on("exit", (code) => {
     childExited = true;
     childExitCode = code;
   });
@@ -358,7 +378,7 @@ async function startDaemonLocked(): Promise<{
 
   const pid = child.pid;
   if (!pid) {
-    throw new DaemonError('Failed to start daemon: no PID returned');
+    throw new DaemonError("Failed to start daemon: no PID returned");
   }
 
   // Wait for socket to appear before writing the PID file. Writing it
@@ -374,12 +394,14 @@ async function startDaemonLocked(): Promise<{
       return { pid, alreadyRunning: false };
     }
     if (childExited) {
-      const stderr = readFileSync(stderrPath, 'utf-8').trim();
+      const stderr = readFileSync(stderrPath, "utf-8").trim();
       const detail = stderr
         ? `\n${stderr}`
         : `\nCheck logs at ~/.vellum/workspace/data/logs/ for details.`;
       throw new DaemonError(
-        `Daemon exited immediately (code ${childExitCode ?? 'unknown'}).${detail}`,
+        `Daemon exited immediately (code ${
+          childExitCode ?? "unknown"
+        }).${detail}`,
       );
     }
     await new Promise((r) => setTimeout(r, interval));
@@ -397,25 +419,28 @@ async function startDaemonLocked(): Promise<{
 
 export type StopResult =
   | { stopped: true }
-  | { stopped: false; reason: 'not_running' | 'stop_failed' };
+  | { stopped: false; reason: "not_running" | "stop_failed" };
 
 export async function stopDaemon(): Promise<StopResult> {
   const pid = readPid();
   if (pid == null || !isProcessRunning(pid)) {
     cleanupPidFile();
-    return { stopped: false, reason: 'not_running' };
+    return { stopped: false, reason: "not_running" };
   }
 
   // Guard against stale PID reuse: if the PID has been recycled by the OS
   // and now belongs to an unrelated process, clean up the PID file but
   // never signal it.
   if (!isVellumDaemonProcess(pid)) {
-    log.info({ pid }, 'PID file references a non-vellum process (stale PID reuse) — cleaning up PID file only');
+    log.info(
+      { pid },
+      "PID file references a non-vellum process (stale PID reuse) — cleaning up PID file only",
+    );
     cleanupPidFile();
-    return { stopped: false, reason: 'not_running' };
+    return { stopped: false, reason: "not_running" };
   }
 
-  process.kill(pid, 'SIGTERM');
+  process.kill(pid, "SIGTERM");
 
   const timeouts = readDaemonTimeouts();
 
@@ -434,9 +459,9 @@ export async function stopDaemon(): Promise<StopResult> {
 
   // Force kill
   try {
-    process.kill(pid, 'SIGKILL');
+    process.kill(pid, "SIGKILL");
   } catch (err) {
-    log.debug({ err, pid }, 'SIGKILL failed, process already exited');
+    log.debug({ err, pid }, "SIGKILL failed, process already exited");
   }
 
   // Wait for the process to actually die after SIGKILL. Without this,
@@ -459,8 +484,11 @@ export async function stopDaemon(): Promise<StopResult> {
     return { stopped: true };
   }
 
-  log.warn({ pid }, 'Daemon process still running after SIGKILL + timeout, leaving socket and PID file intact');
-  return { stopped: false, reason: 'stop_failed' };
+  log.warn(
+    { pid },
+    "Daemon process still running after SIGKILL + timeout, leaving socket and PID file intact",
+  );
+  return { stopped: false, reason: "stop_failed" };
 }
 
 export async function ensureDaemonRunning(): Promise<void> {