wizards 0.2.15 → 0.2.17

package/apps/runtime/dist/db/migrations/tenant/meta/_journal.json

@@ -57,6 +57,13 @@
       "when": 1791287441521,
       "tag": "0007_space_data",
       "breakpoints": true
+    },
+    {
+      "idx": 8,
+      "version": "6",
+      "when": 1791307814904,
+      "tag": "0008_run_event_note",
+      "breakpoints": true
     }
   ]
 }

package/apps/runtime/dist/db/schema.js

@@ -129,6 +129,8 @@ export const runEvent = sqliteTable("run_event", {
     stepId: text("step_id"),
     type: text("type", { enum: ["step_started", "step_done", "tool", "info", "error"] }).notNull(),
     message: text("message").notNull(),
+    /** The message as a note of `RUN_NOTES`, for a runner in another language. */
+    note: text("note", { mode: "json" }).$type(),
     /** A picture of the run the event is about; shown while the step works. */
     assetId: text("asset_id"),
     createdAt: createdAt(),

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

@@ -1,13 +1,23 @@
 import { AsyncResource } from "node:async_hooks";
 import { EventEmitter } from "node:events";
+import { noteText } from "@engenty-wizards/shared/run";
 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) {
+export async function emitEvent(runId, stepId, type, said, asset) {
+    const note = typeof said === "string" ? null : said;
+    const message = note ? noteText(note, "de") : said;
     const [row] = await db
         .insert(schema.runEvent)
-        .values({ runId, stepId, type, message: message.slice(0, 2000), assetId: asset ?? null })
+        .values({
+        runId,
+        stepId,
+        type,
+        message: message.slice(0, 2000),
+        note,
+        assetId: asset ?? null,
+    })
         .returning();
     const event = {
         id: row.id,
@@ -15,6 +25,7 @@ export async function emitEvent(runId, stepId, type, message, asset) {
         stepId: row.stepId,
         type: row.type,
         message: row.message,
+        note: row.note ?? null,
         asset: row.assetId,
     };
     bus.emit(runId, { runId, event });
@@ -41,6 +52,7 @@ export async function recentEvents(runId, afterId = 0, limit = 40) {
         stepId: r.stepId,
         type: r.type,
         message: r.message,
+        note: r.note ?? null,
         asset: r.assetId,
     }));
 }

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

@@ -28,7 +28,7 @@ export async function prepareInputs(ctx) {
             delete values[field.id];
             continue;
         }
-        await ctx.emit("info", `Hört „${field.label}“ an …`);
+        await ctx.emit("info", { code: "listen", params: { label: field.label } });
         try {
             const transcript = await transcribeAudio({
                 bytes: new Uint8Array(found.data),
@@ -45,7 +45,10 @@ export async function prepareInputs(ctx) {
             }
             // 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.`);
+            await ctx.emit("info", {
+                code: "listenFailed",
+                params: { label: field.label },
+            });
         }
     }
 }

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

@@ -1,4 +1,4 @@
-import { isDecisionStep, } from "@engenty-wizards/shared/definition";
+import { isDecisionStep, MODEL_CLASSES, ruleMatches, } 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
@@ -32,28 +32,58 @@ export function stepClasses(step) {
                 default:
                     return [step.model ?? "high"];
             }
+        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:
-            // Pages, reviews (they redo a generate step counted already), widgets, results.
+            // 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"]
+        : [];
+}
 /** The steps every run passes through: without one of them the end is not reachable. */
 export function unavoidableSteps(def) {
+    return def.steps.length ? unavoidableFrom(def, def.steps[0].id, {}) : new Set();
+}
+/**
+ * The steps every path from `from` to the end passes through. A rule on an answer in `known`
+ * goes one way; a rule on anything else may go either way.
+ */
+export function unavoidableFrom(def, from, known) {
     const index = new Map(def.steps.map((s, i) => [s.id, i]));
+    const start = index.get(from) ?? 0;
     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);
