@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/__tests__/context-search-agent-runner.test.ts

@@ -9,6 +9,7 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { RecallMetadataSchema } from "../api/events/tool-result.js";
 import type { AssistantConfig } from "../config/schema.js";
 import type { Provider, ProviderResponse } from "../providers/types.js";
 
@@ -22,11 +23,11 @@ mock.module("../providers/provider-send-message.js", () => ({
   },
 }));
 
+import type { RecallSource } from "../api/events/tool-result.js";
 import { runAgenticRecall } from "../plugins/defaults/memory/context-search/agent-runner.js";
 import type {
   RecallEvidence,
   RecallSearchContext,
-  RecallSource,
   RecallSourceAdapter,
 } from "../plugins/defaults/memory/context-search/types.js";
 
@@ -943,3 +944,261 @@ describe("runAgenticRecall", () => {
     });
   });
 });
+
+describe("runAgenticRecall activity", () => {
+  beforeEach(() => {
+    configuredProvider = null;
+    getConfiguredProviderCallSites.length = 0;
+  });
+
+  const launchAdapter = () =>
+    makeAdapter({
+      "launch notes": [
+        makeEvidence("workspace:launch", {
+          excerpt: "  Alice   chose\nFriday.  ",
+          timestampMs: 1_700_000_000_000,
+        }),
+        makeEvidence("workspace:retro"),
+      ],
+    });
+
+  test("carries the finish answer alone and the cited evidence", async () => {
+    configuredProvider = makeProvider([
+      toolResponse("finish_recall", {
+        answer: "Alice chose Friday.",
+        confidence: "high",
+        citation_ids: ["workspace:launch"],
+      }),
+    ]);
+
+    const result = await runAgenticRecall(
+      { query: "launch notes", sources: ["workspace"], depth: "fast" },
+      makeContext(),
+      { searchOptions: { adapters: [launchAdapter()] } },
+    );
+
+    expect(result.activity).toEqual({
+      query: "launch notes",
+      depth: "fast",
+      sources: ["workspace"],
+      answer: "Alice chose Friday.",
+      evidence: [
+        {
+          source: "workspace",
+          title: "workspace:launch title",
+          locator: "workspace:launch.md",
+          excerpt: "Alice chose Friday.",
+          timestampMs: 1_700_000_000_000,
+        },
+      ],
+      searchedSources: [
+        { source: "workspace", status: "searched", evidenceCount: 2 },
+      ],
+    });
+    expect(RecallMetadataSchema.parse(result.activity)).toEqual(
+      result.activity,
+    );
+  });
+
+  test("lists the available evidence the text appends on a low-confidence answer", async () => {
+    configuredProvider = makeProvider([
+      toolResponse("finish_recall", {
+        answer: "Probably Friday.",
+        confidence: "low",
+        citation_ids: ["workspace:launch"],
+      }),
+    ]);
+
+    const result = await runAgenticRecall(
+      { query: "launch notes", sources: ["workspace"] },
+      makeContext(),
+      { searchOptions: { adapters: [launchAdapter()] } },
+    );
+
+    expect(result.content).toContain("Available evidence:");
+    expect(result.activity.answer).toBe("Probably Friday.");
+    expect(result.activity.evidence.map((item) => item.title)).toEqual([
+      "workspace:launch title",
+      "workspace:retro title",
+    ]);
+  });
+
+  test("has no answer when recall falls back to listing what it found", async () => {
+    const result = await runAgenticRecall(
+      { query: "launch notes", sources: ["workspace"] },
+      makeContext(),
+      { searchOptions: { adapters: [launchAdapter()] } },
+    );
+
+    expect(result.debug.mode).toBe("deterministic_fallback");
+    expect(result.activity.answer).toBeUndefined();
+    expect(result.activity.depth).toBe("standard");
+    expect(result.activity.evidence.map((item) => item.title)).toEqual([
+      "workspace:launch title",
+      "workspace:retro title",
+    ]);
+  });
+
+  test("carries the file or conversation each item was found in", async () => {
+    const result = await runAgenticRecall(
+      { query: "launch notes", sources: ["workspace", "conversations"] },
+      makeContext(),
+      {
+        searchOptions: {
+          adapters: [
+            makeAdapter({
+              "launch notes": [
+                makeEvidence("workspace:launch", {
+                  metadata: { path: "notes/launch.md", lineNumber: 4 },
+                }),
+                makeEvidence("workspace:unreadable", {
+                  metadata: { path: "notes/gone.md", inspectError: true },
+                }),
+              ],
+            }),
+            makeAdapter(
+              {
+                "launch notes": [
+                  makeEvidence("conversations:c1:m1", {
+                    source: "conversations",
+                    metadata: {
+                      conversationId: "c1",
+                      messageId: "m1",
+                      role: "user",
+                    },
+                  }),
+                ],
+              },
+              [],
+              "conversations",
+            ),
+          ],
+        },
+      },
+    );
+
+    const byTitle = Object.fromEntries(
+      result.activity.evidence.map((item) => [item.title, item]),
+    );
+    expect(byTitle["workspace:launch title"]?.path).toBe("notes/launch.md");
+    expect(byTitle["workspace:unreadable title"]?.path).toBeUndefined();
+    expect(byTitle["conversations:c1:m1 title"]?.conversationId).toBe("c1");
+    expect(byTitle["conversations:c1:m1 title"]?.messageId).toBe("m1");
+    expect(byTitle["conversations:c1:m1 title"]?.path).toBeUndefined();
+  });
+
+  test("reports a source that degrades on a follow-up search", async () => {
+    configuredProvider = makeProvider([
+      toolResponse("search_sources", {
+        query: "decision notes",
+        sources: ["workspace"],
+      }),
+      toolResponse("finish_recall", {
+        answer: "Friday.",
+        confidence: "medium",
+        citation_ids: ["workspace:seed"],
+      }),
+    ]);
+
+    const result = await runAgenticRecall(
+      { query: "launch notes", sources: ["workspace"] },
+      makeContext(),
+      {
+        searchOptions: {
+          adapters: [
+            {
+              source: "workspace",
+              async search(query) {
+                if (query === "decision notes") {
+                  throw new Error("index unavailable");
+                }
+                return { evidence: [makeEvidence("workspace:seed")] };
+              },
+            },
+          ],
+        },
+      },
+    );
+
+    expect(result.activity.searchedSources).toEqual([
+      {
+        source: "workspace",
+        status: "degraded",
+        evidenceCount: 1,
+        error: "index unavailable",
+      },
+    ]);
+    expect(result.content).toContain(
+      "Degraded sources: workspace (index unavailable).",
+    );
+  });
+
+  test("clears a degradation that a follow-up search recovers from", async () => {
+    configuredProvider = makeProvider([
+      toolResponse("search_sources", {
+        query: "decision notes",
+        sources: ["workspace"],
+      }),
+      toolResponse("finish_recall", {
+        answer: "Friday.",
+        confidence: "medium",
+        citation_ids: ["workspace:decision"],
+      }),
+    ]);
+
+    const result = await runAgenticRecall(
+      { query: "launch notes", sources: ["workspace"] },
+      makeContext(),
+      {
+        searchOptions: {
+          adapters: [
+            {
+              source: "workspace",
+              async search(query) {
+                if (query === "launch notes") {
+                  throw new Error("index warming up");
+                }
+                return { evidence: [makeEvidence("workspace:decision")] };
+              },
+            },
+          ],
+        },
+      },
+    );
+
+    expect(result.activity.searchedSources).toEqual([
+      { source: "workspace", status: "searched", evidenceCount: 1 },
+    ]);
+    expect(result.content).not.toContain("Degraded sources");
+  });
+
+  test("reports a degraded source and no evidence when nothing is found", async () => {
+    const result = await runAgenticRecall(
+      { query: "launch notes", sources: ["workspace"] },
+      makeContext(),
+      {
+        searchOptions: {
+          adapters: [
+            {
+              source: "workspace",
+              async search() {
+                throw new Error("index unavailable");
+              },
+            },
+          ],
+        },
+      },
+    );
+
+    expect(result.content).toContain("No reliable results found.");
+    expect(result.activity.evidence).toEqual([]);
+    expect(result.activity.searchedSources).toEqual([
+      {
+        source: "workspace",
+        status: "degraded",
+        evidenceCount: 0,
+        error: "index unavailable",
+      },
+    ]);
+  });
+});

