@gentbajko/slopify 0.7.0 → 0.8.0

package/dist/main.js

@@ -7,6 +7,8 @@ import { buildRegistry } from "./adapter-registry.js";
 import { alignSubtitles } from "./adapters/alignment/index.js";
 import { prepareFfmpeg } from "./adapters/ffmpeg.js";
 import { nodeRunCli } from "./adapters/llm/run-cli.js";
+import { curateRegistry } from "./catalog/registry.js";
+import { createCatalogueStore } from "./catalog/store.js";
 import { createHub } from "./edge/events/hub.js";
 import { createApp } from "./edge/http/app.js";
 import { createAudioPreviewStore } from "./kernel/audio-preview.js";
@@ -21,11 +23,13 @@ import { sqliteAttempts } from "./kernel/runner/attempt-repo.js";
 import { dependenciesOf } from "./kernel/runner/graph.js";
 import { createRunner } from "./kernel/runner/index.js";
 import { stageProviders } from "./kernel/runner/providers.js";
+import { createProviderQueue } from "./kernel/runner/queue.js";
 import { readVersion } from "./kernel/version.js";
 import { modelSources } from "./model-catalog.js";
 import { claimStage, finishStage, projectById, projectPaused, stagesOf, } from "./slices/admission/repo.js";
 import { prepareProvidedArticleSegments } from "./slices/article/provided-entries.js";
 import { runArticle } from "./slices/article/run.js";
+import { pumpQueue, queueWaiting } from "./slices/batch/index.js";
 import { runImages } from "./slices/images/run.js";
 import { runNarration } from "./slices/narration/run.js";
 import { runResearch } from "./slices/research/run.js";
@@ -78,13 +82,14 @@ export async function boot(config) {
             log,
             post: httpPostEvents(collectorEndpoint(process.env), collectorTimeoutMs),
         }, flushDelayMs);
