@uzooai/anime-ai-cli 0.0.0-stage → 0.5.0

package/src/repaint-delivery.js

@@ -0,0 +1,783 @@
+import { archiveRepaintResult } from './repaint-archive.js'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { isDeepStrictEqual } from 'node:util'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { atomic, json, root, safeName } from './store.js'
+import {
+  repaintPromptContext,
+  repaintPromptFields as fields
+} from './repaint-reverse.js'
+import { repaintOf, jobPath } from './repaint-graph.js'
+import { requireServiceReady } from './service.js'
+import { cancellation } from './api.js'
+import { repaintAttachmentView } from './repaint-settings.js'
+
+const hash = (value) =>
+  crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex')
+const text = (value) => String(value ?? '')
+const fail = (code, message, cause) =>
+  Object.assign(new Error(message), {
+    code,
+    ...(cause
+      ? {
+          cause,
+          status: cause.status,
+          apiCode: cause.apiCode,
+          requestId: cause.requestId
+        }
+      : {})
+  })
+export const deliveryPath = (profile, operation) =>
+  path.join(
+    root(),
+    'repaint-delivery',
+    safeName(profile),
+    safeName(operation) + '.json'
+  )
+const persist = (record) =>
+  atomic(deliveryPath(record.profile, record.operation), record)
+const api = (client, endpoint, options = {}, controls) =>
+  client.raw(
+    endpoint,
+    {
+      ...options,
+      headers: { ...options.headers, 'X-Client-Source': 'canvas' }
+    },
+    controls
+  )
+const object = (value) =>
+  value && typeof value === 'object' && !Array.isArray(value)
+export function deliveryInput(value = {}) {
+  if (
+    !object(value) ||
+    Object.keys(value).some((k) => !['rules', 'edited_sections'].includes(k))
+  )
+    throw new Error(
+      '最终提示词输入只支持rules/edited_sections；附件来自已同步全局节点，单次附件、模型或文化指令额外字段尚未接入'
+    )
+  if (
+    value.rules !== undefined &&
+    (!object(value.rules) ||
+      Object.keys(value.rules).some(
+        (k) =>
+          !['character', 'scene', 'sceneList', 'prop', 'dialogue'].includes(k)
+      ))
+  )
+    throw new Error('替换规则仅支持character/scene/sceneList/prop/dialogue')
+  const rules = value.rules || {}
+  for (const key of ['character', 'scene', 'sceneList', 'prop', 'dialogue']) {
+    const list = rules[key]
+    if (list === undefined) continue
+    if (key === 'scene' && typeof list === 'string') {
+      if (list.length > 12000) throw new Error('场景替换过长')
+      continue
+    }
+    if (
+      !Array.isArray(list) ||
+      list.length > 100 ||
+      list.some(
+        (item) =>
+          !object(item) ||
+          Object.keys(item).some((k) => !['source', 'target'].includes(k)) ||
+          typeof item.source !== 'string' ||
+          typeof item.target !== 'string' ||
+          item.source.length > 300 ||
+          item.target.length > 300
+      )
+    )
+      throw new Error(
+        '替换列表须为最多100项的source/target字符串，单项最长300字符'
+      )
+  }
+  if (
+    value.edited_sections !== undefined &&
+    (!object(value.edited_sections) ||
+      Object.entries(value.edited_sections).some(
+        ([k, v]) =>
+          !['character', 'scene', 'prop', 'dialogue'].includes(k) ||
+          typeof v !== 'string' ||
+          v.length > 12000
+      ))
+  )
+    throw new Error('edited_sections只接受四类文本')
+  return structuredClone(value)
+}
+function dialogueReplace(section, rules) {
+  const map = new Map(rules.map((item) => [item.source, item.target]))
+  return section
+    .split(/(\r?\n)/)
+    .map((line) => {
+      const source = line.trim(),
+        replacement = map.get(source)
+      if (!replacement) return line
+      const quoted = source.match(/^(.+?)\s*[：:]\s*[“\"]([\s\S]*?)[”\"]\s*$/),
+        plain = source.match(/^(.+?)\s*[：:]\s*(.+)$/)
+      const speaker = (quoted || plain)?.[1]?.trim()
+      return speaker ? `${speaker}：“${replacement}”` : replacement
+    })
+    .join('')
+}
+// Kept equivalent to the website's buildDeliveryPromptPayload; verified against it.
+export function deliveryBody(reversePrompt, value = {}) {
+  const input = deliveryInput(value),
+    sections = { character: '', scene: '', prop: '', dialogue: '' }
+  if (input.edited_sections) Object.assign(sections, input.edited_sections)
+  else {
+    const keys = {
+      角色: 'character',
+      场景: 'scene',
+      道具: 'prop',
+      台词: 'dialogue'
+    }
+    const pattern =
+      /【(角色|场景|道具|台词)】\s*([\s\S]*?)(?=【(?:上一段视频结尾|开头|镜头|画面|角色|场景|道具|台词|负面提示词)】|$)/g
+    for (const match of text(reversePrompt?.prompt).matchAll(pattern))
+      sections[keys[match[1]]] = match[2].trim()
+  }
+  const normalize = (list) =>
+    (Array.isArray(list) ? list : [])
+      .map((item) => ({
+        source: item.source.trim(),
+        target: item.target.trim()
+      }))
+      .filter(
+        (item) => item.source && item.target && item.source !== item.target
+      )
+  const rules = input.rules || {},
+    replacement = typeof rules.scene === 'string' ? rules.scene.trim() : ''
+  const scene = replacement
+    ? sections.scene !== replacement
+      ? [{ source: sections.scene, target: replacement }]
+      : []
+    : normalize(Array.isArray(rules.scene) ? rules.scene : rules.sceneList)
+  sections.dialogue = dialogueReplace(
+    sections.dialogue,
+    normalize(rules.dialogue)
+  )
+  if (
+    Object.values(sections).some(
+      (value) => !value.trim() || value.length > 12000
+    )
+  )
+    throw new Error('反推正文缺少有效角色/场景/道具/台词章节；不能补造内容提交')
+  if (
+    scene.some((item) => item.source.length > 300 || item.target.length > 300)
+  )
+    throw new Error(
+      '场景映射超过接口300字符限制，改用有效的章节编辑或短名称替换'
+    )
+  return {
+    character: normalize(rules.character),
+    scene,
+    prop: normalize(rules.prop),
+    cultural_reference: '',
+    sections,
+    reference_images: []
+  }
+}
+const promptOf = (job, index) =>
+  (job.delivery_prompts || []).find((item) => item.segment_index === index) ||
+  null
+const runState = (ctx) => ({
+  status:
+    ctx.output.delivery_prompt_status ||
+    (ctx.result ? 'completed' : 'not_started'),
+  prompt: ctx.result,
+  billing: ctx.output.delivery_prompt_billing || null
+})
+// The current attachment worker passes image URLs straight to the model and
+// fetches PDFs by URL. A browser-only proxy address is not a storage resolver.
+export function deliveryAttachmentBlockers(attachments) {
+  return attachments.flatMap((a, index) => {
+    const url = new URL(a.url),
+      host = url.hostname.toLowerCase().replace(/^\[|\]$/g, '')
+    if (url.protocol === 'data:') {
+      const prefix = `data:${a.media_type.toLowerCase()};base64,`
+      if (
+        a.url.length <= 8000000 &&
+        a.url.toLowerCase().startsWith(prefix) &&
+        /^[a-zA-Z0-9+/]+={0,2}$/.test(a.url.slice(prefix.length))
+      )
+        return []
+    } else if (
+      url.protocol === 'https:' &&
+      !(
+        /^(?:localhost|.*\.localhost|.*\.local|0\.|10\.|127\.|169\.254\.|192\.168\.|172\.(?:1[6-9]|2\d|3[01])\.)/.test(
+          host
+        ) ||
+        host === '::' ||
+        host === '::1' ||
+        /^(?:fc|fd|fe[89ab])[0-9a-f]*:/i.test(host) ||
+        host.includes(':')
+      )
+    )
+      return []
+    return [
+      {
+        code: 'DELIVERY_ATTACHMENT_ADDRESS_UNUSABLE',
+        attachment_index: index + 1,
+        name: a.name,
+        message:
+          '附件已上传，但当前地址只适用于本机/内网或格式不适合服务端读取；原文件引用保留。需同服务可访问的HTTPS文件地址，或服务端解析存储引用后再处理。'
+      }
+    ]
+  })
+}
+async function context(client, profile, parent, index) {
+  const ctx = await repaintPromptContext(client, profile, parent, index)
+  const reverse = ctx.output.reverse_prompt,
+    reverseStatus =
+      ctx.output.reverse_prompt_status ||
+      (reverse ? 'completed' : 'not_started')
+  if (reverseStatus !== 'completed' || !text(reverse?.prompt).trim())
+    throw new Error('先完成原片段反推，不用空节点代替反推结果')
+  if (ctx.final.type !== 'text') throw new Error('最终提示词节点类型已变化')
+  const generation = ctx.doc.nodes.filter(
+    (n) =>
+      repaintOf(n).jobId === ctx.job.id &&
+      repaintOf(n).role === 'generation' &&
+      repaintOf(n).segmentIndex === index
+  )
+  if (
+    generation.length !== 1 ||
+    !ctx.doc.edges.some(
+      (e) =>
+        e.source === ctx.final.id &&
+        e.target === generation[0].id &&
+        e.data?.role === 'final-generation-link'
+    ) ||
+    !ctx.doc.edges.some(
+      (e) =>
+        e.source === ctx.global.id &&
+        e.target === ctx.final.id &&
+        e.data?.role === 'global-prompt-link'
+    )
+  )
+    throw new Error('最终提示词下游或全局系统线缺失，不重建')
+  const localAttachments = repaintAttachmentView(
+      repaintOf(ctx.global).attachments,
+      client.baseUrl
+    ),
+    remoteAttachments = repaintAttachmentView(
+      ctx.job.delivery_prompt_attachments,
+      client.baseUrl
+    )
+  if (!isDeepStrictEqual(localAttachments, remoteAttachments))
+    throw new Error('画布与后端全局附件不一致，不清空或覆盖后提交')
+  ctx.attachments = remoteAttachments
+  ctx.result = promptOf(ctx.job, index)
+  ctx.node = ctx.final
+  ctx.binding = {
+    ...ctx.binding,
+    node_id: ctx.final.id,
+    reverse_hash: hash(reverse),
+    ...(ctx.attachments.length ? { attachments: ctx.attachments } : {})
+  }
+  return ctx
+}
+async function quote(client, ctx) {
+  const pricing = await api(client, '/video-segmentation/pricing'),
+    unit = pricing.ai_edit_credits_per_segment,
+    benefit = ctx.job.billing?.has_base_benefit
+  if (
+    pricing.currency !== 'OO' ||
+    !Number.isSafeInteger(unit) ||
+    unit < 0 ||
+    typeof benefit !== 'boolean'
+  )
+    throw new Error('最终提示词实时单价或基础权益未知')
+  const me = await client.raw('/auth/me'),
+    team =
+      ctx.parent.input.space === 'team'
+        ? me.teams?.find(
+            (t) =>
+              text(t.uid) === ctx.parent.input.team_uid && t.status === 'active'
+          )
+        : null
+  if (
+    text(me.uid) !== ctx.parent.owner ||
+    (ctx.parent.input.space === 'team' && !team)
+  )
+    throw new Error('账号或团队成员身份变化')
+  const first = benefit && !ctx.result
+  let extra = 0,
+    attachmentPricing
+  if (ctx.attachments.length) {
+    const keys = [
+      'attachment_free_images',
+      'attachment_free_docs',
+      'attachment_extra_fee',
+      'attachment_max'
+    ]
+    if (
+      keys.some((k) => !Number.isSafeInteger(pricing[k]) || pricing[k] < 0) ||
+      pricing.attachment_max < ctx.attachments.length
+    )
+      throw new Error('附件实时限额/价格无效或数量超限')
+    const images = ctx.attachments.filter((a) =>
+        a.media_type.toLowerCase().startsWith('image/')
+      ).length,
+      docs = ctx.attachments.length - images
+    extra =
+      images > pricing.attachment_free_images ||
+      docs > pricing.attachment_free_docs
+        ? pricing.attachment_extra_fee
+        : 0
+    const estimated = await api(
+      client,
+      jobPath(ctx.job.id) + '/billing-estimate',
+      {
+        method: 'POST',
+        body: { segment_count: 1, attachments: ctx.attachments }
+      },
+      { retry: false }
+    )
+    if (
+      estimated?.currency !== 'OO' ||
+      estimated.segment_count !== 1 ||
+      ['ai_edit_credits_per_segment', ...keys].some(
+        (k) => estimated.pricing?.[k] !== pricing[k]
+      ) ||
+      estimated.manual_segmentation !== !benefit ||
+      estimated.attachments?.count !== ctx.attachments.length ||
+      estimated.attachments.image_files !== images ||
+      estimated.attachments.pdf_files !== docs ||
+      estimated.attachments.extra_fee !== extra ||
+      estimated.breakdown?.ai_edit?.first_run !== (benefit ? 0 : unit) ||
+      estimated.breakdown?.ai_edit?.rerun_all !== unit ||
+      estimated.breakdown?.attachment_extra?.first_run !== extra ||
+      estimated.breakdown?.attachment_extra?.rerun_all !== extra
+    )
+      throw new Error(
+        '附件预估与实时价格/数量/权益不一致；不使用历史任务价格或整任务总价提交单段处理'
+      )
+    attachmentPricing = {
+      images,
+      docs,
+      ...Object.fromEntries(keys.map((k) => [k, pricing[k]])),
+      extra_fee_per_segment_per_run: extra,
+      server_estimate_verified: true
+    }
+  }
+  return {
+    currency: 'OO',
+    credits: (first ? 0 : unit) + extra,
+    base_credits: first ? 0 : unit,
+    attachment_credits: extra,
+    unit_price: unit,
+    first_run_included: first,
+    attachments: ctx.attachments.length,
+    ...(attachmentPricing ? { attachment_pricing: attachmentPricing } : {}),
+    wallet: {
+      space: ctx.parent.input.space,
+      team_uid: ctx.parent.input.team_uid || null,
+      team_name: team?.name || null,
+      shared: Boolean(team),
+      balance_snapshot: (team || me).oo_balance ?? null
+    }
+  }
+}
+const costKey = (q) =>
+  hash({
+    credits: q.credits,
+    unit_price: q.unit_price,
+    first_run_included: q.first_run_included,
+    space: q.wallet.space,
+    team_uid: q.wallet.team_uid,
+    ...(q.attachments
+      ? { attachments: q.attachments, attachment_pricing: q.attachment_pricing }
+      : {})
+  })
+async function bound(client, profile, operation) {
+  const record = await json(deliveryPath(profile, operation), null)
+  if (
+    !record ||
+    record.schema !== 1 ||
+    record.profile !== profile ||
+    record.baseUrl !== client.baseUrl
+  )
+    throw new Error('最终提示词operation不存在或服务不匹配')
+  const ctx = await context(
+    client,
+    profile,
+    record.parentOperation,
+    record.index
+  )
+  if (
+    record.owner !== ctx.parent.owner ||
+    !isDeepStrictEqual(ctx.binding, record.binding)
+  )
+    throw new Error('原方案、反推原文、全局规则/附件或节点关联变化，停止恢复')
+  return { record, ctx }
+}
+async function preventDuplicate(profile, operation, ctx) {
+  const dir = path.dirname(deliveryPath(profile, operation)),
+    files = await fs.readdir(dir).catch((e) => {
+      if (e.code === 'ENOENT') return []
+      throw e
+    })
+  for (const file of files.filter((f) => f.endsWith('.json'))) {
+    const r = await json(path.join(dir, file))
+    if (
+      r.operation !== operation &&
+      r.owner === ctx.parent.owner &&
+      r.baseUrl === ctx.parent.baseUrl &&
+      r.binding?.job_id === ctx.job.id &&
+      r.index === ctx.binding.index &&
+      r.attempted &&
+      !['completed', 'completed_fallback', 'failed'].includes(r.state)
+    )
+      throw new Error('该片段已有未结束或未知最终提示词operation，不能换名重提')
+  }
+}
+function summary(record, ctx) {
+  const state = runState(ctx),
+    prompt = state.prompt?.prompt
+  return {
+    operation: record.operation,
+    repaint_operation: record.parentOperation,
+    state: record.state,
+    job_id: ctx.job.id,
+    plan_version: ctx.job.plan_version,
+    segment_index: record.index,
+    node_id: ctx.node.id,
+    attachment_count: ctx.attachments.length,
+    attachment_address_blockers: deliveryAttachmentBlockers(ctx.attachments),
+    processing_submitted: record.accepted
+      ? true
+      : record.attempted
+        ? null
+        : false,
+    remote_status: state.status,
+    canvas_synced:
+      record.canvasSynced === true &&
+      Boolean(prompt) &&
+      isDeepStrictEqual(fields(ctx.node), {
+        input: prompt,
+        prompt,
+        output: prompt
+      }),
+    billing: state.billing,
+    delivery_prompt: state.prompt,
+    fallback: ctx.output.delivery_prompt_fallback === true,
+    warning: ctx.output.delivery_prompt_warning || null,
+    remote_error: ctx.output.delivery_prompt_error || null,
+    library_saved: false
+  }
+}
+export function validateDeliveryRun(record, ctx) {
+  if (!record.accepted)
+    throw fail(
+      'DELIVERY_SUBMISSION_UNKNOWN',
+      '最终提示词响应未知；仅查询原任务，不认领观察结果或重发POST'
+    )
+  const state = runState(ctx),
+    billing = state.billing
+  if (
+    !billing ||
+    billing.plan_version !== record.binding.plan_version ||
+    billing.amount !== record.approvedCost ||
+    (record.reservationKey && billing.reservation_key !== record.reservationKey)
+  )
+    throw new Error('最终提示词运行/计费标记变化，不认领另一轮结果')
+  if (state.status === 'completed' && !text(state.prompt?.prompt).trim())
+    throw new Error('完成但缺少真实最终提示词，不回填空内容')
+  if (
+    record.resultHash &&
+    (state.status !== 'completed' || hash(state.prompt) !== record.resultHash)
+  )
+    throw new Error('原最终提示词被另一轮替换，停止覆盖')
+  return state
+}
+const validateRun = validateDeliveryRun
+export async function startDelivery(
+  client,
+  profile,
+  parent,
+  index,
+  operation,
+  value = {},
+  confirmed = false,
+  expectedCost
+) {
+  safeName(parent)
+  safeName(operation)
+  const input = deliveryInput(value),
+    ctx = await context(client, profile, parent, index)
+  let record = await json(deliveryPath(profile, operation), null)
+  if (
+    record &&
+    (record.parentOperation !== parent ||
+      record.index !== index ||
+      record.baseUrl !== client.baseUrl ||
+      record.owner !== ctx.parent.owner ||
+      !isDeepStrictEqual(record.binding, ctx.binding) ||
+      !isDeepStrictEqual(record.input, input))
+  )
+    throw new Error('原最终提示词operation参数不能修改')
+  if (record?.attempted) return recoverDelivery(client, profile, operation)
+  await preventDuplicate(profile, operation, ctx)
+  const state = runState(ctx)
+  if (!['not_started', 'completed'].includes(state.status))
+    throw new Error(
+      '该片段最终提示词运行中、失败或状态未知，先查原操作，不自动重做'
+    )
+  const body = deliveryBody(ctx.output.reverse_prompt, input),
+    estimate = await quote(client, ctx),
+    blockers = deliveryAttachmentBlockers(ctx.attachments)
+  if (!confirmed) {
+    record = {
+      schema: 1,
+      profile,
+      operation,
+      parentOperation: parent,
+      index,
+      owner: ctx.parent.owner,
+      baseUrl: client.baseUrl,
+      binding: ctx.binding,
+      input,
+      body,
+      baseline: state,
+      nodeBefore: fields(ctx.node),
+      estimate,
+      estimateKey: costKey(estimate),
+      state: 'prepared',
+      createdAt: new Date().toISOString(),
+      ...(record?.settingsAttempted
+        ? { settingsAttempted: true, settingsVerified: record.settingsVerified }
+        : {})
+    }
+    await persist(record)
+    return {
+      ...summary(record, ctx),
+      submitted: false,
+      submission_available: blockers.length === 0,
+      blockers,
+      estimate,
+      parameters: {
+        start_ms: ctx.binding.start_ms,
+        end_ms: ctx.binding.end_ms,
+        global_rules: ctx.binding.rules,
+        attachments: ctx.attachments.map((a) => ({
+          name: a.name,
+          media_type: a.media_type
+        })),
+        body,
+        model: 'service_managed'
+      },
+      next: '通过交互卡片明确替换要求或不替换，展示钱包/规则/费用；当次确认后同operation加--yes --expected-cost。不生成视频'
+    }
+  }
+  if (blockers.length)
+    throw Object.assign(
+      fail(
+        'DELIVERY_ATTACHMENT_ADDRESS_UNUSABLE',
+        '附件已上传，但服务端/模型读取地址不适用；未提交最终提示词，不重新上传素材'
+      ),
+      { blockers }
+    )
+  if (
+    !record ||
+    expectedCost === undefined ||
+    Number(expectedCost) !== estimate.credits ||
+    record.estimateKey !== costKey(estimate) ||
+    !isDeepStrictEqual(record.body, body) ||
+    !isDeepStrictEqual(record.baseline, state) ||
+    !isDeepStrictEqual(record.nodeBefore, fields(ctx.node))
+  )
+    throw new Error('先预估并当次确认；费用/原文/规则/节点变化须重新核对')
+  await requireServiceReady(client)
+  if (record.settingsAttempted && !record.settingsVerified)
+    throw fail(
+      'DELIVERY_SUBMISSION_UNKNOWN',
+      '设置保存响应未知；先delivery-recover核对，不重发设置或生成'
+    )
+  if (!record.settingsVerified) {
+    record.settingsAttempted = true
+    record.state = 'saving_settings'
+    await persist(record)
+    try {
+      await api(
+        client,
+        jobPath(ctx.job.id) + '/delivery-prompt-settings',
+        {
+          method: 'POST',
+          body: {
+            custom_prompt: ctx.binding.rules,
+            attachments: ctx.attachments
+          }
+        },
+        { retry: false }
+      )
+      record.settingsVerified = true
+      await persist(record)
+    } catch (error) {
+      record.state = 'settings_unknown'
+      await persist(record)
+      throw fail(
+        'DELIVERY_SUBMISSION_UNKNOWN',
+        '全局设置保存未确认，未发送生成；先检查后端并查原操作',
+        error
+      )
+    }
+  }
+  const fresh = await context(client, profile, parent, index)
+  if (
+    !isDeepStrictEqual(fresh.binding, record.binding) ||
+    !isDeepStrictEqual(runState(fresh), record.baseline) ||
+    !isDeepStrictEqual(fields(fresh.node), record.nodeBefore) ||
+    costKey(await quote(client, fresh)) !== record.estimateKey
+  )
+    throw new Error('设置保存后参数/费用变化，尚未提交最终提示词')
+  record.attempted = true
+  record.approvedCost = estimate.credits
+  record.state = 'submitting'
+  await persist(record)
+  try {
+    const response = await api(
+        client,
+        jobPath(ctx.job.id) + '/segments/' + index + '/delivery-prompt',
+        { method: 'POST', body },
+        { retry: false }
+      ),
+      output = response?.outputs?.find((o) => o.index === index && !o.type)
+    if (
+      response?.id === ctx.job.id &&
+      response.canvas_doc_id === ctx.doc.id &&
+      text(response.team_uid || '') === text(ctx.doc.team_uid || '') &&
+      response.plan_version === record.binding.plan_version &&
+      output?.delivery_prompt_billing?.plan_version ===
+        record.binding.plan_version
+    ) {
+      record.accepted = true
+      record.reservationKey =
+        output.delivery_prompt_billing.reservation_key || null
+      await persist(record)
+    }
+    if (!record.accepted) throw new Error('响应缺少本次原任务运行标记')
+    record.state = 'running'
+    await persist(record)
+  } catch (error) {
+    record.state = 'submission_unknown'
+    await persist(record)
+    throw fail(
+      'DELIVERY_SUBMISSION_UNKNOWN',
+      '最终提示词提交结果未确认；仅查原job/segment，不重发或换operation',
+      error
+    )
+  }
+  return recoverDelivery(client, profile, operation)
+}
+export async function getDelivery(client, profile, operation) {
+  const { record, ctx } = await bound(client, profile, operation)
+  if (record.accepted) validateRun(record, ctx)
+  return summary(record, ctx)
+}
+export async function recoverDelivery(client, profile, operation) {
+  const { record, ctx } = await bound(client, profile, operation)
+  if (!record.attempted) {
+    if (record.settingsAttempted) {
+      record.settingsVerified = true
+      record.state = 'settings_verified'
+      await persist(record)
+    }
+    return summary(record, ctx)
+  }
+  const state = validateRun(record, ctx)
+  if (state.status === 'failed') {
+    record.state = 'failed'
+    await persist(record)
+    return summary(record, ctx)
+  }
+  if (state.status !== 'completed') {
+    record.state = 'running'
+    await persist(record)
+    return summary(record, ctx)
+  }
+  await archiveRepaintResult(record, 'delivery', state.prompt, state.billing, { fallback: ctx.output.delivery_prompt_fallback === true, warning: ctx.output.delivery_prompt_warning || null })
+  const prompt = state.prompt.prompt,
+    expected = { input: prompt, prompt, output: prompt },
+    current = fields(ctx.node)
+  if (
+    !isDeepStrictEqual(current, expected) &&
+    !isDeepStrictEqual(current, record.nodeBefore)
+  )
+    throw fail(
+      'DELIVERY_SYNC_PENDING',
+      '最终提示词节点已被用户编辑，不覆盖；原结果仍可查询'
+    )
+  record.resultHash = hash(state.prompt)
+  record.state = ctx.output.delivery_prompt_fallback
+    ? 'completed_fallback'
+    : 'completed'
+  await persist(record)
+  if (!isDeepStrictEqual(current, expected)) {
+    ctx.node.data = { ...ctx.node.data, ...expected }
+    try {
+      const saved = await api(
+        client,
+        '/canvas/docs/' + encodeURIComponent(ctx.doc.id),
+        {
+          method: 'PUT',
+          body: {
+            version: ctx.doc.version,
+            name: ctx.doc.name,
+            viewport: ctx.doc.viewport,
+            nodes: ctx.doc.nodes,
+            edges: ctx.doc.edges,
+            meta: ctx.doc.meta
+          }
+        },
+        { retry: false }
+      )
+      if (
+        saved.version !== ctx.doc.version + 1 ||
+        !isDeepStrictEqual(
+          fields(saved.nodes?.find((n) => n.id === ctx.node.id) || {}),
+          expected
+        )
+      )
+        throw new Error('保存响应不完整')
+    } catch (error) {
+      record.state = 'sync_pending'
+      await persist(record)
+      throw fail(
+        'DELIVERY_SYNC_PENDING',
+        '原最终提示词已完成，画布保存未确认；恢复只同步原结果，不重新生成',
+        error
+      )
+    }
+  }
+  record.canvasSynced = true
+  await persist(record)
+  return summary(record, ctx)
+}
+export async function waitDelivery(
+  client,
+  profile,
+  operation,
+  interval = 2000,
+  timeout = 180000
+) {
+  if (![interval, timeout].every((v) => Number.isSafeInteger(v) && v > 0))
+    throw new Error('等待参数必须为正整数')
+  const deadline = Date.now() + timeout
+  while (Date.now() < deadline) {
+    const result = await recoverDelivery(client, profile, operation)
+    if (['completed', 'completed_fallback'].includes(result.state))
+      return result
+    if (result.state === 'failed')
+      throw fail('TASK_FAILED', '原最终提示词任务失败，不自动重做')
+    if (!result.processing_submitted) return result
+    await sleep(
+      Math.min(interval, Math.max(1, deadline - Date.now())),
+      undefined,
+      {
+        signal: cancellation.signal
+      }
+    )
+  }
+  throw fail('WAIT_TIMEOUT', '最终提示词等待超时；继续原operation，不重新提交')
+}