833 lines
27 KiB
TypeScript
833 lines
27 KiB
TypeScript
import "server-only";
|
||
|
||
import sharp from "sharp";
|
||
import {
|
||
getKreaModelPresetById,
|
||
inferKreaModelKind,
|
||
type KreaModelKind,
|
||
} from "@/lib/ai/krea-models";
|
||
import { uploadFile } from "@/lib/storage/service";
|
||
|
||
interface KreaConfig {
|
||
apiKey: string;
|
||
baseURL: string;
|
||
}
|
||
|
||
interface KreaImageParams {
|
||
aspectRatio?: string;
|
||
imageSize?: string;
|
||
imageCount?: number;
|
||
seed?: number;
|
||
negativePrompt?: string;
|
||
promptExtend?: boolean;
|
||
}
|
||
|
||
interface KreaVideoParams {
|
||
mode?: "text-to-video" | "first-frame" | "first-last-frame" | "reference-images";
|
||
ratio?: string;
|
||
duration?: number;
|
||
resolution?: string;
|
||
seed?: number;
|
||
generateAudio?: boolean;
|
||
}
|
||
|
||
interface UploadedImage {
|
||
thumbnail: string;
|
||
original: string;
|
||
}
|
||
|
||
const DEFAULT_BASE_URL = "https://api.krea.ai";
|
||
const IMAGE_POLL_INTERVAL_MS = 2000;
|
||
const VIDEO_POLL_INTERVAL_MS = 5000;
|
||
const IMAGE_TIMEOUT_MS = 5 * 60 * 1000;
|
||
const VIDEO_TIMEOUT_MS = 20 * 60 * 1000;
|
||
|
||
function normalizeText(value?: string | null) {
|
||
return String(value || "").replace(/\u00a0/g, " ").trim().normalize("NFKC");
|
||
}
|
||
|
||
function normalizeBaseURL(baseURL: string) {
|
||
const normalized = normalizeText(baseURL).replace(/\/+$/, "");
|
||
return normalized || DEFAULT_BASE_URL;
|
||
}
|
||
|
||
function normalizeKreaApiKey(apiKey: string) {
|
||
const stripped = normalizeText(apiKey)
|
||
.replace(/^bearer\s+/i, "")
|
||
.replace(/^key\s+/i, "")
|
||
.replace(/^(?:krea[_-]?api[_-]?key|api[_-]?key|token)\s*[:：]\s*/i, "");
|
||
return stripped.trim().replace(/[^\x20-\x7E]/g, "");
|
||
}
|
||
|
||
function buildHeaders(apiKey: string) {
|
||
return {
|
||
Authorization: `Bearer ${normalizeKreaApiKey(apiKey)}`,
|
||
"Content-Type": "application/json",
|
||
Accept: "application/json",
|
||
};
|
||
}
|
||
|
||
function joinEndpoint(baseURL: string, path: string) {
|
||
const cleanPath = path.startsWith("/") ? path : `/${path}`;
|
||
return `${normalizeBaseURL(baseURL)}${cleanPath}`;
|
||
}
|
||
|
||
function resolveKreaEndpoint(modelId: string) {
|
||
const normalized = normalizeText(modelId);
|
||
if (!normalized) {
|
||
throw new Error("Krea 模型 ID 不能为空");
|
||
}
|
||
if (normalized.startsWith("/generate/")) return normalized;
|
||
if (normalized.startsWith("generate/")) return `/${normalized}`;
|
||
if (/^(image|video|enhance)\//i.test(normalized)) return `/generate/${normalized}`;
|
||
throw new Error("Krea 模型 ID 需要使用官方 /generate/... endpoint");
|
||
}
|
||
|
||
function detectExtensionFromContentType(contentType?: string | null) {
|
||
const normalized = String(contentType || "").toLowerCase();
|
||
if (normalized.includes("jpeg") || normalized.includes("jpg")) return "jpg";
|
||
if (normalized.includes("webp")) return "webp";
|
||
if (normalized.includes("gif")) return "gif";
|
||
if (normalized.includes("png")) return "png";
|
||
if (normalized.includes("mp4")) return "mp4";
|
||
if (normalized.includes("quicktime")) return "mov";
|
||
if (normalized.includes("webm")) return "webm";
|
||
return "bin";
|
||
}
|
||
|
||
function generateFilename(prefix: string, extension: string) {
|
||
const timestamp = Date.now();
|
||
const random = Math.random().toString(36).slice(2, 8);
|
||
return `${prefix}-${timestamp}-${random}.${extension}`;
|
||
}
|
||
|
||
function extractDataUriParts(dataUri: string) {
|
||
const match = dataUri.match(/^data:([^;]+);base64,(.+)$/);
|
||
if (!match) {
|
||
throw new Error("不支持的 Data URI 格式");
|
||
}
|
||
return {
|
||
mimeType: match[1],
|
||
buffer: Buffer.from(match[2], "base64"),
|
||
};
|
||
}
|
||
|
||
async function uploadDataUriAsset(dataUri: string, prefix: "krea-input" | "krea-video") {
|
||
const { mimeType, buffer } = extractDataUriParts(dataUri);
|
||
const extension = detectExtensionFromContentType(mimeType);
|
||
const arrayBuffer = buffer.buffer.slice(
|
||
buffer.byteOffset,
|
||
buffer.byteOffset + buffer.byteLength
|
||
) as ArrayBuffer;
|
||
const uploaded = await uploadFile(generateFilename(prefix, extension), arrayBuffer);
|
||
return uploaded.url;
|
||
}
|
||
|
||
async function normalizeAssetUrl(url?: string | null) {
|
||
const normalized = normalizeText(url);
|
||
if (!normalized) return "";
|
||
if (/^https?:\/\//i.test(normalized)) return normalized;
|
||
if (/^data:(image|video)\//i.test(normalized)) {
|
||
return uploadDataUriAsset(
|
||
normalized,
|
||
/^data:video\//i.test(normalized) ? "krea-video" : "krea-input"
|
||
);
|
||
}
|
||
return normalized;
|
||
}
|
||
|
||
function isVideoUrl(url: string, mediaType?: string | null) {
|
||
const normalizedMediaType = String(mediaType || "").toLowerCase();
|
||
if (normalizedMediaType.startsWith("video/")) return true;
|
||
return /\.(mp4|mov|webm|m4v)(\?|#|$)/i.test(url) || /^data:video\//i.test(url);
|
||
}
|
||
|
||
function extractPromptAndAssets(messages: Array<{ role: string; content: any }>) {
|
||
const lastUserMessage = messages.filter((message) => message.role === "user").pop();
|
||
if (!lastUserMessage) {
|
||
throw new Error("未找到用户输入内容");
|
||
}
|
||
|
||
let prompt = "";
|
||
const imageUrls: string[] = [];
|
||
const videoUrls: string[] = [];
|
||
|
||
const pushAssetUrl = (value?: string, mediaType?: string | null) => {
|
||
if (!value) return;
|
||
const normalized = String(value || "").trim();
|
||
if (!normalized) return;
|
||
const target = isVideoUrl(normalized, mediaType) ? videoUrls : imageUrls;
|
||
if (!target.includes(normalized)) {
|
||
target.push(normalized);
|
||
}
|
||
};
|
||
|
||
const readContentPart = (part: any) => {
|
||
if (!part) return;
|
||
if (part.type === "text" && typeof part.text === "string") {
|
||
prompt = `${prompt} ${part.text}`.trim();
|
||
return;
|
||
}
|
||
if (part.type === "image_url" && part.image_url?.url) {
|
||
pushAssetUrl(part.image_url.url, "image/jpeg");
|
||
return;
|
||
}
|
||
if (part.type === "file") {
|
||
pushAssetUrl(part.url || part.data, part.mediaType || part.mimeType);
|
||
return;
|
||
}
|
||
if (part.type === "image") {
|
||
pushAssetUrl(part.image || part.url || part.data, part.mediaType || "image/jpeg");
|
||
return;
|
||
}
|
||
if (part.type === "video") {
|
||
pushAssetUrl(part.video || part.url || part.data, part.mediaType || "video/mp4");
|
||
}
|
||
};
|
||
|
||
if (typeof lastUserMessage.content === "string") {
|
||
prompt = normalizeText(lastUserMessage.content);
|
||
} else if (Array.isArray(lastUserMessage.content)) {
|
||
for (const part of lastUserMessage.content) {
|
||
readContentPart(part);
|
||
}
|
||
}
|
||
|
||
return {
|
||
prompt: normalizeText(prompt) || "生成内容",
|
||
imageUrls,
|
||
videoUrls,
|
||
};
|
||
}
|
||
|
||
function normalizeAspectRatio(value?: string, fallback = "16:9") {
|
||
const normalized = normalizeText(value || fallback);
|
||
if (
|
||
[
|
||
"21:9",
|
||
"16:9",
|
||
"9:16",
|
||
"4:3",
|
||
"3:4",
|
||
"1:1",
|
||
"9:21",
|
||
"auto",
|
||
].includes(normalized)
|
||
) {
|
||
return normalized;
|
||
}
|
||
return fallback;
|
||
}
|
||
|
||
function clamp(value: number, min: number, max: number) {
|
||
return Math.max(min, Math.min(max, value));
|
||
}
|
||
|
||
function roundToMultiple(value: number, multiple = 16) {
|
||
return Math.max(multiple, Math.round(value / multiple) * multiple);
|
||
}
|
||
|
||
function normalizeImageSizeLabel(imageSize?: string): "1K" | "2K" | "4K" {
|
||
const normalized = normalizeText(imageSize).toUpperCase();
|
||
if (normalized === "1K" || normalized === "2K" || normalized === "4K") {
|
||
return normalized;
|
||
}
|
||
return "2K";
|
||
}
|
||
|
||
function resolveImageDimensions(aspectRatio?: string, imageSize?: string) {
|
||
const size = normalizeImageSizeLabel(imageSize);
|
||
const base = size === "4K" ? 2048 : size === "2K" ? 1536 : 1024;
|
||
const ratio = normalizeAspectRatio(aspectRatio, "1:1");
|
||
if (ratio === "auto" || !ratio.includes(":")) {
|
||
return { width: base, height: base, imageSize: size };
|
||
}
|
||
|
||
const [rawW, rawH] = ratio.split(":").map((item) => Number(item));
|
||
const ratioW = Number.isFinite(rawW) && rawW > 0 ? rawW : 1;
|
||
const ratioH = Number.isFinite(rawH) && rawH > 0 ? rawH : 1;
|
||
const landscape = ratioW >= ratioH;
|
||
const width = landscape ? base : Math.round((base * ratioW) / ratioH);
|
||
const height = landscape ? Math.round((base * ratioH) / ratioW) : base;
|
||
return {
|
||
width: clamp(roundToMultiple(width), 256, 2048),
|
||
height: clamp(roundToMultiple(height), 256, 2048),
|
||
imageSize: size,
|
||
};
|
||
}
|
||
|
||
function resolveVideoDimensions(ratio?: string, resolution?: string) {
|
||
const normalizedResolution = normalizeText(resolution).toLowerCase();
|
||
const baseHeight = normalizedResolution === "1080p" ? 1080 : 720;
|
||
const aspectRatio = normalizeAspectRatio(ratio, "16:9");
|
||
if (aspectRatio === "9:16") {
|
||
return { width: baseHeight, height: Math.round((baseHeight * 16) / 9) };
|
||
}
|
||
if (aspectRatio === "1:1") {
|
||
return { width: baseHeight, height: baseHeight };
|
||
}
|
||
if (aspectRatio === "4:3") {
|
||
return { width: Math.round((baseHeight * 4) / 3), height: baseHeight };
|
||
}
|
||
if (aspectRatio === "3:4") {
|
||
return { width: baseHeight, height: Math.round((baseHeight * 4) / 3) };
|
||
}
|
||
if (aspectRatio === "21:9") {
|
||
return { width: Math.round((baseHeight * 21) / 9), height: baseHeight };
|
||
}
|
||
return { width: Math.round((baseHeight * 16) / 9), height: baseHeight };
|
||
}
|
||
|
||
function normalizeSeed(seed?: number) {
|
||
if (!Number.isFinite(Number(seed))) return undefined;
|
||
return clamp(Math.round(Number(seed)), 0, 4294967295);
|
||
}
|
||
|
||
function normalizeBatchSize(value?: number) {
|
||
if (!Number.isFinite(Number(value))) return 1;
|
||
return clamp(Math.round(Number(value)), 1, 4);
|
||
}
|
||
|
||
function normalizeVideoDuration(duration: unknown, endpoint: string) {
|
||
const value = Number.isFinite(Number(duration)) ? Math.round(Number(duration)) : 5;
|
||
if (endpoint.includes("/minimax/hailuo-02") || endpoint.includes("/minimax/hailuo-2.3")) {
|
||
return clamp(value || 6, 6, 10);
|
||
}
|
||
if (endpoint.includes("/google/veo")) {
|
||
return clamp(value || 8, 4, 8);
|
||
}
|
||
if (endpoint.includes("/openai/sora-2")) {
|
||
return clamp(value || 4, 4, 20);
|
||
}
|
||
if (endpoint.includes("/kling/")) {
|
||
return value >= 8 ? 10 : 5;
|
||
}
|
||
if (endpoint.includes("/alibaba/wan-2.5")) {
|
||
return clamp(value || 5, 5, 10);
|
||
}
|
||
return value >= 8 ? 10 : 5;
|
||
}
|
||
|
||
function normalizeVideoResolution(resolution: unknown, endpoint: string) {
|
||
const normalized = normalizeText(String(resolution || "")).toLowerCase();
|
||
if (endpoint.includes("/minimax/")) {
|
||
if (normalized === "1080p") return "1080p";
|
||
if (normalized === "512p" || normalized === "480p") return "512p";
|
||
return "768p";
|
||
}
|
||
if (normalized === "1080p" || normalized === "480p") return normalized;
|
||
return "720p";
|
||
}
|
||
|
||
function normalizeVideoAspectRatio(ratio: unknown, endpoint: string) {
|
||
const normalized = normalizeAspectRatio(String(ratio || ""), "16:9");
|
||
if (endpoint.includes("/openai/sora-2")) {
|
||
return normalized === "9:16" ? "9:16" : "16:9";
|
||
}
|
||
if (endpoint.includes("/google/veo") || endpoint.includes("/kling/")) {
|
||
return ["16:9", "9:16", "1:1"].includes(normalized) ? normalized : "16:9";
|
||
}
|
||
return normalized === "auto" ? "16:9" : normalized;
|
||
}
|
||
|
||
function buildStyleImages(imageUrls: string[]) {
|
||
return imageUrls.map((url) => ({ url, strength: 1 }));
|
||
}
|
||
|
||
function buildTaggedReferences(imageUrls: string[], tagPrefix = "ref", max = 3) {
|
||
return imageUrls.slice(0, max).map((url, index) => ({
|
||
url,
|
||
tag: `${tagPrefix}_${index + 1}`.replace(/[^a-z0-9_]/gi, "_").toLowerCase(),
|
||
}));
|
||
}
|
||
|
||
function collectHttpUrls(payload: unknown): string[] {
|
||
const urls = new Set<string>();
|
||
const visit = (value: unknown) => {
|
||
if (typeof value === "string") {
|
||
const normalized = value.trim();
|
||
if (/^https?:\/\//i.test(normalized)) {
|
||
urls.add(normalized);
|
||
}
|
||
return;
|
||
}
|
||
if (Array.isArray(value)) {
|
||
value.forEach(visit);
|
||
return;
|
||
}
|
||
if (value && typeof value === "object") {
|
||
Object.values(value as Record<string, unknown>).forEach(visit);
|
||
}
|
||
};
|
||
visit(payload);
|
||
return Array.from(urls);
|
||
}
|
||
|
||
async function downloadRemoteAsset(url: string) {
|
||
const controller = new AbortController();
|
||
const timeoutId = setTimeout(() => controller.abort(), 120000);
|
||
|
||
try {
|
||
const response = await fetch(url, {
|
||
cache: "no-store",
|
||
signal: controller.signal,
|
||
});
|
||
if (!response.ok) {
|
||
throw new Error(`下载 Krea 输出失败: ${response.status}`);
|
||
}
|
||
return {
|
||
buffer: Buffer.from(await response.arrayBuffer()),
|
||
contentType: response.headers.get("content-type"),
|
||
};
|
||
} finally {
|
||
clearTimeout(timeoutId);
|
||
}
|
||
}
|
||
|
||
async function uploadGeneratedBuffer(buffer: Buffer, extension: string): Promise<UploadedImage> {
|
||
const thumbnailBuffer = await sharp(buffer)
|
||
.resize(400, 400, { fit: "inside", withoutEnlargement: true })
|
||
.jpeg({ quality: 80 })
|
||
.toBuffer();
|
||
|
||
const originalArrayBuffer = buffer.buffer.slice(
|
||
buffer.byteOffset,
|
||
buffer.byteOffset + buffer.byteLength
|
||
) as ArrayBuffer;
|
||
const originalUploaded = await uploadFile(
|
||
generateFilename("krea-image-orig", extension === "bin" ? "png" : extension),
|
||
originalArrayBuffer
|
||
);
|
||
|
||
const thumbnailArrayBuffer = thumbnailBuffer.buffer.slice(
|
||
thumbnailBuffer.byteOffset,
|
||
thumbnailBuffer.byteOffset + thumbnailBuffer.byteLength
|
||
) as ArrayBuffer;
|
||
const thumbnailUploaded = await uploadFile(
|
||
generateFilename("krea-image-thumb", "jpg"),
|
||
thumbnailArrayBuffer
|
||
);
|
||
|
||
return {
|
||
thumbnail: thumbnailUploaded.url,
|
||
original: originalUploaded.url,
|
||
};
|
||
}
|
||
|
||
async function uploadKreaImages(payload: unknown) {
|
||
const uploadedImages: UploadedImage[] = [];
|
||
for (const url of collectHttpUrls(payload)) {
|
||
try {
|
||
const { buffer, contentType } = await downloadRemoteAsset(url);
|
||
if (!String(contentType || "").startsWith("image/")) continue;
|
||
uploadedImages.push(await uploadGeneratedBuffer(buffer, detectExtensionFromContentType(contentType)));
|
||
} catch (error) {
|
||
console.warn("[Krea] Failed to archive image output:", error);
|
||
}
|
||
}
|
||
if (uploadedImages.length === 0) {
|
||
throw new Error("Krea 未返回可用图片");
|
||
}
|
||
return uploadedImages;
|
||
}
|
||
|
||
async function uploadVideoToStorage(remoteVideoUrl: string) {
|
||
try {
|
||
const { buffer, contentType } = await downloadRemoteAsset(remoteVideoUrl);
|
||
const extension = detectExtensionFromContentType(contentType || "video/mp4");
|
||
const arrayBuffer = buffer.buffer.slice(
|
||
buffer.byteOffset,
|
||
buffer.byteOffset + buffer.byteLength
|
||
) as ArrayBuffer;
|
||
const uploaded = await uploadFile(
|
||
generateFilename("krea-video", extension === "bin" ? "mp4" : extension),
|
||
arrayBuffer
|
||
);
|
||
return uploaded.url;
|
||
} catch (error) {
|
||
console.warn("[Krea] Failed to archive video output, using temporary URL:", error);
|
||
return remoteVideoUrl;
|
||
}
|
||
}
|
||
|
||
async function resolveKreaVideoUrl(payload: unknown) {
|
||
const outputUrls = collectHttpUrls(payload);
|
||
if (outputUrls.length === 0) {
|
||
throw new Error("Krea 未返回可用视频地址");
|
||
}
|
||
const videoUrl =
|
||
outputUrls.find((url) => /\.(mp4|mov|webm)(\?|#|$)/i.test(url) || /video/i.test(url)) ||
|
||
outputUrls[0]!;
|
||
return uploadVideoToStorage(videoUrl);
|
||
}
|
||
|
||
function formatImageMarkdown(images: UploadedImage[], imageSize: string) {
|
||
return images
|
||
.map((image) => ``)
|
||
.join("\n\n");
|
||
}
|
||
|
||
function formatVideoMarkdown(videoUrl: string) {
|
||
return `<video src="${videoUrl}" controls style="max-width: 100%; border-radius: 8px; margin-bottom: 12px;"></video>\n\n[下载视频](${videoUrl})`;
|
||
}
|
||
|
||
async function requestKreaJob(
|
||
baseURL: string,
|
||
apiKey: string,
|
||
endpoint: string,
|
||
body: Record<string, any>
|
||
) {
|
||
const response = await fetch(joinEndpoint(baseURL, endpoint), {
|
||
method: "POST",
|
||
headers: buildHeaders(apiKey),
|
||
body: JSON.stringify(body),
|
||
});
|
||
|
||
const rawText = await response.text();
|
||
let payload: any = null;
|
||
try {
|
||
payload = rawText ? JSON.parse(rawText) : null;
|
||
} catch {
|
||
payload = rawText;
|
||
}
|
||
|
||
if (!response.ok) {
|
||
console.error("[Krea] Job request failed:", {
|
||
endpoint,
|
||
status: response.status,
|
||
requestFields: Object.keys(body),
|
||
response: payload,
|
||
});
|
||
const message =
|
||
typeof payload?.error === "string"
|
||
? payload.error
|
||
: typeof payload?.message === "string"
|
||
? payload.message
|
||
: rawText || "Krea 请求失败";
|
||
throw new Error(`${message} (HTTP ${response.status})`);
|
||
}
|
||
|
||
const jobId = normalizeText(payload?.job_id || payload?.id);
|
||
if (!jobId && Array.isArray(payload?.result?.urls) && payload.result.urls.length > 0) {
|
||
return payload;
|
||
}
|
||
if (!jobId) {
|
||
throw new Error("Krea 未返回任务 ID");
|
||
}
|
||
return { ...payload, job_id: jobId };
|
||
}
|
||
|
||
async function waitForKreaJob(
|
||
baseURL: string,
|
||
apiKey: string,
|
||
jobId: string,
|
||
kind: KreaModelKind
|
||
) {
|
||
const isVideo = kind === "video";
|
||
const deadline = Date.now() + (isVideo ? VIDEO_TIMEOUT_MS : IMAGE_TIMEOUT_MS);
|
||
const pollInterval = isVideo ? VIDEO_POLL_INTERVAL_MS : IMAGE_POLL_INTERVAL_MS;
|
||
|
||
while (Date.now() < deadline) {
|
||
const response = await fetch(joinEndpoint(baseURL, `/jobs/${jobId}`), {
|
||
method: "GET",
|
||
headers: buildHeaders(apiKey),
|
||
cache: "no-store",
|
||
});
|
||
|
||
const rawText = await response.text();
|
||
let payload: any = null;
|
||
try {
|
||
payload = rawText ? JSON.parse(rawText) : null;
|
||
} catch {
|
||
payload = rawText;
|
||
}
|
||
|
||
if (!response.ok) {
|
||
const message =
|
||
typeof payload?.error === "string"
|
||
? payload.error
|
||
: typeof payload?.message === "string"
|
||
? payload.message
|
||
: rawText || "Krea 轮询失败";
|
||
throw new Error(`${message} (HTTP ${response.status})`);
|
||
}
|
||
|
||
const status = normalizeText(payload?.status).toLowerCase();
|
||
if (status === "completed") {
|
||
return payload;
|
||
}
|
||
if (status === "failed" || status === "cancelled") {
|
||
throw new Error(String(payload?.error || payload?.message || "Krea 任务失败"));
|
||
}
|
||
|
||
await new Promise((resolve) => setTimeout(resolve, pollInterval));
|
||
}
|
||
|
||
throw new Error("Krea 任务超时，请稍后重试");
|
||
}
|
||
|
||
function getRequiredTopazModel(endpoint: string) {
|
||
if (endpoint.includes("/standard-enhance")) return "Standard V2";
|
||
if (endpoint.includes("/bloom-enhance")) return "Reimagine";
|
||
if (endpoint.includes("/generative-enhance")) return "Redefine";
|
||
return undefined;
|
||
}
|
||
|
||
function getRequiredModelValue(endpoint: string) {
|
||
if (endpoint.includes("/seedream-3")) return "seedream-3-0-t2i-250415";
|
||
if (endpoint.includes("/minimax/hailuo")) return "video-01";
|
||
return getRequiredTopazModel(endpoint);
|
||
}
|
||
|
||
function buildKreaBody(params: {
|
||
endpoint: string;
|
||
kind: KreaModelKind;
|
||
requestFields: string[];
|
||
requiredFields: string[];
|
||
prompt: string;
|
||
imageUrls: string[];
|
||
videoUrls: string[];
|
||
imageParams?: KreaImageParams;
|
||
videoParams?: KreaVideoParams;
|
||
}) {
|
||
const {
|
||
endpoint,
|
||
kind,
|
||
requestFields,
|
||
requiredFields,
|
||
prompt,
|
||
imageUrls,
|
||
videoUrls,
|
||
imageParams,
|
||
videoParams,
|
||
} = params;
|
||
const fields = new Set(requestFields);
|
||
const required = new Set(requiredFields);
|
||
const body: Record<string, any> = {};
|
||
const isVideo = kind === "video";
|
||
const ratio = isVideo
|
||
? normalizeVideoAspectRatio(videoParams?.ratio, endpoint)
|
||
: normalizeAspectRatio(imageParams?.aspectRatio, "1:1");
|
||
const videoResolution = normalizeVideoResolution(videoParams?.resolution, endpoint);
|
||
const imageDimensions = resolveImageDimensions(imageParams?.aspectRatio, imageParams?.imageSize);
|
||
const videoDimensions = resolveVideoDimensions(ratio, videoResolution);
|
||
|
||
if (fields.has("prompt")) body.prompt = prompt;
|
||
if (fields.has("batchSize")) body.batchSize = normalizeBatchSize(imageParams?.imageCount);
|
||
|
||
if (fields.has("width")) body.width = isVideo ? videoDimensions.width : imageDimensions.width;
|
||
if (fields.has("height")) body.height = isVideo ? videoDimensions.height : imageDimensions.height;
|
||
if (fields.has("aspectRatio")) body.aspectRatio = ratio === "auto" ? "1:1" : ratio;
|
||
if (fields.has("ratio")) body.ratio = ratio === "auto" ? "16:9" : ratio;
|
||
if (fields.has("resolution")) {
|
||
body.resolution = isVideo ? videoResolution : normalizeImageSizeLabel(imageParams?.imageSize);
|
||
}
|
||
|
||
const seed = normalizeSeed(isVideo ? videoParams?.seed : imageParams?.seed);
|
||
if (fields.has("seed") && seed !== undefined) body.seed = seed;
|
||
if (fields.has("negative_prompt") && imageParams?.negativePrompt) {
|
||
body.negative_prompt = imageParams.negativePrompt;
|
||
}
|
||
if (fields.has("skipPromptExpansion") && typeof imageParams?.promptExtend === "boolean") {
|
||
body.skipPromptExpansion = !imageParams.promptExtend;
|
||
}
|
||
if (fields.has("enablePromptExpansion")) {
|
||
body.enablePromptExpansion = true;
|
||
}
|
||
if (fields.has("expandPrompt")) {
|
||
body.expandPrompt = true;
|
||
}
|
||
if (fields.has("duration")) {
|
||
body.duration = normalizeVideoDuration(videoParams?.duration, endpoint);
|
||
}
|
||
if (fields.has("generateAudio") && typeof videoParams?.generateAudio === "boolean") {
|
||
body.generateAudio = videoParams.generateAudio;
|
||
}
|
||
if (fields.has("loop")) {
|
||
body.loop = false;
|
||
}
|
||
if (fields.has("mode")) {
|
||
body.mode = endpoint.includes("/kling/kling-2") ? "master" : "std";
|
||
}
|
||
if (fields.has("model")) {
|
||
const modelValue = getRequiredModelValue(endpoint);
|
||
if (modelValue) body.model = modelValue;
|
||
}
|
||
if (fields.has("output_format")) body.output_format = "jpg";
|
||
if (fields.has("backgroundImage")) body.backgroundImage = "auto";
|
||
|
||
if (fields.has("imageUrls") && imageUrls.length > 0) {
|
||
body.imageUrls = imageUrls.slice(0, 8);
|
||
}
|
||
if (fields.has("imageUrl") && imageUrls[0]) {
|
||
body.imageUrl = imageUrls[0];
|
||
}
|
||
if (fields.has("image_url") && imageUrls[0]) {
|
||
body.image_url = imageUrls[0];
|
||
}
|
||
if (fields.has("styleImages") && imageUrls.length > 0 && !body.imageUrls && !body.imageUrl) {
|
||
body.styleImages = buildStyleImages(imageUrls.slice(0, 4));
|
||
}
|
||
if (fields.has("imageStyleRefs") && imageUrls.length > 1) {
|
||
body.imageStyleRefs = buildStyleImages(imageUrls.slice(1, 5));
|
||
}
|
||
if (fields.has("characterReferenceImages") && imageUrls.length > 0) {
|
||
body.characterReferenceImages = imageUrls.slice(0, 4);
|
||
}
|
||
|
||
if (fields.has("referenceImages") && imageUrls.length > 0) {
|
||
body.referenceImages = endpoint.includes("/image/runway/gen-4-image")
|
||
? buildTaggedReferences(imageUrls, "ref", 3)
|
||
: imageUrls.slice(0, endpoint.includes("/seedance-2") ? 9 : 4);
|
||
}
|
||
|
||
if (fields.has("startImage") && imageUrls[0]) body.startImage = imageUrls[0];
|
||
if (fields.has("endImage") && imageUrls[1]) body.endImage = imageUrls[1];
|
||
if (fields.has("init_image_url") && imageUrls[0]) body.init_image_url = imageUrls[0];
|
||
if (fields.has("references") && imageUrls[0]) {
|
||
body.references = [{ type: "image", uri: imageUrls[0] }];
|
||
}
|
||
if (fields.has("subjects") && imageUrls[0] && videoParams?.mode === "reference-images") {
|
||
body.subjects = [{ type: "character", image: [imageUrls[0]] }];
|
||
}
|
||
if (fields.has("styleReferences") && imageUrls.length > 0) {
|
||
body.styleReferences = buildTaggedReferences(imageUrls, "style", 3);
|
||
}
|
||
if (fields.has("elementReferences") && imageUrls.length > 0) {
|
||
body.elementReferences = [
|
||
{
|
||
tag: "element_1",
|
||
images: imageUrls.slice(0, 3),
|
||
},
|
||
];
|
||
}
|
||
if (fields.has("videoReference") && videoUrls[0]) {
|
||
body.videoReference = { url: videoUrls[0], tag: "video_1" };
|
||
}
|
||
if (fields.has("startVideo") && videoUrls[0]) body.startVideo = videoUrls[0];
|
||
if (fields.has("init_video") && videoUrls[0]) body.init_video = videoUrls[0];
|
||
if (fields.has("referenceVideos") && videoUrls.length > 0) {
|
||
body.referenceVideos = videoUrls.slice(0, 3);
|
||
}
|
||
|
||
if (required.has("referenceImages") && !body.referenceImages) {
|
||
throw new Error("该 Krea 模型需要至少 1 张参考图");
|
||
}
|
||
if ((required.has("imageUrl") || required.has("image_url")) && !body.imageUrl && !body.image_url) {
|
||
throw new Error("该 Krea 模型需要上传图片");
|
||
}
|
||
if (required.has("init_video") && !body.init_video) {
|
||
throw new Error("该 Krea 模型需要上传视频");
|
||
}
|
||
|
||
return { body, imageSize: imageDimensions.imageSize };
|
||
}
|
||
|
||
export function createKrea({ apiKey, baseURL }: KreaConfig) {
|
||
return {
|
||
provider: "krea",
|
||
chat: (modelId: string) => ({
|
||
provider: "krea",
|
||
doGenerate: async (options: {
|
||
messages: Array<{ role: string; content: any }>;
|
||
imageParams?: KreaImageParams;
|
||
videoParams?: KreaVideoParams;
|
||
overrideModelId?: string;
|
||
}) => {
|
||
try {
|
||
const activeModelId = normalizeText(options.overrideModelId || modelId);
|
||
const endpoint = resolveKreaEndpoint(activeModelId);
|
||
const preset = getKreaModelPresetById(endpoint);
|
||
const kind =
|
||
preset?.kind ||
|
||
inferKreaModelKind(endpoint) ||
|
||
(options.videoParams ? "video" : "image");
|
||
const { prompt, imageUrls, videoUrls } = extractPromptAndAssets(options.messages);
|
||
const normalizedImageUrls = (
|
||
await Promise.all(imageUrls.map((url) => normalizeAssetUrl(url)))
|
||
).filter(Boolean);
|
||
const normalizedVideoUrls = (
|
||
await Promise.all(videoUrls.map((url) => normalizeAssetUrl(url)))
|
||
).filter(Boolean);
|
||
|
||
const requestFields =
|
||
preset?.requestFields ||
|
||
(kind === "video"
|
||
? ["prompt", "aspectRatio", "duration", "startImage", "endImage", "referenceImages"]
|
||
: ["prompt", "width", "height", "imageUrls", "imageUrl", "batchSize"]);
|
||
const requiredFields = preset?.requiredFields || ["prompt"];
|
||
const { body, imageSize } = buildKreaBody({
|
||
endpoint,
|
||
kind,
|
||
requestFields,
|
||
requiredFields,
|
||
prompt,
|
||
imageUrls: normalizedImageUrls,
|
||
videoUrls: normalizedVideoUrls,
|
||
imageParams: options.imageParams,
|
||
videoParams: options.videoParams,
|
||
});
|
||
|
||
console.log("[Krea] Submitting job:", {
|
||
endpoint,
|
||
kind,
|
||
requestFields: Object.keys(body),
|
||
imageCount: normalizedImageUrls.length,
|
||
videoCount: normalizedVideoUrls.length,
|
||
});
|
||
|
||
const job = await requestKreaJob(baseURL, apiKey, endpoint, body);
|
||
const output = job?.result?.urls?.length
|
||
? job
|
||
: await waitForKreaJob(baseURL, apiKey, job.job_id, kind);
|
||
|
||
const text =
|
||
kind === "video"
|
||
? formatVideoMarkdown(await resolveKreaVideoUrl(output?.result ?? output))
|
||
: formatImageMarkdown(await uploadKreaImages(output?.result ?? output), imageSize);
|
||
|
||
return {
|
||
text,
|
||
finishReason: "stop" as const,
|
||
usage: {
|
||
promptTokens: 0,
|
||
completionTokens: text.length,
|
||
},
|
||
};
|
||
} catch (error) {
|
||
console.error("[Krea] Generation failed:", error);
|
||
const kind =
|
||
inferKreaModelKind(options.overrideModelId || modelId) ||
|
||
(options.videoParams ? "video" : "image");
|
||
return {
|
||
text:
|
||
error instanceof Error
|
||
? `${kind === "video" ? "视频" : "图片"}生成失败: ${error.message}`
|
||
: "Krea 生成失败，请稍后重试",
|
||
finishReason: "error" as const,
|
||
usage: {
|
||
promptTokens: 0,
|
||
completionTokens: 0,
|
||
},
|
||
};
|
||
}
|
||
},
|
||
doStream: async function* (options: {
|
||
messages: Array<{ role: string; content: any }>;
|
||
imageParams?: KreaImageParams;
|
||
videoParams?: KreaVideoParams;
|
||
overrideModelId?: string;
|
||
}) {
|
||
const result = await this.doGenerate(options);
|
||
yield {
|
||
type: "text-delta",
|
||
textDelta: result.text,
|
||
};
|
||
},
|
||
modelId,
|
||
specificationVersion: "v1" as const,
|
||
defaultObjectGenerationMode: "json" as const,
|
||
}),
|
||
};
|
||
}
|