@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/__tests__/computer-use-tools.test.ts

@@ -1,246 +1,14 @@
 import { describe, expect, test } from "bun:test";
 
-import {
-  allComputerUseTools,
-  computerUseClickTool,
-  computerUseDoneTool,
-  computerUseDragTool,
-  computerUseKeyTool,
-  computerUseObserveTool,
-  computerUseOpenAppTool,
-  computerUseRespondTool,
-  computerUseRunAppleScriptTool,
-  computerUseScrollTool,
-  computerUseTypeTextTool,
-  computerUseWaitTool,
-} from "../tools/computer-use/definitions.js";
 import { forwardComputerUseProxyTool } from "../tools/computer-use/skill-proxy-bridge.js";
 import type { ToolContext } from "../tools/types.js";
 
-interface JsonSchema {
-  type?: string;
-  required?: string[];
-  properties?: Record<string, unknown>;
-}
-
-/** Cast a tool definition's input_schema to a usable JSON Schema shape. */
-function schema(tool: { input_schema?: object }): JsonSchema {
-  return tool.input_schema as JsonSchema;
-}
-
 const ctx: ToolContext = {
   workingDir: "/tmp",
-  conversationId: "test-conversation",
+  conversationId: "conv-123",
   trustClass: "guardian",
 };
 
