1005 lines
52 KiB
TypeScript
1005 lines
52 KiB
TypeScript
/**
|
||
* 统一生成任务服务 — 图片/视频生成共用 sys_task 表与同一条生命周期:
|
||
* 创建(processing) → 适配器构建请求 → 同步完成或异步轮询 → 下载落盘 → 回写业务表
|
||
*/
|
||
import { db, getInsertId, schema } from '../db/index.js'
|
||
import { and, desc, eq, gt, ne, or, isNull } from 'drizzle-orm'
|
||
import fs from 'node:fs'
|
||
import { getAbsolutePath } from '../utils/storage.js'
|
||
import { downloadVideo, safeTaskError } from './video-download.js'
|
||
import { prepareReferenceAudio, resolveReferenceAudioUrls } from './reference-audio.js'
|
||
import { getActiveConfig, getConfigById } from './ai.js'
|
||
import { parseWorkerRouting, type WorkerRouting } from './worker-routing.js'
|
||
import { isLocalQueuedTask, taskPollingProfile } from './local-task-tracking.js'
|
||
import { joinProviderUrl } from './adapters/url'
|
||
import { now } from '../utils/response.js'
|
||
import { downloadFile, fetchImageAsCompressedDataUrl, generateImageThumb, readImageAsCompressedDataUrl, readImageAsDataUrl, saveBase64Image } from '../utils/storage.js'
|
||
import { extractVideoPoster } from '../utils/video-poster.js'
|
||
import { ffmpeg } from '../utils/ffmpeg.js'
|
||
import { getImageAdapter, getVideoAdapter } from './adapters/registry'
|
||
import type { AIConfig } from './adapters/types'
|
||
import { logTaskError, logTaskPayload, logTaskProgress, logTaskStart, logTaskSuccess, logTaskWarn, redactUrl } from '../utils/task-logger.js'
|
||
|
||
import { continuityPrompt, extractContinuityFrame, resolveContinuity, sourceReadiness, validateContinuityModel, type ContinuityPlan } from './continuity.js'
|
||
import { englishSubmissionPrompt, usesEnglishVideoPrompt } from './english-video-prompt.js'
|
||
|
||
type TaskType = 'image' | 'video'
|
||
|
||
const activeTasks = new Set<number>()
|
||
const videoSubmissions = new Set<number>()
|
||
const cancellingTasks = new Set<number>()
|
||
function runBackground(id: number, job: () => Promise<void>) {
|
||
if (activeTasks.has(id)) return
|
||
activeTasks.add(id)
|
||
void job().catch(error => failTask(id, safeTaskError(error))).finally(() => activeTasks.delete(id))
|
||
}
|
||
|
||
const taskLabel = (type: TaskType) => (type === 'image' ? 'ImageTask' : 'VideoTask')
|
||
|
||
interface GenerateImageParams {
|
||
storyboardId?: number
|
||
dramaId?: number
|
||
sceneId?: number
|
||
characterId?: number
|
||
propId?: number
|
||
prompt: string
|
||
model?: string
|
||
size?: string
|
||
referenceImages?: string[]
|
||
frameType?: string
|
||
configId?: number
|
||
}
|
||
|
||
interface GenerateVideoParams {
|
||
gpu?: AIConfig['gpu']
|
||
replaceTaskId?: number
|
||
variant?: 'hd'
|
||
originalVideoUrl?: string
|
||
storyboardId?: number
|
||
dramaId?: number
|
||
prompt: string
|
||
model?: string
|
||
referenceMode?: string
|
||
imageUrl?: string
|
||
firstFrameUrl?: string
|
||
lastFrameUrl?: string
|
||
referenceImageUrls?: string[]
|
||
referenceVideoUrls?: string[]
|
||
referenceAudioUrls?: string[]
|
||
referenceFileUrl?: string
|
||
referenceLinkUrl?: string
|
||
generateAudio?: boolean
|
||
duration?: number
|
||
aspectRatio?: string
|
||
resolution?: string
|
||
seed?: number
|
||
promptExtend?: boolean
|
||
watermark?: boolean
|
||
configId?: number
|
||
forceNew?: boolean
|
||
}
|
||
|
||
export async function generateImage(params: GenerateImageParams): Promise<number> {
|
||
// 指定配置(集锁定)可能已停用/删除/厂商收敛,失效时回退到当前启用配置,避免生成被旧引用卡死
|
||
const config = params.configId
|
||
? (await getConfigById(params.configId)) ?? await getActiveConfig('image')
|
||
: await getActiveConfig('image')
|
||
if (!config) throw new Error('未配置图片模型,请先到「设置」页添加并启用 AI 服务')
|
||
|
||
const id = await createTask('image', config, {
|
||
storyboardId: params.storyboardId,
|
||
dramaId: params.dramaId,
|
||
sceneId: params.sceneId,
|
||
characterId: params.characterId,
|
||
propId: params.propId,
|
||
prompt: params.prompt,
|
||
model: params.model || config.model,
|
||
}, {
|
||
size: params.size || '1920x1080',
|
||
frameType: params.frameType,
|
||
referenceImages: params.referenceImages,
|
||
})
|
||
|
||
logTaskStart('ImageTask', 'enqueue', {
|
||
id,
|
||
provider: config.provider,
|
||
storyboardId: params.storyboardId,
|
||
sceneId: params.sceneId,
|
||
characterId: params.characterId,
|
||
frameType: params.frameType,
|
||
model: params.model || config.model,
|
||
})
|
||
logTaskPayload('ImageTask', 'enqueue params', {
|
||
id,
|
||
config: { provider: config.provider, model: config.model, baseUrl: config.baseUrl },
|
||
params,
|
||
})
|
||
return id
|
||
}
|
||
|
||
export async function generateVideo(params: GenerateVideoParams): Promise<number> {
|
||
const storyboardId = params.storyboardId
|
||
if (storyboardId && videoSubmissions.has(storyboardId)) throw new Error('该分镜正在提交任务,请勿重复点击')
|
||
if (storyboardId) videoSubmissions.add(storyboardId)
|
||
try {
|
||
if (params.gpu !== undefined && !['auto', 'gpu1', 'gpu2', 'gpu3'].includes(params.gpu)) throw new Error('请选择自动分配、GPU1、GPU2 或 GPU3')
|
||
if (params.replaceTaskId !== undefined && (!storyboardId || !Number.isSafeInteger(params.replaceTaskId) || params.replaceTaskId <= 0)) throw new Error('被替换的任务 ID 无效')
|
||
// 指定配置(集锁定)可能已停用/删除/厂商收敛,失效时回退到当前启用配置
|
||
const selectedConfig = params.configId
|
||
? await getConfigById(params.configId)
|
||
: await getActiveConfig('video')
|
||
const config = selectedConfig ? { ...selectedConfig, gpu: params.gpu ?? selectedConfig.gpu } : null
|
||
if (!config) throw new Error('未配置视频模型,请先到「设置」页添加并启用 AI 服务')
|
||
if (params.gpu !== undefined && !['localvideo', 'minimax'].includes(config.provider)) throw new Error('所选模型不支持指定本地显卡')
|
||
if (params.variant === 'hd' && (config.id !== params.configId || config.provider !== 'localvideo')) throw new Error('高清服务配置已停用或变更,请恢复 VDN-H3 配置')
|
||
|
||
params.referenceAudioUrls = await prepareReferenceAudio(params.referenceAudioUrls, config.provider)
|
||
|
||
const continuity = storyboardId && params.variant !== 'hd' ? (await resolveContinuity(storyboardId)).plan : null
|
||
if (continuity) validateContinuityModel(continuity, config, params.model)
|
||
if (continuity?.mode === 'first_frame' && params.referenceAudioUrls?.length) throw new Error('当前尾帧接续工作流不支持音色参考,请改为状态承接')
|
||
const previewParams = { ...params, prompt: continuity ? continuityPrompt(params.prompt, continuity) : params.prompt }
|
||
const english = usesEnglishVideoPrompt(params.model || config.model)
|
||
// Translate and validate BEFORE cancelling an old job or admitting a new one.
|
||
if (english) previewParams.prompt = await englishSubmissionPrompt(previewParams.prompt, storyboardId, params.dramaId)
|
||
if (continuity?.mode === 'first_frame') {
|
||
// A validation-only placeholder; never submitted as a generation input.
|
||
previewParams.firstFrameUrl = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aN1kAAAAASUVORK5CYII='
|
||
previewParams.imageUrl = undefined; previewParams.lastFrameUrl = undefined
|
||
previewParams.referenceImageUrls = []; previewParams.referenceVideoUrls = []
|
||
previewParams.referenceFileUrl = undefined; previewParams.referenceLinkUrl = undefined
|
||
}
|
||
// Validate the new request before touching the previous job.
|
||
getVideoAdapter(config.provider).buildGenerateRequest(config, { ...previewParams, id: 0,
|
||
referenceImageUrls: JSON.stringify(previewParams.referenceImageUrls || []),
|
||
referenceVideoUrls: JSON.stringify(previewParams.referenceVideoUrls || []),
|
||
referenceAudioUrls: JSON.stringify(previewParams.referenceAudioUrls || []) })
|
||
if (params.replaceTaskId && ['minimax', 'localvideo'].includes(config.provider)) {
|
||
const target = new URL(config.baseUrl)
|
||
if (target.hostname === '192.168.110.111' && ['18792', '18794'].includes(target.port)) {
|
||
// Preflight must see the same inline images as submission. A static/
|
||
// path is local to this computer and cannot be read by the GPU server.
|
||
const references = await prepareVideoReferences(previewParams, config.provider)
|
||
const validatedRequest = getVideoAdapter(config.provider).buildGenerateRequest(config, {
|
||
...previewParams, id: 0, ...references,
|
||
})
|
||
const response = await fetch(`${config.baseUrl.replace(/\/$/, '')}/v2/video_generation/validate`, {
|
||
method: 'POST', headers: { Authorization: `Bearer ${config.apiKey}`, 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(validatedRequest.body), signal: AbortSignal.timeout(35_000) })
|
||
if (!response.ok) throw new Error(`新显卡未就绪,原任务保持运行:${safeTaskError(await response.text())}`)
|
||
}
|
||
}
|
||
if (storyboardId) {
|
||
const tasks = await db.select().from(schema.sysTask).where(and(eq(schema.sysTask.type, 'video'), eq(schema.sysTask.storyboardId, storyboardId)))
|
||
.orderBy(desc(schema.sysTask.id))
|
||
const latest = tasks[0]
|
||
if (params.replaceTaskId !== undefined && latest?.id !== params.replaceTaskId) throw new Error('任务已变化,请刷新后再操作;未取消任何其他任务')
|
||
if (tasks.some(t => t.status === 'processing' && t.id !== params.replaceTaskId)) throw new Error('该分镜已有运行中的任务,请等待结果')
|
||
if (latest?.status === 'processing') await cancelVideoForReplacement(latest)
|
||
if (latest?.status === 'failed' && params.forceNew !== true) throw new Error('请先恢复原任务;重新生成需确认可能再次计费')
|
||
}
|
||
|
||
const id = await createTask('video', config, {
|
||
storyboardId: params.storyboardId,
|
||
dramaId: params.dramaId,
|
||
prompt: english ? previewParams.prompt : params.prompt,
|
||
model: params.model || config.model,
|
||
}, {
|
||
continuity,
|
||
promptLanguage: english ? 'en' : 'original',
|
||
promptIncludesContinuity: english,
|
||
sourcePrompt: english ? params.prompt : undefined,
|
||
referenceMode: params.referenceMode || 'reference',
|
||
variant: params.variant,
|
||
originalVideoUrl: params.originalVideoUrl,
|
||
replacesTaskId: params.replaceTaskId,
|
||
imageUrl: params.imageUrl,
|
||
firstFrameUrl: params.firstFrameUrl,
|
||
lastFrameUrl: params.lastFrameUrl,
|
||
referenceImageUrls: params.referenceImageUrls,
|
||
referenceVideoUrls: params.referenceVideoUrls,
|
||
referenceAudioUrls: params.referenceAudioUrls,
|
||
referenceFileUrl: params.referenceFileUrl,
|
||
referenceLinkUrl: params.referenceLinkUrl,
|
||
generateAudio: params.generateAudio === false ? 0 : 1,
|
||
duration: params.duration,
|
||
aspectRatio: params.aspectRatio,
|
||
// 统一存为项目内部格式,各适配器再转换为官方大小写与枚举。
|
||
resolution: normalizeStoredVideoResolution(params.resolution),
|
||
seed: params.seed,
|
||
promptExtend: params.promptExtend,
|
||
watermark: params.watermark,
|
||
})
|
||
|
||
logTaskStart('VideoTask', 'enqueue', {
|
||
id,
|
||
provider: config.provider,
|
||
storyboardId: params.storyboardId,
|
||
dramaId: params.dramaId,
|
||
referenceMode: params.referenceMode || 'reference',
|
||
duration: params.duration || 5,
|
||
})
|
||
logTaskPayload('VideoTask', 'enqueue params', {
|
||
id,
|
||
config: { provider: config.provider, model: config.model, baseUrl: config.baseUrl },
|
||
params,
|
||
})
|
||
return id
|
||
} finally {
|
||
if (storyboardId) videoSubmissions.delete(storyboardId)
|
||
}
|
||
}
|
||
|
||
export async function cancelWaitingVideo(id: number) {
|
||
const result = await db.update(schema.sysTask).set({ status: 'failed', stage: 'cancelled', errorCode: 'user_cancelled',
|
||
errorMsg: '已取消等待前镜头的任务,未向显卡提交生成', updatedAt: now() })
|
||
.where(and(eq(schema.sysTask.id, id), eq(schema.sysTask.status, 'processing'), isNull(schema.sysTask.taskId),
|
||
or(eq(schema.sysTask.stage, 'waiting_predecessor'), eq(schema.sysTask.stage, 'blocked_predecessor')))).returning({ id: schema.sysTask.id })
|
||
if (!result.length) throw new Error('任务已经开始提交或结束,请刷新后再操作')
|
||
}
|
||
|
||
async function cancelVideoForReplacement(record: SysTaskRecord) {
|
||
const result = await cancelGenerationTask(record.id, 'replacement')
|
||
if (result.outcome === 'completed') throw new Error('原视频已经生成,正在保存;完成后可以重新生成')
|
||
if (result.outcome === 'pending') throw new Error('原任务仍在停止中,请稍后再点击;未提交新任务')
|
||
}
|
||
|
||
export function canCancelGenerationTask(record: SysTaskRecord): boolean {
|
||
if (record.status !== 'processing' || record.resultUrl || ['downloading', 'saving', 'transferring'].includes(record.stage || '')) return false
|
||
if (record.type === 'video' && !record.taskId && ['waiting_predecessor', 'blocked_predecessor'].includes(record.stage || '')) return true
|
||
return !!record.taskId && record.stage !== 'submitting'
|
||
&& (record.type === 'video' ? ['minimax', 'localvideo'].includes(record.provider || '') : record.type === 'image' && record.provider === 'openai')
|
||
&& isLocalQueuedTask({ baseUrl: record.configBaseUrl || '', provider: record.provider || '' }, record.taskId)
|
||
}
|
||
|
||
async function markTaskCancelled(id: number, reason = 'user') {
|
||
await db.update(schema.sysTask).set({ status: 'failed', stage: 'cancelled', errorCode: 'user_cancelled',
|
||
errorMsg: reason === 'replacement' ? '已取消原任务并请求重新生成,历史记录保留' : '任务已取消,历史记录和已有素材保留', updatedAt: now(), completedAt: now() })
|
||
.where(and(eq(schema.sysTask.id, id), eq(schema.sysTask.status, 'processing')))
|
||
}
|
||
|
||
export async function cancelGenerationTask(id: number, reason: 'user' | 'replacement' = 'user'): Promise<{ outcome: 'cancelled' | 'pending' | 'completed' | 'failed' }> {
|
||
if (!Number.isSafeInteger(id) || id <= 0) throw new Error('任务编号无效')
|
||
const record = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id)).get()
|
||
if (!record) throw new Error('任务不存在')
|
||
if (record.errorCode === 'user_cancelled') return { outcome: 'cancelled' }
|
||
if (record.status !== 'processing') throw new Error('任务已结束,请刷新列表')
|
||
if (cancellingTasks.has(id)) return { outcome: 'pending' }
|
||
if (!canCancelGenerationTask(record)) throw new Error('当前任务尚未返回编号、正在保存或不支持取消,请稍后刷新')
|
||
if (!record.taskId) { await cancelWaitingVideo(id); return { outcome: 'cancelled' } }
|
||
cancellingTasks.add(id)
|
||
try {
|
||
const config = await recoveryConfig(record)
|
||
const current = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id)).get()
|
||
if (!current || !canCancelGenerationTask(current)) throw new Error('任务状态已变化,请刷新后操作')
|
||
await db.update(schema.sysTask).set({ stage: 'cancelling', params: JSON.stringify({ ...parseTaskParams(current.params),
|
||
cancellation: { requestedAt: now(), reason } }), updatedAt: now() })
|
||
.where(and(eq(schema.sysTask.id, id), eq(schema.sysTask.status, 'processing')))
|
||
const headers = { Authorization: `Bearer ${config.apiKey}`, 'Content-Type': 'application/json' }
|
||
const request = async (cancel: boolean) => {
|
||
const job = encodeURIComponent(record.taskId!)
|
||
const path = record.type === 'image' ? `/images/task/${job}${cancel ? '/cancel' : ''}`
|
||
: cancel ? `/video_generation/${job}/cancel` : `/query/video_generation/${job}`
|
||
const response = await fetch(joinProviderUrl(config.baseUrl, record.type === 'image' ? '/v1' : '/v2', path), { method: cancel ? 'POST' : 'GET', headers,
|
||
...(cancel ? { body: '{}' } : {}), signal: AbortSignal.timeout(35_000) })
|
||
if (!response.ok) throw new Error('任务取消未确认,请稍后重试')
|
||
const result = await response.json() as any
|
||
const receipt = record.type === 'image' && !cancel ? { id: result.task_id,
|
||
status: result.cancelled ? 'cancelled' : result.status === 'completed' ? 'succeeded' : result.status } : result.task
|
||
if (receipt?.id !== record.taskId) throw new Error('取消回执任务编号不匹配')
|
||
return receipt.status as string
|
||
}
|
||
let status: string
|
||
const deadline = Date.now() + 45_000
|
||
try {
|
||
status = await request(true)
|
||
while (!['cancelled', 'failed', 'succeeded'].includes(status) && Date.now() < deadline) {
|
||
await new Promise(resolve => setTimeout(resolve, 1000))
|
||
status = await request(false)
|
||
}
|
||
} catch {
|
||
// The request may have reached the worker. Keep tracking the same ID;
|
||
// only an exact terminal receipt can declare it cancelled.
|
||
return { outcome: 'pending' }
|
||
}
|
||
if (status === 'cancelled') { await markTaskCancelled(id, reason); return { outcome: 'cancelled' } }
|
||
if (status === 'failed') { await failTask(id, '生成节点确认任务已失败', 'generation_failed'); return { outcome: 'failed' } }
|
||
if (status === 'succeeded') {
|
||
await db.update(schema.sysTask).set({ stage: 'polling', updatedAt: now() }).where(and(eq(schema.sysTask.id, id), eq(schema.sysTask.status, 'processing')))
|
||
return { outcome: 'completed' }
|
||
}
|
||
return { outcome: 'pending' }
|
||
} finally { cancellingTasks.delete(id) }
|
||
}
|
||
|
||
async function createTask(
|
||
type: TaskType,
|
||
config: AIConfig,
|
||
fields: {
|
||
storyboardId?: number
|
||
dramaId?: number
|
||
sceneId?: number
|
||
characterId?: number
|
||
propId?: number
|
||
prompt: string
|
||
model?: string | null
|
||
},
|
||
params: Record<string, unknown>,
|
||
): Promise<number> {
|
||
const ts = now()
|
||
const res = await db.insert(schema.sysTask).values({
|
||
type,
|
||
...fields,
|
||
provider: config.provider,
|
||
configId: config.id,
|
||
configBaseUrl: config.baseUrl,
|
||
stage: (params.continuity as ContinuityPlan | undefined)?.mode === 'first_frame' ? 'waiting_predecessor' : 'submitting',
|
||
params: JSON.stringify({ ...params, gpu: config.gpu || 'auto' }),
|
||
status: 'processing',
|
||
createdAt: ts,
|
||
updatedAt: ts,
|
||
})
|
||
|
||
const id = getInsertId(res)
|
||
runBackground(id, () => processTask(id, config))
|
||
return id
|
||
}
|
||
|
||
function parseTaskParams(raw: string | null | undefined): Record<string, any> {
|
||
if (!raw) return {}
|
||
try {
|
||
return JSON.parse(raw) || {}
|
||
} catch {
|
||
return {}
|
||
}
|
||
}
|
||
|
||
async function prepareContinuityTask(record: SysTaskRecord): Promise<boolean> {
|
||
const params = parseTaskParams(record.params)
|
||
const plan = params.continuity as ContinuityPlan | undefined
|
||
if (!plan || !record.storyboardId) return true
|
||
while (true) {
|
||
const current = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, record.id)).get()
|
||
if (!current || current.status !== 'processing') return false
|
||
const fresh = (await resolveContinuity(record.storyboardId)).plan
|
||
if (JSON.stringify(fresh) !== JSON.stringify(plan)) throw new Error('镜头衔接设置或前镜头结束状态已变化,请重新提交此镜头')
|
||
const source = plan.sourceId ? await sourceReadiness(plan.sourceId) : null
|
||
if (plan.mode === 'first_frame' && source?.state !== 'ready') {
|
||
await db.update(schema.sysTask).set({ stage: source?.state || 'waiting_predecessor', updatedAt: now() })
|
||
.where(and(eq(schema.sysTask.id, record.id), eq(schema.sysTask.status, 'processing')))
|
||
await new Promise(resolve => setTimeout(resolve, 2000))
|
||
continue
|
||
}
|
||
if (plan.mode === 'first_frame' && source) {
|
||
const frameUrl = await extractContinuityFrame(source.video, plan.offsetMs)
|
||
const after = await sourceReadiness(plan.sourceId!)
|
||
if (after.state !== 'ready' || after.video !== source.video || after.taskId !== source.taskId) continue
|
||
params.firstFrameUrl = frameUrl; params.imageUrl = undefined; params.lastFrameUrl = undefined
|
||
params.referenceImageUrls = []; params.referenceVideoUrls = []; params.referenceAudioUrls = []
|
||
params.referenceFileUrl = undefined; params.referenceLinkUrl = undefined
|
||
params.referenceMode = 'first_frame'
|
||
params.continuity = { ...plan, sourceVideo: source.video, sourceTaskId: source.taskId, frameUrl }
|
||
} else {
|
||
params.continuity = { ...plan, sourceVideo: source?.video || '', sourceTaskId: source?.taskId ?? null }
|
||
}
|
||
const prompt = params.promptIncludesContinuity ? record.prompt || '' : continuityPrompt(record.prompt || '', plan)
|
||
const claimed = await db.update(schema.sysTask).set({ params: JSON.stringify(params), prompt, stage: 'submitting', updatedAt: now() })
|
||
.where(and(eq(schema.sysTask.id, record.id), eq(schema.sysTask.status, 'processing'), isNull(schema.sysTask.taskId))).returning({ id: schema.sysTask.id })
|
||
return claimed.length > 0
|
||
}
|
||
}
|
||
|
||
async function processTask(id: number, config: AIConfig) {
|
||
try {
|
||
let [record] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
|
||
if (!record || record.status !== 'processing') return
|
||
if (record.type === 'video' && !await prepareContinuityTask(record)) return
|
||
;[record] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
|
||
const type = record.type as TaskType
|
||
const label = taskLabel(type)
|
||
const params = parseTaskParams(record.params)
|
||
logTaskProgress(label, 'build-request', {
|
||
id,
|
||
provider: config.provider,
|
||
storyboardId: record.storyboardId,
|
||
sceneId: record.sceneId,
|
||
characterId: record.characterId,
|
||
})
|
||
|
||
let url: string, method: string, headers: Record<string, string>, body: unknown
|
||
|
||
if (type === 'image') {
|
||
const adapter = getImageAdapter(config.provider)
|
||
const resolvedReferenceImages = await normalizeReferenceImages(params.referenceImages)
|
||
;({ url, method, headers, body } = adapter.buildGenerateRequest(config, {
|
||
id: record.id,
|
||
model: record.model,
|
||
prompt: record.prompt,
|
||
size: params.size,
|
||
frameType: params.frameType,
|
||
referenceImages: resolvedReferenceImages.length ? JSON.stringify(resolvedReferenceImages) : null,
|
||
}))
|
||
} else {
|
||
const adapter = getVideoAdapter(config.provider)
|
||
const references = await prepareVideoReferences(params, config.provider)
|
||
;({ url, method, headers, body } = adapter.buildGenerateRequest(config, {
|
||
id: record.id,
|
||
model: record.model,
|
||
prompt: record.prompt,
|
||
referenceMode: params.referenceMode,
|
||
...references,
|
||
referenceLinkUrl: params.referenceLinkUrl,
|
||
generateAudio: params.generateAudio,
|
||
duration: params.duration,
|
||
aspectRatio: params.aspectRatio,
|
||
resolution: params.resolution,
|
||
seed: params.seed,
|
||
promptExtend: params.promptExtend,
|
||
watermark: params.watermark,
|
||
}))
|
||
}
|
||
|
||
logTaskProgress(label, 'request', {
|
||
id,
|
||
provider: config.provider,
|
||
method,
|
||
url: redactUrl(url),
|
||
model: record.model,
|
||
})
|
||
|
||
const isMultipart = body instanceof FormData
|
||
logTaskPayload(label, 'request payload', {
|
||
id, method, url, headers,
|
||
// multipart 表单(如 OpenAI /v1/images/edits)无法 JSON 化,记录字段摘要
|
||
body: isMultipart ? `[multipart/form-data: ${[...(body as FormData).keys()].join(', ')}]` : body,
|
||
})
|
||
|
||
const beforeSend = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id)).get()
|
||
if (!beforeSend || beforeSend.status !== 'processing') return
|
||
if (params.continuity?.mode === 'first_frame') {
|
||
const source = await sourceReadiness(params.continuity.sourceId)
|
||
if (source.state !== 'ready' || source.video !== params.continuity.sourceVideo || source.taskId !== params.continuity.sourceTaskId) {
|
||
throw new Error('前镜头版本已变化,请重新提交此镜头;尚未发送到显卡')
|
||
}
|
||
}
|
||
const resp = await fetch(url, {
|
||
method,
|
||
headers,
|
||
body: isMultipart ? (body as FormData) : JSON.stringify(body),
|
||
signal: AbortSignal.timeout(600_000),
|
||
})
|
||
|
||
// Firemux 在响应头提供内部任务编号;即使 JSON 响应体中断也能查询原任务。
|
||
const gatewayTaskId = resp.headers.get('X-Firemux-Task-Id') || resp.headers.get('X-Huobao-Task-Id')
|
||
if (type === 'video' && gatewayTaskId) {
|
||
await markPolling(id, gatewayTaskId)
|
||
record.taskId = gatewayTaskId
|
||
}
|
||
|
||
if (!resp.ok) throw new Error(`API error ${resp.status}: ${await resp.text()}`)
|
||
const result = await resp.json() as any
|
||
logTaskPayload(label, 'response payload', { id, provider: config.provider, result })
|
||
|
||
if (type === 'image') {
|
||
const adapter = getImageAdapter(config.provider)
|
||
const { isAsync, taskId, imageUrl } = adapter.parseGenerateResponse(result)
|
||
|
||
if (!isAsync && imageUrl) {
|
||
logTaskProgress(label, 'sync-complete', { id, imageUrl })
|
||
await handleImageComplete(record, imageUrl)
|
||
return
|
||
}
|
||
|
||
if (!isAsync && !imageUrl) {
|
||
// 同步模式但无 URL(Gemini 等返回 base64)
|
||
const b64 = adapter.extractImageBase64(result)
|
||
if (b64) {
|
||
logTaskProgress(label, 'sync-base64-complete', { id, mimeType: b64.mimeType })
|
||
await handleImageCompleteBase64(record, b64.data, b64.mimeType)
|
||
return
|
||
}
|
||
throw new Error('No image URL or base64 data in response')
|
||
}
|
||
|
||
await markPolling(id, taskId)
|
||
await pollTask(record, config, taskId!)
|
||
return
|
||
}
|
||
|
||
const adapter = getVideoAdapter(config.provider)
|
||
const { isAsync, taskId, videoUrl, duration, routing } = adapter.parseGenerateResponse(result)
|
||
if (routing) await saveRouting(id, routing)
|
||
if (taskId) {
|
||
await markPolling(id, taskId)
|
||
record.taskId = taskId
|
||
}
|
||
|
||
if (!isAsync && videoUrl) {
|
||
logTaskProgress(label, 'sync-complete', { id, videoUrl })
|
||
await handleVideoComplete(record, videoUrl, duration ?? params.duration)
|
||
return
|
||
}
|
||
|
||
await markPolling(id, taskId)
|
||
await pollTask(record, config, taskId!)
|
||
} catch (err: any) {
|
||
const [current] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
|
||
const uncertain = current?.type === 'video' && !current.taskId && !current.resultUrl
|
||
&& (err instanceof TypeError || /timeout|abort|No task_id|API error 5/i.test(err.message))
|
||
await failTask(id, safeTaskError(err), uncertain ? 'submission_unknown' : undefined)
|
||
}
|
||
}
|
||
|
||
async function markPolling(id: number, taskId: string | undefined) {
|
||
await db.update(schema.sysTask)
|
||
.set({ taskId, stage: 'polling', status: 'processing', updatedAt: now() })
|
||
.where(eq(schema.sysTask.id, id))
|
||
logTaskProgress('SysTask', 'poll-start', { id, taskId })
|
||
}
|
||
|
||
async function saveRouting(id: number, routing: WorkerRouting) {
|
||
const checked = parseWorkerRouting(routing)
|
||
if (!checked) return
|
||
const [record] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
|
||
if (!record || record.status !== 'processing') return
|
||
await db.update(schema.sysTask).set({ params: JSON.stringify({ ...parseTaskParams(record.params), routing: checked }), updatedAt: now() })
|
||
.where(and(eq(schema.sysTask.id, id), eq(schema.sysTask.status, 'processing')))
|
||
}
|
||
|
||
async function failTask(id: number, message: string, code?: string) {
|
||
message = safeTaskError(message)
|
||
logTaskError('SysTask', 'failed', { id, error: message })
|
||
await db.update(schema.sysTask)
|
||
.set({ status: 'failed', errorMsg: safeTaskError(message), ...(code ? { errorCode: code } : {}), updatedAt: now() })
|
||
.where(and(eq(schema.sysTask.id, id), ne(schema.sysTask.status, 'completed'),
|
||
or(isNull(schema.sysTask.errorCode), ne(schema.sysTask.errorCode, 'user_cancelled'))))
|
||
}
|
||
|
||
type SysTaskRecord = typeof schema.sysTask.$inferSelect
|
||
|
||
async function pollTask(record: SysTaskRecord, config: AIConfig, taskId: string) {
|
||
const type = record.type as TaskType
|
||
const label = taskLabel(type)
|
||
const local = isLocalQueuedTask(config, taskId)
|
||
const profile = taskPollingProfile(type, local, parseTaskParams(record.params).variant === 'hd')
|
||
const adapter = type === 'image' ? getImageAdapter(config.provider) : getVideoAdapter(config.provider)
|
||
const startedAt = Date.now()
|
||
let delayMs = profile.intervalMs
|
||
let missingChecks = 0
|
||
|
||
for (let i = 0; i < profile.attempts; i++) {
|
||
if (profile.maxDurationMs && Date.now() - startedAt >= profile.maxDurationMs) {
|
||
await failTask(record.id, 'Timeout: Polling exceeded 10 minutes')
|
||
return
|
||
}
|
||
await new Promise(r => setTimeout(r, delayMs))
|
||
const [current] = await db.select({ status: schema.sysTask.status }).from(schema.sysTask).where(eq(schema.sysTask.id, record.id))
|
||
if (!current || current.status !== 'processing') return
|
||
try {
|
||
const { url, method, headers } = adapter.buildPollRequest(config, taskId)
|
||
logTaskProgress(label, 'poll-request', {
|
||
id: record.id,
|
||
taskId,
|
||
provider: config.provider,
|
||
method,
|
||
url: redactUrl(url),
|
||
attempt: i + 1,
|
||
})
|
||
const remainingMs = local ? 30_000 : profile.maxDurationMs
|
||
? Math.max(1_000, profile.maxDurationMs - (Date.now() - startedAt))
|
||
: 600_000
|
||
const resp = await fetch(url, {
|
||
method,
|
||
headers,
|
||
signal: AbortSignal.timeout(remainingMs),
|
||
})
|
||
if (!resp.ok) throw new Error(`Polling HTTP ${resp.status}`)
|
||
const result = await resp.json() as any
|
||
|
||
if (cancellingTasks.has(record.id)) continue
|
||
const [afterPoll] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, record.id))
|
||
if (!afterPoll || afterPoll.status !== 'processing') return
|
||
if (cancellingTasks.has(record.id)) continue
|
||
|
||
// 图片/视频 PollResponse 结构不同,这里统一按 any 取值后按 type 分支
|
||
const pollResp: any = adapter.parsePollResponse(result)
|
||
delayMs = profile.intervalMs
|
||
if (local && pollResp.status !== 'completed' && pollResp.status !== 'failed') {
|
||
missingChecks = pollResp.stage === 'missing' ? missingChecks + 1 : 0
|
||
if (missingChecks >= 3) {
|
||
await failTask(record.id, '显卡节点已找不到此任务,请核对节点重启记录后重新生成', 'upstream_missing')
|
||
return
|
||
}
|
||
const stage = parseTaskParams(afterPoll.params).cancellation ? 'cancelling' : pollResp.stage === 'missing' ? 'checking' : pollResp.stage || 'polling'
|
||
await db.update(schema.sysTask).set({ stage, updatedAt: now() })
|
||
.where(and(eq(schema.sysTask.id, record.id), eq(schema.sysTask.status, 'processing')))
|
||
}
|
||
if (type === 'video' && pollResp.routing) await saveRouting(record.id, pollResp.routing)
|
||
if (type === 'video' && local && pollResp.status === 'processing') {
|
||
const latest = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, record.id)).get()
|
||
if (latest?.status === 'processing') await db.update(schema.sysTask).set({
|
||
params: JSON.stringify({ ...parseTaskParams(latest.params), progress: pollResp.progress || null }),
|
||
}).where(and(eq(schema.sysTask.id, record.id), eq(schema.sysTask.status, 'processing')))
|
||
}
|
||
if (type === 'video' && pollResp.stage === 'transferring') {
|
||
await db.update(schema.sysTask).set({ stage: 'transferring', updatedAt: now() }).where(eq(schema.sysTask.id, record.id))
|
||
}
|
||
|
||
if (pollResp.status === 'completed') {
|
||
if (type === 'image') {
|
||
if (pollResp.imageUrl) {
|
||
logTaskSuccess(label, 'poll-complete', { id: record.id, taskId, imageUrl: pollResp.imageUrl })
|
||
if (await handleImageComplete(record, pollResp.imageUrl) === false) continue
|
||
return
|
||
}
|
||
if (adapter.provider === 'gemini') {
|
||
// Gemini 可能返回 base64
|
||
const b64 = (adapter as ReturnType<typeof getImageAdapter>).extractImageBase64(result)
|
||
if (b64) {
|
||
logTaskSuccess(label, 'poll-base64-complete', { id: record.id, taskId, mimeType: b64.mimeType })
|
||
await handleImageCompleteBase64(record, b64.data, b64.mimeType)
|
||
return
|
||
}
|
||
}
|
||
} else if (pollResp.videoUrl) {
|
||
logTaskSuccess(label, 'poll-complete', { id: record.id, taskId, videoUrl: pollResp.videoUrl })
|
||
if (await handleVideoComplete(record, pollResp.videoUrl, pollResp.duration) === false) continue
|
||
return
|
||
}
|
||
}
|
||
if (pollResp.status === 'failed') {
|
||
if (pollResp.cancelled) { await markTaskCancelled(record.id, parseTaskParams(afterPoll.params).cancellation?.reason); return }
|
||
// 上游明确失败(如内容审核拦截)属终态:立即落库,不重试不等待超时
|
||
const deliveryFailed = /video_transfer_failed/.test(pollResp.error || '')
|
||
if (deliveryFailed) await db.update(schema.sysTask).set({ stage: 'transferring' }).where(eq(schema.sysTask.id, record.id))
|
||
await failTask(record.id, pollResp.error || 'Generation failed', deliveryFailed ? 'delivery_failed' : 'generation_failed')
|
||
return
|
||
}
|
||
} catch (err: any) {
|
||
if (local) {
|
||
// A transient transport failure cannot cancel an accepted GPU job.
|
||
missingChecks = 0
|
||
delayMs = Math.min(60_000, Math.max(profile.intervalMs, delayMs * 2))
|
||
await db.update(schema.sysTask).set({ stage: 'reconnecting', updatedAt: now() })
|
||
.where(and(eq(schema.sysTask.id, record.id), eq(schema.sysTask.status, 'processing')))
|
||
logTaskWarn(label, 'poll-reconnect', { id: record.id, taskId, error: err.message })
|
||
continue
|
||
}
|
||
const exhausted = i === profile.attempts - 1
|
||
|| (profile.maxDurationMs != null && Date.now() - startedAt >= profile.maxDurationMs)
|
||
if (exhausted) {
|
||
await failTask(record.id, `Timeout: ${err.message}`)
|
||
return
|
||
}
|
||
logTaskWarn(label, 'poll-retry', { id: record.id, taskId, attempt: i + 1, error: err.message })
|
||
}
|
||
}
|
||
await failTask(record.id, 'Timeout: polling attempts exhausted')
|
||
}
|
||
|
||
async function handleImageComplete(record: SysTaskRecord, imageUrl: string) {
|
||
const current = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, record.id)).get()
|
||
if (!current || current.errorCode === 'user_cancelled') return
|
||
if (cancellingTasks.has(record.id)) return false
|
||
await db.update(schema.sysTask).set({ resultUrl: imageUrl, stage: 'downloading', updatedAt: now() })
|
||
.where(eq(schema.sysTask.id, record.id))
|
||
const localPath = await downloadFile(imageUrl, 'images')
|
||
// 列表页缩略图(前端按命名约定推导地址,失败不影响主流程)
|
||
await generateImageThumb(localPath)
|
||
|
||
await db.update(schema.sysTask)
|
||
.set({ resultUrl: imageUrl, localPath, status: 'completed', stage: 'completed', errorCode: null, errorMsg: null, completedAt: now(), updatedAt: now() })
|
||
.where(eq(schema.sysTask.id, record.id))
|
||
|
||
logTaskSuccess('ImageTask', 'downloaded', { id: record.id, provider: record.provider, localPath })
|
||
|
||
await writeBackImageAssets(record, localPath)
|
||
}
|
||
|
||
async function handleImageCompleteBase64(record: SysTaskRecord, base64Data: string, mimeType: string) {
|
||
const localPath = await saveBase64Image(base64Data, mimeType, 'images')
|
||
await generateImageThumb(localPath)
|
||
|
||
await db.update(schema.sysTask)
|
||
.set({ localPath, status: 'completed', stage: 'completed', errorCode: null, errorMsg: null, completedAt: now(), updatedAt: now() })
|
||
.where(eq(schema.sysTask.id, record.id))
|
||
|
||
logTaskSuccess('ImageTask', 'saved-base64', { id: record.id, provider: record.provider, mimeType, localPath })
|
||
|
||
await writeBackImageAssets(record, localPath)
|
||
}
|
||
|
||
// 图片完成后回写业务表:分镜(按 frameType)、角色、场景、道具
|
||
async function writeBackImageAssets(record: SysTaskRecord, localPath: string) {
|
||
const params = parseTaskParams(record.params)
|
||
// A late result is kept in task history, never substituted for a newer attempt.
|
||
const newer = await db.select().from(schema.sysTask).where(and(eq(schema.sysTask.type, 'image'), gt(schema.sysTask.id, record.id), or(
|
||
eq(schema.sysTask.characterId, record.characterId || -1), eq(schema.sysTask.sceneId, record.sceneId || -1),
|
||
eq(schema.sysTask.propId, record.propId || -1), eq(schema.sysTask.storyboardId, record.storyboardId || -1))))
|
||
if (newer.some(task => !record.storyboardId || parseTaskParams(task.params).frameType === params.frameType)) return
|
||
if (record.storyboardId) {
|
||
const sbUpdate: Record<string, any> = { updatedAt: now() }
|
||
if (params.frameType === 'first_frame') sbUpdate.firstFrameImage = localPath
|
||
else if (params.frameType === 'last_frame') sbUpdate.lastFrameImage = localPath
|
||
else sbUpdate.composedImage = localPath
|
||
await db.update(schema.storyboards).set(sbUpdate).where(eq(schema.storyboards.id, record.storyboardId))
|
||
}
|
||
if (record.characterId) {
|
||
await db.update(schema.characters).set({ imageUrl: localPath, updatedAt: now() }).where(eq(schema.characters.id, record.characterId))
|
||
}
|
||
if (record.sceneId) {
|
||
await db.update(schema.scenes).set({ imageUrl: localPath, status: 'completed', updatedAt: now() }).where(eq(schema.scenes.id, record.sceneId))
|
||
}
|
||
if (record.propId) {
|
||
await db.update(schema.props).set({ imageUrl: localPath, updatedAt: now() }).where(eq(schema.props.id, record.propId))
|
||
}
|
||
}
|
||
|
||
async function handleVideoComplete(record: SysTaskRecord, videoUrl: string, duration: number | null | undefined) {
|
||
const [current] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, record.id))
|
||
if (!current || current.errorCode === 'user_cancelled') return
|
||
if (cancellingTasks.has(record.id)) return false
|
||
// 先落库地址与实际时长;后续下载失败仍可恢复,且不重新提交生成。
|
||
const params: Record<string, unknown> = { ...parseTaskParams(current.params), resultDuration: duration }
|
||
await db.update(schema.sysTask).set({ resultUrl: videoUrl, params: JSON.stringify(params),
|
||
stage: 'downloading', status: 'processing', errorCode: null, errorMsg: null, updatedAt: now() })
|
||
.where(eq(schema.sysTask.id, record.id))
|
||
try {
|
||
const localPath = record.localPath && fs.existsSync(getAbsolutePath(record.localPath))
|
||
? record.localPath : await downloadVideo(videoUrl, record.id)
|
||
if (params.variant === 'hd') {
|
||
const readDimensions = () => new Promise<{ width?: number; height?: number }>((resolve, reject) => {
|
||
ffmpeg.ffprobe(getAbsolutePath(localPath), (error, meta) => {
|
||
if (error) return reject(error)
|
||
resolve(meta.streams.find(stream => stream.codec_type === 'video') || {})
|
||
})
|
||
})
|
||
let dimensions = await readDimensions()
|
||
const expected = params.resolution === '4K' ? [3840, 2160] : [2560, 1440]
|
||
if (params.aspectRatio === '9:16') expected.reverse()
|
||
// H3 aligns its latent dimensions to 32 pixels. Trim only that padding;
|
||
// never upscale a lower-resolution render and label it as native HD.
|
||
const aligned = expected.map(size => Math.ceil(size / 32) * 32)
|
||
if ((dimensions.width !== expected[0] || dimensions.height !== expected[1]) && dimensions.width === aligned[0] && dimensions.height === aligned[1]) {
|
||
const absolute = getAbsolutePath(localPath)
|
||
const cropped = `${absolute}.hd-crop.mp4`
|
||
try {
|
||
await new Promise<void>((resolve, reject) => ffmpeg(absolute)
|
||
.outputOptions(['-vf', `crop=${expected[0]}:${expected[1]}:0:0`, '-c:v', 'libx264', '-preset', 'fast', '-crf', '18', '-c:a', 'copy', '-movflags', '+faststart'])
|
||
.output(cropped).on('end', () => resolve()).on('error', reject).run())
|
||
await fs.promises.rename(cropped, absolute)
|
||
} finally { await fs.promises.rm(cropped, { force: true }) }
|
||
dimensions = await readDimensions()
|
||
}
|
||
if (dimensions.width !== expected[0] || dimensions.height !== expected[1]) throw new Error(`高清结果尺寸不匹配:需要 ${expected.join('×')},收到 ${dimensions.width}×${dimensions.height};原版保持不变`)
|
||
}
|
||
await db.update(schema.sysTask).set({ localPath, stage: 'saving', updatedAt: now() }).where(eq(schema.sysTask.id, record.id))
|
||
await extractVideoPoster(localPath)
|
||
// 完成状态与业务回写原子提交;恢复旧任务不能覆盖用户后来生成的视频。
|
||
db.transaction(tx => {
|
||
const newer = record.storyboardId ? tx.select({ id: schema.sysTask.id }).from(schema.sysTask)
|
||
.where(and(eq(schema.sysTask.storyboardId, record.storyboardId), eq(schema.sysTask.type, 'video'), gt(schema.sysTask.id, record.id))).get() : null
|
||
if (record.storyboardId && !newer && parseTaskParams(record.params).variant !== 'hd') tx.update(schema.storyboards)
|
||
.set({ videoUrl: localPath, duration: duration || undefined, updatedAt: now() })
|
||
.where(eq(schema.storyboards.id, record.storyboardId)).run()
|
||
tx.update(schema.sysTask).set({ localPath, status: 'completed', stage: 'completed', errorCode: null,
|
||
errorMsg: null, completedAt: now(), updatedAt: now() }).where(eq(schema.sysTask.id, record.id)).run()
|
||
})
|
||
} catch (error) {
|
||
await failTask(record.id, safeTaskError(error), 'delivery_failed')
|
||
}
|
||
}
|
||
|
||
async function recoveryConfig(record: SysTaskRecord): Promise<AIConfig> {
|
||
if (record.configId) {
|
||
const config = await getConfigById(record.configId)
|
||
if (config && config.provider === record.provider && config.baseUrl === record.configBaseUrl) return config
|
||
throw new Error('原生成服务配置已删除、停用或地址变更,请恢复原配置')
|
||
}
|
||
// 旧任务只在同厂商唯一配置时恢复,绝不任意换服务商查询。
|
||
const rows = (await db.select().from(schema.aiServiceConfigs)).filter(c => c.isActive && c.serviceType === record.type && c.provider === record.provider)
|
||
if (rows.length === 1) {
|
||
const config = await getConfigById(rows[0].id)
|
||
if (config) return config
|
||
}
|
||
throw new Error('历史任务无法确定原服务配置,请先核对配置')
|
||
}
|
||
|
||
export async function recoverVideoTask(id: number): Promise<void> {
|
||
const [record] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
|
||
if (!record || record.type !== 'video') throw new Error('视频任务不存在')
|
||
if (record.errorCode === 'user_cancelled') throw new Error('原任务已取消,请选择模型和显卡重新生成')
|
||
if (activeTasks.has(id) || record.status === 'completed') return
|
||
if (!record.resultUrl && !record.taskId) throw new Error('未保存上游任务编号,请先核对上游记录,勿重复生成')
|
||
if (record.errorCode === 'generation_failed') throw new Error('上游已确认生成失败,无法恢复原任务')
|
||
// 在任何异步配置读取前获取锁,重复点击不会启动多个下载。
|
||
activeTasks.add(id)
|
||
try {
|
||
const config = record.taskId && !record.resultUrl ? await recoveryConfig(record) : null
|
||
await db.update(schema.sysTask).set({ status: 'processing', errorMsg: null, errorCode: null,
|
||
stage: record.resultUrl ? 'downloading' : record.stage === 'transferring' || record.errorCode === 'delivery_failed' ? 'transferring' : 'polling', updatedAt: now() }).where(eq(schema.sysTask.id, id))
|
||
void (async () => {
|
||
if (record.resultUrl) {
|
||
await handleVideoComplete(record, record.resultUrl, parseTaskParams(record.params).resultDuration)
|
||
const [fresh] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
|
||
if (fresh?.status !== 'failed' || !record.taskId) return
|
||
// 签名链接可能过期:重新查询原任务拿新地址。
|
||
}
|
||
const originalConfig = config ?? await recoveryConfig(record)
|
||
// Firemux 的交付恢复是独立接口;只在其明确返回交付失败时调用。
|
||
if (record.provider === 'minimax' && (record.errorCode === 'delivery_failed' || record.stage === 'transferring') && !record.resultUrl) {
|
||
const req = getVideoAdapter('minimax').buildPollRequest(originalConfig, record.taskId!)
|
||
const resp = await fetch(`${req.url}/recover`, { method: 'POST', headers: req.headers, signal: AbortSignal.timeout(30_000) })
|
||
if (!resp.ok) throw new Error(`Video delivery recovery HTTP ${resp.status}`)
|
||
}
|
||
await markPolling(id, record.taskId!)
|
||
await pollTask(record, originalConfig, record.taskId!)
|
||
})().catch(error => failTask(id, safeTaskError(error), 'recovery_failed')).finally(() => activeTasks.delete(id))
|
||
} catch (error) {
|
||
activeTasks.delete(id)
|
||
throw error
|
||
}
|
||
}
|
||
|
||
export async function recoverGenerationTask(id: number): Promise<void> {
|
||
const [record] = await db.select().from(schema.sysTask).where(eq(schema.sysTask.id, id))
|
||
if (record?.type === 'video') return recoverVideoTask(id)
|
||
if (!record || record.type !== 'image') throw new Error('生成任务不存在')
|
||
if (['generation_failed', 'user_cancelled'].includes(record.errorCode || '')) throw new Error('原任务已结束,无法恢复')
|
||
if (activeTasks.has(id) || record.status === 'completed') return
|
||
if (!record.taskId) throw new Error('未保存上游任务编号,无法恢复')
|
||
activeTasks.add(id)
|
||
try {
|
||
const config = await recoveryConfig(record)
|
||
await db.update(schema.sysTask).set({ status: 'processing', errorMsg: null, errorCode: null, stage: 'polling', updatedAt: now() }).where(eq(schema.sysTask.id, id))
|
||
void pollTask(record, config, record.taskId).catch(error => failTask(id, safeTaskError(error), 'recovery_failed')).finally(() => activeTasks.delete(id))
|
||
} catch (error) { activeTasks.delete(id); throw error }
|
||
}
|
||
|
||
export async function resumeInterruptedTasks() {
|
||
const candidates = await db.select().from(schema.sysTask).where(or(eq(schema.sysTask.status, 'processing'), eq(schema.sysTask.status, 'failed'))).orderBy(desc(schema.sysTask.id))
|
||
const tasks = candidates.filter(task => task.status === 'processing' || (!task.errorCode && /^Timeout: (polling attempts exhausted|Polling exceeded 10 minutes)/.test(task.errorMsg || '')
|
||
&& isLocalQueuedTask({ provider: task.provider || '', baseUrl: task.configBaseUrl || '' }, task.taskId)))
|
||
for (const task of tasks) {
|
||
if (task.type === 'video' && !task.taskId && task.status === 'processing' && ['waiting_predecessor', 'blocked_predecessor'].includes(task.stage || '') && parseTaskParams(task.params).continuity?.mode === 'first_frame') {
|
||
try {
|
||
const config = await recoveryConfig(task)
|
||
runBackground(task.id, () => processTask(task.id, { ...config, gpu: parseTaskParams(task.params).gpu || config.gpu }))
|
||
} catch (error) { await failTask(task.id, safeTaskError(error), 'recovery_failed') }
|
||
continue
|
||
}
|
||
if ((task.type === 'video' && (task.taskId || task.resultUrl)) || (task.type === 'image' && isLocalQueuedTask({ provider: task.provider || '', baseUrl: task.configBaseUrl || '' }, task.taskId))) {
|
||
try { await recoverGenerationTask(task.id) } catch (error) { await failTask(task.id, safeTaskError(error), 'recovery_failed') }
|
||
} else {
|
||
await failTask(task.id, task.type === 'video' ? '服务中断,提交结果待确认,请先核对上游记录' : '服务重启,生成任务中断,请重试',
|
||
task.type === 'video' ? 'submission_unknown' : 'interrupted')
|
||
}
|
||
}
|
||
}
|
||
|
||
// ─── 参考素材归一化 ───────────────────────────────────────────────
|
||
|
||
async function normalizeReferenceImages(refs: string[] | null | undefined): Promise<string[]> {
|
||
if (!Array.isArray(refs) || !refs.length) return []
|
||
|
||
const deduped = Array.from(
|
||
new Set(
|
||
refs
|
||
.map((item) => String(item || '').trim())
|
||
.filter(Boolean),
|
||
),
|
||
)
|
||
|
||
const normalized = await Promise.all(deduped.map(async (value) => {
|
||
if (value.startsWith('data:image/')) return value
|
||
if (value.startsWith('static/') || value.startsWith('/static/')) {
|
||
const localPath = value.startsWith('/static/') ? value.slice(1) : value
|
||
try {
|
||
return await readImageAsCompressedDataUrl(localPath, {
|
||
maxWidth: 768,
|
||
maxHeight: 768,
|
||
quality: 68,
|
||
})
|
||
} catch (err) {
|
||
logTaskWarn('ImageTask', 'reference-read-failed', { path: localPath, error: (err as Error).message })
|
||
throw new Error('参考图读取失败,请重新上传后再生成')
|
||
}
|
||
}
|
||
// 远程 URL:下载压缩为 data URL,保证 multipart 上传(OpenAI edits)/ inline_data(Gemini)都可用
|
||
if (/^https?:\/\//.test(value)) {
|
||
try {
|
||
return await fetchImageAsCompressedDataUrl(value, {
|
||
maxWidth: 768,
|
||
maxHeight: 768,
|
||
quality: 68,
|
||
})
|
||
} catch (err) {
|
||
logTaskWarn('ImageTask', 'reference-fetch-failed', { url: value, error: (err as Error).message })
|
||
throw new Error('参考图读取失败,请重新上传后再生成')
|
||
}
|
||
}
|
||
throw new Error('参考图地址无效,请重新上传后再生成')
|
||
}))
|
||
|
||
if (normalized.length > 6) throw new Error('参考图最多 6 张')
|
||
return normalized
|
||
}
|
||
|
||
async function prepareVideoReferences(params: Pick<GenerateVideoParams, 'imageUrl' | 'firstFrameUrl' | 'lastFrameUrl' |
|
||
'referenceImageUrls' | 'referenceVideoUrls' | 'referenceAudioUrls' | 'referenceFileUrl'>, provider: string) {
|
||
const imageUrl = await normalizeVideoReferenceUrl(params.imageUrl)
|
||
const firstFrameUrl = await normalizeVideoReferenceUrl(params.firstFrameUrl)
|
||
const lastFrameUrl = await normalizeVideoReferenceUrl(params.lastFrameUrl)
|
||
const images = await normalizeVideoReferenceUrls(params.referenceImageUrls)
|
||
const videos = resolvePublicMediaUrls(params.referenceVideoUrls, 'video')
|
||
const audios = await resolveReferenceAudioUrls(params.referenceAudioUrls, provider)
|
||
return { imageUrl, firstFrameUrl, lastFrameUrl,
|
||
referenceImageUrls: images.length ? JSON.stringify(images) : null,
|
||
referenceVideoUrls: videos.length ? JSON.stringify(videos) : null,
|
||
referenceAudioUrls: audios.length ? JSON.stringify(audios) : null,
|
||
referenceFileUrl: resolvePublicMediaUrl(params.referenceFileUrl, 'file') }
|
||
}
|
||
|
||
async function normalizeVideoReferenceUrl(value: string | null | undefined): Promise<string | null> {
|
||
const raw = String(value || '').trim()
|
||
if (!raw) return null
|
||
if (raw.startsWith('data:image/')) return raw
|
||
if (raw.startsWith('static/') || raw.startsWith('/static/')) {
|
||
const localPath = raw.startsWith('/static/') ? raw.slice(1) : raw
|
||
try {
|
||
// 视频参考图直接编码原文件,保留原始尺寸、格式、透明通道和画质。
|
||
return readImageAsDataUrl(localPath)
|
||
} catch (err) {
|
||
logTaskWarn('VideoTask', 'reference-read-failed', { path: localPath, error: (err as Error).message })
|
||
throw new Error('参考图读取失败,请重新上传后再生成')
|
||
}
|
||
}
|
||
return raw
|
||
}
|
||
|
||
async function normalizeVideoReferenceUrls(refs: string[] | null | undefined): Promise<string[]> {
|
||
if (!Array.isArray(refs) || !refs.length) return []
|
||
const normalized = await Promise.all(
|
||
Array.from(new Set(refs.map((item) => String(item || '').trim()).filter(Boolean))).map((item) => normalizeVideoReferenceUrl(item)),
|
||
)
|
||
return normalized.filter((item): item is string => !!item)
|
||
}
|
||
|
||
/**
|
||
* 将参考视频/音频解析为 Seedance API 可访问的 URL。
|
||
* http(s)/dataURL 直通;本地 static 路径需要 PUBLIC_BASE_URL 拼成公网地址,
|
||
* 未配置时抛出可操作的中文错误(落入 catch 写入 error_msg 供前端展示)。
|
||
*/
|
||
function resolvePublicMediaUrl(value: string | null | undefined, kind: 'video' | 'audio' | 'file'): string | null {
|
||
const raw = String(value || '').trim()
|
||
if (!raw) return null
|
||
if (raw.startsWith('http://') || raw.startsWith('https://') || raw.startsWith('data:')) return raw
|
||
if (raw.startsWith('static/') || raw.startsWith('/static/')) {
|
||
const base = (process.env.PUBLIC_BASE_URL || '').trim().replace(/\/+$/, '')
|
||
if (!base) {
|
||
const label = kind === 'video' ? '视频' : kind === 'audio' ? '音频' : '文件'
|
||
throw new Error(
|
||
`参考${label}为本地路径 ${raw},但后端未配置 PUBLIC_BASE_URL,上游视频生成 API 无法访问内网地址。` +
|
||
`请在 backend/.env 配置 PUBLIC_BASE_URL(如 https://your-domain.com)后重试,或改用公网 URL。`,
|
||
)
|
||
}
|
||
const p = raw.startsWith('/') ? raw : `/${raw}`
|
||
return `${base}${p}`
|
||
}
|
||
return raw
|
||
}
|
||
|
||
function resolvePublicMediaUrls(refs: string[] | null | undefined, kind: 'video' | 'audio'): string[] {
|
||
if (!Array.isArray(refs) || !refs.length) return []
|
||
const items = Array.from(new Set(refs.map((item) => String(item || '').trim()).filter(Boolean)))
|
||
return items.map((item) => resolvePublicMediaUrl(item, kind)).filter((item): item is string => !!item)
|
||
}
|
||
|
||
function normalizeStoredVideoResolution(resolution: string | null | undefined): string | undefined {
|
||
const value = String(resolution || '').trim().toLowerCase()
|
||
if (value === '480p' || value === '720p' || value === '1080p') return value
|
||
if (value === '2k') return '2K'
|
||
if (value === '4k') return '4K'
|
||
return undefined
|
||
}
|