@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/__tests__/headless-browser-interactions.test.ts

@@ -163,7 +163,7 @@ function resetMockPage() {
  */
 function defaultCdpHandler(
   method: string,
-  _params: Record<string, unknown> | undefined,
+  params: Record<string, unknown> | undefined,
 ): unknown {
   switch (method) {
     case "DOM.getDocument":
@@ -177,12 +177,28 @@ function defaultCdpHandler(
     case "Runtime.evaluate":
       return { result: { value: { w: 800, h: 600 } } };
     case "Runtime.callFunctionOn":
+      if (
+        params?.returnByValue === true &&
+        String(params.functionDeclaration).includes("isConnected")
+      ) {
+        return {
+          result: { value: { connected: true, matches: true } },
+        };
+      }
+      if (
+        params?.returnByValue === true &&
+        String(params.functionDeclaration).includes("clearFirst")
+      ) {
+        return { result: { value: { needsRefocus: false } } };
+      }
       // executeBrowserSelectOption invokes a function that returns
       // a `matched` boolean — default to true so wrapper-contract
       // tests don't need to know the inner select-option matching
       // shape. Tests that exercise the no-match path override the
       // handler explicitly.
       return { result: { value: true } };
+    case "Input.insertText":
+      return {};
     default:
       return {};
   }
@@ -485,20 +501,21 @@ describe("executeBrowserType", () => {
     expect(result.content).toContain('Typed into element: element_id "e3"');
     expect(result.content).toContain("cleared existing content");
 
-    // Expected CDP sequence when resolving by backendNodeId + clearFirst:
-    //   DOM.focus → DOM.resolveNode → Runtime.callFunctionOn (clear) →
-    //   DOM.focus → Input.insertText
+    // The editor selection precedes insertion, and a live-node read verifies
+    // that the requested text persisted.
     const methods = sendCalls.map((c) => c.method);
     expect(methods).toEqual([
       "DOM.focus",
       "DOM.resolveNode",
       "Runtime.callFunctionOn",
-      "DOM.focus",
       "Input.insertText",
+      "Runtime.callFunctionOn",
     ]);
     const focusCall = sendCalls[0]!;
     expect(focusCall.params).toEqual({ backendNodeId: 555 });
-    const insertCall = sendCalls[sendCalls.length - 1]!;
+    const insertCall = sendCalls.find(
+      (call) => call.method === "Input.insertText",
+    )!;
     expect(insertCall.params).toEqual({ text: "hello" });
   });
 
@@ -524,11 +541,10 @@ describe("executeBrowserType", () => {
     );
     expect(result.isError).toBe(false);
     expect(result.content).not.toContain("cleared");
-    // clear_first=false skips DOM.resolveNode + Runtime.callFunctionOn
-    // and the re-focus call, so we should see focus + insertText only.
+    // Append mode collapses the editor selection at the end before insertion.
     const methods = sendCalls.map((c) => c.method);
-    expect(methods).not.toContain("DOM.resolveNode");
-    expect(methods).not.toContain("Runtime.callFunctionOn");
+    expect(methods).toContain("DOM.resolveNode");
+    expect(methods).toContain("Runtime.callFunctionOn");
     const focusCount = methods.filter((m) => m === "DOM.focus").length;
     expect(focusCount).toBe(1);
     expect(methods).toContain("Input.insertText");
@@ -542,22 +558,22 @@ describe("executeBrowserType", () => {
     expect(result.isError).toBe(false);
     expect(result.content).toContain("pressed Enter");
     const methods = sendCalls.map((c) => c.method);
-    // Input.insertText must come before the Enter keyDown/char/keyUp.
+    // Input.insertText must come before the Enter rawKeyDown/char/keyUp.
     const insertIdx = methods.indexOf("Input.insertText");
     const keyDownIdx = methods.findIndex(
       (m, i) =>
         m === "Input.dispatchKeyEvent" &&
-        (sendCalls[i]!.params as { type: string }).type === "keyDown",
+        (sendCalls[i]!.params as { type: string }).type === "rawKeyDown",
     );
     expect(insertIdx).toBeGreaterThanOrEqual(0);
     expect(keyDownIdx).toBeGreaterThan(insertIdx);
-    // Enter is text-producing → keyDown + char + keyUp.
+    // Enter is text-producing, so it emits rawKeyDown + char + keyUp.
     const keyEvents = sendCalls.filter(
       (c) => c.method === "Input.dispatchKeyEvent",
     );
     expect(keyEvents).toHaveLength(3);
     expect((keyEvents[0]!.params as { key: string }).key).toBe("Enter");
-    expect((keyEvents[0]!.params as { type: string }).type).toBe("keyDown");
+    expect((keyEvents[0]!.params as { type: string }).type).toBe("rawKeyDown");
     expect((keyEvents[1]!.params as { type: string }).type).toBe("char");
     expect((keyEvents[2]!.params as { type: string }).type).toBe("keyUp");
   });
@@ -689,7 +705,7 @@ describe("executeBrowserPressKey", () => {
     expect(result.content).toContain('Pressed "Enter"');
     // No target => no DOM.focus, no selector resolution. Enter is a
     // text-producing key (text "\r") so dispatchKeyPress emits
-    // keyDown + char + keyUp.
+    // rawKeyDown + char + keyUp.
     const methods = sendCalls.map((c) => c.method);
     expect(methods).toEqual([
       "Input.dispatchKeyEvent",
@@ -699,7 +715,7 @@ describe("executeBrowserPressKey", () => {
     const keyDown = sendCalls[0]!.params as Record<string, unknown>;
     const charEvt = sendCalls[1]!.params as Record<string, unknown>;
     const keyUp = sendCalls[2]!.params as Record<string, unknown>;
-    expect(keyDown.type).toBe("keyDown");
+    expect(keyDown.type).toBe("rawKeyDown");
     expect(keyDown.key).toBe("Enter");
     expect(keyDown.windowsVirtualKeyCode).toBe(13);
     expect(charEvt.type).toBe("char");
@@ -707,6 +723,36 @@ describe("executeBrowserPressKey", () => {
     expect(keyUp.key).toBe("Enter");
   });
 
+  test("presses modifier chords on the focused element", async () => {
+    const result = await executeBrowserPressKey({ key: "Meta+v" }, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Pressed "Meta+v"');
+
+    const keyEvents = sendCalls.filter(
+      (call) => call.method === "Input.dispatchKeyEvent",
+    );
+    expect(keyEvents).toHaveLength(4);
+    expect(keyEvents[0]!.params).toMatchObject({
+      type: "rawKeyDown",
+      key: "Meta",
+      modifiers: 4,
+    });
+    expect(keyEvents[1]!.params).toMatchObject({
+      type: "rawKeyDown",
+      key: "v",
+      modifiers: 4,
+    });
+    expect(keyEvents[2]!.params).toMatchObject({
+      type: "keyUp",
+      key: "v",
+      modifiers: 4,
+    });
+    expect(keyEvents[3]!.params).toMatchObject({
+      type: "keyUp",
+      key: "Meta",
+    });
+  });
+
   test("presses key on targeted element via element_id", async () => {
     snapshotBackendNodeMaps.set("test-conversation", new Map([["e5", 555]]));
     const result = await executeBrowserPressKey(
@@ -716,14 +762,12 @@ describe("executeBrowserPressKey", () => {
     expect(result.isError).toBe(false);
     expect(result.content).toContain('Pressed "Tab" on element');
     expect(result.content).toContain('element_id "e5"');
-    // Backend-resolved path: focus → dispatchKeyEvent × 3 (Tab is
-    // text-producing so we also dispatch a char event).
+    // Backend-resolved path: focus, then Tab key down and key up.
     const methods = sendCalls.map((c) => c.method);
     expect(methods).toEqual([
       "DOM.focus",
       "Input.dispatchKeyEvent",
       "Input.dispatchKeyEvent",
-      "Input.dispatchKeyEvent",
     ]);
     expect(sendCalls[0]!.params).toEqual({ backendNodeId: 555 });
   });
@@ -767,7 +811,7 @@ describe("executeBrowserPressKey", () => {
 
   test("surfaces CDP failure as a press-key error", async () => {
     sendHandler = () => new Error("Key not recognized");
-    const result = await executeBrowserPressKey({ key: "InvalidKey" }, ctx);
+    const result = await executeBrowserPressKey({ key: "Enter" }, ctx);
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Press key failed");
     expect(result.content).toContain("Key not recognized");

package/src/__tests__/heartbeat-service.test.ts

@@ -334,11 +334,10 @@ const SCAFFOLD_PERSONA = stripCommentLines(GUARDIAN_PERSONA_TEMPLATE).trim();
 const { resolveCallSiteConfig } = await import("../config/llm-resolver.js");
 const { LLMSchema } = await import("../config/schemas/llm.js");
 
-// Capture broadcastMessage so tests can observe the alerts and
-// conversation-created events the heartbeat service emits directly.
+// Capture broadcastMessage so tests can observe the conversation-created
+// events the heartbeat service emits directly.
 type BroadcastedMessage = { type: string; [key: string]: unknown };
 const broadcastedMessages: BroadcastedMessage[] = [];
-let onBroadcast: ((msg: BroadcastedMessage) => void) | null = null;
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: {
@@ -347,7 +346,6 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   },
   broadcastMessage: (msg: BroadcastedMessage) => {
     broadcastedMessages.push(msg);
-    onBroadcast?.(msg);
   },
 }));
 
@@ -357,7 +355,6 @@ describe("HeartbeatService", () => {
     content: string;
     options?: { callSite?: string };
   }>;
-  let alerterCalls: Array<{ type: string; title: string; body: string }>;
 
   afterEach(() => {
     // Clean up workspace files between tests so file-existence tests don't leak
@@ -368,13 +365,7 @@ describe("HeartbeatService", () => {
 
   beforeEach(() => {
     processMessageCalls = [];
-    alerterCalls = [];
     broadcastedMessages.length = 0;
-    onBroadcast = (msg) => {
-      if (msg.type === "heartbeat_alert") {
-        alerterCalls.push(msg as { type: string; title: string; body: string });
-      }
-    };
     createdConversations.length = 0;
     conversationIdCounter = 0;
     mockStoredMessages.length = 0;
@@ -693,21 +684,6 @@ describe("HeartbeatService", () => {
     expect(processMessageCalls).toHaveLength(1);
   });
 
-  test("alerts on processMessage failure", async () => {
-    const service = createService({
-      processMessage: async () => {
-        throw new Error("LLM timeout");
-      },
-    });
-
-    await service.runOnce();
-
-    expect(alerterCalls).toHaveLength(1);
-    expect(alerterCalls[0].type).toBe("heartbeat_alert");
-    expect(alerterCalls[0].title).toBe("Heartbeat Failed");
-    expect(alerterCalls[0].body).toBe("LLM timeout");
-  });
-
   test("successful run updates lastRunAt and nextRunAt", async () => {
     const service = createService();
     expect(service.lastRunAt).toBeNull();
@@ -724,24 +700,6 @@ describe("HeartbeatService", () => {
     );
   });
 
-  test("alerts on conversation creation failure", async () => {
-    // Override createConversation to throw via a fresh import trick:
-    // Since createConversation is mocked at module level, we simulate
-    // this by having processMessage throw before it's called — but the
-    // real fix is that executeRun wraps createConversation in the try/catch.
-    // We verify by checking that any error in executeRun triggers the alert.
-    const service = createService({
-      processMessage: async () => {
-        throw new Error("DB locked");
-      },
-    });
-
-    await service.runOnce();
-
-    expect(alerterCalls).toHaveLength(1);
-    expect(alerterCalls[0].body).toBe("DB locked");
-  });
-
   test("resetTimer() pushes nextRunAt forward", () => {
     const service = createService();
     service.start();
@@ -1467,21 +1425,6 @@ describe("HeartbeatService", () => {
       });
     });
 
-    test("CAS false suppresses failure alerter and feed event", async () => {
-      mockCompleteHeartbeatRun.mockImplementation(() => false);
-
-      const service = createService({
-        processMessage: async () => {
-          throw new Error("LLM timeout");
-        },
-      });
-
-      await service.runOnce();
-
-      // completeHeartbeatRun returned false, so alerter should NOT be called
-      expect(alerterCalls).toHaveLength(0);
-    });
-
     test("active-hours skip calls skipHeartbeatRun", async () => {
       setHeartbeatConfig({ activeHoursStart: 9, activeHoursEnd: 17 });
 

package/src/__tests__/helpers/mock-conversation.ts

@@ -18,6 +18,26 @@
 import type { Conversation } from "../../daemon/conversation.js";
 import type { ChannelCapabilities } from "../../daemon/conversation-runtime-assembly.js";
 
+/** Build a coordinator double representing a turn with no mode owner. */
+export function mockUnownedModeSessions(): Conversation["modeSessions"] {
+  return {
+    acceptTurn: () => undefined,
+    getTurnOwner: () => undefined,
+    getTerminalDisposition: () => undefined,
+    hasResidentWork: () => false,
+    keepsSessionOpenAfterTurn: () => false,
+    trackPersistedRow: () => false,
+    recordStructuralWait: () => false,
+    invalidateStructuralWait: () => false,
+    settleStructuralWait: () => false,
+    invalidateAllStructuralWaits: () => 0,
+    beginDraining: () => false,
+    finalizeTurn: () => false,
+    releaseTurn: () => {},
+    transferTurn: () => undefined,
+  } as unknown as Conversation["modeSessions"];
+}
+
 /**
  * `TExtra` carries test-only fields a double hangs off the same object
  * (recorded calls, captured messages) through to the return type, so a caller
@@ -38,6 +58,7 @@ export function asConversation<TExtra extends object = object>(
       merged.currentTurnTrustContext ?? merged.trustContext,
     isStale: () => false,
     hasInFlightWork: () => false,
+    modeSessions: mockUnownedModeSessions(),
     ...mock,
   };
   return merged as unknown as Conversation & TExtra;

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

@@ -20,6 +20,7 @@ import type {
   EventHandlerState,
 } from "../../daemon/conversation-agent-loop-handlers.js";
 import { dispatchAgentEvent } from "../../daemon/conversation-agent-loop-handlers.js";
+import { mockUnownedModeSessions } from "./mock-conversation.js";
 
 /** A `tool_result` `AssistantEvent` emitted by the handler. */
 export type ToolResultEvent = Extract<AssistantEvent, { type: "tool_result" }>;
@@ -59,6 +60,7 @@ export function createHandlerDeps(reqId = "req-web-search"): HandlerHarness {
       emitActivityState: () => {},
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: (msg: AssistantEvent) => events.push(msg),
     reqId,

package/src/__tests__/helpers/verification-sessions-ipc-sim.ts

@@ -276,6 +276,11 @@ export function createOutboundSessionGuarded(
     }
     source.status = "revoked";
     source.updatedAt = Date.now();
+    // Like the gateway, the replacement keeps the claimed session's purpose.
+    return createOutboundSession({
+      ...createParams,
+      verificationPurpose: source.verificationPurpose,
+    });
   }
 
   return createOutboundSession(createParams);

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

@@ -643,6 +643,59 @@ describe("repairHistory", () => {
     ]);
   });
 
+  test("deferred mixed tail answered by a tool_result plus trailing text gets a synthetic result", () => {
+    // Text after the client result closes the assistant turn on the provider
+    // side, which then rejects the unanswered search as unpaired. The search
+    // is an orphan here, so the synthetic error result keeps the request
+    // valid at the cost of that one search. `deepRepairHistory` is the loop's
+    // recovery path for that rejection.
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Check both" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "tu_a", name: "web_fetch", input: {} },
+          {
+            type: "server_tool_use",
+            id: "stu_deferred",
+            name: "web_search",
+            input: { query: "news" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "tu_a",
+            content: "Error: HTTP 404",
+            is_error: true,
+          },
+          { type: "text", text: "<system_notice>retry</system_notice>" },
+        ],
+      },
+    ];
+
+    const { messages: repaired, stats } = deepRepairHistory(messages);
+
+    expect(stats.missingToolResultsInserted).toBe(1);
+    expect(repaired).toHaveLength(3);
+    expect(repaired[1].content.map((b) => b.type)).toEqual([
+      "tool_use",
+      "server_tool_use",
+      "web_search_tool_result",
+    ]);
+    expect(repaired[1].content[2]).toMatchObject({
+      type: "web_search_tool_result",
+      tool_use_id: "stu_deferred",
+    });
+    expect(repaired[2].content.map((b) => b.type)).toEqual([
+      "tool_result",
+      "text",
+    ]);
+  });
+
   test("cross-message server tool pair from a completed deferred execution survives a reload untouched", () => {
     const messages: Message[] = [
       { role: "user", content: [{ type: "text", text: "Check both" }] },

package/src/__tests__/host-cu-proxy.test.ts

@@ -464,6 +464,43 @@ describe("HostCuProxy", () => {
       const result = await resultPromise;
       expect(result.isError).toBe(false);
     });
+
+    test("runs the lifecycle callback only for a validated dispatch", async () => {
+      setup(0);
+      const rejectedCallback = mock(() => {});
+      proxy.recordAction("computer_use_click", { element_id: 1 });
+      const rejected = await proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        proxy.stepCount,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        rejectedCallback,
+      );
+      expect(rejected.isError).toBe(true);
+      expect(rejectedCallback).not.toHaveBeenCalled();
+
+      setup();
+      const acceptedCallback = mock(() => {});
+      const pending = proxy.request(
+        "computer_use_click",
+        { element_id: 1 },
+        "session-1",
+        1,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        acceptedCallback,
+      );
+      expect(acceptedCallback).toHaveBeenCalledTimes(1);
+      const requestId = (sentMessages[0] as { requestId: string }).requestId;
+      proxy.processObservation(requestId, { executionResult: "Clicked" });
+      await pending;
+    });
   });
 
   // -------------------------------------------------------------------------
@@ -1333,7 +1370,13 @@ describe("HostCuProxy", () => {
       proxy.processObservation(requestId, { axTree: "Button [1]" });
       await resultPromise;
 
-      proxy.endTask("session-1");
+      const sourceId = proxy.sourceId;
+      expect(sourceId).not.toBe("");
+      expect(proxy.resetGeneration).toBe(0);
+
+      expect(proxy.endTask("session-1")).toBe(0);
+      expect(proxy.sourceId).toBe(sourceId);
+      expect(proxy.resetGeneration).toBe(1);
       const cancels = sentMessages.filter(
         (m) => (m as Record<string, unknown>).type === "host_cu_cancel",
       ) as Array<Record<string, unknown>>;
@@ -1341,7 +1384,8 @@ describe("HostCuProxy", () => {
       expect(cancels[0].conversationId).toBe("session-1");
       expect(cancels[0].requestId).not.toBe(requestId);
 
-      proxy.endTask("session-1");
+      expect(proxy.endTask("session-1")).toBe(1);
+      expect(proxy.resetGeneration).toBe(2);
       expect(
         sentMessages.filter(
           (m) => (m as Record<string, unknown>).type === "host_cu_cancel",

package/src/__tests__/http-user-message-parity.test.ts

@@ -161,6 +161,7 @@ mock.module("../runtime/trust-context-resolver.js", () => ({
 import type { AuthContext } from "../runtime/auth/types.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 import { callHandler } from "./helpers/call-route-handler.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 const _testAuthContext: AuthContext = {
   subject: "actor:self:test-actor",
@@ -194,6 +195,7 @@ function makeConversation(overrides: Record<string, unknown> = {}) {
     setHostCuProxy: () => {},
     setHostAppControlProxy: () => {},
     addPreactivatedSkillId: () => {},
+    modeSessions: mockUnownedModeSessions(),
     emitConfirmationStateChanged: () => {},
     emitActivityState: () => {},
     setTurnChannelContext: () => {},

package/src/__tests__/image-credentials.test.ts

@@ -136,6 +136,34 @@ describe("resolveImageGenCredentials", () => {
       expect(result.errorHint).toBeDefined();
       expect(result.errorHint).toContain("OpenAI API key");
     });
+
+    test("returns direct credentials for openrouter when key is present", async () => {
+      mockProviderKey = "openrouter-api-key";
+
+      const result = await resolveImageGenCredentials({
+        provider: "openrouter",
+        managed: false,
+      });
+
+      expect(result.errorHint).toBeUndefined();
+      expect(result.credentials).toEqual({
+        type: "direct",
+        apiKey: "openrouter-api-key",
+      });
+    });
+
+    test("returns errorHint mentioning 'OpenRouter API key' when no key is set", async () => {
+      mockProviderKey = undefined;
+
+      const result = await resolveImageGenCredentials({
+        provider: "openrouter",
+        managed: false,
+      });
+
+      expect(result.credentials).toBeUndefined();
+      expect(result.errorHint).toBeDefined();
+      expect(result.errorHint).toContain("OpenRouter API key");
+    });
   });
 });
 
@@ -173,6 +201,27 @@ describe("resolveImageGenRouting", () => {
     ).toEqual({ backendProvider: "openai", managed: false });
   });
 
+  test("OpenRouter keeps ownership for google/ and openai/ slugs", () => {
+    expect(
+      resolveImageGenRouting({
+        provider: "openrouter",
+        model: "google/gemini-3.1-flash-image-preview",
+      }),
+    ).toEqual({ backendProvider: "openrouter", managed: false });
+    expect(
+      resolveImageGenRouting(
+        { provider: "openrouter", model: "google/gemini-3.1-flash-image-preview" },
+        "openai/gpt-image-2",
+      ),
+    ).toEqual({ backendProvider: "openrouter", managed: false });
+    expect(
+      resolveImageGenRouting(
+        { provider: "openrouter", model: "google/gemini-3.1-flash-image-preview" },
+        "gpt-image-2",
+      ),
+    ).toEqual({ backendProvider: "openrouter", managed: false });
+  });
+
   test("vellum with an unavailable platform is a hard error, not a BYOK fallback", async () => {
     // Billing rule: an explicit vellum choice never silently spends a stored
     // provider key.

package/src/__tests__/image-service-dispatcher.test.ts

@@ -17,8 +17,10 @@ interface GenerateCall {
 
 let geminiCalls: GenerateCall[] = [];
 let openaiCalls: GenerateCall[] = [];
+let openrouterCalls: GenerateCall[] = [];
 let geminiErrorCalls: unknown[] = [];
 let openaiErrorCalls: unknown[] = [];
+let openrouterErrorCalls: unknown[] = [];
 
 let geminiResult: ImageGenerationResult = {
   images: [],
@@ -28,6 +30,10 @@ let openaiResult: ImageGenerationResult = {
   images: [],
   resolvedModel: "openai-mock",
 };
+let openrouterResult: ImageGenerationResult = {
+  images: [],
+  resolvedModel: "openrouter-mock",
+};
 
 // ---------------------------------------------------------------------------
 // Mock underlying services — must run before the module under test is imported
@@ -61,6 +67,20 @@ mock.module("../media/openai-image-service.js", () => ({
   },
 }));
 
+mock.module("../media/openrouter-image-service.js", () => ({
+  generateImageOpenRouter: async (
+    credentials: ImageGenCredentials,
+    request: ImageGenerationRequest,
+  ): Promise<ImageGenerationResult> => {
+    openrouterCalls.push({ credentials, request });
+    return openrouterResult;
+  },
+  mapOpenRouterError: (error: unknown): string => {
+    openrouterErrorCalls.push(error);
+    return "openrouter-mapped";
+  },
+}));
+
 // Import after mocking
 import {
   generateImage,
@@ -90,8 +110,10 @@ describe("image-service dispatcher", () => {
   beforeEach(() => {
     geminiCalls = [];
     openaiCalls = [];
+    openrouterCalls = [];
     geminiErrorCalls = [];
     openaiErrorCalls = [];
+    openrouterErrorCalls = [];
     geminiResult = {
       images: [{ mimeType: "image/png", dataBase64: "gemini-bytes" }],
       resolvedModel: "gemini-3.1-flash-image-preview",
@@ -100,6 +122,10 @@ describe("image-service dispatcher", () => {
       images: [{ mimeType: "image/png", dataBase64: "openai-bytes" }],
       resolvedModel: "gpt-image-2",
     };
+    openrouterResult = {
+      images: [{ mimeType: "image/png", dataBase64: "openrouter-bytes" }],
+      resolvedModel: "google/gemini-3.1-flash-image-preview",
+    };
   });
 
   test("generateImage('gemini', ...) delegates to the Gemini implementation", async () => {
@@ -131,6 +157,17 @@ describe("image-service dispatcher", () => {
     expect(mapped).toBe("gemini-mapped");
   });
 
+  test("generateImage('openrouter', ...) delegates to the OpenRouter implementation", async () => {
+    const result = await generateImage("openrouter", directCreds, request);
+
+    expect(openrouterCalls).toHaveLength(1);
+    expect(openrouterCalls[0]?.credentials).toBe(directCreds);
+    expect(openrouterCalls[0]?.request).toBe(request);
+    expect(geminiCalls).toHaveLength(0);
+    expect(openaiCalls).toHaveLength(0);
+    expect(result).toEqual(openrouterResult);
+  });
+
   test("mapImageGenError('openai', err) delegates to mapOpenAIError", () => {
     const err = new Error("kapow");
     const mapped = mapImageGenError("openai", err);
@@ -139,6 +176,14 @@ describe("image-service dispatcher", () => {
     expect(geminiErrorCalls).toEqual([]);
     expect(mapped).toBe("openai-mapped");
   });
+
+  test("mapImageGenError('openrouter', err) delegates to mapOpenRouterError", () => {
+    const err = new Error("or-boom");
+    const mapped = mapImageGenError("openrouter", err);
+
+    expect(openrouterErrorCalls).toEqual([err]);
+    expect(mapped).toBe("openrouter-mapped");
+  });
 });
 
 describe("providerForModel", () => {