@engenty/wizards-runtime 0.0.0-stage → 0.7.6

package/apps/runtime/dist/engine/owner.js

@@ -0,0 +1,32 @@
+import { ownerUrl } from "../tenants/control.js";
+/**
+ * Hands a request on to the runner holding the run — what only the process with the run's
+ * browser can answer. The runner serves the same routes and checks the same cookie; the caller's
+ * headers go along. Null: nobody holds the run, or the runner named no address (RUNNER_URL).
+ */
+export async function fromOwner(c, runId) {
+    const base = await ownerUrl(runId);
+    if (!base) {
+        return null;
+    }
+    const here = new URL(c.req.url);
+    const headers = new Headers(c.req.raw.headers);
+    headers.delete("host");
+    headers.delete("content-length");
+    const method = c.req.method;
+    const body = method === "GET" || method === "HEAD" ? undefined : await c.req.raw.arrayBuffer();
+    try {
+        const res = await fetch(`${base}${here.pathname}${here.search}`, {
+            method,
+            headers,
+            body,
+            redirect: "manual",
+            signal: AbortSignal.timeout(15_000),
+        });
+        return new Response(res.body, { status: res.status, headers: res.headers });
+    }
+    catch (err) {
+        console.error(`[run ${runId}] the runner did not answer:`, err);
+        return null;
+    }
+}

package/apps/runtime/dist/engine/prepare.js

@@ -0,0 +1,90 @@
+import { allFields, isAudioValue } from "@engenty-wizards/shared/definition";
+import { extFor, loadAsset } from "../files/storage.js";
+import { listenPieces, transcribeAudio } from "../media/transcribe.js";
+/**
+ * Gets the person's answers ready for a step that works on its own: a voice note is listened to
+ * once and kept as text with the answer, and a recording or signature that is not this run's own
+ * upload is dropped. Runs before every automatic step; what is already done costs nothing.
+ */
+export async function prepareInputs(ctx) {
+    const values = ctx.state.values;
+    for (const field of allFields(ctx.def)) {
+        const value = values[field.id];
+        if (field.kind === "signature" && typeof value === "string") {
+            const drawn = await loadAsset(value);
+            if (drawn?.row.runId !== ctx.runId || !drawn.row.mime.startsWith("image/")) {
+                delete values[field.id];
+            }
+            continue;
+        }
+        if (field.kind === "file" && field.listen) {
+            await listenTo(ctx, field.id, field.label, value);
+            continue;
+        }
+        if (field.kind !== "audio" || !isAudioValue(value)) {
+            continue;
+        }
+        if (value.transcript !== undefined) {
+            continue;
+        }
+        const found = await loadAsset(value.asset);
+        if (!found || found.row.runId !== ctx.runId || !/^(audio|video)\//.test(found.row.mime)) {
+            delete values[field.id];
+            continue;
+        }
+        await ctx.emit("info", { code: "listen", params: { label: field.label } });
+        try {
+            const transcript = await transcribeAudio({
+                bytes: new Uint8Array(found.data),
+                mediaType: found.row.mime,
+                abortSignal: ctx.signal,
+                call: ctx.call,
+                language: value.lang,
+            });
+            await ctx.chargeUsd(transcript.costUsd);
+            values[field.id] = { ...value, transcript: transcript.text };
+        }
+        catch (err) {
+            if (ctx.signal.aborted) {
+                throw err;
+            }
+            // The step goes on without the words; the next one tries again.
+            console.error(`[run ${ctx.runId}] transcribe ${field.id}`, err);
+            await ctx.emit("info", {
+                code: "listenFailed",
+                params: { label: field.label },
+            });
+        }
+    }
+}
+/** A recording in a file field with `listen`: written down once, piece by piece with its times. */
+async function listenTo(ctx, id, label, value) {
+    if (ctx.state.heard?.[id]) {
+        return;
+    }
+    // Several recordings: the first is the one that is cut.
+    const first = Array.isArray(value) ? value[0] : value;
+    const found = typeof first === "string" && first ? await loadAsset(first) : null;
+    if (!found || found.row.runId !== ctx.runId || !/^(audio|video)\//.test(found.row.mime)) {
+        return;
+    }
+    await ctx.emit("info", { code: "listen", params: { label } });
+    try {
+        const { pieces, costUsd } = await listenPieces({
+            bytes: new Uint8Array(found.data),
+            ext: extFor(found.row.mime),
+            abortSignal: ctx.signal,
+            call: ctx.call,
+        });
+        await ctx.chargeUsd(costUsd);
+        ctx.state.heard = { ...ctx.state.heard, [id]: pieces };
+    }
+    catch (err) {
+        if (ctx.signal.aborted) {
+            throw err;
+        }
+        // The step goes on without the words; the next one tries again.
+        console.error(`[run ${ctx.runId}] listen ${id}`, err);
+        await ctx.emit("info", { code: "listenFailed", params: { label } });
+    }
+}

