@vellumai/assistant 0.5.16 → 0.6.1

package/src/config/schema.ts

@@ -3,6 +3,11 @@ import { z } from "zod";
 import { getDataDir } from "../util/platform.js";
 
 // Re-export all domain schemas
+export type { PermissionMode } from "../permissions/permission-mode.js";
+export {
+  DEFAULT_PERMISSION_MODE,
+  PermissionModeSchema,
+} from "../permissions/permission-mode.js";
 export type { AcpAgentConfig, AcpConfig } from "./acp-schema.js";
 export { AcpAgentConfigSchema, AcpConfigSchema } from "./acp-schema.js";
 export type {
@@ -143,6 +148,7 @@ export type {
 export {
   PermissionsConfigSchema,
   SecretDetectionConfigSchema,
+  VALID_PERMISSIONS_MODES,
 } from "./schemas/security.js";
 export type {
   ImageGenerationService,
@@ -197,6 +203,7 @@ import {
   WhatsAppConfigSchema,
 } from "./schemas/channels.js";
 import { ElevenLabsConfigSchema } from "./schemas/elevenlabs.js";
+import { FilingConfigSchema } from "./schemas/filing.js";
 import { FishAudioConfigSchema } from "./schemas/fish-audio.js";
 import { HeartbeatConfigSchema } from "./schemas/heartbeat.js";
 import {
@@ -272,6 +279,7 @@ export const AssistantConfigSchema = z
       .describe(
         "Custom pricing overrides for specific provider/model combinations",
       ),
+    filing: FilingConfigSchema.default(FilingConfigSchema.parse({})),
     heartbeat: HeartbeatConfigSchema.default(HeartbeatConfigSchema.parse({})),
     journal: JournalConfigSchema.default(JournalConfigSchema.parse({})),
     mcp: McpConfigSchema.default(McpConfigSchema.parse({})),

package/src/config/schemas/filing.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+
+import { SpeedSchema } from "./inference.js";
+
+export const FilingConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "filing.enabled must be a boolean" })
+      .default(true)
+      .describe(
+        "Whether periodic PKB filing is enabled — processes buffer.md into topic files and reviews knowledge base organization",
+      ),
+    intervalMs: z
+      .number({ error: "filing.intervalMs must be a number" })
+      .int("filing.intervalMs must be an integer")
+      .positive("filing.intervalMs must be a positive integer")
+      .default(4 * 3_600_000)
+      .describe("Time between filing runs in milliseconds"),
+    speed: SpeedSchema.default("standard").describe(
+      "Inference speed mode for filing conversations",
+    ),
+    activeHoursStart: z
+      .number({ error: "filing.activeHoursStart must be a number" })
+      .int("filing.activeHoursStart must be an integer")
+      .min(0, "filing.activeHoursStart must be >= 0")
+      .max(23, "filing.activeHoursStart must be <= 23")
+      .default(8)
+      .describe("Hour of the day (0-23) when filing runs begin"),
+    activeHoursEnd: z
+      .number({ error: "filing.activeHoursEnd must be a number" })
+      .int("filing.activeHoursEnd must be an integer")
+      .min(0, "filing.activeHoursEnd must be >= 0")
+      .max(23, "filing.activeHoursEnd must be <= 23")
+      .default(22)
+      .describe("Hour of the day (0-23) when filing runs stop"),
+  })
+  .describe(
+    "Periodic PKB (personal knowledge base) filing — processes the buffer into topic files and maintains knowledge organization",
+  )
+  .superRefine((config, ctx) => {
+    if (config.activeHoursStart === config.activeHoursEnd) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["activeHoursEnd"],
+        message:
+          "filing.activeHoursStart and filing.activeHoursEnd must not be equal (would create an empty window)",
+      });
+    }
+  });
+
+export type FilingConfig = z.infer<typeof FilingConfigSchema>;

package/src/config/schemas/heartbeat.ts

@@ -12,7 +12,7 @@ export const HeartbeatConfigSchema = z
       .number({ error: "heartbeat.intervalMs must be a number" })
       .int("heartbeat.intervalMs must be an integer")
       .positive("heartbeat.intervalMs must be a positive integer")
