@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/__tests__/helpers/native-web-search-harness.ts

@@ -0,0 +1,129 @@
+/**
+ * Shared test harness for driving the daemon's native `server_tool_complete`
+ * web_search handler in isolation (ATL-727).
+ *
+ * Both `native-web-search.test.ts` and `web-search-backend-failure.test.ts`
+ * exercise the same handler the same way: build a set of mocked
+ * `EventHandlerDeps` (capturing emitted `ServerMessage`s and `rlog.warn`
+ * records), then drive a `server_tool_start` → `server_tool_complete` pair.
+ * This module is the single source of truth for that harness so the two suites
+ * cannot drift apart.
+ *
+ * Note: each consuming test file must still install its own
+ * `mock.module(...)` stubs for the daemon collaborators the handler imports at
+ * load time (config loader, conversation-crud, llm-request-log-store), because
+ * Bun's `mock.module()` is scoped to the file that registers it.
+ */
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../../daemon/conversation-agent-loop-handlers.js";
+import { dispatchAgentEvent } from "../../daemon/conversation-agent-loop-handlers.js";
+import type { ServerMessage } from "../../daemon/message-protocol.js";
+
+/** A `tool_result` `ServerMessage` emitted by the handler. */
+export type ToolResultEvent = Extract<ServerMessage, { type: "tool_result" }>;
+
+/** A captured `rlog.warn(obj, msg)` call. */
+export interface LogRecord {
+  obj: Record<string, unknown>;
+  msg?: string;
+}
+
+export interface HandlerHarness {
+  deps: EventHandlerDeps;
+  /** Every `ServerMessage` the handler emitted via `onEvent`. */
+  events: ServerMessage[];
+  /** Every `rlog.warn(obj, msg)` call the handler made. */
+  warnings: LogRecord[];
+}
+
+/** Build mocked handler deps that capture emitted events and warn logs. */
+export function createHandlerDeps(reqId = "req-web-search"): HandlerHarness {
+  const events: ServerMessage[] = [];
+  const warnings: LogRecord[] = [];
+  const rlog = {
+    warn: (obj: Record<string, unknown>, msg?: string) =>
+      warnings.push({ obj, msg }),
+    info: () => {},
+    error: () => {},
+    debug: () => {},
+    trace: () => {},
+    fatal: () => {},
+  };
+  const deps = {
+    ctx: {
+      conversationId: "conv-web-search",
+      provider: { name: "anthropic" },
+      traceEmitter: { emit: () => {} },
+      streamThinking: false,
+      emitActivityState: () => {},
+      markWorkspaceTopLevelDirty: () => {},
+      currentTurnSurfaces: [],
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: (msg: ServerMessage) => events.push(msg),
+    reqId,
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: rlog as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    } as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
+  } as EventHandlerDeps;
+  return { deps, events, warnings };
+}
+
+/** The `server_tool_complete` payload shape a test supplies. */
+export interface WebSearchCompleteEvent {
+  isError: boolean;
+  errorCode?: string;
+  errorMessage?: string;
+  content?: unknown[];
+}
+
+/** Drive one native (Anthropic) web_search start → complete pair. */
+export async function completeNativeWebSearch(
+  state: EventHandlerState,
+  deps: EventHandlerDeps,
+  toolUseId: string,
+  event: WebSearchCompleteEvent,
+): Promise<void> {
+  await dispatchAgentEvent(state, deps, {
+    type: "server_tool_start",
+    name: "web_search",
+    toolUseId,
+    input: { query: "what is the weather" },
+  });
+  await dispatchAgentEvent(state, deps, {
+    type: "server_tool_complete",
+    toolUseId,
+    isError: event.isError,
+    ...(event.errorCode ? { errorCode: event.errorCode } : {}),
+    ...(event.errorMessage ? { errorMessage: event.errorMessage } : {}),
+    content: event.content ?? [],
+  });
+}
+
+/** All `tool_result` events emitted so far, in order. */
+export function toolResults(events: ServerMessage[]): ToolResultEvent[] {
+  return events.filter((e): e is ToolResultEvent => e.type === "tool_result");
+}
+
+/** The most recent `tool_result` event, if any. */
+export function lastToolResult(
+  events: ServerMessage[],
+): ToolResultEvent | undefined {
+  const results = toolResults(events);
+  return results[results.length - 1];
+}
+
+/** The captured `web_search_backend_failure` telemetry warn records. */
+export function backendFailureLogs(warnings: LogRecord[]): LogRecord[] {
+  return warnings.filter((w) => w.obj.event === "web_search_backend_failure");
+}

