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
import { errorResponse } from "@omniroute/open-sse/utils/error.ts";
import { HTTP_STATUS } from "@omniroute/open-sse/config/constants.ts";
import { attachOmniRouteMetaHeaders } from "@/domain/omnirouteResponseMeta";
import { calculateModalCost } from "@/lib/usage/costCalculator";
import { generateRequestId } from "@/shared/utils/requestId";
import { toJsonErrorPayload } from "@/shared/utils/upstreamError";
import { v1ImageGenerationSchema } from "@/shared/validation/schemas";
import { isValidationFailure, validateBody } from "@/shared/validation/helpers";
type MediaModelListEntry = {
id: string;
provider: string;
};
type MediaGenerationResult =
{ success: true; data: unknown } | { success: false; error: unknown; status: number };
type MediaGenerationFailure = Extract<MediaGenerationResult, { success: false }>;
export type MediaGenerationResultLike = {
success: boolean;
data?: unknown;
error?: unknown;
status?: number;
};
export function isMediaGenerationFailure(
result: MediaGenerationResultLike
): result is MediaGenerationFailure {
return result.success === false && "error" in result && typeof result.status === "number";
}
type MediaGenerationBody = {
model: string;
prompt?: unknown;
duration?: unknown;
} & Record<string, unknown>;
type ValidatedMediaGenerationBody =
{ state: "ok"; body: MediaGenerationBody } | { state: "invalid"; response: Response };
export function mediaGenerationOptionsResponse() {
return new Response(null, {
headers: {
"Access-Control-Allow-Methods": "GET, POST, OPTIONS",
"Access-Control-Allow-Headers": "*",
},
});
}
export function mediaGenerationModelListResponse(
models: MediaModelListEntry[],
type: "music" | "video"
) {
return new Response(
JSON.stringify({
object: "list",
data: models.map((m) => ({
id: m.id,
object: "model",
created: Math.floor(Date.now() / 1000),
owned_by: m.provider,
type,
})),
}),
{
headers: { "Content-Type": "application/json" },
}
);
}
export async function readMediaGenerationBody(
request: Request,
log: { warn: (scope: string, message: string) => void },
logScope: string
): Promise<ValidatedMediaGenerationBody> {
let rawBody: unknown;
try {
rawBody = await request.json();
} catch {
log.warn(logScope, "Invalid JSON body");
return {
state: "invalid",
response: errorResponse(HTTP_STATUS.BAD_REQUEST, "Invalid JSON body"),
};
}
const validation = validateBody(v1ImageGenerationSchema, rawBody);
if (isValidationFailure(validation)) {
return {
state: "invalid",
response: errorResponse(HTTP_STATUS.BAD_REQUEST, validation.error.message),
};
}
return { state: "ok", body: validation.data as MediaGenerationBody };
}
export function promptRequiredResponse(body: { prompt?: unknown }) {
if (typeof body.prompt === "string" && body.prompt.trim().length > 0) {
return null;
}
return errorResponse(HTTP_STATUS.BAD_REQUEST, "Prompt is required");
}
export async function successfulMediaGenerationResponse({
result,
billingMode,
provider,
model,
startTime,
duration,
strategy,
fallbackAttempts,
}: {
result: { data: unknown };
billingMode: "audio" | "video";
provider: string;
model: string;
startTime: number;
duration: unknown;
// Set by combo execution so the response reports which strategy picked the
// target and how many earlier targets were skipped. Omitted on the direct
// single-model path, where neither is meaningful.
strategy?: string;
fallbackAttempts?: number;
}) {
const seconds = Number(duration) || 0;
const costUsd = await calculateModalCost(billingMode, provider, model, { seconds });
const headers = new Headers({ "Content-Type": "application/json" });
attachOmniRouteMetaHeaders(headers, {
provider,
model,
costUsd,
latencyMs: Date.now() - startTime,
requestId: generateRequestId(),
...(strategy ? { strategy } : {}),
...(fallbackAttempts !== undefined ? { fallbackAttempts } : {}),
});
return new Response(JSON.stringify(result.data), {
status: 200,
headers,
});
}
export function failedMediaGenerationResponse(
result: MediaGenerationResult,
fallbackMessage: string
) {
if (!isMediaGenerationFailure(result)) {
return new Response(JSON.stringify(toJsonErrorPayload(undefined, fallbackMessage)), {
headers: { "Content-Type": "application/json" },
});
}
const errorPayload = toJsonErrorPayload(result.error, fallbackMessage);
return new Response(JSON.stringify(errorPayload), {
status: result.status,
headers: { "Content-Type": "application/json" },
});
}