-      .default(3_600_000)
+      .default(6 * 3_600_000)
       .describe("Time between heartbeat checks in milliseconds"),
     speed: SpeedSchema.default("standard").describe(
       "Inference speed mode for heartbeat conversations — defaults to standard to avoid inheriting the global fast mode multiplier",
@@ -22,35 +22,38 @@ export const HeartbeatConfigSchema = z
       .int("heartbeat.activeHoursStart must be an integer")
       .min(0, "heartbeat.activeHoursStart must be >= 0")
       .max(23, "heartbeat.activeHoursStart must be <= 23")
-      .optional()
+      .nullable()
+      .default(8)
       .describe(
-        "Hour of the day (0-23) when heartbeat checks begin — must be set together with activeHoursEnd",
+        "Hour of the day (0-23) when heartbeat checks begin, or null to disable active hours restriction",
       ),
     activeHoursEnd: z
       .number({ error: "heartbeat.activeHoursEnd must be a number" })
       .int("heartbeat.activeHoursEnd must be an integer")
       .min(0, "heartbeat.activeHoursEnd must be >= 0")
       .max(23, "heartbeat.activeHoursEnd must be <= 23")
-      .optional()
+      .nullable()
+      .default(22)
       .describe(
-        "Hour of the day (0-23) when heartbeat checks stop — must be set together with activeHoursStart",
+        "Hour of the day (0-23) when heartbeat checks stop, or null to disable active hours restriction",
       ),
   })
   .describe("Periodic heartbeat configuration for health monitoring")
   .superRefine((config, ctx) => {
-    const hasStart = config.activeHoursStart != null;
-    const hasEnd = config.activeHoursEnd != null;
-    if (hasStart !== hasEnd) {
+    const startNull = config.activeHoursStart == null;
+    const endNull = config.activeHoursEnd == null;
+    if (startNull !== endNull) {
       ctx.addIssue({
         code: z.ZodIssueCode.custom,
-        path: [hasStart ? "activeHoursEnd" : "activeHoursStart"],
+        path: [startNull ? "activeHoursStart" : "activeHoursEnd"],
         message:
-          "heartbeat.activeHoursStart and heartbeat.activeHoursEnd must both be set or both be omitted",
+          "heartbeat.activeHoursStart and heartbeat.activeHoursEnd must both be set or both be null",
       });
+      return;
     }
     if (
-      hasStart &&
-      hasEnd &&
+      config.activeHoursStart != null &&
+      config.activeHoursEnd != null &&
       config.activeHoursStart === config.activeHoursEnd
     ) {
       ctx.addIssue({

package/src/config/schemas/memory-lifecycle.ts

@@ -72,6 +72,18 @@ export const MemoryCleanupConfigSchema = z
       .describe(
         "Number of days to retain conversation data before cleanup (0 disables pruning)",
       ),
+    llmRequestLogRetentionMs: z
+      .number({
+        error: "memory.cleanup.llmRequestLogRetentionMs must be a number",
+      })
+      .int("memory.cleanup.llmRequestLogRetentionMs must be an integer")
+      .nonnegative(
+        "memory.cleanup.llmRequestLogRetentionMs must be non-negative",
+      )
+      .default(7 * 24 * 60 * 60 * 1000)
+      .describe(
+        "Retention period for LLM request/response logs in milliseconds (0 disables pruning)",
+      ),
   })
   .describe("Automatic memory cleanup and garbage collection settings");
 

package/src/config/schemas/platform.ts

@@ -56,6 +56,14 @@ export const UiConfigSchema = z
       .describe(
         "IANA timezone identifier for displaying dates and times (e.g. 'America/New_York')",
       ),
+    greetingModelIntent: z
+      .enum(["latency-optimized", "quality-optimized"], {
+        error: "ui.greetingModelIntent must be 'latency-optimized' or 'quality-optimized'",
+      })
+      .default("latency-optimized")
+      .describe(
+        "Model intent for empty-state greeting generation (latency-optimized = fast/small model, quality-optimized = primary model)",
+      ),
   })
   .describe("User interface display settings");
 

package/src/config/schemas/security.ts

@@ -79,6 +79,20 @@ export const PermissionsConfigSchema = z
       .describe(
         "Permission mode — 'strict' requires explicit approval for all operations, 'workspace' allows operations within the workspace",
       ),
+    askBeforeActing: z
+      .boolean({
+        error: "permissions.askBeforeActing must be a boolean",
+      })
+      .default(true)
+      .describe("Whether the assistant should check in before taking actions"),
+    hostAccess: z
+      .boolean({
+        error: "permissions.hostAccess must be a boolean",
+      })
+      .default(false)
+      .describe(
+        "Whether the assistant can execute commands on the host machine without prompting",
+      ),
   })
   .describe("Permission enforcement mode for tool operations");
 