+        const out = [];
+        for (const rule of def.steps[i].next ?? []) {
+            const target = rule.goto === "end" ? def.steps.length : (index.get(rule.goto) ?? -1);
+            if (!(rule.when.field in known)) {
+                if (target >= 0) {
+                    out.push(target);
+                }
+                continue;
+            }
+            if (ruleMatches(rule, known)) {
+                // The first rule that matches decides; nothing after it is tried.
+                return target >= 0 ? [...out, target] : out;
+            }
+        }
         // 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) {
+        if (without === start) {
             return false;
         }
-        const seen = new Set([0]);
-        const queue = [0];
+        const seen = new Set([start]);
+        const queue = [start];
         while (queue.length) {
             const i = queue.shift();
             if (i >= def.steps.length) {
@@ -70,24 +100,135 @@ export function unavoidableSteps(def) {
     };
     return new Set(def.steps.filter((_, i) => !reachesEnd(i)).map((s) => s.id));
 }
+/** Whether a rule matches given what is known: true, false, or null = it may go either way. */
+function ruleHolds(rule, facts) {
+    const k = facts[rule.when.field];
+    const value = rule.when.value;
+    switch (rule.when.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;
+        }
+    }
+}
+/** What is known once a rule did (`held`) or did not match. */
+function learn(rule, held, facts) {
+    const field = rule.when.field;
+    const k = { ...(facts[field] ?? { not: [] }) };
+    k.not = [...k.not];
+    const value = String(rule.when.value);
+    const op = rule.when.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(rule.when.value)) {
+        k.not.push(...rule.when.value.map(String));
+    }
+    else if (op === "empty" || op === "notEmpty") {
+        k.filled = (op === "notEmpty") === held;
+    }
+    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 ?? []) {
+                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(i + 1, 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; 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]);
+            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 = [];
-    for (const [cls, steps] of needs) {
+    for (const [cls, uses] 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)),
+                steps: uses.map(({ step }) => ({ id: step.id, title: step.title })),
+                blocking: uses.some(({ step, required }) => required && unavoidable.has(step.id)),
             });
         }
     }
@@ -122,3 +263,98 @@ export async function missingCapabilities() {
     }
     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;
+}
+function choicesOf(step) {
+    return step.fields.flatMap((f) => {
+        if (f.kind === "select" && f.options?.length) {
+            return [{ field: f.id, values: f.options }];
+        }
+        if (f.kind === "toggle") {
+            return [{ field: f.id, values: [true, false] }];
+        }
+        return [];
+    });
+}
+/**
+ * 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 {};
+    }
+    const byId = new Map(def.steps.map((s) => [s.id, s]));
+    const known = Object.fromEntries(Object.entries(values).filter(([id]) => !step.fields.some((f) => f.id === id)));
+    const out = {};
+    // A voice note nothing here can listen to: the field is closed as a whole.
+    if (missing.has("audio")) {
+        for (const field of step.fields) {
+            if (field.kind === "audio") {
+                out[field.id] = { values: [], classes: ["audio"] };
+            }
+        }
+    }
+    for (const choice of choicesOf(step)) {
+        const closed = { values: [], classes: [] };
+        for (const value of choice.values) {
+            const ahead = unavoidableFrom(def, step.id, { ...known, [choice.field]: value });
+            const lacking = [...ahead].flatMap((id) => {
+                const s = byId.get(id);
+                return s ? stepClasses(s).filter((cls) => missing.has(cls)) : [];
+            });
+            if (lacking.length) {
+                closed.values.push(value);
+                closed.classes = [...new Set([...closed.classes, ...lacking])];
+            }
+        }
+        if (closed.values.length && closed.values.length < choice.values.length) {
+            out[choice.field] = closed;
+        }
+    }
+    return out;
+}
+/** The answer a closed choice gets instead: its first value that stays open. */
+export function openValue(step, field, closed) {
+    const choice = choicesOf(step).find((c) => c.field === field);
+    return choice?.values.find((v) => !closed.values.some((c) => String(c) === String(v)));
+}

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

