@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/context/strip-injections.ts

@@ -0,0 +1,128 @@
+/**
+ * Runtime-injection stripping for compaction and overflow recovery.
+ *
+ * Runtime injections (turn context, memory, NOW.md, workspace, Slack
+ * chronological, etc.) persist in message history to keep the conversation
+ * prefix stable for Anthropic's prefix caching. They only need to be removed
+ * when compaction rewrites the message array, so the compactor summarizes the
+ * raw persistent messages rather than the ephemeral injected blocks.
+ *
+ * This module is the compaction-layer home for that strip so both the agent
+ * loop (which drives the compaction pipeline) and the compactor can call it
+ * without reaching up into the daemon orchestrator.
+ */
+import type { Message } from "../providers/types.js";
+
+/**
+ * A matcher for an injected text block. A plain string matches by prefix
+ * (`startsWith`). A `{ prefix, suffix }` wrapper requires BOTH the opening
+ * prefix and the closing suffix, so user-authored content that merely begins
+ * with an injection-like opening tag (e.g. a message discussing `<info>`
+ * markup) is not mistaken for an injected block and dropped. This mirrors
+ * `countMemoryPrefixBlocks`, which only treats `<memory>…</memory>` /
+ * `<info>…</info>` blocks as injected when the full wrapper is present.
+ */
+export type InjectionMatcher = string | { prefix: string; suffix: string };
+
+/**
+ * Remove text blocks from user messages that match any of the given matchers.
+ * If stripping removes all content blocks from a message, the message itself
+ * is dropped.
+ *
+ * This is the shared primitive behind the individual strip* functions and
+ * the `stripInjectionsForCompaction` pipeline.
+ */
+export function stripUserTextBlocksByPrefix(
+  messages: Message[],
+  matchers: InjectionMatcher[],
+): Message[] {
+  return messages
+    .map((message) => {
+      if (message.role !== "user") return message;
+      const nextContent = message.content.filter((block) => {
+        if (block.type !== "text") return true;
+        return !matchers.some((m) =>
+          typeof m === "string"
+            ? block.text.startsWith(m)
+            : block.text.startsWith(m.prefix) && block.text.endsWith(m.suffix),
+        );
+      });
+      if (nextContent.length === message.content.length) return message;
+      if (nextContent.length === 0) return null;
+      return { ...message, content: nextContent };
+    })
+    .filter(
+      (message): message is NonNullable<typeof message> => message != null,
+    );
+}
+
+/** Matchers stripped by the pipeline (order doesn't matter — single pass). */
+const RUNTIME_INJECTION_PREFIXES: InjectionMatcher[] = [
+  "<channel_capabilities>",
+  "<channel_command_context>",
+  "<disk_pressure_warning>",
+  "<channel_turn_context>", // backward-compat: strip legacy separate channel blocks
+  "<guardian_context>",
+  "<inbound_actor_context>", // backward-compat: strip legacy separate actor blocks
+  "<interface_turn_context>", // backward-compat: strip legacy separate interface blocks
+  // NOTE: <turn_context> is intentionally NOT stripped — unified turn context
+  // blocks persist in history so the assistant retains temporal/actor grounding.
+  "<background_turn>",
+  "<memory_context __injected>",
+  "<memory_context>", // backward-compat: strip legacy blocks from pre-__injected history
+  // The static `memory-v2-static` block (`<info>\n…</info>`) and the
+  // dynamic activation block (`<memory>\n…</memory>`, plus legacy
+  // `<memory __injected>…`) are both stripped so each compaction
+  // re-injects the freshest essentials/threads/recent/buffer view and
+  // re-runs the activation pipeline, matching the `<knowledge_base>`
+  // cadence. The activation pipeline dedupes via `everInjected`, and
+  // compaction handles aggregate growth, so accumulation does not cause
+  // unbounded context growth. Both wrappers may appear in persisted rows.
+  //
+  // These two use the full `{ prefix, suffix }` wrapper shape (not a bare
+  // prefix) so that user-authored text merely starting with `<memory>\n` or
+  // `<info>\n` is never silently dropped during compaction/`/clean`. This
+  // matches the full-wrapper requirement in `countMemoryPrefixBlocks`.
+  { prefix: "<memory>\n", suffix: "\n</memory>" },
+  { prefix: "<info>\n", suffix: "\n</info>" },
+  "<voice_call_control>",
+  "<workspace_top_level>", // backward-compat: strip legacy workspace blocks
+  // The `<workspace>` top-level block is stripped so each compaction re-injects
+  // a fresh directory snapshot rather than carrying a stale listing into the
+  // summary — matching the `<knowledge_base>`/`<NOW.md>` cadence and keeping the
+  // `workspace-context` injector's presence detection in lockstep (the block is
+  // present exactly when compaction would strip it). The full `{ prefix, suffix }`
+  // wrapper shape ensures user-authored text merely starting with `<workspace>\n`
+  // is never mistaken for an injected block.
+  { prefix: "<workspace>\n", suffix: "\n</workspace>" },
+  "<temporal_context>\nToday:", // backward-compat: strip legacy temporal blocks
+  "<active_subagents>",
+  "<active_workspace>",
+  "<active_dynamic_page>",
+  "<non_interactive_context>",
+  // Shared prefix catches both the current NOW.md tag and any pre-line-limit
+  // variant that may linger in in-flight histories during a rolling deploy.
+  "<NOW.md Always keep this up to date",
+  "<now_scratchpad>", // backward-compat: strip legacy blocks from pre-rename history
+  "<knowledge_base>",
+  "<pkb>", // backward-compat: strip legacy tag from pre-rename history
+  "<system_reminder>",
+  "<transport_hints>",
+  // The Slack active-thread focus block is non-persisted and injected on
+  // the FINAL user turn only. Strip it here so re-assembly during compaction
+  // and overflow recovery does not duplicate it across turns.
+  "<active_thread>",
+  "<system_notice>One or more tool calls returned an error.",
+];
+
+/**
+ * Strip all runtime-injected context from message history in a single pass.
+ *
+ * Used only during compaction and overflow recovery — not on normal turns.
+ * Runtime injections persist in history to keep the conversation prefix
+ * stable for Anthropic's prefix caching. Stripping is only needed when
+ * compaction rewrites the message array (cache miss is expected anyway).
+ */
+export function stripInjectionsForCompaction(messages: Message[]): Message[] {
+  return stripUserTextBlocksByPrefix(messages, RUNTIME_INJECTION_PREFIXES);
+}

