740 lines
21 KiB
TypeScript
740 lines
21 KiB
TypeScript
import { auth } from "@/app/(auth)/auth";
|
||
import { getSystemSetting } from "@/lib/db/queries";
|
||
import {
|
||
DEFAULT_BFL_MODEL,
|
||
DEFAULT_REPLICATE_BASE_URL,
|
||
DEFAULT_REPLICATE_MODEL,
|
||
RealtimeCanvasConfig,
|
||
RealtimeProviderConfig,
|
||
resolveRealtimeProviders,
|
||
} from "@/lib/realtime/config";
|
||
|
||
type GeneratePayload = {
|
||
requestId?: string;
|
||
imageUrl?: string;
|
||
maskImageUrl?: string;
|
||
qualityProfile?: "preview" | "refine";
|
||
roi?:
|
||
| {
|
||
x?: number;
|
||
y?: number;
|
||
width?: number;
|
||
height?: number;
|
||
}
|
||
| null;
|
||
prompt?: string;
|
||
seed?: number;
|
||
imageSize?: "square" | "square_hd";
|
||
steps?: number;
|
||
cfgScale?: number;
|
||
strength?: number;
|
||
};
|
||
|
||
type BflSubmitResponse = {
|
||
id?: string;
|
||
polling_url?: string;
|
||
response?: {
|
||
id?: string;
|
||
polling_url?: string;
|
||
result?: unknown;
|
||
};
|
||
result?: unknown;
|
||
sample?: string;
|
||
error?: unknown;
|
||
message?: string;
|
||
};
|
||
|
||
type ReplicatePredictionResponse = {
|
||
id?: string;
|
||
status?: string;
|
||
output?: unknown;
|
||
error?: unknown;
|
||
detail?: unknown;
|
||
urls?: {
|
||
get?: string;
|
||
};
|
||
};
|
||
|
||
const FALLBACK_REALTIME_PROMPT =
|
||
"严格按照输入草图生成：保持主体轮廓、位置、比例和数量一致，只做材质与光影细化；禁止改变构图，禁止新增无关背景纹理。";
|
||
|
||
function clamp(value: number, min: number, max: number) {
|
||
return Math.min(max, Math.max(min, value));
|
||
}
|
||
|
||
function resolveSquareSize(
|
||
imageSize: "square" | "square_hd" | undefined,
|
||
maxInputResolution: number
|
||
) {
|
||
const preferred = imageSize === "square_hd" ? 1280 : 1024;
|
||
const capped = Math.min(preferred, maxInputResolution);
|
||
return clamp(Math.round(capped / 64) * 64, 512, 1536);
|
||
}
|
||
|
||
function resolveSeed(seed: unknown) {
|
||
const parsed = Number(seed);
|
||
if (!Number.isFinite(parsed)) return undefined;
|
||
const normalized = Math.floor(parsed);
|
||
if (normalized < 0 || normalized > 2147483647) return undefined;
|
||
return normalized;
|
||
}
|
||
|
||
function encodeModelPath(modelId: string) {
|
||
return modelId
|
||
.split("/")
|
||
.filter(Boolean)
|
||
.map((part) => encodeURIComponent(part))
|
||
.join("/");
|
||
}
|
||
|
||
function sanitizeText(raw: string) {
|
||
return raw.replace(/[\u2028\u2029]/g, " ").trim();
|
||
}
|
||
|
||
function extractBflImageUrl(payload: any): string {
|
||
const candidates = [
|
||
payload?.sample,
|
||
payload?.result?.sample,
|
||
payload?.response?.result?.sample,
|
||
payload?.output?.[0],
|
||
payload?.result?.output?.[0],
|
||
payload?.images?.[0],
|
||
payload?.result?.images?.[0],
|
||
payload?.image_url,
|
||
payload?.result?.image_url,
|
||
payload?.url,
|
||
payload?.result?.url,
|
||
];
|
||
|
||
for (const candidate of candidates) {
|
||
const value = String(candidate || "").trim();
|
||
if (!value) continue;
|
||
if (value.startsWith("data:")) return value;
|
||
if (/^https?:\/\//i.test(value)) return value;
|
||
}
|
||
|
||
return "";
|
||
}
|
||
|
||
function extractBflErrorMessage(payload: any, fallback: string) {
|
||
const message = String(
|
||
payload?.error?.message ||
|
||
payload?.error ||
|
||
payload?.detail ||
|
||
payload?.message ||
|
||
payload?.response?.error?.message ||
|
||
payload?.response?.error ||
|
||
""
|
||
).trim();
|
||
return message || fallback;
|
||
}
|
||
|
||
function shouldRetryWithAlternateImageField(message: string) {
|
||
const normalized = message.toLowerCase();
|
||
return (
|
||
normalized.includes("image_prompt") ||
|
||
normalized.includes("input_image") ||
|
||
normalized.includes("unsupported parameter") ||
|
||
normalized.includes("unknown field") ||
|
||
normalized.includes("invalid request")
|
||
);
|
||
}
|
||
|
||
function delay(ms: number) {
|
||
return new Promise((resolve) => setTimeout(resolve, ms));
|
||
}
|
||
|
||
function toImagePromptValue(imageUrl: string) {
|
||
const trimmed = imageUrl.trim();
|
||
if (!trimmed) return "";
|
||
if (trimmed.startsWith("data:")) {
|
||
const commaIndex = trimmed.indexOf(",");
|
||
if (commaIndex > -1) {
|
||
return trimmed.slice(commaIndex + 1).trim();
|
||
}
|
||
}
|
||
return trimmed;
|
||
}
|
||
|
||
function getBflImageFieldCandidates() {
|
||
// BFL's current FLUX/Kontext editing APIs use `input_image` as the canonical field.
|
||
// Keep `image_prompt` only as a legacy fallback in case an older compatible endpoint is used.
|
||
return ["input_image", "image_prompt"] as const;
|
||
}
|
||
|
||
function getReplicateImageFieldCandidates(imagePrompt: string) {
|
||
return [
|
||
{ images: [imagePrompt] },
|
||
{ image: imagePrompt },
|
||
{ input_image: imagePrompt },
|
||
] as const;
|
||
}
|
||
|
||
function isSelfHostedRealtimeProvider(provider: RealtimeProviderConfig) {
|
||
return !provider.baseUrl.includes("api.bfl.ai");
|
||
}
|
||
|
||
function splitReplicateModelIdentifier(modelId: string) {
|
||
const [owner, ...rest] = modelId.split("/").filter(Boolean);
|
||
const name = rest.join("/");
|
||
if (!owner || !name) {
|
||
throw new Error(`无效的 Replicate 模型标识：${modelId}`);
|
||
}
|
||
return { owner, name };
|
||
}
|
||
|
||
function extractReplicateImageUrl(payload: any): string {
|
||
const output = payload?.output;
|
||
const candidates = [
|
||
Array.isArray(output) ? output[0] : output,
|
||
payload?.urls?.stream,
|
||
payload?.result,
|
||
];
|
||
|
||
for (const candidate of candidates) {
|
||
const value = String(candidate || "").trim();
|
||
if (!value) continue;
|
||
if (value.startsWith("data:")) return value;
|
||
if (/^https?:\/\//i.test(value)) return value;
|
||
}
|
||
|
||
return "";
|
||
}
|
||
|
||
function extractReplicateErrorMessage(payload: any, fallback: string) {
|
||
const message = String(payload?.detail || payload?.error || payload?.message || "").trim();
|
||
return message || fallback;
|
||
}
|
||
|
||
async function submitReplicatePrediction(params: {
|
||
apiKey: string;
|
||
model: string;
|
||
input: Record<string, unknown>;
|
||
}): Promise<SubmitTaskResult> {
|
||
const { owner, name } = splitReplicateModelIdentifier(params.model);
|
||
const endpoint = `${DEFAULT_REPLICATE_BASE_URL}/models/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/predictions`;
|
||
const response = await fetch(endpoint, {
|
||
method: "POST",
|
||
headers: {
|
||
Authorization: `Bearer ${params.apiKey}`,
|
||
"Content-Type": "application/json",
|
||
Prefer: "wait=2",
|
||
},
|
||
body: JSON.stringify({ input: params.input }),
|
||
cache: "no-store",
|
||
});
|
||
const payload = (await response.json().catch(() => null)) as ReplicatePredictionResponse | null;
|
||
const imageUrl = extractReplicateImageUrl(payload);
|
||
const taskId = String(payload?.id || "").trim();
|
||
const pollingUrl = String(payload?.urls?.get || "").trim();
|
||
|
||
if (response.ok && (imageUrl || taskId || pollingUrl)) {
|
||
return {
|
||
taskId,
|
||
pollingUrl,
|
||
imageUrl,
|
||
errorMessage: "",
|
||
status: response.status,
|
||
};
|
||
}
|
||
|
||
return {
|
||
taskId,
|
||
pollingUrl,
|
||
imageUrl,
|
||
errorMessage: extractReplicateErrorMessage(payload, `Replicate 请求失败（${response.status}）`),
|
||
status: response.status,
|
||
};
|
||
}
|
||
|
||
async function pollReplicateResult(params: {
|
||
apiKey: string;
|
||
pollingUrl?: string;
|
||
taskId?: string;
|
||
timeoutMs?: number;
|
||
}) {
|
||
const timeoutMs = Math.max(10_000, Number(params.timeoutMs || 60_000));
|
||
const deadline = Date.now() + timeoutMs;
|
||
let lastMessage = "";
|
||
|
||
while (Date.now() < deadline) {
|
||
const taskId = String(params.taskId || "").trim();
|
||
const url =
|
||
String(params.pollingUrl || "").trim() ||
|
||
`${DEFAULT_REPLICATE_BASE_URL}/predictions/${encodeURIComponent(taskId)}`;
|
||
|
||
const response = await fetch(url, {
|
||
method: "GET",
|
||
headers: {
|
||
Authorization: `Bearer ${params.apiKey}`,
|
||
Accept: "application/json",
|
||
},
|
||
cache: "no-store",
|
||
});
|
||
|
||
const payload = (await response.json().catch(() => null)) as ReplicatePredictionResponse | null;
|
||
const imageUrl = extractReplicateImageUrl(payload);
|
||
if (imageUrl) return { imageUrl, errorMessage: "", status: response.status };
|
||
|
||
const status = String(payload?.status || "").trim().toLowerCase();
|
||
if (status) {
|
||
lastMessage = status;
|
||
}
|
||
|
||
if (status === "succeeded") {
|
||
return {
|
||
imageUrl: "",
|
||
errorMessage: "Replicate 返回成功状态但未携带图像结果",
|
||
status: response.status,
|
||
};
|
||
}
|
||
|
||
if (status === "failed" || status === "canceled") {
|
||
return {
|
||
imageUrl: "",
|
||
errorMessage: extractReplicateErrorMessage(payload, "Replicate 任务执行失败"),
|
||
status: response.status,
|
||
};
|
||
}
|
||
|
||
if (!response.ok) {
|
||
return {
|
||
imageUrl: "",
|
||
errorMessage: extractReplicateErrorMessage(payload, `Replicate 轮询失败（${response.status}）`),
|
||
status: response.status,
|
||
};
|
||
}
|
||
|
||
await delay(250);
|
||
}
|
||
|
||
return {
|
||
imageUrl: "",
|
||
errorMessage: `Replicate 轮询超时${lastMessage ? `（${lastMessage}）` : ""}`,
|
||
status: 504,
|
||
};
|
||
}
|
||
|
||
type SubmitTaskResult = {
|
||
taskId: string;
|
||
pollingUrl: string;
|
||
imageUrl: string;
|
||
errorMessage: string;
|
||
status: number;
|
||
};
|
||
|
||
type ProviderAttemptResult =
|
||
| {
|
||
ok: true;
|
||
imageUrl: string;
|
||
taskId: string;
|
||
imageField: "input_image" | "image_prompt";
|
||
fallbackWarning: string;
|
||
provider: RealtimeProviderConfig;
|
||
}
|
||
| {
|
||
ok: false;
|
||
message: string;
|
||
status: number;
|
||
provider: RealtimeProviderConfig;
|
||
};
|
||
|
||
async function submitBflTask(params: {
|
||
apiKey: string;
|
||
baseUrl: string;
|
||
model: string;
|
||
body: Record<string, unknown>;
|
||
}): Promise<SubmitTaskResult> {
|
||
const endpoint = `${params.baseUrl}/v1/${encodeModelPath(params.model)}`;
|
||
const response = await fetch(endpoint, {
|
||
method: "POST",
|
||
headers: {
|
||
"x-key": params.apiKey,
|
||
"Content-Type": "application/json",
|
||
Accept: "application/json",
|
||
},
|
||
body: JSON.stringify(params.body),
|
||
cache: "no-store",
|
||
});
|
||
const payload = (await response.json().catch(() => null)) as BflSubmitResponse | null;
|
||
const imageUrl = extractBflImageUrl(payload);
|
||
const taskId = String(payload?.id || payload?.response?.id || "").trim();
|
||
const pollingUrl = String(payload?.polling_url || payload?.response?.polling_url || "").trim();
|
||
|
||
if (response.ok && (imageUrl || taskId || pollingUrl)) {
|
||
return {
|
||
taskId,
|
||
pollingUrl,
|
||
imageUrl,
|
||
errorMessage: "",
|
||
status: response.status,
|
||
};
|
||
}
|
||
|
||
return {
|
||
taskId,
|
||
pollingUrl,
|
||
imageUrl,
|
||
errorMessage: extractBflErrorMessage(payload, `BFL 请求失败（${response.status}）`),
|
||
status: response.status,
|
||
};
|
||
}
|
||
|
||
async function pollBflResult(params: {
|
||
apiKey: string;
|
||
baseUrl: string;
|
||
pollingUrl?: string;
|
||
taskId?: string;
|
||
timeoutMs?: number;
|
||
}) {
|
||
const timeoutMs = Math.max(20_000, Number(params.timeoutMs || 100_000));
|
||
const deadline = Date.now() + timeoutMs;
|
||
let lastMessage = "";
|
||
|
||
while (Date.now() < deadline) {
|
||
const url = (() => {
|
||
const direct = String(params.pollingUrl || "").trim();
|
||
if (direct) {
|
||
if (/^https?:\/\//i.test(direct)) return direct;
|
||
if (direct.startsWith("/")) return `${params.baseUrl}${direct}`;
|
||
}
|
||
const taskId = String(params.taskId || "").trim();
|
||
return `${params.baseUrl}/v1/get_result?id=${encodeURIComponent(taskId)}`;
|
||
})();
|
||
|
||
const response = await fetch(url, {
|
||
method: "GET",
|
||
headers: {
|
||
"x-key": params.apiKey,
|
||
Accept: "application/json",
|
||
},
|
||
cache: "no-store",
|
||
});
|
||
const payload = await response.json().catch(() => null);
|
||
const imageUrl = extractBflImageUrl(payload);
|
||
if (imageUrl) return { imageUrl, errorMessage: "", status: response.status };
|
||
|
||
const status = String(
|
||
payload?.status ||
|
||
payload?.task_status ||
|
||
payload?.response?.status ||
|
||
payload?.response?.task_status ||
|
||
""
|
||
)
|
||
.trim()
|
||
.toLowerCase();
|
||
if (status) {
|
||
lastMessage = status;
|
||
}
|
||
|
||
if (status === "ready" || status === "success" || status === "succeeded" || status === "completed") {
|
||
return {
|
||
imageUrl: "",
|
||
errorMessage: "BFL 返回成功状态但未携带图像结果",
|
||
status: response.status,
|
||
};
|
||
}
|
||
|
||
if (status === "error" || status === "failed" || status === "cancelled") {
|
||
return {
|
||
imageUrl: "",
|
||
errorMessage: extractBflErrorMessage(payload, "BFL 任务执行失败"),
|
||
status: response.status,
|
||
};
|
||
}
|
||
|
||
if (!response.ok) {
|
||
return {
|
||
imageUrl: "",
|
||
errorMessage: extractBflErrorMessage(payload, `BFL 轮询失败（${response.status}）`),
|
||
status: response.status,
|
||
};
|
||
}
|
||
|
||
await delay(1_200);
|
||
}
|
||
|
||
return {
|
||
imageUrl: "",
|
||
errorMessage: `BFL 轮询超时${lastMessage ? `（${lastMessage}）` : ""}`,
|
||
status: 504,
|
||
};
|
||
}
|
||
|
||
async function generateWithProvider(params: {
|
||
provider: RealtimeProviderConfig;
|
||
imagePrompt: string;
|
||
prompt: string;
|
||
size: number;
|
||
seed?: number;
|
||
body: GeneratePayload;
|
||
config: RealtimeCanvasConfig;
|
||
}): Promise<ProviderAttemptResult> {
|
||
const isReplicate = params.provider.type === "replicate";
|
||
const imageFieldCandidates = isReplicate
|
||
? getReplicateImageFieldCandidates(params.imagePrompt)
|
||
: getBflImageFieldCandidates();
|
||
|
||
let selectedImageField: "input_image" | "image_prompt" = "input_image";
|
||
let submitResult: SubmitTaskResult | null = null;
|
||
let fallbackWarning = "";
|
||
|
||
for (let index = 0; index < imageFieldCandidates.length; index += 1) {
|
||
if (isReplicate) {
|
||
const candidate = getReplicateImageFieldCandidates(params.imagePrompt)[index];
|
||
const requestBody: Record<string, unknown> = {
|
||
prompt: params.prompt,
|
||
...(typeof params.seed === "number" ? { seed: params.seed } : {}),
|
||
...candidate,
|
||
};
|
||
|
||
submitResult = await submitReplicatePrediction({
|
||
apiKey: params.provider.apiKey,
|
||
model: params.provider.model || DEFAULT_REPLICATE_MODEL,
|
||
input: requestBody,
|
||
});
|
||
} else {
|
||
selectedImageField = imageFieldCandidates[index] as "input_image" | "image_prompt";
|
||
const requestBody: Record<string, unknown> = {
|
||
prompt: params.prompt,
|
||
width: params.size,
|
||
height: params.size,
|
||
output_format: "jpeg",
|
||
safety_tolerance: 2,
|
||
[selectedImageField]: params.imagePrompt,
|
||
...(typeof params.seed === "number" ? { seed: params.seed } : {}),
|
||
};
|
||
|
||
if (isSelfHostedRealtimeProvider(params.provider)) {
|
||
requestBody.steps = clamp(Number(params.body.steps ?? params.config.defaults?.steps ?? 1), 1, 6);
|
||
requestBody.cfg_scale = clamp(
|
||
Number(params.body.cfgScale ?? params.config.defaults?.cfgScale ?? 1),
|
||
1,
|
||
14
|
||
);
|
||
requestBody.strength = clamp(
|
||
Number(params.body.strength ?? params.config.defaults?.strength ?? 0.32),
|
||
0.05,
|
||
1
|
||
);
|
||
requestBody.preview_megapixels = clamp(Number(params.config.previewMegapixels ?? 0.4), 0.2, 0.8);
|
||
requestBody.detail_megapixels = clamp(Number(params.config.detailMegapixels ?? 1.0), 0.6, 1.2);
|
||
requestBody.output_jpeg_quality = clamp(
|
||
Number(params.config.outputJpegQuality ?? 62),
|
||
35,
|
||
90
|
||
);
|
||
requestBody.quality_profile = params.body.qualityProfile || "refine";
|
||
}
|
||
|
||
submitResult = await submitBflTask({
|
||
apiKey: params.provider.apiKey,
|
||
baseUrl: params.provider.baseUrl,
|
||
model: params.provider.model,
|
||
body: requestBody,
|
||
});
|
||
}
|
||
|
||
if (!submitResult?.errorMessage) {
|
||
break;
|
||
}
|
||
|
||
if (
|
||
index < imageFieldCandidates.length - 1 &&
|
||
shouldRetryWithAlternateImageField(submitResult.errorMessage)
|
||
) {
|
||
fallbackWarning = "模型参数兼容性已自动切换，继续生成。";
|
||
continue;
|
||
}
|
||
|
||
return {
|
||
ok: false,
|
||
message: submitResult?.errorMessage || "实时生成提交失败",
|
||
status: submitResult?.status || 502,
|
||
provider: params.provider,
|
||
};
|
||
}
|
||
|
||
if (!submitResult) {
|
||
return {
|
||
ok: false,
|
||
message: "实时生成提交失败",
|
||
status: 502,
|
||
provider: params.provider,
|
||
};
|
||
}
|
||
|
||
let finalImageUrl = submitResult.imageUrl;
|
||
if (!finalImageUrl) {
|
||
const pollResult =
|
||
params.provider.type === "replicate"
|
||
? await pollReplicateResult({
|
||
apiKey: params.provider.apiKey,
|
||
pollingUrl: submitResult.pollingUrl,
|
||
taskId: submitResult.taskId,
|
||
timeoutMs: 60_000,
|
||
})
|
||
: await pollBflResult({
|
||
apiKey: params.provider.apiKey,
|
||
baseUrl: params.provider.baseUrl,
|
||
pollingUrl: submitResult.pollingUrl,
|
||
taskId: submitResult.taskId,
|
||
timeoutMs: 110_000,
|
||
});
|
||
if (!pollResult.imageUrl) {
|
||
return {
|
||
ok: false,
|
||
message: pollResult.errorMessage || "实时生成未返回图像",
|
||
status: pollResult.status || 502,
|
||
provider: params.provider,
|
||
};
|
||
}
|
||
finalImageUrl = pollResult.imageUrl;
|
||
}
|
||
|
||
return {
|
||
ok: true,
|
||
imageUrl: finalImageUrl,
|
||
taskId: submitResult.taskId,
|
||
imageField: selectedImageField,
|
||
fallbackWarning,
|
||
provider: params.provider,
|
||
};
|
||
}
|
||
|
||
export async function POST(request: Request) {
|
||
const session = await auth();
|
||
if (!session?.user?.id) {
|
||
return Response.json({ code: "UNAUTHORIZED", message: "请先登录" }, { status: 401 });
|
||
}
|
||
|
||
let body: GeneratePayload;
|
||
try {
|
||
body = (await request.json()) as GeneratePayload;
|
||
} catch {
|
||
return Response.json({ code: "BAD_REQUEST", message: "无效 JSON" }, { status: 400 });
|
||
}
|
||
|
||
const imageUrl = String(body.imageUrl || "").trim();
|
||
if (!imageUrl) {
|
||
return Response.json({ code: "BAD_REQUEST", message: "缺少 imageUrl" }, { status: 400 });
|
||
}
|
||
|
||
const setting = await getSystemSetting({ key: "realtime_canvas_config" }).catch(() => null);
|
||
const config = (setting?.value || {}) as RealtimeCanvasConfig;
|
||
|
||
if (config.enabled === false) {
|
||
return Response.json(
|
||
{ code: "FEATURE_DISABLED", message: "实时画布功能未开启" },
|
||
{ status: 403 }
|
||
);
|
||
}
|
||
|
||
const providers = resolveRealtimeProviders(config);
|
||
if (providers.length === 0) {
|
||
return Response.json(
|
||
{
|
||
code: "BFL_KEY_MISSING",
|
||
message: "未配置可用的实时画布服务",
|
||
},
|
||
{ status: 500 }
|
||
);
|
||
}
|
||
|
||
const maxInputResolution = clamp(Number(config.maxInputResolution || 1024), 512, 1536);
|
||
const size = resolveSquareSize(body.imageSize, maxInputResolution);
|
||
const seed = resolveSeed(body.seed);
|
||
|
||
const rawPrompt = sanitizeText(String(body.prompt || "").trim()) || FALLBACK_REALTIME_PROMPT;
|
||
const negativePrompt =
|
||
sanitizeText(String(config.negativePrompt || "").trim()) ||
|
||
"改变构图, 改变主体位置, 多余人物, 重复物体, 镜像翻转, 错误透视, 模糊轮廓, 文字水印, 线稿, 草图";
|
||
const positivePrompt = sanitizeText(
|
||
[
|
||
rawPrompt,
|
||
"Keep exact object silhouette, placement and count from the input sketch.",
|
||
"Photorealistic material and lighting only, keep composition unchanged.",
|
||
`Negative constraints: ${negativePrompt}`,
|
||
].join(" ")
|
||
);
|
||
|
||
const imagePrompt = toImagePromptValue(imageUrl);
|
||
if (!imagePrompt) {
|
||
return Response.json(
|
||
{
|
||
code: "BAD_REQUEST",
|
||
message: "输入图像格式无效",
|
||
},
|
||
{ status: 400 }
|
||
);
|
||
}
|
||
|
||
const providerErrors: string[] = [];
|
||
|
||
for (const provider of providers) {
|
||
const result = await generateWithProvider({
|
||
provider,
|
||
imagePrompt,
|
||
prompt: positivePrompt,
|
||
size,
|
||
seed,
|
||
body,
|
||
config,
|
||
});
|
||
|
||
if (!result.ok) {
|
||
providerErrors.push(`${provider.label}（${provider.baseUrl}）: ${result.message}`);
|
||
continue;
|
||
}
|
||
|
||
const warningParts = [result.fallbackWarning];
|
||
if (result.provider.source === "fallback") {
|
||
warningParts.push("主实时服务异常，已自动切换到备用服务。");
|
||
}
|
||
const warning = warningParts.filter(Boolean).join(" ");
|
||
|
||
console.log("[RealtimeBFL] frame success", {
|
||
userId: session.user.id,
|
||
requestId: body.requestId || null,
|
||
model: result.provider.model || DEFAULT_BFL_MODEL,
|
||
providerSource: result.provider.source,
|
||
providerBaseUrl: result.provider.baseUrl,
|
||
taskId: result.taskId || null,
|
||
hasPrompt: Boolean(rawPrompt && rawPrompt !== FALLBACK_REALTIME_PROMPT),
|
||
imageField: result.imageField,
|
||
qualityProfile: body.qualityProfile || "refine",
|
||
size,
|
||
roi: body.roi || null,
|
||
hasMask: Boolean(body.maskImageUrl),
|
||
warning: warning || null,
|
||
});
|
||
|
||
return Response.json({
|
||
ok: true,
|
||
provider: "bfl",
|
||
providerSource: result.provider.source,
|
||
model: result.provider.model,
|
||
transport: "http-poll",
|
||
taskUUID: result.taskId || undefined,
|
||
imageDataURI: result.imageUrl.startsWith("data:")
|
||
? result.imageUrl
|
||
: !/^https?:\/\//i.test(result.imageUrl)
|
||
? `data:image/jpeg;base64,${result.imageUrl}`
|
||
: undefined,
|
||
imageUrl: /^https?:\/\//i.test(result.imageUrl) ? result.imageUrl : undefined,
|
||
warning: warning || undefined,
|
||
});
|
||
}
|
||
|
||
return Response.json(
|
||
{
|
||
code: "BFL_REQUEST_FAILED",
|
||
message:
|
||
providerErrors.length > 0
|
||
? `主备用实时服务均不可用：${providerErrors.join("；")}`
|
||
: "实时生成失败",
|
||
},
|
||
{ status: 502 }
|
||
);
|
||
}
|