@@ -20,7 +20,7 @@ import { askPerson, clearStaleAsk, unattended } from "./asks.js";
 import { emitEvent, recentEvents, signalChanged } from "./events.js";
 import { readPageInput } from "./input.js";
 import { pushRun } from "./push.js";
-import { blockingMessage, missingModels } from "./requirements.js";
+import { blockingMessage, closedChoices, missingModels, openValue, stepsWithoutModel, } from "./requirements.js";
 import { releaseResources, resourcesFor } from "./resources.js";
 import { runAutomaticStep } from "./steps.js";
 import { resolveRef } from "./template.js";
@@ -161,7 +161,7 @@ export async function createRun(input) {
         throw new ModelUnavailableError(blocked);
     }
     // The run's expected cost is held before it starts; what it really costs is booked per call.
-    const estimate = await estimateRun(input.wizardId, input.version, input.definition);
+    const estimate = await estimateRun(input.wizardId, input.version, input.definition, await stepsWithoutModel(input.definition));
     if (!(await reserveForRun(id, estimate.reserve))) {
         throw new NoCreditsError();
     }
@@ -358,6 +358,15 @@ export async function submitPage(runId, stepId, input) {
         throw new RunConflict("Not a page");
     }
     const { values, errors } = readPageInput(step, input);
+    // An answer that leads to a step without a model here would stop the run there, later.
+    const closed = await closedChoices(run.definition, step, run.state.values);
+    for (const [id, choice] of Object.entries(closed)) {
+        const answer = values[id];
+        if (answer !== undefined &&
+            (choice.values.length === 0 || choice.values.some((v) => String(v) === String(answer)))) {
+            errors.push({ field: id, message: "Das ist hier gerade nicht verfügbar." });
+        }
+    }
     if (errors.length) {
         throw new RunInputError(errors);
     }
@@ -483,8 +492,11 @@ export async function availableFormats(step, run, wanted) {
     }
     return formats;
 }
