videobook 0.0.0-stage → 0.2.0

package/dist/local-upload.js

@@ -0,0 +1,318 @@
+import { normalizeFilePath } from "videobook-engine";
+import { createWriteStream } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { pipeline } from "node:stream/promises";
+import { queue } from "./queue.js";
+const extensionToKind = {
+    ".mp4": "video",
+    ".mov": "video",
+    ".webm": "video",
+    ".avi": "video",
+    ".mkv": "video",
+    ".jpg": "image",
+    ".jpeg": "image",
+    ".png": "image",
+    ".gif": "image",
+    ".heic": "image",
+    ".heif": "image",
+    ".webp": "image",
+    ".svg": "image",
+    ".mp3": "audio",
+    ".wav": "audio",
+    ".aac": "audio",
+    ".flac": "audio",
+    ".ogg": "audio",
+    ".m4a": "audio",
+    ".weba": "audio",
+    ".md": "script",
+};
+function statusCodeForFsError(error) {
+    if (error.code === "NOT_FOUND")
+        return 404;
+    if (error.code === "INVALID_INPUT" || error.code === "ALREADY_EXISTS")
+        return 400;
+    if (error.code === "LOCKED")
+        return 423;
+    return 500;
+}
+function availableUploadFilename(filename, existing) {
+    const files = new Set(existing.map((name) => name.normalize("NFC").toLowerCase()));
+    const directories = new Set();
+    for (const file of files) {
+        const parts = file.split("/");
+        for (let index = 1; index < parts.length; index += 1) {
+            directories.add(parts.slice(0, index).join("/"));
+        }
+    }
+    const parts = filename.split("/");
+    const selected = [];
+    for (const [index, part] of parts.entries()) {
+        const { name, ext } = path.posix.parse(part);
+        let candidate = part;
+        let counter = 1;
+        while (true) {
+            const candidatePath = [...selected, candidate].join("/").normalize("NFC").toLowerCase();
+            if (!files.has(candidatePath) && (index < parts.length - 1 || !directories.has(candidatePath)))
+                break;
+            candidate = `${name}-${counter}${ext}`;
+            counter += 1;
+        }
+        selected.push(candidate);
+    }
+    return selected.join("/");
+}
+export async function uploadLocalBytes(engine, args) {
+    return uploadLocal(engine, {
+        bookId: args.bookId,
+        filename: args.filename,
+        origin: args.origin,
+        waitForProcessing: args.waitForProcessing,
+        targetAssetId: args.targetAssetId,
+        write: async (assetId, writtenFilename) => {
+            const writeResult = await engine.files.write(assetId, writtenFilename, args.data);
+            if (!writeResult.ok) {
+                return {
+                    ok: false,
+                    statusCode: statusCodeForFsError(writeResult.error),
+                    message: writeResult.error.message,
+                };
+            }
+            return { ok: true };
+        },
+    });
+}
+export async function uploadLocalStream(engine, args) {
+    return uploadLocal(engine, {
+        bookId: args.bookId,
+        filename: args.filename,
+        origin: args.origin,
+        waitForProcessing: args.waitForProcessing,
+        targetAssetId: args.targetAssetId,
+        write: async (assetId, writtenFilename) => {
+            let uploadRoot;
+            try {
+                uploadRoot = await mkdtemp(path.join(tmpdir(), "videobook-media-upload-"));
+                const uploadPath = path.join(uploadRoot, "input");
+                await pipeline(args.stream, createWriteStream(uploadPath, { flags: "wx" }));
+                const written = await engine.files.writeFromPath(assetId, writtenFilename, uploadPath);
+                if (!written.ok) {
+                    return {
+                        ok: false,
+                        statusCode: statusCodeForFsError(written.error),
+                        message: written.error.message,
+                    };
+                }
+                return { ok: true };
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    statusCode: 500,
+                    message: error instanceof Error ? error.message : String(error),
+                };
+            }
+            finally {
+                if (uploadRoot)
+                    await rm(uploadRoot, { recursive: true, force: true, maxRetries: 3 });
+            }
+        },
+    });
+}
+// Long enough to cover slow streaming writes for large videos plus the
+// runner's 250ms poll. process_video writes native metadata a few seconds in,
+// so even if this lock expires mid-job, the sweep falls back to the metadata
+// presence check and still skips the asset.
+const UPLOAD_LOCK_MS = 5 * 60_000;
+async function runProcessingJob(jobId, payload, waitForProcessing) {
+    if (!waitForProcessing) {
+        await queue.enqueue(jobId, payload);
+        return null;
+    }
+    try {
+        await queue.enqueueAndWait(jobId, payload);
+        return null;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+async function uploadLocal(engine, args) {
+    const ext = path.extname(args.filename).toLowerCase();
+    const kind = extensionToKind[ext];
+    if (!kind && !args.targetAssetId) {
+        return {
+            ok: false,
+            statusCode: 400,
+            message: `Unsupported file extension: ${ext}`,
+        };
+    }
+    let filename = args.filename;
+    if (args.targetAssetId) {
+        try {
+            filename = normalizeFilePath(filename);
+        }
+        catch (error) {
+            return {
+                ok: false,
+                statusCode: 400,
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    let assetId;
+    let artifactId;
+    let assetPath;
+    let assetKind;
+    let isNewAsset = false;
+    if (args.targetAssetId) {
+        const artifact = engine.artifacts.get(args.targetAssetId);
+        if (!artifact.ok) {
+            return {
+                ok: false,
+                statusCode: statusCodeForFsError(artifact.error),
+                message: artifact.error.message,
+            };
+        }
+        if (artifact.value.kind !== "character") {
+            return { ok: false, statusCode: 400, message: "Target asset must be a character folder" };
+        }
+        const resolveResult = await engine.workspaces.resolveArtifact(args.targetAssetId);
+        if (!resolveResult.ok) {
+            return { ok: false, statusCode: statusCodeForFsError(resolveResult.error), message: resolveResult.error.message };
+        }
+        assetId = args.targetAssetId;
+        assetPath = resolveResult.value;
+        artifactId = artifact.value.artifactId;
+        assetKind = artifact.value.kind;
+    }
+    else {
+        const assetName = path.basename(args.filename, ext);
+        const assetResult = await engine.artifacts.create(kind, assetName);
+        if (!assetResult.ok) {
+            return {
+                ok: false,
+                statusCode: statusCodeForFsError(assetResult.error),
+                message: assetResult.error.message,
+            };
+        }
+        assetId = assetResult.value.artifactId;
+        artifactId = assetResult.value.artifactId;
+        assetPath = assetResult.value.path;
+        assetKind = assetResult.value.kind;
+        isNewAsset = true;
+    }
+    // Hold an fs lock from before the bytes hit disk through the process_*
+    // enqueue. Without it, sync's findUnprocessedUploads sweep races the
+    // streaming write — sees `original.{ext}` with no metadata and no lock —
+    // and queues a duplicate process_video that re-extracts every frame after
+    // the real job finishes.
+    const lockResult = await engine.jobs.locks.acquire(assetPath, {
+        durationMs: UPLOAD_LOCK_MS,
+        data: { state: "uploading" },
+    });
+    if (!lockResult.ok) {
+        if (isNewAsset)
+            await engine.artifacts.delete(assetId).catch(() => { });
+        return {
+            ok: false,
+            statusCode: statusCodeForFsError(lockResult.error),
+            message: lockResult.error.message,
+        };
+    }
+    let outcome;
+    try {
+        let writtenFilename = isNewAsset ? `original${ext}` : filename;
+        if (!isNewAsset) {
+            const manifest = await engine.files.manifest(assetId);
+            if (!manifest.ok) {
+                return {
+                    ok: false,
+                    statusCode: statusCodeForFsError(manifest.error),
+                    message: manifest.error.message,
+                };
+            }
+            writtenFilename = availableUploadFilename(filename, manifest.value.files.map((file) => file.name));
+        }
+        const writeResult = await args.write(assetId, writtenFilename);
+        if (!writeResult.ok) {
+            outcome = {
+                ok: false,
+                statusCode: writeResult.statusCode,
+                message: writeResult.message,
+            };
+        }
+        else {
+            const provenance = { origin: args.origin ?? "upload", processed_at: new Date().toISOString() };
+            let processingError = null;
+            if (assetKind === "video") {
+                const videoPath = path.join(assetPath, writtenFilename);
+                const jobId = `process-video-${assetId}-${Date.now()}`;
+                // Downstream speech-to-text stays enqueued even when the caller waits:
+                // it is fire-and-forget (separate job id), so enqueueAndWait still
+                // returns as soon as processing finishes. Skipping it here left MCP
+                // upload_file videos permanently transcript-less, which wedged the
+                // slot auto-render pipeline for audio videos (hasAudio + no
+                // .analysis.gpt4otrans.json blocks findEligibleRenderActions forever).
+                // Tests stay deterministic via process-video's NODE_ENV gate.
+                const payload = {
+                    type: "process_video",
+                    videoPath,
+                    assetId,
+                    assetDir: assetPath,
+                    bookId: args.bookId,
+                    provenance,
+                };
+                processingError = await runProcessingJob(jobId, payload, args.waitForProcessing);
+            }
+            else if (assetKind === "image") {
+                const jobId = `process-image-${assetId}-${Date.now()}`;
+                const payload = {
+                    type: "process_image",
+                    assetId,
+                    bookId: args.bookId,
+                    extension: ext,
+                    provenance,
+                };
+                processingError = await runProcessingJob(jobId, payload, args.waitForProcessing);
+            }
+            else if (assetKind === "audio") {
+                const audioPath = path.join(assetPath, writtenFilename);
+                const jobId = `process-audio-${assetId}-${Date.now()}`;
+                const payload = {
+                    type: "process_audio",
+                    audioPath,
+                    sourceFilename: writtenFilename,
+                    assetId,
+                    assetDir: assetPath,
+                    bookId: args.bookId,
+                    provenance,
+                };
+                processingError = await runProcessingJob(jobId, payload, args.waitForProcessing);
+            }
+            else {
+                await engine.metadata.artifacts.write(assetId, "original", provenance);
+            }
+            outcome = {
+                ok: true,
+                value: {
+                    artifactId,
+                    assetId,
+                    path: assetPath,
+                    filename: writtenFilename,
+                    ...(processingError ? { processingError } : {}),
+                },
+            };
+        }
+    }
+    finally {
+        // deleteAsset refuses while the lock is held, so always release before
+        // any cleanup branch below runs.
+        engine.jobs.locks.release(assetPath);
+    }
+    if (!outcome.ok && isNewAsset) {
+        await engine.artifacts.delete(assetId).catch(() => { });
+    }
+    return outcome;
+}

package/dist/logger.js

@@ -0,0 +1,69 @@
+import { diagnosticRecord } from "./diagnostics.js";
+const LEVEL_RANK = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4,
+};
+const consoleSink = {
+    error: (...args) => {
+        console.error(...args);
+    },
+    warn: (...args) => {
+        console.warn(...args);
+    },
+    info: (...args) => {
+        console.log(...args);
+    },
+    debug: (...args) => {
+        console.debug(...args);
+    },
+};
+function parseLevel(value) {
+    if (!value)
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (normalized in LEVEL_RANK)
+        return normalized;
+    return null;
+}
+export function resolveLogLevel(env = process.env) {
+    const explicit = parseLevel(env.VIDEOBOOK_LOG_LEVEL);
+    if (explicit)
+        return explicit;
+    if (env.VITEST && env.VIDEOBOOK_TEST_LOG !== "1")
+        return "error";
+    return "info";
+}
+let currentLevel = resolveLogLevel();
+let currentSink = consoleSink;
+export function configureLoggerForTests(options) {
+    if (options.level !== undefined)
+        currentLevel = options.level;
+    if (options.sink !== undefined)
+        currentSink = options.sink;
+}
+export function resetLoggerForTests() {
+    currentLevel = resolveLogLevel();
+    currentSink = consoleSink;
+}
+function enabled(level) {
+    return LEVEL_RANK[currentLevel] >= LEVEL_RANK[level];
+}
+function emit(level, event, fields) {
+    if (!enabled(level))
+        return;
+    const record = diagnosticRecord(event, fields);
+    if (record.event === "server-listening" && typeof record.port === "number") {
+        currentSink[level](`MCP server listening on http://127.0.0.1:${record.port}/mcp`);
+        return;
+    }
+    currentSink[level](`[${record.event}] ${JSON.stringify(record)}`);
+}
+export const logger = {
+    error: (event, fields) => emit("error", event, fields),
+    warn: (event, fields) => emit("warn", event, fields),
+    info: (event, fields) => emit("info", event, fields),
+    debug: (event, fields) => emit("debug", event, fields),
+};

package/dist/media/adapters/alibaba.js

@@ -0,0 +1,20 @@
+import { createAlibaba } from "../../usage-providers.js";
+import { requireApiKey } from "../../api-key.js";
+import { uploadAssetToAlibaba } from "../../jobs/_alibaba-upload.js";
+async function submit(request, _context) {
+    const provider = createAlibaba({ apiKey: requireApiKey("DASHSCOPE_API_KEY"), timeout: 120_000 });
+    const response = await provider.post.api.v1.services.aigc.multimodalGeneration.generation(request);
+    const urls = response.output.choices.flatMap((choice) => choice.message.content.flatMap((part) => part.image ? [part.image] : []));
+    if (urls.length === 0)
+        throw new Error("Alibaba response contained no image URLs");
+    return { kind: "done", taskId: response.request_id, outputs: urls.map((url) => ({ url })) };
+}
+export function alibabaAdapterFor(apiId) {
+    return {
+        provider: "alibaba",
+        envKey: "DASHSCOPE_API_KEY",
+        upload: (engine, assetId, filename) => uploadAssetToAlibaba(engine, assetId, filename, apiId),
+        uploadUrl: async (url) => url,
+        submit,
+    };
+}

package/dist/media/adapters/elevenlabs.js

@@ -0,0 +1,58 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createElevenLabs } from "../../usage-providers.js";
+import { requireApiKey } from "../../api-key.js";
+import { providerEndpoints } from "../endpoints.js";
+const ASSET_SCHEME = "asset://";
+function elevenLabsProvider() {
+    const baseURL = providerEndpoints().elevenlabsBaseURL;
+    return createElevenLabs({
+        apiKey: requireApiKey("ELEVENLABS_API_KEY"),
+        timeout: 10 * 60_000,
+        ...(baseURL ? { baseURL } : {}),
+    });
+}
+async function readAssetBlob(engine, ref) {
+    const [assetId, ...rest] = ref.slice(ASSET_SCHEME.length).split("/");
+    const dir = await engine.workspaces.resolveArtifact(assetId);
+    if (!dir.ok)
+        throw new Error(dir.error.message);
+    const bytes = await readFile(join(dir.value, rest.join("/")));
+    return new Blob([bytes], { type: "video/mp4" });
+}
+async function videoToMusic(request, context) {
+    const refs = Array.isArray(request.videos) ? request.videos.map(String) : [];
+    const videos = await Promise.all(refs.map((ref) => readAssetBlob(context.engine, ref)));
+    return elevenLabsProvider().v1.music.videoToMusic({ ...request, videos }, context.ctx.signal);
+}
+function generate(request, context) {
+    const provider = elevenLabsProvider();
+    const signal = context.ctx.signal;
+    switch (context.model.apiId) {
+        case "sound-generation":
+            return provider.v1.soundGeneration(request, signal);
+        case "music":
+            return provider.v1.music(request, signal);
+        case "video-to-music":
+            return videoToMusic(request, context);
+        case "text-to-speech": {
+            const { voice_id: voiceId, ...body } = request;
+            return provider.v1.textToSpeech(String(voiceId), body, signal);
+        }
+        default:
+            throw new Error(`Unsupported ElevenLabs model ${context.model.apiId}`);
+    }
+}
+async function submit(request, context) {
+    const audio = await generate(request, context);
+    return { kind: "done", taskId: `${context.model.apiId}-${Date.now()}`, outputs: [{ bytes: Buffer.from(audio), extension: "mp3" }] };
+}
+export const elevenLabsAdapter = {
+    provider: "elevenlabs",
+    envKey: "ELEVENLABS_API_KEY",
+    upload: async (_engine, assetId, filename) => `${ASSET_SCHEME}${assetId}/${filename}`,
+    uploadUrl: async (url) => {
+        throw new Error(`ElevenLabs needs a project asset, not a URL: ${url}`);
+    },
+    submit,
+};

package/dist/media/adapters/fal.js

@@ -0,0 +1,45 @@
+import { createFal } from "../../usage-providers.js";
+import { requireApiKey } from "../../api-key.js";
+import { uploadAssetToFal } from "../../jobs/_fal-upload.js";
+import { describeFalError } from "../../jobs/_fal-shared.js";
+import { withProviderHandoff } from "../../jobs/_lease.js";
+import { providerEndpoints } from "../endpoints.js";
+import { writePendingTask } from "./pending.js";
+import { MEDIA_TASK_TYPES } from "./types.js";
+function falProvider() {
+    const queueBaseURL = providerEndpoints().falQueueBaseURL;
+    return createFal({
+        apiKey: requireApiKey("FAL_API_KEY"),
+        timeout: 60_000,
+        ...(queueBaseURL ? { queueBaseURL } : {}),
+    });
+}
+async function submitQueued(request, context, ownerId) {
+    const endpointId = context.model.apiId;
+    let submitted;
+    try {
+        submitted = await falProvider().post.v1.queue.submit({ endpoint_id: endpointId, input: request });
+    }
+    catch (cause) {
+        const message = describeFalError(cause);
+        if (cause instanceof Error && message === cause.message)
+            throw cause;
+        throw new Error(message, { cause });
+    }
+    await writePendingTask(context, submitted.request_id, MEDIA_TASK_TYPES.fal, { falEndpointId: endpointId }, ownerId);
+    return submitted.request_id;
+}
+async function submit(request, context) {
+    const taskId = await withProviderHandoff(context.engine, context.assetId, context.ctx, "generate", async (ownerId) => {
+        const id = await submitQueued(request, context, ownerId);
+        return { taskId: id, result: id };
+    });
+    return { kind: "pending", taskId };
+}
+export const falAdapter = {
+    provider: "fal",
+    envKey: "FAL_API_KEY",
+    upload: uploadAssetToFal,
+    uploadUrl: async (url) => url,
+    submit,
+};

package/dist/media/adapters/index.js

@@ -0,0 +1,26 @@
+import { alibabaAdapterFor } from "./alibaba.js";
+import { elevenLabsAdapter } from "./elevenlabs.js";
+import { falAdapter } from "./fal.js";
+import { kieAdapter } from "./kie.js";
+import { xaiAdapter } from "./xai.js";
+export function adapterFor(model) {
+    switch (model.provider) {
+        case "kie":
+            return kieAdapter;
+        case "fal":
+            return falAdapter;
+        case "xai":
+            return xaiAdapter;
+        case "alibaba":
+            return alibabaAdapterFor(model.apiId);
+        case "elevenlabs":
+            return elevenLabsAdapter;
+    }
+}
+export const PROVIDER_ENV_KEYS = {
+    kie: "KIE_API_KEY",
+    fal: "FAL_API_KEY",
+    xai: "XAI_API_KEY",
+    alibaba: "DASHSCOPE_API_KEY",
+    elevenlabs: "ELEVENLABS_API_KEY",
+};

package/dist/media/adapters/kie.js

@@ -0,0 +1,120 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { KieError, submitMediaJob } from "@apicity/kie";
+import { createKie } from "../../usage-providers.js";
+import { requireApiKey } from "../../api-key.js";
+import { authorizeKiePaygate, ensurePaygateSecret, mintKieOtp } from "../../jobs/kie-paygate.js";
+import { uploadAssetToKie } from "../../jobs/_kie-upload.js";
+import { providerEndpoints } from "../endpoints.js";
+import { isKieSunoModel, isKieVeoModel } from "../wire.js";
+import { nonEmpty, writePendingTask } from "./pending.js";
+import { MEDIA_TASK_TYPES } from "./types.js";
+const VEO_DOT_PATH = "api.v1.veo.generate";
+const SUNO_DOT_PATH = "api.v1.generate";
+const SUNO_FAILURES = new Set(["CREATE_TASK_FAILED", "GENERATE_AUDIO_FAILED", "SENSITIVE_WORD_ERROR"]);
+const SUNO_DONE = new Set(["SUCCESS", "FIRST_SUCCESS", "CALLBACK_EXCEPTION"]);
+function kieProvider() {
+    const baseURL = providerEndpoints().kieBaseURL;
+    return createKie({
+        apiKey: requireApiKey("KIE_API_KEY"),
+        timeout: 60_000,
+        paygate: { secret: ensurePaygateSecret() },
+        ...(baseURL ? { baseURL } : {}),
+    });
+}
+function correlation(context, stage) {
+    return { bookId: context.bookId, artifactId: context.assetId, tool: context.model.id, stage };
+}
+async function recordTaskId(context, taskId) {
+    await context.engine.metadata.artifacts.write(context.assetId, "kie-task-id", { taskId });
+}
+async function submitCreateTask(request, context) {
+    const typed = request;
+    if (Object.keys(context.costHints).length > 0) {
+        await context.engine.metadata.artifacts.write(context.assetId, "generation-cost-hints", context.costHints);
+    }
+    const { otp } = await authorizeKiePaygate(typed, {
+        costHints: {
+            ...(context.costHints.durationSeconds !== undefined ? { duration: context.costHints.durationSeconds } : {}),
+            ...(context.costHints.inputDurationSeconds !== undefined ? { inputDuration: context.costHints.inputDurationSeconds } : {}),
+        },
+        engine: context.engine,
+        correlation: correlation(context, "submit-kie"),
+    });
+    const taskId = await submitMediaJob(kieProvider(), typed, { otp });
+    await writePendingTask(context, taskId, MEDIA_TASK_TYPES.kie);
+    await recordTaskId(context, taskId);
+    return { kind: "pending", taskId };
+}
+async function submitVeo(request, context) {
+    const typed = request;
+    const { otp } = await authorizeKiePaygate(typed, {
+        dotPath: VEO_DOT_PATH,
+        engine: context.engine,
+        correlation: correlation(context, "submit-veo"),
+    });
+    const result = await kieProvider().veo.post.api.v1.veo.generate(typed, { otp });
+    const taskId = nonEmpty(result.data?.taskId);
+    if (!taskId)
+        throw new KieError(`veo.generate failed: ${result.code}`, result.code);
+    await writePendingTask(context, taskId, MEDIA_TASK_TYPES.kie, { veoModel: context.model.apiId });
+    await recordTaskId(context, taskId);
+    return { kind: "pending", taskId };
+}
+function sunoTrackUrl(tracks) {
+    for (const track of tracks ?? []) {
+        const url = nonEmpty(track.audioUrl);
+        if (url)
+            return url;
+    }
+    return null;
+}
+async function submitSunoTask(provider, request, apiId) {
+    if (apiId === "suno/sounds-generate") {
+        const response = await provider.suno.post.api.v1.generate.sounds(request);
+        const taskId = nonEmpty(response.data?.taskId);
+        if (!taskId)
+            throw new Error(`Suno sounds submission failed: ${response.msg ?? response.code}`);
+        return taskId;
+    }
+    const otp = mintKieOtp(request, undefined, SUNO_DOT_PATH);
+    const response = await provider.suno.post.api.v1.generate(request, { otp });
+    const taskId = nonEmpty(response.data?.taskId);
+    if (!taskId)
+        throw new Error(`Suno submission failed: ${response.msg ?? response.code}`);
+    return taskId;
+}
+async function pollSuno(provider, taskId, signal) {
+    const settings = providerEndpoints();
+    const deadline = Date.now() + (settings.timeoutMs ?? 25 * 60_000);
+    while (Date.now() < deadline) {
+        const result = await provider.suno.get.api.v1.generate.recordInfo(taskId);
+        const status = result.data?.status;
+        const url = sunoTrackUrl(result.data?.response?.sunoData);
+        if (url && status && SUNO_DONE.has(status))
+            return url;
+        if (status && SUNO_FAILURES.has(status))
+            throw new Error(`Suno generation failed: ${result.data?.errorMessage || status}`);
+        await delay(settings.pollIntervalMs ?? 3_000, undefined, { signal });
+    }
+    throw new Error(`Suno task ${taskId} did not finish in time`);
+}
+async function submitSuno(request, context) {
+    const provider = kieProvider();
+    const taskId = await submitSunoTask(provider, request, context.model.apiId);
+    await recordTaskId(context, taskId);
+    const url = await pollSuno(provider, taskId, context.ctx.signal);
+    return { kind: "done", taskId, outputs: [{ url }] };
+}
+export const kieAdapter = {
+    provider: "kie",
+    envKey: "KIE_API_KEY",
+    upload: uploadAssetToKie,
+    uploadUrl: async (url) => url,
+    submit: (request, context) => {
+        if (isKieVeoModel(context.model.apiId))
+            return submitVeo(request, context);
+        if (isKieSunoModel(context.model.apiId))
+            return submitSuno(request, context);
+        return submitCreateTask(request, context);
+    },
+};

package/dist/media/adapters/pending.js

@@ -0,0 +1,21 @@
+export async function writePendingTask(context, taskId, taskType, extraMeta = {}, ownerId = context.ctx.getOwnerId()) {
+    const written = await context.engine.jobs.pending.write({
+        taskId,
+        taskType,
+        artifactId: context.assetId,
+        meta: { ...context.meta, ...extraMeta },
+    }, ownerId);
+    if (!written.ok)
+        throw new Error(`Failed to write pending-task for ${context.assetId}: ${written.error.message}`);
+    if (written.value === null)
+        throw new Error(`Lost local lease for ${context.assetId} while writing pending-task`);
+    context.ctx.setLease({ kind: "task", taskId });
+}
+export function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+export function nonEmpty(value) {
+    return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
+}

package/dist/media/adapters/types.js

@@ -0,0 +1,5 @@
+export const MEDIA_TASK_TYPES = {
+    kie: "media_kie",
+    fal: "fal_media",
+    xai: "xai_media",
+};