-// ── Tool definitions ────────────────────────────────────────────────
-
-describe("computer-use tool definitions", () => {
-  test("allComputerUseTools contains 12 tools", () => {
-    expect(allComputerUseTools.length).toBe(12);
-  });
-
-  test("all tools belong to computer-use category", () => {
-    for (const tool of allComputerUseTools) {
-      expect(tool.category).toBe("computer-use");
-    }
-  });
-
-  test("all tools have unique names", () => {
-    const names = allComputerUseTools.map((t) => t.name);
-    expect(new Set(names).size).toBe(names.length);
-  });
-
-  test("all tools have descriptions", () => {
-    for (const tool of allComputerUseTools) {
-      expect(tool.description!.length).toBeGreaterThan(0);
-    }
-  });
-});
-
-// ── observe ─────────────────────────────────────────────────────────
-
-describe("computer_use_observe", () => {
-  test("supports target_client_id", () => {
-    const props = schema(computerUseObserveTool).properties as Record<
-      string,
-      { type: string }
-    >;
-    expect(props.target_client_id.type).toBe("string");
-  });
-});
-
-// ── Unified click tool ──────────────────────────────────────────────
-
-describe("computer_use_click (unified)", () => {
-  test("has correct name", () => {
-    expect(computerUseClickTool.name).toBe("computer_use_click");
-  });
-
-  test("schema requires reasoning", () => {
-    expect(schema(computerUseClickTool).required).toContain("reasoning");
-  });
-
-  test("schema supports click_type enum", () => {
-    const props = schema(computerUseClickTool).properties as Record<
-      string,
-      { type: string; enum?: string[] }
-    >;
-    expect(props.click_type.type).toBe("string");
-    expect(props.click_type.enum).toEqual(["single", "double", "right"]);
-  });
-
-  test("schema supports element_id and coordinates", () => {
-    const props = schema(computerUseClickTool).properties as Record<
-      string,
-      { type: string }
-    >;
-    expect(props.element_id.type).toBe("integer");
-    expect(props.x.type).toBe("integer");
-    expect(props.y.type).toBe("integer");
-  });
-
-  test("execute returns isError when no proxy resolver is configured", async () => {
-    const result = await computerUseClickTool.execute({}, ctx);
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain(
-      "The Vellum desktop app is needed to view or control your screen",
-    );
-    expect(result.content).toContain("https://www.vellum.ai/downloads");
-  });
-});
-
-// ── type_text ───────────────────────────────────────────────────────
-
-describe("computer_use_type_text", () => {
-  test("requires text and reasoning", () => {
-    expect(schema(computerUseTypeTextTool).required).toContain("text");
-    expect(schema(computerUseTypeTextTool).required).toContain("reasoning");
-  });
-
-  test("execute returns isError when no proxy resolver is configured", async () => {
-    const result = await computerUseTypeTextTool.execute({}, ctx);
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain(
-      "The Vellum desktop app is needed to view or control your screen",
-    );
-    expect(result.content).toContain("https://www.vellum.ai/downloads");
-  });
-});
-
-// ── key ─────────────────────────────────────────────────────────────
-
-describe("computer_use_key", () => {
-  test("requires key and reasoning", () => {
-    expect(schema(computerUseKeyTool).required).toContain("key");
-    expect(schema(computerUseKeyTool).required).toContain("reasoning");
-  });
-
-  test("execute returns isError when no proxy resolver is configured", async () => {
-    const result = await computerUseKeyTool.execute({}, ctx);
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain(
-      "The Vellum desktop app is needed to view or control your screen",
-    );
-    expect(result.content).toContain("https://www.vellum.ai/downloads");
-  });
-});
-
-// ── scroll ──────────────────────────────────────────────────────────
-
-describe("computer_use_scroll", () => {
-  test("requires direction, amount, and reasoning", () => {
-    expect(schema(computerUseScrollTool).required).toContain("direction");
-    expect(schema(computerUseScrollTool).required).toContain("amount");
-    expect(schema(computerUseScrollTool).required).toContain("reasoning");
-  });
-
-  test("direction enum includes up, down, left, right", () => {
-    const props = schema(computerUseScrollTool).properties as Record<
-      string,
-      { enum?: string[] }
-    >;
-    expect(props.direction.enum).toEqual(["up", "down", "left", "right"]);
-  });
-});
-
-// ── drag ────────────────────────────────────────────────────────────
-
-describe("computer_use_drag", () => {
-  test("supports source and destination coordinates", () => {
-    const props = schema(computerUseDragTool).properties as Record<
-      string,
-      { type: string }
-    >;
-    expect(props.element_id.type).toBe("integer");
-    expect(props.to_element_id.type).toBe("integer");
-    expect(props.x.type).toBe("integer");
-    expect(props.y.type).toBe("integer");
-    expect(props.to_x.type).toBe("integer");
-    expect(props.to_y.type).toBe("integer");
-  });
-
-  test("requires reasoning only", () => {
-    expect(schema(computerUseDragTool).required).toEqual(["reasoning"]);
-  });
-});
-
-// ── wait ────────────────────────────────────────────────────────────
-
-describe("computer_use_wait", () => {
-  test("requires duration_ms and reasoning", () => {
-    expect(schema(computerUseWaitTool).required).toContain("duration_ms");
-    expect(schema(computerUseWaitTool).required).toContain("reasoning");
-  });
-});
-
-// ── open_app ────────────────────────────────────────────────────────
-
-describe("computer_use_open_app", () => {
-  test("requires app_name and reasoning", () => {
-    expect(schema(computerUseOpenAppTool).required).toContain("app_name");
-    expect(schema(computerUseOpenAppTool).required).toContain("reasoning");
-  });
-});
-
-// ── run_applescript ─────────────────────────────────────────────────
-
-describe("computer_use_run_applescript", () => {
-  test("requires script and reasoning", () => {
-    expect(schema(computerUseRunAppleScriptTool).required).toContain("script");
-    expect(schema(computerUseRunAppleScriptTool).required).toContain(
-      "reasoning",
-    );
-  });
-
-  test("description warns against do shell script", () => {
-    expect(computerUseRunAppleScriptTool.description).toContain(
-      "do shell script",
-    );
-    expect(computerUseRunAppleScriptTool.description).toContain("blocked");
-  });
-});
-
-// ── done ────────────────────────────────────────────────────────────
-
-describe("computer_use_done", () => {
-  test("requires summary", () => {
-    expect(schema(computerUseDoneTool).required).toContain("summary");
-  });
-});
-
-// ── respond ─────────────────────────────────────────────────────────
-
-describe("computer_use_respond", () => {
-  test("requires answer and reasoning", () => {
-    expect(schema(computerUseRespondTool).required).toContain("answer");
-    expect(schema(computerUseRespondTool).required).toContain("reasoning");
-  });
-});
-
-// ── skill-proxy-bridge ──────────────────────────────────────────────
-
 describe("forwardComputerUseProxyTool", () => {
   test("returns error when no proxy resolver available", async () => {
     const result = await forwardComputerUseProxyTool(

package/src/__tests__/config-model-image-provider.test.ts

@@ -110,6 +110,45 @@ describe("setImageGenModel — provider derived from model prefix", () => {
   });
 });
 
+describe("setImageGenModel with provider openrouter", () => {
+  test("a model change leaves provider openrouter untouched", () => {
+    writeConfig({
+      services: {
+        "image-generation": {
+          provider: "openrouter",
+          model: "google/gemini-3.1-flash-image-preview",
+        },
+      },
+    });
+
+    setImageGenModel("openai/gpt-image-2", makeCtx());
+
+    const raw = readConfig() as {
+      services: { "image-generation": { provider: string; model: string } };
+    };
+    expect(raw.services["image-generation"].model).toBe("openai/gpt-image-2");
+    expect(raw.services["image-generation"].provider).toBe("openrouter");
+  });
+
+  test("a google/ slug does not rewrite provider to gemini", () => {
+    writeConfig({
+      services: {
+        "image-generation": {
+          provider: "openrouter",
+          model: "openai/gpt-image-2",
+        },
+      },
+    });
+
+    setImageGenModel("google/gemini-3.1-flash-image-preview", makeCtx());
+
+    const raw = readConfig() as {
+      services: { "image-generation": { provider: string; model: string } };
+    };
+    expect(raw.services["image-generation"].provider).toBe("openrouter");
+  });
+});
+
 describe("setImageGenModel with provider vellum", () => {
   test("a model change leaves provider vellum untouched", () => {
     writeConfig({

package/src/__tests__/config-schema.test.ts

@@ -110,6 +110,22 @@ describe("AssistantConfigSchema", () => {
     expect(result.services["image-generation"].model).toBe("gpt-image-2");
   });
 
+  test("accepts openrouter as an image generation provider", () => {
+    const result = AssistantConfigSchema.parse({
+      services: {
+        "image-generation": {
+          provider: "openrouter",
+          model: "google/gemini-3.1-flash-image-preview",
+        },
+      },
+    });
+
+    expect(result.services["image-generation"].provider).toBe("openrouter");
+    expect(result.services["image-generation"].model).toBe(
+      "google/gemini-3.1-flash-image-preview",
+    );
+  });
+
   test("accepts Tavily as a web search provider", () => {
     const result = AssistantConfigSchema.parse({
       services: {

package/src/__tests__/config-watcher.test.ts

@@ -315,6 +315,30 @@ describe("ConfigWatcher workspace file handlers", () => {
     expect(evictCallCount).toBe(1);
   });
 
+  test("config.json change reloads MCP when tools.mcpGlobalMaxTools changes", async () => {
+    watcher.initFingerprint({
+      tools: { exclude: [], mcpGlobalMaxTools: 50 },
+    } as never);
+    watcher.refreshConfigFromSources = async () => true;
+    watcher.start();
+    simulateFileChange(WORKSPACE_DIR, "config.json");
+    await new Promise((r) => setTimeout(r, WAIT_MS));
+    expect(mcpReloadCallCount).toBe(1);
+    expect(evictCallCount).toBe(1);
+  });
+
+  test("config.json change does not reload MCP when the global max is unchanged", async () => {
+    watcher.initFingerprint({
+      tools: { exclude: [] },
+    } as never);
+    watcher.refreshConfigFromSources = async () => true;
+    watcher.start();
+    simulateFileChange(WORKSPACE_DIR, "config.json");
+    await new Promise((r) => setTimeout(r, WAIT_MS));
+    expect(mcpReloadCallCount).toBe(0);
+    expect(evictCallCount).toBe(1);
+  });
+
   test("config.json change is suppressed when suppressConfigReload is true", async () => {
     let refreshCalled = false;
     watcher.refreshConfigFromSources = async () => {

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,