videobook 0.2.5 → 0.3.1

package/dist/har-index.js

@@ -0,0 +1,98 @@
+import { lstat, readFile, realpath, stat } from "node:fs/promises";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { harDirectory } from "./har-settings.js";
+const OUTCOMES = new Set(["ok", "provider_error", "local_error", "network_error"]);
+let indexCache = null;
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function indexRow(line) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    const row = record(value);
+    if (!row || typeof row.ts !== "string" || typeof row.callId !== "string" || typeof row.provider !== "string"
+        || typeof row.endpoint !== "string" || typeof row.outcome !== "string" || !OUTCOMES.has(row.outcome)
+        || typeof row.file !== "string")
+        return null;
+    const context = record(row.context);
+    return {
+        ts: row.ts,
+        callId: row.callId,
+        provider: row.provider,
+        endpoint: row.endpoint,
+        outcome: row.outcome,
+        ...(typeof row.status === "number" ? { status: row.status } : {}),
+        file: row.file,
+        ...(context ? { context } : {}),
+    };
+}
+export async function readHarIndex(dir = harDirectory()) {
+    const path = join(dir, "index.jsonl");
+    let key;
+    try {
+        const info = await stat(path);
+        key = `${info.dev}:${info.ino}:${info.size}:${info.mtimeMs}`;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    if (indexCache?.path === path && indexCache.key === key)
+        return indexCache.rows;
+    const text = await readFile(path, "utf8");
+    const rows = text.split("\n").flatMap((line) => {
+        const row = line.trim() ? indexRow(line) : null;
+        return row ? [row] : [];
+    });
+    indexCache = { path, key, rows };
+    return rows;
+}
+export function captureFilePath(dir, file) {
+    if (!file.endsWith(".har") || isAbsolute(file) || file.includes("\0"))
+        return null;
+    const parts = file.split(/[\\/]/u);
+    if (parts.some((part) => part === "" || part === "." || part === ".."))
+        return null;
+    return join(dir, ...parts);
+}
+function isHar(value) {
+    const log = record(record(value)?.log);
+    return Boolean(log && Array.isArray(log.entries));
+}
+export async function readCaptureFile(dir, file) {
+    const path = captureFilePath(dir, file);
+    if (!path)
+        return null;
+    try {
+        if (!(await lstat(path)).isFile())
+            return null;
+        const location = relative(await realpath(dir), await realpath(path));
+        if (location === ".." || location.startsWith(`..${sep}`) || isAbsolute(location))
+            return null;
+        const bytes = await readFile(path);
+        const har = JSON.parse(bytes.toString("utf8"));
+        return isHar(har) ? { path, bytes, har } : null;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError || error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+export async function captureFileExists(dir, file) {
+    const path = captureFilePath(dir, file);
+    if (!path)
+        return false;
+    try {
+        return (await lstat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/har-retention.js

@@ -0,0 +1,73 @@
+import { readFile, readdir, stat, unlink, writeFile, rename } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { randomUUID } from "node:crypto";
+import { harDirectory, readHarSettings } from "./har-settings.js";
+import { maintainHarCaptures } from "./har-capture.js";
+import { logger } from "./logger.js";
+let nextSweep = 0;
+async function captureFiles(dir, root = dir) {
+    const result = [];
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory())
+            result.push(...await captureFiles(path, root));
+        else if (entry.isFile() && entry.name.endsWith(".har")) {
+            const info = await stat(path);
+            result.push({ file: relative(root, path), bytes: info.size, time: info.mtimeMs });
+        }
+    }
+    return result;
+}
+export async function pruneHarCaptures(dir, settings, now = Date.now()) {
+    if (settings.mode === "off")
+        return;
+    let files;
+    try {
+        files = await captureFiles(dir);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    files.sort((a, b) => a.time - b.time || a.file.localeCompare(b.file));
+    let index = "";
+    try {
+        index = await readFile(join(dir, "index.jsonl"), "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const rows = index.split("\n").filter(Boolean).map((line) => ({ line, value: JSON.parse(line) }));
+    let bytes = files.reduce((sum, file) => sum + file.bytes, 0) + Buffer.byteLength(index);
+    const keep = new Set(files.map((file) => file.file));
+    for (const file of files) {
+        if (file.time >= now - settings.maxAgeDays * 86_400_000 && bytes <= settings.maxTotalMB * 1024 * 1024)
+            continue;
+        await unlink(join(dir, file.file));
+        keep.delete(file.file);
+        bytes -= file.bytes + rows.filter((row) => row.value.file === file.file).reduce((sum, row) => sum + Buffer.byteLength(row.line) + 1, 0);
+    }
+    const retained = rows.filter((row) => keep.has(row.value.file)).map((row) => row.line + "\n").join("");
+    const temporary = join(dir, `.index-${randomUUID()}.tmp`);
+    await writeFile(temporary, retained, { mode: 0o600 });
+    await rename(temporary, join(dir, "index.jsonl"));
+}
+export async function sweepHarCaptures(force = false) {
+    if (!force && Date.now() < nextSweep)
+        return;
+    nextSweep = Date.now() + 86_400_000;
+    try {
+        const settings = await readHarSettings();
+        if (settings.mode === "off") {
+            nextSweep = 0;
+            return;
+        }
+        if (!await maintainHarCaptures(() => pruneHarCaptures(harDirectory(), settings)))
+            nextSweep = Date.now() + 60_000;
+    }
+    catch (error) {
+        logger.warn("har-capture-failed", { error });
+    }
+}

package/dist/har-settings.js

@@ -0,0 +1,27 @@
+import { join } from "node:path";
+import { z } from "zod";
+import { appState } from "./app-state.js";
+import { dataLayout } from "./data-home.js";
+export const harSettingsSchema = z.object({
+    mode: z.enum(["off", "failures", "all"]).default("off"),
+    maxAgeDays: z.number().positive().finite().default(30),
+    maxTotalMB: z.number().positive().finite().default(512),
+});
+export function harDirectory() {
+    const layout = dataLayout();
+    return join(layout.root, ...(layout.kind === "checkout" ? ["runtime"] : []), "har");
+}
+export async function readHarSettings(store = appState, env = process.env) {
+    const stored = harSettingsSchema.safeParse(await store.get("harCapture") ?? {});
+    const settings = stored.success ? stored.data : harSettingsSchema.parse({});
+    const override = env.VIDEOBOOK_HAR_CAPTURE?.trim();
+    if (!override)
+        return settings;
+    const mode = harSettingsSchema.shape.mode.safeParse(override);
+    return { ...settings, mode: mode.success ? mode.data : "off" };
+}
+export async function writeHarSettings(value, store = appState) {
+    const settings = harSettingsSchema.parse(value);
+    await store.set("harCapture", settings);
+    return readHarSettings(store);
+}

package/dist/jobs/_alibaba-upload.js

@@ -1,5 +1,4 @@
-import { createAlibaba } from "../usage-providers.js";
-import { uploadFile } from "@apicity/alibaba";
+import { uploadAlibabaFile } from "../usage-providers.js";
 import { prepareAssetForUpload, uploadBytesToFreeHost } from "../upload.js";
 import { getApiKey } from "../api-key.js";
 import { logger } from "../logger.js";
@@ -11,8 +10,7 @@ export async function uploadAssetToAlibaba(engine, assetId, filename, model) {
     const apiKey = getApiKey("DASHSCOPE_API_KEY");
     if (apiKey) {
         try {
-            const provider = createAlibaba({ apiKey, timeout: 60_000 });
-            return await uploadFile(provider, {
+            return await uploadAlibabaFile({ apiKey, timeout: 60_000 }, {
                 model,
                 data,
                 filename: hashedFilename,

package/dist/jobs/_fal-upload.js

@@ -1,5 +1,4 @@
-import { createFal } from "../usage-providers.js";
-import { uploadFile } from "@apicity/fal";
+import { uploadFalFile } from "../usage-providers.js";
 import { prepareAssetForUpload, uploadBytesToFreeHost, } from "../upload.js";
 import { getApiKey } from "../api-key.js";
 import { logger } from "../logger.js";
@@ -10,8 +9,7 @@ async function uploadPreparedToFal(data, hashedFilename, contentType) {
     const apiKey = getApiKey("FAL_API_KEY");
     if (apiKey) {
         try {
-            const provider = createFal({ apiKey, timeout: 60_000 });
-            return await uploadFile(provider, {
+            return await uploadFalFile({ apiKey, timeout: 60_000 }, {
                 data,
                 filename: hashedFilename,
                 contentType,

package/dist/jobs/_image-edit-adapter.js

@@ -1,5 +1,5 @@
 import { createFal } from "../usage-providers.js";
-import { submitMediaJob } from "@apicity/kie";
+import { submitMediaJob } from "../usage-providers.js";
 import { FalError } from "@apicity/fal";
 import { SeedreamProImageToImageRequestSchema } from "@apicity/kie/zod";
 import { setTimeout as delay } from "node:timers/promises";
@@ -99,6 +99,7 @@ function kieImageEditAdapter(model, build) {
     });
     return {
         id: model.apiId,
+        envKey: "KIE_API_KEY",
         uploadAsset: (engine, artifactId, filename) => uploadAssetToKie(engine, artifactId, filename),
         buildSemanticRequest: (input) => buildRequest({ ...input, imageUrls: [input.imageUrls[0]] }),
         buildRegionRequest: buildRequest,
@@ -166,6 +167,7 @@ function falImageEditAdapter(model) {
     const buildRequest = (input) => toProviderRequest(model.apiId, catalogEditRequest(model, input));
     return {
         id: model.apiId,
+        envKey: "FAL_API_KEY",
         uploadAsset: (engine, artifactId, filename) => uploadAssetToFal(engine, artifactId, filename),
         buildSemanticRequest: (input) => buildRequest({ ...input, imageUrls: [input.imageUrls[0]] }),
         buildRegionRequest: buildRequest,

package/dist/jobs/_kie-upload.js

@@ -1,5 +1,4 @@
-import { createKie } from "../usage-providers.js";
-import { uploadFile } from "@apicity/kie";
+import { uploadKieFile } from "../usage-providers.js";
 import { prepareAssetForUpload, uploadBytesToFreeHost, } from "../upload.js";
 import { getApiKey } from "../api-key.js";
 import { logger } from "../logger.js";
@@ -12,9 +11,8 @@ async function uploadPreparedToKie(data, hashedFilename, contentType) {
     const apiKey = getApiKey("KIE_API_KEY");
     if (apiKey) {
         try {
-            const provider = createKie({ apiKey, timeout: 120_000 });
             const blob = new Blob([new Uint8Array(data)], { type: contentType });
-            return await uploadFile(provider, blob, hashedFilename);
+            return await uploadKieFile({ apiKey, timeout: 120_000 }, blob, hashedFilename);
         }
         catch (err) {
             logger.warn("kie-upload-fallback", { error: err });

package/dist/jobs/assess-media-probes.js

@@ -0,0 +1,94 @@
+import { join } from "node:path";
+import { probeVideo } from "../ffmpeg.js";
+import { logger } from "../logger.js";
+import { queue, registerJobHandler } from "../queue.js";
+import { invalidVideoProxyMetadata, probeStoredVideoFile, videoProxyAssessmentMatches, videoProxyMetadata, videoProxyValidationError, } from "../video-proxy.js";
+const PROXY_FILENAME = "proxy.mp4";
+export function scheduleVideoProxyAssessment(input) {
+    const jobId = `assess-video-proxy-${input.bookId}-${input.artifactId}-${input.proxyFile.objectHash}`;
+    void queue.enqueue(jobId, {
+        type: "assess_video_proxy",
+        bookId: input.bookId,
+        proxyAssetId: input.artifactId,
+        sourceFilename: input.sourceFile.name,
+        sourceHash: input.sourceFile.objectHash,
+        proxyHash: input.proxyFile.objectHash,
+        sourceProfile: input.sourceProfile,
+    }).catch((error) => {
+        logger.error("proxy-assessment-enqueue-failed", { assetId: input.artifactId, error });
+    });
+}
+export function scheduleMediaDurationBackfill(input) {
+    const jobId = `backfill-media-duration-${input.bookId}-${input.artifactId}-${input.mediaFile.objectHash}`;
+    void queue.enqueue(jobId, {
+        type: "backfill_media_duration",
+        bookId: input.bookId,
+        durationAssetId: input.artifactId,
+        mediaFilename: input.mediaFile.name,
+        mediaHash: input.mediaFile.objectHash,
+    }).catch((error) => {
+        logger.error("duration-backfill-enqueue-failed", { assetId: input.artifactId, error });
+    });
+}
+async function currentFile(engine, artifactId, name, objectHash) {
+    const manifest = await engine.files.manifest(artifactId);
+    if (!manifest.ok)
+        return null;
+    return manifest.value.files.find((file) => file.name === name && file.objectHash === objectHash) ?? null;
+}
+export async function assessStoredVideoProxy(engine, assetId, sourceFile, proxyFile, sourceProfile) {
+    let assessment;
+    try {
+        const proxy = await probeStoredVideoFile(engine, assetId, proxyFile.name);
+        const error = videoProxyValidationError(sourceProfile, proxy);
+        assessment = error
+            ? invalidVideoProxyMetadata(sourceFile, proxyFile, error)
+            : videoProxyMetadata(sourceFile, proxyFile, proxy);
+    }
+    catch (cause) {
+        const error = cause instanceof Error ? cause.message : String(cause);
+        assessment = invalidVideoProxyMetadata(sourceFile, proxyFile, error);
+    }
+    await engine.metadata.artifacts.write(assetId, "proxy", assessment);
+    return assessment.valid;
+}
+async function runVideoProxyAssessment(engine, payload) {
+    const { proxyAssetId } = payload;
+    const sourceFile = await currentFile(engine, proxyAssetId, payload.sourceFilename, payload.sourceHash);
+    const proxyFile = await currentFile(engine, proxyAssetId, PROXY_FILENAME, payload.proxyHash);
+    if (!sourceFile || !proxyFile)
+        return { skipped: true };
+    const existing = await engine.metadata.artifacts.read(proxyAssetId, "proxy");
+    if (existing.ok && videoProxyAssessmentMatches(existing.value, sourceFile, proxyFile)) {
+        return { skipped: true };
+    }
+    return {
+        valid: await assessStoredVideoProxy(engine, proxyAssetId, sourceFile, proxyFile, payload.sourceProfile),
+    };
+}
+async function runMediaDurationBackfill(engine, payload, signal) {
+    const { durationAssetId } = payload;
+    const metadata = await engine.metadata.artifacts.read(durationAssetId, "original");
+    if (!metadata.ok || typeof metadata.value.duration === "number")
+        return { skipped: true };
+    if (!await currentFile(engine, durationAssetId, payload.mediaFilename, payload.mediaHash)) {
+        return { skipped: true };
+    }
+    const dir = await engine.workspaces.resolveArtifact(durationAssetId);
+    if (!dir.ok)
+        throw new Error(`backfill_media_duration: ${dir.error.message}`);
+    const probe = await probeVideo(join(dir.value, payload.mediaFilename), { signal });
+    if (!Number.isFinite(probe.duration) || probe.duration <= 0)
+        return { skipped: true };
+    const written = await engine.metadata.artifacts.write(durationAssetId, "original", {
+        ...metadata.value,
+        duration: probe.duration,
+    });
+    if (!written.ok)
+        throw new Error(written.error.message);
+    return { duration: probe.duration };
+}
+export function registerAssessMediaProbeJobs(engine) {
+    registerJobHandler("assess_video_proxy", async (payload) => runVideoProxyAssessment(engine, payload));
+    registerJobHandler("backfill_media_duration", async (payload, { signal }) => runMediaDurationBackfill(engine, payload, signal));
+}

package/dist/jobs/generate-media.js

@@ -1,3 +1,6 @@
+import { withHarLocalFailure } from "../har-capture.js";
+import { generationHarEndpoint } from "../media/har-endpoint.js";
+import { withBookContext } from "../book-context.js";
 import { isSeedanceEdit } from "../media/seedance-edit.js";
 import { registerJobHandler } from "../queue.js";
 import { assertProviderPayload } from "../provider-prompt-transform.js";
@@ -41,6 +44,8 @@ export async function generationSourceCostHints(engine, refs, job) {
 function generationMeta(job, model, refs) {
     return {
         model: model.id,
+        runId: job.runId,
+        attemptId: job.generationId ?? job.assetId,
         media: model.media,
         prompt: job.prompt ?? "",
         sourceImageIds: refs.sourceImageIds,
@@ -48,7 +53,7 @@ function generationMeta(job, model, refs) {
         sourceAudioIds: refs.sourceAudioIds,
     };
 }
-export async function runGenerateMedia(engine, job, ctx) {
+async function generateMedia(engine, job, ctx) {
     const model = resolveModel(job.model);
     const adapter = adapterFor(model);
     requireApiKey(adapter.envKey);
@@ -81,6 +86,10 @@ export async function runGenerateMedia(engine, job, ctx) {
     }
     return { success: true, model: model.id, taskId: result.taskId, status: result.kind };
 }
+export async function runGenerateMedia(engine, job, ctx) {
+    return withBookContext({ bookId: job.bookId, engine, operation: "generate_media", artifactId: job.assetId,
+        attemptId: job.generationId ?? job.assetId, runId: job.runId, model: job.model }, () => withHarLocalFailure({ provider: resolveModel(job.model).provider, endpoint: generationHarEndpoint(resolveModel(job.model)), input: job }, () => generateMedia(engine, job, ctx)));
+}
 export function registerGenerateMediaJob(engine) {
     registerJobHandler("generate_media", (payload, ctx) => runGenerateMedia(engine, payload, ctx));
 }

package/dist/jobs/image-subjects.js

@@ -1,9 +1,10 @@
-import { submitMediaJob, } from "@apicity/kie";
+import { submitMediaJob } from "../usage-providers.js";
 import { GrokImagineImage2ImageEditRequestSchema, GrokImagineImage2SegmentMapRequestSchema, SeedreamProLayerDecompositionRequestSchema, } from "@apicity/kie/zod";
 import sharp from "sharp";
 import { KIE_RESULT_TIMEOUT_MS, kieProvider, parseResultUrls, waitForKieResult, } from "./_kie-poll.js";
 import { GROK_EXACT_MASK_ADAPTER_ID, imageEditAdapter, IMAGE_EDIT_ADAPTERS, } from "./_image-edit-adapter.js";
 import { DEFAULT_IMAGE_EDIT_MODEL_ID } from "../image-edit-models.js";
+import { requireApiKey } from "../api-key.js";
 import { compositeImageRegionEdit, imageRegionEditPrompt } from "../image-region-edit.js";
 import { IMAGE_SUBJECT_MAP_VERSION, applyGrokSegmentsToSubjects, composeImageSubjectRemoval, exactEditMaskIndexes, grokMaskIndex, parseGrokSegmentMapResult, persistSeedreamSubjectLayers, readImageSubjectMapRecord, resolveImageSubjectSource, writeCurrentImageSubjectAnalysisRecord, } from "../image-subject-map.js";
 import { enqueueSearchIndex } from "./enqueue-search-index.js";
@@ -534,6 +535,7 @@ export async function previewImageSubjectEditRequest(engine, payload, imageUrls)
         : adapter.buildSemanticRequest(input);
 }
 async function runAdapterImageSubjectEdit(engine, payload, adapter, route, prepared, sourceFilename, signal) {
+    requireApiKey(adapter.envKey);
     const stored = await readStoredImageSubjectEditTask(engine, payload.imageAssetId);
     const storedMatch = stored?.adapterId === adapter.id ? stored : null;
     let request = storedMatch?.request ?? null;

package/dist/jobs/kie-paygate.js

@@ -1,5 +1,6 @@
+import { withHarLocalFailure } from "../har-capture.js";
 import { createKie } from "../usage-providers.js";
-import { submitMediaJob } from "@apicity/kie";
+import { submitMediaJob } from "../usage-providers.js";
 import { mintOtp } from "@apicity/cost";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { randomBytes } from "node:crypto";
@@ -81,7 +82,7 @@ function createKieProvider(apiKey) {
         paygate: { secret: ensurePaygateSecret() },
     });
 }
-export async function submitKieTask(engine, ctx, args) {
+async function submitKieTaskInner(engine, ctx, args) {
     const request = args.request;
     assertProviderPayload(request, {
         toolName: args.taskType,
@@ -129,7 +130,7 @@ export async function submitKieTask(engine, ctx, args) {
     ctx.setLease({ kind: "task", taskId });
     return taskId;
 }
-export async function submitQueuedKieTask(engine, task) {
+async function submitQueuedKieTaskInner(engine, task) {
     if (task.taskId !== QUEUED_TASK_ID)
         throw new Error(`KIE task ${task.artifactId} is not locally queued`);
     const ownerId = await engine.jobs.pending.getOwner(task.artifactId, QUEUED_TASK_ID);
@@ -175,3 +176,9 @@ export async function submitQueuedKieTask(engine, task) {
     await engine.metadata.artifacts.write(task.artifactId, "kie-task-id", { taskId });
     return writeResult.value.task;
 }
+export async function submitKieTask(engine, ctx, args) {
+    return withHarLocalFailure({ provider: "kie", endpoint: "api.v1.jobs.createTask", input: args.request }, () => submitKieTaskInner(engine, ctx, args));
+}
+export async function submitQueuedKieTask(engine, task) {
+    return withHarLocalFailure({ provider: "kie", endpoint: "api.v1.jobs.createTask", input: task }, () => submitQueuedKieTaskInner(engine, task));
+}

package/dist/jobs/register-all.js

@@ -38,6 +38,7 @@ import { registerLabelMusicSectionsJob } from "./label-music-sections.js";
 import { registerEditingMomentsJob } from "./analyze-editing-moments.js";
 import { registerExtractWaveformJob } from "./extract-waveform.js";
 import { registerExtractVideoPosterJob } from "./extract-video-poster.js";
+import { registerAssessMediaProbeJobs } from "./assess-media-probes.js";
 import { registerReplaceVideoAudioJob } from "./replace-video-audio.js";
 import { registerSpliceVideoJob } from "./splice-video.js";
 import { registerSmoothSceneConcatJob } from "./smooth-scene-concat.js";
@@ -109,6 +110,7 @@ export function registerAllJobHandlers(engine, books = bookManager) {
     registerExtractAudioJob(engine);
     registerExtractWaveformJob(engine);
     registerExtractVideoPosterJob(engine);
+    registerAssessMediaProbeJobs(engine);
     registerAnalyzeMusicJob(engine);
     registerPlanGoalJob(engine);
     registerAssembleGoalJob(engine);

package/dist/jobs/run-notebook.js

@@ -1,3 +1,4 @@
+import { withBookContext } from "../book-context.js";
 import { createHash } from "node:crypto";
 import { setTimeout as delay } from "node:timers/promises";
 import { LIGHTNING_VIDEO_MODEL, payloadPrompt, submittedGenerationPrompt, } from "../lightning-defaults.js";
@@ -1006,6 +1007,7 @@ async function generationTool(engine, document, cell, bookId, options = {}) {
             await queue.enqueue(jobId, {
                 ...prepared.imageEdit.jobInput,
                 type: "generate_image_subject_edit", imageAssetId, bookId,
+                runId: options.runId, model: prepared.model,
                 notebookId: document.id, producerCellId: cell.id, outputCellId, jobId,
                 managedByNotebook: true,
                 ...(generationId ? { generationId } : {}),
@@ -1013,7 +1015,8 @@ async function generationTool(engine, document, cell, bookId, options = {}) {
             response = { content: [{ type: "text", text: JSON.stringify({ image_asset_id: imageAssetId }) }] };
         }
         else {
-            response = await definition.handler(prepared.input);
+            response = await withBookContext({ bookId, engine, operation: prepared.tool, runId: options.runId,
+                attemptId: generationId ?? undefined, model: prepared.model }, () => definition.handler(prepared.input));
         }
     }
     catch (cause) {
@@ -2606,6 +2609,21 @@ async function finishAwaitingNotebookCell(engine, input) {
         throw new Error(refreshed.error.message);
     return { outputArtifactId, document: refreshed.value };
 }
+function withFailedGenerationPlan(document, cellId, runId, error, updatedAt) {
+    return {
+        ...document,
+        generationPlans: (document.generationPlans ?? []).map((record) => record.cellId === cellId
+            && (record.status === "queued" || record.status === "awaiting-output")
+            && generationPlanClaimRunId(record.plan) === runId
+            ? {
+                ...record,
+                status: "failed",
+                updatedAt,
+                error: truncateGenerationError(error),
+            }
+            : record),
+    };
+}
 async function failAwaitingNotebookCell(engine, input, message) {
     const updatedAt = new Date().toISOString();
     const result = await mutateNotebook(engine, input.notebookId, "fail_notebook_provider_output", (document) => {
@@ -2625,7 +2643,7 @@ async function failAwaitingNotebookCell(engine, input, message) {
             : undefined) ?? cell.id;
         const current = executionState(document)[failTargetId]
             ?? executionState(document)[cell.id];
-        const withFailure = withExecution(document, failTargetId, {
+        const withFailure = withExecution(withFailedGenerationPlan(document, cell.id, input.runId, message, updatedAt), failTargetId, {
             fingerprint: current?.fingerprint
                 ?? notebookCellFingerprint(document, cell),
             status: "error",

package/dist/jobs/xai-paygate.js

@@ -1,3 +1,4 @@
+import { withHarCapture } from "../har-capture.js";
 import { createXai } from "../usage-providers.js";
 import { mintOtp } from "@apicity/cost";
 import { ensurePaygateSecret } from "./kie-paygate.js";
@@ -21,6 +22,8 @@ export function mintXaiOtp(dotPath, request, ttlSeconds = 10 * 60) {
     });
 }
 export async function callXaiPaid(method, dotPath, request) {
-    assertProviderPayload(request, { toolName: dotPath, wire: true });
-    return method(request, { otp: mintXaiOtp(dotPath, request) });
+    return withHarCapture({ provider: "xai", endpoint: dotPath, input: request }, () => {
+        assertProviderPayload(request, { toolName: dotPath, wire: true });
+        return method(request, { otp: mintXaiOtp(dotPath, request) });
+    });
 }