package/apps/runtime/dist/engine/push.js

@@ -0,0 +1,58 @@
+import { eq } from "drizzle-orm";
+import { control, controlDb, db, schema } from "../db/client.js";
+import { managed, pushToDevice } from "../manage.js";
+import { currentTenant } from "../tenants/tenant.js";
+const TEXT = {
+    en: {
+        done: "Your result is ready.",
+        failed: "The run stopped with an error.",
+        waiting: "The wizard is waiting for you.",
+        asks: "The wizard has a question for you.",
+    },
+    de: {
+        done: "Dein Ergebnis ist bereit.",
+        failed: "Der Lauf ist mit einem Fehler stehen geblieben.",
+        waiting: "Der Wizard wartet auf dich.",
+        asks: "Der Wizard hat eine Frage an dich.",
+    },
+};
+export const pushAvailable = () => managed;
+export async function setPushDevice(runId, device) {
+    await controlDb
+        .update(control.runIndex)
+        .set({ push: device })
+        .where(eq(control.runIndex.runId, runId));
+}
+/** Tells the run's device, if the app gave one; never fails the run. */
+export async function pushRun(runId, kind) {
+    if (!managed) {
+        return;
+    }
+    try {
+        const row = await controlDb.query.runIndex.findFirst({
+            where: eq(control.runIndex.runId, runId),
+        });
+        const device = row?.push;
+        if (!device) {
+            return;
+        }
+        const run = await db.query.run.findFirst({ where: eq(schema.run.id, runId) });
+        if (!run) {
+            return;
+        }
+        await pushToDevice({
+            tenantId: currentTenant(),
+            device: { token: device.token, platform: device.platform },
+            title: run.definition.title,
+            body: TEXT[device.lang][kind],
+            data: { runId, kind },
+        });
+        // An ended run has nothing more to say.
+        if (kind === "done" || kind === "failed") {
+            await setPushDevice(runId, null);
+        }
+    }
+    catch (err) {
+        console.error("[push]", err.message);
+    }
+}

package/apps/runtime/dist/engine/requirements.js

