The all-in-one local AI studio for your desktop: chat, image and video generation and a coding agent in one free, open source app. Windows and Linux. No Docker, no terminal, no cloud required.
TypeScript agentai-chatai-studioall-in-onecoding-agentdesktop-appfluximage-generationlinuxllmlocal-ailocal-llmopen-sourceprivacyself-hostedstable-diffusionuncensoreduncensored-aivideo-generationwindows
// MIRRORED from the web app (lib/create/order.ts), without its comments. Do not edit here.
// scripts/create-chat-mirror.mjs writes this file, and web-parity.test.ts
// holds it to its source. Only the import paths differ, the places listed
// under PATCHES in that script, and the classes under CLASSES.
import type { CreateIntent } from './bridge/create-store'
import type { CloudJob, CloudJobParams, CloudJobSubmit, UploadRole } from './bridge/cloud-jobs'
import type { RenderKind } from '../render/cloud-jobs'
import { cloudModelById, resolveCharacterModel } from './bridge/cloud-models'
import { pricesByInput } from '../render/create-studio'
import {
STUDIO_MODELS, studioCredits, studioFields, studioOptions, studioSchema, type StudioModel,
} from '../render/studio-contract'
import { mediaCredits, lengthPrice, lengthCredits } from './bridge/credits'
import { modelLabel, type StepRole } from './bridge/preset-models'
import type { CreatePreset } from '../render/create-presets'
import { dataUrlToBlob } from '../render/data-url'
import { errorText } from '../../types/json-guards'
import type { OrderItemStatus, OrderItemView, OrderStepView, OrderView } from '../../components/chat/create/types'
import { blockMessageFor } from '../render/safety'
import {
EXTEND_NEEDS_RESULT, adoptResult, buildCreateParams, buildPresetStepParams, createJobSubmit, describeSubmitError, failedJobText,
presetAdoptRole, presetEstimate, presetSlotFor, presetStepSubmit, presetUploadRole, requestStudioQuote,
resolveCreateJob, resolvePresetStep, runCloudJob, validateCreateJob, CreateInputError, PROMPT_MISSING,
type CreateDeps, type CreateInputs, type CreateRequest, type MediaRef, type PromptSafetyCheck,
type ResolvedPresetStep, type RunDeps,
} from './engine'
import {
HandleError, resolveHandle, validHandlesText, type HandleContext, type HandleItem, type MediaKind,
} from './handles'
import {
ERASE_REFUSAL, IMAGE_ASPECTS, INTENT_KIND, INTENT_LABEL, VIDEO_ASPECTS, checkOptions, classicOptions,
intentModels, presetById, speechModels, stepClassicOptions, visible, visiblePresets,
type ChatModel,
} from './chat-catalog'
export type InputSpec = Record<string, string | string[]>
export interface IntentItemSpec {
intent: string
prompt?: string
model?: string
inputs?: InputSpec
options?: Record<string, unknown>
}
export interface StepSpec {
prompt?: string
model?: string
inputs?: InputSpec
options?: Record<string, unknown>
}
export interface PresetItemSpec {
preset: string
steps?: StepSpec[]
}
export interface SpeechItemSpec {
speech: string
model?: string
reference?: string
options?: Record<string, unknown>
}
export type ItemSpec = IntentItemSpec | PresetItemSpec | SpeechItemSpec
export class OrderSpecError extends Error {
constructor(message: string) {
super(message)
this.name = 'OrderSpecError'
}
}
export type OrderState = 'awaiting' | 'running' | 'done' | 'stopped' | 'declined' | 'repricing'
export type RunStatus = 'waiting' | 'queued' | 'running' | 'done' | 'failed'
export type PriceSource = 'table' | 'quote' | 'formula' | 'estimate'
export interface RunPrice {
credits: number
estimated: boolean
source: PriceSource
assumedSeconds?: number
}
export interface RunInput {
handle: string
kind: MediaKind
}
export interface OrderRun {
engine: 'create' | 'step'
title: string
model: string
kind: MediaKind
prompt: string
options: Record<string, unknown>
inputs: Record<string, RunInput | RunInput[]>
intent?: CreateIntent
characterTab?: 'train' | 'use'
character?: { id: string; family: string } | null
role?: StepRole
presetId?: string
stepIndex?: number
carry?: string
price: RunPrice
approvedCredits?: number
requoted?: number
outputSeconds?: number
requestId?: string
status: RunStatus
jobId?: string
resultUrl?: string
spent?: number
interrupted?: boolean
stoppedLate?: boolean
lostTrack?: boolean
refunded?: boolean
error?: string
}
export interface OrderItem {
n: number
type: 'intent' | 'preset' | 'speech'
title: string
detail: string
kind: MediaKind
runs: OrderRun[]
}
export interface Order {
id: string
conversationId: string
createdAt: number
state: OrderState
items: OrderItem[]
spentBefore: number
approvedAt?: number
note?: string
}
export interface PlanContext {
conversationId: string
handles: Omit<HandleContext, 'items'>
openAllowed: boolean
characters: { id: string; name: string; family: string }[]
checkSafety: PromptSafetyCheck
spentBefore: number
now: number
newId: () => string
}
export type PriceDeps = Pick<CreateDeps, 'fetch' | 'signal'>
export const ASSUMED_INPUT_SECONDS = 10
const CHARS_PER_SECOND = 15
const MAX_ITEMS = 8
const SLOT_KIND: Record<string, MediaKind> = {
source: 'image', video: 'video', audio: 'audio', extend: 'video', clip: 'video', train: 'image',
}
const CREATE_SLOT_NAME: Record<string, string> = {
image: 'source', video: 'video', audio: 'audio', photos: 'train',
}
function spec(error: string): never {
throw new OrderSpecError(error)
}
/** What a chat order may render. 3D models (3.1.0) are made in the Create tab
* only: chat results are images, clips and tracks. */
function chatKind(kind: RenderKind): MediaKind {
if (kind === '3d') spec('3D models are made in the Create tab, not in chat.')
return kind
}
function isIntent(s: ItemSpec): s is IntentItemSpec {
return typeof (s as IntentItemSpec).intent === 'string'
}
function isPreset(s: ItemSpec): s is PresetItemSpec {
return typeof (s as PresetItemSpec).preset === 'string'
}
function isSpeech(s: ItemSpec): s is SpeechItemSpec {
return typeof (s as SpeechItemSpec).speech === 'string'
}
export function routeCredits(submit: CloudJobSubmit): number {
const { kind, model, params } = submit
const seconds = kind === 'video'
? (typeof params.frames === 'number' && params.frames > 0
? params.frames / (typeof params.fps === 'number' && params.fps > 0 ? params.fps : 16)
: undefined)
: kind === 'audio' ? params.duration : undefined
const withLora = Array.isArray(params.loras) && params.loras.length > 0
return mediaCredits(kind, model, seconds, params.op, params.target_resolution, withLora)
}
function studioRequiredFields(model: string): string[] {
const required = studioSchema(model).required ?? []
return Object.keys(STUDIO_MODELS[model].inputs).filter((f) => required.includes(f))
}
function measuredSeconds(inputs: Record<string, RunInput | RunInput[]>, known: (handle: string) => number | undefined, order?: unknown): number {
const one = (key: string) => {
const v = inputs[key]
return v && !Array.isArray(v) ? known(v.handle) ?? ASSUMED_INPUT_SECONDS : undefined
}
const video = one('video_path') ?? one('video') ?? one('clip') ?? one('extend')
if (video !== undefined) return video
const left = one('audio_path') ?? one('audio')
const right = one('audio2_path')
if (left !== undefined && right !== undefined) return order === 'meanwhile' || order === undefined ? Math.max(left, right) : left + right
return left ?? ASSUMED_INPUT_SECONDS
}
function classicPrice(
model: string,
op: string | undefined,
table: number,
prompt: string,
inputs: Record<string, RunInput | RunInput[]>,
known: (handle: string) => number | undefined,
): RunPrice {
const rate = lengthPrice(model, op)
if (!rate || rate.basis === 'extension') return { credits: table, estimated: false, source: 'table' }
if (rate.basis === 'chars') return { credits: lengthCredits(model, Array.from(prompt).length), estimated: false, source: 'table' }
const keys = rate.basis === 'audio' ? ['audio_path', 'audio'] : ['video_path', 'video', 'clip']
const input = keys.map((k) => inputs[k]).find((v): v is RunInput => !!v && !Array.isArray(v))
const seconds = (input && known(input.handle)) ?? ASSUMED_INPUT_SECONDS
return { credits: lengthCredits(model, seconds), estimated: true, source: 'estimate', assumedSeconds: seconds }
}
async function studioPrice(
model: string,
prompt: string,
options: Record<string, unknown>,
quoteParams: CloudJobParams,
seconds: number,
imageCount: number,
deps: PriceDeps,
): Promise<RunPrice> {
const filled = studioOptions(model, prompt, options, false)
const formula = (s?: number) => studioCredits(model, filled, s, imageCount, Array.from(prompt).length)
if (pricesByInput(model)) {
return { credits: formula(seconds), estimated: true, source: 'estimate', assumedSeconds: seconds }
}
if (!studioRequiredFields(model).length) {
try {
const quote = await requestStudioQuote(model, prompt, quoteParams, deps)
return { credits: quote.credits, estimated: false, source: 'quote' }
} catch {
return { credits: formula(), estimated: true, source: 'formula' }
}
}
return { credits: formula(), estimated: false, source: 'formula' }
}
function studioOutputSeconds(m: StudioModel, options: Record<string, unknown>, fallback?: number): number | undefined {
if (m.price.mode === 'output' && m.kind !== 'image') {
const raw = Number(options[m.price.durationField ?? 'duration'])
if (Number.isFinite(raw) && raw > 0) return raw / (m.price.unitDivisor ?? 1)
}
return fallback
}
interface Planner {
ctx: PlanContext
deps: PriceDeps
items: OrderItem[]
carrySeconds?: number
}
function inputFor(p: Planner, slot: string, handle: unknown, kind: MediaKind): RunInput {
const hctx: HandleContext = { ...p.ctx.handles, items: p.items.map(asHandleItem) }
try {
const hit = resolveHandle(handle, hctx)
if (hit.kind !== kind) {
spec(`Input "${slot}" needs ${kind === 'image' ? 'an image' : `a ${kind === 'video' ? 'clip' : 'sound track'}`}, `
+ `but ${hit.handle} is ${hit.kind === 'image' ? 'an image' : hit.kind === 'video' ? 'a clip' : 'a sound track'}. `
+ validHandlesText(hctx, kind))
}
return { handle: hit.handle, kind }
} catch (err) {
if (err instanceof HandleError) spec(`Input "${slot}": ${err.message}`)
throw err
}
}
function asHandleItem(item: OrderItem): HandleItem {
return { n: item.n, kind: item.kind, title: item.title }
}
function knownSeconds(p: Planner) {
return (handle: string): number | undefined => {
const m = /^item:(\d+)$/.exec(handle)
if (!m) return undefined
const item = p.items.find((i) => i.n === Number(m[1]))
return item?.runs[item.runs.length - 1]?.outputSeconds
}
}
export function coerceOptionValues(
options: Record<string, unknown>,
typeOf: (key: string) => { type?: string; enum?: readonly unknown[] } | undefined,
): Record<string, unknown> {
const out: Record<string, unknown> = {}
for (const [key, value] of Object.entries(options)) {
const t = typeOf(key)
let v = value
if (typeof value === 'string' && t) {
const text = value.trim()
const numeric = text !== '' && Number.isFinite(Number(text))
if ((t.type === 'integer' || t.type === 'number') && numeric) v = Number(text)
else if (t.type === 'boolean' && (text === 'true' || text === 'false')) v = text === 'true'
else if (t.enum?.some((e) => typeof e === 'number') && numeric && !t.enum.includes(value)) v = Number(text)
}
out[key] = v
}
return out
}
function pickModel(list: ChatModel[], wanted: string | undefined, openAllowed: boolean, what: string): ChatModel {
const allowed = visible(list, openAllowed)
if (!wanted) {
if (!allowed.length) spec(`${what} has no model available for this account.`)
return allowed[0]
}
const hit = list.find((m) => m.id === wanted)
if (!hit) spec(`Unknown model "${wanted}" for ${what}. Allowed: ${allowed.map((m) => m.id).join(', ')}.`)
if (hit.adult && !openAllowed) {
spec(`"${wanted}" is not available for this account. Allowed: ${allowed.map((m) => m.id).join(', ')}.`)
}
return hit
}
function checkPrompt(p: Planner, text: string, negative?: string): void {
const verdict = p.ctx.checkSafety(text, negative)
if (verdict.blocked) spec(blockMessageFor(verdict.reason))
}
function inputNames(list: string[]): string {
return list.length ? list.join(', ') : 'none'
}
export function imageSlotFor(name: string, slots: string[], imageSlots: string[]): string {
if (slots.includes(name) || (name !== 'image' && name !== 'images')) return name
const other = name === 'image' ? 'images' : 'image'
return imageSlots.length === 1 && imageSlots[0] === other ? other : name
}
function aliasedValue(value: string | string[], aliased: boolean): string | string[] {
return aliased && Array.isArray(value) && value.length === 1 ? value[0] : value
}
async function planCreate(p: Planner, s: IntentItemSpec, intent: CreateIntent, model: ChatModel | null): Promise<OrderRun> {
const prompt = (s.prompt ?? '').trim()
const modelId = model?.id ?? ''
const studio = model ? STUDIO_MODELS[model.id] : undefined
const classic = classicOptions(intent, modelId)
const options = coerceOptionValues({ ...(s.options ?? {}) }, (key) => (studio ? studioFields(modelId)[key] : classic[key]))
const mode = intent === 'character' ? (options.mode ?? 'train') : undefined
if (studio) {
try { studioOptions(modelId, prompt, options, false) } catch (err) { spec(errorText(err)) }
} else {
try { checkOptions(options, classic) } catch (err) { spec(errorText(err)) }
}
let character: { id: string; family: string } | null = null
let useModel = modelId
if (intent === 'character' && mode === 'use') {
const shelf = p.ctx.characters.find((c) => c.id === options.character)
if (!shelf) {
spec(p.ctx.characters.length
? `Option "character" must be one of: ${p.ctx.characters.map((c) => `${c.id} (${c.name})`).join(', ')}.`
: 'There is no trained character yet. Train one first (intent "character", mode "train").')
}
character = { id: shelf.id, family: shelf.family }
useModel = resolveCharacterModel(shelf.family, '') ?? ''
if (!useModel) spec('This character has no compatible generation model yet.')
}
const given = s.inputs ?? {}
const inputs: Record<string, RunInput | RunInput[]> = {}
const allowedSlots = createSlots(intent, modelId)
const imageSlots = allowedSlots.filter((n) => SLOT_KIND[CREATE_SLOT_NAME[n]] === 'image')
for (const [name, raw] of Object.entries(given)) {
const known = imageSlotFor(name, allowedSlots, imageSlots)
if (known !== name && given[known] !== undefined) spec(`Input "${name}" is the same place as "${known}". Give one of them.`)
const value = aliasedValue(raw, known !== name)
const slot = CREATE_SLOT_NAME[known]
const place = intent === 'extend' && slot === 'video' ? 'extend' : intent === 'video_upscale' && slot === 'video' ? 'clip' : slot
if (!slot || !allowedSlots.includes(known)) {
spec(`Input "${name}" is not used by ${INTENT_LABEL[intent]}${modelId ? ` on ${modelId}` : ''}. Inputs: ${inputNames(allowedSlots)}.`)
}
if (place === 'train') {
const list = Array.isArray(value) ? value : [value]
inputs.train = list.map((h) => inputFor(p, name, h, 'image'))
} else {
if (Array.isArray(value)) spec(`Input "${name}" takes one handle, not a list.`)
inputs[place] = inputFor(p, name, value, SLOT_KIND[place])
}
}
const extendInput = inputs.extend
if (intent === 'extend' && !studio && extendInput && !Array.isArray(extendInput) && extendInput.handle.startsWith('att:')) {
spec(`Input "video": ${EXTEND_NEEDS_RESULT}`)
}
const width = intent === 'video' ? VIDEO_ASPECTS[String(options.aspect ?? '16:9')].width
: intent === 'animate' ? 1280 : IMAGE_ASPECTS[String(options.aspect ?? '1:1')]?.width ?? 1024
const height = intent === 'video' ? VIDEO_ASPECTS[String(options.aspect ?? '16:9')].height
: intent === 'animate' ? 720 : IMAGE_ASPECTS[String(options.aspect ?? '1:1')]?.height ?? 1024
const seconds = typeof options.duration === 'number' ? options.duration : 5
const req: CreateRequest = {
...emptyRequest(intent),
characterTab: mode === 'use' ? 'use' : 'train',
cloudImageModel: ['image', 'edit', 'removebg', 'upscale'].includes(intent) ? modelId : '',
cloudVideoModel: intent === 'video' || intent === 'animate' ? modelId : '',
cloudOpModel: ['image', 'edit', 'removebg', 'upscale', 'video', 'animate'].includes(intent) ? '' : (mode === 'use' ? useModel : modelId),
prompt,
negativePrompt: typeof options.negative_prompt === 'string' ? options.negative_prompt : '',
width, height,
seed: typeof options.seed === 'number' ? options.seed : -1,
frames: seconds * 16, fps: 16,
musicDuration: typeof options.duration === 'number' ? options.duration : 60,
musicLyrics: typeof options.lyrics === 'string' ? options.lyrics : '',
triggerWord: typeof options.trigger_word === 'string' ? options.trigger_word : '',
character,
studioOptions: studio ? options : {},
studioCredits: null,
inputs: placeholderInputs(inputs),
}
const resolved = resolveCreateJob(req)
if (model && resolved.model !== (mode === 'use' ? useModel : modelId)) spec(`"${modelId}" cannot run ${INTENT_LABEL[intent]}.`)
const invalid = validateCreateJob(resolved, req, p.ctx.checkSafety)
if (invalid) spec(inputHint(invalid, intent, allowedSlots))
const params = await buildCreateParams(resolved, req, dryDeps)
const submit = createJobSubmit(resolved, req, params)
let price: RunPrice
let outputSeconds: number | undefined
if (resolved.studioModel) {
const m = STUDIO_MODELS[resolved.studioModel]
const measured = measuredSeconds(inputs, knownSeconds(p))
price = await studioPrice(resolved.studioModel, prompt, options, { op: 'studio', studio_options: params.studio_options ?? {} }, measured, 1, p.deps)
outputSeconds = studioOutputSeconds(m, studioOptions(resolved.studioModel, prompt, options, false), pricesByInput(resolved.studioModel) ? measured : undefined)
} else {
price = classicPrice(submit.model, params.op, routeCredits(submit), prompt, inputs, knownSeconds(p))
outputSeconds = resolved.kind === 'video' && typeof params.frames === 'number' ? params.frames / (params.fps ?? 16)
: resolved.kind === 'audio' ? params.duration : undefined
}
return {
engine: 'create',
title: INTENT_LABEL[intent],
model: resolved.model,
kind: resolved.op === 'lora-train' ? 'image' : chatKind(resolved.kind),
prompt,
options,
inputs,
intent,
characterTab: req.characterTab,
character,
price,
outputSeconds,
status: 'waiting',
}
}
export function createSlots(intent: CreateIntent, model: string): string[] {
switch (intent) {
case 'edit': case 'removebg': case 'upscale': case 'animate': return ['image']
case 'extend': case 'video_upscale': return ['video']
case 'motion': return ['image', 'video']
case 'character': return ['photos']
case 'lipsync': {
const clip = cloudModelById(model)?.lipsyncSource === 'video'
if (clip) return ['video', 'audio']
if (STUDIO_MODELS[model] && !STUDIO_MODELS[model].inputs.image) return ['audio']
return ['image', 'audio']
}
default: return []
}
}
function inputHint(message: string, intent: CreateIntent, slots: string[]): string {
if (message === PROMPT_MISSING) return `${INTENT_LABEL[intent]} has no prompt. Put what to create into "prompt" of this item.`
return slots.length ? `${message} ${INTENT_LABEL[intent]} inputs: ${slots.join(', ')} (handles).` : message
}
function emptyRequest(intent: CreateIntent): CreateRequest {
return {
intent, characterTab: 'train', cloudImageModel: '', cloudVideoModel: '', cloudOpModel: '', prompt: '',
negativePrompt: '', width: 1024, height: 1024, steps: 20, cfg: 7, seed: -1, denoise: 0.7, growMaskBy: 6,
frames: 80, fps: 16, musicDuration: 60, musicLyrics: '', triggerWord: '', character: null, studioOptions: {},
studioCredits: null, inputs: {},
}
}
function placeholderInputs(inputs: Record<string, RunInput | RunInput[]>): CreateInputs {
const out: CreateInputs = {}
const job = (i: number) => ({ type: 'job' as const, jobId: `placeholder-${i}` })
for (const [slot, value] of Object.entries(inputs)) {
if (slot === 'train') out.train = (value as RunInput[]).map((_, i) => job(i))
else (out as Record<string, unknown>)[slot] = job(0)
}
return out
}
const dryDeps: Pick<CreateDeps, 'uploadInput' | 'adoptInput' | 'getJob'> = {
uploadInput: async (_file, role) => `placeholder/${role}`,
adoptInput: async (jobId, role) => `placeholder/${jobId}-${role}`,
getJob: async (id) => ({ id, result_url: 'https://placeholder.invalid/result' }) as CloudJob,
}
async function planStep(
p: Planner,
preset: CreatePreset,
index: number,
s: StepSpec,
carryFrom: MediaKind | null,
title: string,
): Promise<OrderRun> {
const raw = preset.steps[index]
const alternatives = visible(presetModelsFor(preset, index), p.ctx.openAllowed)
if (s.model !== undefined && !alternatives.some((m) => m.id === s.model)) {
spec(`Unknown model "${s.model}" for ${title}. Allowed: ${alternatives.map((m) => m.id).join(', ')}.`)
}
const picked = s.model ?? (alternatives.some((m) => m.id === raw.model) ? raw.model : alternatives[0]?.id)
if (!picked) spec(`${title} has no model available for this account.`)
const r = resolvePresetStep(preset, index, picked)
const prompt = (s.prompt ?? '').trim()
const classic = stepClassicOptions(raw.role, r.step.model)
const options = coerceOptionValues({ ...(s.options ?? {}) }, (key) => (r.studio ? r.fields[key] : classic[key]))
if (r.studio) {
try { studioOptions(r.step.model, prompt, options, false) } catch (err) { spec(errorText(err)) }
} else {
try { checkOptions(options, classic) } catch (err) { spec(errorText(err)) }
}
const carry = carryFrom ? presetSlotFor(r, carryFrom) : undefined
const fields = stepFields(r)
const inputs: Record<string, RunInput | RunInput[]> = {}
const imageFields = Object.keys(fields).filter((n) => keyKind(fields[n]) === 'image')
for (const [name, raw] of Object.entries(s.inputs ?? {})) {
const known = imageSlotFor(name, Object.keys(fields), imageFields)
if (known !== name && s.inputs?.[known] !== undefined) spec(`Input "${name}" is the same place as "${known}". Give one of them.`)
const value = aliasedValue(raw, known !== name)
const key = fields[known]
if (!key) spec(`Input "${name}" is not used by ${title} on ${r.step.model}. Inputs: ${inputNames(Object.keys(fields))}.`)
if (key === carry) spec(`Input "${name}" of ${title} comes from the previous step.`)
const kind = keyKind(key)
if (key === 'image_paths') {
inputs[key] = (Array.isArray(value) ? value : [value]).map((h) => inputFor(p, name, h, kind))
} else {
if (Array.isArray(value)) spec(`Input "${name}" takes one handle, not a list.`)
inputs[key] = inputFor(p, name, value, kind)
}
}
const missing = r.required.filter((key) => key !== carry && !inputs[key])
if (!r.studio && raw.role === 'extend' && carry !== 'source_url' && !inputs.source_url) missing.push('source_url')
if (missing.length) {
const names = Object.entries(fields).filter(([, key]) => missing.includes(key)).map(([name]) => name)
spec(`${title} on ${r.step.model} needs: ${names.join(', ')} (handles).`)
}
const promptNeeded = r.studio
? (studioSchema(r.step.model).required ?? []).includes(r.studio.promptField ?? 'prompt')
: ['image', 'animate', 'speech', 'music', 'extend', 'edit', 'restyle'].includes(raw.role)
if (promptNeeded && !prompt) spec(`${title} has no ${raw.role === 'speech' ? 'text to speak' : 'prompt'}. Put it into "prompt" of that step.`)
if (!r.studio && raw.role === 'speech' && r.step.model === 'qwen3-tts-design' && !options.voice_description) {
spec(`${title} on qwen3-tts-design needs option "voice_description".`)
}
// The negative prompt the model wrote goes apart: it is where a model puts
// "child, underage" to keep them OUT (B30, safety.ts).
const { negative_prompt: negative, ...rest } = options
checkPrompt(
p,
`${prompt} ${Object.values(rest).filter((v) => typeof v === 'string').join(' ')}`,
typeof negative === 'string' ? negative : undefined,
)
const placeholder: Record<string, string | string[]> = {}
for (const key of [...Object.keys(inputs), ...(carry ? [carry] : [])]) {
placeholder[key] = key === 'image_paths' ? ['placeholder'] : key === 'source_url' ? 'https://placeholder.invalid/clip.mp4' : 'placeholder'
}
const images = Array.isArray(inputs.image_paths) ? inputs.image_paths.length : 1
let price: RunPrice
let outputSeconds: number | undefined
const measureOf = { ...inputs, ...(carry && carryFrom ? { [carry]: { handle: 'carry', kind: carryFrom } } : {}) }
const known = (h: string) => (h === 'carry' ? p.carrySeconds : knownSeconds(p)(h))
const measured = measuredSeconds(measureOf, known, options.order)
if (r.studio) {
price = await studioPrice(r.step.model, prompt, options, buildPresetStepParams(r, {}, options), measured, images, p.deps)
const filled = studioOptions(r.step.model, prompt, options, false)
outputSeconds = r.step.kind === 'audio' && r.studio.price.mode === 'characters'
? Math.max(1, Math.ceil(Array.from(prompt).length / CHARS_PER_SECOND))
: studioOutputSeconds(r.studio, filled, pricesByInput(r.step.model) ? measured : undefined)
} else {
const credits = presetEstimate(r, prompt, options, placeholder) ?? 0
price = classicPrice(r.step.model, r.step.op, credits, prompt, measureOf, known)
const p2 = buildPresetStepParams(r, placeholder, options)
outputSeconds = r.step.kind === 'video' && typeof p2.frames === 'number' ? p2.frames / (p2.fps ?? 16)
: raw.role === 'speech' ? Math.max(1, Math.ceil(Array.from(prompt).length / CHARS_PER_SECOND)) : undefined
}
return {
engine: 'step',
title,
model: r.step.model,
kind: chatKind(r.step.kind),
prompt,
options,
inputs,
role: raw.role,
presetId: preset.id,
stepIndex: index,
carry,
price,
outputSeconds,
status: 'waiting',
}
}
function keyKind(key: string): MediaKind {
return key.includes('audio') ? 'audio' : key === 'video_path' || key === 'source_url' ? 'video' : 'image'
}
export function stepFields(r: ResolvedPresetStep): Record<string, string> {
const fields = { ...r.inputs }
if (!r.studio && r.raw.role === 'extend') fields.video = 'source_url'
return fields
}
function presetModelsFor(preset: CreatePreset, index: number): ChatModel[] {
return resolvePresetStep(preset, index).alternatives.map((m) => ({
id: m.id, label: m.label, kind: m.kind, adult: m.adult, engine: 'step' as const, role: preset.steps[index].role,
}))
}
export function roleStep(role: StepRole, model: string, title: string): CreatePreset {
const kind = STUDIO_MODELS[model]?.kind ?? cloudModelById(model)?.kind ?? 'image'
return {
id: `chat-${role}`, title, summary: '', category: 'Video', adult: false, accent: '',
steps: [{ model, kind, op: STUDIO_MODELS[model] ? 'studio' : 'generate', title, role }],
}
}
async function planItem(p: Planner, s: ItemSpec, n: number): Promise<OrderItem> {
if (isSpeech(s)) {
const model = pickModel(speechModels(), s.model, p.ctx.openAllowed, 'Speech')
const inputs: InputSpec = {}
if (s.reference !== undefined) {
const field = Object.entries(resolvePresetStep(roleStep('speech', model.id, 'Speech'), 0, model.id).inputs)[0]?.[0]
if (!field) {
const cloning = speechModels().filter((m) => Object.keys(resolvePresetStep(roleStep('speech', m.id, 'Speech'), 0, m.id).inputs).length)
spec(`"${model.id}" does not take a reference voice. Models that do: ${cloning.map((m) => m.id).join(', ')}.`)
}
inputs[field] = s.reference
}
const run = await planStep(p, roleStep('speech', model.id, 'Speech'), 0, { prompt: s.speech, model: model.id, inputs, options: s.options }, null, 'Speech')
return { n, type: 'speech', title: 'Speech', detail: `Voice · ${modelLabel(run.model)}`, kind: 'audio', runs: [run] }
}
if (isPreset(s)) {
const preset = presetById(s.preset)
if (!preset || (preset.adult && !p.ctx.openAllowed)) {
spec(`Unknown preset "${s.preset}". Presets: ${visiblePresets(p.ctx.openAllowed).map((x) => x.id).join(', ')}.`)
}
const steps = s.steps ?? []
if (steps.length > preset.steps.length) spec(`Preset "${preset.id}" has ${preset.steps.length} step(s), not ${steps.length}.`)
const runs: OrderRun[] = []
p.carrySeconds = undefined
for (let i = 0; i < preset.steps.length; i++) {
const title = preset.steps[i].title
const run = await planStep(p, preset, i, steps[i] ?? {}, i > 0 ? runs[i - 1].kind : null, title)
p.carrySeconds = run.outputSeconds
runs.push(run)
}
const last = runs[runs.length - 1]
return {
n, type: 'preset', title: preset.title,
detail: runs.length > 1 ? `Preset · ${runs.length} steps` : `Preset · ${modelLabel(last.model)}`,
kind: last.kind, runs,
}
}
if (!isIntent(s)) spec('Each item needs "intent", "preset" or "speech".')
const intent = s.intent as CreateIntent
if (intent === 'eraser') spec(ERASE_REFUSAL)
if (!INTENT_KIND[intent]) {
spec(`Unknown intent "${s.intent}". Intents: ${Object.keys(INTENT_LABEL).filter((i) => i !== 'eraser').join(', ')}.`)
}
const list = intentModels(intent)
if (!list.length) {
if (s.model !== undefined) spec(`${INTENT_LABEL[intent]} has no model choice. Leave "model" out.`)
const run = await planCreate(p, s, intent, null)
return { n, type: 'intent', title: INTENT_LABEL[intent], detail: INTENT_LABEL[intent], kind: run.kind, runs: [run] }
}
const model = pickModel(list, s.model, p.ctx.openAllowed, INTENT_LABEL[intent])
if (model.engine === 'step' && model.role) {
const run = await planStep(p, roleStep(model.role, model.id, INTENT_LABEL[intent]), 0,
{ prompt: s.prompt, model: model.id, inputs: s.inputs, options: s.options }, null, INTENT_LABEL[intent])
return { n, type: 'intent', title: INTENT_LABEL[intent], detail: `${INTENT_LABEL[intent]} · ${model.label}`, kind: run.kind, runs: [run] }
}
checkPrompt(p, `${s.prompt ?? ''}`)
const run = await planCreate(p, s, intent, model)
return { n, type: 'intent', title: INTENT_LABEL[intent], detail: `${detailFor(run)} · ${modelLabel(run.model)}`, kind: run.kind, runs: [run] }
}
function detailFor(run: OrderRun): string {
if (run.kind === 'video' && run.outputSeconds) return `Clip ${run.outputSeconds} s`
if (run.kind === 'audio' && run.outputSeconds) return `Track ${run.outputSeconds} s`
return run.title
}
export async function planOrder(specs: ItemSpec[], ctx: PlanContext, deps: PriceDeps): Promise<Order> {
if (!Array.isArray(specs) || specs.length === 0) spec('An order needs at least one item.')
if (specs.length > MAX_ITEMS) spec(`An order takes at most ${MAX_ITEMS} items.`)
const p: Planner = { ctx, deps, items: [] }
for (const [i, s] of specs.entries()) {
try {
p.items.push(await planItem(p, s, i + 1))
} catch (err) {
if (err instanceof OrderSpecError) throw new OrderSpecError(`Item ${i + 1}: ${err.message}`)
if (err instanceof CreateInputError) throw new OrderSpecError(`Item ${i + 1}: ${err.message}`)
throw err
}
}
return {
id: ctx.newId(),
conversationId: ctx.conversationId,
createdAt: ctx.now,
state: 'awaiting',
items: p.items,
spentBefore: ctx.spentBefore,
}
}
export function runCredits(run: OrderRun): number {
return run.requoted ?? run.approvedCredits ?? run.price.credits
}
export interface OrderSum {
order: number
estimated: boolean
spentBefore: number
together: number
}
export function orderSum(order: Order): OrderSum {
let sum = 0
let estimated = false
for (const item of order.items) for (const run of item.runs) {
if (run.status === 'done') { sum += run.spent ?? runCredits(run); continue }
if (run.status === 'failed') continue
sum += runCredits(run)
if (run.price.estimated) estimated = true
}
return { order: sum, estimated, spentBefore: order.spentBefore, together: order.spentBefore + sum }
}
export function conversationSpent(orders: Order[]): number {
let sum = 0
for (const o of orders) for (const item of o.items) for (const run of item.runs) {
if (run.status === 'done') sum += run.spent ?? 0
}
return sum
}
export function orderDifference(order: Order): { item: number; credits: number; approved: number; difference: number } | null {
if (order.state !== 'repricing') return null
for (const item of order.items) for (const run of item.runs) {
if (run.requoted !== undefined) {
const approved = run.approvedCredits ?? run.price.credits
return { item: item.n, credits: run.requoted, approved, difference: run.requoted - approved }
}
}
return null
}
export function approveOrder(order: Order, now: number): Order {
if (order.state !== 'awaiting') return order
return {
...order,
state: 'running',
approvedAt: now,
items: order.items.map((item) => ({
...item,
runs: item.runs.map((run) => ({ ...run, approvedCredits: run.price.credits })),
})),
}
}
export function declineOrder(order: Order): Order {
return order.state === 'awaiting' ? { ...order, state: 'declined' } : order
}
export function approveDifference(order: Order): Order {
if (order.state !== 'repricing') return order
return {
...order,
state: 'running',
note: undefined,
items: order.items.map((item) => ({
...item,
runs: item.runs.map((run) => (run.requoted !== undefined
? { ...run, approvedCredits: run.requoted, requoted: undefined, error: undefined }
: run)),
})),
}
}
export class OrderNotApprovedError extends Error {
constructor() {
super('This order has not been approved. Nothing was started and nothing was charged.')
this.name = 'OrderNotApprovedError'
}
}
export interface ExecuteDeps extends RunDeps, Pick<CreateDeps, 'uploadInput' | 'adoptInput' | 'getJob'> {
handles: () => Omit<HandleContext, 'items'>
signal?: AbortSignal
onUpdate: (order: Order) => void
newRequestId: () => string
}
export function timeoutFor(run: OrderRun): number {
if (run.engine === 'step') return 125 * 60_000
return run.kind === 'video' || run.intent === 'character' ? 45 * 60_000 : 15 * 60_000
}
function itemResult(order: Order, n: number): { jobId: string; kind: MediaKind } | undefined {
const item = order.items.find((i) => i.n === n)
const last = item?.runs[item.runs.length - 1]
return last?.status === 'done' && last.jobId ? { jobId: last.jobId, kind: last.kind } : undefined
}
function mediaOf(order: Order, input: RunInput, deps: ExecuteDeps, before: number): MediaRef {
const items = order.items.filter((i) => i.n < before).map(asHandleItem)
const hit = resolveHandle(input.handle, { ...deps.handles(), items })
if (hit.ref.type === 'item') {
const result = itemResult(order, hit.ref.n)
if (!result) throw new Error(`Item ${hit.ref.n} has no result to use.`)
return { type: 'job', jobId: result.jobId }
}
if (hit.ref.type === 'job') return { type: 'job', jobId: hit.ref.jobId }
if (hit.ref.type === 'blob') return { type: 'blob', blob: hit.ref.blob }
return { type: 'dataUrl', url: hit.ref.url }
}
async function stepPaths(order: Order, item: OrderItem, run: OrderRun, index: number, deps: ExecuteDeps): Promise<Record<string, string | string[]>> {
const paths: Record<string, string | string[]> = {}
const stage = async (key: string, ref: MediaRef): Promise<string> => {
if (key === 'source_url') {
if (ref.type !== 'job') throw new Error('The source clip must be one of your results.')
const src = await deps.getJob(ref.jobId)
if (!src.result_url) throw new Error('The source clip has expired. Re-render it first.')
return src.result_url
}
if (ref.type === 'job') return adoptResult(deps.adoptInput, ref.jobId, presetAdoptRole(key))
if (ref.type === 'dataUrl') return deps.uploadInput(await dataUrlToBlob(ref.url), presetUploadRole(key) as UploadRole)
return deps.uploadInput(ref.blob, presetUploadRole(key) as UploadRole)
}
for (const [key, value] of Object.entries(run.inputs)) {
if (Array.isArray(value)) {
const list: string[] = []
for (const v of value) list.push(await stage(key, mediaOf(order, v, deps, item.n)))
paths[key] = list
} else {
paths[key] = await stage(key, mediaOf(order, value, deps, item.n))
}
}
if (run.carry) {
const prev = item.runs[index - 1]
if (!prev?.jobId) throw new Error('The previous step has no result to use.')
const path = await stage(run.carry, { type: 'job', jobId: prev.jobId })
paths[run.carry] = run.carry === 'image_paths' ? [path] : path
}
return paths
}
async function createSubmit(order: Order, item: OrderItem, run: OrderRun, deps: ExecuteDeps, approved: number, requestId: string): Promise<CloudJobSubmit> {
const inputs: CreateInputs = {}
for (const [slot, value] of Object.entries(run.inputs)) {
if (Array.isArray(value)) {
inputs.train = value.map((v) => mediaOf(order, v, deps, item.n)) as CreateInputs['train']
} else {
(inputs as Record<string, unknown>)[slot] = mediaOf(order, value, deps, item.n)
}
}
const o = run.options
const intent = run.intent!
const req: CreateRequest = {
...emptyRequest(intent),
characterTab: run.characterTab ?? 'train',
cloudImageModel: ['image', 'edit', 'removebg', 'upscale'].includes(intent) ? run.model : '',
cloudVideoModel: intent === 'video' || intent === 'animate' ? run.model : '',
cloudOpModel: ['image', 'edit', 'removebg', 'upscale', 'video', 'animate'].includes(intent) ? '' : run.model,
prompt: run.prompt,
negativePrompt: typeof o.negative_prompt === 'string' ? o.negative_prompt : '',
width: intent === 'video' ? VIDEO_ASPECTS[String(o.aspect ?? '16:9')].width : intent === 'animate' ? 1280 : IMAGE_ASPECTS[String(o.aspect ?? '1:1')]?.width ?? 1024,
height: intent === 'video' ? VIDEO_ASPECTS[String(o.aspect ?? '16:9')].height : intent === 'animate' ? 720 : IMAGE_ASPECTS[String(o.aspect ?? '1:1')]?.height ?? 1024,
seed: typeof o.seed === 'number' ? o.seed : -1,
frames: (typeof o.duration === 'number' ? o.duration : 5) * 16,
fps: 16,
musicDuration: typeof o.duration === 'number' ? o.duration : 60,
musicLyrics: typeof o.lyrics === 'string' ? o.lyrics : '',
triggerWord: typeof o.trigger_word === 'string' ? o.trigger_word : '',
character: run.character ?? null,
studioOptions: STUDIO_MODELS[run.model] ? o : {},
studioCredits: approved,
inputs,
}
const resolved = resolveCreateJob(req)
const params = await buildCreateParams(resolved, req, { ...deps, signal: deps.signal })
params.max_credits = approved
params.client_request_id = requestId
return createJobSubmit(resolved, req, params)
}
async function stepSubmit(order: Order, item: OrderItem, run: OrderRun, index: number, deps: ExecuteDeps, approved: number, requestId: string): Promise<CloudJobSubmit> {
const preset = run.presetId && presetById(run.presetId) ? presetById(run.presetId)! : roleStep(run.role!, run.model, run.title)
const r = resolvePresetStep(preset, run.stepIndex ?? 0, run.model)
const paths = await stepPaths(order, item, run, index, deps)
return presetStepSubmit(r, run.prompt, paths, run.options, { credits: approved, requestId })
}
function replaceRun(order: Order, n: number, index: number, patch: Partial<OrderRun>): Order {
return {
...order,
items: order.items.map((item) => (item.n !== n ? item : {
...item,
runs: item.runs.map((run, i) => (i === index ? { ...run, ...patch } : run)),
})),
}
}
export const INTERRUPTED_ERROR = 'Interrupted by a reload.'
export const STOPPED_LATE_ERROR = 'Stopped too late: it was already rendering.'
export const LOST_TRACK_ERROR = 'Still with LU Cloud: its answer did not arrive yet.'
export const INTERRUPTED_NOTE =
'Interrupted by a reload. Finished items stay; an item that was rendering may still finish in your gallery.'
export function markInterrupted(order: Order): Order {
if (order.state !== 'running') return order
return {
...order,
state: 'stopped',
note: INTERRUPTED_NOTE,
items: order.items.map((item) => ({
...item,
runs: item.runs.map((run) => (run.status === 'queued' || run.status === 'running'
? { ...run, status: 'failed' as const, refunded: false, error: INTERRUPTED_ERROR, interrupted: true }
: run)),
})),
}
}
function serverJobId(run: OrderRun): string | undefined {
return run.jobId ?? run.requestId
}
export function interruptedRuns(order: Order): { n: number; index: number; jobId: string }[] {
const out: { n: number; index: number; jobId: string }[] = []
for (const item of order.items) {
item.runs.forEach((run, index) => {
const jobId = serverJobId(run)
if (run.interrupted && jobId) out.push({ n: item.n, index, jobId })
})
}
return out
}
export function resumeInterrupted(order: Order, n: number, index: number): Order {
const run = order.items.find((i) => i.n === n)?.runs[index]
return {
...replaceRun(order, n, index, { status: 'running', error: undefined, refunded: undefined, jobId: run && serverJobId(run) }),
state: 'running', note: undefined,
}
}
export function settleInterrupted(order: Order, n: number, index: number, job: CloudJob): Order {
const run = order.items.find((i) => i.n === n)?.runs[index]
if (!run?.interrupted) return order
const jobId = serverJobId(run)
let next: Order
if (job.status === 'succeeded' && (job.result_url || run.intent === 'character')) {
next = replaceRun(order, n, index, {
status: 'done', jobId, resultUrl: job.result_url ?? undefined, spent: job.cost_units,
error: undefined, refunded: undefined, interrupted: undefined, stoppedLate: undefined, lostTrack: undefined,
})
} else if (job.status === 'canceled') {
next = replaceRun(order, n, index, { status: 'failed', jobId, refunded: true, spent: 0, error: 'Stopped.', interrupted: undefined, stoppedLate: undefined, lostTrack: undefined })
} else if (job.status === 'failed' || job.status === 'succeeded') {
next = replaceRun(order, n, index, { status: 'failed', jobId, refunded: true, spent: 0, error: failedJobText(job), interrupted: undefined, stoppedLate: undefined, lostTrack: undefined })
} else {
return order
}
const runs = next.items.flatMap((i) => i.runs)
if (runs.every((r) => r.status === 'done')) {
return { ...next, state: 'done', note: run.stoppedLate ? `Your stop came after item ${n} had started rendering. It finished and was charged.` : undefined }
}
const finished = next.items.find((i) => i.n === n)?.runs[index].status === 'done'
if (run.stoppedLate) {
return {
...next,
state: 'stopped',
note: finished
? `You stopped this order after item ${n} had started rendering. It finished and was charged; items that had not started were not run and not charged.`
: `You stopped this order. Item ${n} did not finish and was refunded; items that had not started were not run and not charged.`,
}
}
if (run.lostTrack) {
return {
...next,
state: 'stopped',
note: finished
? `Item ${n} has finished on LU Cloud after all and was charged.`
: `Item ${n} did not finish on LU Cloud and was refunded.`,
}
}
return {
...next,
state: 'stopped',
note: finished
? 'The page was reloaded while this order ran. The item that was rendering has finished; items that had not started were not run and not charged.'
: `The page was reloaded while this order ran. Item ${n} did not finish and was refunded; items that had not started were not run and not charged.`,
}
}
export async function executeOrder(start: Order, deps: ExecuteDeps): Promise<Order> {
if (start.state !== 'running' || !start.approvedAt) throw new OrderNotApprovedError()
let order = start
const emit = (next: Order) => { order = next; deps.onUpdate(order) }
for (const item of start.items) {
for (let index = 0; index < item.runs.length; index++) {
const run = order.items.find((i) => i.n === item.n)!.runs[index]
if (run.status === 'done') continue
const approved = run.approvedCredits
if (approved === undefined) throw new OrderNotApprovedError()
if (deps.signal?.aborted) { emit({ ...order, state: 'stopped' }); return order }
const requestId = run.requestId ?? deps.newRequestId()
emit(replaceRun(order, item.n, index, { status: 'queued', requestId, error: undefined }))
let polling = false
try {
const current = order.items.find((i) => i.n === item.n)!
const submit = run.engine === 'create'
? await createSubmit(order, current, run, deps, approved, requestId)
: await stepSubmit(order, current, run, index, deps, approved, requestId)
if (deps.signal?.aborted) { emit({ ...replaceRun(order, item.n, index, { status: 'waiting' }), state: 'stopped' }); return order }
const job = await runCloudJob(submit, deps, {
signal: deps.signal,
timeoutMs: timeoutFor(run),
onSubmitted: (id) => emit(replaceRun(order, item.n, index, { jobId: id })),
onPolling: () => { polling = true },
onTick: (j) => { if (j.status === 'running') emit(replaceRun(order, item.n, index, { status: 'running' })) },
})
if (job.status === 'succeeded' && (job.result_url || run.intent === 'character')) {
emit(replaceRun(order, item.n, index, {
status: 'done', jobId: job.id, resultUrl: job.result_url ?? undefined, spent: job.cost_units,
}))
continue
}
if (job.status === 'canceled') {
emit({ ...replaceRun(order, item.n, index, { status: 'failed', refunded: true, spent: 0, error: 'Stopped.' }), state: 'stopped' })
return order
}
emit({
...replaceRun(order, item.n, index, { status: 'failed', refunded: true, spent: 0, error: failedJobText(job) }),
state: 'stopped', note: `Item ${item.n} failed. Finished items stay, the failed one was refunded.`,
})
return order
} catch (err) {
const failure = describeSubmitError(err)
if (deps.signal?.aborted && failure.kind !== 'aborted' && !order.items.find((i) => i.n === item.n)!.runs[index].jobId) {
emit({
...replaceRun(order, item.n, index, { status: 'waiting' }),
state: 'stopped',
note: 'Stopped. Items that had not started were not charged.',
})
return order
}
if (failure.kind === 'quote_changed' && failure.credits != null) {
emit({
...replaceRun(order, item.n, index, { status: 'waiting', requoted: failure.credits, jobId: undefined }),
state: 'repricing',
note: `Item ${item.n} now costs ${(failure.credits - approved).toLocaleString('en-US')} credits more than approved. Nothing was charged for it.`,
})
return order
}
if (failure.kind === 'aborted') {
const jobId = order.items.find((i) => i.n === item.n)!.runs[index].jobId
let refunded = !polling && !!jobId
if (jobId) {
try {
const res = await deps.cancelJob(jobId) as { refunded?: boolean } | undefined
refunded = res?.refunded !== false
} catch {
refunded = false
}
}
emit({
...replaceRun(order, item.n, index, !jobId
? { status: 'waiting' }
: refunded
? { status: 'failed', refunded: true, spent: 0, error: 'Stopped.' }
: { status: 'failed', refunded: false, error: STOPPED_LATE_ERROR, interrupted: true, stoppedLate: true }),
state: 'stopped',
note: jobId && !refunded
? `Item ${item.n} was already rendering and cannot be recalled. It is charged if it finishes. Items that had not started were not charged.`
: 'Stopped. Items that had not started were not charged.',
})
return order
}
const sentId = order.items.find((i) => i.n === item.n)!.runs[index].jobId
if (polling && sentId) {
emit({
...replaceRun(order, item.n, index, { status: 'failed', refunded: false, error: LOST_TRACK_ERROR, interrupted: true, lostTrack: true }),
state: 'stopped',
note: `Item ${item.n} is with LU Cloud, but its answer did not arrive (${failure.text ?? 'no reply'}). LU keeps checking; it is charged only if it finishes.`,
})
return order
}
const text = err instanceof HandleError ? err.message : failure.text ?? 'Could not start this item.'
emit({
...replaceRun(order, item.n, index, { status: 'failed', refunded: false, spent: 0, error: text }),
state: 'stopped', note: `Item ${item.n} could not start. Finished items stay.`,
})
return order
}
}
}
emit({ ...order, state: 'done', note: undefined })
return order
}
export const ORDER_RESULT_PREFIX = 'Order '
const ORDER_ID = /^Order ([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}) /
export function orderIdFromToolResult(toolName: string, result: unknown): string | null {
if (toolName !== 'create_order' || typeof result !== 'string') return null
return ORDER_ID.exec(result)?.[1] ?? null
}
export function toOrderView(order: Order): OrderView {
const items: OrderItemView[] = order.items.map((item) => {
const statuses = item.runs.map((r) => r.status)
const status: OrderItemStatus = statuses.includes('running') ? 'running'
: statuses.includes('queued') ? 'queued'
: statuses.every((s) => s === 'done') ? 'done'
: statuses.includes('failed') ? 'failed'
: 'waiting'
const open = item.runs.filter((r) => r.status !== 'failed')
const view: OrderItemView = {
id: `${order.id}:${item.n}`,
title: item.title,
detail: item.detail,
kind: item.kind,
credits: open.reduce((sum, r) => sum + runCredits(r), 0),
status,
}
if (open.some((r) => r.price.estimated && r.status !== 'done')) view.estimated = true
if (status === 'done') view.spent = item.runs.reduce((sum, r) => sum + (r.spent ?? 0), 0)
const failed = item.runs.find((r) => r.status === 'failed')
if (failed) { view.error = failed.error; view.refunded = failed.refunded === true }
const repriced = item.runs.find((r) => r.requoted !== undefined)
if (repriced && !view.error) {
view.error = `Now ${(repriced.requoted! - (repriced.approvedCredits ?? repriced.price.credits)).toLocaleString('en-US')} credits more than approved.`
}
if (item.runs.length > 1) {
view.steps = item.runs.map((r): OrderStepView => ({
title: r.title, model: modelLabel(r.model), credits: runCredits(r),
status: r.status,
}))
}
return view
})
return {
id: order.id,
state: order.state === 'repricing' ? 'awaiting' : order.state,
items,
...(order.spentBefore > 0 ? { spentBefore: order.spentBefore } : {}),
}
}