package/src/__tests__/history-repair-hook.test.ts

@@ -40,6 +40,7 @@ const noopLogger: PluginLogger = {
 function makeCtx(messages: Message[]): UserPromptSubmitContext {
   return {
     conversationId: "conv-test",
+    prompt: "",
     originalMessages: messages,
     latestMessages: messages,
     logger: noopLogger,

package/src/__tests__/host-app-control-routes.test.ts

@@ -47,7 +47,7 @@ interface FakeConversation {
 
 const conversations = new Map<string, FakeConversation>();
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => conversations.get(id),
 }));
 

package/src/__tests__/host-cu-routes-targeted.test.ts

@@ -8,9 +8,9 @@
  *  4. Untargeted (no targetClientId, no header) → 200 accepted (regression)
  *
  * Resolution goes through conversation.hostCuProxy?.resolve(...). The
- * conversation store is mocked to return a controlled conversation object.
+ * conversation registry is mocked to return a controlled conversation object.
  *
- * Note: host-cu-routes.ts has a deep import chain (conversation-store →
+ * Note: host-cu-routes.ts has a deep import chain (conversation-registry →
  * conversation.ts → ces-client → service-contracts) that requires mocking
  * before the module loads. We use dynamic imports to ensure all mocks are
  * registered before the route module is evaluated.
@@ -75,7 +75,7 @@ const conversationStore = new Map<
   { hostCuProxy?: { processObservation: (...args: unknown[]) => void } }
 >();
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (conversationId: string) =>
     conversationStore.get(conversationId),
 }));

package/src/__tests__/identity-intro-cache.test.ts

@@ -1,9 +1,8 @@
 /**
  * Unit tests for the identity intro cache (identity-intro-cache.ts).
  *
- * Validates TTL-based expiration, content-hash-based invalidation when
- * workspace identity files or the guardian persona content change, and
- * round-trip get/set behavior.
+ * Validates TTL-based expiration, round-trip get/set behavior, and parsing
+ * workspace-authored greeting sections.
  */
 
 import { afterEach, describe, expect, mock, test } from "bun:test";
@@ -45,20 +44,11 @@ mock.module("node:fs", () => ({
   },
 }));
 
