wizards 0.1.9

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

@@ -0,0 +1,46 @@
+import { AsyncResource } from "node:async_hooks";
+import { EventEmitter } from "node:events";
+import { and, desc, eq, gt } from "drizzle-orm";
+import { db, schema } from "../db/client.js";
+const bus = new EventEmitter();
+bus.setMaxListeners(0);
+export async function emitEvent(runId, stepId, type, message, asset) {
+    const [row] = await db
+        .insert(schema.runEvent)
+        .values({ runId, stepId, type, message: message.slice(0, 2000), assetId: asset ?? null })
+        .returning();
+    const event = {
+        id: row.id,
+        at: row.createdAt.toISOString(),
+        stepId: row.stepId,
+        type: row.type,
+        message: row.message,
+        asset: row.assetId,
+    };
+    bus.emit(runId, { runId, event });
+}
+export function signalChanged(runId) {
+    bus.emit(runId, { runId, event: null });
+}
+/** The listener runs in the subscriber's own context (its tenant), whoever signals. */
+export function subscribe(runId, listener) {
+    const bound = AsyncResource.bind(listener);
+    bus.on(runId, bound);
+    return () => bus.off(runId, bound);
+}
+export async function recentEvents(runId, afterId = 0, limit = 40) {
+    const rows = await db
+        .select()
+        .from(schema.runEvent)
+        .where(and(eq(schema.runEvent.runId, runId), gt(schema.runEvent.id, afterId)))
+        .orderBy(desc(schema.runEvent.id))
+        .limit(limit);
+    return rows.reverse().map((r) => ({
+        id: r.id,
+        at: r.createdAt.toISOString(),
+        stepId: r.stepId,
+        type: r.type,
+        message: r.message,
+        asset: r.assetId,
+    }));
+}

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

