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

package/src/mcp/__tests__/manager-tool-caps.test.ts

@@ -10,7 +10,15 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 import type { ResolvedMcpConfig } from "../../config/schemas/mcp.js";
 
 const toolsByServer = new Map<string, Array<{ name: string }>>();
-const connectDelays = new Map<string, number>();
+const connectGates = new Map<string, Promise<void>>();
+const listedServers = new Set<string>();
+let mcpGlobalMaxTools: number | undefined;
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    tools: { exclude: [], mcpGlobalMaxTools },
+  }),
+}));
 
 mock.module("../client.js", () => ({
   McpClient: class {
@@ -22,12 +30,13 @@ mock.module("../client.js", () => ({
       return null;
     }
     async connect() {
-      const delay = connectDelays.get(this.serverId) ?? 0;
-      if (delay > 0) {
-        await new Promise((resolve) => setTimeout(resolve, delay));
+      const gate = connectGates.get(this.serverId);
+      if (gate) {
+        await gate;
       }
     }
     async listTools() {
+      listedServers.add(this.serverId);
       return (toolsByServer.get(this.serverId) ?? []).map((tool) => ({
         name: tool.name,
         description: `${this.serverId} ${tool.name}`,
@@ -59,7 +68,9 @@ function configWith(ids: string[]): ResolvedMcpConfig {
 describe("McpServerManager tool selection", () => {
   beforeEach(() => {
     toolsByServer.clear();
-    connectDelays.clear();
+    connectGates.clear();
+    listedServers.clear();
+    mcpGlobalMaxTools = undefined;
   });
 
   test("later servers keep tools when eight servers exceed the global cap", async () => {
@@ -90,22 +101,56 @@ describe("McpServerManager tool selection", () => {
   test("a slow earlier server does not prevent later servers from connecting", async () => {
     toolsByServer.set("slow", [{ name: "slow_tool" }]);
     toolsByServer.set("fast", [{ name: "fast_tool" }]);
-    connectDelays.set("slow", 40);
+    let releaseSlow!: () => void;
+    connectGates.set(
+      "slow",
+      new Promise<void>((resolve) => {
+        releaseSlow = resolve;
+      }),
+    );
 
     const manager = new McpServerManager();
-    const startedAt = Date.now();
-    const started = await manager.start(configWith(["slow", "fast"]));
-    const elapsed = Date.now() - startedAt;
+    const starting = manager.start(configWith(["slow", "fast"]));
+    try {
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      expect([...listedServers]).toEqual(["fast"]);
 
-    expect(started.connectedServerCount).toBe(2);
-    expect(started.servers.map((server) => server.serverId).sort()).toEqual([
-      "fast",
-      "slow",
-    ]);
-    expect(
-      elapsed < 80,
-      "Servers connect in parallel, so one 40ms delay should not serialize both.",
-    ).toBe(true);
+      releaseSlow();
+      const started = await starting;
+      expect(started.connectedServerCount).toBe(2);
+      expect(started.servers.map((server) => server.serverId).sort()).toEqual([
+        "fast",
+        "slow",
+      ]);
+    } finally {
+      releaseSlow();
+      await starting;
+      await manager.stop();
+    }
+  });
+
+  test("a workspace global-max override raises how many tools are kept", async () => {
+    const ids = Array.from(
+      { length: 8 },
+      (_, i) => `server-${String(i + 1).padStart(2, "0")}`,
+    );
+    for (const id of ids) {
+      toolsByServer.set(
+        id,
+        Array.from({ length: 10 }, (_, i) => ({ name: `tool_${i}` })),
+      );
+    }
+
+    mcpGlobalMaxTools = 80;
+    const manager = new McpServerManager();
+    const started = await manager.start(configWith(ids));
+
+    expect(started.discoveredToolCount).toBe(80);
+    expect(started.keptToolCount).toBe(80);
+    expect(started.droppedToolCount).toBe(0);
+    expect(started.servers.every((server) => server.tools.length === 10)).toBe(
+      true,
+    );
     await manager.stop();
   });
 });

package/src/mcp/__tests__/tool-caps.test.ts

@@ -10,7 +10,7 @@ import {
   MCP_GLOBAL_MAX_TOOLS,
   MCP_MAX_TOOLS_PER_SERVER,
 } from "../../config/schemas/mcp.js";
-import { applyMcpToolCaps } from "../tool-caps.js";
+import { applyMcpToolCaps, resolveMcpGlobalMaxTools } from "../tool-caps.js";
 
 function toolsNamed(prefix: string, count: number): string[] {
   return Array.from({ length: count }, (_, i) => `${prefix}-tool-${i}`);
@@ -104,4 +104,31 @@ describe("applyMcpToolCaps", () => {
       4,
     );
   });
+
+  test("honors a workspace global-max override", () => {
+    const servers = Array.from({ length: 8 }, (_, i) => ({
+      serverId: `server-${String(i + 1).padStart(2, "0")}`,
+      tools: toolsNamed(`s${i + 1}`, 10),
+    }));
+
+    const result = applyMcpToolCaps(servers, { globalMax: 80, perServerMax: 20 });
+
+    expect(result.keptToolCount).toBe(80);
+    expect(result.droppedToolCount).toBe(0);
+    expect(result.servers.every((server) => server.tools.length === 10)).toBe(
+      true,
+    );
+  });
+});
+
+describe("resolveMcpGlobalMaxTools", () => {
+  test("uses the shipped default when the workspace omits the override", () => {
+    expect(resolveMcpGlobalMaxTools()).toBe(MCP_GLOBAL_MAX_TOOLS);
+    expect(resolveMcpGlobalMaxTools({})).toBe(MCP_GLOBAL_MAX_TOOLS);
+  });
+
+  test("uses tools.mcpGlobalMaxTools from config.json when set", () => {
+    expect(resolveMcpGlobalMaxTools({ mcpGlobalMaxTools: 80 })).toBe(80);
+    expect(resolveMcpGlobalMaxTools({ mcpGlobalMaxTools: 1 })).toBe(1);
+  });
 });

package/src/mcp/manager.ts

@@ -1,3 +1,4 @@
+import { getConfig } from "../config/loader.js";
 import type {
   ResolvedMcpConfig,
   ResolvedMcpServerConfig,
@@ -6,6 +7,7 @@ import { getLogger } from "../util/logger.js";
 import { McpClient, type McpToolInfo } from "./client.js";
 import {
   applyMcpToolCaps,
+  resolveMcpGlobalMaxTools,
   truncatedServerIdsFromCaps,
 } from "./tool-caps.js";
 
@@ -78,6 +80,7 @@ export class McpServerManager {
         serverId: result.serverId,
         tools: result.tools,
       })),
+      { globalMax: resolveMcpGlobalMaxTools(getConfig().tools) },
     );
     const keptByServer = new Map(
       capped.servers.map((server) => [server.serverId, server.tools]),

package/src/mcp/tool-caps.ts

@@ -1,10 +1,11 @@
 /**
  * Code-owned MCP tool-count caps and the selection used when they bind.
  *
- * Caps live here, not in workspace config: migration 153 strips
- * `maxTools` / `globalMaxTools` from `config.json`. The numbers are a
- * context-window budget, not a permission gate. Allowlists and risk
- * still decide what a turn may call.
+ * The shipped global cap is {@link MCP_GLOBAL_MAX_TOOLS}. A workspace may
+ * raise or lower it with `tools.mcpGlobalMaxTools` in config.json. The
+ * per-server cap stays code-owned. These numbers are a context-window
+ * budget, not a permission gate. Allowlists and risk still decide what
+ * a turn may call.
  *
  * The global cap is applied by a deterministic round-robin across
  * servers sorted by id. Insertion order must not empty a later server
@@ -15,6 +16,7 @@ import {
   MCP_GLOBAL_MAX_TOOLS,
   MCP_MAX_TOOLS_PER_SERVER,
 } from "../config/schemas/mcp.js";
+import type { ToolsConfig } from "../config/schemas/tools.js";
 
 export interface McpServerToolSet<T> {
   serverId: string;
@@ -39,6 +41,12 @@ export interface McpToolCapResult<T> {
   decisions: McpToolCapDecision[];
 }
 
+export function resolveMcpGlobalMaxTools(
+  tools?: Pick<ToolsConfig, "mcpGlobalMaxTools">,
+): number {
+  return tools?.mcpGlobalMaxTools ?? MCP_GLOBAL_MAX_TOOLS;
+}
+
 export function applyMcpToolCaps<T>(
   servers: ReadonlyArray<McpServerToolSet<T>>,
   options?: { globalMax?: number; perServerMax?: number },

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}`);

package/src/media/openrouter-image-service.test.ts

@@ -0,0 +1,133 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+import {
+  generateImageOpenRouter,
+  mapOpenRouterError,
+} from "./openrouter-image-service.js";
+
+const originalFetch = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("generateImageOpenRouter", () => {
+  test("generates images through the dedicated OpenRouter Images API", async () => {
+    let request: Request | undefined;
+    globalThis.fetch = mock(async (input, init) => {
+      request = new Request(input, init);
+      return Response.json({
+        data: [
+          { b64_json: "png-data", media_type: "image/png" },
+          { b64_json: "svg-data", media_type: "image/svg+xml" },
+        ],
+      });
+    }) as unknown as typeof fetch;
+
+    const result = await generateImageOpenRouter(
+      { type: "direct", apiKey: "or-key" },
+      {
+        prompt: "a friendly robot",
+        mode: "generate",
+        model: "google/gemini-3.1-flash-image-preview",
+        variants: 2,
+      },
+    );
+
+    expect(request?.url).toBe("https://openrouter.ai/api/v1/images");
+    expect(request?.headers.get("authorization")).toBe("Bearer or-key");
+    expect(await request?.json()).toEqual({
+      model: "google/gemini-3.1-flash-image-preview",
+      prompt: "a friendly robot",
+      n: 2,
+    });
+    expect(result).toEqual({
+      images: [
+        { mimeType: "image/png", dataBase64: "png-data" },
+        { mimeType: "image/svg+xml", dataBase64: "svg-data" },
+      ],
+      text: undefined,
+      resolvedModel: "google/gemini-3.1-flash-image-preview",
+    });
+  });
+
+  test("sends source images as data URL references for edits", async () => {
+    let body: Record<string, unknown> | undefined;
+    globalThis.fetch = mock(async (_input, init) => {
+      body = JSON.parse(String(init?.body)) as Record<string, unknown>;
+      return Response.json({ data: [] });
+    }) as unknown as typeof fetch;
+
+    await generateImageOpenRouter(
+      { type: "direct", apiKey: "or-key" },
+      {
+        prompt: "make it watercolor",
+        mode: "edit",
+        sourceImages: [{ mimeType: "image/jpeg", dataBase64: "abc123" }],
+      },
+    );
+
+    expect(body?.input_references).toEqual([
+      {
+        type: "image_url",
+        image_url: { url: "data:image/jpeg;base64,abc123" },
+      },
+    ]);
+  });
+
+  test("qualifies a bare built-in model ID at the backend boundary", async () => {
+    let body: Record<string, unknown> | undefined;
+    globalThis.fetch = mock(async (_input, init) => {
+      body = JSON.parse(String(init?.body)) as Record<string, unknown>;
+      return Response.json({ data: [] });
+    }) as unknown as typeof fetch;
+
+    const result = await generateImageOpenRouter(
+      { type: "direct", apiKey: "or-key" },
+      {
+        prompt: "a cat",
+        mode: "generate",
+        model: "gemini-3.1-flash-image-preview",
+      },
+    );
+
+    expect(body?.model).toBe("google/gemini-3.1-flash-image-preview");
+    expect(result.resolvedModel).toBe("google/gemini-3.1-flash-image-preview");
+  });
+
+  test("defaults an empty model to the OpenRouter Gemini Flash slug", async () => {
+    let body: Record<string, unknown> | undefined;
+    globalThis.fetch = mock(async (_input, init) => {
+      body = JSON.parse(String(init?.body)) as Record<string, unknown>;
+      return Response.json({ data: [] });
+    }) as unknown as typeof fetch;
+
+    await generateImageOpenRouter(
+      { type: "direct", apiKey: "or-key" },
+      { prompt: "a cat", mode: "generate" },
+    );
+
+    expect(body?.model).toBe("google/gemini-3.1-flash-image-preview");
+  });
+
+  test("surfaces the provider's invalid-request message", async () => {
+    globalThis.fetch = mock(async () =>
+      Response.json(
+        { error: { message: "Model does not support image output" } },
+        { status: 400 },
+      ),
+    ) as unknown as typeof fetch;
+
+    try {
+      await generateImageOpenRouter(
+        { type: "direct", apiKey: "or-key" },
+        { prompt: "a cat", mode: "generate", model: "text-only/model" },
+      );
+      throw new Error("expected request to fail");
+    } catch (error) {
+      expect(mapOpenRouterError(error)).toBe(
+        "The OpenRouter image request was invalid: Model does not support image output",
+      );
+    }
+  });
+});

package/src/media/openrouter-image-service.ts

@@ -0,0 +1,153 @@
+import {
+  DEFAULT_OPENROUTER_IMAGE_MODEL,
+  qualifyImageModelForOpenRouter,
+  resolveImageModel,
+} from "./image-models.js";
+import {
+  type GeneratedImage,
+  type ImageGenCredentials,
+  type ImageGenerationRequest,
+  type ImageGenerationResult,
+  isImageProviderBillingError,
+  MAX_VARIANTS,
+} from "./types.js";
+
+const OPENROUTER_IMAGES_URL = "https://openrouter.ai/api/v1/images";
+
+/**
+ * Qualify a bare built-in ID or alias for OpenRouter. Call sites that skip
+ * tool-level validation (app-icon, avatar) still reach this boundary.
+ */
+function resolveOpenRouterModel(model: string | undefined): string {
+  const trimmed = model?.trim();
+  if (!trimmed) {
+    return DEFAULT_OPENROUTER_IMAGE_MODEL;
+  }
+  if (resolveImageModel(trimmed)) {
+    return qualifyImageModelForOpenRouter(trimmed);
+  }
+  return trimmed;
+}
+
+const OPENROUTER_BILLING_MESSAGE =
+  "Image generation is unavailable because the OpenRouter account or API key is out of credits. " +
+  "Add funds with the provider or update the key in Settings. Retrying won't help until credits are added.";
+
+class OpenRouterImageError extends Error {
+  constructor(
+    readonly status: number,
+    message: string,
+  ) {
+    super(message);
+    this.name = "OpenRouterImageError";
+  }
+}
+
+export function mapOpenRouterError(error: unknown): string {
+  if (error instanceof OpenRouterImageError) {
+    if (
+      isImageProviderBillingError({
+        status: error.status,
+        message: error.message,
+      })
+    ) {
+      return OPENROUTER_BILLING_MESSAGE;
+    }
+    if (error.status === 400) {
+      return `The OpenRouter image request was invalid: ${error.message}`;
+    }
+    if (error.status === 401 || error.status === 403) {
+      return "Authentication failed. Please check your OpenRouter API key.";
+    }
+    if (error.status === 429) {
+      return "OpenRouter rate limit exceeded. Please wait a moment and try again.";
+    }
+    if (error.status >= 500) {
+      return "The OpenRouter service is temporarily unavailable. Please try again later.";
+    }
+    return `OpenRouter API error (status ${error.status}). Please try again.`;
+  }
+  if (error instanceof Error) {
+    if (isImageProviderBillingError({ message: error.message })) {
+      return OPENROUTER_BILLING_MESSAGE;
+    }
+    return `Image generation failed: ${error.message}`;
+  }
+  return "An unexpected error occurred during image generation.";
+}
+
+function errorMessage(body: unknown): string {
+  if (typeof body !== "object" || body === null) {
+    return "Request failed";
+  }
+  const error = (body as { error?: unknown }).error;
+  if (typeof error === "string") {
+    return error;
+  }
+  if (typeof error === "object" && error !== null) {
+    const message = (error as { message?: unknown }).message;
+    if (typeof message === "string" && message) {
+      return message;
+    }
+  }
+  return "Request failed";
+}
+
+export async function generateImageOpenRouter(
+  credentials: ImageGenCredentials,
+  request: ImageGenerationRequest,
+): Promise<ImageGenerationResult> {
+  if (credentials.type !== "direct") {
+    throw new Error("OpenRouter image generation requires an OpenRouter API key.");
+  }
+
+  const model = resolveOpenRouterModel(request.model);
+  const variants = Math.max(1, Math.min(request.variants ?? 1, MAX_VARIANTS));
+  const inputReferences = request.sourceImages?.map((image) => ({
+    type: "image_url" as const,
+    image_url: {
+      url: `data:${image.mimeType};base64,${image.dataBase64}`,
+    },
+  }));
+
+  const response = await fetch(OPENROUTER_IMAGES_URL, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${credentials.apiKey}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      model,
+      prompt: request.prompt,
+      n: variants,
+      ...(request.mode === "edit" && inputReferences?.length
+        ? { input_references: inputReferences }
+        : {}),
+    }),
+    ...(request.signal ? { signal: request.signal } : {}),
+  });
+
+  const body = (await response.json().catch(() => undefined)) as
+    | {
+        data?: Array<{ b64_json?: string; media_type?: string }>;
+        error?: unknown;
+      }
+    | undefined;
+
+  if (!response.ok) {
+    throw new OpenRouterImageError(response.status, errorMessage(body));
+  }
+
+  const images: GeneratedImage[] = [];
+  for (const entry of body?.data ?? []) {
+    if (!entry.b64_json) {
+      continue;
+    }
+    images.push({
+      mimeType: entry.media_type || "image/png",
+      dataBase64: entry.b64_json,
+    });
+  }
+
+  return { images, text: undefined, resolvedModel: model };
+}

package/src/media/types.ts

@@ -1,4 +1,4 @@
-export type ImageGenProvider = "gemini" | "openai";
+export type ImageGenProvider = "gemini" | "openai" | "openrouter";
 
 export interface DirectCredentials {
   type: "direct";