370 lines
9.7 KiB
TypeScript
370 lines
9.7 KiB
TypeScript
import path from "node:path";
|
|
import { readFile } from "node:fs/promises";
|
|
import type { CliArgs } from "../types";
|
|
|
|
const DEFAULT_MODEL = "google/gemini-3.1-flash-image-preview";
|
|
const COMMON_ASPECT_RATIOS = [
|
|
"1:1",
|
|
"2:3",
|
|
"3:2",
|
|
"3:4",
|
|
"4:3",
|
|
"4:5",
|
|
"5:4",
|
|
"9:16",
|
|
"16:9",
|
|
"21:9",
|
|
];
|
|
const GEMINI_EXTENDED_ASPECT_RATIOS = ["1:4", "4:1", "1:8", "8:1"];
|
|
|
|
type OpenRouterImageEntry = {
|
|
image_url?: string | { url?: string | null } | null;
|
|
imageUrl?: string | { url?: string | null } | null;
|
|
};
|
|
|
|
type OpenRouterMessagePart = {
|
|
type?: string;
|
|
text?: string;
|
|
image_url?: string | { url?: string | null } | null;
|
|
imageUrl?: string | { url?: string | null } | null;
|
|
};
|
|
|
|
type OpenRouterResponse = {
|
|
choices?: Array<{
|
|
finish_reason?: string | null;
|
|
native_finish_reason?: string | null;
|
|
message?: {
|
|
images?: OpenRouterImageEntry[];
|
|
content?: string | OpenRouterMessagePart[] | null;
|
|
};
|
|
}>;
|
|
};
|
|
|
|
export function getDefaultModel(): string {
|
|
return process.env.OPENROUTER_IMAGE_MODEL || DEFAULT_MODEL;
|
|
}
|
|
|
|
function normalizeModelId(model: string): string {
|
|
return model.trim().toLowerCase().split(":")[0]!;
|
|
}
|
|
|
|
function isTextAndImageModel(model: string): boolean {
|
|
const normalized = normalizeModelId(model);
|
|
if (normalized === "openrouter/auto") {
|
|
return true;
|
|
}
|
|
|
|
if (normalized.startsWith("google/gemini-") && normalized.includes("image")) {
|
|
return true;
|
|
}
|
|
|
|
if (normalized.startsWith("openai/gpt-") && normalized.includes("image")) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function getSupportedAspectRatios(model: string): Set<string> {
|
|
const normalized = normalizeModelId(model);
|
|
if (normalized !== "google/gemini-3.1-flash-image-preview") {
|
|
return new Set(COMMON_ASPECT_RATIOS);
|
|
}
|
|
|
|
return new Set([...COMMON_ASPECT_RATIOS, ...GEMINI_EXTENDED_ASPECT_RATIOS]);
|
|
}
|
|
|
|
function getApiKey(): string | null {
|
|
return process.env.OPENROUTER_API_KEY || null;
|
|
}
|
|
|
|
function getBaseUrl(): string {
|
|
const base = process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1";
|
|
return base.replace(/\/+$/g, "");
|
|
}
|
|
|
|
function getHeaders(apiKey: string): Record<string, string> {
|
|
const headers: Record<string, string> = {
|
|
"Content-Type": "application/json",
|
|
Authorization: `Bearer ${apiKey}`,
|
|
};
|
|
|
|
const referer = process.env.OPENROUTER_HTTP_REFERER?.trim();
|
|
if (referer) {
|
|
headers["HTTP-Referer"] = referer;
|
|
}
|
|
|
|
const title = process.env.OPENROUTER_TITLE?.trim();
|
|
if (title) {
|
|
headers["X-OpenRouter-Title"] = title;
|
|
headers["X-Title"] = title;
|
|
}
|
|
|
|
return headers;
|
|
}
|
|
|
|
function parsePixelSize(value: string): { width: number; height: number } | null {
|
|
const match = value.match(/^(\d+)\s*[xX]\s*(\d+)$/);
|
|
if (!match) return null;
|
|
|
|
const width = parseInt(match[1]!, 10);
|
|
const height = parseInt(match[2]!, 10);
|
|
|
|
if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
|
|
return null;
|
|
}
|
|
|
|
return { width, height };
|
|
}
|
|
|
|
function gcd(a: number, b: number): number {
|
|
let x = Math.abs(a);
|
|
let y = Math.abs(b);
|
|
while (y !== 0) {
|
|
const next = x % y;
|
|
x = y;
|
|
y = next;
|
|
}
|
|
return x || 1;
|
|
}
|
|
|
|
function inferAspectRatio(size: string | null): string | null {
|
|
if (!size) return null;
|
|
const parsed = parsePixelSize(size);
|
|
if (!parsed) return null;
|
|
|
|
const divisor = gcd(parsed.width, parsed.height);
|
|
return `${parsed.width / divisor}:${parsed.height / divisor}`;
|
|
}
|
|
|
|
function inferImageSize(size: string | null): "1K" | "2K" | "4K" | null {
|
|
if (!size) return null;
|
|
const parsed = parsePixelSize(size);
|
|
if (!parsed) return null;
|
|
|
|
const longestEdge = Math.max(parsed.width, parsed.height);
|
|
if (longestEdge <= 1024) return "1K";
|
|
if (longestEdge <= 2048) return "2K";
|
|
return "4K";
|
|
}
|
|
|
|
export function getImageSize(args: CliArgs): "1K" | "2K" | "4K" | null {
|
|
if (args.imageSize) return args.imageSize as "1K" | "2K" | "4K";
|
|
|
|
const inferredFromSize = inferImageSize(args.size);
|
|
if (inferredFromSize) return inferredFromSize;
|
|
|
|
if (args.quality === "normal") return "1K";
|
|
if (args.quality === "2k") return "2K";
|
|
return null;
|
|
}
|
|
|
|
export function getAspectRatio(model: string, args: CliArgs): string | null {
|
|
if (args.aspectRatio) return args.aspectRatio;
|
|
|
|
const inferred = inferAspectRatio(args.size);
|
|
if (!inferred || !getSupportedAspectRatios(model).has(inferred)) {
|
|
return null;
|
|
}
|
|
|
|
return inferred;
|
|
}
|
|
|
|
function getModalities(model: string): string[] {
|
|
return isTextAndImageModel(model) ? ["image", "text"] : ["image"];
|
|
}
|
|
|
|
export function validateArgs(model: string, args: CliArgs): void {
|
|
const requestedAspectRatio = args.aspectRatio || inferAspectRatio(args.size);
|
|
if (!requestedAspectRatio) {
|
|
return;
|
|
}
|
|
|
|
const supported = getSupportedAspectRatios(model);
|
|
if (supported.has(requestedAspectRatio)) {
|
|
return;
|
|
}
|
|
|
|
const requestedValue = args.aspectRatio
|
|
? `aspect ratio ${requestedAspectRatio}`
|
|
: `size ${args.size} (aspect ratio ${requestedAspectRatio})`;
|
|
|
|
throw new Error(
|
|
`OpenRouter model ${model} does not support ${requestedValue}. Supported values: ${Array.from(supported).join(", ")}`
|
|
);
|
|
}
|
|
|
|
function getMimeType(filename: string): string {
|
|
const ext = path.extname(filename).toLowerCase();
|
|
if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
|
|
if (ext === ".webp") return "image/webp";
|
|
if (ext === ".gif") return "image/gif";
|
|
return "image/png";
|
|
}
|
|
|
|
async function readImageAsDataUrl(filePath: string): Promise<string> {
|
|
const bytes = await readFile(filePath);
|
|
return `data:${getMimeType(filePath)};base64,${bytes.toString("base64")}`;
|
|
}
|
|
|
|
export function buildContent(
|
|
prompt: string,
|
|
referenceImages: string[],
|
|
): string | Array<Record<string, unknown>> {
|
|
if (referenceImages.length === 0) {
|
|
return prompt;
|
|
}
|
|
|
|
const content: Array<Record<string, unknown>> = [{ type: "text", text: prompt }];
|
|
|
|
for (const imageUrl of referenceImages) {
|
|
content.push({
|
|
type: "image_url",
|
|
image_url: { url: imageUrl },
|
|
});
|
|
}
|
|
|
|
return content;
|
|
}
|
|
|
|
function extractImageUrl(entry: OpenRouterImageEntry | OpenRouterMessagePart): string | null {
|
|
const value = entry.image_url ?? entry.imageUrl;
|
|
if (!value) return null;
|
|
if (typeof value === "string") return value;
|
|
return value.url ?? null;
|
|
}
|
|
|
|
function decodeDataUrl(value: string): Uint8Array | null {
|
|
const match = value.match(/^data:image\/[^;]+;base64,([A-Za-z0-9+/=]+)$/);
|
|
if (!match) return null;
|
|
return Uint8Array.from(Buffer.from(match[1]!, "base64"));
|
|
}
|
|
|
|
async function downloadImage(value: string): Promise<Uint8Array> {
|
|
const inline = decodeDataUrl(value);
|
|
if (inline) return inline;
|
|
|
|
if (value.startsWith("http://") || value.startsWith("https://")) {
|
|
const response = await fetch(value);
|
|
if (!response.ok) {
|
|
throw new Error(`Failed to download OpenRouter image: ${response.status}`);
|
|
}
|
|
const buffer = await response.arrayBuffer();
|
|
return new Uint8Array(buffer);
|
|
}
|
|
|
|
return Uint8Array.from(Buffer.from(value, "base64"));
|
|
}
|
|
|
|
export async function extractImageFromResponse(result: OpenRouterResponse): Promise<Uint8Array> {
|
|
const choice = result.choices?.[0];
|
|
const message = choice?.message;
|
|
|
|
for (const image of message?.images ?? []) {
|
|
const imageUrl = extractImageUrl(image);
|
|
if (imageUrl) return downloadImage(imageUrl);
|
|
}
|
|
|
|
if (Array.isArray(message?.content)) {
|
|
for (const item of message.content) {
|
|
const imageUrl = extractImageUrl(item);
|
|
if (imageUrl) return downloadImage(imageUrl);
|
|
|
|
if (item.type === "text" && item.text) {
|
|
const inline = decodeDataUrl(item.text);
|
|
if (inline) return inline;
|
|
}
|
|
}
|
|
} else if (typeof message?.content === "string") {
|
|
const inline = decodeDataUrl(message.content);
|
|
if (inline) return inline;
|
|
}
|
|
|
|
const finishReason =
|
|
choice?.native_finish_reason || choice?.finish_reason || "unknown";
|
|
throw new Error(
|
|
`No image in OpenRouter response (finish_reason=${finishReason})`,
|
|
);
|
|
}
|
|
|
|
export function buildRequestBody(
|
|
prompt: string,
|
|
model: string,
|
|
args: CliArgs,
|
|
referenceImages: string[],
|
|
): Record<string, unknown> {
|
|
validateArgs(model, args);
|
|
|
|
const imageConfig: Record<string, string> = {};
|
|
|
|
const imageSize = getImageSize(args);
|
|
if (imageSize) {
|
|
imageConfig.image_size = imageSize;
|
|
}
|
|
|
|
const aspectRatio = getAspectRatio(model, args);
|
|
if (aspectRatio) {
|
|
imageConfig.aspect_ratio = aspectRatio;
|
|
}
|
|
|
|
const body: Record<string, unknown> = {
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: buildContent(prompt, referenceImages),
|
|
},
|
|
],
|
|
modalities: getModalities(model),
|
|
stream: false,
|
|
};
|
|
|
|
if (Object.keys(imageConfig).length > 0) {
|
|
body.image_config = imageConfig;
|
|
body.provider = {
|
|
require_parameters: true,
|
|
};
|
|
}
|
|
|
|
return body;
|
|
}
|
|
|
|
export async function generateImage(
|
|
prompt: string,
|
|
model: string,
|
|
args: CliArgs
|
|
): Promise<Uint8Array> {
|
|
const apiKey = getApiKey();
|
|
if (!apiKey) {
|
|
throw new Error("OPENROUTER_API_KEY is required. Get one at https://openrouter.ai/settings/keys");
|
|
}
|
|
|
|
const referenceImages: string[] = [];
|
|
for (const refPath of args.referenceImages) {
|
|
referenceImages.push(await readImageAsDataUrl(refPath));
|
|
}
|
|
|
|
const body = {
|
|
model,
|
|
...buildRequestBody(prompt, model, args, referenceImages),
|
|
};
|
|
|
|
console.log(
|
|
`Generating image with OpenRouter (${model})...`,
|
|
(body.image_config as Record<string, string>),
|
|
);
|
|
|
|
const response = await fetch(`${getBaseUrl()}/chat/completions`, {
|
|
method: "POST",
|
|
headers: getHeaders(apiKey),
|
|
body: JSON.stringify(body),
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const errorText = await response.text();
|
|
throw new Error(`OpenRouter API error (${response.status}): ${errorText}`);
|
|
}
|
|
|
|
const result = (await response.json()) as OpenRouterResponse;
|
|
return extractImageFromResponse(result);
|
|
}
|