@vellumai/assistant 0.4.48 → 0.4.50

package/src/context/image-dimensions.ts

@@ -0,0 +1,229 @@
+/**
+ * Parses image dimensions from base64-encoded image data by reading binary headers.
+ * Supports PNG, JPEG, GIF, and WebP formats.
+ * Returns null if parsing fails for any reason (corrupt, truncated, unrecognized).
+ */
+export function parseImageDimensions(
+  base64Data: string,
+  mediaType: string,
+): { width: number; height: number } | null {
+  try {
+    switch (mediaType) {
+      case "image/png":
+        return parsePng(base64Data);
+      case "image/jpeg":
+        return parseJpeg(base64Data);
+      case "image/gif":
+        return parseGif(base64Data);
+      case "image/webp":
+        return parseWebp(base64Data);
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}
+
+function decodeBase64Bytes(
+  base64Data: string,
+  maxBytes: number,
+): Buffer | null {
+  // Estimate how much base64 we need: every 4 base64 chars = 3 bytes
+  const charsNeeded = Math.ceil((maxBytes * 4) / 3);
+  const slice = base64Data.slice(0, charsNeeded + 4); // a little extra for padding
+  try {
+    const buf = Buffer.from(slice, "base64");
+    return buf.length > 0 ? buf : null;
+  } catch {
+    return null;
+  }
+}
+
+function readUint32BE(buf: Buffer, offset: number): number {
+  if (offset + 4 > buf.length) return -1;
+  return buf.readUInt32BE(offset);
+}
+
+function readUint16BE(buf: Buffer, offset: number): number {
+  if (offset + 2 > buf.length) return -1;
+  return buf.readUInt16BE(offset);
+}
+
+function readUint16LE(buf: Buffer, offset: number): number {
+  if (offset + 2 > buf.length) return -1;
+  return buf.readUInt16LE(offset);
+}
+
+function readUint32LE(buf: Buffer, offset: number): number {
+  if (offset + 4 > buf.length) return -1;
+  return buf.readUInt32LE(offset);
+}
+
+function readUint24LE(buf: Buffer, offset: number): number {
+  if (offset + 3 > buf.length) return -1;
+  return buf[offset]! | (buf[offset + 1]! << 8) | (buf[offset + 2]! << 16);
+}
+
+function parsePng(
+  base64Data: string,
+): { width: number; height: number } | null {
+  const buf = decodeBase64Bytes(base64Data, 32);
+  if (!buf || buf.length < 24) return null;
+
+  // Validate PNG signature: 89 50 4E 47
+  if (
+    buf[0] !== 0x89 ||
+    buf[1] !== 0x50 ||
+    buf[2] !== 0x4e ||
+    buf[3] !== 0x47
+  ) {
+    return null;
+  }
+
+  const width = readUint32BE(buf, 16);
+  const height = readUint32BE(buf, 20);
+  if (width <= 0 || height <= 0) return null;
+
+  return { width, height };
+}
+
+function parseJpeg(
+  base64Data: string,
+): { width: number; height: number } | null {
+  // Scan up to 1 MiB to handle JPEGs with large EXIF/ICC metadata before the SOF marker
+  const buf = decodeBase64Bytes(base64Data, 1_048_576);
+  if (!buf || buf.length < 2) return null;
+
+  // Validate JPEG SOI marker
+  if (buf[0] !== 0xff || buf[1] !== 0xd8) return null;
+
+  let offset = 2;
+  while (offset < buf.length - 1) {
+    // Find next marker
+    if (buf[offset] !== 0xff) {
+      offset++;
+      continue;
+    }
+
+    // Skip padding 0xFF bytes
+    while (offset < buf.length && buf[offset] === 0xff) {
+      offset++;
+    }
+    if (offset >= buf.length) return null;
+
+    const marker = buf[offset]!;
+    offset++;
+
+    // Check for SOF markers: C0-CF excluding C4 (DHT) and CC (DAC)
+    if (
+      marker >= 0xc0 &&
+      marker <= 0xcf &&
+      marker !== 0xc4 &&
+      marker !== 0xcc
+    ) {
+      // SOF marker found: skip 2-byte length + 1-byte precision
+      if (offset + 7 > buf.length) return null;
+      const height = readUint16BE(buf, offset + 3);
+      const width = readUint16BE(buf, offset + 5);
+      if (width <= 0 || height <= 0) return null;
+      return { width, height };
+    }
+
+    // Skip this marker's payload
+    if (offset + 1 >= buf.length) return null;
+    const segmentLength = readUint16BE(buf, offset);
+    if (segmentLength < 2) return null;
+    offset += segmentLength;
+  }
+
+  return null;
+}
+
+function parseGif(
+  base64Data: string,
+): { width: number; height: number } | null {
+  const buf = decodeBase64Bytes(base64Data, 12);
+  if (!buf || buf.length < 10) return null;
+
+  // Validate GIF signature: 47 49 46 38 (GIF8)
+  if (
+    buf[0] !== 0x47 ||
+    buf[1] !== 0x49 ||
+    buf[2] !== 0x46 ||
+    buf[3] !== 0x38
+  ) {
+    return null;
+  }
+
+  const width = readUint16LE(buf, 6);
+  const height = readUint16LE(buf, 8);
+  if (width <= 0 || height <= 0) return null;
+
+  return { width, height };
+}
+
+function parseWebp(
+  base64Data: string,
+): { width: number; height: number } | null {
+  const buf = decodeBase64Bytes(base64Data, 32);
+  if (!buf || buf.length < 16) return null;
+
+  // Validate RIFF signature
+  if (
+    buf[0] !== 0x52 ||
+    buf[1] !== 0x49 ||
+    buf[2] !== 0x46 ||
+    buf[3] !== 0x46
+  ) {
+    return null;
+  }
+  // Validate WEBP signature at offset 8
+  if (
+    buf[8] !== 0x57 ||
+    buf[9] !== 0x45 ||
+    buf[10] !== 0x42 ||
+    buf[11] !== 0x50
+  ) {
+    return null;
+  }
+
+  // Identify sub-format at offset 12
+  const subFormat =
+    String.fromCharCode(buf[12]!) +
+    String.fromCharCode(buf[13]!) +
+    String.fromCharCode(buf[14]!) +
+    String.fromCharCode(buf[15]!);
+
+  if (subFormat === "VP8 ") {
+    // VP8 lossy
+    if (buf.length < 30) return null;
+    const width = readUint16LE(buf, 26) & 0x3fff;
+    const height = readUint16LE(buf, 28) & 0x3fff;
+    if (width <= 0 || height <= 0) return null;
+    return { width, height };
+  }
+
+  if (subFormat === "VP8L") {
+    // VP8L lossless — validate signature byte 0x2f at offset 20
+    if (buf.length < 25) return null;
+    if (buf[20] !== 0x2f) return null;
+    const bits = readUint32LE(buf, 21);
+    if (bits < 0) return null;
+    const width = (bits & 0x3fff) + 1;
+    const height = ((bits >> 14) & 0x3fff) + 1;
+    if (width <= 0 || height <= 0) return null;
+    return { width, height };
+  }
+
+  if (subFormat === "VP8X") {
+    // VP8X extended
+    if (buf.length < 30) return null;
+    const width = readUint24LE(buf, 24) + 1;
+    const height = readUint24LE(buf, 27) + 1;
+    if (width <= 0 || height <= 0) return null;
+    return { width, height };
+  }
+
+  return null;
+}

package/src/context/token-estimator.ts

@@ -1,4 +1,5 @@
 import type { ContentBlock, Message } from "../providers/types.js";
+import { parseImageDimensions } from "./image-dimensions.js";
 
 const CHARS_PER_TOKEN = 4;
 const MESSAGE_OVERHEAD_TOKENS = 4;
@@ -12,6 +13,22 @@ const OTHER_BLOCK_TOKENS = 16;
 const SYSTEM_PROMPT_OVERHEAD_TOKENS = 8;
 const GEMINI_INLINE_FILE_MIME_TYPES = new Set(["application/pdf"]);
 
+// Anthropic scales images to fit within 1568x1568 maintaining aspect ratio,
+// then charges ~(width * height) / 750 tokens.
+const ANTHROPIC_IMAGE_MAX_DIMENSION = 1568;
+const ANTHROPIC_IMAGE_TOKENS_PER_PIXEL = 1 / 750;
+const ANTHROPIC_IMAGE_MAX_TOKENS = Math.ceil(
+  ANTHROPIC_IMAGE_MAX_DIMENSION *
+    ANTHROPIC_IMAGE_MAX_DIMENSION *
+    ANTHROPIC_IMAGE_TOKENS_PER_PIXEL,
+); // ~3,277 tokens
+
+// Anthropic renders each PDF page as an image (~1,568 tokens at standard
+// resolution) plus any extracted text. Typical PDF pages are 50-150 KB.
+// Using ~100 KB/page and ~1,600 tokens/page gives ~0.016 tokens/byte.
+const ANTHROPIC_PDF_TOKENS_PER_BYTE = 0.016;
+const ANTHROPIC_PDF_MIN_TOKENS = 1600; // At least one page
+
 export interface TokenEstimatorOptions {
   providerName?: string;
 }
@@ -21,21 +38,69 @@ export function estimateTextTokens(text: string): number {
   return Math.ceil(text.length / CHARS_PER_TOKEN);
 }
 
-function shouldCountFileSourceData(
+function estimateAnthropicPdfTokens(base64Data: string): number {
+  const rawBytes = Math.ceil((base64Data.length * 3) / 4);
+  return Math.max(
+    ANTHROPIC_PDF_MIN_TOKENS,
+    Math.ceil(rawBytes * ANTHROPIC_PDF_TOKENS_PER_BYTE),
+  );
+}
+
+function estimateFileDataTokens(
   block: Extract<ContentBlock, { type: "file" }>,
   options?: TokenEstimatorOptions,
-): boolean {
-  if (options?.providerName !== "gemini") {
-    return false;
+): number {
+  const providerName = options?.providerName;
+
+  // Anthropic sends PDFs as native document blocks and renders each page as an image
+  if (
+    providerName === "anthropic" &&
+    block.source.media_type === "application/pdf"
+  ) {
+    return estimateAnthropicPdfTokens(block.source.data);
+  }
+
+  // Gemini sends certain file types inline as base64
+  if (
+    providerName === "gemini" &&
+    GEMINI_INLINE_FILE_MIME_TYPES.has(block.source.media_type)
+  ) {
+    return estimateTextTokens(block.source.data);
   }
-  return GEMINI_INLINE_FILE_MIME_TYPES.has(block.source.media_type);
+
+  return 0;
+}
+
+function estimateAnthropicImageTokens(width: number, height: number): number {
+  // Scale down to fit within 1568x1568 bounding box, maintaining aspect ratio
+  const scale = Math.min(
+    1,
+    ANTHROPIC_IMAGE_MAX_DIMENSION / Math.max(width, height),
+  );
+  const scaledWidth = Math.round(width * scale);
+  const scaledHeight = Math.round(height * scale);
+  return Math.max(
+    IMAGE_BLOCK_TOKENS, // minimum 1024
+    Math.ceil(scaledWidth * scaledHeight * ANTHROPIC_IMAGE_TOKENS_PER_PIXEL),
+  );
 }
 
-function estimateImageSourceDataTokens(
+function estimateImageTokens(
   block: Extract<ContentBlock, { type: "image" }>,
+  options?: TokenEstimatorOptions,
 ): number {
-  // Image payloads are carried inline as base64 for all currently supported
-  // providers, so estimator must scale with payload size (not fixed per image).
+  if (options?.providerName === "anthropic") {
+    const dims = parseImageDimensions(
+      block.source.data,
+      block.source.media_type,
+    );
+    if (dims) {
+      return estimateAnthropicImageTokens(dims.width, dims.height);
+    }
+    // Fallback: if dimensions can't be parsed, use Anthropic's max
+    return ANTHROPIC_IMAGE_MAX_TOKENS;
+  }
+  // Non-Anthropic: keep existing base64-size heuristic
   return estimateTextTokens(block.source.data);
 }
 
@@ -69,16 +134,14 @@ export function estimateContentBlockTokens(
         IMAGE_BLOCK_TOKENS,
         IMAGE_BLOCK_OVERHEAD_TOKENS +
           estimateTextTokens(block.source.media_type) +
-          estimateImageSourceDataTokens(block),
+          estimateImageTokens(block, options),
       );
     case "file":
       return (
         FILE_BLOCK_OVERHEAD_TOKENS +
         estimateTextTokens(block.source.filename) +
         estimateTextTokens(block.source.media_type) +
-        (shouldCountFileSourceData(block, options)
-          ? estimateTextTokens(block.source.data)
-          : 0) +
+        estimateFileDataTokens(block, options) +
         estimateTextTokens(block.extracted_text ?? "")
       );
     case "thinking":

package/src/context/window-manager.ts

@@ -83,21 +83,44 @@ export interface ContextWindowCompactOptions {
 
 export interface ContextWindowManagerOptions {
   provider: Provider;
-  systemPrompt: string;
+  systemPrompt: string | (() => string);
   config: ContextWindowConfig;
 }
 
 export class ContextWindowManager {
   private readonly provider: Provider;
-  private readonly systemPrompt: string;
+  private readonly _systemPrompt: string | (() => string);
   private readonly config: ContextWindowConfig;
+  /**
+   * Cached resolved system prompt. Lazily populated on first access via the
+   * `systemPrompt` getter and cleared after each compaction pass so the next
+   * pass picks up any prompt changes.
+   */
+  private _resolvedSystemPrompt: string | undefined;
 
   constructor(options: ContextWindowManagerOptions) {
     this.provider = options.provider;
-    this.systemPrompt = options.systemPrompt;
+    this._systemPrompt = options.systemPrompt;
     this.config = options.config;
   }
 
+  /** Lazily resolve and cache the system prompt for the duration of a compaction pass. */
+  private get systemPrompt(): string {
+    if (this._resolvedSystemPrompt !== undefined) {
+      return this._resolvedSystemPrompt;
+    }
+    const resolved =
+      typeof this._systemPrompt === "function"
+        ? this._systemPrompt()
+        : this._systemPrompt;
+    this._resolvedSystemPrompt = resolved;
+    return resolved;
+  }
+
+  private clearSystemPromptCache(): void {
+    this._resolvedSystemPrompt = undefined;
+  }
+
   /**
    * Cheap pre-check: returns whether the estimated token count exceeds
    * the compaction threshold, along with the estimated token count so
@@ -106,19 +129,35 @@ export class ContextWindowManager {
    */
   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 };
+    try {
+      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 };
+    } finally {
+      this.clearSystemPromptCache();
+    }
   }
 
   async maybeCompact(
     messages: Message[],
     signal?: AbortSignal,
     options?: ContextWindowCompactOptions,
+  ): Promise<ContextWindowResult> {
+    try {
+      return await this._maybeCompact(messages, signal, options);
+    } finally {
+      this.clearSystemPromptCache();
+    }
+  }
+
+  private async _maybeCompact(
+    messages: Message[],
+    signal?: AbortSignal,
+    options?: ContextWindowCompactOptions,
   ): Promise<ContextWindowResult> {
     const previousEstimatedInputTokens =
       options?.precomputedEstimate ??
@@ -632,7 +671,10 @@ function countPersistedMessages(messages: Message[]): number {
 function isToolResultOnly(message: Message): boolean {
   return (
     message.content.length > 0 &&
-    message.content.every((block) => block.type === "tool_result")
+    message.content.every(
+      (block) =>
+        block.type === "tool_result" || block.type === "web_search_tool_result",
+    )
   );
 }
 

package/src/daemon/assistant-attachments.ts

@@ -17,9 +17,6 @@ import {
 // Constants
 // ---------------------------------------------------------------------------
 
-/** Maximum number of attachments the assistant may emit per turn. */
-export const MAX_ASSISTANT_ATTACHMENTS = 5;
-
 /** Maximum size in bytes for a single assistant attachment (20 MB). */
 export const MAX_ASSISTANT_ATTACHMENT_BYTES = 20 * 1024 * 1024;
 
@@ -122,10 +119,9 @@ export interface ValidatedDrafts {
 }
 
 /**
- * Enforce per-turn attachment caps.
+ * Enforce per-attachment size cap.
  *
  * - Rejects individual drafts that exceed `MAX_ASSISTANT_ATTACHMENT_BYTES`.
- * - Truncates the list at `MAX_ASSISTANT_ATTACHMENTS`.
  */
 export function validateDrafts(
   drafts: AssistantAttachmentDraft[],
@@ -144,14 +140,6 @@ export function validateDrafts(
       continue;
     }
 
-    if (accepted.length >= MAX_ASSISTANT_ATTACHMENTS) {
-      warnings.push(
-        `Skipped attachment "${draft.filename}": ` +
-          `exceeded maximum of ${MAX_ASSISTANT_ATTACHMENTS} attachments per turn.`,
-      );
-      continue;
-    }
-
     accepted.push(draft);
   }
 

package/src/daemon/config-watcher.ts

@@ -3,7 +3,13 @@
  * Watches workspace files (config, prompts), protected directory
  * (trust rules, secret allowlist), and skills directories for changes.
  */
-import { existsSync, type FSWatcher, readdirSync, watch } from "node:fs";
+import {
+  existsSync,
+  type FSWatcher,
+  mkdirSync,
+  readdirSync,
+  watch,
+} from "node:fs";
 import { join } from "node:path";
 
 import { getConfig, invalidateConfigCache } from "../config/loader.js";
@@ -98,8 +104,14 @@ export class ConfigWatcher {
    * Start all file watchers. `onSessionEvict` is called when watched
    * files change and sessions need to be evicted for reload.
    * `onIdentityChanged` is called when IDENTITY.md changes on disk.
+   * `onMcpReload` is called when the MCP section of config.json changes
+   * or when a signal file appears in the workspace `signals/` directory.
    */
-  start(onSessionEvict: () => void, onIdentityChanged?: () => void): void {
+  start(
+    onSessionEvict: () => void,
+    onIdentityChanged?: () => void,
+    onMcpReload?: () => void,
+  ): void {
     const workspaceDir = getWorkspaceDir();
     const protectedDir = join(getRootDir(), "protected");
 
@@ -107,8 +119,17 @@ export class ConfigWatcher {
       "config.json": () => {
         if (this.suppressReload) return;
         try {
+          const prevConfig = getConfig();
+          const prevMcpFingerprint = JSON.stringify(prevConfig.mcp ?? {});
           const changed = this.refreshConfigFromSources();
-          if (changed) onSessionEvict();
+          if (changed) {
+            onSessionEvict();
+            const newConfig = getConfig();
+            const newMcpFingerprint = JSON.stringify(newConfig.mcp ?? {});
+            if (newMcpFingerprint !== prevMcpFingerprint) {
+              onMcpReload?.();
+            }
+          }
         } catch (err) {
           log.error(
             { err, configPath: join(workspaceDir, "config.json") },
@@ -185,6 +206,7 @@ export class ConfigWatcher {
       );
     }
 
+    this.startSignalsWatcher(onMcpReload);
     this.startSkillsWatchers(onSessionEvict);
   }
 
@@ -196,6 +218,42 @@ export class ConfigWatcher {
     this.watchers = [];
   }
 
+  private startSignalsWatcher(onMcpReload?: () => void): void {
+    const signalsDir = join(getWorkspaceDir(), "signals");
+    try {
+      if (!existsSync(signalsDir)) {
+        mkdirSync(signalsDir, { recursive: true });
+      }
+    } catch {
+      // If we can't create it, watching will also fail — handled below.
+    }
+
+    const signalHandlers: Record<string, () => void> = {
+      "mcp-reload": () => {
+        onMcpReload?.();
+      },
+    };
+
+    try {
+      const watcher = watch(signalsDir, (_eventType, filename) => {
+        if (!filename) return;
+        const file = String(filename);
+        if (!signalHandlers[file]) return;
+        this.debounceTimers.schedule(`signal:${file}`, () => {
+          log.info({ file }, "Signal file detected");
+          signalHandlers[file]();
+        });
+      });
+      this.watchers.push(watcher);
+      log.info({ dir: signalsDir }, "Watching signals directory");
+    } catch (err) {
+      log.warn(
+        { err, dir: signalsDir },
+        "Failed to watch signals directory. Signal-based reload will be unavailable.",
+      );
+    }
+  }
+
   private startSkillsWatchers(onSessionEvict: () => void): void {
     const skillsDir = getWorkspaceSkillsDir();
     if (!existsSync(skillsDir)) return;

package/src/daemon/daemon-control.ts

@@ -143,7 +143,7 @@ function healthCheckHost(host: string): string {
 /** 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> {
+export async function isHttpHealthy(): Promise<boolean> {
   const host = healthCheckHost(getRuntimeHttpHost());
   const port = getRuntimeHttpPort();
   try {