videobook 0.0.0-stage → 0.2.0

package/dist/chain-step-review.js

@@ -0,0 +1,60 @@
+import { assessToolCallEstimate, logUnavailableCostEstimate, } from "./jobs/cost-estimate-assessment.js";
+/** Keys whose values never belong on a review sheet or in a spoken line. */
+const SENSITIVE_KEY = /api.?key|secret|(?:^|[_-])token(?:$|[_-])|password|credential|authorization/iu;
+function humanize(value) {
+    const words = value.replaceAll("_", " ").replace(/^generate kie /u, "generate ");
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function reviewParams(params) {
+    return Object.fromEntries(Object.entries(params)
+        .filter(([key]) => key !== "book_id" && key !== "notebook_id")
+        .map(([key, value]) => [key, SENSITIVE_KEY.test(key) ? "Hidden" : value]));
+}
+function formatUsd(usd) {
+    return usd < 0.01 ? `${Math.round(usd * 100)} cents` : `$${usd.toFixed(2)}`;
+}
+/** One sentence naming the step, what it consumes, and what approving costs. */
+function reviewReason(input) {
+    const position = `Step ${input.index + 1} of ${input.total}`;
+    const source = input.address ? ` from ${input.address}` : "";
+    const cost = input.estimateUsd === null
+        ? "I can't price this one"
+        : `about ${formatUsd(input.estimateUsd)}`;
+    return `${position}: ${input.title.toLowerCase()}${source}, ${cost}. Apply to spend it, or cancel to stop the whole chain.`;
+}
+/**
+ * Price a paused step from its dispatch-ready params. Estimating earlier would
+ * price the {$ref} placeholder rather than the value the step actually receives.
+ */
+export async function buildChainStepReview(input) {
+    const assessment = await assessToolCallEstimate(input.engine, input.tool, input.dispatchParams);
+    if (!assessment.available) {
+        await logUnavailableCostEstimate({
+            assessment,
+            engine: input.engine,
+            correlation: { bookId: input.bookId, tool: input.tool, stage: "chain-step" },
+        });
+    }
+    const estimateUsd = assessment.available ? assessment.usd : null;
+    const title = humanize(input.tool);
+    const address = input.pins[0]?.address ?? null;
+    return {
+        stepId: input.stepId,
+        index: input.index,
+        total: input.total,
+        tool: input.tool,
+        title,
+        address,
+        params: reviewParams(input.dispatchParams),
+        estimateUsd,
+        estimateUnavailable: !assessment.available,
+        estimateWarnings: assessment.warnings,
+        reason: reviewReason({
+            title,
+            index: input.index,
+            total: input.total,
+            address,
+            estimateUsd,
+        }),
+    };
+}

package/dist/character-name.js

@@ -0,0 +1,25 @@
+const MIN_STEM_LEN = 3;
+/** Strip @ and normalize to bare asset id. */
+export function bareAssetId(reference) {
+    return reference.startsWith("@") ? reference.slice(1) : reference;
+}
+/**
+ * Stem suitable for a short character name. Artifact ids are opaque UUIDs, so
+ * the stem comes from the source artifact's free-text label.
+ * "french-head" → french-head
+ * "French Head" → French Head
+ * "n" → "" (degenerate)
+ * "" (unlabelled artifact) → ""
+ */
+export function characterNameStem(label) {
+    const stem = label.trim();
+    return stem.length >= MIN_STEM_LEN ? stem : "";
+}
+/** Asset create name + display_name: stem or fallback. */
+export function resolveCharacterCreateName(explicitNameParts, imageLabels) {
+    if (explicitNameParts.length > 0) {
+        return explicitNameParts.join("-");
+    }
+    const fromImage = imageLabels[0] ? characterNameStem(imageLabels[0]) : "";
+    return fromImage || "character";
+}

package/dist/chat-generation-routing.js

@@ -0,0 +1,73 @@
+import { LIGHTNING_SCENE_MODEL, LIGHTNING_VIDEO_MODEL } from "./lightning-defaults.js";
+import { listElevenLabsVoices } from "./tools/list-elevenlabs-voices.js";
+import { isChainRef } from "./chain-plan.js";
+export const CHAT_DEFAULT_MODELS = {
+    generate_image: LIGHTNING_SCENE_MODEL,
+    generate_video: LIGHTNING_VIDEO_MODEL,
+    generate_audio: "elevenlabs:text-to-speech",
+};
+const FLAT_REF_FIELDS = {
+    image_refs: "image",
+    image_ref: "image",
+    video_refs: "video",
+    video_ref: "video",
+    audio_refs: "audio",
+    audio_ref: "audio",
+    first_frame_ref: "first_frame",
+    last_frame_ref: "last_frame",
+};
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function list(value) {
+    const values = Array.isArray(value) ? value : value === undefined || value === null ? [] : [value];
+    return values.filter((entry) => (typeof entry === "string" && entry.trim() !== "") || isChainRef(entry));
+}
+function foldFlatRefs(params) {
+    const refs = Object.fromEntries(Object.entries(record(params.refs)).map(([role, value]) => [role, list(value)]));
+    const next = { ...params };
+    for (const [field, role] of Object.entries(FLAT_REF_FIELDS)) {
+        if (!(field in next))
+            continue;
+        refs[role] = [...(refs[role] ?? []), ...list(next[field])];
+        delete next[field];
+    }
+    const kept = Object.fromEntries(Object.entries(refs).filter(([, values]) => values.length > 0));
+    return Object.keys(kept).length > 0 ? { ...next, refs: kept } : next;
+}
+async function withDefaultVoice(params) {
+    if (params.model !== "elevenlabs:text-to-speech")
+        return params;
+    const options = record(params.options);
+    if (typeof options.voice_id === "string" && options.voice_id.trim() !== "")
+        return params;
+    const fallback = (await listElevenLabsVoices()).voices[0]?.voice_id;
+    return fallback ? { ...params, options: { ...options, voice_id: fallback } } : params;
+}
+/**
+ * Fill routing gaps for chat-dispatched generations: the router may omit the
+ * model, keep provider-era ref fields at the top level, or leave the ElevenLabs
+ * voice unset because it cannot know voice ids. The review sheet shows the
+ * filled values before anything runs.
+ */
+export async function applyGenerationRoutingDefaults(tool, params) {
+    if (tool === "chain" && Array.isArray(params.steps)) {
+        const steps = await Promise.all(params.steps.map(async (entry) => {
+            const step = record(entry);
+            if (typeof step.tool !== "string" || !CHAT_DEFAULT_MODELS[step.tool])
+                return entry;
+            if (!step.params || typeof step.params !== "object" || Array.isArray(step.params))
+                return entry;
+            return { ...step, params: await applyGenerationRoutingDefaults(step.tool, record(step.params)) };
+        }));
+        return { ...params, steps };
+    }
+    const defaultModel = CHAT_DEFAULT_MODELS[tool];
+    if (!defaultModel)
+        return params;
+    const folded = foldFlatRefs(params);
+    const withModel = typeof folded.model === "string" && folded.model.trim() !== ""
+        ? folded
+        : { ...folded, model: defaultModel };
+    return withDefaultVoice(withModel);
+}

package/dist/chat-generation-settings.js

@@ -0,0 +1,78 @@
+/**
+ * Optional generation settings the request never asked for.
+ *
+ * The routing prompt already carries the rule — "Omit optional parameters
+ * unless the user explicitly requests them so the tool can apply its defaults"
+ * (chat-router.ts) — and nothing enforced it. A spoken "make a Seedance video
+ * of the kittens in @a1 dancing like @a2" came back carrying duration 22 and
+ * generate_audio false: neither was in the request, neither is derivable from
+ * the asset context the router sees, and generate_audio false is the opposite
+ * of the provider's own default.
+ *
+ * So the rule moves out of the prompt and into code. A setting the router
+ * emitted survives only when the request shows evidence for it, and dropping
+ * one is safe by construction: the tool then applies the default the guideline
+ * wanted in the first place. Settings with no entry in the evidence table are
+ * left alone, so this narrows what the router can invent without becoming a
+ * second guess at what it meant.
+ */
+// The audio toggle is spelled four ways across providers, but what a person
+// says to ask for it is the same either way.
+const AUDIO_EVIDENCE = /\b(?:audio|sound|sounds|sfx|music|musical|soundtrack|score|silent|silence|mute|muted|voice|voices|vocal|vocals|dialogue|dialog|narration|noise)\b/iu;
+const RESOLUTION_EVIDENCE = /\b(?:480p|720p|1080p|1440p|2k|4k|8k|hd|uhd|resolution|sharper|crisper)\b/iu;
+const SAFETY_EVIDENCE = /\b(?:nsfw|safety|safe|filter|filtered|explicit|censor|censored|uncensored|spicy)\b/iu;
+// What counts as asking for a setting. Deliberately generous about phrasing and
+// strict about shape: a missed cue costs the provider default, an over-eager
+// match keeps a value the router invented. Enum-valued settings match their own
+// vocabulary (720p, 16:9) rather than a bare number, so a timestamp or a shot
+// count never reads as a resolution or a ratio.
+const SETTING_EVIDENCE = {
+    duration: /\b\d+(?:\.\d+)?\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes)\b|\b(?:duration|length|long|longer|short|shorter|brief)\b/iu,
+    resolution: RESOLUTION_EVIDENCE,
+    output_resolution: RESOLUTION_EVIDENCE,
+    aspect_ratio: /\b(?:1:1|4:3|3:4|16:9|9:16|21:9)\b|\b(?:aspect|ratio|square|portrait|landscape|vertical|horizontal|widescreen)\b/iu,
+    output_format: /\b(?:mp4|mov|webm|gif|format)\b/iu,
+    generate_audio: AUDIO_EVIDENCE,
+    audio: AUDIO_EVIDENCE,
+    sound: AUDIO_EVIDENCE,
+    audio_setting: AUDIO_EVIDENCE,
+    return_last_frame: /\b(?:last|final|closing|ending)\s+frame\b/iu,
+    web_search: /\bweb\s*search\b|\bsearch\s+the\s+web\b|\blook\s+(?:it|this|that)\s+up\b|\bresearch\b/iu,
+    nsfw_checker: SAFETY_EVIDENCE,
+    enable_safety_checker: SAFETY_EVIDENCE,
+    seed: /\bseed(?:ed|s)?\b/iu,
+    watermark: /\bwatermark(?:ed|s)?\b/iu,
+};
+/** Whether the request asks for this setting at all. A setting with no evidence
+ *  rule is always treated as requested, so only reviewed names can be dropped. */
+export function settingIsRequested(name, query) {
+    const evidence = SETTING_EVIDENCE[name];
+    return evidence === undefined || evidence.test(query);
+}
+/**
+ * Drop the optional settings a generation request never asked for, so the tool
+ * applies its own defaults instead of values the router filled in.
+ */
+function requestedEntries(entries, query, required, dropped) {
+    const kept = {};
+    for (const [name, value] of Object.entries(entries)) {
+        if (required.has(name) || settingIsRequested(name, query)) {
+            kept[name] = value;
+            continue;
+        }
+        dropped.push(name);
+    }
+    return kept;
+}
+function optionsRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+export function withoutUnrequestedSettings(input) {
+    const required = new Set(input.requiredParams);
+    const dropped = [];
+    const params = requestedEntries(input.params, input.query, required, dropped);
+    const options = optionsRecord(params.options);
+    if (options)
+        params.options = requestedEntries(options, input.query, new Set(), dropped);
+    return { params, dropped };
+}