-        const registry = buildRegistry({
+        const catalogue = createCatalogueStore({ dataDir: paths.dataDir, fetch: globalThis.fetch });
+        const registry = curateRegistry(buildRegistry({
             db,
             fetch: globalThis.fetch,
             spawn: nodeRunCli,
             clock,
             probe: nodeCliProbe,
-        });
+        }), catalogue);
         const audioPreviews = createAudioPreviewStore();
         const runner = wire({
             db,
@@ -96,6 +101,7 @@ export async function boot(config) {
             telemetry,
             flusher,
             registry,
+            catalogue,
             ffmpeg,
             audioPreviews,
         });
@@ -170,6 +176,7 @@ export async function boot(config) {
             updater,
             audioPreviews,
             ...modelSources(registry),
+            catalogue,
             clock,
             ids,
             log,
@@ -179,6 +186,20 @@ export async function boot(config) {
             probe: nodeCliProbe,
         });
         const server = await listen(app, config, log);
+        const queueTimer = setInterval(() => {
+            const release = updater.beginMutation();
+            if (!release)
+                return;
+            try {
+                pumpQueue(updateDb, runner);
+            }
+            catch {
+                log.write("error", "batch.queue", { detail: "The batch queue could not advance." });
+            }
+            finally {
+                release();
+            }
+        }, 1000);
         listeningPort = portOf(server) ?? config.port;
         // Whatever last run left queued goes out at start. Nothing waits for
         // it, and an unreachable collector costs one refused socket.
@@ -188,6 +209,7 @@ export async function boot(config) {
         let stopActivation = () => { };
         shutdown = () => {
             stopping ??= (async () => {
+                clearInterval(queueTimer);
                 stopActivation();
                 audioPreviews.close();
                 try {
@@ -221,7 +243,7 @@ export async function boot(config) {
         throw error;
     }
 }
-function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, ffmpeg, }) {
+function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, catalogue, ffmpeg, }) {
     // A stage counts what it did and the queue is flushed after each new event. `record`
     // swallows its own failures, so this can neither fail a stage nor widen what leaves the
     // machine - the payload allow-list is checked inside it.
@@ -237,11 +259,17 @@ function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flush
     const writing = { db, paths, ids, clock, log, count };
     // A stage slice is handed the wrapped calls, never the registry: every provider call
     // it makes is already inside the retry policy (kernel/runner/providers.ts).
-    const providers = { registry, attempts: sqliteAttempts(db, ids), clock, log };
+    const providers = {
+        registry,
+        attempts: sqliteAttempts(db, ids),
+        clock,
+        log,
+        queue: createProviderQueue((provider) => catalogue.read().providers[provider]?.maxConcurrent ?? 1),
+    };
     return createRunner({
         stages: {
             stagesOf: (projectId) => stagesOf(db, projectId),
-            paused: (projectId) => projectPaused(db, projectId),
+            paused: (projectId) => projectPaused(db, projectId) || queueWaiting(db, projectId),
             dependenciesOf: (projectId, kind) => {
                 const project = projectById(db, projectId);
                 return project === undefined ? [] : dependenciesOf(kind, project.config.sources);
@@ -257,7 +285,14 @@ function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flush
             audio: async (context) => {
                 const wrapped = stageProviders(providers, context);
                 await prepareProvidedArticleSegments(writing, context, wrapped);
-                await runNarration({ ...video, audioPreviews }, context, wrapped);
+                await runNarration({
+                    ...video,
+                    audioPreviews,
+                    maxCharacters: (provider, model) => {
+                        const entry = catalogue.models(provider, "tts").find((m) => m.id === model);
+                        return entry && "tts" in entry ? entry.tts.maxCharacters : 4000;
+                    },
+                }, context, wrapped);
             },
             images: (context) => runImages(writing, context, stageProviders(providers, context)),
             thumbnail: (context) => runThumbnail(writing, context, stageProviders(providers, context)),

package/dist/slices/admission/repo.js

@@ -1,9 +1,14 @@
 import { z } from "zod";
 import { stageKinds, stageStates } from "../../kernel/pipeline.js";
+import { thinkingModes } from "../../kernel/ports/llm.js";
 import { chunkModes } from "../narration/chunk.js";
 import { subtitleConfigSchema } from "../subtitles/model.js";
 import { entryModes, formats, stageSources } from "./model.js";
-const providerChoice = z.object({ provider: z.string(), model: z.string() });
+const providerChoice = z.object({
+    provider: z.string(),
+    model: z.string(),
+    thinking: z.enum(thinkingModes).optional(),
+});
 const entryChoice = z.object({ name: z.string(), mode: z.enum(entryModes) });
 // The shape Play posts and the shape `projects.config` holds, in one place: the second
 // is the first plus the rendered prompt texts.

package/dist/slices/admission/start.js

@@ -13,7 +13,7 @@ export function initialState(source) {
 }
 // The project row, its six stages and the provided content all land together or not at
 // all. The caller ticks the runner after this returns, never inside it.
-export function startRun(deps, draft, rendered) {
+export function startRun(deps, draft, rendered, retainStaged = false) {
     const id = deps.ids.next();
     const at = deps.clock.now().toISOString();
     const config = { ...draft, rendered };
@@ -49,14 +49,14 @@ export function startRun(deps, draft, rendered) {
         for (const stage of stages) {
             insertStage(deps.db, stage);
         }
-        attachProvided(deps, id, draft, moved);
+        attachProvided(deps, id, draft, moved, retainStaged);
     });
-    for (const source of moved) {
+    for (const source of retainStaged ? [] : moved) {
         dropStagedSource(deps, source);
     }
     return { project, stages };
 }
-function attachProvided(deps, projectId, draft, collected) {
+function attachProvided(deps, projectId, draft, collected, retainStaged) {
     const { sources, provided } = draft;
     if (sources.research === "provide" && provided.research !== undefined) {
         storeText(deps, {
@@ -73,24 +73,25 @@ function attachProvided(deps, projectId, draft, collected) {
         storeArticleText(deps, { projectId, markdown: provided.article.trim() });
     }
     if (sources.audio === "provide") {
-        attach(deps, projectId, "audio", provided.audio, "audio_body", collected);
+        attach(deps, projectId, "audio", provided.audio, "audio_body", collected, retainStaged);
     }
     if (sources.thumbnail === "provide") {
-        attach(deps, projectId, "thumbnail", provided.thumbnail, "thumbnail", collected);
+        attach(deps, projectId, "thumbnail", provided.thumbnail, "thumbnail", collected, retainStaged);
     }
     if (sources.images === "provide") {
         // Slideshow order is the order the user left the list in.
         for (const [index, stagedFileId] of (provided.images ?? []).entries()) {
-            attach(deps, projectId, "images", stagedFileId, "image", collected, index + 1);
+            attach(deps, projectId, "images", stagedFileId, "image", collected, retainStaged, index + 1);
         }
     }
 }
-function attach(deps, projectId, kind, stagedFileId, role, collected, index) {
+function attach(deps, projectId, kind, stagedFileId, role, collected, retainStaged, index) {
     if (stagedFileId === undefined) {
         throw new Error(`the ${kind} stage is provided but carries no staged file`);
     }
     const result = attachStagedFile(deps, {
         stagedFileId,
+        retainStaged,
         projectId,
         role,
         ...(index === undefined ? {} : { index }),

package/dist/slices/article/continuation.js

@@ -43,7 +43,13 @@ export async function writeArticle(providers, choice, brief, onDelta) {
             onDelta(event.text);
         }
     };
-    let answer = await providers.llm({ provider: choice.provider, model: choice.model, messages: base, check: written }, stream);
+    let answer = await providers.llm({
+        provider: choice.provider,
+        model: choice.model,
+        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
+        messages: base,
+        check: written,
+    }, stream);
     const pieces = [answer.text];
     let tokens = plusUsage(noTokens, answer.usage);
     for (let n = 1; truncated(answer) && n <= continuationLimit; n += 1) {
@@ -52,6 +58,7 @@ export async function writeArticle(providers, choice, brief, onDelta) {
         answer = await providers.llm({
             provider: choice.provider,
             model: choice.model,
+            ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
             messages,
             // The last continuation allowed is the one that has to end the article: a fourth
             // truncation is a failed attempt, which is the wrapper's to retry. The

package/dist/slices/article/segments.js

@@ -18,6 +18,7 @@ export async function writeSegment(providers, choice, config, category, article,
     const answer = await providers.llm({
         provider: choice.provider,
         model: choice.model,
+        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         messages,
         check: (given) => given.text.trim() === "" ? `the ${category} answered with nothing` : undefined,
     });

package/dist/slices/batch/index.js

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { derive } from "../../kernel/runner/graph.js";
+import { projectPaused, stagesOf } from "../admission/repo.js";
+import { startRun } from "../admission/start.js";
+import { stagingPath } from "../storage/layout.js";
+import { deleteStagedFile, stagedFileById } from "../storage/repo.js";
+import { dropStagedSource } from "../storage/staging.js";
+const queueRow = z.object({
+    projectId: z.string(),
+    batchId: z.string(),
+    position: z.number(),
+    state: z.enum(["queued", "active", "finished"]),
+});
+export function queueEntries(db, batchId) {
+    return db
+        .prepare(`SELECT project_id AS projectId, batch_id AS batchId, position, state
+    FROM project_queue ${batchId === undefined ? "WHERE state != 'finished'" : "WHERE batch_id = ?"}
+    ORDER BY position`)
+        .all(...(batchId === undefined ? [] : [batchId]))
+        .map((row) => queueRow.parse(row));
+}
+export function queueWaiting(db, projectId) {
+    return (db
+        .prepare("SELECT 1 FROM project_queue WHERE project_id = ? AND state = 'queued'")
+        .get(projectId) !== undefined);
+}
+export function batchExists(db, id) {
+    return db.prepare("SELECT 1 FROM batches WHERE id = ?").get(id) !== undefined;
+}
+export function enqueueBatch(deps, batchId, runs) {
+    if (batchExists(deps.db, batchId))
+        return queueEntries(deps.db, batchId);
+    const sources = new Set();
+    transact(deps.db, () => {
+        deps.db
+            .prepare("INSERT INTO batches(id, created_at) VALUES (?, ?)")
+            .run(batchId, deps.clock.now().toISOString());
+        const used = new Set();
+        for (const { draft, rendered } of runs) {
+            const { project } = startRun(deps, draft, rendered, true);
+            deps.db
+                .prepare("INSERT INTO project_queue(project_id, batch_id) VALUES (?, ?)")
+                .run(project.id, batchId);
+            if (draft.sources.audio === "provide" && draft.provided.audio)
+                used.add(draft.provided.audio);
+            if (draft.sources.thumbnail === "provide" && draft.provided.thumbnail)
+                used.add(draft.provided.thumbnail);
+            if (draft.sources.images === "provide")
+                for (const id of draft.provided.images ?? [])
+                    used.add(id);
+        }
+        for (const id of used) {
+            const file = stagedFileById(deps.db, id);
+            if (file)
+                sources.add(stagingPath(deps.paths, file.path));
+            deleteStagedFile(deps.db, id);
+        }
+    });
+    for (const source of sources)
+        dropStagedSource(deps, source);
+    return queueEntries(deps.db, batchId);
+}
+// Only one batch video runs at once. A paused item holds its place; a failed or
+// canceled item releases the next video once its provider calls have drained.
+export function pumpQueue(db, runner) {
+    for (const entry of queueEntries(db)) {
+        const stages = stagesOf(db, entry.projectId);
+        const status = derive(stages, projectPaused(db, entry.projectId));
+        if (runner.hasInflight?.(entry.projectId))
+            return;
+        if (["done", "failed", "canceled"].includes(status)) {
+            db.prepare("UPDATE project_queue SET state = 'finished' WHERE project_id = ?").run(entry.projectId);
+            continue;
+        }
+        if (status === "paused")
+            return;
+        db.prepare("UPDATE project_queue SET state = 'active' WHERE project_id = ?").run(entry.projectId);
+        runner.tick(entry.projectId);
+        return;
+    }
+}

package/dist/slices/control/index.js

@@ -137,13 +137,17 @@ export function changeProviders(deps, id, changes) {
             (changes.audio.provider !== project.config.audio?.provider ||
                 changes.audio.model !== project.config.audio?.model ||
                 changes.audio.voice !== project.config.audio?.voice);
+        const chunkingChanged = changes.chunking !== undefined &&
+            (changes.chunking.mode !== (project.config.chunking?.mode ?? "whole") ||
+                (changes.chunking.words ?? 500) !== (project.config.chunking?.words ?? 500));
         const orphaned = transact(deps.db, () => {
-            const files = audioChanged ? clearUnfinishedAudio(deps, id) : [];
+            const files = audioChanged || chunkingChanged ? clearUnfinishedAudio(deps, id) : [];
             updateProjectConfig(deps.db, id, {
                 ...project.config,
                 ...(changes.llm === undefined ? {} : { llm: changes.llm }),
                 ...(changes.audio === undefined ? {} : { audio: changes.audio }),
                 ...(changes.images === undefined ? {} : { images: changes.images }),
+                ...(changes.chunking === undefined ? {} : { chunking: changes.chunking }),
             }, deps.clock.now().toISOString());
             return files;
         });

package/dist/slices/control/providers.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
+import { thinkingModes } from "../../kernel/ports/llm.js";
+import { chunkModes } from "../narration/chunk.js";
 const choice = z
     .object({
     provider: z.string().trim().min(1).max(200),
     model: z.string().trim().min(1).max(200),
+    thinking: z.enum(thinkingModes).optional(),
 })
     .strict();
 export const providerChangesSchema = z
@@ -10,6 +13,10 @@ export const providerChangesSchema = z
     llm: choice.optional(),
     audio: choice.extend({ voice: z.string().trim().min(1).max(200) }).optional(),
     images: choice.optional(),
+    chunking: z
+        .object({ mode: z.enum(chunkModes), words: z.number().int().min(1).max(10000).optional() })
+        .strict()
+        .optional(),
 })
     .strict()
     .refine((value) => Object.keys(value).length > 0, "Pick at least one provider to update.");
@@ -53,9 +60,15 @@ export async function validateProviderChanges(changes, current) {
         if (current.allowsCustomModels?.(picked.provider) === true)
             continue;
         const models = await current.modelsFor(picked.provider, families[key]);
-        if (!models.some((model) => model.id === picked.model)) {
+        const model = models.find((model) => model.id === picked.model);
+        if (!model) {
             fields.push({ field: `${key}.model`, message: "Choose a model supported by this provider." });
         }
+        else if (key === "llm" &&
+            picked.thinking &&
+            !model.thinkingModes?.includes(picked.thinking)) {
+            fields.push({ field: `${key}.thinking`, message: "Choose a supported thinking setting." });
+        }
     }
     return fields;
 }

package/dist/slices/estimate/index.js

@@ -0,0 +1,81 @@
+export function estimateRun(draft, rendered, expectedWords, catalogue) {
+    const rows = [];
+    const model = (family, choice) => choice
+        ? catalogue?.models(choice.provider, family).find((m) => m.id === choice.model)
+        : undefined;
+    const llm = model("llm", draft.llm);
+    const tts = model("tts", draft.audio);
+    const image = model("image", draft.images);
+    const generatedArticle = draft.sources.article === "generate";
+    const articleChars = generatedArticle ? expectedWords * 6 : (draft.provided.article?.length ?? 0);
+    const promptChars = Object.values(rendered).reduce((sum, value) => sum + value.length, 0);
+    const row = (stage, amount, detail, variable = false) => {
+        rows.push({
+            stage,
+            low: amount === undefined ? null : amount * (variable ? 0.5 : 1),
+            high: amount === undefined ? null : amount * (variable ? 1.5 : 1),
+            detail,
+        });
+    };
+    const textCost = (input, output) => {
+        const p = llm?.pricing;
+        return p?.inputPerMillionTokens === undefined || p.outputPerMillionTokens === undefined
+            ? undefined
+            : ((input / 4) * p.inputPerMillionTokens + (output / 4) * p.outputPerMillionTokens) / 1000000;
+    };
+    const textNote = llm?.pricing.note ??
+        "CLI subscription or model pricing is unavailable; usage may be billed by your account.";
+    if (draft.sources.research === "generate")
+        row("Research", textCost(promptChars + 6000, 12000), `Assumes about 2,000 words of notes; web search fees are excluded. ${textNote}`, true);
+    else
+        row("Research", 0, "Provided or off; no generation charge.");
+    if (generatedArticle)
+        row("Article", textCost(promptChars + (draft.sources.research === "generate" ? 12000 : 0), articleChars), `${expectedWords.toLocaleString()} expected words. ${textNote}`, true);
+    else
+        row("Article", 0, "Provided article; no generation charge.");
+    if (draft.intro?.mode === "llm" || draft.outro?.mode === "llm")
+        row("Intro / outro text", textCost(promptChars + articleChars, 2400), textNote, true);
+    if (draft.sources.audio === "generate") {
+        const extras = ["intro", "outro"].reduce((n, key) => n + (rendered[key]?.length ?? 0), 0);
+        const llmExtras = (draft.intro?.mode === "llm" ? 1200 : 0) + (draft.outro?.mode === "llm" ? 1200 : 0);
+        const chars = articleChars + extras + llmExtras;
+        const p = tts?.pricing;
+        const amount = p?.perMillionCharacters === undefined
+            ? p?.perMinute === undefined
+                ? undefined
+                : (chars / 6 / 150) * p.perMinute
+            : (chars / 1000000) * p.perMillionCharacters;
+        row("Narration", amount, `About ${chars.toLocaleString()} characters. ${p?.note ?? "Account pricing is unknown."}`, generatedArticle || llmExtras > 0 || p?.perMinute !== undefined);
+    }
+    else
+        row("Narration", 0, "Provided or off; no generation charge.");
+    const images = draft.sources.images === "generate" ? draft.imagePrompts.reduce((n, p) => n + p.number, 0) : 0;
+    row("Images", images === 0
+        ? 0
+        : image?.pricing.perImage === undefined
+            ? undefined
+            : images * image.pricing.perImage, images === 0
+        ? "Provided or off."
+        : `${images} images. ${image?.pricing.note ?? "Model or account pricing is unknown."}`);
+    const thumbnail = ["from_prompt", "prompt_by_llm"].includes(draft.sources.thumbnail);
+    row("Thumbnail", thumbnail ? image?.pricing.perImage : 0, thumbnail
+        ? (image?.pricing.note ?? "Model or account pricing is unknown.")
+        : "Provided or off.");
+    if (draft.sources.thumbnail === "prompt_by_llm")
+        row("Thumbnail prompt", textCost(promptChars + articleChars, 1200), textNote, true);
+    row("Export / subtitles", 0, "Local processing; no API fee.");
+    return {
+        currency: "USD",
+        rows,
+        expectedWords,
+        catalogueDate: catalogue?.status().updatedAt ?? null,
+        low: rows.reduce((n, r) => n + (r.low ?? 0), 0),
+        high: rows.reduce((n, r) => n + (r.high ?? 0), 0),
+        unknown: rows.filter((r) => r.low === null).length,
+        assumptions: [
+            "Planning estimate, not a spending limit. Generated lengths use a ±50% range; actual output can exceed it.",
+            "Assumes roughly 6 characters per word, 4 characters per token, and 150 spoken words per minute.",
+            "Retries, extra reasoning tokens, web tools, taxes, discounts and included credits are excluded. Unknown charges are not counted as zero.",
+        ],
+    };
+}

package/dist/slices/narration/plan.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { splitText } from "../../kernel/ports/text.js";
+import { insertPiece, piecesOf } from "../../kernel/runner/piece-repo.js";
+const payload = z.object({ text: z.string(), file: z.string().optional() });
+// Old whole-text plans can exceed a newly known account limit. Preserve finished
+// pieces and their paths, and split only unfinished work before any request starts.
+export function planNarration(deps, stageId, texts, maxCharacters, finished) {
+    const old = piecesOf(deps.db, stageId, "chunk");
+    const source = old.length
+        ? old
+        : texts.map((text, idx) => ({
+            id: deps.ids.next(),
+            stageId,
+            kind: "chunk",
+            idx: idx + 1,
+            state: "pending",
+            payload: JSON.stringify({ text }),
+        }));
+    const planned = [];
+    for (const piece of source) {
+        const data = payload.parse(JSON.parse(piece.payload ?? "null"));
+        if (finished(piece)) {
+            planned.push({ ...piece, idx: planned.length + 1 });
+            continue;
+        }
+        for (const [part, text] of splitText(data.text, maxCharacters).entries())
+            planned.push({
+                ...piece,
+                id: part === 0 ? piece.id : deps.ids.next(),
+                idx: planned.length + 1,
+                state: "pending",
+                payload: JSON.stringify({ text }),
+            });
+    }
+    if (old.length &&
+        planned.length === old.length &&
+        planned.every((p, i) => p.id === old[i]?.id &&
+            payload.parse(JSON.parse(p.payload ?? "null")).text ===
+                payload.parse(JSON.parse(old[i]?.payload ?? "null")).text))
+        return old;
+    transact(deps.db, () => {
+        // Negative temporary indices avoid colliding with a retained completed piece.
+        deps.db
+            .prepare("UPDATE stage_pieces SET idx=-idx WHERE stage_id=? AND kind='chunk'")
+            .run(stageId);
+        const known = new Set(old.map((p) => p.id));
+        for (const piece of planned) {
+            if (known.has(piece.id))
+                deps.db
+                    .prepare("UPDATE stage_pieces SET idx=?,state=?,payload=? WHERE id=?")
+                    .run(piece.idx, piece.state, piece.payload, piece.id);
+            else
+                insertPiece(deps.db, piece);
+        }
+    });
+    return planned;
+}

package/dist/slices/narration/run.js

@@ -1,8 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { z } from "zod";
-import { transact } from "../../kernel/db/tx.js";
-import { insertPiece, piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
+import { piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
 import { entryModes } from "../admission/model.js";
 import { projectById, setStageProgress, stagesOf } from "../admission/repo.js";
 import { entryCategories } from "../library/model.js";
@@ -12,6 +11,7 @@ import { probeDurationMs } from "../video/ffmpeg.js";
 import { chunkNarration, defaultChunking } from "./chunk.js";
 import { joinNarration } from "./concat.js";
 import { observeNarration } from "./live.js";
+import { planNarration } from "./plan.js";
 // An empty narration source fails the stage immediately with no retries. Thrown from the
 // slice rather than from a provider call, so the attempt wrapper never sees it.
 export const nothingToNarrate = "nothing to narrate";
@@ -53,7 +53,8 @@ export async function runNarration(deps, context, providers) {
     if (texts.length === 0) {
         throw new Error(nothingToNarrate);
     }
-    const files = await speakChunks(deps, context, providers, choice, plan(deps, context, texts));
+    const planned = planNarration(deps, context.stage.id, texts, deps.maxCharacters?.(choice.provider, choice.model) ?? 1000000, (piece) => finished(deps, projectId, piece) !== undefined);
+    const files = await speakChunks(deps, context, providers, choice, planned);
     await storeBody(deps, context, choice, files, outputs);
     await speakSegments(deps, context, providers, choice, outputs);
     deps.log.write("info", "narration.done", {
@@ -71,29 +72,7 @@ function narrationSource(deps, outputs, projectId) {
     }
     return readFileSync(outputPath(deps.paths, projectId, article.path), "utf8");
 }
-// The chunk list, planned once and kept. A retry after a failure finds the rows the first
-// run wrote and narrates only the ones that did not finish.
-function plan(deps, context, texts) {
-    const existing = piecesOf(deps.db, context.stage.id, "chunk");
-    if (existing.length > 0) {
-        return existing;
-    }
-    const planned = texts.map((text, index) => ({
-        id: deps.ids.next(),
-        stageId: context.stage.id,
-        kind: "chunk",
-        idx: index + 1,
-        state: "pending",
-        payload: JSON.stringify({ text }),
-    }));
-    transact(deps.db, () => {
-        for (const piece of planned) {
-            insertPiece(deps.db, piece);
-        }
-    });
-    return planned;
-}
-// Every chunk is synthesized in parallel. A chunk a previous run finished is not spoken
+// Chunks are scheduled through the shared provider queue. A chunk a previous run finished is not spoken
 // again, and one that fails takes down the whole stage while its siblings finish and keep their
 // audio for the next resume.
 async function speakChunks(deps, context, providers, choice, pieces) {
@@ -107,7 +86,7 @@ async function speakChunks(deps, context, providers, choice, pieces) {
         if (kept !== undefined) {
             return { ok: true, file: kept };
         }
-        const file = `${chunkDir}/${String(piece.idx).padStart(3, "0")}.mp3`;
+        const file = `${chunkDir}/${piece.id}.mp3`;
         setPiece(deps.db, piece.id, "running", piece.payload);
         try {
             const spoken = await providers.forPiece(piece.id).tts({

package/dist/slices/research/run.js

@@ -52,6 +52,7 @@ async function research(deps, context, providers, choice, brief) {
     const answer = await providers.llm({
         provider: choice.provider,
         model: choice.model,
+        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         messages: synthesisMessages(brief, findings),
         previewLabel: "Writing research notes",
         check: (given) => sourcedAnswer("the synthesis", given.text),
@@ -71,6 +72,7 @@ async function research(deps, context, providers, choice, brief) {
         stage: "research",
         provider: choice.provider,
         model: choice.model,
+        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         ...tokens,
     });
     deps.log.write("info", "research.done", {
@@ -89,6 +91,7 @@ async function plan(deps, context, providers, choice, brief, add) {
     const answer = await providers.llm({
         provider: choice.provider,
         model: choice.model,
+        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         messages: plannerMessages(brief),
         previewLabel: "Planning research",
         // An empty answer, or one with no chapter in it, is a failed attempt.
@@ -130,6 +133,7 @@ async function researchChapters(deps, context, providers, choice, brief, chapter
             const answer = await providers.forPiece(piece.id).llm({
                 provider: choice.provider,
                 model: choice.model,
+                ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
                 messages: subAgentMessages(brief, kept.title, outline),
                 previewLabel: kept.title,
                 // Grounding is asked for explicitly, so a model without it says so

package/dist/slices/storage/staging.js

@@ -140,7 +140,8 @@ export function attachStagedFile(deps, input) {
     try {
         transact(deps.db, () => {
             insertOutput(deps.db, output);
-            deleteStagedFile(deps.db, staged.id);
+            if (!input.retainStaged)
+                deleteStagedFile(deps.db, staged.id);
         });
     }
     catch (error) {

package/dist/slices/thumbnail/run.js

@@ -81,6 +81,7 @@ async function byLlm(deps, context, providers, project) {
     const answer = await providers.llm({
         provider: llm.provider,
         model: llm.model,
+        ...(llm.thinking === undefined ? {} : { thinking: llm.thinking }),
         messages,
         // An empty answer is a failed attempt, and the wrapper is what retries it.
         check: (given) => writtenPrompt(given.text),
@@ -151,6 +152,7 @@ async function make(deps, context, providers, project, choice, prompt) {
     const made = await providers.image({
         provider: choice.provider,
         model: choice.model,
+        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         prompt,
         aspect: project.format,
     });
@@ -175,6 +177,7 @@ async function make(deps, context, providers, project, choice, prompt) {
             prompt,
             provider: choice.provider,
             model: choice.model,
+            ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         },
         createdAt: deps.clock.now().toISOString(),
     };