package/src/config/schemas/timeouts.ts

@@ -36,7 +36,7 @@ export const TimeoutConfigSchema = z
       .number({ error: "timeouts.providerStreamTimeoutSec must be a number" })
       .finite("timeouts.providerStreamTimeoutSec must be finite")
       .positive("timeouts.providerStreamTimeoutSec must be a positive number")
-      .default(300)
+      .default(1800)
       .describe(
         "Timeout for waiting on the LLM provider's streaming response (seconds)",
       ),

package/src/config/skills.ts

@@ -73,7 +73,6 @@ export interface SkillSummary {
   bundled?: boolean;
   icon?: string;
   emoji?: string;
-  homepage?: string;
   source: SkillSource;
   /** Parsed tool manifest metadata, if the skill has a valid TOOLS.json. */
   toolManifest?: SkillToolManifestMeta;
@@ -962,8 +961,9 @@ function isEscapingSymlink(filePath: string, rootDir: string): boolean {
 /**
  * Check for a `references/` subdirectory within a skill directory and return
  * a formatted listing of available `.md` reference files with full absolute
- * paths. Returns `null` if no references exist. Files are listed in
- * alphabetical order. Non-`.md` files are ignored. Symlinks that resolve
+ * paths. Returns `null` if no references exist. Files are discovered
+ * recursively through subdirectories and listed alphabetically within each
+ * directory level. Non-`.md` files are ignored. Symlinks that resolve
  * outside the skill directory are skipped.
  */
 export function listReferenceFiles(directoryPath: string): string | null {
@@ -977,10 +977,21 @@ export function listReferenceFiles(directoryPath: string): string | null {
       return null;
     }
 
-    const entries = readdirSync(refsDir);
+    const entries = readdirSync(refsDir, { recursive: true }) as string[];
     const mdFiles = entries
       .filter((f) => f.toLowerCase().endsWith(".md"))
-      .filter((f) => !isEscapingSymlink(join(refsDir, f), directoryPath))
+      .filter((f) => {
+        // Check the file itself
+        if (isEscapingSymlink(join(refsDir, f), directoryPath)) return false;
+        // Check all intermediate directory components (e.g. for "sub/dir/file.md"
+        // check "sub" and "sub/dir") to prevent traversal through symlinked dirs.
+        const parts = f.split("/");
+        for (let i = 1; i < parts.length; i++) {
+          const ancestor = join(refsDir, ...parts.slice(0, i));
+          if (isEscapingSymlink(ancestor, directoryPath)) return false;
+        }
+        return true;
+      })
       .sort((a, b) => a.localeCompare(b));
 
     if (mdFiles.length === 0) return null;
@@ -991,8 +1002,8 @@ export function listReferenceFiles(directoryPath: string): string | null {
       "The following reference files are available in this skill's directory. Use `file_read` to load any that are relevant to the current task:",
       "",
     ];
-    for (const filename of mdFiles) {
-      lines.push(`- \`${join(refsDir, filename)}\``);
+    for (const filepath of mdFiles) {
+      lines.push(`- \`${join(refsDir, filepath)}\` (references/${filepath})`);
     }
 
     return lines.join("\n");

package/src/context/token-estimator.ts

@@ -9,7 +9,6 @@ const CHARS_PER_TOKEN = 4;
 const MESSAGE_OVERHEAD_TOKENS = 4;
 const TEXT_BLOCK_OVERHEAD_TOKENS = 2;
 const TOOL_BLOCK_OVERHEAD_TOKENS = 16;
-const IMAGE_BLOCK_TOKENS = 1024;
 const IMAGE_BLOCK_OVERHEAD_TOKENS = 16;
 const FILE_BLOCK_OVERHEAD_TOKENS = 48;
 const WEB_SEARCH_RESULT_TOKENS = 800;
@@ -20,12 +19,15 @@ 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;
+// Anthropic caps images at ~1.2 megapixels in addition to the 1568px dimension limit.
+// Images exceeding this are further scaled down. The docs state images above ~1,600 tokens
+// are resized. 1,200,000 / 750 = 1,600 tokens, matching the documented threshold.
+// Reference table (max sizes that won't be resized):
+//   1:1 → 1092x1092 (~1,590 tokens)   1:2 → 784x1568 (~1,639 tokens)
+// See: https://platform.claude.com/docs/en/build-with-claude/vision#evaluate-image-size
+const ANTHROPIC_IMAGE_MAX_PIXELS = 1_200_000;
 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
+const ANTHROPIC_IMAGE_MAX_TOKENS = 1_600;
 
 // 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.
@@ -85,17 +87,23 @@ function estimateFileDataTokens(
 }
 
 function estimateAnthropicImageTokens(width: number, height: number): number {
-  // Scale down to fit within 1568x1568 bounding box, maintaining aspect ratio
-  const scale = Math.min(
+  // Step 1: Scale to fit within 1568px bounding box
+  const dimScale = 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),
-  );
+  let scaledWidth = Math.round(width * dimScale);
+  let scaledHeight = Math.round(height * dimScale);
+
+  // Step 2: Scale further if exceeds megapixel budget
+  const pixels = scaledWidth * scaledHeight;
+  if (pixels > ANTHROPIC_IMAGE_MAX_PIXELS) {
+    const mpScale = Math.sqrt(ANTHROPIC_IMAGE_MAX_PIXELS / pixels);
+    scaledWidth = Math.round(scaledWidth * mpScale);
+    scaledHeight = Math.round(scaledHeight * mpScale);
+  }
+
+  return Math.ceil(scaledWidth * scaledHeight * ANTHROPIC_IMAGE_TOKENS_PER_PIXEL);
 }
 
 function estimateImageTokens(
@@ -143,11 +151,10 @@ export function estimateContentBlockTokens(
       return tokens;
     }
     case "image":
-      return Math.max(
-        IMAGE_BLOCK_TOKENS,
+      return (
         IMAGE_BLOCK_OVERHEAD_TOKENS +
-          estimateTextTokens(block.source.media_type) +
-          estimateImageTokens(block, options),
+        estimateTextTokens(block.source.media_type) +
+        estimateImageTokens(block, options)
       );
     case "file":
       return (

package/src/context/window-manager.ts

@@ -628,14 +628,18 @@ export class ContextWindowManager {
       const excess = totalTokens - maxTranscriptTokens;
       if (blockTokens > excess && result[i].type === "text") {
         // Truncate this block to shed exactly the excess tokens.
-        const keepTokens = blockTokens - excess;
+        // Subtract the cost of the "[...truncated] " prefix so the final
+        // block (prefix + kept text) stays within budget.
+        const truncationPrefix = "[...truncated] ";
+        const prefixTokens = estimateTextTokens(truncationPrefix);
+        const keepTokens = Math.max(1, blockTokens - excess - prefixTokens);
         const text = (result[i] as { type: "text"; text: string }).text;
         // Approximate: 1 token ≈ 4 characters for truncation purposes.
         const keepChars = Math.max(1, Math.floor(keepTokens * 4));
         const truncatedText = text.slice(-keepChars);
         const truncatedBlock: ContentBlock = {
           type: "text",
-          text: `[...truncated] ${truncatedText}`,
+          text: `${truncationPrefix}${truncatedText}`,
         };
         const newBlockTokens = estimateBlockTokens(truncatedBlock);
         droppedTokens += blockTokens - newBlockTokens;

package/src/credential-execution/process-manager.ts

@@ -31,6 +31,7 @@ import { StringDecoder } from "node:string_decoder";
 import type { Subprocess } from "bun";
 
 import type { AssistantConfig } from "../config/schema.js";
+import { ensureBun } from "../util/bun-runtime.js";
 import { getLogger } from "../util/logger.js";
 import type { CesTransport } from "./client.js";
 import {
@@ -266,8 +267,9 @@ export function createCesProcessManager(
       "Spawning CES child process from source",
     );
 
+    const bunPath = await ensureBun();
     const proc = Bun.spawn({
-      cmd: ["bun", "run", discovery.sourcePath],
+      cmd: [bunPath, "run", discovery.sourcePath],
       stdin: "pipe",
       stdout: "pipe",
       stderr: "ignore",

package/src/daemon/app-source-watcher.ts

@@ -0,0 +1,93 @@
+/**
+ * Filesystem watcher for app source directories.
+ *
+ * Watches the apps root directory recursively using fs.watch (FSEvents on
+ * macOS). When a source file changes, debounces per app ID and calls the
+ * provided callback so the server can recompile + refresh surfaces.
+ *
+ * This catches ALL modification sources (file_edit, file_write, bash, etc.)
+ * without relying on individual tool hooks.
+ */
+
+import { existsSync, type FSWatcher, watch } from "node:fs";
+
+import {
+  getAppsDir,
+  resolveAppIdByDirName,
+} from "../memory/app-store.js";
+import { DebouncerMap } from "../util/debounce.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("app-source-watcher");
+
+const APP_REFRESH_DEBOUNCE_MS = 500;
+
+export type AppSourceChangeCallback = (appId: string) => void;
+
+/**
+ * Resolve app ID from a relative path within the apps directory.
+ * Returns null if the path is not an app source file (e.g. dist/, records/).
+ */
+function resolveAppIdFromRelPath(relPath: string): string | null {
+  const slashIdx = relPath.indexOf("/");
+  if (slashIdx === -1) return null; // file directly in apps/ (e.g. .json definition)
+
+  const dirName = relPath.slice(0, slashIdx);
+  const innerPath = relPath.slice(slashIdx + 1);
+
+  // Skip non-source directories (include bare directory names for fs.watch events)
+  if (
+    innerPath === "records" || innerPath.startsWith("records/") ||
+    innerPath === "dist" || innerPath.startsWith("dist/")
+  ) {
+    return null;
+  }
+
+  return resolveAppIdByDirName(dirName);
+}
+
+export class AppSourceWatcher {
+  private watcher: FSWatcher | null = null;
+  private debouncer = new DebouncerMap({
+    defaultDelayMs: APP_REFRESH_DEBOUNCE_MS,
+    maxEntries: 50,
+  });
+
+  start(onChange: AppSourceChangeCallback): void {
+    let appsDir: string;
+    try {
+      appsDir = getAppsDir();
+    } catch {
+      log.warn("Could not resolve apps directory; app source watching disabled");
+      return;
+    }
+
+    if (!existsSync(appsDir)) {
+      log.info("Apps directory does not exist yet; skipping source watcher");
+      return;
+    }
+
+    try {
+      this.watcher = watch(appsDir, { recursive: true }, (_eventType, filename) => {
+        if (!filename) return;
+
+        const appId = resolveAppIdFromRelPath(filename);
+        if (!appId) return;
+
+        this.debouncer.schedule(`app:${appId}`, () => {
+          onChange(appId);
+        });
+      });
+    } catch (err) {
+      log.warn({ err }, "Failed to watch apps directory; source watching disabled");
+    }
+  }
+
+  stop(): void {
+    this.debouncer.cancelAll();
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+  }
+}

package/src/daemon/config-watcher.ts

@@ -28,7 +28,10 @@ import { handleUserMessageSignal } from "../signals/user-message.js";
 import { DebouncerMap } from "../util/debounce.js";
 import { getLogger } from "../util/logger.js";
 import {
+  AVATAR_IMAGE_FILENAME,
+  getAvatarDir,
   getSignalsDir,
+  getSoundsDir,
   getWorkspaceDir,
   getWorkspaceSkillsDir,
 } from "../util/platform.js";
@@ -110,7 +113,12 @@ export class ConfigWatcher {
    * files change and conversations need to be evicted for reload.
    * `onIdentityChanged` is called when IDENTITY.md changes on disk.
    */
-  start(onConversationEvict: () => void, onIdentityChanged?: () => void): void {
+  start(
+    onConversationEvict: () => void,
+    onIdentityChanged?: () => void,
+    onSoundsConfigChanged?: () => void,
+    onAvatarChanged?: () => void,
+  ): void {
     const workspaceDir = getWorkspaceDir();
 
     const workspaceHandlers: Record<string, () => void> = {
@@ -175,6 +183,13 @@ export class ConfigWatcher {
       "workspace directory for config/prompt changes",
     );
 
+    if (onSoundsConfigChanged) {
+      this.startSoundsWatcher(onSoundsConfigChanged);
+    }
+    if (onAvatarChanged) {
+      this.startAvatarWatcher(onAvatarChanged);
+    }
+
     this.startFeatureFlagsWatcher();
     this.startSignalsWatcher();
     this.startSkillsWatchers(onConversationEvict);
@@ -188,6 +203,69 @@ export class ConfigWatcher {
     this.watchers = [];
   }
 
+  private startSoundsWatcher(onSoundsConfigChanged: () => void): void {
+    const soundsDir = getSoundsDir();
+    try {
+      if (!existsSync(soundsDir)) {
+        mkdirSync(soundsDir, { recursive: true });
+      }
+    } catch {
+      // If we can't create it, watching will also fail — handled below.
+    }
+
+    try {
+      const watcher = watch(soundsDir, (_eventType, filename) => {
+        if (!filename) return;
+        this.debounceTimers.schedule("file:sounds", () => {
+          log.info(
+            { file: String(filename) },
+            "Sounds directory changed, notifying clients",
+          );
+          onSoundsConfigChanged();
+        });
+      });
+      this.watchers.push(watcher);
+      log.info({ dir: soundsDir }, "Watching sounds directory for changes");
+    } catch (err) {
+      log.warn(
+        { err, dir: soundsDir },
+        "Failed to watch sounds directory. Sound config changes will require a restart.",
+      );
+    }
+  }
+
+  private startAvatarWatcher(onAvatarChanged: () => void): void {
+    const avatarDir = getAvatarDir();
+    try {
+      if (!existsSync(avatarDir)) {
+        mkdirSync(avatarDir, { recursive: true });
+      }
+    } catch {
+      // If we can't create it, watching will also fail — handled below.
+    }
+
+    try {
+      const watcher = watch(avatarDir, (_eventType, filename) => {
+        if (!filename) return;
+        if (String(filename) !== AVATAR_IMAGE_FILENAME) return;
+        this.debounceTimers.schedule("file:avatar", () => {
+          log.info(
+            { file: String(filename) },
+            "Avatar image changed, notifying clients",
+          );
+          onAvatarChanged();
+        });
+      });
+      this.watchers.push(watcher);
+      log.info({ dir: avatarDir }, "Watching avatar directory for changes");
+    } catch (err) {
+      log.warn(
+        { err, dir: avatarDir },
+        "Failed to watch avatar directory. Avatar changes will require a restart.",
+      );
+    }
+  }
+
   private startFeatureFlagsWatcher(): void {
     const protectedDir = process.env.GATEWAY_SECURITY_DIR
       ? process.env.GATEWAY_SECURITY_DIR

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

@@ -17,7 +17,10 @@
  */
 
 import type { ContextWindowConfig } from "../config/types.js";
-import { estimatePromptTokens } from "../context/token-estimator.js";
+import {
+  estimateContentBlockTokens,
+  estimatePromptTokens,
+} from "../context/token-estimator.js";
 import { truncateToolResultsAcrossHistory } from "../context/tool-result-truncation.js";
 import type {
   ContextWindowCompactOptions,
@@ -26,6 +29,7 @@ import type {
 import type { Message } from "../providers/types.js";
 import {
   countMediaBlocks,
+  estimateUnconditionalStubTokens,
   stripMediaPayloadsForRetry,
 } from "./conversation-media-retry.js";
 import type { InjectionMode } from "./conversation-runtime-assembly.js";
@@ -240,7 +244,47 @@ function applyMediaStubbing(
   let nextMessages = messages;
 
   if (mediaCount > 0) {
-    const stripped = stripMediaPayloadsForRetry(messages);
+    // Compute the token budget available for media content.
+    const totalTokens = estimatePromptTokens(messages, config.systemPrompt, {
+      providerName: config.providerName,
+      toolTokenBudget: config.toolTokenBudget,
+    });
+
+    // Sum tokens for all image and file blocks (top-level and nested in tool_result).
+    let mediaTokens = 0;
+    for (const msg of messages) {
+      for (const block of msg.content) {
+        if (block.type === "image" || block.type === "file") {
+          mediaTokens += estimateContentBlockTokens(block, {
+            providerName: config.providerName,
+          });
+        } else if (block.type === "tool_result" && block.contentBlocks) {
+          for (const cb of block.contentBlocks) {
+            if (cb.type === "image" || cb.type === "file") {
+              mediaTokens += estimateContentBlockTokens(cb, {
+                providerName: config.providerName,
+              });
+            }
+          }
+        }
+      }
+    }
+
+    const nonMediaTokens = totalTokens - mediaTokens;
+
+    // Account for the token cost of text stubs that replace unconditionally
+    // stubbed media (non-latest-user images/files, tool_result-nested media).
+    // Without this adjustment the budget is systematically over-allocated.
+    const estimatedStubTokens = estimateUnconditionalStubTokens(messages, {
+      providerName: config.providerName,
+    });
+    const adjustedNonMediaTokens = nonMediaTokens + estimatedStubTokens;
+    const mediaTokenBudget = Math.max(0, config.targetTokens - adjustedNonMediaTokens);
+
+    const stripped = stripMediaPayloadsForRetry(messages, {
+      mediaTokenBudget,
+      providerName: config.providerName,
+    });
     if (stripped.modified) {
       nextMessages = stripped.messages;
     }