@@ -0,0 +1,170 @@
+import { isLocationValue, MAX_FILES, } from "@engenty-wizards/shared/definition";
+function empty(v) {
+    return v === undefined || v === null || v === "" || (Array.isArray(v) && v.length === 0);
+}
+function coerce(field, raw) {
+    if (raw === undefined || raw === null) {
+        return undefined;
+    }
+    switch (field.kind) {
+        case "number": {
+            if (raw === "") {
+                return undefined;
+            }
+            const n = Number(String(raw).replace(",", "."));
+            return Number.isFinite(n) ? n : Number.NaN;
+        }
+        case "toggle":
+            return raw === true || raw === "true" || raw === "on";
+        case "multiselect":
+            return (Array.isArray(raw) ? raw : [raw])
+                .map(String)
+                .filter((v) => field.options?.includes(v));
+        case "image":
+        case "file": {
+            const ids = (Array.isArray(raw) ? raw : [raw])
+                .filter((v) => typeof v === "string" && v.length > 0)
+                .slice(0, MAX_FILES);
+            if (!ids.length) {
+                return undefined;
+            }
+            return field.multiple ? ids : ids[0];
+        }
+        case "signature":
+            return typeof raw === "string" && raw ? raw.slice(0, 64) : undefined;
+        case "audio":
+            return readAudio(raw);
+        case "location":
+            return readLocation(raw);
+        // The account and the list live in the wizard's store, not in the page's answers.
+        case "connection":
+        case "list":
+            return undefined;
+        case "items": {
+            if (!Array.isArray(raw)) {
+                return [];
+            }
+            const cols = field.columns ?? [];
+            return raw
+                .filter((r) => r && typeof r === "object")
+                .map((r) => Object.fromEntries(cols.map((c) => {
+                const v = r[c.id];
+                if (c.kind === "text") {
+                    return [c.id, String(v ?? "").slice(0, 2000)];
+                }
+                const n = Number(String(v ?? "").replace(",", "."));
+                return [c.id, Number.isFinite(n) ? n : 0];
+            })))
+                .filter((r) => Object.values(r).some((v) => v !== "" && v !== 0))
+                .slice(0, 200);
+        }
+        default:
+            return String(raw).slice(0, 20_000);
+    }
+}
+function finite(v) {
+    const n = typeof v === "number" ? v : typeof v === "string" && v.trim() ? Number(v) : Number.NaN;
+    return Number.isFinite(n) ? n : undefined;
+}
+/**
+ * A position from the device, a typed place, or both. Coordinates outside the globe are dropped,
+ * so a step never reads a point that cannot exist.
+ */
+function readLocation(raw) {
+    if (typeof raw === "string") {
+        const label = raw.trim().slice(0, 300);
+        return label ? { label } : undefined;
+    }
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return undefined;
+    }
+    const input = raw;
+    const out = {};
+    const lat = finite(input.lat);
+    const lng = finite(input.lng);
+    if (lat !== undefined && lng !== undefined && Math.abs(lat) <= 90 && Math.abs(lng) <= 180) {
+        out.lat = Math.round(lat * 1e6) / 1e6;
+        out.lng = Math.round(lng * 1e6) / 1e6;
+        const accuracy = finite(input.accuracy);
+        if (accuracy !== undefined && accuracy >= 0) {
+            out.accuracy = Math.round(accuracy);
+        }
+    }
+    const label = typeof input.label === "string" ? input.label.trim().slice(0, 300) : "";
+    if (label) {
+        out.label = label;
+    }
+    return isLocationValue(out) ? out : undefined;
+}
+/** A recording by its upload id; a transcript the page already shows travels with it. */
+function readAudio(raw) {
+    const input = typeof raw === "string" ? { asset: raw } : raw;
+    if (!input || typeof input !== "object" || typeof input.asset !== "string" || !input.asset) {
+        return undefined;
+    }
+    const out = { asset: input.asset.slice(0, 64) };
+    const seconds = finite(input.seconds);
+    if (seconds !== undefined && seconds >= 0) {
+        out.seconds = Math.round(seconds);
+    }
+    if (typeof input.transcript === "string") {
+        out.transcript = input.transcript.slice(0, 20_000);
+    }
+    return out;
+}
+/** Keep only this page's fields, typed; report what is missing or wrong. */
+export function readPageInput(step, input) {
+    const values = {};
+    const errors = [];
+    for (const field of step.fields) {
+        const v = coerce(field, input[field.id]);
+        if (field.kind === "connection" || field.kind === "list") {
+            continue;
+        }
+        if (field.required && empty(v) && field.kind !== "toggle") {
+            errors.push({ field: field.id, message: "Pflichtfeld" });
+            continue;
+        }
+        if (Array.isArray(v) && (field.kind === "image" || field.kind === "file")) {
+            if (field.min && v.length < field.min) {
+                errors.push({ field: field.id, message: `Bitte mindestens ${field.min} auswählen` });
+                continue;
+            }
+            if (field.max && v.length > field.max) {
+                errors.push({
+                    field: field.id,
+                    message: `Höchstens ${field.max} – bitte einige entfernen`,
+                });
+                continue;
+            }
+        }
+        if (field.kind === "number" && Number.isNaN(v)) {
+            errors.push({ field: field.id, message: "Bitte eine Zahl eingeben" });
+            continue;
+        }
+        if (field.kind === "select" && !empty(v) && !field.options?.includes(String(v))) {
+            errors.push({ field: field.id, message: "Ungültige Auswahl" });
+            continue;
+        }
+        if (field.kind === "email" && !empty(v) && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(v))) {
+            errors.push({ field: field.id, message: "Keine gültige E-Mail-Adresse" });
+            continue;
+        }
+        if (field.kind === "url" && !empty(v)) {
+            try {
+                new URL(String(v));
+            }
+            catch {
+                errors.push({ field: field.id, message: "Keine gültige URL" });
+                continue;
+            }
+        }
+        if (v !== undefined) {
+            values[field.id] = v;
+        }
+    }
+    return { values, errors };
+}
+export function defaultsFor(step) {
+    return Object.fromEntries(step.fields.filter((f) => f.default !== undefined).map((f) => [f.id, f.default]));
+}

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

@@ -0,0 +1,51 @@
+import { allFields, isAudioValue } from "@engenty-wizards/shared/definition";
+import { loadAsset } from "../files/storage.js";
+import { 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 !== "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", `Hört „${field.label}“ an …`);
+        try {
+            const transcript = await transcribeAudio({
+                bytes: new Uint8Array(found.data),
+                mediaType: found.row.mime,
+                abortSignal: ctx.signal,
+                call: ctx.call,
+            });
+            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", `„${field.label}“ konnte nicht verschriftlicht werden.`);
+        }
+    }
+}

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

