@engenty/wizards-runtime 0.7.5 → 0.7.7

package/node_modules/@engenty/wizards/dist/openui/Wizard.d.ts

@@ -0,0 +1,20 @@
+import { type Lang, type MascotProps } from "@engenty-wizards/runner";
+export interface WizardsConfig {
+    /**
+     * Where the runtime answers, as the browser reaches it: a path the host proxies to it
+     * (`/wizards-runtime`, so the runner's cookie stays first-party) or the runtime's address.
+     */
+    runtime: string;
+    /** The language of the runner's own words: `en` unless given. */
+    lang?: Lang;
+    /** The wizard's mascot above its pages; a plain dot in the wizard's colour unless given. */
+    Mascot?: (props: MascotProps) => React.ReactNode;
+}
+/** Names the runtime the Wizard component talks to. Once, before the first render. */
+export declare function configureWizards(config: WizardsConfig): void;
+/** The component an OpenUI library gets: `Wizard("<token>", "<note>", {prefill})`. */
+export declare const Wizard: import("@openuidev/react-lang").DefinedComponent<import("zod").ZodObject<{
+    wizard: import("zod").ZodString;
+    note: import("zod").ZodOptional<import("zod").ZodString>;
+    prefill: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, import("zod/v4/core").$strip>>;

package/node_modules/@engenty/wizards/dist/openui/Wizard.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { api, configureRunner, RunnerBody, } from "@engenty-wizards/runner";
+import { defineComponent } from "@openuidev/react-lang";
+import { useEffect, useRef } from "react";
+import { useMessageRun, useReport } from "./message.js";
+import { useWizardRun } from "./run.js";
+import { WIZARD_COMPONENT, WIZARD_DESCRIPTION, wizardProps } from "./server.js";
+/** A plain stand-in for the studio's engenty. */
+function Dot({ size = 64 }) {
+    const d = Math.min(size, 72);
+    return (_jsx("span", { "aria-hidden": "true", className: "inline-block rounded-full bg-ember", style: { width: d * 0.6, height: d * 0.6 } }));
+}
+/** Names the runtime the Wizard component talks to. Once, before the first render. */
+export function configureWizards(config) {
+    const base = config.runtime.replace(/\/+$/, "");
+    configureRunner({
+        lang: config.lang ?? "en",
+        runBase: (runId) => `/api/runs/${runId}`,
+        withBase: (path) => `${base}${path}`,
+        asset: (path) => `${base}/${path.replace(/^\/+/, "")}`,
+        Mascot: config.Mascot ?? Dot,
+    });
+}
+/** Starts a run of the published wizard behind `token`, as a visitor of the runtime. */
+const startRun = (token) => api
+    .post(`/api/public/wizards/${encodeURIComponent(token)}/runs`, {})
+    .then((started) => started.runId);
+/** What the chat hears when a run is done: the result's texts, each cut short. */
+function resultContext(view) {
+    const results = Object.entries(view.outputs)
+        .filter(([, out]) => typeof out.text === "string" && out.text.trim())
+        .map(([step, out]) => ({ step, text: (out.text ?? "").slice(0, 4000) }));
+    return { wizard: view.wizard.title, runId: view.id, results };
+}
+function WizardRun({ props }) {
+    const { runId, failed } = useMessageRun(props.wizard, startRun);
+    const run = useWizardRun(runId, props.prefill);
+    const report = useReport();
+    // The chat hears of a run it saw finish. A message shown again with a done run tells nothing.
+    const view = run.view;
+    const seenRunning = useRef(false);
+    useEffect(() => {
+        if (!view) {
+            return;
+        }
+        if (view.status !== "done") {
+            seenRunning.current = true;
+        }
+        else if (seenRunning.current) {
+            seenRunning.current = false;
+            report(`The wizard “${view.wizard.title}” finished.`, resultContext(view));
+        }
+    }, [view, report]);
+    return (_jsxs("div", { className: "engenty-runner overflow-hidden rounded-2xl border border-paper-3 bg-paper", children: [props.note ? _jsx("p", { className: "px-5 pt-4 text-[0.9375rem] text-ink-2", children: props.note }) : null, _jsx("div", { className: "px-5 pb-6", children: failed ? (_jsx("p", { className: "py-10 text-center text-ink-3", children: failed })) : (_jsx(RunnerBody, { run: run, compact: true })) })] }));
+}
+/** The component an OpenUI library gets: `Wizard("<token>", "<note>", {prefill})`. */
+export const Wizard = defineComponent({
+    name: WIZARD_COMPONENT,
+    description: WIZARD_DESCRIPTION,
+    props: wizardProps,
+    component: ({ props }) => _jsx(WizardRun, { props: props }),
+});

package/node_modules/@engenty/wizards/dist/openui/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Wizards in OpenUI chats: the Wizard component runs a published wizard inside the chat, page
+ * by page, as its author defined it; the chat's model only decides that it runs and what it
+ * already knows. `server.ts` (`@engenty/wizards/openui/server`) is the server's half: the rules
+ * and the list of wizards.
+ */
+export { useWizardRun } from "./run.js";
+export { addWizard, loadWizards, WIZARD_COMPONENT, WIZARD_DESCRIPTION, type WizardInfo, type WizardProps, WizardSpec, wizardProps, wizardRules, } from "./server.js";
+export { configureWizards, Wizard, type WizardsConfig } from "./Wizard.js";

package/node_modules/@engenty/wizards/dist/openui/index.js

@@ -0,0 +1,9 @@
+/**
+ * Wizards in OpenUI chats: the Wizard component runs a published wizard inside the chat, page
+ * by page, as its author defined it; the chat's model only decides that it runs and what it
+ * already knows. `server.ts` (`@engenty/wizards/openui/server`) is the server's half: the rules
+ * and the list of wizards.
+ */
+export { useWizardRun } from "./run.js";
+export { addWizard, loadWizards, WIZARD_COMPONENT, WIZARD_DESCRIPTION, WizardSpec, wizardProps, wizardRules, } from "./server.js";
+export { configureWizards, Wizard } from "./Wizard.js";

package/node_modules/@engenty/wizards/dist/openui/message.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The run this message shows: the one it kept, else a new one from `start`. A run starts once
+ * the reply has finished streaming, as the token can be half written until then, and once per
+ * message, however often React runs the effect (twice in Strict Mode).
+ */
+export declare function useMessageRun(token: string | undefined, start: (token: string) => Promise<string>): {
+    runId: string | null;
+    failed: string | null;
+};
+/** Tells the chat something as a turn of the person, with `context` for the model. */
+export declare function useReport(): (message: string, context: unknown) => void;

package/node_modules/@engenty/wizards/dist/openui/message.js

@@ -0,0 +1,69 @@
+import { useGetFieldValue, useIsStreaming, useSetFieldValue, useTriggerAction, } from "@openuidev/react-lang";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { WIZARD_COMPONENT } from "./server.js";
+/**
+ * What the Wizard component keeps with its message, in OpenUI's state of the message.
+ *
+ * OpenUI keeps that state as the fields of forms, saves it with the message and restores it when
+ * the message is shown again. An action hands the chat the fields of the form it names, or every
+ * field where it names none; the chat shows them as “Form data” and gives them to the model. So
+ * the run id is a field of its own, which no action names, and the action that reports the
+ * result names a form that holds nothing.
+ */
+const runField = (token) => `wizard:${token}`;
+const EMPTY_FORM = "wizard:empty";
+/**
+ * The run this message shows: the one it kept, else a new one from `start`. A run starts once
+ * the reply has finished streaming, as the token can be half written until then, and once per
+ * message, however often React runs the effect (twice in Strict Mode).
+ */
+export function useMessageRun(token, start) {
+    const streaming = useIsStreaming();
+    const getField = useGetFieldValue();
+    const setField = useSetFieldValue();
+    const [runId, setRunId] = useState(null);
+    const [failed, setFailed] = useState(null);
+    const started = useRef(null);
+    useEffect(() => {
+        if (streaming || runId || failed || !token) {
+            return;
+        }
+        let cancelled = false;
+        const take = async () => {
+            // OpenUI restores the message's state in an effect of its own, which runs after this one.
+            await Promise.resolve();
+            if (cancelled) {
+                return;
+            }
+            const kept = getField(undefined, runField(token));
+            if (typeof kept === "string") {
+                setRunId(kept);
+                return;
+            }
+            started.current ??= start(token);
+            const id = await started.current;
+            if (!cancelled) {
+                setRunId(id);
+                setField(undefined, WIZARD_COMPONENT, runField(token), id, true);
+            }
+        };
+        take().catch((err) => {
+            if (!cancelled) {
+                setFailed(err instanceof Error ? err.message : String(err));
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [streaming, runId, failed, token, getField, setField, start]);
+    return { runId, failed };
+}
+/** Tells the chat something as a turn of the person, with `context` for the model. */
+export function useReport() {
+    const setField = useSetFieldValue();
+    const trigger = useTriggerAction();
+    return useCallback((message, context) => {
+        setField(EMPTY_FORM, undefined, "empty", undefined, false);
+        void trigger(message, EMPTY_FORM, { type: "continue_conversation", params: { context } });
+    }, [setField, trigger]);
+}

package/node_modules/@engenty/wizards/dist/openui/run.d.ts

@@ -0,0 +1,8 @@
+import { type RunSource } from "@engenty-wizards/runner";
+/**
+ * One run, live: the runtime's stream of the whole view, plus the commands a person gives. The
+ * same as the studio's `useRun` (apps/web/src/runner/useRun.ts), on the runner's own client, so
+ * it talks to whichever runtime `configureWizards` named. `prefill` starts a page's fields with
+ * answers the chat already knows; the person still sees and sends the page.
+ */
+export declare function useWizardRun(runId: string | null, prefill: Record<string, unknown> | undefined): RunSource;

package/node_modules/@engenty/wizards/dist/openui/run.js

@@ -0,0 +1,137 @@
+import { ApiError, api, runnerEnv, setChoiceLabels } from "@engenty-wizards/runner";
+import { useCallback, useEffect, useMemo, useState } from "react";
+/** Two missed pings: the stream is taken for dead. */
+const STALE_MS = 45_000;
+/**
+ * One run, live: the runtime's stream of the whole view, plus the commands a person gives. The
+ * same as the studio's `useRun` (apps/web/src/runner/useRun.ts), on the runner's own client, so
+ * it talks to whichever runtime `configureWizards` named. `prefill` starts a page's fields with
+ * answers the chat already knows; the person still sees and sends the page.
+ */
+export function useWizardRun(runId, prefill) {
+    const [view, setView] = useState(null);
+    const [error, setError] = useState(null);
+    const [notFound, setNotFound] = useState(false);
+    const [busy, setBusy] = useState(false);
+    const [fieldErrors, setFieldErrors] = useState({});
+    useEffect(() => {
+        setView(null);
+        setNotFound(false);
+        if (!runId) {
+            return;
+        }
+        const { runBase, withBase } = runnerEnv();
+        let stopped = false;
+        let retry = 0;
+        let timer;
+        let es = null;
+        let lastHeard = Date.now();
+        const refresh = async () => {
+            try {
+                const fresh = await api.get(runBase(runId));
+                if (!stopped) {
+                    setView(fresh);
+                }
+            }
+            catch (err) {
+                if (err instanceof ApiError && err.status === 404) {
+                    stopped = true;
+                    es?.close();
+                    setNotFound(true);
+                }
+            }
+        };
+        const open = () => {
+            clearTimeout(timer);
+            es?.close();
+            if (stopped) {
+                return;
+            }
+            const stream = new EventSource(withBase(`${runBase(runId)}/stream`), {
+                withCredentials: true,
+            });
+            es = stream;
+            lastHeard = Date.now();
+            stream.addEventListener("view", (e) => {
+                retry = 0;
+                lastHeard = Date.now();
+                setView(JSON.parse(e.data));
+            });
+            stream.addEventListener("ping", () => {
+                lastHeard = Date.now();
+            });
+            stream.onerror = () => {
+                stream.close();
+                if (stopped || es !== stream) {
+                    return;
+                }
+                es = null;
+                void refresh();
+                retry = Math.min(retry + 1, 6);
+                timer = setTimeout(open, 500 * 2 ** retry);
+            };
+        };
+        const watchdog = setInterval(() => {
+            if (!stopped && es && Date.now() - lastHeard > STALE_MS) {
+                retry = 0;
+                open();
+            }
+        }, 15_000);
+        open();
+        return () => {
+            stopped = true;
+            clearTimeout(timer);
+            clearInterval(watchdog);
+            es?.close();
+        };
+    }, [runId]);
+    const command = useCallback(async (path, body) => {
+        if (!runId) {
+            return false;
+        }
+        setBusy(true);
+        setError(null);
+        setFieldErrors({});
+        try {
+            await api.post(`${runnerEnv().runBase(runId)}/${path}`, body);
+            return true;
+        }
+        catch (err) {
+            if (err instanceof ApiError && err.status === 422 && Array.isArray(err.body?.fields)) {
+                setFieldErrors(Object.fromEntries(err.body.fields.map((f) => [f.field, f.message])));
+            }
+            setError(err.message);
+            return false;
+        }
+        finally {
+            setBusy(false);
+        }
+    }, [runId]);
+    // The chat's answers start the page's fields, under what the run already holds.
+    const shown = useMemo(() => {
+        if (!view || !prefill || view.step?.type !== "page") {
+            return view;
+        }
+        const known = Object.fromEntries(view.step.fields.filter((f) => f.id in prefill).map((f) => [f.id, prefill[f.id]]));
+        return Object.keys(known).length ? { ...view, prefill: { ...known, ...view.prefill } } : view;
+    }, [view, prefill]);
+    setChoiceLabels(view?.translation?.labels);
+    return {
+        view: shown,
+        notFound,
+        error,
+        busy,
+        fieldErrors,
+        submitPage: (stepId, values) => command(`pages/${stepId}`, { values }),
+        accept: (stepId, edits) => command(`reviews/${stepId}`, { type: "accept", edits }),
+        regenerate: (stepId, target, note, items) => command(`reviews/${stepId}`, {
+            type: "regenerate",
+            target,
+            note,
+            items: items?.length ? items : undefined,
+        }),
+        back: () => command("back"),
+        retry: () => command("retry"),
+        translateResult: (stepId) => command("translate-result", { stepId }),
+    };
+}

package/node_modules/@engenty/wizards/dist/openui/server.d.ts

@@ -0,0 +1,37 @@
+import type { PublicField } from "@engenty-wizards/shared/run";
+import { type Library } from "@openuidev/react-lang";
+import { z } from "zod";
+/**
+ * The model's half of the Wizard component: its props, its description and the rules a system
+ * prompt gets. Nothing here draws, so a chat server builds its prompt from this file alone.
+ */
+export declare const WIZARD_COMPONENT = "Wizard";
+export declare const wizardProps: z.ZodObject<{
+    wizard: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+    prefill: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type WizardProps = z.infer<typeof wizardProps>;
+export declare const WIZARD_DESCRIPTION = "Runs a predefined wizard inline: its pages, AI steps, review and result, exactly as its author defined them. Use it whenever a listed wizard fits the request; never rebuild a wizard's pages with Form components.";
+/** The component as a prompt sees it: the same name and props, nothing to draw. */
+export declare const WizardSpec: import("@openuidev/react-lang").DefinedComponent<z.ZodObject<{
+    wizard: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+    prefill: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>>;
+/**
+ * The library with the Wizard component among a Card's children. A server passes `WizardSpec`
+ * for its prompt, the browser the drawing `Wizard`; both make the same prompt.
+ */
+export declare function addWizard<L extends Library>(library: L, component?: typeof WizardSpec): Library;
+/** A wizard as the chat server lists it to the model. */
+export interface WizardInfo {
+    token: string;
+    title: string;
+    description: string;
+    fields: PublicField[];
+}
+/** Reads the published wizards behind these tokens from a runtime; ones it cannot read are left out. */
+export declare function loadWizards(runtimeUrl: string, tokens: string[]): Promise<WizardInfo[]>;
+/** The rules a system prompt adds for the Wizard component: when to use it and which wizards exist. */
+export declare function wizardRules(wizards: WizardInfo[]): string[];

package/node_modules/@engenty/wizards/dist/openui/server.js

@@ -0,0 +1,77 @@
+import { defineComponent } from "@openuidev/react-lang";
+import { z } from "zod";
+/**
+ * The model's half of the Wizard component: its props, its description and the rules a system
+ * prompt gets. Nothing here draws, so a chat server builds its prompt from this file alone.
+ */
+export const WIZARD_COMPONENT = "Wizard";
+export const wizardProps = z.object({
+    wizard: z.string().describe("The token of a wizard from the list of available wizards"),
+    note: z
+        .string()
+        .optional()
+        .describe("One short sentence shown above the wizard: why it starts now"),
+    prefill: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe("Answers already known from the conversation, by field id; the person still checks them"),
+});
+export const WIZARD_DESCRIPTION = "Runs a predefined wizard inline: its pages, AI steps, review and result, exactly as its author defined them. Use it whenever a listed wizard fits the request; never rebuild a wizard's pages with Form components.";
+/** The component as a prompt sees it: the same name and props, nothing to draw. */
+export const WizardSpec = defineComponent({
+    name: WIZARD_COMPONENT,
+    description: WIZARD_DESCRIPTION,
+    props: wizardProps,
+    component: () => null,
+});
+/**
+ * The library with the Wizard component among a Card's children. A server passes `WizardSpec`
+ * for its prompt, the browser the drawing `Wizard`; both make the same prompt.
+ */
+export function addWizard(library, component = WizardSpec) {
+    if (!library.extend) {
+        throw new Error("This OpenUI library cannot be extended.");
+    }
+    return library.extend({ components: { add: [{ component, slots: ["Card"] }] } });
+}
+/** Reads the published wizards behind these tokens from a runtime; ones it cannot read are left out. */
+export async function loadWizards(runtimeUrl, tokens) {
+    const base = runtimeUrl.replace(/\/+$/, "");
+    const found = await Promise.all(tokens.map(async (token) => {
+        try {
+            const res = await fetch(`${base}/api/public/wizards/${encodeURIComponent(token)}`);
+            if (!res.ok) {
+                return null;
+            }
+            const w = (await res.json());
+            return w.available
+                ? { token: w.token, title: w.title, description: w.description, fields: w.fields ?? [] }
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }));
+    return found.filter((w) => w !== null);
+}
+function fieldLine(f) {
+    const choices = f.options?.length
+        ? ` one of ${f.options.map((o) => JSON.stringify(o)).join(" | ")}`
+        : "";
+    return `${f.id} (${f.kind}${choices}${f.required ? ", required" : ""}): ${f.label}`;
+}
+/** The rules a system prompt adds for the Wizard component: when to use it and which wizards exist. */
+export function wizardRules(wizards) {
+    if (!wizards.length) {
+        return [];
+    }
+    const list = wizards
+        .map((w) => `- "${w.title}" token: ${w.token} — ${w.description}\n  fields: ${w.fields.map(fieldLine).join("; ") || "none"}`)
+        .join("\n");
+    return [
+        `Wizards are fixed workflows with their own pages, AI steps and results. When the person asks for something a wizard below does, answer with a Card that holds one short TextContent and Wizard("<token>", "<note>", {prefill}). Do not ask the wizard's questions yourself and do not build them as a Form: the wizard asks them.`,
+        `Prefill only answers the person has actually given in this conversation, by field id; leave out anything you would have to guess. Dates are YYYY-MM-DD.`,
+        `When a message says a wizard finished, its context holds the result: answer in plain words about it, and start a wizard again only when asked.`,
+        `Available wizards:\n${list}`,
+    ];
+}

package/node_modules/@engenty/wizards/package.json

@@ -6,6 +6,9 @@
   "exports": {
     "./plugin": "./dist/plugin/index.js",
     "./plugin/studio": "./dist/plugin/studio.js",
-    "./plugin/thread": "./dist/plugin/thread.js"
+    "./plugin/thread": "./dist/plugin/thread.js",
+    "./openui": "./dist/openui/index.js",
+    "./openui/server": "./dist/openui/server.js",
+    "./openui/styles.css": "./src/openui/styles.css"
   }
 }

package/node_modules/@engenty-wizards/shared/dist/definition.d.ts

@@ -95,7 +95,7 @@ export declare function isAudioValue(v: unknown): v is AudioValue;
 export declare function locationText(v: LocationValue): string;
 /** A field takes at most this many files. */
 export declare const MAX_FILES = 30;
-export declare const TOOL_IDS: readonly ["web_search", "web_fetch", "browser", "sandbox", "image", "http", "pages"];
+export declare const TOOL_IDS: readonly ["web_search", "web_fetch", "browser", "sandbox", "image", "http", "pages", "code"];
 /**
  * A tool a plugin of the runtime adds: `<plugin id>.<tool name>`. A wizard that names one runs
  * only where that plugin is installed.
@@ -532,6 +532,7 @@ export declare const agentStepSchema: z.ZodObject<{
     }, z.core.$strip>>;
     tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
         browser: "browser";
+        code: "code";
         http: "http";
         image: "image";
         pages: "pages";
@@ -1278,6 +1279,7 @@ export declare const stepSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>>;
     tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
         browser: "browser";
+        code: "code";
         http: "http";
         image: "image";
         pages: "pages";
@@ -2277,6 +2279,7 @@ export declare const wizardSchema: z.ZodObject<{
         }, z.core.$strip>>;
         tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
             browser: "browser";
+            code: "code";
             http: "http";
             image: "image";
             pages: "pages";

package/node_modules/@engenty-wizards/shared/dist/definition.js

@@ -297,6 +297,7 @@ export const TOOL_IDS = [
     "image",
     "http",
     "pages",
+    "code",
 ];
 /**
  * A tool a plugin of the runtime adds: `<plugin id>.<tool name>`. A wizard that names one runs

package/node_modules/@engenty-wizards/shared/dist/fit.js

@@ -2,6 +2,11 @@
 import { conditionsOf, dataRef, isOtherwise, listRef, pluginToolOf, ruleMatches, templateRefs, } from "./definition.js";
 /** What the standalone runner can hand over of a thinking step's text itself. */
 const BASE_FORMATS = new Set(["html", "md", "txt", "csv", "json"]);
+/**
+ * A program over the step's tools: where programs do not run, the step calls its tools one by
+ * one and loses nothing. No need at all.
+ */
+const OPTIONAL_TOOLS = new Set(["code"]);
 /** Tools the standalone runner has no way to run; `pages` only reads the space's pages, which it lacks. */
 const HARD_TOOLS = new Set(["web_search", "browser", "sandbox", "image"]);
 /**
@@ -99,8 +104,8 @@ export function needs(step, def) {
                 if (plugin) {
                     add(`plugin:${plugin.plugin}`, true);
                 }
-                else if (RUNNER_TOOLS.has(tool)) {
-                    // The site runs it.
+                else if (RUNNER_TOOLS.has(tool) || OPTIONAL_TOOLS.has(tool)) {
+                    // The site runs it, or the step does without.
                 }
                 else if (HARD_TOOLS.has(tool)) {
                     add(`tool:${tool}`, true);

package/node_modules/@engenty-wizards/shared/dist/run.d.ts

@@ -214,6 +214,7 @@ declare const NOTES_EN: {
     readonly downloads: "Downloading {name}";
     readonly runs: "Running: {command}";
     readonly python: "Running Python";
+    readonly runsProgram: "Working through the data in one go";
     readonly drawing: "Drawing an image";
     readonly writesPage: "Writing the page “{title}”";
     readonly searchesDocuments: "Searching the documents: {query}";
@@ -634,6 +635,19 @@ export interface PublicWizard {
     translatable: boolean;
     /** The page in the viewer's language, where it was asked for (`?lang=`); null: the original. */
     translation: Omit<RunTranslation, "results"> | null;
+    /**
+     * What the wizard's pages ask, in order: an AI app that starts the wizard (the OpenUI
+     * component) can fill in what it already knows. The person still sees and sends each page.
+     */
+    fields: PublicField[];
+}
+/** A field of a wizard's page, as `PublicWizard.fields` lists it. */
+export interface PublicField {
+    id: string;
+    label: string;
+    kind: string;
+    options?: string[];
+    required?: boolean;
 }
 /** The runner's own words in a language outside `LANGS`: `GET /api/public/texts/:lang`. */
 export interface UiTexts {

package/node_modules/@engenty-wizards/shared/dist/run.js

@@ -50,6 +50,7 @@ const NOTES_EN = {
     downloads: "Downloading {name}",
     runs: "Running: {command}",
     python: "Running Python",
+    runsProgram: "Working through the data in one go",
     drawing: "Drawing an image",
     writesPage: "Writing the page “{title}”",
     searchesDocuments: "Searching the documents: {query}",
@@ -339,6 +340,7 @@ const NOTES_DE = {
     waitsForSignIn: "Wartet auf deine Anmeldung bei {name}",
     downloads: "Lädt {name} herunter",
     runs: "Führt aus: {command}",
+    runsProgram: "Arbeitet die Daten in einem Zug durch",
     python: "Führt Python aus",
     drawing: "Zeichnet ein Bild",
     writesPage: "Schreibt die Seite „{title}“",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@engenty/wizards-runtime",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "description": "Make a wish. Get your wizard. It guides you step by step. Let AI do the work. Runs on your machine, on the AI subscription you already have. The runtime, which `npx wizards` installs.",
   "license": "FSL-1.1-MIT",
   "homepage": "https://engenty.ai",
@@ -42,6 +42,7 @@
     "@mastra/core": "1.77.0",
     "@mastra/docker": "0.8.0",
     "@mastra/mcp": "2.4.0",
+    "@mastra/quickjs": "0.1.3",
     "@modelcontextprotocol/client": "2.2.0",
     "@modelcontextprotocol/ext-apps": "2.0.3",
     "@modelcontextprotocol/server": "2.2.0",
@@ -73,7 +74,7 @@
     "node-pty": "1.1.0"
   },
   "bundleDependencies": [
-    "@engenty/wizards",
-    "@engenty-wizards/shared"
+    "@engenty-wizards/shared",
+    "@engenty/wizards"
   ]
 }