package/src/__tests__/context-search-fanout.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect, test } from "bun:test";
 
+import type { RecallSource } from "../api/events/tool-result.js";
 import type { AssistantConfig } from "../config/schema.js";
 import { formatDeterministicRecallAnswer } from "../plugins/defaults/memory/context-search/format.js";
 import { runDeterministicRecallSearch } from "../plugins/defaults/memory/context-search/search.js";
 import type {
   RecallEvidence,
   RecallSearchContext,
-  RecallSource,
   RecallSourceAdapter,
 } from "../plugins/defaults/memory/context-search/types.js";
 

package/src/__tests__/context-search-types.test.ts

@@ -1,7 +1,10 @@
 import { describe, expect, test } from "bun:test";
 
 import {
-  ALL_RECALL_SOURCES,
+  type RecallSource,
+  RecallSourceSchema,
+} from "../api/events/tool-result.js";
+import {
   DEFAULT_RECALL_MAX_RESULTS,
   normalizeRecallInput,
   normalizeRecallMaxResults,
@@ -10,11 +13,8 @@ import {
   RECALL_SOURCE_ROUNDS_BY_DEPTH,
   RECALL_TOTAL_EVIDENCE_TEXT_CAP,
 } from "../plugins/defaults/memory/context-search/limits.js";
-import type {
-  RecallInput,
-  RecallSource,
-  RecallSourceAdapter,
-} from "../plugins/defaults/memory/context-search/types.js";
+import type { RecallInput } from "../plugins/defaults/memory/context-search/recall-input.js";
+import type { RecallSourceAdapter } from "../plugins/defaults/memory/context-search/types.js";
 
 describe("normalizeRecallInput", () => {
   test("defaults omitted sources, max results, and depth", () => {
@@ -22,7 +22,7 @@ describe("normalizeRecallInput", () => {
 
     expect(normalized).toEqual({
       query: "project notes",
-      sources: [...ALL_RECALL_SOURCES],
+      sources: [...RecallSourceSchema.options],
       maxResults: DEFAULT_RECALL_MAX_RESULTS,
       depth: "standard",
       sourceRounds: 2,

package/src/__tests__/conversation-agent-loop-disk-pressure.test.ts

@@ -169,6 +169,7 @@ describe("runAgentLoopImpl disk pressure gate", () => {
     const events: AssistantEvent[] = [];
     const activityStates: unknown[][] = [];
     const drainQueue = mock(async (_reason: unknown) => {});
+    const onFirstModelCallPrepared = mock(() => {});
     const ctx = makeCtx({
       emitActivityState: (...args: unknown[]) => {
         activityStates.push(args);
@@ -176,8 +177,12 @@ describe("runAgentLoopImpl disk pressure gate", () => {
       drainQueue,
     });
 
-    await runAgentLoopImpl(ctx, "background task", "msg-1", (event) =>
-      events.push(event),
+    await runAgentLoopImpl(
+      ctx,
+      "background task",
+      "msg-1",
+      (event) => events.push(event),
+      { onFirstModelCallPrepared },
     );
 
     expect(events.find((event) => event.type === "error")).toMatchObject({
@@ -195,5 +200,6 @@ describe("runAgentLoopImpl disk pressure gate", () => {
     expect(ctx.abortController).toBeNull();
     expect(ctx.currentRequestId).toBeUndefined();
     expect(drainQueue).toHaveBeenCalledWith("loop_complete");
+    expect(onFirstModelCallPrepared).not.toHaveBeenCalled();
   });
 });

package/src/__tests__/conversation-agent-loop-fatal-cleanup.test.ts

@@ -20,6 +20,7 @@ import type { AgentLoop } from "../agent/loop.js";
 import type { AssistantEvent } from "../api/index.js";
 import type { Conversation } from "../daemon/conversation.js";
 import type { DiskPressureStatus } from "../daemon/disk-pressure-guard.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // Short turn-boundary commit wait and no second-pass retitling keep the loop
@@ -109,6 +110,7 @@ function makeCtx(overrides: Partial<Context> = {}): Conversation {
     pendingSurfaceActions: new Map(),
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
+    modeSessions: mockUnownedModeSessions(),
     workingDir: "/tmp",
     channelCapabilities: undefined,
     commandIntent: undefined,