@@ -0,0 +1,124 @@
+import { isDecisionStep, } from "@engenty-wizards/shared/definition";
+import { classProblem } from "../models.js";
+/**
+ * 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. */
+export function stepClasses(step) {
+    switch (step.type) {
+        case "agent": {
+            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");
+            }
+            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"];
+            }
+        default:
+            // Pages, reviews (they redo a generate step counted already), widgets, results.
+            return [];
+    }
+}
+/** The steps every run passes through: without one of them the end is not reachable. */
+export function unavoidableSteps(def) {
+    const index = new Map(def.steps.map((s, i) => [s.id, i]));
+    const successors = (i) => {
+        const out = (def.steps[i].next ?? [])
+            .map((rule) => (rule.goto === "end" ? def.steps.length : (index.get(rule.goto) ?? -1)))
+            .filter((j) => j >= 0);
+        // No rule matching goes on to the next step (or ends after the last).
+        out.push(i + 1);
+        return out;
+    };
+    const reachesEnd = (without) => {
+        if (without === 0) {
+            return false;
+        }
+        const seen = new Set([0]);
+        const queue = [0];
+        while (queue.length) {
+            const i = queue.shift();
+            if (i >= def.steps.length) {
+                return true;
+            }
+            for (const j of successors(i)) {
+                if (j !== without && !seen.has(j)) {
+                    seen.add(j);
+                    queue.push(j);
+                }
+            }
+        }
+        return false;
+    };
+    return new Set(def.steps.filter((_, i) => !reachesEnd(i)).map((s) => s.id));
+}
+/** The classes this wizard needs that this runtime cannot serve; empty = every step can run. */
+export async function missingModels(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]);
+        }
+    }
+    const missing = [];
+    for (const [cls, steps] of needs) {
+        const problem = await classProblem(cls);
+        if (problem) {
+            missing.push({
+                cls,
+                problem,
+                steps: steps.map((s) => ({ id: s.id, title: s.title })),
+                blocking: steps.some((s) => unavoidable.has(s.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) => `${m.steps.map((s) => `„${s.title}“`).join(", ")}: ${m.problem}`)
+        .join(" ");
+}
+/** 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);
+        }
+    }
+    return missing;
+}

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

@@ -0,0 +1,89 @@
+import { webContext } from "../render/chromium.js";
+import { createSandbox } from "../sandbox/index.js";
+import { getSecret, putSecret } from "../store/index.js";
+/** Sign-ins the person asked the wizard to keep, as Playwright storage state. */
+const SESSION_SLOT = "browser";
+/**
+ * What a run holds while an agent works: a browser context and a sandbox, both made on first
+ * use and released when the run stops running.
+ */
+export class RunResources {
+    runId;
+    context = null;
+    page = null;
+    sandbox = null;
+    scope = null;
+    /** Changes the person allowed for the rest of this run, as "<connection>:<action>". */
+    allowed = new Set();
+    constructor(runId) {
+        this.runId = runId;
+    }
+    /** Whose store kept sign-ins are read from and written to. */
+    bind(scope) {
+        this.scope = scope;
+    }
+    async browserContext() {
+        if (!this.context) {
+            const kept = this.scope
+                ? await getSecret(this.scope, SESSION_SLOT).catch(() => null)
+                : null;
+            this.context = await webContext({
+                locale: "de-DE",
+                ...(kept ? { storageState: kept.data } : {}),
+            });
+        }
+        return this.context;
+    }
+    async browserPage() {
+        const context = await this.browserContext();
+        if (!this.page || this.page.isClosed()) {
+            this.page = await context.newPage();
+        }
+        return this.page;
+    }
+    /** The page the agent has open, if any — without opening a browser for the question. */
+    openPage() {
+        return this.page && !this.page.isClosed() ? this.page : null;
+    }
+    /** A link opened a new tab: the agent goes on there. */
+    adopt(page) {
+        this.page = page;
+    }
+    /** Keeps the browser's sign-ins for the person's next run (they ticked "remember"). */
+    async keepSession() {
+        if (this.context && this.scope) {
+            await putSecret(this.scope, SESSION_SLOT, "browser", "Browser-Anmeldungen", await this.context.storageState());
+        }
+    }
+    sandboxHandle() {
+        this.sandbox ??= createSandbox(this.runId);
+        return this.sandbox;
+    }
+    async release() {
+        const context = this.context;
+        const sandbox = this.sandbox;
+        this.context = null;
+        this.page = null;
+        this.sandbox = null;
+        await context?.close().catch(() => undefined);
+        await sandbox?.destroy().catch(() => undefined);
+    }
+}
+const live = new Map();
+export function resourcesFor(runId) {
+    let r = live.get(runId);
+    if (!r) {
+        r = new RunResources(runId);
+        live.set(runId, r);
+    }
+    return r;
+}
+/** The resources of a run that is working right now, if it has any. */
+export function liveResources(runId) {
+    return live.get(runId) ?? null;
+}
+export async function releaseResources(runId) {
+    const r = live.get(runId);
+    live.delete(runId);
+    await r?.release();
+}