@vellumai/assistant 0.8.9-staging.1 → 0.8.9-staging.3

package/src/__tests__/agent-loop-output-hooks.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for the `pre-model-call` and `assistant-message` plugin hooks: a plugin
+ * Tests for the `pre-model-call` and `post-model-call` plugin hooks: a plugin
  * can edit the outbound request, transform the finalized assistant message
  * (persisted + streamed), and defer the live stream so the transformed text is
  * emitted once. All hooks here use neutral transforms (redaction / uppercasing).
@@ -9,7 +9,7 @@ import { beforeEach, describe, expect, test } from "bun:test";
 import type { AgentEvent } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
 import type {
-  AssistantMessageContext,
+  PostModelCallContext,
   PreModelCallContext,
 } from "../plugin-api/types.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
@@ -55,7 +55,7 @@ function lastAssistant(history: Message[]): Message {
 
 function registerOutputHookPlugin(hooks: {
   preModelCall?: (ctx: PreModelCallContext) => void;
-  assistantMessage?: (ctx: AssistantMessageContext) => void;
+  postModelCall?: (ctx: PostModelCallContext) => void;
 }): void {
   registerPlugin({
     manifest: { name: "test-output-hooks", version: "0.0.0" },
@@ -67,10 +67,10 @@ function registerOutputHookPlugin(hooks: {
             },
           }
         : {}),
-      ...(hooks.assistantMessage
+      ...(hooks.postModelCall
         ? {
-            "assistant-message": async (ctx: AssistantMessageContext) => {
-              hooks.assistantMessage!(ctx);
+            "post-model-call": async (ctx: PostModelCallContext) => {
+              hooks.postModelCall!(ctx);
             },
           }
         : {}),
@@ -83,9 +83,9 @@ describe("agent loop output hooks", () => {
     resetPluginRegistryAndRegisterDefaults();
   });
 
-  test("assistant-message transforms the persisted message content", async () => {
+  test("post-model-call transforms the persisted message content", async () => {
     registerOutputHookPlugin({
-      assistantMessage: (ctx) => {
+      postModelCall: (ctx) => {
         ctx.content = ctx.content.map((b) =>
           b.type === "text"
             ? { type: "text", text: b.text.replace("secret", "[redacted]") }
@@ -113,7 +113,7 @@ describe("agent loop output hooks", () => {
       preModelCall: (ctx) => {
         ctx.deferAssistantOutput = true;
       },
-      assistantMessage: (ctx) => {
+      postModelCall: (ctx) => {
         ctx.content = [{ type: "text", text: "[filtered]" }];
       },
     });
@@ -137,7 +137,7 @@ describe("agent loop output hooks", () => {
 
   test("without defer, the real text still streams while storage is transformed", async () => {
     registerOutputHookPlugin({
-      assistantMessage: (ctx) => {
+      postModelCall: (ctx) => {
         ctx.content = [{ type: "text", text: "[stored]" }];
       },
     });
@@ -168,7 +168,7 @@ describe("agent loop output hooks", () => {
       stopReason: "tool_use",
     };
     registerOutputHookPlugin({
-      assistantMessage: (ctx) => {
+      postModelCall: (ctx) => {
         ctx.content = ctx.content.map((b) =>
           b.type === "text" ? { type: "text", text: b.text.toUpperCase() } : b,
         );
@@ -237,7 +237,7 @@ describe("agent loop output hooks", () => {
     // mid-mutation would survive into history. The loop must clone the
     // content before invoking the hook.
     registerOutputHookPlugin({
-      assistantMessage: (ctx) => {
+      postModelCall: (ctx) => {
         ctx.content.push({ type: "text", text: "[INJECTED]" });
         throw new Error("boom");
       },
@@ -269,7 +269,7 @@ describe("agent loop output hooks", () => {
       preModelCall: (ctx) => {
         ctx.deferAssistantOutput = true;
       },
-      assistantMessage: (ctx) => {
+      postModelCall: (ctx) => {
         seen.calls += 1;
         ctx.content = ctx.content.map((b) =>
           b.type === "text" ? { type: "text", text: b.text.toUpperCase() } : b,

package/src/__tests__/app-builder-tool-scripts.test.ts

@@ -81,6 +81,7 @@ mock.module("../bundler/app-compiler.js", () => ({
 import * as appCreateScript from "../config/bundled-skills/app-builder/tools/app-create.js";
 import * as appDeleteScript from "../config/bundled-skills/app-builder/tools/app-delete.js";
 import * as appRefreshScript from "../config/bundled-skills/app-builder/tools/app-refresh.js";
+import * as appUpdateScript from "../config/bundled-skills/app-builder/tools/app-update.js";
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -171,4 +172,24 @@ describe("app-builder skill tool scripts", () => {
       expect(parsed.appId).toBe("app-1");
     });
   });
+
+  // ---- app-update --------------------------------------------------------
+
+  describe("app-update", () => {
+    test("exports a run function", () => {
+      expect(typeof appUpdateScript.run).toBe("function");
+    });
+
+    test("delegates to executeAppUpdate and returns result", async () => {
+      const result = await appUpdateScript.run(
+        { app_id: "app-1", name: "Renamed" },
+        makeContext(),
+      );
+      expect(result.isError).toBe(false);
+      const parsed = JSON.parse(result.content);
+      expect(parsed.updated).toBe(true);
+      expect(parsed.appId).toBe("app-1");
+      expect(parsed.name).toBe("Renamed");
+    });
+  });
 });

package/src/__tests__/app-executors.test.ts

@@ -32,6 +32,7 @@ import type { AppStore } from "../tools/apps/executors.js";
 import {
   executeAppCreate,
   executeAppRefresh,
+  executeAppUpdate,
 } from "../tools/apps/executors.js";
 
 // ---------------------------------------------------------------------------
@@ -89,6 +90,46 @@ function mockStore(
 // ---------------------------------------------------------------------------
 
 describe("executeAppCreate", () => {
+  test("falls back to the preview title when the name is omitted or blank", async () => {
+    let createdParams: Record<string, unknown> | undefined;
+    const app = makeMultifileApp({ name: "Coffee Tracker" });
+    const store: AppStore = {
+      ...mockStore(app, {}),
+      createApp: (params) => {
+        createdParams = params as unknown as Record<string, unknown>;
+        return app;
+      },
+    };
+
+    const result = await executeAppCreate(
+      { name: "   ", preview: { title: "Coffee Tracker" } },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(createdParams?.name).toBe("Coffee Tracker");
+  });
+
+  test("defaults the name to 'New App' when neither name nor preview title is given", async () => {
+    let createdParams: Record<string, unknown> | undefined;
+    const app = makeMultifileApp({ name: "New App" });
+    const store: AppStore = {
+      ...mockStore(app, {}),
+      createApp: (params) => {
+        createdParams = params as unknown as Record<string, unknown>;
+        return app;
+      },
+    };
+
+    const result = await executeAppCreate(
+      {} as unknown as Parameters<typeof executeAppCreate>[0],
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(createdParams?.name).toBe("New App");
+  });
+
   test("creates multifile app with src/ scaffold", async () => {
     const files: Record<string, string> = {};
     let createdParams: Record<string, unknown> | undefined;
@@ -408,3 +449,94 @@ describe("executeAppRefresh", () => {
     expect(parsed.error).toContain("not found");
   });
 });
+
+// ---------------------------------------------------------------------------
+// executeAppUpdate
+// ---------------------------------------------------------------------------
+
+describe("executeAppUpdate", () => {
+  test("updates metadata and recompiles a multifile app", async () => {
+    const app = makeMultifileApp({ name: "Old", description: "old desc" });
+    let updateArgs: unknown;
+    const store: AppStore = {
+      ...mockStore(app),
+      updateApp: (_id, updates) => {
+        updateArgs = updates;
+        return { ...app, ...updates };
+      },
+    };
+
+    const result = await executeAppUpdate(
+      { app_id: app.id, name: "New Name", description: "new desc" },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(updateArgs).toEqual({ name: "New Name", description: "new desc" });
+    const parsed = JSON.parse(result.content);
+    expect(parsed.updated).toBe(true);
+    expect(parsed.name).toBe("New Name");
+    expect(parsed.description).toBe("new desc");
+    expect(parsed.compiled).toBe(true);
+  });
+
+  test("writes source_files before recompiling", async () => {
+    const files: Record<string, string> = {};
+    const app = makeMultifileApp();
+    const store: AppStore = {
+      ...mockStore(app, files),
+      updateApp: (_id, updates) => ({ ...app, ...updates }),
+    };
+
+    const result = await executeAppUpdate(
+      { app_id: app.id, source_files: { "src/App.tsx": "// new code" } },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(files["src/App.tsx"]).toBe("// new code");
+    expect(JSON.parse(result.content).compiled).toBe(true);
+  });
+
+  test("legacy app: updates without compiling", async () => {
+    const app = makeLegacyApp({ name: "Legacy" });
+    const store: AppStore = {
+      ...mockStore(app),
+      updateApp: (_id, updates) => ({ ...app, ...updates }),
+    };
+
+    const result = await executeAppUpdate(
+      { app_id: app.id, name: "Renamed" },
+      store,
+    );
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.updated).toBe(true);
+    expect(parsed.name).toBe("Renamed");
+    expect(parsed.compiled).toBeUndefined();
+  });
+
+  test("returns error for unknown app", async () => {
+    const store = mockStore(makeMultifileApp());
+    const result = await executeAppUpdate({ app_id: "nope" }, store);
+
+    expect(result.isError).toBe(true);
+    expect(JSON.parse(result.content).error).toContain("not found");
+  });
+
+  test("rejects invalid source_files", async () => {
+    const app = makeMultifileApp();
+    const store = mockStore(app);
+    const result = await executeAppUpdate(
+      {
+        app_id: app.id,
+        source_files: { "src/App.tsx": 123 as unknown as string },
+      },
+      store,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(JSON.parse(result.content).error).toContain("must be a string");
+  });
+});

package/src/__tests__/approval-cascade.test.ts

@@ -173,7 +173,7 @@ 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() {}

package/src/__tests__/compaction-direct.test.ts

@@ -3,19 +3,29 @@
  *
  * The agent loop calls {@link defaultCompact} directly with a
  * {@link CompactionContext} rather than routing through a middleware pipeline.
- * These tests assert that the default implementation delegates to the
- * supplied {@link ContextWindowManager} and forwards the request's
- * conversational options verbatim. The orchestrator integration path
- * (conversation-agent-loop) is exercised by
+ * These tests assert that the default implementation resolves the
+ * conversation's {@link ContextWindowManager} from the compaction store and
+ * forwards the request's conversational options verbatim. The orchestrator
+ * integration path (conversation-agent-loop) is exercised by
  * `conversation-agent-loop-overflow.test.ts`.
  */
 
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
 
-import {
-  type CompactionContext,
-  defaultCompact,
-} from "../plugins/defaults/compaction/compact.js";
+// `defaultCompact` resolves the manager from the per-conversation compaction
+// store. Register each test's canned stub in a map the mocked store reads from.
+const fakeContextWindowManagers = new Map<string, unknown>();
+mock.module("../plugins/defaults/compaction/manager-store.js", () => ({
+  createContextWindowManager: () => undefined,
+  getContextWindowManager: (conversationId: string) =>
+    fakeContextWindowManagers.get(conversationId),
+  disposeContextWindowManager: (conversationId: string) => {
+    fakeContextWindowManagers.delete(conversationId);
+  },
+}));
+
+const { defaultCompact } =
+  await import("../plugins/defaults/compaction/compact.js");
 
 type ContextWindowResultShape = {
   compacted: boolean;
@@ -55,13 +65,17 @@ function makeResult(
   };
 }
 
-function makeManager(result: ContextWindowResultShape) {
+/** Register a stub manager under a conversation id and return its recorder. */
+function registerManager(
+  conversationId: string,
+  result: ContextWindowResultShape,
+) {
   const observed: {
     messages: unknown;
     signal: unknown;
     options: unknown;
   }[] = [];
-  const manager = {
+  fakeContextWindowManagers.set(conversationId, {
     maybeCompact: async (
       messages: unknown,
       signal: unknown,
@@ -70,8 +84,8 @@ function makeManager(result: ContextWindowResultShape) {
       observed.push({ messages, signal, options });
       return result;
     },
-  } as unknown as CompactionContext["manager"];
-  return { manager, observed };
+  });
+  return observed;
 }
 
 describe("defaultCompact", () => {
@@ -81,13 +95,13 @@ describe("defaultCompact", () => {
       summaryText: "manager-summary",
       compactedMessages: 7,
     });
-    const { manager, observed } = makeManager(expected);
+    const observed = registerManager("conv-delegates", expected);
     const messages = [{ role: "user", content: "hi" }] as never;
     const signal = new AbortController().signal;
 
     // WHEN defaultCompact runs with those messages and a signal
     const result = (await defaultCompact({
-      manager,
+      conversationId: "conv-delegates",
       messages,
       signal,
     })) as unknown as ContextWindowResultShape;
@@ -105,11 +119,11 @@ describe("defaultCompact", () => {
 
   test("forwards the request's compaction options to the manager", async () => {
     // GIVEN a manager and a fully-populated compaction context
-    const { manager, observed } = makeManager(makeResult());
+    const observed = registerManager("conv-options", makeResult());
 
     // WHEN defaultCompact runs with force/profile/trust options
     await defaultCompact({
-      manager,
+      conversationId: "conv-options",
       messages: [] as never,
       force: true,
       overrideProfile: "fast-profile",
@@ -118,7 +132,7 @@ describe("defaultCompact", () => {
       actorTrustClass: "guardian",
     });
 
-    // THEN the manager received exactly those options, and the manager,
+    // THEN the manager received exactly those options, and the conversation id,
     // messages, and signal are not leaked into the options bag
     expect(observed).toHaveLength(1);
     expect(observed[0]!.options).toEqual({

package/src/__tests__/compaction-events.test.ts

@@ -12,8 +12,8 @@ import { describe, expect, mock, test } from "bun:test";
 
 import { CompactionCircuit } from "../agent/compaction-circuit.js";
 import type { AgentEvent } from "../agent/loop.js";
-import type { ContextWindowResult } from "../context/window-manager.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { ContextWindowResult } from "../plugins/defaults/compaction/window-manager.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
@@ -187,7 +187,7 @@ let mockCompactResult: ContextWindowResult = {
   summaryText: "",
 };
 
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     nonPersistedPrefixCount = 0;
     constructor() {}

package/src/__tests__/compaction.benchmark.test.ts

@@ -12,7 +12,7 @@ import { describe, expect, mock, test } from "bun:test";
 
 import { DEFAULT_CONFIG } from "../config/defaults.js";
 import { estimatePromptTokens } from "../context/token-estimator.js";
-import { ContextWindowManager } from "../context/window-manager.js";
+import { ContextWindowManager } from "../plugins/defaults/compaction/window-manager.js";
 import type { Message, Provider } from "../providers/types.js";
 
 mock.module("../util/logger.js", () => ({

package/src/__tests__/compactor-web-search-strip.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, mock, test } from "bun:test";
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getMessages: () => [],
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentMetadataForMessage: () => [],
+  getAttachmentContent: () => null,
+}));
+
+import {
+  runAssistantDrivenCompaction,
+  runEmergencyCompaction,
+} from "../context/compactor.js";
+import type { Message, Provider } from "../providers/types.js";
+
+const TAIL_TIMESTAMP =
+  "2026-05-21 (Thursday) 10:00:00 -05:00 (America/Chicago)";
+
+const compactionResponse = `
+<compaction_result>
+<summary>
+Earlier turns summarized here.
+</summary>
+
+<key_state>
+- Nothing critical pending.
+</key_state>
+
+<tail_start timestamp="${TAIL_TIMESTAMP}" preview="tail anchor message" />
+</compaction_result>
+`;
+
+const ENCRYPTED_TOKEN = "expired_encrypted_token_abc123";
+
+const userText = (text: string): Message => ({
+  role: "user",
+  content: [{ type: "text", text }],
+});
+
+const userTextWithTurnContext = (text: string, timestamp: string): Message => ({
+  role: "user",
+  content: [
+    {
+      type: "text",
+      text: `<turn_context>\ncurrent_time: ${timestamp}\n</turn_context>\n${text}`,
+    },
+  ],
+});
+
+const assistantWithWebSearch = (): Message => ({
+  role: "assistant",
+  content: [
+    {
+      type: "server_tool_use",
+      id: "stu_1",
+      name: "web_search",
+      input: { query: "cats" },
+    },
+    {
+      type: "web_search_tool_result",
+      tool_use_id: "stu_1",
+      content: [
+        {
+          type: "web_search_result",
+          url: "https://cats.example",
+          title: "All About Cats",
+          encrypted_content: ENCRYPTED_TOKEN,
+        },
+      ],
+    },
+  ],
+});
+
+const assistantToolUse = (): Message => ({
+  role: "assistant",
+  content: [
+    { type: "tool_use", id: "tu_1", name: "bash", input: { cmd: "ls" } },
+  ],
+});
+
+const toolResult = (): Message => ({
+  role: "user",
+  content: [{ type: "tool_result", tool_use_id: "tu_1", content: "ok" }],
+});
+
+function serializeBlocks(messages: Message[]): string {
+  return JSON.stringify(messages);
+}
+
+// Records the exact message list the provider is asked to summarize.
+function recordingProvider(sink: { sent: Message[] }): Provider {
+  return {
+    name: "mock-provider",
+    sendMessage: async (msgs: Message[]) => {
+      sink.sent = msgs;
+      return {
+        content: [{ type: "text", text: compactionResponse }],
+        model: "mock-model",
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+}
+
+// Expired Anthropic web-search tokens must never reach the summarization LLM:
+// both compaction provider calls funnel through the same request builder, so
+// each is guarded here.
+describe("compaction summary calls — historical web-search sanitization", () => {
+  test("runAssistantDrivenCompaction strips expired encrypted_content from the request while leaving durable history untouched", async () => {
+    // GIVEN a history whose older turn contains a native web_search_tool_result
+    // block carrying an opaque, expired `encrypted_content` token
+    const messages: Message[] = [
+      userText("old user turn"),
+      assistantWithWebSearch(),
+      userTextWithTurnContext("tail anchor message", TAIL_TIMESTAMP),
+      assistantWithWebSearch(),
+    ];
+
+    // AND a snapshot of the caller's array so we can assert it is not mutated
+    const inputSnapshot = serializeBlocks(messages);
+    const sink = { sent: [] as Message[] };
+
+    // WHEN compaction runs over that history
+    const result = await runAssistantDrivenCompaction({
+      conversationId: "conv-web-search",
+      messages,
+      provider: recordingProvider(sink),
+      systemPrompt: "system",
+      compaction: { enabled: true, autoThreshold: 0.7 },
+      maxInputTokens: 1000,
+      previousEstimatedInputTokens: 900,
+    });
+
+    // THEN the summary request the provider received carries no expired token
+    // and no native web_search blocks, but keeps the search content as text
+    const sentSerialized = serializeBlocks(sink.sent);
+    expect(sentSerialized).not.toContain(ENCRYPTED_TOKEN);
+    expect(sentSerialized).not.toContain("web_search_tool_result");
+    expect(sentSerialized).not.toContain("server_tool_use");
+    expect(sentSerialized).toContain("All About Cats");
+    expect(sentSerialized).toContain("https://cats.example");
+
+    // AND the caller's durable history array is left byte-for-byte untouched,
+    // so persisted messages keep the original rich blocks
+    expect(serializeBlocks(messages)).toBe(inputSnapshot);
+    expect(result.compacted).toBe(true);
+  });
+
+  test("runEmergencyCompaction strips expired encrypted_content from the prefix request", async () => {
+    // GIVEN a mid-turn history whose prefix (before the last tool pair) holds a
+    // web_search_tool_result block with an expired token
+    const messages: Message[] = [
+      userText("old user turn"),
+      assistantWithWebSearch(),
+      userText("keep going"),
+      assistantToolUse(),
+      toolResult(),
+    ];
+
+    const inputSnapshot = serializeBlocks(messages);
+    const sink = { sent: [] as Message[] };
+
+    // WHEN emergency compaction splits at the last tool pair and summarizes the
+    // prefix
+    const result = await runEmergencyCompaction({
+      conversationId: "conv-web-search-emergency",
+      messages,
+      provider: recordingProvider(sink),
+      systemPrompt: "system",
+      compaction: { enabled: true, autoThreshold: 0.7 },
+      // Large budget so the prefix is not front-truncated — this test exercises
+      // the web-search sanitizer, not the truncation fallback.
+      maxInputTokens: 100000,
+      previousEstimatedInputTokens: 90000,
+    });
+
+    // THEN the prefix sent to the provider carries no expired token
+    const sentSerialized = serializeBlocks(sink.sent);
+    expect(sentSerialized).not.toContain(ENCRYPTED_TOKEN);
+    expect(sentSerialized).not.toContain("web_search_tool_result");
+    expect(sentSerialized).not.toContain("server_tool_use");
+    expect(sentSerialized).toContain("All About Cats");
+
+    // AND the caller's durable history is untouched
+    expect(serializeBlocks(messages)).toBe(inputSnapshot);
+    expect(result.compacted).toBe(true);
+  });
+});

package/src/__tests__/context-overflow-reducer.test.ts

@@ -1,17 +1,17 @@
 import { describe, expect, test } from "bun:test";
 
 import { estimatePromptTokens } from "../context/token-estimator.js";
-import type {
-  ContextWindowCompactOptions,
-  ContextWindowResult,
-} from "../context/window-manager.js";
-import { createContextSummaryMessage } from "../context/window-manager.js";
 import {
   createInitialReducerState,
   reduceContextOverflow,
   type ReducerConfig,
   type ReducerState,
-} from "../daemon/context-overflow-reducer.js";
+} from "../plugins/defaults/compaction/context-overflow-reducer.js";
+import type {
+  ContextWindowCompactOptions,
+  ContextWindowResult,
+} from "../plugins/defaults/compaction/window-manager.js";
+import { createContextSummaryMessage } from "../plugins/defaults/compaction/window-manager.js";
 import type { Message } from "../providers/types.js";
 
 function msg(role: "user" | "assistant", text: string): Message {

package/src/__tests__/context-window-manager-compact-retry.test.ts

@@ -94,7 +94,7 @@ mock.module("../context/compactor.js", () => ({
   },
 }));
 
-import { ContextWindowManager } from "../context/window-manager.js";
+import { ContextWindowManager } from "../plugins/defaults/compaction/window-manager.js";
 import type { Message, Provider } from "../providers/types.js";
 
 function makeProvider(): Provider {

package/src/__tests__/conversation-abort-tool-results.test.ts

@@ -167,7 +167,7 @@ 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() {}