package/dist/chat-models.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+const CHAT_MODEL_IDS = ["gpt-6-astra"];
+export const DEFAULT_CHAT_MODEL = "gpt-6-astra";
+export const CHAT_MODEL_OPTIONS = [
+    {
+        id: "gpt-6-astra",
+        label: "Astra",
+        description: "Routes every composer request and configures its tools",
+        reasoningEffort: "medium",
+    },
+];
+export function chatIntelligenceRequestOptions(model) {
+    const resolved = resolveChatModel(model);
+    return {
+        model: resolved.id,
+        reasoningEffort: resolved.reasoningEffort,
+    };
+}
+export const chatModelSchema = z.enum(CHAT_MODEL_IDS);
+export function resolveChatModel(model) {
+    return CHAT_MODEL_OPTIONS.find((option) => option.id === model)
+        ?? CHAT_MODEL_OPTIONS[0];
+}
+export function listChatModelsDef() {
+    return {
+        name: "list_chat_models",
+        description: "List supported chat routing models and the default selection",
+        scope: "global",
+        schema: {},
+        handler: async () => ({
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        defaultModel: DEFAULT_CHAT_MODEL,
+                        models: CHAT_MODEL_OPTIONS.map(({ id, label, description }) => ({
+                            id,
+                            label,
+                            description,
+                        })),
+                    }),
+                }],
+        }),
+    };
+}