-/** What the page's fields start with, where they name an earlier step's result. */
-function prefillOf(step, run) {
+/**
+ * What the page's fields start with: an earlier step's result where they name one, and for a
+ * choice whose default leads to a step without a model here, the first value that does not.
+ */
+function prefillOf(step, run, closed) {
     const scope = { def: run.definition, state: run.state, brand: {} };
     const out = {};
     for (const field of step.fields) {
@@ -496,11 +508,21 @@ function prefillOf(step, run) {
             out[field.id] = value;
         }
     }
+    for (const [id, choice] of Object.entries(closed)) {
+        const field = step.fields.find((f) => f.id === id);
+        const start = out[id] ?? field?.default ?? (field?.kind === "toggle" ? false : undefined);
+        if (field && start !== undefined && choice.values.some((v) => String(v) === String(start))) {
+            out[id] = openValue(step, id, choice);
+        }
+    }
     return out;
 }
 export async function runView(run, brand) {
     const def = run.definition;
     const step = stepOf(def, run.cursor) ?? null;
+    const closed = step?.type === "page" && run.status === "waiting_input"
+        ? await closedChoices(def, step, run.state.values)
+        : {};
     const index = step ? def.steps.indexOf(step) : def.steps.length;
     const refs = step?.type === "review"
         ? step.show
@@ -549,7 +571,8 @@ export async function runView(run, brand) {
         },
         step,
         values: run.state.values,
-        prefill: step?.type === "page" ? prefillOf(step, run) : {},
+        prefill: step?.type === "page" ? prefillOf(step, run, closed) : {},
+        closed,
         outputs: Object.fromEntries(shownIds.map((id) => [id, run.state.outputs[id]]).filter(([, o]) => o)),
         shown,
         progress: { done: run.status === "done" ? def.steps.length : index, total: def.steps.length },

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

@@ -1,4 +1,4 @@
-import { allFields, dataRef, isDecisionStep, templateRefs, } from "@engenty-wizards/shared/definition";
+import { allFields, dataRef, isDecisionStep, LOCALES, templateRefs, wizardLang, } from "@engenty-wizards/shared/definition";
 import { Agent } from "@mastra/core/agent";
 import { generateText, Output } from "ai";
 import { z } from "zod";
@@ -13,8 +13,13 @@ import { runWidgetStep } from "../widgets/step.js";
 import { prepareInputs } from "./prepare.js";
 import { answersAsText, colorLine, factLines, renderTemplate, resolveRef, } from "./template.js";
 import { StepError } from "./types.js";
-function today() {
-    return new Date().toLocaleDateString("de-DE", { year: "numeric", month: "long", day: "numeric" });
+/** Today's date as the wizard's people write it. */
+function today(ctx) {
+    return new Date().toLocaleDateString(LOCALES[wizardLang(ctx.def)], {
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+    });
 }
 function brandBlock(ctx) {
     const b = ctx.scope.brand;
@@ -166,7 +171,7 @@ export async function runAgentStep(step, ctx) {
                 : "Finish with everything the result needs in your final answer; it is turned into structured data afterwards.";
         const system = [
             GROUND_RULES,
-            `Today is ${today()}.`,
+            `Today is ${today(ctx)}.`,
             brandBlock(ctx),
             documentsBlock(ctx),
             // What the space's plugins hold for its wizards: a wiki, questions and answers.
@@ -221,7 +226,7 @@ export async function runAgentStep(step, ctx) {
         // Working through a mailbox or a row of portals takes many small tool calls.
         const maxSteps = step.tools.includes("browser") || step.connections?.length ? 60 : 20;
         for (const [i, photo] of photos.entries()) {
-            await ctx.emit("info", `Sieht sich Foto ${i + 1} von ${photos.length} an`, photo.id);
+            await ctx.emit("info", { code: "photo", params: { n: i + 1, total: photos.length } }, photo.id);
         }
         const message = photos.length
             ? [
@@ -381,7 +386,7 @@ async function writeHtml(step, ctx, kind) {
         ].join("\n");
     const system = [
         GROUND_RULES,
-        `Today is ${today()}.`,
+        `Today is ${today(ctx)}.`,
         brandBlock(ctx),
         guide,
         images.length
@@ -474,8 +479,8 @@ async function runMediaStep(step, ctx, asset) {
     const todo = entries.filter((e) => !keep(e));
     if (asset === "video") {
         await ctx.emit("info", todo.length > 1
-            ? `${todo.length} Clips werden gerendert – das dauert einige Minuten.`
-            : "Das Video wird gerendert – das dauert meist 1–3 Minuten.");
+            ? { code: "clipsRendering", params: { count: todo.length } }
+            : { code: "videoRendering" });
     }
     let finished = 0;
     const note = ctx.state.notes[step.id];
@@ -496,7 +501,10 @@ async function runMediaStep(step, ctx, asset) {
                 .join("\n")
             : await visualPrompt(step, ctx, entry);
         if (entry.reference && todo.length > 1) {
-            await ctx.emit("info", `${asset === "image" ? "Bearbeitet" : "Dreht"} ${entry.index + 1} von ${entries.length}`, entry.reference);
+            await ctx.emit("info", {
+                code: asset === "image" ? "editing" : "filming",
+                params: { n: entry.index + 1, total: entries.length },
+            }, entry.reference);
         }
         const reference = await loadReference(entry.reference, ctx);
         const media = asset === "image"
@@ -529,7 +537,7 @@ async function runMediaStep(step, ctx, asset) {
         });
         finished++;
         if (todo.length > 1) {
-            await ctx.emit("info", `${finished} von ${todo.length} fertig`, asset === "image" ? ref.id : undefined);
+            await ctx.emit("info", { code: "batchDone", params: { done: finished, total: todo.length } }, asset === "image" ? ref.id : undefined);
         }
         return { index: entry.index, prompt, ref };
     });

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

@@ -1,16 +1,17 @@
-import { allFields, isAudioValue, isLocationValue, itemsTotals, locationText, } from "@engenty-wizards/shared/definition";
+import { allFields, isAudioValue, isLocationValue, itemsTotals, LOCALES, locationText, wizardLang, } from "@engenty-wizards/shared/definition";
 import { listAsMarkdown } from "@engenty-wizards/shared/store";
 const TEMPLATE_RE = /\{\{\s*([^}]+?)\s*\}\}/g;
-function money(n, currency) {
+function money(n, currency, locale) {
     try {
-        return new Intl.NumberFormat("de-DE", { style: "currency", currency }).format(n);
+        return new Intl.NumberFormat(locale, { style: "currency", currency }).format(n);
     }
     catch {
         return `${n.toFixed(2)} ${currency}`;
     }
 }
 /** Line items as a Markdown table with their totals — what a model needs to write a document. */
-export function itemsAsMarkdown(field, value, values) {
+export function itemsAsMarkdown(field, value, values, lang = "de") {
+    const locale = LOCALES[lang];
     const totals = itemsTotals(field, value, values);
     const cols = field.columns ?? [];
     if (!totals.rows.length) {
@@ -18,12 +19,14 @@ export function itemsAsMarkdown(field, value, values) {
     }
     const head = `| ${cols.map((c) => c.label).join(" | ")} | Amount |\n|${cols.map(() => " --- ").join("|")}| ---: |`;
     const body = totals.rows.map((r) => `| ${cols
-        .map((c) => c.kind === "money" ? money(Number(r[c.id]) || 0, totals.currency) : String(r[c.id] ?? ""))
-        .join(" | ")} | ${money(r.amount, totals.currency)} |`);
+        .map((c) => c.kind === "money"
+        ? money(Number(r[c.id]) || 0, totals.currency, locale)
+        : String(r[c.id] ?? ""))
+        .join(" | ")} | ${money(r.amount, totals.currency, locale)} |`);
     const sums = [
-        `Net: ${money(totals.net, totals.currency)}`,
-        totals.vatRate ? `VAT ${totals.vatRate}%: ${money(totals.vat, totals.currency)}` : null,
-        `Total: ${money(totals.gross, totals.currency)}`,
+        `Net: ${money(totals.net, totals.currency, locale)}`,
+        totals.vatRate ? `VAT ${totals.vatRate}%: ${money(totals.vat, totals.currency, locale)}` : null,
+        `Total: ${money(totals.gross, totals.currency, locale)}`,
     ].filter(Boolean);
     return [head, ...body, "", ...sums].join("\n");
 }
@@ -118,7 +121,7 @@ export function resolveRef(ref, scope) {
     const value = state.values[head];
     if (field?.kind === "items") {
         if (!rest.length) {
-            return itemsAsMarkdown(field, value, state.values);
+            return itemsAsMarkdown(field, value, state.values, wizardLang(def));
         }
         const totals = itemsTotals(field, value, state.values);
         return totals[rest[0]];

package/apps/runtime/dist/routes/studio.js

@@ -16,7 +16,7 @@ import { layout } from "../cli/home.js";
 import { connectorImportSchema, importConnector, listConnectors, previewSource, refreshConnector, registryService, removeConnector, searchRegistry, } from "../connectors/external.js";
 import { balanceCredits, canSpend } from "../credits/credits.js";
 import { estimateRun } from "../credits/estimate.js";
-import { missingModels } from "../engine/requirements.js";
+import { missingModels, stepsWithoutModel } from "../engine/requirements.js";
 import { env } from "../env.js";
 import { freshAuth, loginEnv } from "../harness/env.js";
 import { detectHarness, detectHarnesses, HARNESS_IDS, harness, installSpec, } from "../harness/index.js";
@@ -639,7 +639,7 @@ export const studio = new Hono()
     // What a run of the draft is expected to cost, per step and in total.
     .get("/wizards/:id/estimate", async (c) => {
     const w = await ownedWizard(c.get("user").id, c.req.param("id"));
-    return c.json(await estimateRun(w.id, null, w.draft));
+    return c.json(await estimateRun(w.id, null, w.draft, await stepsWithoutModel(w.draft)));
 })
     // The models the draft needs that this runtime cannot serve, by class, with the steps that call them.
     .get("/wizards/:id/models", async (c) => {