-// Mocked guardian persona — mutable so tests can change it and verify cache
-// invalidation based on the per-user persona file content.
-let guardianPersonaContent: string | null = null;
-
-mock.module("../prompts/persona-resolver.js", () => ({
-  resolveGuardianPersona: () => guardianPersonaContent,
-}));
-
 // ---------------------------------------------------------------------------
 // Imports (after mocks)
 // ---------------------------------------------------------------------------
 
 import {
-  computeIdentityContentHash,
   getCachedIntro,
   parseGreetingsSection,
   readWorkspaceGreetings,
@@ -75,7 +65,6 @@ afterEach(() => {
   for (const key of Object.keys(workspaceFiles)) {
     delete workspaceFiles[key];
   }
-  guardianPersonaContent = null;
 });
 
 // ---------------------------------------------------------------------------
@@ -118,7 +107,6 @@ describe("identity intro cache", () => {
   test("round-trip: set then get returns cached greetings array", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
     workspaceFiles["SOUL.md"] = "Be playful.";
-    guardianPersonaContent = "The user likes coffee.";
 
     setCachedIntro(["Hey, I'm Atlas.", "What's up?"]);
     const cached = getCachedIntro();
@@ -131,111 +119,45 @@ describe("identity intro cache", () => {
 
     setCachedIntro(["Hello!"]);
 
-    // Manually set the timestamp to 5 hours ago
-    const fiveHoursAgo = String(Date.now() - 5 * 60 * 60 * 1000);
-    checkpointStore.set("identity:intro:cached_at", fiveHoursAgo);
+    const fortyNineHoursAgo = String(Date.now() - 49 * 60 * 60 * 1000);
+    checkpointStore.set("identity:intro:cached_at", fortyNineHoursAgo);
 
     expect(getCachedIntro()).toBeNull();
   });
 
-  test("returns cached greetings when within TTL (3 hours ago)", () => {
+  test("returns cached greetings when within TTL (47 hours ago)", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
 
     setCachedIntro(["Hello!"]);
 
-    // Set timestamp to 3 hours ago (within 4-hour TTL)
-    const threeHoursAgo = String(Date.now() - 3 * 60 * 60 * 1000);
-    checkpointStore.set("identity:intro:cached_at", threeHoursAgo);
+    const fortySevenHoursAgo = String(Date.now() - 47 * 60 * 60 * 1000);
+    checkpointStore.set("identity:intro:cached_at", fortySevenHoursAgo);
 
     const cached = getCachedIntro();
     expect(cached).not.toBeNull();
     expect(cached!.greetings).toEqual(["Hello!"]);
   });
 
-  test("busts cache when IDENTITY.md changes", () => {
+  test("keeps cached greetings when IDENTITY.md changes", () => {
     workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
     setCachedIntro(["I'm Atlas!"]);
 
-    // Change IDENTITY.md
     workspaceFiles["IDENTITY.md"] = "- **Name:** Nova";
 
-    expect(getCachedIntro()).toBeNull();
+    expect(getCachedIntro()?.greetings).toEqual(["I'm Atlas!"]);
   });
 
-  test("busts cache when SOUL.md changes", () => {
+  test("keeps cached greetings when SOUL.md changes", () => {
     workspaceFiles["SOUL.md"] = "Be playful.";
     setCachedIntro(["Hey there!"]);
 
-    // Change SOUL.md
     workspaceFiles["SOUL.md"] = "Be serious and formal.";
 
-    expect(getCachedIntro()).toBeNull();
-  });
-
-  test("busts cache when guardian persona content changes", () => {
-    guardianPersonaContent = "Likes coffee.";
-    setCachedIntro(["Good morning!"]);
-
-    // Change guardian persona (e.g. user edited users/<slug>.md)
-    guardianPersonaContent = "Likes tea.";
-
-    expect(getCachedIntro()).toBeNull();
-  });
-
-  test("cache remains valid when guardian persona is unchanged", () => {
-    workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
-    workspaceFiles["SOUL.md"] = "Be chill.";
-    guardianPersonaContent = "Likes sunsets.";
-
-    setCachedIntro(["Atlas here.", "Hey friend."]);
-
-    expect(getCachedIntro()?.greetings).toEqual(["Atlas here.", "Hey friend."]);
-    expect(getCachedIntro()?.greetings).toEqual(["Atlas here.", "Hey friend."]);
-  });
-
-  test("computeIdentityContentHash is deterministic", () => {
-    workspaceFiles["IDENTITY.md"] = "test";
-    workspaceFiles["SOUL.md"] = "test2";
-    guardianPersonaContent = "test3";
-
-    const hash1 = computeIdentityContentHash();
-    const hash2 = computeIdentityContentHash();
-    expect(hash1).toBe(hash2);
-    expect(hash1).toMatch(/^[a-f0-9]{64}$/); // SHA-256 hex
-  });
-
-  test("computeIdentityContentHash changes when guardian persona changes", () => {
-    workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
-    workspaceFiles["SOUL.md"] = "Be playful.";
-    guardianPersonaContent = "Likes coffee.";
-    const hash1 = computeIdentityContentHash();
-
-    guardianPersonaContent = "Likes tea.";
-    const hash2 = computeIdentityContentHash();
-
-    expect(hash1).not.toBe(hash2);
-  });
-
-  test("computeIdentityContentHash handles null guardian persona", () => {
-    workspaceFiles["IDENTITY.md"] = "- **Name:** Atlas";
-    guardianPersonaContent = null;
-
-    const hash = computeIdentityContentHash();
-    expect(hash).toMatch(/^[a-f0-9]{64}$/);
-  });
-
-  test("computeIdentityContentHash changes when file content changes", () => {
-    workspaceFiles["IDENTITY.md"] = "v1";
-    const hash1 = computeIdentityContentHash();
-
-    workspaceFiles["IDENTITY.md"] = "v2";
-    const hash2 = computeIdentityContentHash();
-
-    expect(hash1).not.toBe(hash2);
+    expect(getCachedIntro()?.greetings).toEqual(["Hey there!"]);
   });
 
   test("handles missing workspace files gracefully", () => {
-    // No files exist — should still work (empty content hashed)
+    // No files exist — should still work.
     setCachedIntro(["Hello!"]);
     const cached = getCachedIntro();
     expect(cached).not.toBeNull();
@@ -244,9 +166,7 @@ describe("identity intro cache", () => {
 
   test("handles legacy single-string cache value", () => {
     // Simulate a cache entry written by an older daemon version
-    const hash = computeIdentityContentHash();
     checkpointStore.set("identity:intro:greetings", "Legacy greeting");
-    checkpointStore.set("identity:intro:content_hash", hash);
     checkpointStore.set("identity:intro:cached_at", String(Date.now()));
 
     const cached = getCachedIntro();
@@ -255,20 +175,12 @@ describe("identity intro cache", () => {
   });
 
   test("returns null when greetings checkpoint is missing", () => {
-    checkpointStore.set("identity:intro:content_hash", "abc");
-    checkpointStore.set("identity:intro:cached_at", String(Date.now()));
-    expect(getCachedIntro()).toBeNull();
-  });
-
-  test("returns null when hash checkpoint is missing", () => {
-    checkpointStore.set("identity:intro:greetings", '["Hello"]');
     checkpointStore.set("identity:intro:cached_at", String(Date.now()));
     expect(getCachedIntro()).toBeNull();
   });
 
   test("returns null when timestamp checkpoint is missing", () => {
     checkpointStore.set("identity:intro:greetings", '["Hello"]');
-    checkpointStore.set("identity:intro:content_hash", "abc");
     expect(getCachedIntro()).toBeNull();
   });
 });

package/src/__tests__/identity-routes.test.ts

@@ -22,14 +22,70 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+const checkpointStore = new Map<string, string>();
+
+mock.module("../memory/checkpoints.js", () => ({
+  getMemoryCheckpoint: (key: string) => checkpointStore.get(key) ?? null,
+  setMemoryCheckpoint: (key: string, value: string) => {
+    checkpointStore.set(key, value);
+  },
+}));
+
+const getConfiguredProviderCalls: string[] = [];
+const mockProvider = { name: "mock-provider" };
+
+mock.module("../providers/provider-send-message.js", () => ({
+  getConfiguredProvider: mock(async (callSite: string) => {
+    getConfiguredProviderCalls.push(callSite);
+    return mockProvider;
+  }),
+}));
+
+type SidechainCall = {
+  callSite?: string;
+  content: string;
+  maxTokens?: number;
+  systemPrompt?: string;
+  tools: unknown[];
+};
+
+type SidechainResult = {
+  text: string;
+  hadTextDeltas: false;
+  response: { content: [] };
+};
+
+const sidechainCalls: SidechainCall[] = [];
+let sidechainText = "";
+let sidechainResultPromise: Promise<SidechainResult> | null = null;
+
+mock.module("../runtime/btw-sidechain.js", () => ({
+  runBtwSidechain: mock(async (params: SidechainCall) => {
+    sidechainCalls.push(params);
+    if (sidechainResultPromise) {
+      return sidechainResultPromise;
+    }
+    return {
+      text: sidechainText,
+      hadTextDeltas: false,
+      response: { content: [] },
+    };
+  }),
+}));
+
+const assistantFeatureFlags: Record<string, boolean> = {};
+
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (key: string) =>
+    assistantFeatureFlags[key] ?? false,
+}));
+
 import {
   handleDetailedHealth,
   handleReadyz,
   ROUTES,
 } from "../runtime/routes/identity-routes.js";
-import {
-  setCesClient,
-} from "../security/secure-keys.js";
+import { setCesClient } from "../security/secure-keys.js";
 import { getWorkspaceDir } from "../util/platform.js";
 import {
   getHatchedSidecarPath,
@@ -37,6 +93,17 @@ import {
   selectHatchedAtFromStats,
 } from "../workspace/hatched-date.js";
 
+function createDeferred<T>(): {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+} {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+}
+
 // ── Env helpers ─────────────────────────────────────────────────────────
 
 let savedEnv: Record<string, string | undefined>;
@@ -133,6 +200,15 @@ beforeEach(() => {
 
   rmSync(getHatchedSidecarPath(), { force: true });
   rmSync(join(getWorkspaceDir(), "IDENTITY.md"), { force: true });
+  rmSync(join(getWorkspaceDir(), "SOUL.md"), { force: true });
+  checkpointStore.clear();
+  getConfiguredProviderCalls.length = 0;
+  sidechainCalls.length = 0;
+  sidechainText = "";
+  sidechainResultPromise = null;
+  for (const key of Object.keys(assistantFeatureFlags)) {
+    delete assistantFeatureFlags[key];
+  }
 });
 
 afterEach(() => {
@@ -202,21 +278,30 @@ describe("identity routes — health endpoint", () => {
     });
 
     test("readyz returns 200 when CES is connected and ready", () => {
-      const mockClient = { isReady: () => true, close: () => {} } as unknown as import("../credential-execution/client.js").CesClient;
+      const mockClient = {
+        isReady: () => true,
+        close: () => {},
+      } as unknown as import("../credential-execution/client.js").CesClient;
       setCesClient(mockClient);
       const res = handleReadyz();
       expect(res.status).toBe(200);
     });
 
     test("readyz returns 200 when CES client exists but is not ready", () => {
-      const mockClient = { isReady: () => false, close: () => {} } as unknown as import("../credential-execution/client.js").CesClient;
+      const mockClient = {
+        isReady: () => false,
+        close: () => {},
+      } as unknown as import("../credential-execution/client.js").CesClient;
       setCesClient(mockClient);
       const res = handleReadyz();
       expect(res.status).toBe(200);
     });
 
     test("/v1/health reports ces.connected=true when CES is ready", async () => {
-      const mockClient = { isReady: () => true, close: () => {} } as unknown as import("../credential-execution/client.js").CesClient;
+      const mockClient = {
+        isReady: () => true,
+        close: () => {},
+      } as unknown as import("../credential-execution/client.js").CesClient;
       setCesClient(mockClient);
       const res = handleDetailedHealth();
       const body = (await res.json()) as Record<string, unknown>;
@@ -226,7 +311,10 @@ describe("identity routes — health endpoint", () => {
     });
 
     test("/v1/health reports ces.connected=false when CES is not ready", async () => {
-      const mockClient = { isReady: () => false, close: () => {} } as unknown as import("../credential-execution/client.js").CesClient;
+      const mockClient = {
+        isReady: () => false,
+        close: () => {},
+      } as unknown as import("../credential-execution/client.js").CesClient;
       setCesClient(mockClient);
       const res = handleDetailedHealth();
       const body = (await res.json()) as Record<string, unknown>;
@@ -485,3 +573,156 @@ describe("identity routes — createdAt selection", () => {
     expect(existsSync(getHatchedSidecarPath())).toBe(false);
   });
 });
+
+describe("identity routes — intro greetings", () => {
+  test("returns static fallback and does not generate when the dynamic greetings flag is off", async () => {
+    const workspaceDir = getWorkspaceDir();
+    writeFileSync(
+      join(workspaceDir, "IDENTITY.md"),
+      "# Identity\n\n- **Name:** Example Assistant\n",
+      "utf-8",
+    );
+    writeFileSync(
+      join(workspaceDir, "SOUL.md"),
+      "# Soul\n\nNo explicit greetings section here.\n",
+      "utf-8",
+    );
+
+    const route = ROUTES.find(
+      (candidate) => candidate.operationId === "identity_intro",
+    );
+    expect(route).toBeDefined();
+
+    const body = route!.handler({}) as {
+      greetings: string[];
+      text: string;
+      source: string;
+      refreshing: boolean;
+    };
+
+    expect(body).toEqual({
+      greetings: [
+        "What are we working on?",
+        "I'm here whenever you need me.",
+        "What's on your mind?",
+        "Ready when you are.",
+      ],
+      text: "What are we working on?",
+      source: "fallback",
+      refreshing: false,
+    });
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(getConfiguredProviderCalls).toEqual([]);
+    expect(sidechainCalls).toEqual([]);
+  });
+
+  test("returns fallback immediately, generates personalized greetings in the background, then reuses the cache", async () => {
+    assistantFeatureFlags["empty-state-dynamic-greetings"] = true;
+
+    const workspaceDir = getWorkspaceDir();
+    writeFileSync(
+      join(workspaceDir, "IDENTITY.md"),
+      [
+        "# Identity",
+        "",
+        "- **Name:** Example Assistant",
+        "- **Personality:** enjoys crisp, useful hellos",
+        "",
+        "Identity sentinel: chartreuse compass.",
+      ].join("\n"),
+      "utf-8",
+    );
+    writeFileSync(
+      join(workspaceDir, "SOUL.md"),
+      [
+        "# Soul",
+        "",
+        "Soul sentinel: copper lighthouse.",
+        "",
+        "Keep greetings warm and specific.",
+      ].join("\n"),
+      "utf-8",
+    );
+    const deferredSidechain = createDeferred<SidechainResult>();
+    sidechainResultPromise = deferredSidechain.promise;
+
+    const route = ROUTES.find(
+      (candidate) => candidate.operationId === "identity_intro",
+    );
+    expect(route).toBeDefined();
+
+    const body = route!.handler({}) as {
+      greetings: string[];
+      text: string;
+      source: string;
+      refreshing: boolean;
+    };
+
+    expect(body).toEqual({
+      greetings: [
+        "What are we working on?",
+        "I'm here whenever you need me.",
+        "What's on your mind?",
+        "Ready when you are.",
+      ],
+      text: "What are we working on?",
+      source: "fallback",
+      refreshing: true,
+    });
+    expect(getConfiguredProviderCalls).toEqual([]);
+    expect(sidechainCalls).toEqual([]);
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(getConfiguredProviderCalls).toEqual(["emptyStateGreeting"]);
+    expect(sidechainCalls).toHaveLength(1);
+    expect(sidechainCalls[0]?.callSite).toBe("emptyStateGreeting");
+    expect(sidechainCalls[0]?.tools).toEqual([]);
+    expect(sidechainCalls[0]?.content).toContain("JSON array");
+    expect(sidechainCalls[0]?.systemPrompt).toContain(
+      "Identity sentinel: chartreuse compass.",
+    );
+    expect(sidechainCalls[0]?.systemPrompt).toContain(
+      "Soul sentinel: copper lighthouse.",
+    );
+    deferredSidechain.resolve({
+      text: JSON.stringify([
+        "Charting the next useful thing?",
+        "I brought the compass. Where to?",
+        "Ready to make this lighter.",
+      ]),
+      hadTextDeltas: false,
+      response: { content: [] },
+    });
+
+    await sidechainResultPromise;
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    sidechainCalls.length = 0;
+    getConfiguredProviderCalls.length = 0;
+
+    const cachedBody = (await route!.handler({})) as {
+      greetings: string[];
+      text: string;
+      source: string;
+      refreshing: boolean;
+    };
+
+    expect(cachedBody).toEqual({
+      greetings: [
+        "Charting the next useful thing?",
+        "I brought the compass. Where to?",
+        "Ready to make this lighter.",
+      ],
+      text: "Charting the next useful thing?",
+      source: "cache",
+      refreshing: false,
+    });
+    expect(getConfiguredProviderCalls).toEqual([]);
+    expect(sidechainCalls).toEqual([]);
+  });
+});

package/src/__tests__/inbound-slack-persistence.test.ts

@@ -105,10 +105,14 @@ function createTestContext(
       }
     : null;
 
+  let processing = false;
   return {
     conversationId: "conv-test",
     messages: [],
-    processing: false,
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      processing = value;
+    },
     abortController: null,
     queue: queueStub,
     getTurnChannelContext: () => turnChannel,