package/dist/chat-prompt-rewrite.js

@@ -0,0 +1,67 @@
+import { modelEntry } from "./media/catalog.js";
+import { unresolvedProviderMentions } from "./provider-prompt-transform.js";
+import { rewritePromptDef } from "./tools/rewrite-prompt.js";
+// Rides on rewrite_prompt's custom_prompt, which caps at 500 characters. The
+// mention rule protects the reference wiring; the model-name rule is the reason
+// this call exists at all; the settings rule keeps the guide from narrating
+// duration and framing into the text when those ride their own payload fields.
+export const CHAT_REWRITE_INSTRUCTION = "Keep every @ reference token byte-for-byte as written (e.g. @a1, "
+    + "@0199f0e4-9332-7383-b1a9-eb016abd4fdb): never renumber one, never rewrite "
+    + "one into @Image1/@Video1/@Audio1 form, never drop one. "
+    + "Describe only the media to produce: drop request preambles and any "
+    + "instruction naming which model, provider or tool to use. "
+    + "Do not state duration, aspect ratio or resolution — those ride their own "
+    + "fields, not the prompt.";
+/** The prompting guide for a catalog model, or null when it has none. */
+export function rewriteGuideForModel(model) {
+    return modelEntry(model)?.guide ?? null;
+}
+/** Every @ token the rewrite has to hand back. Same scanner the provider
+ *  transform uses to find tokens it still has to resolve, so the two agree on
+ *  what counts as a mention. */
+function mentionTokens(prompt) {
+    return unresolvedProviderMentions(prompt);
+}
+/**
+ * The rewrite to use, which is the original whenever the rewritten text is
+ * blank or has lost a mention. Exported for the tests that cover the guard
+ * without spending a model call.
+ */
+export function usableRewrite(original, rewritten) {
+    const candidate = rewritten.trim();
+    if (!candidate)
+        return original;
+    const kept = mentionTokens(candidate);
+    const missing = mentionTokens(original).filter((token) => !kept.includes(token));
+    return missing.length > 0 ? original : candidate;
+}
+function rewrittenPromptFromResult(result) {
+    const text = result.isError ? undefined : result.content[0]?.text;
+    if (text === undefined)
+        return "";
+    const { rewritten_prompt: rewritten } = JSON.parse(text);
+    return typeof rewritten === "string" ? rewritten : "";
+}
+/**
+ * Rewrite a routed generation prompt against its model's guide. Returns the
+ * original prompt when the model has no guide, when the rewrite fails, and when
+ * the result would cost a mention — this sits between routing and the confirm
+ * sheet, so it must never be the thing that stops a generation.
+ */
+export async function rewriteChatGenerationPrompt(engine, input) {
+    const guide = rewriteGuideForModel(input.model);
+    if (!guide || !input.prompt.trim())
+        return input.prompt;
+    try {
+        const result = await rewritePromptDef(engine).handler({
+            book_id: input.bookId,
+            prompt: input.prompt,
+            model: guide,
+            custom_prompt: CHAT_REWRITE_INSTRUCTION,
+        });
+        return usableRewrite(input.prompt, rewrittenPromptFromResult(result));
+    }
+    catch {
+        return input.prompt;
+    }
+}