Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
feat(api): combo/alias resolution + OpenAI-compatible edits for image routes (#3214, #3215) (#3219)
Diego Rodrigues de Sa e Souzaec4f8c4d4252
diff --git a/open-sse/handlers/imageGeneration.ts b/open-sse/handlers/imageGeneration.tsindex bdd5943f88..a98762a8fc 100644--- a/open-sse/handlers/imageGeneration.ts+++ b/open-sse/handlers/imageGeneration.ts@@ -111,7 +111,8 @@ export function resolveImageBaseUrl(| { baseUrl?: unknown; providerSpecificData?: { baseUrl?: unknown } | null }| null| undefined,- fallback: string+ fallback: string,+ endpoint: "generations" | "edits" = "generations"): string {const psd = credentials?.providerSpecificData;const psdBaseUrl =@@ -126,9 +127,14 @@ export function resolveImageBaseUrl(if (!nodeBaseUrl) return fallback;+ // A single configured node serves both image routes: honor a base URL that already+ // points at the requested OpenAI image path, and rewrite one that points at the other+ // image endpoint (e.g. `.../images/generations` requested for edits) (#3214/#3215).+ const suffix = `/images/${endpoint}`;const normalized = nodeBaseUrl.replace(/\/+$/, "");- if (/\/images\/generations$/.test(normalized)) return normalized;- return `${normalized}/images/generations`;+ if (normalized.endsWith(suffix)) return normalized;+ const stripped = normalized.replace(/\/images\/(?:generations|edits)$/, "");+ return `${stripped}${suffix}`;}function normalizeImageAspectRatio(value: unknown, fallbackSize: unknown): string {@@ -971,6 +977,92 @@ async function handleOpenAIImageGeneration({return result;}+/**+ * OpenAI-compatible image *edit* forwarder for custom providers (#3214 / #3215).+ *+ * Mirrors `handleOpenAIImageGeneration` but posts multipart/form-data to the node's+ * `/images/edits` endpoint and returns the upstream OpenAI-compatible response. Kept+ * separate from the chatgpt-web edit flow, which continues a saved conversation node+ * rather than forwarding a stateless edit. The fetch helper leaves Content-Type unset so+ * `fetch` derives the multipart boundary from the FormData body.+ */+export async function handleOpenAIImageEdit({+ model,+ provider,+ credentials,+ prompt,+ imageBytes,+ imageMime,+ size,+ responseFormat,+ n = 1,+ log,+}: {+ model: string;+ provider: string;+ credentials:+ | {+ apiKey?: string;+ accessToken?: string;+ baseUrl?: unknown;+ providerSpecificData?: { baseUrl?: unknown } | null;+ }+ | null+ | undefined;+ prompt: string;+ imageBytes: Buffer;+ imageMime?: string | null;+ size?: string | null;+ responseFormat?: string | null;+ n?: number;+ log?: { info: (tag: string, message: string) => void } | null;+}) {+ const startTime = Date.now();+ const url = resolveImageBaseUrl(+ credentials,+ `https://generativelanguage.googleapis.com/v1beta/openai/images/edits`,+ "edits"+ );++ const form = new FormData();+ form.append("model", model);+ form.append("prompt", prompt);+ if (size) form.append("size", size);+ if (responseFormat) form.append("response_format", responseFormat);+ form.append("n", String(n || 1));+ const blob = new Blob([imageBytes], { type: imageMime || "image/png" });+ form.append("image", blob, "image.png");++ const headers: Record<string, string> = {};+ const token = credentials?.apiKey || credentials?.accessToken;+ if (token) headers["Authorization"] = `Bearer ${token}`;++ if (log) {+ log.info("IMAGE", `${provider}/${model} (edit) | prompt: "${prompt.slice(0, 60)}..." -> ${url}`);+ }++ const result = await fetchImageEndpoint(url, headers, form as unknown as BodyInit, provider, log);++ saveCallLog({+ method: "POST",+ path: "/v1/images/edits",+ status: result.status || (result.success ? 200 : 502),+ model: `${provider}/${model}`,+ provider,+ duration: Date.now() - startTime,+ tokens: { prompt_tokens: 0, completion_tokens: 0 },+ error: result.success+ ? null+ : typeof result.error === "string"+ ? result.error.slice(0, 500)+ : null,+ requestBody: { model, prompt: prompt.slice(0, 200), size: size || "default", n: n || 1 },+ responseBody: result.success ? { images_count: result.data?.data?.length || 0 } : null,+ }).catch(() => {});++ return result;+}+const CHATGPT_WEB_IMAGE_MARKDOWN_RE = /!\[[^\]]*\]\(([^)\s]+)\)/g;const CHATGPT_WEB_IMAGE_ID_RE = /\/v1\/chatgpt-web\/image\/([a-f0-9]{16,64})(?=[?\s"'<>)]|$)/i;diff --git a/src/app/api/v1/images/edits/route.ts b/src/app/api/v1/images/edits/route.tsindex 6bfe33c7c0..9c6b18a0bc 100644--- a/src/app/api/v1/images/edits/route.ts+++ b/src/app/api/v1/images/edits/route.ts@@ -1,4 +1,7 @@-import { handleImageEdit } from "@omniroute/open-sse/handlers/imageGeneration.ts";+import {+ handleImageEdit,+ handleOpenAIImageEdit,+} from "@omniroute/open-sse/handlers/imageGeneration.ts";import { getProviderCredentials, clearRecoveredProviderState } from "@/sse/services/auth";import { parseImageModel, getImageProvider } from "@omniroute/open-sse/config/imageRegistry.ts";import { errorResponse, unavailableResponse } from "@omniroute/open-sse/utils/error.ts";@@ -6,20 +9,29 @@ import { HTTP_STATUS } from "@omniroute/open-sse/config/constants.ts";import * as log from "@/sse/utils/logger";import { toJsonErrorPayload } from "@/shared/utils/upstreamError";import { enforceApiKeyPolicy } from "@/shared/utils/apiKeyPolicy";+import {+ resolveImageRouteModel,+ extractImageEditInputFromJson,+} from "@/lib/images/imageRouteModel";/**- * /v1/images/edits — multipart edit endpoint matching OpenAI's images-edit API.+ * /v1/images/edits — OpenAI-compatible image-edit endpoint.*- * Open WebUI's "Image Edit" toggle (images.edit.engine = "openai") posts here- * with `prompt` + `image` (file). For chatgpt-web, an "edit" only makes sense- * if the uploaded image was originally generated through OmniRoute — we then- * have its `{conversationId, parentMessageId}` cached and can continue the- * saved chatgpt.com conversation node, which is the only way to actually edit- * the image instead of generating an unrelated one from scratch.+ * Two upstream shapes are supported:+ * - **chatgpt-web**: an "edit" only makes sense if the uploaded image was originally+ * generated through OmniRoute — we then have its `{conversationId, parentMessageId}`+ * cached and can continue the saved chatgpt.com conversation node (the only way to+ * actually edit the image instead of generating an unrelated one).+ * - **custom OpenAI-compatible providers** (#3214/#3215): forward a multipart edit to+ * the node's `{base_url}/images/edits`, mirroring how generations forwards.*- * Without this route, multipart bodies trip Next.js's Server Action handler- * (which intercepts ALL POSTs with multipart/form-data content-type) and the- * client gets a confusing "Failed to find Server Action" 500.+ * Input is accepted as multipart/form-data (Open WebUI's "Image Edit" toggle) or as JSON+ * with data-URL images (`images: [{ image_url: "data:..." }]`), since some OpenAI-compatible+ * clients send the latter. The model may be a built-in id, a `provider/model`, a custom+ * provider prefix, or a combo/alias name — all resolved the same as generations.+ *+ * Without this route, multipart bodies trip Next.js's Server Action handler (which+ * intercepts ALL multipart POSTs) and the client gets a confusing 500.*/export async function OPTIONS() {@@ -42,14 +54,16 @@ function publicBaseUrlHeaders(headers: Headers): Record<string, string> {return out;}-async function readMultipartImage(formData: FormData): Promise<{+interface EditInput {prompt: string;model: string | null;size: string | null;responseFormat: string | null;imageBytes: Buffer | null;imageMime: string | null;-}> {+}++async function readMultipartImage(formData: FormData): Promise<EditInput> {const promptRaw = formData.get("prompt");const prompt = typeof promptRaw === "string" ? promptRaw.trim() : "";const modelRaw = formData.get("model");@@ -72,21 +86,45 @@ async function readMultipartImage(formData: FormData): Promise<{return { prompt, model, size, responseFormat, imageBytes, imageMime };}+/** Read the edit input from either multipart/form-data or a JSON/data-URL body. */+async function readEditInput(request: Request): Promise<EditInput | null> {+ const contentType = request.headers.get("content-type") || "";+ if (contentType.includes("multipart/form-data")) {+ try {+ return await readMultipartImage(await request.formData());+ } catch (err) {+ log.warn("IMAGE", `Invalid multipart body: ${err instanceof Error ? err.message : err}`);+ return null;+ }+ }+ if (contentType.includes("application/json")) {+ try {+ return extractImageEditInputFromJson(await request.json());+ } catch (err) {+ log.warn("IMAGE", `Invalid JSON edit body: ${err instanceof Error ? err.message : err}`);+ return null;+ }+ }+ return null;+}++function jsonResponse(data: unknown, status = 200): Response {+ return new Response(JSON.stringify(data), {+ status,+ headers: { "Content-Type": "application/json" },+ });+}+export async function POST(request: Request) {- let formData: FormData;- try {- formData = await request.formData();- } catch (err) {- log.warn(- "IMAGE",- `Invalid multipart body: ${err instanceof Error ? err.message : String(err)}`+ const input = await readEditInput(request);+ if (!input) {+ return errorResponse(+ HTTP_STATUS.BAD_REQUEST,+ "Invalid request body. Send multipart/form-data or JSON with a data-URL image.");- return errorResponse(HTTP_STATUS.BAD_REQUEST, "Invalid multipart body");}- const { prompt, model, size, responseFormat, imageBytes, imageMime } =- await readMultipartImage(formData);-+ const { prompt, model, size, responseFormat, imageBytes, imageMime } = input;if (!prompt) {return errorResponse(HTTP_STATUS.BAD_REQUEST, "Missing required field: prompt");}@@ -99,74 +137,128 @@ export async function POST(request: Request) {const policy = await enforceApiKeyPolicy(request, fullModel);if (policy.rejection) return policy.rejection;- const parsed = parseImageModel(fullModel);- const providerConfig = getImageProvider(parsed.provider);- if (!providerConfig) {- return errorResponse(HTTP_STATUS.BAD_REQUEST, `Unknown image provider: ${parsed.provider}`);+ const allowedConnections =+ policy.apiKeyInfo?.allowedConnections && policy.apiKeyInfo.allowedConnections.length > 0+ ? policy.apiKeyInfo.allowedConnections+ : null;++ // Resolve combo/alias, custom-provider prefix, and built-in ids consistently with+ // /v1/images/generations (#3215).+ const resolvedModel = await resolveImageRouteModel(fullModel);+ const parsed = parseImageModel(resolvedModel);+ const providerConfig = parsed.provider ? getImageProvider(parsed.provider) : null;++ // chatgpt-web keeps its conversation-continuation edit flow unchanged.+ if (providerConfig?.format === "chatgpt-web") {+ const credentials = await getProviderCredentials(+ parsed.provider,+ null,+ allowedConnections,+ resolvedModel+ );+ if (!credentials) {+ return errorResponse(+ HTTP_STATUS.UNAUTHORIZED,+ `No credentials for provider: ${parsed.provider}`+ );+ }+ if (credentials.allRateLimited) {+ return unavailableResponse(+ HTTP_STATUS.RATE_LIMITED,+ `[${parsed.provider}] All accounts rate limited`,+ credentials.retryAfter,+ credentials.retryAfterHuman+ );+ }++ const result = await handleImageEdit({+ provider: parsed.provider,+ model: parsed.model,+ body: {+ prompt,+ size: size ?? undefined,+ response_format: responseFormat ?? undefined,+ n: 1,+ },+ imageBytes,+ imageMime,+ credentials,+ log,+ signal: request.signal,+ clientHeaders: publicBaseUrlHeaders(request.headers),+ });++ if (result.success) {+ await clearRecoveredProviderState(credentials);+ return jsonResponse((result as any).data);+ }+ return jsonResponse(+ toJsonErrorPayload((result as any).error, "Image edit provider error"),+ (result as any).status+ );}- if (providerConfig.format !== "chatgpt-web") {- // We only implement edit for chatgpt-web today; everything else routes- // through generations which doesn't accept image inputs. Surface a- // useful error rather than silently dropping the image.++ // Built-in non-chatgpt-web providers do not expose an OpenAI-compatible edit endpoint.+ if (providerConfig) {return errorResponse(HTTP_STATUS.BAD_REQUEST,- `Image edit is only supported for chatgpt-web models (got ${parsed.provider})`+ `Image edit is not supported for built-in provider "${parsed.provider}". ` ++ `Use chatgpt-web or a custom OpenAI-compatible image provider.`+ );+ }++ // Custom OpenAI-compatible node (no built-in config): forward to {base_url}/images/edits.+ const slash = resolvedModel.indexOf("/");+ const customProviderId = slash > 0 ? resolvedModel.slice(0, slash) : null;+ const customModel = slash > 0 ? resolvedModel.slice(slash + 1) : null;+ if (!customProviderId || !customModel) {+ return errorResponse(+ HTTP_STATUS.BAD_REQUEST,+ `Unknown image provider for model "${fullModel}". Use provider/model, a custom ` ++ `provider prefix, or a combo/alias name.`);}- const allowedConnections =- policy.apiKeyInfo?.allowedConnections && policy.apiKeyInfo.allowedConnections.length > 0- ? policy.apiKeyInfo.allowedConnections- : null;const credentials = await getProviderCredentials(- parsed.provider,+ customProviderId,null,allowedConnections,- fullModel+ resolvedModel);if (!credentials) {return errorResponse(- HTTP_STATUS.UNAUTHORIZED,- `No credentials for provider: ${parsed.provider}`+ HTTP_STATUS.BAD_REQUEST,+ `No credentials for custom image provider: ${customProviderId}`);}if (credentials.allRateLimited) {return unavailableResponse(HTTP_STATUS.RATE_LIMITED,- `[${parsed.provider}] All accounts rate limited`,+ `[${customProviderId}] All accounts rate limited`,credentials.retryAfter,credentials.retryAfterHuman);}- const result = await handleImageEdit({- provider: parsed.provider,- model: parsed.model,- body: {- prompt,- size: size ?? undefined,- response_format: responseFormat ?? undefined,- n: 1,- },+ const result = await handleOpenAIImageEdit({+ provider: customProviderId,+ model: customModel,+ credentials,+ prompt,imageBytes,imageMime,- credentials,+ size,+ responseFormat,+ n: 1,log,- signal: request.signal,- clientHeaders: publicBaseUrlHeaders(request.headers),});if (result.success) {await clearRecoveredProviderState(credentials);- return new Response(JSON.stringify((result as any).data), {- status: 200,- headers: { "Content-Type": "application/json" },- });+ return jsonResponse((result as any).data);}-- const errorPayload = toJsonErrorPayload((result as any).error, "Image edit provider error");- return new Response(JSON.stringify(errorPayload), {- status: (result as any).status,- headers: { "Content-Type": "application/json" },- });+ return jsonResponse(+ toJsonErrorPayload((result as any).error, "Image edit provider error"),+ (result as any).status+ );}diff --git a/src/app/api/v1/images/generations/route.ts b/src/app/api/v1/images/generations/route.tsindex 2f4ad82c7a..2b950a9911 100644--- a/src/app/api/v1/images/generations/route.ts+++ b/src/app/api/v1/images/generations/route.ts@@ -20,7 +20,7 @@ import { v1ImageGenerationSchema } from "@/shared/validation/schemas";import { isValidationFailure, validateBody } from "@/shared/validation/helpers";import { getAllCustomModels, resolveProxyForConnection } from "@/lib/localDb";-import { getProviderNodes } from "@/lib/db/providers";+import { resolveImageRouteModel } from "@/lib/images/imageRouteModel";import { runWithProxyContext } from "@omniroute/open-sse/utils/proxyFetch.ts";/**@@ -118,43 +118,6 @@ function publicBaseUrlHeaders(headers: Headers): Record<string, string> {return out;}-/**- * Resolve a `prefix/model` image request to the internal `<nodeId>/<model>`- * form (#3205).- *- * The custom-model lookup below only matches the full internal id- * (`<nodeId>/<modelId>`), so a request that uses the user-defined provider- * prefix (e.g. `myImg/gpt-image-2`) never matched and fell through to- * "Invalid image model". This mirrors how chat resolves prefixes in- * `src/sse/services/model.ts` (match on `node.prefix` OR `node.id`).- *- * Returns the rewritten model string, or the original string when no node- * prefix matches (so built-in and already-internal ids are untouched).- */-async function resolveImageModelPrefix(modelStr: string): Promise<string> {- if (typeof modelStr !== "string") return modelStr;- const slash = modelStr.indexOf("/");- if (slash <= 0) return modelStr;-- const prefixPart = modelStr.slice(0, slash);- const rest = modelStr.slice(slash + 1);- if (!rest) return modelStr;-- try {- const nodes = await getProviderNodes({ type: "openai-compatible" });- // Prefer an explicit user-defined prefix match; node.id (internal UUID) is- // already handled by the exact-id loop, so only rewrite when the prefix- // differs from the node id.- const matched = nodes.find((node: any) => node.prefix === prefixPart);- if (matched && matched.id && matched.id !== prefixPart) {- return `${matched.id}/${rest}`;- }- } catch {- // DB unavailable (pre-migration / tests) — leave the model untouched.- }- return modelStr;-}-export async function POST(request) {let rawBody;try {@@ -174,13 +137,11 @@ export async function POST(request) {const policy = await enforceApiKeyPolicy(request, body.model);if (policy.rejection) return policy.rejection;- // #3205: rewrite a user-prefixed custom image model (`myImg/gpt-image-2`) to- // its internal `<nodeId>/<model>` form so the custom-model lookup and- // handler's resolvedProvider extraction resolve correctly. Built-in and- // already-internal ids pass through unchanged.- if (!parseImageModel(body.model).provider) {- body.model = await resolveImageModelPrefix(body.model);- }+ // #3205/#3215: resolve a combo/alias name (`image`) or a user-prefixed custom image+ // model (`myImg/gpt-image-2`) to its internal `<nodeId>/<model>` form so the+ // custom-model lookup and handler's resolvedProvider extraction resolve correctly.+ // Built-in and already-internal ids pass through unchanged. Shared with /images/edits.+ body.model = await resolveImageRouteModel(body.model);// Parse model to get providerlet { provider } = parseImageModel(body.model);diff --git a/src/lib/images/imageRouteModel.ts b/src/lib/images/imageRouteModel.tsnew file mode 100644index 0000000000..1425044f17--- /dev/null+++ b/src/lib/images/imageRouteModel.ts@@ -0,0 +1,161 @@+/**+ * Shared model resolution for the image routes (#3214 / #3215).+ *+ * `/v1/images/generations` and `/v1/images/edits` must resolve a requested model the+ * same way, and as close as practical to how chat routing resolves models:+ *+ * 1. Built-in image model id / alias (`cgpt-web/...`, `gpt-image-1`, …) — untouched.+ * 2. Custom provider *prefix* form (`myImg/gpt-image-2`) — rewritten to the internal+ * `<nodeId>/<model>` id (#3205 did this inline in the generations route only).+ * 3. Bare combo / alias name with no slash (`image`) — resolved to the combo's single+ * image target, then that target is itself prefix-resolved.+ *+ * Anything that does not match falls through unchanged, so existing built-in and+ * already-internal ids keep working.+ */+import { parseImageModel } from "@omniroute/open-sse/config/imageRegistry.ts";+import { resolveComboTargets } from "@omniroute/open-sse/services/combo.ts";++import { getComboByName, getCombos } from "@/lib/db/combos";+import { getProviderNodes } from "@/lib/db/providers";++/**+ * Rewrite a `prefix/model` custom image model to its internal `<nodeId>/<model>` form.+ * Returns the original string when no openai-compatible node prefix matches (so built-in+ * and already-internal ids pass through). Mirrors `src/sse/services/model.ts` (match on+ * `node.prefix` OR `node.id`).+ */+export async function resolveImageModelPrefix(modelStr: string): Promise<string> {+ if (typeof modelStr !== "string") return modelStr;+ const slash = modelStr.indexOf("/");+ if (slash <= 0) return modelStr;++ const prefixPart = modelStr.slice(0, slash);+ const rest = modelStr.slice(slash + 1);+ if (!rest) return modelStr;++ try {+ const nodes = await getProviderNodes({ type: "openai-compatible" });+ // node.id (internal UUID) is already a valid internal id; only rewrite when a+ // user-defined prefix differs from the node id.+ const matched = nodes.find((node: { prefix?: unknown }) => node.prefix === prefixPart);+ if (matched && typeof matched.id === "string" && matched.id && matched.id !== prefixPart) {+ return `${matched.id}/${rest}`;+ }+ } catch {+ // DB unavailable (pre-migration / tests) — leave the model untouched.+ }+ return modelStr;+}++/**+ * Resolve a bare combo/alias name (e.g. `image`) to its first image model target's+ * model string, or null when the name is not a combo / has no usable target.+ */+export async function resolveSingleImageComboTarget(name: string): Promise<string | null> {+ if (typeof name !== "string" || !name.trim()) return null;+ try {+ const combo = await getComboByName(name);+ if (!combo) return null;+ const allCombos = await getCombos();+ const targets = resolveComboTargets(combo as never, allCombos as never);+ const first = targets.find(+ (t: { modelStr?: unknown }) => typeof t?.modelStr === "string" && (t.modelStr as string).trim()+ );+ return (first?.modelStr as string) ?? null;+ } catch {+ return null;+ }+}++/**+ * Full image-route model resolver. See module header for the resolution order.+ */+export async function resolveImageRouteModel(modelStr: string): Promise<string> {+ if (typeof modelStr !== "string" || !modelStr.trim()) return modelStr;++ // 1. Built-in image model (alias or provider/model) — leave untouched.+ if (parseImageModel(modelStr).provider) return modelStr;++ // 3. Bare combo/alias name (no slash): resolve to its single image target, then+ // prefix-resolve that target (it may itself be a `prefix/model` custom id).+ if (!modelStr.includes("/")) {+ const target = await resolveSingleImageComboTarget(modelStr);+ if (target && target !== modelStr) return resolveImageModelPrefix(target);+ return modelStr;+ }++ // 2. Custom provider prefix form — rewrite to internal `<nodeId>/<model>`.+ return resolveImageModelPrefix(modelStr);+}++interface ParsedImageEditInput {+ prompt: string;+ model: string | null;+ size: string | null;+ responseFormat: string | null;+ imageBytes: Buffer | null;+ imageMime: string | null;+}++/** Parse a `data:<mime>;base64,<data>` URL into raw bytes + mime, or null when invalid. */+export function parseDataUrl(value: unknown): { bytes: Buffer; mime: string } | null {+ if (typeof value !== "string") return null;+ const match = /^data:([^;,]+)?(;base64)?,(.*)$/s.exec(value.trim());+ if (!match) return null;+ const mime = match[1] || "image/png";+ const isBase64 = Boolean(match[2]);+ const payload = match[3] ?? "";+ try {+ const bytes = isBase64+ ? Buffer.from(payload, "base64")+ : Buffer.from(decodeURIComponent(payload), "utf8");+ if (bytes.length === 0) return null;+ return { bytes, mime };+ } catch {+ return null;+ }+}++/**+ * Extract an OpenAI-compatible image-edit payload from a JSON body. Some clients send+ * edit input as JSON with data-URL images instead of multipart/form-data; accept the+ * common shapes (`image: "data:..."`, `images: [{ image_url: "data:..." }]` or+ * `images: ["data:..."]`) and surface the same fields the multipart reader produces.+ */+export function extractImageEditInputFromJson(body: unknown): ParsedImageEditInput {+ const obj = (body && typeof body === "object" ? body : {}) as Record<string, unknown>;+ const str = (v: unknown): string | null =>+ typeof v === "string" && v.trim() ? v.trim() : null;++ const prompt = typeof obj.prompt === "string" ? obj.prompt.trim() : "";+ const model = str(obj.model);+ const size = str(obj.size);+ const responseFormat = str(obj.response_format);++ const candidates: unknown[] = [];+ if (obj.image !== undefined) candidates.push(obj.image);+ const images = obj.images;+ if (Array.isArray(images)) {+ for (const entry of images) {+ if (typeof entry === "string") candidates.push(entry);+ else if (entry && typeof entry === "object") {+ const e = entry as Record<string, unknown>;+ candidates.push(e.image_url ?? e.url ?? e.b64_json);+ }+ }+ }++ let imageBytes: Buffer | null = null;+ let imageMime: string | null = null;+ for (const candidate of candidates) {+ const parsed = parseDataUrl(candidate);+ if (parsed) {+ imageBytes = parsed.bytes;+ imageMime = parsed.mime;+ break;+ }+ }++ return { prompt, model, size, responseFormat, imageBytes, imageMime };+}diff --git a/tests/unit/image-routes-combo-edits-3214-3215.test.ts b/tests/unit/image-routes-combo-edits-3214-3215.test.tsnew file mode 100644index 0000000000..f847320a06--- /dev/null+++ b/tests/unit/image-routes-combo-edits-3214-3215.test.ts@@ -0,0 +1,117 @@+/**+ * #3214 / #3215 — image routes: combo/alias resolution + OpenAI-compatible edits.+ *+ * Before this change:+ * - `/v1/images/generations` resolved built-in ids and `prefix/model` custom ids but NOT+ * a bare combo/alias name (`model: "image"`) — it fell through to "Invalid image model".+ * - `/v1/images/edits` resolved a base URL only for `/images/generations` and rejected any+ * non-chatgpt-web provider, so custom OpenAI-compatible providers could not edit, and+ * JSON/data-URL edit clients got "Invalid multipart body".+ */+import test from "node:test";+import assert from "node:assert/strict";+import fs from "node:fs";+import os from "node:os";+import path from "node:path";++// Isolate the DB to a throwaway DATA_DIR *before* importing any module that pulls in+// src/lib/db/core (its DATA_DIR/SQLITE_FILE consts are resolved eagerly at import), so the+// combo fixture never touches the real ~/.omniroute database. Mirrors a2a-enabled-route.test.+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-img-routes-3214-"));+const ORIGINAL_DATA_DIR = process.env.DATA_DIR;+process.env.DATA_DIR = TEST_DATA_DIR;++const { resolveImageBaseUrl } = await import("../../open-sse/handlers/imageGeneration.ts");+const {+ parseDataUrl,+ extractImageEditInputFromJson,+ resolveSingleImageComboTarget,+ resolveImageRouteModel,+} = await import("../../src/lib/images/imageRouteModel.ts");+const { resetDbInstance } = await import("../../src/lib/db/core.ts");+const { createCombo } = await import("../../src/lib/db/combos.ts");++test.after(() => {+ resetDbInstance();+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+ if (ORIGINAL_DATA_DIR === undefined) delete process.env.DATA_DIR;+ else process.env.DATA_DIR = ORIGINAL_DATA_DIR;+});++test("resolveImageBaseUrl appends /images/edits for the edits endpoint", () => {+ const creds = { providerSpecificData: { baseUrl: "https://img.example.com/v1" } };+ assert.equal(+ resolveImageBaseUrl(creds, "https://fallback/x", "edits"),+ "https://img.example.com/v1/images/edits"+ );+ // generations stays the default and unchanged+ assert.equal(+ resolveImageBaseUrl(creds, "https://fallback/x"),+ "https://img.example.com/v1/images/generations"+ );+});++test("resolveImageBaseUrl rewrites a base URL that points at the other image endpoint", () => {+ const creds = {+ providerSpecificData: { baseUrl: "https://img.example.com/v1/images/generations" },+ };+ assert.equal(+ resolveImageBaseUrl(creds, "https://fallback/x", "edits"),+ "https://img.example.com/v1/images/edits"+ );+});++test("resolveImageBaseUrl falls back when no node base URL is configured", () => {+ assert.equal(+ resolveImageBaseUrl(null, "https://fallback/v1/images/edits", "edits"),+ "https://fallback/v1/images/edits"+ );+});++test("parseDataUrl decodes a base64 data URL", () => {+ const png = Buffer.from([0x89, 0x50, 0x4e, 0x47]);+ const parsed = parseDataUrl(`data:image/png;base64,${png.toString("base64")}`);+ assert.ok(parsed);+ assert.equal(parsed!.mime, "image/png");+ assert.deepEqual([...parsed!.bytes], [...png]);+ assert.equal(parseDataUrl("not-a-data-url"), null);+ assert.equal(parseDataUrl(`data:image/png;base64,`), null);+});++test("extractImageEditInputFromJson reads model/prompt and the first data-URL image", () => {+ const png = Buffer.from([1, 2, 3, 4]);+ const out = extractImageEditInputFromJson({+ model: "image",+ prompt: "make it blue",+ size: "1024x1024",+ response_format: "b64_json",+ images: [{ image_url: `data:image/webp;base64,${png.toString("base64")}` }],+ });+ assert.equal(out.model, "image");+ assert.equal(out.prompt, "make it blue");+ assert.equal(out.size, "1024x1024");+ assert.equal(out.responseFormat, "b64_json");+ assert.equal(out.imageMime, "image/webp");+ assert.deepEqual([...(out.imageBytes ?? [])], [...png]);++ // also accepts a top-level `image` data URL string+ const out2 = extractImageEditInputFromJson({+ prompt: "x",+ image: `data:image/png;base64,${png.toString("base64")}`,+ });+ assert.ok(out2.imageBytes && out2.imageBytes.length === 4);+});++test("resolveImageRouteModel resolves a bare combo/alias to its single image target", async () => {+ await createCombo({ name: "image-alias-3215", models: ["myimg/gpt-image-2"], strategy: "priority" });++ assert.equal(await resolveSingleImageComboTarget("image-alias-3215"), "myimg/gpt-image-2");+ // No openai-compatible node has prefix "myimg" in this test DB, so the prefix step+ // leaves it intact — but the combo name itself is now resolved (was the bug).+ assert.equal(await resolveImageRouteModel("image-alias-3215"), "myimg/gpt-image-2");+});++test("resolveImageRouteModel leaves built-in / already-resolved ids untouched", async () => {+ assert.equal(await resolveImageRouteModel("cgpt-web/gpt-5.3-instant"), "cgpt-web/gpt-5.3-instant");+ assert.equal(await resolveSingleImageComboTarget("definitely-not-a-combo-3215"), null);+});