@vellumai/assistant 0.12.2-dev.202609180126.8de5565 → 0.12.2-dev.202609181315.9aaf787

package/openapi.yaml

@@ -16217,7 +16217,7 @@ paths:
     post:
       operationId: imagegeneration_generate_post
       summary: Generate or edit images using AI
-      description: Calls the configured image-generation provider (Gemini or OpenAI) to produce one or more images.
+      description: Calls the configured image-generation provider (Gemini, OpenAI, or OpenRouter) to produce one or more images.
       tags:
         - image-generation
       requestBody:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.2-dev.202609180126.8de5565",
+  "version": "0.12.2-dev.202609181315.9aaf787",
   "license": "MIT",
   "type": "module",
   "exports": {

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__/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", () => {

package/src/__tests__/media-generate-image.test.ts

@@ -21,6 +21,7 @@ import { setConfig } from "./helpers/set-config.js";
 
 let mockGeminiKey: string | undefined = "test-gemini-key";
 let mockOpenAIKey: string | undefined = "test-openai-key";
+let mockOpenRouterKey: string | undefined = "test-openrouter-key";
 let mockGenerateResult = {
   images: [{ mimeType: "image/png", dataBase64: "generated-data" }],
   text: "A beautiful image",
@@ -40,7 +41,7 @@ let mockGenerateDelayMs = 0;
  */
 function seedImageGenService(
   overrides: {
-    provider?: "vellum" | "gemini" | "openai";
+    provider?: "vellum" | "gemini" | "openai" | "openrouter";
     model?: string;
   } = {},
 ): void {
@@ -64,6 +65,9 @@ mock.module("../security/secure-keys.js", () => ({
     if (provider === "openai") {
       return mockOpenAIKey;
     }
+    if (provider === "openrouter") {
+      return mockOpenRouterKey;
+    }
     return undefined;
   },
 }));
@@ -143,6 +147,7 @@ const CONFIG_DIR = join(
 beforeEach(() => {
   mockGeminiKey = "test-gemini-key";
   mockOpenAIKey = "test-openai-key";
+  mockOpenRouterKey = "test-openrouter-key";
   seedImageGenService();
   mockGenerateResult = {
     images: [{ mimeType: "image/png", dataBase64: "generated-data" }],
@@ -308,6 +313,49 @@ describe("image-studio skill script wrapper", () => {
     expect(result.content).not.toContain("No Gemini API key");
   });
 
+  test("OpenRouter accepts an arbitrary slug and keeps OpenRouter ownership", async () => {
+    seedImageGenService({
+      provider: "openrouter",
+      model: "google/gemini-3.1-flash-image-preview",
+    });
+
+    const result = await run(
+      { prompt: "a nebula", model: "black-forest-labs/flux" },
+      fakeContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(lastGenerateProvider).toBe("openrouter");
+    expect(lastGenerateCredentials).toEqual({
+      type: "direct",
+      apiKey: "test-openrouter-key",
+    });
+    expect(lastGenerateRequest?.model).toBe("black-forest-labs/flux");
+  });
+
+  test("OpenRouter qualifies a built-in alias and keeps OpenRouter ownership", async () => {
+    seedImageGenService({ provider: "openrouter" });
+
+    const result = await run({ prompt: "a robot", model: "openai" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(lastGenerateProvider).toBe("openrouter");
+    expect(lastGenerateRequest?.model).toBe("openai/gpt-image-2");
+  });
+
+  test("OpenRouter returns a missing-key hint without falling back to Gemini", async () => {
+    seedImageGenService({ provider: "openrouter" });
+    mockOpenRouterKey = undefined;
+    mockGeminiKey = "gemini-key-should-not-be-used";
+
+    const result = await run({ prompt: "a cat" }, fakeContext);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("OpenRouter API key");
+    expect(result.content).not.toContain("No Gemini API key");
+    expect(lastGenerateProvider).toBeNull();
+  });
+
   test("explicit model override routes to owning provider (gemini config → openai call)", async () => {
     // Config says the user's default provider is gemini, but the LLM
     // explicitly requests a gpt-* model. The tool must dispatch to OpenAI

package/src/config/bundled-skills/image-studio/tools/media-generate-image.ts

@@ -5,10 +5,7 @@ import {
   resolveImageGenCredentials,
   resolveImageGenRouting,
 } from "../../../../media/image-credentials.js";
-import {
-  describeImageModels,
-  resolveImageModel,
-} from "../../../../media/image-models.js";
+import { resolveRequestedImageModel } from "../../../../media/image-models.js";
 import {
   generateImage,
   mapImageGenError,
@@ -115,18 +112,17 @@ export async function run(
   const config = getConfig();
   const svc = config.services["image-generation"];
   let modelOverride = input.model;
-  // Resolve tier aliases (fast, quality, openai) to concrete model IDs via
-  // the registry. Unknown values get an error listing the current catalog so
-  // callers can self-correct without a stale schema enum.
+  // Resolve aliases and OpenRouter slugs against the configured provider.
+  // Built-in providers still list the current catalog on unknown values.
   if (typeof modelOverride === "string" && modelOverride) {
-    const entry = resolveImageModel(modelOverride);
-    if (!entry) {
+    const resolved = resolveRequestedImageModel(modelOverride, svc.provider);
+    if (resolved.error) {
       return {
-        content: `Unknown model "${modelOverride}". Available models and aliases:\n${describeImageModels()}\n\nRetry with one of the aliases above, or omit the model parameter to use the configured default.`,
+        content: `${resolved.error}\n\nRetry with one of the aliases above, or omit the model parameter to use the configured default.`,
         isError: true,
       };
     }
-    modelOverride = entry.id;
+    modelOverride = resolved.model;
   }
   // Backend and managed-ness resolve together: an explicit model re-routes
   // to the model's backend (e.g. `gpt-image-2` under a gemini config routes

package/src/config/schemas/services.ts

@@ -22,7 +22,12 @@ export const VALID_INFERENCE_PROVIDERS = [
 
 // `vellum` generates through the platform runtime proxy; the backend
 // (gemini/openai) derives from the selected model's prefix at request time.
-const VALID_IMAGE_GEN_PROVIDERS = ["vellum", "gemini", "openai"] as const;
+const VALID_IMAGE_GEN_PROVIDERS = [
+  "vellum",
+  "gemini",
+  "openai",
+  "openrouter",
+] as const;
 
 /**
  * Derived from `SEARCH_PROVIDER_CATALOG`. Adding a new web-search provider
@@ -56,8 +61,9 @@ const InferenceServiceSchema = z.object({});
 /**
  * Image generation carries no `mode`: `provider` is the only axis. `"vellum"`
  * generates through the platform runtime proxy for the model-appropriate
- * backend, billed to Vellum credits; `"gemini"`/`"openai"` use the user's
- * key. A `mode` key sent by an older client is stripped at parse.
+ * backend, billed to Vellum credits; `"gemini"`/`"openai"`/`"openrouter"`
+ * use the user's key. A `mode` key sent by an older client is stripped at
+ * parse.
  */
 const ImageGenerationServiceSchema = z.object({
   provider: z.enum(VALID_IMAGE_GEN_PROVIDERS).default("gemini"),

package/src/daemon/conversation-agent-loop.ts

@@ -677,8 +677,6 @@ export async function runAgentLoopImpl(
     ctx.currentTurnOverrideProfile = currentOverrideProfile;
     return currentOverrideProfile;
   };
-  const resolveCurrentOverrideProfile = (): string | undefined =>
-    refreshCurrentProfileState();
   const resolveCurrentMaxInputTokens = (): number => {
     refreshCurrentProfileState();
     return currentEffectiveContextWindow.maxInputTokens;
@@ -704,7 +702,7 @@ export async function runAgentLoopImpl(
   };
 
   // Initial value for `createToolExecutor` to read into
-  // `ToolContext.overrideProfile`. `resolveCurrentOverrideProfile` refreshes
+  // `ToolContext.overrideProfile`. `refreshCurrentProfileState` refreshes
   // this between model calls so a confirmed profile session opened by a tool
   // applies to later tool executions and nested subagents in the same turn.
   ctx.currentTurnOverrideProfile = turnOverrideProfile;
@@ -1486,7 +1484,7 @@ export async function runAgentLoopImpl(
           trust: loopTrust,
           overrideProfile: turnOverrideProfile,
           ...(forceOverrideProfile ? { forceOverrideProfile: true } : {}),
-          resolveOverrideProfile: resolveCurrentOverrideProfile,
+          resolveOverrideProfile: refreshCurrentProfileState,
           resolveContextWindow,
           compactInPlace,
           isNonInteractive,
@@ -1901,7 +1899,7 @@ export async function runAgentLoopImpl(
         callSite: turnCallSite,
         overrideProfile:
           state.exchangeInferenceProfile ??
-          resolveCurrentOverrideProfile() ??
+          refreshCurrentProfileState() ??
           null,
         ...(state.exchangeInferenceProfile !== undefined
           ? { forceOverrideProfile: true }

package/src/daemon/handlers/config-model.ts

@@ -98,14 +98,16 @@ export function setImageGenModel(modelId: string, ctx: ModelSetContext): void {
   // Keep the derived provider in sync with the selected model so downstream
   // routing never sends a Gemini request to an OpenAI model (or vice versa).
   // The prefix logic is shared with workspace migration 006-services-config
-  // via providerForImageModelPrefix(). Provider "vellum" is exempt: it is
-  // managed for every model (the backend derives from the model at request
-  // time), and rewriting it here would silently move a managed user onto a
-  // BYOK provider they may hold no key for.
+  // via providerForImageModelPrefix(). Providers "vellum" and "openrouter"
+  // are exempt: vellum is managed for every model, and openrouter owns every
+  // selected slug (including google/ and openai/ prefixes). Rewriting either
+  // would silently move the user onto a BYOK provider they may hold no key
+  // for.
   const services = raw.services as
     | Record<string, { provider?: string }>
     | undefined;
-  if (services?.["image-generation"]?.provider !== "vellum") {
+  const currentProvider = services?.["image-generation"]?.provider;
+  if (currentProvider !== "vellum" && currentProvider !== "openrouter") {
     setServiceField(
       raw,
       "image-generation",

package/src/media/__tests__/image-models.test.ts

@@ -2,9 +2,12 @@ import { describe, expect, test } from "bun:test";
 
 import {
   DEFAULT_IMAGE_MODEL,
+  DEFAULT_OPENROUTER_IMAGE_MODEL,
   describeImageModels,
   IMAGE_MODELS,
+  qualifyImageModelForOpenRouter,
   resolveImageModel,
+  resolveRequestedImageModel,
 } from "../image-models.js";
 import { providerForModel } from "../image-service.js";
 
@@ -55,3 +58,58 @@ describe("image model registry", () => {
     }
   });
 });
+
+describe("resolveRequestedImageModel", () => {
+  test("qualifies built-in aliases for OpenRouter", () => {
+    expect(resolveRequestedImageModel("fast", "openrouter")).toEqual({
+      model: "google/gemini-3.1-flash-image-preview",
+    });
+    expect(resolveRequestedImageModel("openai", "openrouter")).toEqual({
+      model: "openai/gpt-image-2",
+    });
+    expect(qualifyImageModelForOpenRouter("quality")).toBe(
+      "google/gemini-3-pro-image-preview",
+    );
+  });
+
+  test("qualifies bare built-in IDs for OpenRouter", () => {
+    expect(
+      resolveRequestedImageModel("gemini-3.1-flash-image-preview", "openrouter"),
+    ).toEqual({ model: DEFAULT_OPENROUTER_IMAGE_MODEL });
+    expect(resolveRequestedImageModel("gpt-image-2", "openrouter")).toEqual({
+      model: "openai/gpt-image-2",
+    });
+  });
+
+  test("accepts arbitrary trimmed OpenRouter slugs", () => {
+    expect(
+      resolveRequestedImageModel("  google/gemini-3.5-flash  ", "openrouter"),
+    ).toEqual({ model: "google/gemini-3.5-flash" });
+    expect(
+      resolveRequestedImageModel("openai/gpt-image-2", "openrouter"),
+    ).toEqual({ model: "openai/gpt-image-2" });
+  });
+
+  test("rejects unknown models for built-in providers", () => {
+    const gemini = resolveRequestedImageModel(
+      "google/gemini-3.5-flash",
+      "gemini",
+    );
+    expect(gemini.model).toBeUndefined();
+    expect(gemini.error).toContain("Unknown model");
+
+    const openai = resolveRequestedImageModel("black-forest-labs/flux", "openai");
+    expect(openai.model).toBeUndefined();
+    expect(openai.error).toContain("Unknown model");
+
+    expect(resolveRequestedImageModel("fast", "vellum")).toEqual({
+      model: "gemini-3.1-flash-image-preview",
+    });
+  });
+
+  test("ignores empty or non-string input", () => {
+    expect(resolveRequestedImageModel("", "openrouter")).toEqual({});
+    expect(resolveRequestedImageModel("   ", "openrouter")).toEqual({});
+    expect(resolveRequestedImageModel(undefined, "gemini")).toEqual({});
+  });
+});

package/src/media/image-credentials.ts

@@ -37,6 +37,9 @@ export function resolveImageGenRouting(
         : svc.model;
     return { backendProvider: providerForImageModelPrefix(model), managed };
   }
+  if (svc.provider === "openrouter") {
+    return { backendProvider: "openrouter", managed: false };
+  }
   return {
     backendProvider: providerForModel(
       modelOverride,
@@ -101,5 +104,7 @@ function providerKeyHint(provider: ImageGenProvider): string {
       return "No Gemini API key configured. Please set your Gemini API key in Settings → Models & Services.";
     case "openai":
       return "No OpenAI API key configured. Please set your OpenAI API key in Settings → Models & Services.";
+    case "openrouter":
+      return "No OpenRouter API key configured. Please set your OpenRouter API key in Settings → Models & Services.";
   }
 }

package/src/media/image-models.ts

@@ -55,6 +55,58 @@ export function resolveImageModel(model: string): ImageModelEntry | undefined {
   return IMAGE_MODELS.find((m) => m.alias === model || m.id === model);
 }
 
+const OPENROUTER_VENDOR_PREFIX: Record<ImageModelProvider, string> = {
+  gemini: "google",
+  openai: "openai",
+};
+
+export const DEFAULT_OPENROUTER_IMAGE_MODEL =
+  "google/gemini-3.1-flash-image-preview";
+
+/**
+ * Qualify a built-in alias or concrete ID for OpenRouter's Images API.
+ * Unknown values are returned trimmed so live catalog slugs pass through.
+ */
+export function qualifyImageModelForOpenRouter(model: string): string {
+  const trimmed = model.trim();
+  const entry = resolveImageModel(trimmed);
+  if (!entry) {
+    return trimmed;
+  }
+  return `${OPENROUTER_VENDOR_PREFIX[entry.provider]}/${entry.id}`;
+}
+
+/**
+ * Resolve a caller-supplied image model against the configured provider.
+ *
+ * OpenRouter accepts any trimmed slug from its live catalog. Built-in
+ * aliases and bare IDs are qualified (`fast` ->
+ * `google/gemini-3.1-flash-image-preview`). Gemini, OpenAI, and Vellum
+ * still require a registry match.
+ */
+export function resolveRequestedImageModel(
+  model: unknown,
+  configuredProvider: string,
+): { model?: string; error?: string } {
+  if (typeof model !== "string" || !model) {
+    return {};
+  }
+  const trimmed = model.trim();
+  if (!trimmed) {
+    return {};
+  }
+  if (configuredProvider === "openrouter") {
+    return { model: qualifyImageModelForOpenRouter(trimmed) };
+  }
+  const entry = resolveImageModel(trimmed);
+  if (!entry) {
+    return {
+      error: `Unknown model "${trimmed}". Available models and aliases:\n${describeImageModels()}`,
+    };
+  }
+  return { model: entry.id };
+}
+
 /**
  * One line per model: "alias -> id (label)". Used in CLI help text and in
  * unknown-model error messages so the available set is always current.

package/src/media/image-service.ts

@@ -3,6 +3,10 @@ import {
   mapGeminiError,
 } from "./gemini-image-service.js";
 import { generateImageOpenAI, mapOpenAIError } from "./openai-image-service.js";
+import {
+  generateImageOpenRouter,
+  mapOpenRouterError,
+} from "./openrouter-image-service.js";
 import type {
   ImageGenCredentials,
   ImageGenerationRequest,
@@ -23,6 +27,8 @@ export function generateImage(
       return generateImageOpenAI(credentials, request);
     case "gemini":
       return generateImageGemini(credentials, request);
+    case "openrouter":
+      return generateImageOpenRouter(credentials, request);
     default: {
       const _exhaustive: never = provider;
       throw new Error(`Unknown image generation provider: ${_exhaustive}`);
@@ -42,6 +48,8 @@ export function mapImageGenError(
       return mapOpenAIError(error);
     case "gemini":
       return mapGeminiError(error);
+    case "openrouter":
+      return mapOpenRouterError(error);
     default: {
       const _exhaustive: never = provider;
       throw new Error(`Unknown image generation provider: ${_exhaustive}`);