@@ -0,0 +1,355 @@
+import { conditionMatches, conditionsOf, isDecidedField, isDecisionStep, isOtherwise, MODEL_CLASSES, } from "@engenty-wizards/shared/definition";
+import { closedChoicesFor, openValue, otherwiseIndex, unavoidableFrom, unavoidableSteps, } from "@engenty-wizards/shared/fit";
+import { note, saidText } from "@engenty-wizards/shared/run";
+import { classProblem, filmClient } from "../models.js";
+// The steps every run passes through, and the choices that lead around a missing model, are
+// pure and shared (packages/shared/src/fit.ts): the standalone check uses the same.
+export { openValue, unavoidableFrom, unavoidableSteps };
+/**
+ * What a wizard needs of the models before a run starts: each class its steps call, and whether
+ * this runtime can serve it. A step every run passes through blocks the start when its class is
+ * missing; a step behind a branch only warns, since the person may choose around it.
+ */
+/**
+ * The classes a step calls, as ../engine/steps.ts and ../media/generate.ts call them — and the
+ * classifier where a decision picks its next step or a page's fields.
+ */
+export function stepClasses(step) {
+    const own = ownClasses(step);
+    const decides = step.next?.some((r) => r.ask) || (step.type === "page" && step.fields.some(isDecidedField));
+    return decides && !own.includes("classifier") ? [...own, "classifier"] : own;
+}
+function ownClasses(step) {
+    switch (step.type) {
+        case "agent": {
+            // A call runs one tool and no model.
+            if (step.call) {
+                return [];
+            }
+            if (isDecisionStep(step)) {
+                return ["classifier"];
+            }
+            const classes = [step.model ?? "high"];
+            if (step.tools.includes("image")) {
+                classes.push("image");
+            }
+            if (step.output.format === "json") {
+                classes.push("classifier");
+            }
+            if (step.output.surface === true && !classes.includes("standard")) {
+                classes.push("standard");
+            }
+            return classes;
+        }
+        case "generate":
+            switch (step.asset) {
+                case "image":
+                    return ["standard", "image"];
+                case "video":
+                    return ["standard", "video"];
+                case "voice":
+                    return ["speech"];
+                default:
+                    return [step.model ?? "high"];
+            }
+        case "film":
+            return [step.model ?? "standard"];
+        case "page":
+            // A voice note the page asks for is listened to before the next step reads it.
+            return step.fields.some((f) => f.kind === "audio" && f.required) ? ["audio"] : [];
+        default:
+            // Reviews (they redo a generate step counted already), widgets, results.
+            return [];
+    }
+}
+/** The classes a step can do without: a voice note the person may leave out. */
+export function optionalStepClasses(step) {
+    return step.type === "page" &&
+        step.fields.some((f) => f.kind === "audio" && !f.required) &&
+        !stepClasses(step).includes("audio")
+        ? ["audio"]
+        : [];
+}
+/** Whether a rule matches given what is known: true, false, or null = it may go either way. */
+function ruleHolds(rule, facts) {
+    // A decision may go either way.
+    if (rule.ask) {
+        return null;
+    }
+    let all = true;
+    for (const c of conditionsOf(rule.when)) {
+        const holds = conditionHolds(c, facts);
+        if (holds === false) {
+            return false;
+        }
+        if (holds === null) {
+            all = null;
+        }
+    }
+    return all;
+}
+function conditionHolds(c, facts) {
+    const k = facts[c.field];
+    const value = c.value;
+    switch (c.op) {
+        case "empty":
+            return k?.filled === undefined ? (k?.is !== undefined ? false : null) : !k.filled;
+        case "notEmpty":
+            return k?.filled === undefined ? (k?.is !== undefined ? true : null) : k.filled;
+        case "equals":
+            return k?.is !== undefined
+                ? k.is === String(value)
+                : k?.not.includes(String(value))
+                    ? false
+                    : null;
+        case "notEquals":
+            return k?.is !== undefined
+                ? k.is !== String(value)
+                : k?.not.includes(String(value))
+                    ? true
+                    : null;
+        case "in": {
+            const list = Array.isArray(value) ? value.map(String) : [];
+            if (k?.is !== undefined) {
+                return list.includes(k.is);
+            }
+            return list.every((v) => k?.not.includes(v)) ? false : null;
+        }
+        case "gt":
+        case "lt":
+        case "contains":
+            if (k?.is !== undefined) {
+                return conditionMatches(c, { [c.field]: k.is });
+            }
+            return k?.filled === false ? false : null;
+    }
+}
+/**
+ * What is known once a rule did (`held`) or did not match. A rule of several conditions that
+ * did not match says nothing about any one of them.
+ */
+function learn(rule, held, facts) {
+    if (rule.ask) {
+        return facts;
+    }
+    const conditions = conditionsOf(rule.when);
+    if (held) {
+        return conditions.reduce((known, c) => learnCondition(c, true, known), facts);
+    }
+    return conditions.length === 1 ? learnCondition(conditions[0], false, facts) : facts;
+}
+function learnCondition(c, held, facts) {
+    const field = c.field;
+    const k = { ...(facts[field] ?? { not: [] }) };
+    k.not = [...k.not];
+    const value = String(c.value);
+    const op = c.op;
+    if ((op === "equals" && held) || (op === "notEquals" && !held)) {
+        k.is = value;
+        k.filled = true;
+    }
+    else if ((op === "equals" && !held) || (op === "notEquals" && held)) {
+        k.not.push(value);
+    }
+    else if (op === "in" && !held && Array.isArray(c.value)) {
+        k.not.push(...c.value.map(String));
+    }
+    else if (op === "empty" || op === "notEmpty") {
+        k.filled = (op === "notEmpty") === held;
+    }
+    else if ((op === "gt" || op === "lt" || op === "contains") && held) {
+        k.filled = true;
+    }
+    return { ...facts, [field]: k };
+}
+/**
+ * The most a run can add up to along one way through the wizard. A branch remembers what it
+ * implies of the answers, so ways that contradict themselves (the 720p clips and the 480p
+ * ones) are not added up. Steps in `closed` are not passed (no model for them here); where that
+ * leaves no way to the end, they count again. A branch back to an earlier step is not followed
+ * twice.
+ */
+export function mostAlongOnePath(def, cost, closed = new Set()) {
+    const index = new Map(def.steps.map((s, i) => [s.id, i]));
+    const end = def.steps.length;
+    const walk = (avoid) => {
+        const best = (i, facts, seen) => {
+            if (i >= end) {
+                return 0;
+            }
+            const step = def.steps[i];
+            if (i < 0 || avoid.has(step.id) || seen.has(i)) {
+                return null;
+            }
+            const passed = new Set(seen).add(i);
+            let most = null;
+            const consider = (j, known) => {
+                const rest = best(j, known, passed);
+                if (rest !== null && (most === null || rest > most)) {
+                    most = rest;
+                }
+            };
+            // The rules are tried in order; the first that matches decides.
+            let known = facts;
+            let decided = false;
+            for (const rule of step.next ?? []) {
+                if (isOtherwise(rule)) {
+                    continue;
+                }
+                const holds = ruleHolds(rule, known);
+                if (holds === false) {
+                    continue;
+                }
+                consider(rule.goto === "end" ? end : (index.get(rule.goto) ?? -1), learn(rule, true, known));
+                if (holds === true) {
+                    decided = true;
+                    break;
+                }
+                known = learn(rule, false, known);
+            }
+            if (!decided) {
+                consider(otherwiseIndex(def, i, index), known);
+            }
+            return most === null ? null : most + cost(step);
+        };
+        return best(0, {}, new Set());
+    };
+    return walk(closed) ?? walk(new Set()) ?? def.steps.reduce((sum, s) => sum + cost(s), 0);
+}
+/** The steps that call a class this runtime cannot serve. */
+export async function stepsWithoutModel(def) {
+    const missing = await missingClasses();
+    return new Set(def.steps.filter((s) => stepClasses(s).some((cls) => missing.has(cls))).map((s) => s.id));
+}
+/** The classes this wizard needs that this runtime cannot serve, in a language; empty = every step can run. */
+export async function missingModels(def, lang = "en") {
+    return (await missingModelsSaid(def)).map((m) => ({ ...m, problem: saidText(m.problem, lang) }));
+}
+/** The classes this wizard needs that this runtime cannot serve; empty = every step can run. */
+export async function missingModelsSaid(def) {
+    const unavoidable = unavoidableSteps(def);
+    const needs = new Map();
+    for (const step of def.steps) {
+        for (const cls of new Set(stepClasses(step))) {
+            needs.set(cls, [...(needs.get(cls) ?? []), { step, required: true }]);
+        }
+        for (const cls of optionalStepClasses(step)) {
+            needs.set(cls, [...(needs.get(cls) ?? []), { step, required: false }]);
+        }
+    }
+    const missing = [];
+    // A film runs on an installed client only, whatever serves its class otherwise.
+    for (const step of def.steps) {
+        if (step.type !== "film") {
+            continue;
+        }
+        const cls = step.model ?? "standard";
+        const found = await filmClient(cls);
+        if ("problem" in found) {
+            missing.push({
+                cls,
+                problem: found.problem,
+                steps: [{ id: step.id, title: step.title }],
+                blocking: unavoidable.has(step.id),
+            });
+        }
+    }
+    for (const [cls, uses] of needs) {
+        const problem = await classProblem(cls);
+        if (problem) {
+            missing.push({
+                cls,
+                problem,
+                steps: uses.map(({ step }) => ({ id: step.id, title: step.title })),
+                blocking: uses.some(({ step, required }) => required && unavoidable.has(step.id)),
+            });
+        }
+    }
+    return missing;
+}
+/** The message a run that cannot start gives, naming the steps and why. */
+export function blockingMessage(missing) {
+    const blocking = missing.filter((m) => m.blocking);
+    if (!blocking.length) {
+        return null;
+    }
+    return blocking
+        .map((m) => note("blockedSteps", {
+        steps: m.steps.map((s) => note("quoted", { text: s.title })),
+        problem: m.problem,
+    }))
+        .reduce((first, second) => note("joined", { first, second }));
+}
+/** The class a marketplace capability stands for; the rest need no model of their own. */
+const CAPABILITY_CLASS = {
+    text: "standard",
+    documents: "standard",
+    image: "image",
+    video: "video",
+    speech: "speech",
+    listening: "audio",
+};
+/** The capabilities this runtime has no model for. */
+export async function missingCapabilities() {
+    const missing = new Set();
+    for (const [capability, cls] of Object.entries(CAPABILITY_CLASS)) {
+        if (await classProblem(cls)) {
+            missing.add(capability);
+        }
+    }
+    if ("problem" in (await filmClient("standard"))) {
+        missing.add("film");
+    }
+    return missing;
+}
+/** The classes this runtime cannot serve. */
+export async function missingClasses() {
+    const missing = new Set();
+    for (const cls of MODEL_CLASSES) {
+        if (await classProblem(cls)) {
+            missing.add(cls);
+        }
+    }
+    return missing;
+}
+/**
+ * The capabilities of a wizard that only some of its paths need: without them it still starts,
+ * on the other paths (animated stills instead of video clips, no voice-over).
+ */
+export function optionalCapabilities(def) {
+    const unavoidable = unavoidableSteps(def);
+    const required = new Set();
+    const any = new Set();
+    for (const step of def.steps) {
+        for (const cls of stepClasses(step)) {
+            any.add(cls);
+            if (unavoidable.has(step.id)) {
+                required.add(cls);
+            }
+        }
+        for (const cls of optionalStepClasses(step)) {
+            any.add(cls);
+        }
+    }
+    const optional = new Set();
+    for (const [capability, cls] of Object.entries(CAPABILITY_CLASS)) {
+        if (any.has(cls) && !required.has(cls)) {
+            optional.add(capability);
+        }
+    }
+    return optional;
+}
+/**
+ * The answers on a page that lead to a step this runtime has no model for: with them the run
+ * would stop there, after what came before was paid for. The answers given already count; the
+ * page's other fields may still go either way. A choice whose every value leads there is left
+ * open: the run cannot go around it, and the start already warned. A voice note nothing here
+ * can listen to is closed as a whole (no values).
+ */
+export async function closedChoices(def, step, values) {
+    const missing = await missingClasses();
+    if (!missing.size) {
+        return {};
+    }
+    return closedChoicesFor(def, step, values, (s) => stepClasses(s).filter((cls) => missing.has(cls)), (field) => (missing.has("audio") && field.kind === "audio" ? ["audio"] : null));
+}