@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091853.fbaa2ae

package/src/__tests__/conversation-clean-command.test.ts

@@ -120,7 +120,7 @@ describe("stripInjectionsForCompaction preserves history shape", () => {
     expect(out[3]).toEqual(messages[3]);
   });
 
-  test("leaves <turn_context>, <workspace>, and <memory __injected> alone", () => {
+  test("strips <workspace> but leaves <turn_context> and <memory __injected> alone", () => {
     const messages: Message[] = [
       {
         role: "user",
@@ -132,6 +132,9 @@ describe("stripInjectionsForCompaction preserves history shape", () => {
       },
     ];
     const out = stripInjectionsForCompaction(messages);
-    expect(out[0].content).toEqual(messages[0].content);
+    expect(out[0].content).toEqual([
+      { type: "text", text: "<turn_context>\nnow\n</turn_context>" },
+      { type: "text", text: "<memory __injected>\nrecent\n</memory>" },
+    ]);
   });
 });

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -164,9 +164,10 @@ mock.module("../memory/retriever.js", () => ({
   injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -199,10 +200,10 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      _messages: Message[],
-      _onEvent: (event: AgentEvent) => void,
-    ): Promise<Message[]> {
+    async run(_options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<Message[]> {
       return [];
     }
   },

package/src/__tests__/conversation-crud-inference-profile.test.ts

@@ -9,7 +9,7 @@ mock.module("../util/logger.js", () => ({
 import {
   createConversation,
   getConversation,
-  getConversationOverrideProfileFromRow,
+  resolveOverrideProfile,
   setConversationInferenceProfile,
   setConversationInferenceProfileSession,
 } from "../memory/conversation-crud.js";
@@ -55,7 +55,7 @@ describe("setConversationInferenceProfile", () => {
   });
 });
 
-describe("getConversationOverrideProfileFromRow — lazy expiry check", () => {
+describe("resolveOverrideProfile — lazy expiry check", () => {
   beforeEach(() => {
     const db = getDb();
     db.run(`DELETE FROM messages`);
@@ -73,7 +73,7 @@ describe("getConversationOverrideProfileFromRow — lazy expiry check", () => {
     );
     const row = getConversation(conv.id);
     expect(row).not.toBeNull();
-    expect(getConversationOverrideProfileFromRow(row)).toBeUndefined();
+    expect(resolveOverrideProfile(row)).toBeUndefined();
   });
 
   test("returns the profile when inferenceProfileExpiresAt is in the future", () => {
@@ -86,7 +86,7 @@ describe("getConversationOverrideProfileFromRow — lazy expiry check", () => {
     );
     const row = getConversation(conv.id);
     expect(row).not.toBeNull();
-    expect(getConversationOverrideProfileFromRow(row)).toBe("balanced");
+    expect(resolveOverrideProfile(row)).toBe("balanced");
   });
 
   test("returns undefined at the exact-expiry boundary (expiresAt === now)", () => {
@@ -110,7 +110,7 @@ describe("getConversationOverrideProfileFromRow — lazy expiry check", () => {
     const realNow = Date.now;
     Date.now = () => now;
     try {
-      expect(getConversationOverrideProfileFromRow(row)).toBeUndefined();
+      expect(resolveOverrideProfile(row)).toBeUndefined();
     } finally {
       Date.now = realNow;
     }
@@ -126,9 +126,7 @@ describe("getConversationOverrideProfileFromRow — lazy expiry check", () => {
     );
     const row = getConversation(conv.id);
     expect(row).not.toBeNull();
-    expect(getConversationOverrideProfileFromRow(row)).toBe(
-      "quality-optimized",
-    );
+    expect(resolveOverrideProfile(row)).toBe("quality-optimized");
   });
 
   test.each<"background" | "scheduled">(["background", "scheduled"])(
@@ -148,7 +146,7 @@ describe("getConversationOverrideProfileFromRow — lazy expiry check", () => {
       expect(row).not.toBeNull();
       expect(row?.conversationType).toBe(conversationType);
       expect(row?.inferenceProfile).toBe("quality-optimized");
-      expect(getConversationOverrideProfileFromRow(row)).toBeUndefined();
+      expect(resolveOverrideProfile(row)).toBeUndefined();
     },
   );
 });

package/src/__tests__/conversation-error.test.ts

@@ -319,7 +319,6 @@ describe("classifyConversationError", () => {
       expect(result.errorCategory).toBe("image_dimensions_too_large");
       expect(result.retryable).toBe(false);
       expect(result.userMessage).toContain("image");
-      expect(result.userMessage).toContain("8000");
     });
 
     it("matches the singular 'image dimension exceeds' phrasing as well", () => {
@@ -333,6 +332,21 @@ describe("classifyConversationError", () => {
       expect(result.retryable).toBe(false);
     });
 
+    it("classifies the base64 payload 'exceeds 5 MB maximum' variant as IMAGE_TOO_LARGE (JARVIS-1041)", () => {
+      // This is the exact shape that wedged the reporting user: an oversized
+      // image nested in a tool_result. It must route to IMAGE_TOO_LARGE so the
+      // recovery path fires, not to a retryable PROVIDER_API loop.
+      const err = new ProviderError(
+        'Anthropic API error (400): 400 {"type":"error","error":{"type":"invalid_request_error","message":"messages.28.content.1.tool_result.content.1.image.source.base64: image exceeds 5 MB maximum: 7465044 bytes > 5242880 bytes"},"request_id":"req_011CbbFqvxBmDQdhVlqxtAfW"}',
+        "anthropic",
+        400,
+      );
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.code).toBe("IMAGE_TOO_LARGE");
+      expect(result.errorCategory).toBe("image_dimensions_too_large");
+      expect(result.retryable).toBe(false);
+    });
+
     it("does not steal generic 400s that happen to mention 'image'", () => {
       const err = new ProviderError(
         "invalid request: image source is missing",

package/src/__tests__/conversation-history-web-search.test.ts

@@ -807,7 +807,12 @@ describe("web_search_tool_result structural guard", () => {
     // Media token counting iterates tool_result.contentBlocks for nested
     // image/file blocks. web_search_tool_result has opaque content with no
     // contentBlocks property, so it cannot contain nested media.
-    "daemon/context-overflow-reducer.ts",
+    "plugins/defaults/compaction/context-overflow-reducer.ts",
+
+    // Downgrades permanently-unsendable images nested in tool_result.contentBlocks
+    // (e.g. an oversized browser screenshot). web_search_tool_result has opaque
+    // content with no contentBlocks property, so it cannot hold such an image.
+    "daemon/persist-unsendable-image.ts",
 
     // Final orphan-pair safety pass in the Slack transcript renderer.
     // Server-side block types (`server_tool_use`, `web_search_tool_result`)

package/src/__tests__/conversation-media-retry.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
-import { createContextSummaryMessage } from "../context/window-manager.js";
 import { stripMediaPayloadsForRetry } from "../daemon/conversation-media-retry.js";
+import { createContextSummaryMessage } from "../plugins/defaults/compaction/window-manager.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------

package/src/__tests__/conversation-process-app-control-preactivation.test.ts

@@ -92,7 +92,7 @@ mock.module("../daemon/conversation-messaging.js", () => ({
 // ---------------------------------------------------------------------------
 
 import type { TurnInterfaceContext } from "../channels/types.js";
-import type { ProcessConversationContext } from "../daemon/conversation-process.js";
+import type { Conversation } from "../daemon/conversation.js";
 import { drainQueue } from "../daemon/conversation-process.js";
 import {
   MessageQueue,
@@ -102,7 +102,7 @@ import { TraceEmitter } from "../daemon/trace-emitter.js";
 
 // ---------------------------------------------------------------------------
 // Fake context — captures preactivation calls, satisfies the bare minimum
-// of `ProcessConversationContext`. `runAgentLoop` resolves immediately so
+// of `Conversation`. `runAgentLoop` resolves immediately so
 // the drain-chain does not recurse forever.
 // ---------------------------------------------------------------------------
 
@@ -113,7 +113,7 @@ interface FakeRecord {
 function makeFakeContext(opts: {
   queue: MessageQueue;
   turnInterfaceContext?: TurnInterfaceContext;
-}): ProcessConversationContext & FakeRecord {
+}): Conversation & FakeRecord {
   const calls: string[] = [];
   let preactivatedSkillIds: string[] | undefined = undefined;
   const ctx = {
@@ -177,7 +177,7 @@ function makeFakeContext(opts: {
     setTransportHints() {},
     applyHostEnvFromTransport() {},
     ensureHostProxiesForTurn() {},
-  } as unknown as ProcessConversationContext & FakeRecord;
+  } as unknown as Conversation & FakeRecord;
   return ctx;
 }
 
@@ -185,6 +185,7 @@ function makeQueuedMessage(opts: {
   requestId: string;
   content?: string;
   turnInterfaceContext?: TurnInterfaceContext;
+  sourceActorPrincipalId?: string;
 }): QueuedMessage {
   return {
     content: opts.content ?? "follow up",
@@ -194,6 +195,10 @@ function makeQueuedMessage(opts: {
     metadata: {},
     sentAt: Date.now(),
     turnInterfaceContext: opts.turnInterfaceContext,
+    sourceActorPrincipalId: opts.sourceActorPrincipalId,
+    authContext: opts.sourceActorPrincipalId
+      ? ({ actorPrincipalId: opts.sourceActorPrincipalId } as never)
+      : undefined,
   };
 }
 
@@ -332,6 +337,7 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
       makeQueuedMessage({
         requestId: "req-web-1",
         turnInterfaceContext: ifCtx,
+        sourceActorPrincipalId: "user-1",
       }),
     );
     const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
@@ -346,6 +352,39 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
     expect(ctx.preactivatedSkillIdCalls).toContain("computer-use");
   });
 
+  test("drainSingleMessage filters cross-client preactivation by the queued requester, not guardian owner", async () => {
+    mockCapabilityClients = [
+      { clientId: "owner-macos-client", actorPrincipalId: "owner-user" },
+    ];
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "web",
+      assistantMessageInterface: "web",
+    };
+    queue.push(
+      makeQueuedMessage({
+        requestId: "req-web-attacker",
+        turnInterfaceContext: ifCtx,
+        sourceActorPrincipalId: "trusted-contact-user",
+      }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+    ctx.trustContext = {
+      trustClass: "trusted_contact",
+      guardianPrincipalId: "owner-user",
+      sourceChannel: "vellum",
+    };
+
+    await drainQueue(ctx);
+
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("computer-use");
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("app-control");
+    expect(ctx.currentTurnAuthContext?.actorPrincipalId).toBe(
+      "trusted-contact-user",
+    );
+    expect(ctx.currentTurnSourceActorPrincipalId).toBe("trusted-contact-user");
+  });
+
   test("drainSingleMessage does NOT re-add 'app-control' for web-sourced message when no capable client is connected", async () => {
     // mockCapabilityClients remains [] (reset by afterEach from prior test)
     const queue = new MessageQueue();
@@ -380,6 +419,7 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
       makeQueuedMessage({
         requestId: "req-web-3",
         turnInterfaceContext: ifCtx,
+        sourceActorPrincipalId: "user-1",
       }),
     );
     const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });

package/src/__tests__/conversation-process-callsite.test.ts

@@ -208,14 +208,12 @@ mock.module("../memory/retriever.js", () => ({
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
     compactionCircuit = new CompactionCircuit("test-conv");
-    constructor(
-      _provider: unknown,
-      _systemPrompt: string,
-      options?: {
-        config?: Record<string, unknown>;
-        resolveSystemPrompt?: (history: Message[]) => Record<string, unknown>;
-      },
-    ) {
+    constructor(options?: {
+      provider?: unknown;
+      systemPrompt?: string;
+      config?: Record<string, unknown>;
+      resolveSystemPrompt?: (history: Message[]) => Record<string, unknown>;
+    }) {
       captured.constructorMaxTokens = options?.config?.maxTokens;
       const resolved = options?.resolveSystemPrompt?.([]);
       captured.resolvedMaxTokens = resolved?.maxTokens;
@@ -229,12 +227,13 @@ mock.module("../agent/loop.js", () => ({
     getResolvedTools() {
       return [];
     }
-    async run(
-      messages: Message[],
-      onEvent: (event: Record<string, unknown>) => void,
-      options?: { callSite?: string },
-    ): Promise<Message[]> {
-      captured.callSite = options?.callSite;
+    async run(options: {
+      messages: Message[];
+      onEvent: (event: Record<string, unknown>) => void;
+      callSite?: string;
+    }): Promise<Message[]> {
+      const { messages, onEvent } = options;
+      captured.callSite = options.callSite;
       onEvent({
         type: "usage",
         inputTokens: 0,
@@ -250,9 +249,10 @@ mock.module("../agent/loop.js", () => ({
   },
 }));
 
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -98,58 +98,57 @@ mock.module("../context/token-estimator.js", () => ({
 
 // Overflow recovery module mocks — the convergence loop delegates to these
 // but these tests exercise the Conversation-level flow, not the reducer internals.
-// The reducer mock delegates to the compactFn to simulate a forced compaction
-// tier, matching the real reducer's behavior for Tier 1.
-mock.module("../daemon/context-overflow-reducer.js", () => ({
-  createInitialReducerState: () => ({
-    appliedTiers: [],
-    injectionMode: "full" as const,
-    exhausted: false,
-  }),
-  reduceContextOverflow: async (
-    msgs: Message[],
-    _cfg: unknown,
-    _state: unknown,
-    compactFn?: (
-      m: Message[],
-      s: AbortSignal | undefined,
-      o: Record<string, unknown>,
-    ) => Promise<{
-      compacted: boolean;
-      messages: Message[];
-      compactedPersistedMessages?: number;
-      summaryText?: string;
-      [k: string]: unknown;
-    }>,
-    signal?: AbortSignal,
-  ) => {
-    let resultMessages = msgs;
-    let compactionResult;
-    if (compactFn) {
-      const cr = await compactFn(msgs, signal, { force: true });
+// The reducer mock runs the forced-compaction tier through defaultCompact, which
+// resolves the conversation's ContextWindowManager from the store — mirroring the
+// real reducer's Tier 1.
+mock.module(
+  "../plugins/defaults/compaction/context-overflow-reducer.js",
+  () => ({
+    createInitialReducerState: () => ({
+      appliedTiers: [],
+      injectionMode: "full" as const,
+      exhausted: false,
+    }),
+    reduceContextOverflow: async (
+      msgs: Message[],
+      cfg: { conversationId: string },
+      _state: unknown,
+      signal?: AbortSignal,
+    ) => {
+      const { defaultCompact } =
+        await import("../plugins/defaults/compaction/compact.js");
+      const cr = await defaultCompact({
+        conversationId: cfg.conversationId,
+        messages: msgs,
+        signal,
+        force: true,
+        minKeepRecentUserTurns: 0,
+      });
+      let resultMessages = msgs;
+      let compactionResult;
       if (cr.compacted) {
         resultMessages = cr.messages;
         compactionResult = cr;
       }
-    }
-    return {
-      messages: resultMessages,
-      tier: "forced_compaction",
-      state: {
-        appliedTiers: [
-          "forced_compaction",
-          "tool_result_truncation",
-          "media_stubbing",
-          "injection_downgrade",
-        ],
-        injectionMode: "full",
-        exhausted: true,
-      },
-      estimatedTokens: 1000,
-      compactionResult,
-    };
-  },
-}));
+      return {
+        messages: resultMessages,
+        tier: "forced_compaction",
+        state: {
+          appliedTiers: [
+            "forced_compaction",
+            "tool_result_truncation",
+            "media_stubbing",
+            "injection_downgrade",
+          ],
+          injectionMode: "full",
+          exhausted: true,
+        },
+        estimatedTokens: 1000,
+        compactionResult,
+      };
+    },
+  }),
+);
 
 mock.module("../daemon/context-overflow-policy.js", () => ({
   resolveOverflowAction: () => "fail_gracefully",
@@ -218,9 +217,10 @@ mock.module("../memory/retriever.js", () => ({
 let maybeCompactCalls: Array<{ force: boolean }> = [];
 let forceCompactionEnabled = false;
 
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -280,10 +280,11 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      messages: Message[],
-      onEvent: (event: AgentEvent) => void,
-    ): Promise<AgentLoopRunResult> {
+    async run(options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<AgentLoopRunResult> {
+      const { messages, onEvent } = options;
       // Prime the assistant row anchor — production code emits this from
       // `AgentLoop.run` just before `provider.sendMessage`.
       await onEvent({ type: "llm_call_started" });
@@ -486,11 +487,10 @@ describe("provider ordering error retry", () => {
     firstRunErrorMode = "ordering";
     maybeCompactCalls = [];
     forceCompactionEnabled = false;
-    // Orchestrator pipelines (`overflowReduce`, `persistence`, …) run through
-    // the plugin registry; re-register every default so each pipeline has a
-    // middleware to dispatch to. The `context-overflow-reducer` module itself
-    // (and other collaborators) are mocked above, so the default plugins'
-    // delegates go through the mocked implementations.
+    // The compaction pipeline runs through the plugin registry; re-register
+    // every default so it has a middleware to dispatch to. Collaborators are
+    // mocked above, so the default plugins' delegates go through the mocked
+    // implementations.
     resetPluginRegistryAndRegisterDefaults();
   });
 
@@ -570,7 +570,7 @@ describe("provider ordering error retry", () => {
     });
 
     expect(agentLoopRunCount).toBe(2);
-    expect(maybeCompactCalls).toEqual([{ force: false }, { force: true }]);
+    expect(maybeCompactCalls).toEqual([{ force: true }]);
     expect(events.some((e) => e.type === "message_complete")).toBe(true);
     expect(events.some((e) => e.type === "conversation_error")).toBe(false);
   });
@@ -595,9 +595,10 @@ describe("provider ordering error retry", () => {
     // (forceCompactionEnabled=false), the second run also fails with
     // context_too_large. The overflow policy (fail_gracefully) surfaces error.
     expect(agentLoopRunCount).toBe(2);
-    // Two maybeCompact calls: initial auto-compact (force:false),
-    // reducer's compactFn (force:true).
-    expect(maybeCompactCalls).toEqual([{ force: false }, { force: true }]);
+    // One maybeCompact call: the reducer's compactFn (force:true). The
+    // orchestrator's start-of-turn auto-compact no longer runs — the loop's
+    // pre-call budget gate owns turn-start compaction and doesn't trip here.
+    expect(maybeCompactCalls).toEqual([{ force: true }]);
 
     expect(events.some((e) => e.type === "conversation_error")).toBe(true);
   });
@@ -618,7 +619,7 @@ describe("provider ordering error retry", () => {
 
     // Same as above — convergence loop re-runs agent loop, which also fails.
     expect(agentLoopRunCount).toBe(2);
-    expect(maybeCompactCalls).toEqual([{ force: false }, { force: true }]);
+    expect(maybeCompactCalls).toEqual([{ force: true }]);
     expect(events.some((e) => e.type === "conversation_error")).toBe(true);
   });
 
@@ -637,7 +638,7 @@ describe("provider ordering error retry", () => {
     });
 
     expect(agentLoopRunCount).toBe(2);
-    expect(maybeCompactCalls).toEqual([{ force: false }, { force: true }]);
+    expect(maybeCompactCalls).toEqual([{ force: true }]);
     expect(events.some((e) => e.type === "message_complete")).toBe(true);
     expect(events.some((e) => e.type === "conversation_error")).toBe(false);
   });
@@ -660,7 +661,7 @@ describe("provider ordering error retry", () => {
     // the regex patterns, but classifyConversationError recognizes statusCode 413
     // as CONTEXT_TOO_LARGE and sets contextTooLargeDetected = true.
     expect(agentLoopRunCount).toBe(2);
-    expect(maybeCompactCalls).toEqual([{ force: false }, { force: true }]);
+    expect(maybeCompactCalls).toEqual([{ force: true }]);
     expect(events.some((e) => e.type === "message_complete")).toBe(true);
     expect(events.some((e) => e.type === "conversation_error")).toBe(false);
   });

package/src/__tests__/conversation-queue.test.ts

@@ -262,9 +262,10 @@ mock.module("../memory/retriever.js", () => ({
   injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -353,15 +354,14 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      messages: Message[],
-      onEvent: (event: AgentEvent) => void | Promise<void>,
-      options?: {
-        onCheckpoint?: (
-          checkpoint: CheckpointInfo,
-        ) => CheckpointDecision | Promise<CheckpointDecision>;
-      },
-    ): Promise<AgentLoopRunResult> {
+    async run(options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void | Promise<void>;
+      onCheckpoint?: (
+        checkpoint: CheckpointInfo,
+      ) => CheckpointDecision | Promise<CheckpointDecision>;
+    }): Promise<AgentLoopRunResult> {
+      const { messages, onEvent } = options;
       return new Promise<AgentLoopRunResult>((resolveResult, reject) => {
         const pending: PendingRun = {
           resolve: (history: Message[]) =>