wizards 0.2.16 → 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

@@ -100,6 +100,114 @@ export function unavoidableFrom(def, from, known) {
     };
     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);

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, closedChoices, missingModels, openValue } 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();
     }

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) => {

package/apps/runtime/dist/services/marketplace.js

@@ -5,7 +5,7 @@ import { searchEntries } from "@engenty-wizards/shared/marketplace-search";
 import { and, eq, inArray, notInArray } from "drizzle-orm";
 import { formulaEstimate } from "../credits/estimate.js";
 import { control, controlDb, db, schema, withTenant } from "../db/client.js";
-import { missingCapabilities, optionalCapabilities } from "../engine/requirements.js";
+import { missingCapabilities, optionalCapabilities, stepsWithoutModel, } from "../engine/requirements.js";
 import { env } from "../env.js";
 import { managed } from "../manage.js";
 import { classCatalog, imageCostUsd, tokenCostUsd, videoCostUsd, WEB_SEARCH_COST_USD, } from "../models.js";
@@ -212,7 +212,7 @@ function listPrices() {
 /** What a run costs: at the gateway's prices where there is one, else at list prices. */
 async function priced(definition) {
     const catalog = await classCatalog().catch(() => null);
-    const price = formulaEstimate(definition, catalog ?? listPrices());
+    const price = formulaEstimate(definition, catalog ?? listPrices(), await stepsWithoutModel(definition));
     return { credits: Math.round(price.credits), high: price.high };
 }
 /** An entry in a language with its wizard read against this app; null where there is none. */

package/apps/runtime/dist/tools/browser.js

@@ -141,7 +141,7 @@ export function browserTools(ctx, assets, files) {
         inputSchema: z.object({ url: z.string() }),
         execute: ({ url }) => inTurn(async () => {
             const safe = await assertPublicUrl(url);
-            await ctx.emit("tool", `Öffnet ${safe.hostname}`);
+            await ctx.emit("tool", { code: "opens", params: { name: safe.hostname } });
             const p = await page();
             await p.goto(safe.toString(), { waitUntil: "domcontentloaded", timeout: 30_000 });
             await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => undefined);
@@ -154,7 +154,7 @@ export function browserTools(ctx, assets, files) {
         inputSchema: z.object({ ref: z.number() }),
         execute: ({ ref: n }) => inTurn(async () => {
             const p = await page();
-            await ctx.emit("tool", "Klickt im Browser");
+            await ctx.emit("tool", { code: "clicks" });
             const popup = p
                 .context()
                 .waitForEvent("page", { timeout: 3000 })
@@ -176,7 +176,7 @@ export function browserTools(ctx, assets, files) {
         inputSchema: z.object({ ref: z.number(), text: z.string(), submit: z.boolean().optional() }),
         execute: ({ ref: n, text, submit }) => inTurn(async () => {
             const p = await page();
-            await ctx.emit("tool", "Tippt im Browser");
+            await ctx.emit("tool", { code: "types" });
             const el = p.locator(ref(n)).first();
             await el.fill(text, { timeout: 10_000 });
             if (submit) {
@@ -192,7 +192,7 @@ export function browserTools(ctx, assets, files) {
         inputSchema: z.object({ save: z.boolean().optional(), name: z.string().optional() }),
         execute: ({ save, name }) => inTurn(async () => {
             const p = await page();
-            await ctx.emit("tool", "Sieht sich die Seite an");
+            await ctx.emit("tool", { code: "looksAtPage" });
             const png = await p.screenshot({ type: "png" });
             let saved;
             if (save) {
@@ -235,7 +235,10 @@ export function browserTools(ctx, assets, files) {
                 };
             }
         }
-        await ctx.emit("tool", `Wartet auf deine Anmeldung bei ${new URL(origin).hostname}`);
+        await ctx.emit("tool", {
+            code: "waitsForSignIn",
+            params: { name: new URL(origin).hostname },
+        });
         const answer = await ctx.ask({
             kind: "login",
             reason: input.reason,
@@ -321,7 +324,10 @@ export function browserTools(ctx, assets, files) {
         }),
         execute: ({ ref: n, url, path, source }) => inTurn(async () => {
             const p = await page();
-            await ctx.emit("tool", `Lädt ${path.split("/").pop()} herunter`);
+            await ctx.emit("tool", {
+                code: "downloads",
+                params: { name: path.split("/").pop() ?? "" },
+            });
             let data;
             let mime;
             if (url) {

package/apps/runtime/dist/tools/index.js

@@ -49,7 +49,7 @@ export async function buildStepTools(step, ctx, resolved, uploads) {
             inputSchema: z.object({ url: z.string().describe("Absolute http(s) URL") }),
             execute: async ({ url }) => {
                 const safe = await assertPublicUrl(url);
-                await ctx.emit("tool", `Liest ${safe.hostname}`);
+                await ctx.emit("tool", { code: "reads", params: { name: safe.hostname } });
                 const res = await safeFetch(safe.toString(), {
                     signal: AbortSignal.any([ctx.signal, AbortSignal.timeout(20_000)]),
                     headers: { "user-agent": "Mozilla/5.0 (compatible; engenty-wizards/0.1)" },
@@ -115,7 +115,7 @@ export async function buildStepTools(step, ctx, resolved, uploads) {
             description: shellToolDescription(sandbox),
             inputSchema: z.object({ command: z.string(), timeoutSeconds: z.number().optional() }),
             execute: async ({ command, timeoutSeconds }) => {
-                await ctx.emit("tool", `Führt aus: ${command.slice(0, 80)}`);
+                await ctx.emit("tool", { code: "runs", params: { command: command.slice(0, 80) } });
                 return report(await ctx.resources
                     .sandboxHandle()
                     .exec(command, { timeoutMs: timeoutMs(timeoutSeconds) }));
@@ -131,7 +131,7 @@ export async function buildStepTools(step, ctx, resolved, uploads) {
                     timeoutSeconds: z.number().optional(),
                 }),
                 execute: async ({ code, packages, timeoutSeconds }) => {
-                    await ctx.emit("tool", "Führt Python aus");
+                    await ctx.emit("tool", { code: "python" });
                     return report(await ctx.resources.sandboxHandle().runPython(code, {
                         packages,
                         timeoutMs: timeoutMs(timeoutSeconds),
@@ -174,7 +174,7 @@ export async function buildStepTools(step, ctx, resolved, uploads) {
                 aspectRatio: z.enum(["1:1", "16:9", "9:16", "4:5", "3:2", "2:3"]).optional(),
             }),
             execute: async ({ prompt, aspectRatio }) => {
-                await ctx.emit("tool", "Zeichnet ein Bild");
+                await ctx.emit("tool", { code: "drawing" });
                 const media = await generateImageMedia({
                     call: ctx.call,
                     prompt,
@@ -225,10 +225,16 @@ export async function buildStepTools(step, ctx, resolved, uploads) {
         });
         try {
             Object.assign(tools, await mcp.listTools());
-            await ctx.emit("tool", `Verbunden mit ${servers.map((s) => s.name).join(", ")}`);
+            await ctx.emit("tool", {
+                code: "mcpConnected",
+                params: { names: servers.map((s) => s.name).join(", ") },
+            });
         }
         catch (err) {
-            await ctx.emit("info", `MCP-Server nicht erreichbar: ${err.message}`);
+            await ctx.emit("info", {
+                code: "mcpUnreachable",
+                params: { detail: err.message },
+            });
         }
     }
     return {

package/apps/runtime/dist/tools/mail.js

@@ -29,7 +29,7 @@ export function mailTools(step, ctx, files) {
         inputSchema: mailSearchInput,
         execute: (input) => attempt(async () => {
             const { connector, ctx: actionCtx, label } = await open();
-            await ctx.emit("tool", `Durchsucht ${label}`);
+            await ctx.emit("tool", { code: "searchesMail", params: { label } });
             const { mails } = await mailAction(connector, "search", input, actionCtx);
             return {
                 mailbox: label,
@@ -64,7 +64,10 @@ export function mailTools(step, ctx, files) {
         }),
         execute: ({ items }) => attempt(async () => {
             const { connector, ctx: actionCtx, label } = await open();
-            await ctx.emit("tool", `Speichert ${items.length} Belege aus ${label}`);
+            await ctx.emit("tool", {
+                code: "savesReceipts",
+                params: { count: items.length, label },
+            });
             const saved = [];
             for (const item of items) {
                 try {

package/apps/runtime/dist/tools/pages.js

@@ -43,7 +43,7 @@ export function pageTools(ctx) {
             }),
             execute: (input) => attempt(async () => {
                 const page = await writeRunPage(projectId, wizardId, input);
-                await ctx.emit("tool", `Schreibt die Seite „${page.title}“`);
+                await ctx.emit("tool", { code: "writesPage", params: { title: page.title } });
                 return page;
             }),
         }),

package/apps/runtime/dist/tools/project.js

@@ -21,7 +21,10 @@ export async function projectTools(ctx) {
                 limit: z.number().int().min(1).max(12).optional(),
             }),
             execute: ({ query, limit }) => attempt(async () => {
-                await ctx.emit("tool", `Sucht in den Dokumenten: ${query.slice(0, 60)}`);
+                await ctx.emit("tool", {
+                    code: "searchesDocuments",
+                    params: { query: query.slice(0, 60) },
+                });
                 const hits = await searchProject(ctx.project.id, query, limit ?? 6);
                 return {
                     passages: hits.map((h) => ({ document: h.name, part: h.index, text: h.text })),
@@ -45,7 +48,7 @@ export async function projectTools(ctx) {
             if (!doc) {
                 throw new Error(`No document "${name}". There are: ${docs.map((d) => d.name).join(", ")}`);
             }
-            await ctx.emit("tool", `Liest ${doc.name}`);
+            await ctx.emit("tool", { code: "reads", params: { name: doc.name } });
             const text = await documentText(doc);
             const start = Math.min(from ?? 0, text.length);
             const part = text.slice(start, start + 12_000);

package/apps/runtime/dist/tools/store.js

@@ -113,7 +113,7 @@ export function storeTools(ctx, uploads, keeper) {
                         ? await saveRows(ctx.store, def, rows)
                         : { added: 0, updated: 0 };
                     const deleted = remove?.length ? await deleteRows(ctx.store, def, remove) : 0;
-                    await ctx.emit("tool", `Merkt sich ${def.title}`);
+                    await ctx.emit("tool", { code: "remembers", params: { title: def.title } });
                     return { ...saved, deleted };
                 }
                 catch (err) {
@@ -159,7 +159,7 @@ export function storeTools(ctx, uploads, keeper) {
                     .max(40),
             }),
             execute: ({ items }) => attempt(async () => {
-                await ctx.emit("tool", `Legt ${items.length} Dateien ab`);
+                await ctx.emit("tool", { code: "files", params: { count: items.length } });
                 const kept = [];
                 for (const item of items) {
                     try {
@@ -190,7 +190,7 @@ export function storeTools(ctx, uploads, keeper) {
         }),
         execute: ({ file, offset }) => attempt(async () => {
             const source = await resolveFile(ctx, file);
-            await ctx.emit("tool", `Liest ${source.name}`, file.startsWith("upload:") && source.mime.startsWith("image/")
+            await ctx.emit("tool", { code: "reads", params: { name: source.name } }, file.startsWith("upload:") && source.mime.startsWith("image/")
                 ? file.slice("upload:".length)
                 : undefined);
             const doc = await parseDocument(source, { charge, signal: ctx.signal, call: ctx.call });
@@ -212,7 +212,7 @@ export function storeTools(ctx, uploads, keeper) {
             kind: z.enum(["invoice", "receipt"]),
         }),
         execute: ({ files, kind }) => attempt(async () => {
-            await ctx.emit("tool", `Liest ${files.length} ${kind === "invoice" ? "Rechnungen" : "Belege"}`);
+            await ctx.emit("tool", { code: "readsMany", params: { count: files.length } });
             const results = [];
             for (let i = 0; i < files.length; i += 4) {
                 const batch = await Promise.all(files.slice(i, i + 4).map(async (file) => {

package/apps/runtime/dist/widgets/step.js

@@ -80,19 +80,22 @@ async function widgetData(step, ctx) {
 }
 /** A film: the widget's timeline rendered to an MP4 with sound — that video is the result. */
 async function runFilmStep(step, ctx, html, data, media, origin) {
-    await ctx.emit("info", "Der Film wird geschnitten – das dauert etwa eine Minute.");
+    await ctx.emit("info", { code: "filmCutting" });
     let told = 0;
     const film = await renderFilm(html, widgetSize(step), media, (done) => {
         if (done - told >= 0.25) {
             told = done;
-            void ctx.emit("info", `${Math.round(done * 100)} % geschnitten`);
+            void ctx.emit("info", { code: "filmProgress", params: { pct: Math.round(done * 100) } });
         }
     });
     if (!film) {
         throw new StepError("Der Film konnte nicht gerendert werden: dazu braucht es ffmpeg und eine Zeitleiste im Widget.");
     }
     if (film.errors.length) {
-        await ctx.emit("info", `Der Film meldet: ${film.errors[0].slice(0, 200)}`);
+        await ctx.emit("info", {
+            code: "filmError",
+            params: { detail: film.errors[0].slice(0, 200) },
+        });
     }
     const assets = [
         await ctx.saveAsset({
@@ -142,7 +145,10 @@ export async function runWidgetStep(step, ctx) {
         console.error(`[widget ${step.id}]`, err);
     }
     if (probe?.errors.length) {
-        await ctx.emit("info", `Das Widget meldet einen Fehler: ${probe.errors[0].slice(0, 200)}`);
+        await ctx.emit("info", {
+            code: "widgetError",
+            params: { detail: probe.errors[0].slice(0, 200) },
+        });
     }
     const assets = [
         await ctx.saveAsset({