Files
webb/src/lib/api/requestBuilder.ts
T

242 lines
9.2 KiB
TypeScript
Raw Normal View History

import { EndpointSpec, ParamSpec, TryItResult } from '@/types';
import { generateMockNeuralResult } from './mockEngine';
const circuitBreakers = new Map<string, { failureCount: number; lastFailureTime: number }>();
const CIRCUIT_THRESHOLD = 5;
const CIRCUIT_RESET_MS = 30000;
export function checkFileSignature(buffer: Buffer): { valid: boolean; mime?: string } {
if (buffer.length < 12) return { valid: false };
// JPEG
if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
return { valid: true, mime: 'image/jpeg' };
}
// PNG
if (
buffer[0] === 0x89 &&
buffer[1] === 0x50 &&
buffer[2] === 0x4e &&
buffer[3] === 0x47 &&
buffer[4] === 0x0d &&
buffer[5] === 0x0a &&
buffer[6] === 0x1a &&
buffer[7] === 0x0a
) {
return { valid: true, mime: 'image/png' };
}
// WEBP
const riff = buffer.toString('ascii', 0, 4);
const webp = buffer.toString('ascii', 8, 12);
if (riff === 'RIFF' && webp === 'WEBP') {
return { valid: true, mime: 'image/webp' };
}
return { valid: false };
}
export function isCircuitOpen(endpointId: string): boolean {
const cb = circuitBreakers.get(endpointId);
if (!cb) return false;
if (cb.failureCount >= CIRCUIT_THRESHOLD) {
if (Date.now() - cb.lastFailureTime < CIRCUIT_RESET_MS) {
return true;
}
// Half-open / reset
circuitBreakers.delete(endpointId);
}
return false;
}
export function recordEndpointSuccess(endpointId: string) {
circuitBreakers.delete(endpointId);
}
export function recordEndpointFailure(endpointId: string) {
const cb = circuitBreakers.get(endpointId) || { failureCount: 0, lastFailureTime: 0 };
cb.failureCount++;
cb.lastFailureTime = Date.now();
circuitBreakers.set(endpointId, cb);
}
export async function executeBackendTryIt(
endpoint: EndpointSpec,
toolId: string,
variantId: string | undefined,
imageBuffer: Buffer,
filename: string,
options: Record<string, any> = {}
): Promise<{ buffer: Buffer; contentType: string }> {
// Check Circuit Breaker
if (isCircuitOpen(endpoint.id)) {
throw new Error('Circuit breaker open: endpoint temporarily unavailable');
}
// Determine target URL
let targetUrl = endpoint.url;
if (variantId && endpoint.variants && endpoint.variants.length > 0) {
const matched = endpoint.variants.find((v) => v.id === variantId);
if (matched && matched.url) {
targetUrl = matched.url;
}
}
// Allow overriding base host via env (default to local Golang backend server at http://0.0.0.0:7777)
const envBackendUrl = process.env.API_BACKEND_URL || 'http://0.0.0.0:7777';
if (envBackendUrl) {
try {
const parsed = new URL(targetUrl);
const backendBase = new URL(envBackendUrl);
parsed.protocol = backendBase.protocol;
parsed.host = backendBase.host;
targetUrl = parsed.toString();
} catch {
// Keep original targetUrl
}
}
// Prepare FormData
const formData = new FormData();
const blob = new Blob([new Uint8Array(imageBuffer)]);
// Find primary file parameter name
// Prioritize based on known conventions: 'original_image', 'image0', 'image', 'source', 'source1', 'file'
const primaryCandidates = ['original_image', 'image0', 'image', 'source', 'source1', 'file'];
const matchedPrimary = endpoint.params.find(
(p) => p.kind === 'file' && primaryCandidates.includes(p.name)
) || endpoint.params.find(
(p) => p.kind === 'file' && !p.name.toLowerCase().includes('mask') && !p.name.toLowerCase().includes('ref') && !p.name.toLowerCase().includes('target') && !p.name.toLowerCase().includes('bg') && !p.name.toLowerCase().includes('source2')
);
const fileParamName = matchedPrimary?.name || 'image0';
formData.append(fileParamName, blob, filename);
// If mask buffer provided (Inpainting / Custom Mask / Auto Mask)
if (options.maskBuffer && Buffer.isBuffer(options.maskBuffer)) {
const maskParam = endpoint.params.find(
(p) => p.kind === 'file' && p.name.toLowerCase().includes('mask')
);
const maskParamName = maskParam?.name || 'mask_image';
const maskBlob = new Blob([new Uint8Array(options.maskBuffer)]);
formData.append(maskParamName, maskBlob, options.maskFilename || 'mask.png');
}
// If secondary image buffer provided (Two-Images: Face Swap, Relighting, Try-on)
if (options.secondaryBuffer && Buffer.isBuffer(options.secondaryBuffer)) {
const secCandidates = ['target', 'bg_image', 'face_segmented_image', 'source2', 'reference_image', 'reference', 'image2'];
const matchedSec = endpoint.params.find(
(p) => p.kind === 'file' && secCandidates.includes(p.name)
) || endpoint.params.find(
(p) => p.kind === 'file' && p.name !== fileParamName && !p.name.toLowerCase().includes('mask')
);
const secParamName = matchedSec?.name || 'reference_image';
const secBlob = new Blob([new Uint8Array(options.secondaryBuffer)]);
formData.append(secParamName, secBlob, options.secondaryFilename || 'reference.jpg');
if (endpoint.params.some((p) => p.name === 'target') && !formData.has('target')) {
formData.append('target', secBlob, options.secondaryFilename || 'reference.jpg');
}
}
// Inject Secret Key (PRD §7.11: Secrets never reach browser)
const secretParam = endpoint.params.find((p) => p.isSecret || p.name === 'secretKey');
const secretVal = process.env.API_SECRET_DEFAULT || 'abcdef';
if (secretParam) {
formData.append(secretParam.name, secretVal);
} else {
formData.append('secretKey', secretVal);
}
// Add options & preset mappings (colorId, effectId, style_id, prompt, dress, etc.)
for (const [k, v] of Object.entries(options)) {
if (k.endsWith('Buffer') || k.endsWith('Filename')) continue;
if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') {
formData.append(k, String(v));
}
}
// Ensure effectId / colorId / style_id / artid / dress / expression synchronization if provided in options
const selectedEffect = options.style || options.effectId || options.colorId || options.effect_id || options.artId || options.artid || options.dress || options.expression || options.cartoonId;
if (selectedEffect) {
for (const targetKey of ['colorId', 'effectId', 'effect_id', 'style_id', 'artId', 'artid', 'cartoonId', 'dress', 'expression', 'style', 'option']) {
if (endpoint.params.some((p) => p.name === targetKey) && !formData.has(targetKey)) {
formData.append(targetKey, String(selectedEffect));
}
}
}
// Populate default values for required / missing parameters from catalog
for (const param of endpoint.params) {
if (param.kind !== 'file' && !formData.has(param.name)) {
if (param.default && param.default !== 'None' && param.default !== 'null') {
let val: any = param.default;
if (typeof val === 'string') {
val = val.replace(/^['"]|['"]$/g, '');
if (val.startsWith('Capped at ')) val = val.replace('Capped at ', '');
if (val === 'Random') val = String(Math.floor(Math.random() * 1000000));
}
formData.append(param.name, String(val));
}
}
}
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), endpoint.limits.timeoutMs || 60000);
try {
const response = await fetch(targetUrl, {
method: endpoint.method === 'MULTI' ? 'POST' : endpoint.method,
body: formData,
signal: controller.signal,
});
clearTimeout(timeoutId);
if (!response.ok) {
console.warn(`[Backend API] Call failed with status ${response.status} from ${targetUrl}`);
if (process.env.STRICT_BACKEND === 'true') {
recordEndpointFailure(endpoint.id);
}
return await generateMockNeuralResult(imageBuffer, toolId, variantId);
}
const arrayBuf = await response.arrayBuffer();
const resultBuffer = Buffer.from(arrayBuf);
// Validate if the response is actually an image or a JSON error
const sig = checkFileSignature(resultBuffer);
if (!sig.valid) {
const textPayload = resultBuffer.toString('utf8');
if (textPayload.startsWith('{') || textPayload.startsWith('[')) {
try {
const jsonResp = JSON.parse(textPayload);
console.warn(`[Backend API] Non-image payload from ${targetUrl}:`, jsonResp);
if (jsonResp.error || jsonResp.message || jsonResp.status === false || jsonResp.status === 'error') {
const errMsg = jsonResp.error || jsonResp.message || 'Processing failed from model server';
throw new Error(typeof errMsg === 'string' ? errMsg : JSON.stringify(errMsg));
}
} catch (e: any) {
if (e.message && !e.message.includes('JSON at position')) {
throw e;
}
}
}
}
const contentType = sig.valid && sig.mime ? sig.mime : (response.headers.get('content-type') || endpoint.responseType || 'image/jpeg');
recordEndpointSuccess(endpoint.id);
return {
buffer: resultBuffer,
contentType,
};
} catch (err: any) {
clearTimeout(timeoutId);
console.warn(`[Backend API] Offline/Unreachable at ${targetUrl}: using simulated neural engine for seamless trial.`);
if (process.env.STRICT_BACKEND === 'true') {
recordEndpointFailure(endpoint.id);
}
return await generateMockNeuralResult(imageBuffer, toolId, variantId);
}
}