@vellumai/assistant 0.4.41 → 0.4.43

package/src/context/window-manager.ts

@@ -45,10 +45,18 @@ export interface ContextWindowResult {
   summaryInputTokens: number;
   summaryOutputTokens: number;
   summaryModel: string;
+  summaryCacheCreationInputTokens?: number;
+  summaryCacheReadInputTokens?: number;
+  summaryRawResponses?: unknown[];
   summaryText: string;
   reason?: string;
 }
 
+export interface ShouldCompactResult {
+  needed: boolean;
+  estimatedTokens: number;
+}
+
 export interface ContextWindowCompactOptions {
   lastCompactedAt?: number;
   /** Bypass the threshold check and force compaction. Used for context-too-large error recovery. */
@@ -66,25 +74,58 @@ export interface ContextWindowCompactOptions {
    * than the normal `config.targetInputTokens` during forced recovery.
    */
   targetInputTokensOverride?: number;
+  /**
+   * Pre-computed token estimate from a prior `shouldCompact()` call.
+   * When provided, `maybeCompact()` skips its own `estimatePromptTokens()`
+   * call, avoiding a redundant O(history) tokenization pass.
+   */
+  precomputedEstimate?: number;
+}
+
+export interface ContextWindowManagerOptions {
+  provider: Provider;
+  systemPrompt: string;
+  config: ContextWindowConfig;
 }
 
 export class ContextWindowManager {
-  constructor(
-    private readonly provider: Provider,
-    private readonly systemPrompt: string,
-    private readonly config: ContextWindowConfig,
-  ) {}
+  private readonly provider: Provider;
+  private readonly systemPrompt: string;
+  private readonly config: ContextWindowConfig;
+
+  constructor(options: ContextWindowManagerOptions) {
+    this.provider = options.provider;
+    this.systemPrompt = options.systemPrompt;
+    this.config = options.config;
+  }
+
+  /**
+   * Cheap pre-check: returns whether the estimated token count exceeds
+   * the compaction threshold, along with the estimated token count so
+   * callers can pass it into `maybeCompact()` via `precomputedEstimate`
+   * to avoid a redundant tokenization pass.
+   */
+  shouldCompact(messages: Message[]): ShouldCompactResult {
+    if (!this.config.enabled) return { needed: false, estimatedTokens: 0 };
+    const estimated = estimatePromptTokens(messages, this.systemPrompt, {
+      providerName: this.provider.name,
+    });
+    const threshold = Math.floor(
+      this.config.maxInputTokens * this.config.compactThreshold,
+    );
+    return { needed: estimated >= threshold, estimatedTokens: estimated };
+  }
 
   async maybeCompact(
     messages: Message[],
     signal?: AbortSignal,
     options?: ContextWindowCompactOptions,
   ): Promise<ContextWindowResult> {
-    const previousEstimatedInputTokens = estimatePromptTokens(
-      messages,
-      this.systemPrompt,
-      { providerName: this.provider.name },
-    );
+    const previousEstimatedInputTokens =
+      options?.precomputedEstimate ??
+      estimatePromptTokens(messages, this.systemPrompt, {
+        providerName: this.provider.name,
+      });
     const thresholdTokens = Math.floor(
       this.config.maxInputTokens * this.config.compactThreshold,
     );
@@ -298,6 +339,9 @@ export class ContextWindowManager {
     let summaryInputTokens = 0;
     let summaryOutputTokens = 0;
     let summaryModel = "";
+    let summaryCacheCreationInputTokens = 0;
+    let summaryCacheReadInputTokens = 0;
+    const summaryRawResponses: unknown[] = [];
     let summaryCalls = 0;
 
     for (const chunk of chunks) {
@@ -306,6 +350,13 @@ export class ContextWindowManager {
       summaryInputTokens += summaryUpdate.inputTokens;
       summaryOutputTokens += summaryUpdate.outputTokens;
       summaryModel = summaryUpdate.model || summaryModel;
+      summaryCacheCreationInputTokens += summaryUpdate.cacheCreationInputTokens;
+      summaryCacheReadInputTokens += summaryUpdate.cacheReadInputTokens;
+      if (Array.isArray(summaryUpdate.rawResponse)) {
+        summaryRawResponses.push(...summaryUpdate.rawResponse);
+      } else if (summaryUpdate.rawResponse !== undefined) {
+        summaryRawResponses.push(summaryUpdate.rawResponse);
+      }
       summaryCalls += 1;
     }
 
@@ -387,6 +438,9 @@ export class ContextWindowManager {
       summaryInputTokens,
       summaryOutputTokens,
       summaryModel,
+      summaryCacheCreationInputTokens,
+      summaryCacheReadInputTokens,
+      summaryRawResponses,
       summaryText: summary,
     };
   }
@@ -451,6 +505,9 @@ export class ContextWindowManager {
     inputTokens: number;
     outputTokens: number;
     model: string;
+    cacheCreationInputTokens: number;
+    cacheReadInputTokens: number;
+    rawResponse?: unknown;
   }> {
     const prompt = buildSummaryPrompt(currentSummary, chunk);
     try {
@@ -471,6 +528,10 @@ export class ContextWindowManager {
           inputTokens: response.usage.inputTokens,
           outputTokens: response.usage.outputTokens,
           model: response.model,
+          cacheCreationInputTokens:
+            response.usage.cacheCreationInputTokens ?? 0,
+          cacheReadInputTokens: response.usage.cacheReadInputTokens ?? 0,
+          rawResponse: response.rawResponse,
         };
       }
     } catch (err) {
@@ -482,6 +543,8 @@ export class ContextWindowManager {
       inputTokens: 0,
       outputTokens: 0,
       model: "",
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0,
     };
   }
 }
@@ -527,10 +590,6 @@ export function getSummaryFromContextMessage(
   if (INTERNAL_CONTEXT_SUMMARY_MESSAGES.has(message)) {
     return stripContextSummaryTags(text);
   }
-  // Backward compatibility for older in-memory sessions that used assistant-role summaries.
-  if (message.role === "assistant") {
-    return stripContextSummaryTags(text);
-  }
   return null;
 }
 

package/src/daemon/assistant-attachments.ts

@@ -340,6 +340,15 @@ export function drainDirectiveDisplayBuffer(
         (nextChar === "\n" || nextChar === "\r")
       ) {
         emitText = emitText.slice(0, -1); // trim \n
+      } else if (
+        nextChar !== undefined &&
+        !/\s/.test(emitText[emitText.length - 1] ?? "") &&
+        !/\s/.test(nextChar)
+      ) {
+        // Inline directive with no surrounding whitespace — insert a space
+        // so the text on either side doesn't get smashed together (e.g.
+        // "down.Let" → "down. Let").
+        emitText += " ";
       }
     }
 

package/src/daemon/computer-use-session.ts

@@ -9,11 +9,11 @@
 import { v4 as uuid } from "uuid";
 
 import { AgentLoop } from "../agent/loop.js";
-import { buildComputerUseSystemPrompt } from "../config/computer-use-prompt.js";
 import { getConfig } from "../config/loader.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { UserDecision } from "../permissions/types.js";
+import { buildComputerUseSystemPrompt } from "../prompts/computer-use-prompt.js";
 import type {
   ContentBlock,
   Message,
@@ -34,8 +34,8 @@ import type {
   SurfaceData,
   SurfaceType,
   UiSurfaceShow,
-} from "./ipc-protocol.js";
-import { INTERACTIVE_SURFACE_TYPES } from "./ipc-protocol.js";
+} from "./message-protocol.js";
+import { INTERACTIVE_SURFACE_TYPES } from "./message-protocol.js";
 import {
   projectSkillTools,
   resetSkillToolProjection,

package/src/daemon/connection-policy.ts

@@ -1,28 +1,16 @@
 /**
  * Connection policy helpers for daemon autostart and authentication behavior.
  *
- * When the user targets a remote/forwarded socket via VELLUM_DAEMON_SOCKET,
- * autostart should be disabled by default to avoid accidentally spawning
- * a local daemon. VELLUM_DAEMON_AUTOSTART=1 forces autostart regardless.
- *
- * Token authentication is always required, even with a socket override.
- * To explicitly disable auth (e.g. SSH-forwarded sockets where the client
- * can't read the remote token file), set VELLUM_DAEMON_NOAUTH=1 on both
- * the daemon and the client. This is an intentional opt-in to an unsafe
- * mode — never enable it on sockets accessible to untrusted users.
+ * Token authentication is always required.
+ * To explicitly disable auth (e.g. development/testing scenarios),
+ * set VELLUM_DAEMON_NOAUTH=1 on both the daemon and the client.
+ * This is an intentional opt-in to an unsafe mode — never enable it
+ * on connections accessible to untrusted users.
  */
 
-export function hasSocketOverride(
-  env: Record<string, string | undefined> = process.env,
-): boolean {
-  const override = env.VELLUM_DAEMON_SOCKET?.trim();
-  return !!override;
-}
-
 /**
  * True when the user has explicitly opted into unauthenticated connections
- * via VELLUM_DAEMON_NOAUTH=1. This is separate from the socket override
- * so that using a custom socket path alone does NOT bypass token auth.
+ * via VELLUM_DAEMON_NOAUTH=1.
  *
  * Requires VELLUM_UNSAFE_AUTH_BYPASS=1 as a safety gate to prevent
  * accidental production use.
@@ -61,9 +49,6 @@ export function shouldAutoStartDaemon(
   if (autostart === "1" || autostart === "true") return true;
   if (autostart === "0" || autostart === "false") return false;
 
-  // No explicit flag: disable autostart when using a remote/custom socket
-  if (hasSocketOverride(env)) return false;
-
   // Default: autostart enabled
   return true;
 }

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

@@ -1,4 +1,4 @@
-import type { ContextOverflowRecoveryConfig } from "../config/core-schema.js";
+import type { ContextOverflowRecoveryConfig } from "../config/schemas/inference.js";
 
 /**
  * Actions the overflow recovery loop can take when the context window is

package/src/daemon/daemon-control.ts

@@ -8,17 +8,15 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs";
-import { createConnection } from "node:net";
 import { join, resolve } from "node:path";
 
+import { getRuntimeHttpHost, getRuntimeHttpPort } from "../config/env.js";
 import { DaemonError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import {
   getPidPath,
   getRootDir,
-  getSocketPath,
   getWorkspaceConfigPath,
-  removeSocketFile,
 } from "../util/platform.js";
 
 const log = getLogger("lifecycle");
@@ -29,7 +27,7 @@ const DAEMON_TIMEOUT_DEFAULTS = {
   sigkillGracePeriodMs: 2000,
 };
 
-const SOCKET_HEALTH_TIMEOUT_MS = 1500;
+const HEALTH_CHECK_TIMEOUT_MS = 1500;
 const STARTUP_LOCK_STALE_MS = 30_000;
 
 function isPositiveInteger(v: unknown): v is number {
@@ -131,31 +129,31 @@ function isVellumDaemonProcess(pid: number): boolean {
   }
 }
 
-/** Try a TCP connect to the Unix socket. Returns true if the connection
- *  handshake completes within the timeout — false on connection refused,
- *  timeout, or missing socket file. */
-function isSocketResponsive(): Promise<boolean> {
-  const socketPath = getSocketPath();
-  if (!existsSync(socketPath)) return Promise.resolve(false);
-
-  return new Promise((resolve) => {
-    const socket = createConnection(socketPath);
-    const timer = setTimeout(() => {
-      socket.destroy();
-      resolve(false);
-    }, SOCKET_HEALTH_TIMEOUT_MS);
-
-    socket.on("connect", () => {
-      clearTimeout(timer);
-      socket.destroy();
-      resolve(true);
-    });
-    socket.on("error", () => {
-      clearTimeout(timer);
-      socket.destroy();
-      resolve(false);
+/** Normalize a bind address to a connectable host for health checks.
+ *  Wildcard addresses (0.0.0.0, ::) bind all interfaces but aren't
+ *  connectable on all platforms — substitute loopback. IPv6 literals
+ *  need brackets in URLs. */
+function healthCheckHost(host: string): string {
+  if (host === "0.0.0.0") return "127.0.0.1";
+  if (host === "::") return "[::1]";
+  if (host.includes(":")) return `[${host}]`;
+  return host;
+}
+
+/** Hit the daemon's HTTP /healthz endpoint. Returns true if it responds
+ *  with HTTP 200 within the timeout — false on connection refused, timeout,
+ *  or any other error. */
+async function isHttpHealthy(): Promise<boolean> {
+  const host = healthCheckHost(getRuntimeHttpHost());
+  const port = getRuntimeHttpPort();
+  try {
+    const response = await fetch(`http://${host}:${port}/healthz`, {
+      signal: AbortSignal.timeout(HEALTH_CHECK_TIMEOUT_MS),
     });
-  });
+    return response.ok;
+  } catch {
+    return false;
+  }
 }
 
 function readPid(): number | null {
@@ -219,13 +217,13 @@ export async function getDaemonStatus(): Promise<{
     cleanupPidFile();
     return { running: false };
   }
-  // Process is alive and is ours — verify the socket is responsive. A
+  // Process is alive and is ours — verify HTTP /healthz is responsive. A
   // deadlocked or wedged daemon will pass the PID liveness check but fail
   // to accept connections, and should be treated as not running so
   // killStaleDaemon() can clean it up.
-  const responsive = await isSocketResponsive();
+  const responsive = await isHttpHealthy();
   if (!responsive) {
-    log.warn({ pid }, "Daemon process alive but socket unresponsive");
+    log.warn({ pid }, "Daemon process alive but HTTP health check unresponsive");
     return { running: false, pid };
   }
   return { running: true, pid };
@@ -335,7 +333,7 @@ async function startDaemonLocked(): Promise<{
   // a crash where the process is alive but non-responsive).
   killStaleDaemon();
 
-  // Only create the root dir for socket/PID — the daemon process itself
+  // Only create the root dir for PID files — the daemon process itself
   // handles migration + full ensureDataDir() in runDaemon(). Calling
   // ensureDataDir() here would pre-create workspace destination dirs
   // and cause migration moves to no-op.
@@ -344,10 +342,6 @@ async function startDaemonLocked(): Promise<{
     mkdirSync(rootDir, { recursive: true });
   }
 
-  // Clean up stale socket (only if it's actually a Unix socket)
-  const socketPath = getSocketPath();
-  removeSocketFile(socketPath);
-
   // Spawn the daemon as a detached child process
   const mainPath = resolve(import.meta.dirname ?? __dirname, "main.ts");
 
@@ -381,18 +375,14 @@ async function startDaemonLocked(): Promise<{
     throw new DaemonError("Failed to start daemon: no PID returned");
   }
 
-  // Wait for socket to appear before writing the PID file. Writing it
-  // earlier would leave an orphaned PID file if the daemon crashes during
+  // Wait for HTTP /healthz to respond before writing the PID file. Writing
+  // it earlier would leave an orphaned PID file if the daemon crashes during
   // initialization — callers would think the daemon is still running.
   const timeouts = readDaemonTimeouts();
   const maxWait = timeouts.startupSocketWaitMs;
-  const interval = 100;
+  const interval = 200;
   let waited = 0;
   while (waited < maxWait) {
-    if (existsSync(socketPath)) {
-      writePid(pid);
-      return { pid, alreadyRunning: false };
-    }
     if (childExited) {
       const stderr = readFileSync(stderrPath, "utf-8").trim();
       const detail = stderr
@@ -404,16 +394,20 @@ async function startDaemonLocked(): Promise<{
         }).${detail}`,
       );
     }
+    if (await isHttpHealthy()) {
+      writePid(pid);
+      return { pid, alreadyRunning: false };
+    }
     await new Promise((r) => setTimeout(r, interval));
     waited += interval;
   }
 
-  // The child process is still running but the socket hasn't appeared yet.
-  // Write the PID file so isDaemonRunning()/stopDaemon() can still track
-  // and manage the orphaned process.
+  // The child process is still running but the HTTP health check hasn't
+  // passed yet. Write the PID file so isDaemonRunning()/stopDaemon() can
+  // still track and manage the orphaned process.
   writePid(pid);
   throw new DaemonError(
-    `Daemon started but socket not available after ${maxWait}ms`,
+    `Daemon started but health check not responding after ${maxWait}ms`,
   );
 }
 
@@ -465,8 +459,7 @@ export async function stopDaemon(): Promise<StopResult> {
   }
 
   // Wait for the process to actually die after SIGKILL. Without this,
-  // startDaemon() can race with the dying process's shutdown handler,
-  // which removes the socket file and bricks the new daemon.
+  // startDaemon() can race with the dying process's shutdown handler.
   const killMaxWait = timeouts.sigkillGracePeriodMs;
   let killWaited = 0;
   while (killWaited < killMaxWait && isProcessRunning(pid)) {
@@ -475,18 +468,17 @@ export async function stopDaemon(): Promise<StopResult> {
   }
 
   // Only clean up if the process has actually exited.
-  // If it's still alive after SIGKILL + timeout, preserve both socket
-  // and PID file so isDaemonRunning() still reports true and prevents
-  // a duplicate daemon from being spawned.
+  // If it's still alive after SIGKILL + timeout, preserve the PID file
+  // so isDaemonRunning() still reports true and prevents a duplicate
+  // daemon from being spawned.
   if (!isProcessRunning(pid)) {
-    removeSocketFile(getSocketPath());
     cleanupPidFile();
     return { stopped: true };
   }
 
   log.warn(
     { pid },
-    "Daemon process still running after SIGKILL + timeout, leaving socket and PID file intact",
+    "Daemon process still running after SIGKILL + timeout, leaving PID file intact",
   );
   return { stopped: false, reason: "stop_failed" };
 }

package/src/daemon/doordash-steps.ts

@@ -6,7 +6,7 @@
  */
 
 import { isPlainObject } from "../util/object.js";
-import type { CardSurfaceData } from "./ipc-contract.js";
+import type { CardSurfaceData } from "./message-protocol.js";
 import type { ToolSetupContext } from "./session-tool-setup.js";
 
 interface DoordashStep {