package/src/context/token-estimator.ts

@@ -1,3 +1,7 @@
+import {
+  estimateGeminiAudioTokens,
+  normalizeGeminiAudioMime,
+} from "../providers/gemini/inline-media.js";
 import type {
   ContentBlock,
   Message,
@@ -116,6 +120,16 @@ function estimateFileDataTokens(
     return estimateAnthropicPdfTokens(block.source.data);
   }
 
+  // Gemini hears audio natively (inline base64) but bills it at ~32 tokens/sec.
+  // Estimate from duration, not payload size, to avoid a ~170x over-count that
+  // would trigger spurious compaction.
+  if (
+    providerName === "gemini" &&
+    normalizeGeminiAudioMime(block.source.media_type) !== null
+  ) {
+    return estimateGeminiAudioTokens(block.source.data);
+  }
+
   // Gemini sends certain file types inline as base64
   if (
     providerName === "gemini" &&
@@ -225,6 +239,11 @@ export function estimateContentBlockTokens(
             tokens += estimateContentBlockTokens(cb, options);
           } else if (cb.type === "image" && !anthropicDropsErrorImage) {
             tokens += estimateContentBlockTokens(cb, options);
+          } else if (cb.type === "file") {
+            // Audio file sub-blocks (e.g. file_read on an .mp3) are sent inline
+            // to Gemini; estimateFileDataTokens charges the ~32 tok/sec audio
+            // rate for Gemini and ~0 for providers that drop the block.
+            tokens += estimateContentBlockTokens(cb, options);
           }
         }
       }
