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

package/src/__tests__/call-routes-http.test.ts

@@ -327,6 +327,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-get-1");
 
     const session = createCallSession({
+      direction: "outbound",
       conversationId: "conv-get-1",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -378,6 +379,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-cancel-1");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-cancel-1",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -407,6 +409,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-cancel-2");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-cancel-2",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -447,6 +450,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-answer-badjson");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-answer-badjson",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -469,6 +473,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-answer-1");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-answer-1",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -495,6 +500,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-answer-2");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-answer-2",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -517,6 +523,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-answer-3");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-answer-3",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -548,6 +555,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-badjson");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-badjson",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -570,6 +578,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-empty");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-empty",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -596,6 +605,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-missing");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-missing",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -640,6 +650,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-ended");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-ended",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -668,6 +679,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-no-orch");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-no-orch",
       provider: "twilio",
       fromNumber: "+15550001111",

package/src/__tests__/call-store.test.ts

@@ -53,9 +53,14 @@ function resetTables() {
 }
 
 /** Wrapper that ensures the FK conversation row exists before creating a session. */
-function createTestCallSession(opts: Parameters<typeof createCallSession>[0]) {
+function createTestCallSession(
+  opts: Omit<Parameters<typeof createCallSession>[0], "direction"> & {
+    direction?: Parameters<typeof createCallSession>[0]["direction"];
+  },
+) {
   ensureConversation(opts.conversationId);
-  return createCallSession(opts);
+  // Direction only shapes the funnel stamp; these suites test other things.
+  return createCallSession({ direction: "inbound", ...opts });
 }
 
 describe("call-store", () => {

package/src/__tests__/channel-retry-sweep.test.ts

@@ -98,6 +98,7 @@ import {
   clearConversations,
   setConversation,
 } from "../daemon/conversation-registry.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import * as deliveryCrud from "../persistence/delivery-crud.js";
@@ -318,7 +319,11 @@ describe("channel-retry-sweep", () => {
           }
         | undefined;
 
+      let capturedAuthor: TrustContext | undefined;
+      let capturedTrust: TrustContext | undefined;
       await sweepFailedEvents(async (conversationId, _content, options) => {
+        capturedAuthor = options?.author;
+        capturedTrust = options?.trustContext;
         capturedOptions = options as {
           trustContext?: {
             trustClass?: string;
@@ -345,6 +350,10 @@ describe("channel-retry-sweep", () => {
         "principal-1",
       );
       expect(capturedOptions?.isInteractive).toBe(c.expectedInteractive);
+      // The replay persists the sender's own message, so it names them as
+      // the row's author, exactly as live ingress does.
+      expect(capturedAuthor?.trustClass).toBe(c.trustClass);
+      expect(capturedAuthor).toEqual(capturedTrust);
 
       const db = getDb();
       const row = db

package/src/__tests__/chat-reveal-guard-priming.test.ts

@@ -99,6 +99,7 @@ import {
   _resetRevealSuccessRegistryForTest,
   recordRevealSuccess,
 } from "../runtime/reveal-success-registry.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 import {
   SYNTHETIC_OPAQUE_CREDENTIAL,
   SYNTHETIC_OPENAI_PROJECT_KEY,
@@ -122,6 +123,7 @@ function createMockDeps(collected: AssistantEvent[]): EventHandlerDeps {
       emitActivityState: () => {},
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: (msg: AssistantEvent) => {
       collected.push(msg);

package/src/__tests__/checker.test.ts

@@ -140,9 +140,17 @@ registerSkillTools("app-builder", [mockBundledSkillTool]);
 
 // Register CU tools so check() can look them up in the tool registry
 // instead of falling through to Medium (unknown tool).
-import { allComputerUseTools } from "../tools/computer-use/definitions.js";
-for (const tool of allComputerUseTools) {
-  registerTool(tool);
+import { COMPUTER_USE_TOOL_NAMES } from "./test-support/computer-use-skill-harness.js";
+for (const name of COMPUTER_USE_TOOL_NAMES) {
+  registerTool({
+    name,
+    description: name,
+    category: "computer-use",
+    defaultRiskLevel: RiskLevel.Low,
+    executionTarget: "host",
+    input_schema: { type: "object", properties: {} },
+    execute: async () => ({ content: "ok", isError: false }),
+  });
 }
 
 function writeSkill(

package/src/__tests__/client-os-metadata-persistence.test.ts

@@ -36,7 +36,7 @@ mock.module("../persistence/conversation-crud.js", () => ({
       content,
       metadata: options?.metadata,
     });
-    return { id: `persisted-${addMessageCalls.length}` };
+    return { id: `persisted-${addMessageCalls.length}`, createdAt: 100 };
   },
   getConversation: () => null,
   provenanceFromTrustContext: () => ({}),
@@ -189,6 +189,40 @@ describe("client OS surface metadata persistence", () => {
       browser_family: "safari",
     });
   });
+
+  test("strips caller ownership and tracks only the inserted structural row", async () => {
+    const acceptTurn = mock(() => ({
+      id: "session-123",
+      mode: "browser" as const,
+    }));
+    const trackPersistedRow = mock(() => {});
+    const ctx = Object.assign(createWebTurnContext("web"), {
+      modeSessions: { acceptTurn, trackPersistedRow },
+    });
+    await persistQueuedMessageBody(ctx, {
+      content: "continue",
+      requestId: "req-structural",
+      activeSurfaceId: "surface-123",
+      metadata: {
+        modeSession: { id: "spoofed", mode: "computer_use" },
+      },
+    });
+
+    expect(lastUserMetadata().modeSession).toBeUndefined();
+    expect(acceptTurn).toHaveBeenCalledWith("req-structural", {
+      kind: "surface",
+      responseId: "surface-123",
+    });
+    expect(trackPersistedRow).toHaveBeenCalledWith(
+      "req-structural",
+      "persisted-1",
+      100,
+      {
+        publishMessagesChanged: true,
+        startsDisplayBoundary: false,
+      },
+    );
+  });
 });
 
 /**

package/src/__tests__/computer-use-skill-manifest-regression.test.ts

@@ -3,7 +3,6 @@ import { resolve } from "node:path";
 import { afterAll, describe, expect, test } from "bun:test";
 
 import { RiskLevel } from "../permissions/types.js";
-import { allComputerUseTools } from "../tools/computer-use/definitions.js";
 import {
   __resetRegistryForTesting,
   getTool,
@@ -74,30 +73,6 @@ describe("computer-use skill manifest regression", () => {
     }
   });
 
-  test("manifest descriptions match core definitions", async () => {
-    await initializeTools();
-
-    for (const cuTool of allComputerUseTools) {
-      const manifestTool = manifest.tools.find(
-        (t: { name: string }) => t.name === cuTool.name,
-      );
-      expect(manifestTool).toBeDefined();
-      expect(manifestTool.description).toBe(cuTool.description);
-    }
-  });
-
-  test("manifest input_schema matches core definitions", async () => {
-    await initializeTools();
-
-    for (const cuTool of allComputerUseTools) {
-      const manifestTool = manifest.tools.find(
-        (t: { name: string }) => t.name === cuTool.name,
-      );
-      expect(manifestTool).toBeDefined();
-      expect(manifestTool.input_schema).toEqual(cuTool.input_schema);
-    }
-  });
-
   test("CU action tools are not registered as core tools after initializeTools()", async () => {
     await initializeTools();
 

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 () => {