videobook 0.2.4 → 0.3.0

package/dist/har-export.js

@@ -0,0 +1,238 @@
+import { createHash, randomUUID } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { mkdir, readdir, readFile, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createGzip } from "node:zlib";
+import { scrubHar } from "@apicity/har";
+import { captureFilePath, readCaptureFile, readHarIndex } from "./har-index.js";
+import { installedPackageVersion } from "./package-version.js";
+const BLOCK = 512;
+const OWN_VERSION = createRequire(import.meta.url)("../package.json").version;
+function isHarArchivePath(path) {
+    return /\.(?:tar\.gz|tgz)$/iu.test(path);
+}
+export function selectHarRows(rows, selection) {
+    const seen = new Set();
+    return rows.filter((row) => {
+        if (seen.has(row.file))
+            return false;
+        seen.add(row.file);
+        return (selection.since == null || Date.parse(row.ts) >= selection.since)
+            && (!selection.failures || row.outcome !== "ok")
+            && (!selection.providers?.length || selection.providers.includes(row.provider));
+    });
+}
+function emptyOutcomes() {
+    return { ok: 0, provider_error: 0, local_error: 0, network_error: 0 };
+}
+function sha256(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+function verifiedMeta(row, har) {
+    const meta = har.log._apicity;
+    return {
+        ts: meta?.startedAt ?? row.ts,
+        callId: meta?.callId ?? row.callId,
+        provider: meta?.provider ?? row.provider,
+        endpoint: meta?.endpoint ?? row.endpoint,
+        outcome: meta?.outcome ?? row.outcome,
+        status: meta?.status ?? row.status ?? null,
+        context: meta?.context ?? row.context ?? null,
+    };
+}
+function manifestFor(captures, options) {
+    const outcomes = emptyOutcomes();
+    const providers = new Map();
+    const endpoints = new Map();
+    for (const { meta } of captures) {
+        outcomes[meta.outcome] += 1;
+        const provider = providers.get(meta.provider) ?? { provider: meta.provider, calls: 0, outcomes: emptyOutcomes() };
+        provider.calls += 1;
+        provider.outcomes[meta.outcome] += 1;
+        providers.set(meta.provider, provider);
+        const key = JSON.stringify([meta.provider, meta.endpoint]);
+        const endpoint = endpoints.get(key) ?? { provider: meta.provider, endpoint: meta.endpoint, calls: 0, outcomes: emptyOutcomes() };
+        endpoint.calls += 1;
+        endpoint.outcomes[meta.outcome] += 1;
+        endpoints.set(key, endpoint);
+    }
+    const times = captures.map(({ meta }) => meta.ts).sort();
+    return {
+        format: "videobook-har-export",
+        version: 1,
+        createdAt: (options.now ?? new Date()).toISOString(),
+        videobook: OWN_VERSION,
+        apicity: {
+            har: installedPackageVersion("@apicity/har"),
+            captured: [...new Set(captures.map((capture) => capture.apicityVersion))].sort(),
+        },
+        filters: {
+            since: options.since == null ? null : new Date(options.since).toISOString(),
+            failures: Boolean(options.failures),
+            providers: options.providers?.length ? [...options.providers] : null,
+        },
+        files: captures.length,
+        dateRange: { first: times[0] ?? null, last: times.at(-1) ?? null },
+        outcomes,
+        providers: [...providers.values()].sort((a, b) => a.provider.localeCompare(b.provider)),
+        endpoints: [...endpoints.values()].sort((a, b) => a.provider.localeCompare(b.provider) || a.endpoint.localeCompare(b.endpoint)),
+    };
+}
+function indexLines(captures) {
+    return captures.map(({ file, meta }) => `${JSON.stringify({
+        ts: meta.ts,
+        callId: meta.callId,
+        provider: meta.provider,
+        endpoint: meta.endpoint,
+        outcome: meta.outcome,
+        ...(meta.status === null ? {} : { status: meta.status }),
+        file,
+        ...(meta.context ? { context: meta.context } : {}),
+    })}\n`).join("");
+}
+async function* exportEntries(captures, manifest) {
+    yield { path: "manifest.json", bytes: Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`) };
+    yield { path: "index.jsonl", bytes: Buffer.from(indexLines(captures)) };
+    for (const capture of captures) {
+        const bytes = await readFile(capture.path);
+        if (sha256(bytes) !== capture.sha256)
+            throw new Error(`${capture.path} changed during the export; run it again`);
+        yield { path: capture.file, bytes };
+    }
+}
+function octal(value, width) {
+    return `${value.toString(8).padStart(width - 1, "0")}\0`;
+}
+function tarHeader(name, size, type, mtime) {
+    const header = Buffer.alloc(BLOCK);
+    header.write(name, 0, 100, "utf8");
+    header.write(octal(0o600, 8), 100, "ascii");
+    header.write(octal(0, 8), 108, "ascii");
+    header.write(octal(0, 8), 116, "ascii");
+    header.write(octal(size, 12), 124, "ascii");
+    header.write(octal(Math.floor(mtime / 1000), 12), 136, "ascii");
+    header.write(" ".repeat(8), 148, "ascii");
+    header.write(type, 156, "ascii");
+    header.write("ustar\0", 257, "ascii");
+    header.write("00", 263, "ascii");
+    const checksum = header.reduce((sum, byte) => sum + byte, 0);
+    header.write(`${checksum.toString(8).padStart(6, "0")}\0 `, 148, "ascii");
+    return header;
+}
+function paxPath(path) {
+    const body = ` path=${path}\n`;
+    const bytes = Buffer.byteLength(body);
+    let length = bytes + String(bytes).length;
+    while (length !== bytes + String(length).length)
+        length = bytes + String(length).length;
+    return Buffer.from(`${length}${body}`);
+}
+function padding(size) {
+    return Buffer.alloc((BLOCK - (size % BLOCK)) % BLOCK);
+}
+async function* tarBlocks(entries, root, mtime) {
+    for await (const entry of entries) {
+        const name = `${root}/${entry.path}`;
+        if (Buffer.byteLength(name) > 100) {
+            const pax = paxPath(name);
+            yield tarHeader("PaxHeader", pax.length, "x", mtime);
+            yield pax;
+            yield padding(pax.length);
+        }
+        yield tarHeader(name, entry.bytes.length, "0", mtime);
+        yield entry.bytes;
+        yield padding(entry.bytes.length);
+    }
+    yield Buffer.alloc(BLOCK * 2);
+}
+async function writeArchive(out, entries, mtime) {
+    const root = basename(out).replace(/\.(?:tar\.gz|tgz)$/iu, "") || "videobook-har";
+    const partial = join(dirname(out), `.${basename(out)}.${randomUUID()}.partial`);
+    try {
+        await pipeline(Readable.from(tarBlocks(entries, root, mtime)), createGzip(), createWriteStream(partial, { flags: "wx", mode: 0o600 }));
+        await rename(partial, out);
+    }
+    catch (error) {
+        await rm(partial, { force: true });
+        throw error;
+    }
+}
+async function writeDirectory(out, entries) {
+    const partial = join(dirname(out), `.${basename(out)}.${randomUUID()}.partial`);
+    try {
+        await mkdir(partial, { mode: 0o700 });
+        for await (const entry of entries) {
+            const target = join(partial, ...entry.path.split("/"));
+            await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+            await writeFile(target, entry.bytes, { flag: "wx", mode: 0o600 });
+        }
+        await rmdir(out).catch((error) => {
+            if (error.code !== "ENOENT")
+                throw error;
+        });
+        await rename(partial, out);
+    }
+    catch (error) {
+        await rm(partial, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function outputTaken(out, archive) {
+    try {
+        const info = await stat(out);
+        return archive || !info.isDirectory() || (await readdir(out)).length > 0;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+function inside(parent, child) {
+    const location = relative(resolve(parent), resolve(child));
+    return location === "" || (location !== ".." && !location.startsWith(`..${sep}`) && !isAbsolute(location));
+}
+export async function exportHarCaptures(options) {
+    const archive = isHarArchivePath(options.out);
+    if (inside(options.dir, options.out))
+        return { status: "out-inside-captures", out: options.out };
+    if (await outputTaken(options.out, archive))
+        return { status: "out-exists", out: options.out };
+    const verified = [];
+    const skipped = [];
+    const needsScrub = [];
+    for (const row of selectHarRows(await readHarIndex(options.dir), options)) {
+        const capture = await readCaptureFile(options.dir, row.file);
+        if (!capture) {
+            skipped.push(captureFilePath(options.dir, row.file) ?? row.file);
+            continue;
+        }
+        const before = JSON.stringify(capture.har);
+        if (JSON.stringify(scrubHar(structuredClone(capture.har))) !== before) {
+            needsScrub.push(capture.path);
+            continue;
+        }
+        verified.push({
+            path: capture.path,
+            file: row.file.split(/[\\/]/u).join("/"),
+            sha256: sha256(capture.bytes),
+            meta: verifiedMeta(row, capture.har),
+            apicityVersion: capture.har.log.creator?.version ?? "unknown",
+        });
+    }
+    if (needsScrub.length > 0)
+        return { status: "needs-scrub", files: needsScrub };
+    if (verified.length === 0)
+        return { status: "empty", skipped };
+    const manifest = manifestFor(verified, options);
+    const entries = exportEntries(verified, manifest);
+    await mkdir(dirname(options.out), { recursive: true });
+    if (archive)
+        await writeArchive(options.out, entries, (options.now ?? new Date()).getTime());
+    else
+        await writeDirectory(options.out, entries);
+    return { status: "exported", out: options.out, archive, manifest, skipped };
+}

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";

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/complete-provider-task.js

@@ -1,3 +1,4 @@
+import { withHarCapture } from "../har-capture.js";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { writeFile, unlink, readFile as readFsFile } from "node:fs/promises";
@@ -47,7 +48,9 @@ async function reclaimFailedCompletion(engine, task, ctx) {
     return lease.ownerId;
 }
 export function registerCompleteProviderTaskJob(engine) {
-    registerJobHandler("complete_kie_task", async (payload, ctx) => {
+    registerJobHandler("complete_kie_task", async (payload, ctx) => withHarCapture({
+        provider: String(payload.taskType).split("_")[0] ?? "unknown", endpoint: "generation.complete", input: payload,
+    }, async () => {
         const { taskId, taskType, assetId, bookId, meta, resultUrls, resultObject, } = payload;
         // Pattern C: inherit the provider lease via getOwner, abort if the row
         // already terminated, and register the lease so the wrapper's catch path
@@ -125,7 +128,7 @@ export function registerCompleteProviderTaskJob(engine) {
             clearInterval(heartbeat);
             await engine.jobs.locks.release(assetDir);
         }
-    });
+    }, globalThis.fetch, { providerTaskId: payload.taskId, model: payload.meta.model, runId: payload.meta.runId, attemptId: payload.meta.attemptId }));
 }
 async function mediaOutputs(taskType, taskId, urls) {
     if (taskType === MEDIA_TASK_TYPES.machgen)

package/dist/jobs/generate-media.js

@@ -1,3 +1,5 @@
+import { withHarCapture } from "../har-capture.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 +43,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 +52,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 +85,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 }, () => withHarCapture({ provider: resolveModel(job.model).provider, endpoint: "generation.submit", 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,4 +1,4 @@
-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";

package/dist/jobs/kie-paygate.js

@@ -1,5 +1,6 @@
+import { withHarCapture } 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 withHarCapture({ provider: "kie", endpoint: "generation.paygate", input: args.request }, () => submitKieTaskInner(engine, ctx, args));
+}
+export async function submitQueuedKieTask(engine, task) {
+    return withHarCapture({ provider: "kie", endpoint: "generation.queued", input: task }, () => submitQueuedKieTaskInner(engine, task));
+}

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) {

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) });
+    });
 }

package/dist/media/adapters/kie.js

@@ -1,5 +1,6 @@
 import { setTimeout as delay } from "node:timers/promises";
-import { KieError, submitMediaJob } from "@apicity/kie";
+import { submitMediaJob } from "../../usage-providers.js";
+import { KieError } from "@apicity/kie";
 import { createKie } from "../../usage-providers.js";
 import { requireApiKey } from "../../api-key.js";
 import { authorizeKiePaygate, ensurePaygateSecret, mintKieOtp } from "../../jobs/kie-paygate.js";