@@ -340,6 +359,29 @@ export function estimatePromptTokens(
   return correction === 1.0 ? raw : Math.ceil(raw * correction);
 }
 
+/**
+ * Calibrated prompt-token estimate including the tool-definition budget.
+ *
+ * Combines the per-tool budget ({@link estimateToolsTokens}) with the
+ * message/system estimate ({@link estimatePromptTokens}) under the EWMA
+ * calibration correction. This is the estimate the overflow gate consumes;
+ * the pre-send calibration capture in `agent/loop.ts` deliberately stays on
+ * `estimatePromptTokensRaw` so the calibrator trains against the uncorrected
+ * value rather than chasing its own output.
+ */
+export function estimatePromptTokensWithTools(
+  history: Message[],
+  systemPrompt: string | undefined,
+  tools: ToolDefinition[],
+  providerName: string,
+): number {
+  const toolTokenBudget = tools.length > 0 ? estimateToolsTokens(tools) : 0;
+  return estimatePromptTokens(history, systemPrompt, {
+    providerName,
+    toolTokenBudget,
+  });
+}
+
 function stableJson(value: unknown): string {
   try {
     return JSON.stringify(value);

package/src/context/tool-result-truncation.ts

@@ -1,74 +1,9 @@
+import { truncateToolResultText } from "../plugins/defaults/tool-result-truncate/terminal.js";
 import type {
   ContentBlock,
   Message,
   ToolResultContent,
 } from "../providers/types.js";
-import { safeStringSlice } from "../util/unicode.js";
-
-/**
- * Maximum share of the context window that a single tool result may occupy.
- */
-const MAX_TOOL_RESULT_CONTEXT_SHARE = 0.3;
-
-/**
- * Absolute cap on tool-result characters (~100K tokens).
- */
-export const HARD_MAX_TOOL_RESULT_CHARS = 400_000;
-
-/**
- * Minimum number of characters to preserve when truncating.
- */
-export const MIN_KEEP_CHARS = 2_000;
-
-/**
- * Suffix appended to truncated tool results.
- */
-export const TRUNCATION_SUFFIX =
-  "\n\n[Content truncated — original exceeded size limit. Use offset/limit parameters or request specific sections for large content.]";
-
-/**
- * Truncate text with newline-boundary awareness.
- *
- * If `text.length <= maxChars`, the text is returned as-is.
- * Otherwise we look for the last newline that falls within 80% of the budget
- * so we get a clean cut. At least `MIN_KEEP_CHARS` characters are always
- * preserved.
- */
-export function truncateToolResultText(text: string, maxChars: number): string {
-  if (text.length <= maxChars) {
-    return text;
-  }
-
-  const effectiveMax = Math.max(maxChars, MIN_KEEP_CHARS);
-  const cutPoint = effectiveMax - TRUNCATION_SUFFIX.length;
-
-  // Look for a newline within the last 20% of the budget for a clean break.
-  const threshold = Math.floor(cutPoint * 0.8);
-  const lastNewline = text.lastIndexOf("\n", cutPoint);
-
-  const sliceEnd = lastNewline >= threshold ? lastNewline : cutPoint;
-
-  // If sliceEnd covers the full text, nothing was actually removed — return
-  // the original text without appending the suffix.
-  if (sliceEnd >= text.length) {
-    return text;
-  }
-
-  return safeStringSlice(text, 0, sliceEnd) + TRUNCATION_SUFFIX;
-}
-
-/**
- * Calculate the maximum allowed characters for a tool result based on the
- * context window size. Uses ~4 chars per token as a rough heuristic.
- */
-export function calculateMaxToolResultChars(
-  contextWindowTokens: number,
-): number {
-  return Math.min(
-    HARD_MAX_TOOL_RESULT_CHARS,
-    Math.floor(contextWindowTokens * MAX_TOOL_RESULT_CONTEXT_SHARE * 4),
-  );
-}
 
 /**
  * Aggressively truncate all tool-result text across an entire message history.

package/src/context/window-manager.ts

@@ -24,6 +24,7 @@ import type {
   Provider,
   ToolDefinition,
 } from "../providers/types.js";
+import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { getLogger } from "../util/logger.js";
 import {
   type CompactionRunArgs,
@@ -68,6 +69,19 @@ export interface ContextWindowResult {
   summaryText: string;
   reason?: string;
   summaryFailed?: boolean;
+  /**
+   * Set to `true` when {@link ContextWindowManager.maybeCompact} ran the
+   * compactor up to `overflowRecovery.maxAttempts` times and still could
+   * not reduce the estimated input tokens below the auto-threshold (or a
+   * single attempt produced no token reduction at all). Callers that
+   * orchestrate mid-loop compaction use this as the "give up, escalate"
+   * signal — there's no point retrying the compactor again; reducers
+   * (truncation / media stubbing) need to step in.
+   *
+   * Omitted (treated as `false`) on no-op early returns and on successful
+   * compactions that did clear the threshold.
+   */
+  exhausted?: boolean;
 }
 
 export interface ShouldCompactResult {
@@ -76,7 +90,6 @@ export interface ShouldCompactResult {
 }
 
 export interface ContextWindowCompactOptions {
-  lastCompactedAt?: number;
   /** Skip the auto-threshold check (used for /compact and recovery). */
   force?: boolean;
   /**
@@ -90,14 +103,18 @@ export interface ContextWindowCompactOptions {
    */
   precomputedEstimate?: number;
   /**
-   * Legacy fields retained for backwards compatibility with existing
-   * callers. The new assistant-driven compactor does not consume them —
-   * the model decides where to cut and what to keep — but accepting them
+   * Legacy field retained for backwards compatibility with existing
+   * callers. The new assistant-driven compactor does not consume it —
+   * the model decides where to cut and what to keep — but accepting it
    * here lets callers keep their existing call sites unchanged.
    */
   minKeepRecentUserTurns?: number;
-  conversationOriginChannel?: string;
-  targetInputTokensOverride?: number;
+  /**
+   * Trust class of the actor whose turn triggered compaction. Forwarded to
+   * the compactor so the image manifest excludes guardian-only attachments
+   * for untrusted actors.
+   */
+  actorTrustClass?: TrustClass;
 }
 
 export interface ContextWindowManagerOptions {
@@ -322,7 +339,7 @@ export class ContextWindowManager {
       });
     }
 
-    const args: CompactionRunArgs = {
+    const baseArgs: CompactionRunArgs = {
       conversationId: this.conversationId,
       messages,
       provider: this.provider,
@@ -334,44 +351,104 @@ export class ContextWindowManager {
       force: options?.force,
       signal,
       overrideProfile: options?.overrideProfile ?? null,
+      actorTrustClass: options?.actorTrustClass,
       nonPersistedPrefixCount: this.nonPersistedPrefixCount,
     };
 
-    const result = await runAssistantDrivenCompaction(args);
+    // Retry budget for the compactor itself. Lives here (not in the
+    // orchestrator/agent loop) because the question "did this compactor
+    // make enough progress?" is a compaction-internal concern. The agent
+    // loop only needs to know the binary outcome — drop below threshold,
+    // or signal `exhausted` so reducers escalate.
+    const maxAttempts = this.config.overflowRecovery.maxAttempts;
+
+    let result = await runAssistantDrivenCompaction(baseArgs);
 
+    // Compactor early-returned without doing any work (e.g. no eligible
+    // messages, summary failed, disabled mid-way). Nothing to retry.
     if (!result.compacted) return result;
 
-    // Recompute the post-compaction token estimate now that the message
-    // array has been rebuilt. The compactor returns a conservative
-    // placeholder; the agent loop wants the real number for its next
-    // budget decision.
-    let estimatedInputTokens = result.estimatedInputTokens;
-    try {
-      estimatedInputTokens = estimatePromptTokens(
-        result.messages,
-        this.systemPrompt,
-        {
-          providerName: this.estimationProviderName,
-          toolTokenBudget: this.toolTokenBudget,
-        },
+    let estimatedInputTokens = this.recomputePostCompactionEstimate(
+      result.messages,
+      result.estimatedInputTokens,
+    );
+    this.consumeCompactionState(result.compactedMessages);
+
+    // If a single pass already cleared the auto-threshold, ship it.
+    if (estimatedInputTokens < thresholdTokens) {
+      return { ...result, estimatedInputTokens };
+    }
+
+    // Still above the threshold after one pass — retry on the compacted
+    // history, up to the remaining budget. Each retry runs against the
+    // PREVIOUS attempt's output, building a tighter summary each time.
+    // Bail early as soon as a pass fails to reduce — that's a stuck
+    // compactor and another attempt won't help.
+    let previousEstimate = estimatedInputTokens;
+    for (let attempt = 2; attempt <= maxAttempts; attempt++) {
+      const nextResult = await runAssistantDrivenCompaction({
+        ...baseArgs,
+        messages: result.messages,
+        previousEstimatedInputTokens: previousEstimate,
+        nonPersistedPrefixCount: this.nonPersistedPrefixCount,
+      });
+      if (!nextResult.compacted) break;
+      const nextEstimate = this.recomputePostCompactionEstimate(
+        nextResult.messages,
+        nextResult.estimatedInputTokens,
       );
+      this.consumeCompactionState(nextResult.compactedMessages);
+      result = mergeCompactionResults(result, nextResult);
+      estimatedInputTokens = nextEstimate;
+      if (estimatedInputTokens < thresholdTokens) {
+        return { ...result, estimatedInputTokens };
+      }
+      // Non-productive (compacted but didn't shrink) — stuck compactor.
+      if (estimatedInputTokens >= previousEstimate) break;
+      previousEstimate = estimatedInputTokens;
+    }
+
+    // Out of attempts or stuck — surface `exhausted` so the orchestrator
+    // can escalate to reducer tiers instead of re-running the compactor.
+    return { ...result, estimatedInputTokens, exhausted: true };
+  }
+
+  /**
+   * Recompute the prompt-token estimate against the post-compaction
+   * message array. The compactor returns a conservative placeholder; the
+   * orchestrator needs the real number for its next budget decision.
+   */
+  private recomputePostCompactionEstimate(
+    messages: Message[],
+    fallback: number,
+  ): number {
+    try {
+      return estimatePromptTokens(messages, this.systemPrompt, {
+        providerName: this.estimationProviderName,
+        toolTokenBudget: this.toolTokenBudget,
+      });
     } catch (err) {
       log.warn({ err }, "Post-compaction token estimate failed");
+      return fallback;
     }
+  }
 
-    // Consume any non-persisted prefix messages that were compacted away
-    // and clear the injected-summary flag.
+  /**
+   * Decrement the non-persisted prefix bookkeeping and clear the
+   * injected-summary flag after a productive compaction. Called once per
+   * successful internal attempt so multi-attempt runs keep the count
+   * honest as the leading injected messages get folded into the summary.
+   */
+  private consumeCompactionState(compactedMessages: number): void {
     const compactedAway = Math.min(
       this.nonPersistedPrefixCount,
-      result.compactedMessages,
+      compactedMessages,
     );
     this.nonPersistedPrefixCount = Math.max(
       0,
       this.nonPersistedPrefixCount - compactedAway,
     );
     this.summaryIsInjected = false;
-
-    return { ...result, estimatedInputTokens };
   }
 }
 
@@ -379,6 +456,44 @@ export class ContextWindowManager {
 // Helpers
 // ---------------------------------------------------------------------------
 
+/**
+ * Combine the result of a follow-up compaction attempt with the running
+ * aggregate so the orchestrator sees cumulative work — total messages
+ * folded into the summary, total summary LLM calls, total token spend —
+ * across all internal retries. Content fields (the new messages array,
+ * latest summary text, latest estimate) take the `next` attempt's value.
+ */
+function mergeCompactionResults(
+  prev: ContextWindowResult,
+  next: ContextWindowResult,
+): ContextWindowResult {
+  return {
+    ...next,
+    previousEstimatedInputTokens: prev.previousEstimatedInputTokens,
+    compactedMessages: prev.compactedMessages + next.compactedMessages,
+    compactedPersistedMessages:
+      prev.compactedPersistedMessages + next.compactedPersistedMessages,
+    summaryCalls: prev.summaryCalls + next.summaryCalls,
+    summaryInputTokens: prev.summaryInputTokens + next.summaryInputTokens,
+    summaryOutputTokens: prev.summaryOutputTokens + next.summaryOutputTokens,
+    summaryCacheCreationInputTokens:
+      (prev.summaryCacheCreationInputTokens ?? 0) +
+      (next.summaryCacheCreationInputTokens ?? 0),
+    summaryCacheReadInputTokens:
+      (prev.summaryCacheReadInputTokens ?? 0) +
+      (next.summaryCacheReadInputTokens ?? 0),
+    summaryRawResponses: [
+      ...(prev.summaryRawResponses ?? []),
+      ...(next.summaryRawResponses ?? []),
+    ],
+    // Any failure across attempts taints the run for the circuit breaker.
+    summaryFailed:
+      next.summaryFailed === true || prev.summaryFailed === true
+        ? true
+        : (next.summaryFailed ?? prev.summaryFailed),
+  };
+}
+
 function noopResult(
   messages: Message[],
   estimated: number,

package/src/credential-execution/executable-discovery.ts

@@ -17,6 +17,7 @@
  */
 
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 
 import { getIsContainerized } from "../config/env-registry.js";
@@ -160,6 +161,21 @@ export function discoverLocalCes():
     return { mode: "local-source", sourcePath: sourceEntry };
   }
 
+  // npm-layout fallback: resolve via node_modules when installed as a package
+  try {
+    const _require = createRequire(import.meta.url);
+    const pkgPath = _require.resolve(
+      "@vellumai/credential-executor/package.json",
+    );
+    const npmSourceEntry = join(dirname(pkgPath), "src", "main.ts");
+    if (existsSync(npmSourceEntry)) {
+      log.info({ path: npmSourceEntry }, "Found CES source via npm package");
+      return { mode: "local-source", sourcePath: npmSourceEntry };
+    }
+  } catch {
+    // Package not installed — fall through to unavailable
+  }
+
   const reason = `CES executable not found. Searched: ${searchPaths.join(", ")}; also checked source at ${sourceEntry}`;
   log.warn(reason);
   return { mode: "unavailable", reason };

package/src/daemon/__tests__/conversation-lifecycle-auto-analyze.test.ts

@@ -165,6 +165,12 @@ function makeDisposeContext(
   const ctx = {
     conversationId: overrides.conversationId ?? "conv-1",
     processing: false,
+    isProcessing(this: { processing: boolean }) {
+      return this.processing;
+    },
+    setProcessing(this: { processing: boolean }, value: boolean) {
+      this.processing = value;
+    },
     abortController,
     prompter,
     secretPrompter,

package/src/daemon/__tests__/conversation-surfaces-launch.test.ts

@@ -180,8 +180,8 @@ function makeContext(
       return { queued: false, requestId: "enq-req" };
     },
     getQueueDepth: () => 0,
-    processMessage: async (content: string) => {
-      processCalls.push({ content });
+    processMessage: async (options) => {
+      processCalls.push({ content: options.content });
       return "ok";
     },
     withSurface: createSurfaceMutex(),