videobook 0.2.5 → 0.3.1

package/dist/media-library.js

@@ -7,9 +7,9 @@ import { markDescendantsStale } from "./notebook-action-catalog.js";
 import { mutateNotebook } from "./notebook-mutations.js";
 import { searchReferenceStore } from "./search-reference-store.js";
 import { comparableHitScore } from "./search-scoring.js";
-import { buildAssetList } from "./tools/reconcile-project-work.js";
+import { projectLibraryAsset, readLibraryCandidates, } from "./library-asset-projection.js";
 import { assetRecency, readAssetUsage, recordAssetUse } from "./asset-usage.js";
-import { matchesTagFilter, tagFacetCounts, transferAssetTags, } from "./asset-tags.js";
+import { tagFacetCounts, transferAssetTags, } from "./asset-tags.js";
 import { addStatusCounts, countBrowseStatuses, emptyStatusCounts, matchesBrowseStatus, pageLibraryAssets, } from "./library-browse.js";
 function isMediaCellType(value) {
     return value === "audio" || value === "image" || value === "video";
@@ -101,9 +101,12 @@ export async function setNotebookMediaSlot(engine, input) {
         revision: result.value.hash,
     };
 }
-function kindMatches(requested, kind) {
-    return requested.has(kind)
-        || (kind === "final" && requested.has("video"));
+function libraryArtifactKinds(requested) {
+    return [
+        ...(requested.has("audio") ? ["audio"] : []),
+        ...(requested.has("image") ? ["image"] : []),
+        ...(requested.has("video") ? ["video", "final"] : []),
+    ];
 }
 function searchRank(asset, query) {
     if (!query)
@@ -143,175 +146,177 @@ function compareRecentlyUsed(left, right) {
         ? created
         : left.artifact_id.localeCompare(right.artifact_id);
 }
-export async function searchLibraryAssets(books, input) {
-    await books.ready();
-    const query = input.query?.trim().toLowerCase() ?? "";
-    const requested = new Set(input.kinds);
-    const prepared = input.referenceId
-        ? searchReferenceStore.get(input.referenceId).reference
-        : undefined;
-    const searching = Boolean(query || prepared);
-    const browseStatus = searching
-        ? "ready"
-        : (input.browseStatus ?? "ready");
-    const artifactKinds = [
-        ...(requested.has("audio") ? ["audio"] : []),
-        ...(requested.has("image") ? ["image"] : []),
-        ...(requested.has("video") ? ["video", "final"] : []),
-    ];
-    const summaries = books.list({ sort: "newest" });
-    const results = await Promise.allSettled(summaries.map(async (summary) => {
-        const book = books.get(summary.bookId);
-        if (!book.ok)
-            throw new Error(book.error.message);
-        const engine = book.value.engine;
-        const builtAssets = await engine.withLocalMedia(() => buildAssetList(engine, summary.bookId, "newest"));
-        const usage = readAssetUsage(engine);
-        const eligible = builtAssets
-            .filter((asset) => kindMatches(requested, asset.type)
-            && matchesTagFilter(asset.tags ?? undefined, input.tags))
-            .map((asset) => ({
-            ...asset,
-            owning_book_id: summary.bookId,
-            owning_book_name: summary.name,
-            last_used_at: lastUsedAt(usage.get(asset.artifact_id)),
-        }));
-        const statusCounts = countBrowseStatuses(eligible);
-        const readyAssets = eligible.filter((asset) => asset.status === "ready");
-        const assets = searching
-            ? readyAssets
-            : eligible.filter((asset) => matchesBrowseStatus(asset.status, browseStatus));
-        let hits = [];
-        let searchError;
-        let preparationJob;
-        if (searching) {
-            registerLocalClipSearchProvider(engine);
-            const searchQuery = {
-                ...(query ? { text: query } : {}),
-                modalities: query
-                    ? ["visual", "metadata"]
-                    : ["visual"],
-                artifactKinds,
-                sourceArtifactIds: readyAssets.map((asset) => asset.artifact_id),
-                limit: 100,
-            };
-            const result = prepared
-                ? await engine.temporalSearch.queryPrepared(searchQuery, prepared, input.referenceRange ? { range: input.referenceRange } : {})
-                : await engine.temporalSearch.query(searchQuery);
-            if (result.ok) {
-                hits = result.value.hits;
-            }
-            else if (result.error.code === "NOT_READY" && result.error.details?.requiresIndexPreparation) {
-                preparationJob = await enqueueTemporalSearchPreparation(summary.bookId);
-            }
-            else {
-                searchError = result.error.message;
-            }
-        }
-        return {
-            assets,
-            statusCounts,
-            hits,
-            searchError,
-            preparationJob,
-            unindexed: missingVisualIndexes(engine, readyAssets).length,
-        };
+function compareNewest(left, right) {
+    const created = Date.parse(right.created_at) - Date.parse(left.created_at);
+    return created !== 0
+        ? created
+        : left.artifact_id.localeCompare(right.artifact_id);
+}
+function entryKey(entry) {
+    return `${entry.owning_book_id}:${entry.artifact_id}`;
+}
+async function querySemanticHits(engine, plan, readyEntries) {
+    registerLocalClipSearchProvider(engine);
+    const searchQuery = {
+        ...(plan.query ? { text: plan.query } : {}),
+        modalities: plan.query
+            ? ["visual", "metadata"]
+            : ["visual"],
+        artifactKinds: plan.searchKinds,
+        sourceArtifactIds: readyEntries.map((entry) => entry.artifact_id),
+        limit: 100,
+    };
+    const result = plan.prepared
+        ? await engine.temporalSearch.queryPrepared(searchQuery, plan.prepared, plan.referenceRange ? { range: plan.referenceRange } : {})
+        : await engine.temporalSearch.query(searchQuery);
+    return result.ok ? { ok: true, value: result.value.hits } : result;
+}
+async function searchBook(books, summary, plan) {
+    const book = books.get(summary.bookId);
+    if (!book.ok)
+        throw new Error(book.error.message);
+    const engine = book.value.engine;
+    const candidates = await engine.withLocalMedia(() => readLibraryCandidates(engine, {
+        kinds: plan.candidateKinds,
+        ...(plan.tags ? { tags: plan.tags } : {}),
     }));
-    const errors = [];
-    const assets = [];
-    let statusCounts = emptyStatusCounts();
-    const semanticHits = [];
-    results.forEach((result, index) => {
-        if (result.status === "fulfilled") {
-            assets.push(...result.value.assets);
-            statusCounts = addStatusCounts(statusCounts, result.value.statusCounts);
-            semanticHits.push(...result.value.hits.map((hit) => ({
-                key: `${summaries[index]?.bookId ?? "unknown"}:${hit.artifactId}`,
-                hit,
-            })));
-            if (result.value.searchError) {
-                errors.push({
-                    book_id: summaries[index]?.bookId ?? "unknown",
-                    message: result.value.searchError,
-                });
-            }
-            return;
-        }
-        const book = summaries[index];
-        errors.push({
-            book_id: book?.bookId ?? "unknown",
-            message: result.reason instanceof Error
-                ? result.reason.message
-                : String(result.reason),
-        });
-    });
-    const metadataRank = new Map(assets
-        .filter((asset) => !prepared && matchesQuery(asset, query))
-        .sort((left, right) => {
-        const rank = searchRank(left, query) - searchRank(right, query);
-        if (rank !== 0)
-            return rank;
-        const created = Date.parse(right.created_at) - Date.parse(left.created_at);
-        return created !== 0
-            ? created
-            : left.artifact_id.localeCompare(right.artifact_id);
-    })
-        .map((asset, index) => [
-        `${asset.owning_book_id}:${asset.artifact_id}`,
-        index + 1,
-    ]));
-    semanticHits.sort((left, right) => comparableHitScore(right.hit) - comparableHitScore(left.hit)
+    const usage = readAssetUsage(engine);
+    const eligible = candidates.map((candidate) => ({
+        ...candidate,
+        owning_book_id: summary.bookId,
+        owning_book_name: summary.name,
+        last_used_at: lastUsedAt(usage.get(candidate.artifact_id)),
+    }));
+    const readyEntries = eligible.filter((entry) => entry.status === "ready");
+    const result = {
+        entries: plan.searching
+            ? readyEntries
+            : eligible.filter((entry) => matchesBrowseStatus(entry.status, plan.browseStatus)),
+        statusCounts: countBrowseStatuses(eligible),
+        hits: [],
+        unindexed: plan.indexCoverage ? missingVisualIndexes(engine, readyEntries).length : 0,
+    };
+    if (!plan.searching)
+        return result;
+    const hits = await querySemanticHits(engine, plan, readyEntries);
+    if (hits.ok)
+        return { ...result, hits: hits.value };
+    if (hits.error.code === "NOT_READY" && hits.error.details?.requiresIndexPreparation) {
+        return { ...result, preparationJob: await enqueueTemporalSearchPreparation(summary.bookId) };
+    }
+    return { ...result, searchError: hits.error.message };
+}
+function rankEntries(entries, semanticHits, plan) {
+    if (!plan.searching) {
+        return [...entries].sort(compareRecentlyUsed).map((entry) => ({ entry, hit: undefined }));
+    }
+    const metadataRank = new Map(entries
+        .filter((entry) => !plan.prepared && matchesQuery(entry, plan.query))
+        .sort((left, right) => searchRank(left, plan.query) - searchRank(right, plan.query)
+        || compareNewest(left, right))
+        .map((entry, index) => [entryKey(entry), index + 1]));
+    const sortedHits = [...semanticHits].sort((left, right) => comparableHitScore(right.hit) - comparableHitScore(left.hit)
         || left.key.localeCompare(right.key));
     const semanticRank = new Map();
     const semanticMatch = new Map();
-    for (const item of semanticHits) {
+    for (const item of sortedHits) {
         if (semanticRank.has(item.key))
             continue;
         semanticRank.set(item.key, semanticRank.size + 1);
         semanticMatch.set(item.key, item.hit);
     }
-    const ranked = assets
-        .flatMap((asset) => {
-        const key = `${asset.owning_book_id}:${asset.artifact_id}`;
+    return entries
+        .flatMap((entry) => {
+        const key = entryKey(entry);
         const metadata = metadataRank.get(key);
         const semantic = semanticRank.get(key);
-        if ((query || prepared) && metadata === undefined && semantic === undefined) {
+        if (metadata === undefined && semantic === undefined)
             return [];
-        }
-        const hit = semanticMatch.get(key);
         return [{
-                asset: hit
-                    ? {
-                        ...asset,
-                        search_match: {
-                            score: comparableHitScore(hit),
-                            location: hit.location,
-                        },
-                    }
-                    : asset,
+                entry,
+                hit: semanticMatch.get(key),
                 score: (metadata === undefined ? 0 : 1 / (60 + metadata))
                     + (semantic === undefined ? 0 : 1 / (60 + semantic)),
             }];
     })
-        .sort((left, right) => {
-        const rank = right.score - left.score;
-        if (rank !== 0)
-            return rank;
-        const created = Date.parse(right.asset.created_at) - Date.parse(left.asset.created_at);
-        return created !== 0
-            ? created
-            : left.asset.artifact_id.localeCompare(right.asset.artifact_id);
-    })
-        .map((item) => item.asset);
-    if (!query && !prepared)
-        ranked.sort(compareRecentlyUsed);
-    const paged = pageLibraryAssets(ranked, {
+        .sort((left, right) => right.score - left.score || compareNewest(left.entry, right.entry))
+        .map(({ entry, hit }) => ({ entry, hit }));
+}
+async function projectLibraryEntry(books, entry, hit) {
+    const book = books.get(entry.owning_book_id);
+    if (!book.ok)
+        throw new Error(book.error.message);
+    const engine = book.value.engine;
+    const row = await engine.withLocalMedia(() => projectLibraryAsset(engine, entry.owning_book_id, entry));
+    return {
+        ...row,
+        owning_book_id: entry.owning_book_id,
+        owning_book_name: entry.owning_book_name,
+        last_used_at: entry.last_used_at,
+        ...(hit
+            ? { search_match: { score: comparableHitScore(hit), location: hit.location } }
+            : {}),
+    };
+}
+function librarySearchPlan(input) {
+    const query = input.query?.trim().toLowerCase() ?? "";
+    const prepared = input.referenceId
+        ? searchReferenceStore.get(input.referenceId).reference
+        : undefined;
+    const searching = Boolean(query || prepared);
+    const searchKinds = libraryArtifactKinds(new Set(input.kinds));
+    return {
+        query,
+        prepared,
+        referenceRange: input.referenceRange,
+        searching,
+        browseStatus: searching ? "ready" : (input.browseStatus ?? "ready"),
+        candidateKinds: new Set(searchKinds),
+        searchKinds,
+        tags: input.tags,
+        indexCoverage: input.indexCoverage ?? searching,
+    };
+}
+export async function searchLibraryAssets(books, input) {
+    await books.ready();
+    const plan = librarySearchPlan(input);
+    const summaries = books.list({ sort: "newest" });
+    const results = await Promise.allSettled(summaries.map((summary) => searchBook(books, summary, plan)));
+    const errors = [];
+    const entries = [];
+    let statusCounts = emptyStatusCounts();
+    const semanticHits = [];
+    results.forEach((result, index) => {
+        const bookId = summaries[index]?.bookId ?? "unknown";
+        if (result.status === "rejected") {
+            errors.push({
+                book_id: bookId,
+                message: result.reason instanceof Error
+                    ? result.reason.message
+                    : String(result.reason),
+            });
+            return;
+        }
+        entries.push(...result.value.entries);
+        statusCounts = addStatusCounts(statusCounts, result.value.statusCounts);
+        semanticHits.push(...result.value.hits.map((hit) => ({
+            key: `${bookId}:${hit.artifactId}`,
+            hit,
+        })));
+        if (result.value.searchError) {
+            errors.push({ book_id: bookId, message: result.value.searchError });
+        }
+    });
+    const ranked = rankEntries(entries, semanticHits, plan);
+    const paged = pageLibraryAssets(ranked.map(({ entry }) => entry), {
         offset: input.offset ?? 0,
         limit: input.limit ?? 50,
     });
+    const offset = input.offset ?? 0;
+    const pageHits = ranked.slice(offset, offset + paged.pageAssets.length);
     return {
-        assets: paged.pageAssets,
-        tag_facets: tagFacetCounts(ranked),
+        assets: await Promise.all(pageHits.map(({ entry, hit }) => projectLibraryEntry(books, entry, hit))),
+        tag_facets: tagFacetCounts(paged.matching),
         unindexed_visual_assets: results.reduce((count, result) => count + (result.status === "fulfilled" ? result.value.unindexed : 0), 0),
         preparationJobs: results.flatMap((result) => result.status === "fulfilled" && result.value.preparationJob
             ? [result.value.preparationJob]

package/dist/notebook-sticky-settings.js

@@ -0,0 +1,60 @@
+import { tryResolveModel } from "./media/descriptor.js";
+import { parseStickySettings, stickySettingGroup, stickySettingsFor, stickySettingsFrom, takesDuration, } from "./media/preferred-defaults.js";
+import { controlsForModel } from "./notebook-generation-controls.js";
+function settingsKey(notebookId) {
+    return `notebook-generation-settings:${notebookId}`;
+}
+function generationSettingsOf(cell) {
+    const settings = cell?.inputs?.generationSettings;
+    return settings && typeof settings === "object" && !Array.isArray(settings)
+        ? settings
+        : {};
+}
+function changedSettings(previous, next) {
+    return Object.fromEntries(Object.entries(next).filter(([name, value]) => previous[name] !== value));
+}
+export function readNotebookStickySettings(engine, notebookId) {
+    const stored = engine.settings.get(settingsKey(notebookId));
+    return stored ? parseStickySettings(stored) : {};
+}
+export function rememberNotebookStickySettings(engine, notebookId, next, previous) {
+    const changed = stickySettingsFrom(changedSettings(generationSettingsOf(previous), generationSettingsOf(next)));
+    if (Object.keys(changed).length === 0)
+        return;
+    const written = engine.settings.set(settingsKey(notebookId), {
+        ...readNotebookStickySettings(engine, notebookId),
+        ...changed,
+    });
+    if (!written.ok)
+        throw new Error(written.error.message);
+}
+function stickyControlsFor(model) {
+    const resolved = tryResolveModel(model);
+    if (!resolved)
+        return [];
+    const timed = takesDuration(resolved.entry);
+    return controlsForModel(resolved).flatMap((control) => {
+        const group = stickySettingGroup(control.name);
+        if (!group || (group === "duration" && !timed))
+            return [];
+        return [{
+                name: control.name,
+                valueType: control.valueType,
+                options: control.options ?? [],
+                ...(control.minimum === undefined ? {} : { minimum: control.minimum }),
+                ...(control.maximum === undefined ? {} : { maximum: control.maximum }),
+            }];
+    });
+}
+export function seedNotebookStickySettings(cell, sticky) {
+    if (!cell.model || Object.keys(sticky).length === 0)
+        return cell;
+    const explicit = generationSettingsOf(cell);
+    const seeded = stickySettingsFor(stickyControlsFor(cell.model).filter((control) => explicit[control.name] === undefined), sticky);
+    if (Object.keys(seeded).length === 0)
+        return cell;
+    return {
+        ...cell,
+        inputs: { ...(cell.inputs ?? {}), generationSettings: { ...seeded, ...explicit } },
+    };
+}

package/dist/package-version.js

@@ -0,0 +1,18 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+export function installedPackageVersion(name) {
+    let dir = dirname(fileURLToPath(import.meta.resolve(name)));
+    while (dir !== dirname(dir)) {
+        try {
+            const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+            if (manifest.name === name && manifest.version)
+                return manifest.version;
+        }
+        catch {
+            void 0;
+        }
+        dir = dirname(dir);
+    }
+    return "unknown";
+}

package/dist/posts/dropbox-auth.js

@@ -1,6 +1,6 @@
 import { createHash, randomBytes } from "node:crypto";
 import { createServer } from "node:http";
-import { createDropbox } from "@apicity/dropbox";
+import { createDropbox } from "../usage-providers.js";
 import { appState } from "../app-state.js";
 const KEY = "dropbox.oauth.tokens";
 const REDIRECT = "http://127.0.0.1:8766/callback";

package/dist/posts/post-metrics.js

@@ -1,4 +1,5 @@
-import { createX, XError } from "@apicity/x";
+import { createX } from "../usage-providers.js";
+import { XError } from "@apicity/x";
 import { v7 as uuidv7 } from "uuid";
 import { getValidAccessToken } from "../x/x-tokens.js";
 import { listBookEngines, queue } from "../queue.js";

package/dist/provider-usage.js

@@ -1,26 +1,9 @@
 import { randomUUID } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { createCost, PRICING, PRICING_AS_OF } from "@apicity/cost";
 import { modelEntry } from "./media/catalog.js";
 import { estimateFalRequest } from "./media/cost.js";
 import { currentBookContext } from "./book-context.js";
-function installedPackageVersion(name) {
-    let dir = dirname(fileURLToPath(import.meta.resolve(name)));
-    while (dir !== dirname(dir)) {
-        try {
-            const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
-            if (manifest.name === name && manifest.version)
-                return manifest.version;
-        }
-        catch {
-            void 0;
-        }
-        dir = dirname(dir);
-    }
-    return "unknown";
-}
+import { installedPackageVersion } from "./package-version.js";
 const COST_PACKAGE_VERSION = installedPackageVersion("@apicity/cost");
 const incomplete = new WeakSet();
 const cost = createCost();

package/dist/queue.js

@@ -1,3 +1,4 @@
+import { sweepHarCaptures } from "./har-retention.js";
 import { appendDiagnostic, registerDiagnosticName } from "./diagnostics.js";
 import { createEngine, } from "videobook-engine";
 import { activeBookEngine, withBookContext } from "./book-context.js";
@@ -54,11 +55,13 @@ export function isProviderPollDriverActive(bookId) {
     const info = runnerByBook.get(bookId);
     return info?.providerPollTimer != null;
 }
+let harRetentionTimer = null;
 async function tickProviderPoll(info) {
     if (info.providerPollInFlight || info.pollAbort.signal.aborted)
         return;
     info.providerPollInFlight = true;
     try {
+        await sweepHarCaptures();
         if (providerPollWorkHook) {
             await providerPollWorkHook(info.pollAbort.signal);
         }
@@ -258,7 +261,10 @@ function makeWrappedResolver(bookId, engine) {
         const handler = handlers.get(type);
         if (!handler)
             return null;
-        return async (job, queueSignal) => withBookContext({ bookId, engine, operation: type, ...(job.artifactId ? { artifactId: job.artifactId } : {}) }, () => runWithJobDeadline(type, async (signal) => {
+        return async (job, queueSignal) => withBookContext({ bookId, engine, operation: type, ...(job.artifactId ? { artifactId: job.artifactId } : {}),
+            ...(typeof job.payload.runId === "string" ? { runId: job.payload.runId } : {}),
+            ...(typeof job.payload.generationId === "string" ? { attemptId: job.payload.generationId } : {}),
+            ...(typeof job.payload.model === "string" ? { model: job.payload.model } : {}) }, () => runWithJobDeadline(type, async (signal) => {
             const jobSignal = queueSignal
                 ? AbortSignal.any([signal, queueSignal])
                 : signal;
@@ -579,6 +585,8 @@ export const queue = {
         };
     },
     async start() {
+        await sweepHarCaptures(true);
+        harRetentionTimer ??= setInterval(() => { void sweepHarCaptures(); }, 60_000).unref();
         await ensureJobHandlersLoaded();
         await reconcileQueueOnStartup();
     },
@@ -586,6 +594,9 @@ export const queue = {
         await ensureRunner(bookId);
     },
     async stop() {
+        if (harRetentionTimer)
+            clearInterval(harRetentionTimer);
+        harRetentionTimer = null;
         if (stoppingQueue)
             return stoppingQueue;
         const pending = stopQueueRunners();

package/dist/serve.js

@@ -1,3 +1,4 @@
+import { flushHarCaptures } from "./har-capture.js";
 import { once } from "node:events";
 import { setTimeout as delay } from "node:timers/promises";
 import { stopAceServer } from "./acestep/process.js";
@@ -22,6 +23,7 @@ async function shutdownServices(services) {
     await services.voiceSessions.close();
     await services.mcpHandler.close();
     await queue.stop();
+    await flushHarCaptures();
     await stopAceServer();
     await bookManager.close();
 }

package/dist/tools/api-status.js

@@ -1,4 +1,4 @@
-import { createKimiCoding } from "@apicity/kimicoding";
+import { createKimiCoding } from "../usage-providers.js";
 import { isPlaceholderApiKey } from "../api-key.js";
 export function apiStatusDef() {
     return {

package/dist/tools/generate-media.js

@@ -1,3 +1,4 @@
+import { currentBookContext } from "../book-context.js";
 import { z } from "zod";
 import { queue } from "../queue.js";
 import { generationLabel } from "../artifact-label.js";
@@ -92,6 +93,8 @@ async function enqueueGeneration(engine, model, args, refs) {
     const jobId = `generate-${model.media}-${artifactId}-${Date.now()}`;
     const job = {
         type: "generate_media",
+        runId: currentBookContext()?.runId,
+        generationId: currentBookContext()?.attemptId,
         model: model.id,
         bookId: String(args.book_id),
         assetId: artifactId,

package/dist/tools/generation-payload.js

@@ -1,20 +1,34 @@
 import { z } from "zod";
+import { captureKeys, generationHarStatus } from "../generation-har.js";
+import { readHarSettings } from "../har-settings.js";
+import { logger } from "../logger.js";
 import { readProviderTaskStatus } from "../provider-task-status.js";
+async function inspectionHar(engine, assetId) {
+    try {
+        const { mode } = await readHarSettings();
+        return await generationHarStatus(await captureKeys(engine, [assetId]), mode);
+    }
+    catch (error) {
+        logger.warn("har-capture-failed", { error });
+        return null;
+    }
+}
 export function generationPayloadDef(engine) {
     return {
         name: "inspect_generation_request",
-        description: "Read the persisted provider request payload, task details, status-page information, and failure info for a single asset. Used by the generating-cell inspector to show what was sent to the provider.",
+        description: "Read the persisted provider request payload, task details, status-page information, failure info and HAR capture status for a single asset. Used by the generating-cell inspector to show what was sent to the provider.",
         schema: {
             book_id: z.string().describe("Book id"),
             asset_id: z.string().describe("Artifact id"),
         },
         handler: async (args) => {
             const { book_id: _book_id, asset_id } = args;
-            const [payloadRes, taskRes, errorRes, providerTask] = await Promise.all([
+            const [payloadRes, taskRes, errorRes, providerTask, har] = await Promise.all([
                 engine.metadata.artifacts.read(asset_id, "generation-payload"),
                 engine.jobs.pending.read(asset_id),
                 engine.jobs.failures.read(asset_id),
                 readProviderTaskStatus(engine, asset_id),
+                inspectionHar(engine, asset_id),
             ]);
             const task = taskRes.ok ? taskRes.value : null;
             const errorRecord = errorRes.ok ? errorRes.value : null;
@@ -32,6 +46,7 @@ export function generationPayloadDef(engine) {
                 error,
                 taskType: task ? task.taskType : null,
                 providerTask,
+                har,
                 task: task
                     ? {
                         taskId: task.taskId,

package/dist/tools/get-generation-har.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { generationCaptureKeys, generationHar } from "../generation-har.js";
+import { readHarSettings } from "../har-settings.js";
+function errorResult(message) {
+    return { isError: true, content: [{ type: "text", text: message }] };
+}
+export function getGenerationHarDef(engine) {
+    return {
+        name: "get_generation_har",
+        description: "Return the scrubbed provider HAR capture of one generation attempt, by attempt id or asset id. Several captured calls are combined into one HAR with a page per call. Needs provider capture (set_har_capture).",
+        schema: {
+            book_id: z.string().describe("Book id"),
+            generation_id: z.string().min(1).describe("Generation attempt id or its asset id"),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+        handler: async (args) => {
+            const { generation_id } = args;
+            try {
+                const result = await generationHar(await generationCaptureKeys(engine, generation_id), generation_id);
+                if (!result) {
+                    const { mode } = await readHarSettings();
+                    return errorResult(mode === "off"
+                        ? "No HAR capture for this generation. Provider capture is off; turn it on in Settings > Diagnostics or with set_har_capture."
+                        : "No HAR capture for this generation.");
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                generationId: generation_id,
+                                filename: `videobook-generation-${generation_id.replace(/[^A-Za-z0-9._-]+/gu, "-")}.har`,
+                                captures: result.captures,
+                                har: result.har,
+                            }),
+                        }],
+                };
+            }
+            catch (error) {
+                return errorResult(error instanceof Error ? error.message : String(error));
+            }
+        },
+    };
+}