wizards 0.2.25 → 0.2.27

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

@@ -0,0 +1,90 @@
+import { assembleSurface, dataRef, listRef, } from "@engenty-wizards/shared/definition";
+import { validateSurface } from "@engenty-wizards/shared/surface";
+import { decide } from "./decide.js";
+import { answersAsText, resolveRef } from "./template.js";
+import { StepError } from "./types.js";
+/**
+ * A surface step: its data read from the run (answers, outputs, stored lists; the pictures a
+ * step made as asset ids), its components written once — or, for a decided surface, the pieces
+ * one decision keeps. Checked against the catalog before it is shown.
+ */
+export async function runSurfaceStep(step, ctx) {
+    const data = surfaceData(step.data, ctx);
+    const components = step.components ?? (await decidedComponents(step, ctx));
+    const issues = validateSurface(components, Object.keys(data));
+    if (issues.length) {
+        throw new StepError(`Die Ansicht ist fehlerhaft: ${issues.map((i) => i.message).join(" ")}`);
+    }
+    return { surface: { components, data }, at: new Date().toISOString() };
+}
+/** What a surface reads: key → a field, a step's output or one of its fields, a stored list. */
+export function surfaceData(refs, ctx) {
+    const out = {};
+    for (const [key, raw] of Object.entries(refs)) {
+        const ref = dataRef(raw);
+        const list = listRef(ref);
+        if (list) {
+            out[key] = (ctx.scope.lists?.[list]?.rows ?? []).map((r) => r.cells);
+            continue;
+        }
+        const source = ctx.def.steps.find((s) => `steps.${s.id}` === ref);
+        if (source && (source.type === "generate" || source.type === "widget")) {
+            // Pictures and clips by asset id: the runner shows them from the run's files.
+            const ids = (ctx.state.outputs[source.id]?.assets ?? []).map((a) => a.id);
+            out[key] = source.type === "generate" && source.each ? ids : (ids[0] ?? null);
+            continue;
+        }
+        const output = source ? ctx.state.outputs[source.id] : undefined;
+        out[key] = output ? (output.json ?? output.text ?? null) : (resolveRef(ref, ctx.scope) ?? null);
+    }
+    return out;
+}
+/** The pieces of a decided surface one decision keeps: required ones always. */
+async function decidedComponents(step, ctx) {
+    const candidates = step.candidates ?? [];
+    const questions = {};
+    for (const c of candidates) {
+        if (!c.required && !c.group) {
+            questions[`p_${c.id}`] = {
+                type: "noul",
+                instructions: `Should the view show this: ${c.description}`,
+            };
+        }
+    }
+    for (const g of step.groups ?? []) {
+        const members = candidates.filter((c) => c.group === g.id && !c.required);
+        if (members.length) {
+            questions[`g_${g.id}`] = {
+                type: "choice",
+                instructions: g.instructions,
+                criteria: {
+                    ...Object.fromEntries(members.map((c) => [c.id, c.description])),
+                    ...(g.optional ? { none: "None of these." } : {}),
+                },
+            };
+        }
+    }
+    const kept = new Set(candidates.filter((c) => c.required).map((c) => c.id));
+    if (Object.keys(questions).length) {
+        const results = Object.fromEntries(ctx.def.steps
+            .map((s) => [s.title, ctx.state.outputs[s.id]?.text ?? ""])
+            .filter(([, text]) => text)
+            .map(([title, text]) => [title, text.slice(0, 6000)]));
+        const decision = await decide({
+            state: { answers: answersAsText(ctx.scope), results },
+            questions,
+            call: ctx.call,
+            signal: ctx.signal,
+            charge: ctx.chargeUsd,
+        });
+        for (const [name, answer] of Object.entries(decision.answers)) {
+            if (answer.type === "noul" && answer.noul >= 0.5) {
+                kept.add(name.slice(2));
+            }
+            else if (answer.type === "choice" && answer.choice !== "none") {
+                kept.add(answer.choice);
+            }
+        }
+    }
+    return assembleSurface(candidates, kept);
+}

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

@@ -143,7 +143,7 @@ export function registerTools(server, who) {
     });
     tool("list_starters", "wizards:read", {
         title: "List starters",
-        description: "The marketplace's ready-made wizards (tweet with image, video ad, research briefing, dashboard, invoice, offer …), with what each makes and needs. Give a query to search them; without one you get the starters.",
+        description: "Ready-made wizards to start from: first those the space's plugins bring (marked with the plugin), then the marketplace's (tweet with image, video ad, research briefing, dashboard, invoice, offer …), with what each makes and needs. Give a query to search them; without one you get the starters.",
         input: z.object({ query: z.string().max(200).optional() }),
         readOnly: true,
     }, async ({ query }) => (await searchMarketplace({ q: query ?? "", lang: "de", limit: 30 })).entries
@@ -155,6 +155,7 @@ export function registerTools(server, who) {
         formats: s.formats,
         useCases: s.useCases,
         capabilities: s.capabilities,
+        ...(s.plugin ? { plugin: s.plugin.name } : {}),
     })));
     tool("get_starter", "wizards:read", {
         title: "Get starter",
@@ -401,7 +402,7 @@ While status is running, get_run with waitSeconds. Hosts with MCP Apps also show
     }, async ({ runId, waitSeconds }) => runReport(who.userId, runId, waitSeconds));
     tool("answer_page", "runs:test", {
         title: "Answer page",
-        description: "Fill the page a run waits for: field id → value (items: an array of row objects; toggle: true/false; multiselect: an array). Returns the run, after waitSeconds.",
+        description: "Fill the page a run waits for: field id → value (items: an array of row objects; toggle: true/false; multiselect: an array; slot: one of the offered times, as given). Returns the run, after waitSeconds.",
         input: z.object({
             runId: z.string(),
             stepId: z.string().describe("waitingFor.page"),

package/apps/runtime/dist/plugins/loader.js

@@ -1,11 +1,12 @@
 import { existsSync, mkdirSync, watch } from "node:fs";
 import { join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { PLUGIN_TOOL_NAME } from "@engenty-wizards/shared/definition";
+import { PLUGIN_ID, PLUGIN_TOOL_NAME, wizardSchema } from "@engenty-wizards/shared/definition";
 import { generateText, Output } from "ai";
 import { createJiti } from "jiti";
 import { readPage } from "../agents/website.js";
 import { packageRoot } from "../cli/home.js";
+import { pluginConnections } from "../connectors/plugin-connections.js";
 import { db, onTenantOpen } from "../db/client.js";
 import { parseDocument } from "../documents/parse.js";
 import { env } from "../env.js";
@@ -98,6 +99,9 @@ function apiFor(record) {
                 }
                 record.assistantTools.set(tool.name, tool);
             },
+            registerAssistantContext(context) {
+                record.assistantPages.push(context);
+            },
             registerPublicRoute(route) {
                 record.publicRoutes.push(compileRoute(route));
             },
@@ -153,6 +157,21 @@ function apiFor(record) {
                     object: (request.schema ? result.output : undefined),
                 };
             },
+            connections: pluginConnections(source.id),
+            registerStarter(starter) {
+                if (!PLUGIN_ID.test(starter.id)) {
+                    throw new Error(`Starter "${starter.id}": an id is lower case, digits and "-".`);
+                }
+                if (record.starters.has(starter.id)) {
+                    throw new Error(`Starter "${starter.id}" is registered twice.`);
+                }
+                const parsed = wizardSchema.safeParse(starter.definition);
+                if (!parsed.success) {
+                    const issue = parsed.error.issues[0];
+                    throw new Error(`Starter "${starter.id}": ${issue?.path.join(".") || "definition"}: ${issue?.message}`);
+                }
+                record.starters.set(starter.id, { ...starter, definition: parsed.data });
+            },
             onUnload(dispose) {
                 record.disposers.push(dispose);
             },
@@ -186,8 +205,10 @@ async function load(source) {
             record.tools.clear();
             record.contexts = [];
             record.assistantTools.clear();
+            record.assistantPages = [];
             record.publicRoutes = [];
             record.jobs.clear();
+            record.starters.clear();
             record.listeners = {};
             record.migrations = [];
             record.error = err?.message || String(err);

package/apps/runtime/dist/plugins/registry.js

@@ -17,8 +17,10 @@ export function emptyRecord(source) {
         tools: new Map(),
         contexts: [],
         assistantTools: new Map(),
+        assistantPages: [],
         publicRoutes: [],
         jobs: new Map(),
+        starters: new Map(),
         listeners: {},
         migrations: [],
         disposers: [],
@@ -83,6 +85,14 @@ export async function pluginToolsOf(tenantId) {
         description: tool.description,
     })));
 }
+/** The starters the tenant's plugins bring, in the order the plugins registered them. */
+export async function pluginStartersOf(tenantId) {
+    return (await pluginsOf(tenantId)).flatMap((plugin) => [...plugin.starters.values()].map((starter) => ({
+        id: `${plugin.source.id}.${starter.id}`,
+        plugin,
+        starter,
+    })));
+}
 /** The built studio half as it is on disk now; null when the plugin has none. */
 export function pluginAsset(record, kind) {
     const file = record.source[kind];

package/apps/runtime/dist/render/downloads.js

@@ -69,6 +69,13 @@ export async function renderDownload(step, output, format, baseName) {
             ? { data: new Uint8Array(found.data), mime: found.row.mime, filename: file(format) }
             : null;
     }
+    if (step.type === "surface") {
+        return {
+            data: JSON.stringify(output.surface ?? {}, null, 2),
+            mime: MIME.json,
+            filename: file("json"),
+        };
+    }
     if (step.type === "widget") {
         const source = output.assets?.find((a) => a.mime === "text/html");
         if (format === "json") {

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

@@ -9,6 +9,7 @@ import { nanoid } from "nanoid";
 import { z } from "zod";
 import { principalOf } from "../auth/index.js";
 import { ConnectError, connectionViews, connectWithCredentials, disconnect, finishOAuth, oauthStateRun, startOAuth, } from "../connectors/index.js";
+import { finishPluginOAuth, pluginStateTenant } from "../connectors/plugin-connections.js";
 import { db, schema, withTenant } from "../db/client.js";
 import { answerAsk, pendingAsk } from "../engine/asks.js";
 import { signalChanged, subscribe } from "../engine/events.js";
@@ -558,8 +559,16 @@ export const runRoutes = new Hono()
     if (!run || !connection) {
         return c.json({ error: "not found" }, 404);
     }
-    const url = await startOAuth(scopeOf(run), await projectIdOf(run), run.id, connection, c.req.param("connectorId"));
-    return c.json({ url });
+    try {
+        const url = await startOAuth(scopeOf(run), await projectIdOf(run), run.id, connection, c.req.param("connectorId"));
+        return c.json({ url });
+    }
+    catch (err) {
+        if (err instanceof ConnectError) {
+            return c.json({ error: err.message }, 422);
+        }
+        throw err;
+    }
 })
     .post("/:id/connections/:connectionId/credentials/:connectorId", async (c) => {
     const run = await accessibleRun(c, c.req.param("id"));
@@ -780,14 +789,26 @@ function sendDownload(c, download) {
  */
 export const connectCallback = new Hono().get("/callback", async (c) => {
     const code = c.req.query("code");
+    // Connected through the account's Manage-App: a ticket instead of a code.
+    const ticket = c.req.query("ticket");
     const state = c.req.query("state");
     let ok = false;
-    let message = "Verbinden wurde abgebrochen.";
-    const tenant = state ? await tenantOfRun(oauthStateRun(state) ?? "") : null;
-    if (code && state && tenant) {
+    let message = c.req.query("error") === "exchange_failed"
+        ? "Verbinden hat nicht geklappt. Bitte noch einmal versuchen."
+        : "Verbinden wurde abgebrochen.";
+    // A plugin's sign-in (server.connections) names its tenant; a wizard's names its run.
+    const pluginTenant = state ? pluginStateTenant(state) : null;
+    const tenant = state ? (pluginTenant ?? (await tenantOfRun(oauthStateRun(state) ?? ""))) : null;
+    const answer = ticket ? { ticket } : code ? { code } : null;
+    if (answer && state && tenant) {
         try {
-            const done = await withTenant(tenant, () => finishOAuth(code, state));
-            signalChanged(done.runId);
+            if (pluginTenant) {
+                await withTenant(tenant, () => finishPluginOAuth(answer, state));
+            }
+            else {
+                const done = await withTenant(tenant, () => finishOAuth(answer, state));
+                signalChanged(done.runId);
+            }
             ok = true;
             message = "Verbunden. Du kannst dieses Fenster schließen.";
         }

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

@@ -1,6 +1,6 @@
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { MODEL_CLASSES, TEXT_CLASSES } from "@engenty-wizards/shared/definition";
+import { MODEL_CLASSES, PLUGIN_ID, TEXT_CLASSES } from "@engenty-wizards/shared/definition";
 import { CATEGORY_TYPES, whereSchema } from "@engenty-wizards/shared/knowledge";
 import { PROJECT_FILE_KINDS } from "@engenty-wizards/shared/projects";
 import { isCreditsRef } from "@engenty-wizards/shared/providers";
@@ -405,6 +405,7 @@ export const studio = new Hono()
             .max(24)
             .default([]),
         part: z.enum(["info", "knowledge"]).default("info"),
+        plugin: z.string().regex(PLUGIN_ID).optional(),
     })
         .parse(await c.req.json());
     if (!(await canSpend())) {
@@ -420,6 +421,7 @@ export const studio = new Hono()
                 message: body.message,
                 history: body.history,
                 part: body.part,
+                plugin: body.plugin,
                 signal: abort.signal,
                 onText: (delta) => {
                     void stream.writeSSE({ event: "text", data: JSON.stringify(delta) });

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

@@ -1,5 +1,7 @@
+import { createHash } from "node:crypto";
+import { statSync } from "node:fs";
 import { DEFINITION_VERSION, readable, wizardSchema, } from "@engenty-wizards/shared/definition";
-import { MARKETPLACE_LANGS, } from "@engenty-wizards/shared/marketplace";
+import { capabilitiesOf, costTierOf, effortOf, formatsOf, MARKETPLACE_LANGS, } from "@engenty-wizards/shared/marketplace";
 import { wizardOutline } from "@engenty-wizards/shared/marketplace-entry";
 import { searchEntries } from "@engenty-wizards/shared/marketplace-search";
 import { and, eq, inArray, notInArray } from "drizzle-orm";
@@ -9,14 +11,19 @@ import { missingCapabilities, optionalCapabilities, stepsWithoutModel, } from ".
 import { env } from "../env.js";
 import { managed } from "../manage.js";
 import { classCatalog, imageCostUsd, tokenCostUsd, videoCostUsd, WEB_SEARCH_COST_USD, } from "../models.js";
+import { pluginStartersOf } from "../plugins/registry.js";
 import { readSetting, writeSetting } from "../settings.js";
-import { LOCAL_TENANT } from "../tenants/tenant.js";
+import { currentTenant, LOCAL_TENANT } from "../tenants/tenant.js";
 import { ServiceError } from "./errors.js";
 /**
  * The marketplace is an app of its own; this runtime is one of its clients
  * (docs/marketplace-contract.md). It searches the marketplace live and starts wizards from its
  * entries. Its starters and what people starred are kept in the control database, so the list
  * and starting a wizard work without a connection too.
+ *
+ * Beside them stand the starters the tenant's plugins bring (docs/content/dev/plugins/starters.md),
+ * listed first and never fetched. They are known as `<plugin id>.<starter id>`; a marketplace
+ * entry's id has no dot, so the two never meet.
  */
 export const asLang = (raw) => MARKETPLACE_LANGS.includes(raw ?? "") ? raw : "de";
 /** A search waits this long for the marketplace; then it searches what is kept here. */
@@ -84,6 +91,69 @@ function keptItem(e, lang) {
     const text = textIn(e, lang);
     return text ? { ...keptSummary(e, lang), definition: text.definition, files: e.files } : null;
 }
+// --- the plugins' starters ------------------------------------------------------------------
+/** One of the starters the tenant's plugins bring, by its id; undefined for any other id. */
+async function pluginStarter(id) {
+    if (!id.includes(".")) {
+        return undefined;
+    }
+    return (await pluginStartersOf(currentTenant())).find((s) => s.id === id);
+}
+/** A plugin's starter as the marketplace lists an entry, read from its definition. */
+function pluginSummary({ id, plugin, starter }) {
+    const definition = starter.definition;
+    const { name, version } = plugin.source.manifest;
+    const capabilities = capabilitiesOf(definition);
+    const changed = statSync(plugin.source.entry ?? plugin.source.root, { throwIfNoEntry: false });
+    return {
+        id,
+        revision: 0,
+        hash: createHash("sha256")
+            .update(`${version}\n${JSON.stringify(definition)}`)
+            .digest("hex")
+            .slice(0, 16),
+        updatedAt: (changed?.mtime ?? new Date()).toISOString(),
+        starter: true,
+        language: starter.language ?? "de",
+        title: starter.title,
+        pitch: starter.description,
+        // Found by the plugin's name as well: "Termine" finds the appointment plugin's starters.
+        terms: [name],
+        avatar: definition.avatar,
+        formats: formatsOf(definition),
+        industries: ["any"],
+        useCases: [],
+        capabilities,
+        effort: effortOf(definition),
+        costTier: costTierOf(capabilities),
+        steps: definition.steps.length,
+        version: definition.version,
+    };
+}
+/** A plugin's starter as this app shows it: never starred, and marked with its plugin. */
+function pluginEntry(found, unavailable) {
+    const { id, name } = found.plugin.source.manifest;
+    return {
+        ...asEntry(pluginSummary(found), new Set(), unavailable, optionalOf(found.starter.definition)),
+        plugin: { id, name },
+    };
+}
+/** Two searches' counts per option, added up. */
+function addFacets(a, b) {
+    const add = (x = {}, y = {}) => {
+        const out = { ...x };
+        for (const [key, n] of Object.entries(y)) {
+            out[key] = (out[key] ?? 0) + n;
+        }
+        return out;
+    };
+    return {
+        useCase: add(a.useCase, b.useCase),
+        industry: add(a.industry, b.industry),
+        format: add(a.format, b.format),
+        capability: add(a.capability, b.capability),
+    };
+}
 // --- searching -----------------------------------------------------------------------------
 /** A summary as this app shows it: whether it can read and run it, and whether it is starred. */
 function asEntry(summary, starred, unavailable, optional = new Set()) {
@@ -120,8 +190,43 @@ async function keptOptional(ids, lang, unavailable) {
     }
     return out;
 }
-/** Searches the marketplace; without an answer, what is kept here, scored the same way. */
+/**
+ * Searches the tenant's plugins' starters and the marketplace, in that order: a page holds the
+ * plugins' starters the words and filters find, then the marketplace's entries.
+ */
 export async function searchMarketplace(search) {
+    const { q = "", starred, limit = 60, offset = 0, lang: _lang, ...filters } = search;
+    const own = starred ? [] : await pluginStartersOf(currentTenant());
+    if (!own.length) {
+        return searchListed(search);
+    }
+    const byId = new Map(own.map((s) => [s.id, s]));
+    const found = searchEntries(own.map(pluginSummary), q, filters, { limit: own.length });
+    const shown = found.entries.slice(offset, offset + limit);
+    // The marketplace fills what is left of the page, and counts from where its entries begin.
+    const room = limit - shown.length;
+    const listed = await searchListed({
+        ...search,
+        limit: Math.max(1, room),
+        offset: Math.max(0, offset - found.total),
+    });
+    const unavailable = new Set(listed.unavailable);
+    return {
+        ...listed,
+        entries: [
+            ...shown.flatMap((e) => {
+                const entry = byId.get(e.id);
+                return entry ? [pluginEntry(entry, unavailable)] : [];
+            }),
+            ...listed.entries.slice(0, room),
+        ],
+        total: found.total + listed.total,
+        all: own.length + listed.all,
+        facets: addFacets(listed.facets, found.facets),
+    };
+}
+/** Searches the marketplace; without an answer, what is kept here, scored the same way. */
+async function searchListed(search) {
     const { q = "", lang, starred: onlyStarred, limit = 60, offset = 0, ...filters } = search;
     const stars = await starredIds();
     const starred = new Set(stars);
@@ -217,6 +322,15 @@ async function priced(definition) {
 }
 /** An entry in a language with its wizard read against this app; null where there is none. */
 export async function marketplaceDetail(id, lang) {
+    const own = await pluginStarter(id);
+    if (own) {
+        const definition = own.starter.definition;
+        return {
+            ...pluginEntry(own, await missingCapabilities()),
+            credits: await priced(definition),
+            ...wizardOutline(definition, Object.keys(own.starter.files ?? {}), lang),
+        };
+    }
     const found = await fetchItem(id, lang);
     if (!found) {
         return null;
@@ -242,6 +356,23 @@ export async function marketplaceDetail(id, lang) {
 }
 /** An entry's wizard and workspace in a language: what a wizard is made from. */
 export async function marketplaceWizard(id, lang) {
+    const own = await pluginStarter(id);
+    if (own) {
+        // A plugin's starter is in its one language, whatever is asked for.
+        const { starter, plugin } = own;
+        return {
+            id,
+            revision: null,
+            plugin: plugin.source.id,
+            title: starter.title,
+            language: starter.language ?? "de",
+            definition: structuredClone(starter.definition),
+            files: Object.fromEntries(Object.entries(starter.files ?? {}).map(([path, data]) => [
+                path,
+                typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data),
+            ])),
+        };
+    }
     const found = await fetchItem(id, lang);
     if (!found) {
         return null;

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

@@ -1,32 +1,27 @@
-import { systemOneAccess } from "../models.js";
+import { decide } from "../engine/decide.js";
 /**
  * The last step of a search of Wissen: does each candidate the index found help answer the
- * question? TypeSafe's Jev answers one yes/no question per candidate, all in one call and each
- * on its own, with P(yes) and no text. What falls under MIN_RELEVANCE goes; the rest is ranked
- * by it. As engenty-pro's knowledge base checks its hits.
+ * question? One yes/no question per candidate, all in one decision: a decision model (Jev)
+ * answers each on its own with P(yes); without one the classifier class's language model
+ * answers yes or no. What falls under MIN_RELEVANCE goes; the rest is ranked by it. As
+ * engenty-pro's knowledge base checks its hits.
  */
 export const MIN_RELEVANCE = 0.5;
 /** A search waits for a person: a classifier that cannot answer in this time is left out. */
 const TIMEOUT_MS = 4000;
-const ATTEMPTS = 2;
 const TEXT_CHARS = 1200;
 const clip = (value, max) => {
     const s = value.replace(/\s+/g, " ").trim();
     return s.length > max ? `${s.slice(0, max - 1)}…` : s;
 };
 /**
- * P(relevant) for each candidate, in their order; null for one the answer left out. Null for
- * all of them when no classifier is set up or it did not answer in time: the search then keeps
- * the order the index gave.
+ * P(relevant) for each candidate, in their order. Null for all of them when no way decided in
+ * time: the search then keeps the order the index gave.
  */
 export async function judgeRelevance(query, candidates, signal) {
     if (!candidates.length) {
         return [];
     }
-    const access = await systemOneAccess().catch(() => null);
-    if (!access) {
-        return null;
-    }
     const questions = {};
     const state = {
         query: clip(query, 600),
@@ -49,42 +44,15 @@ export async function judgeRelevance(query, candidates, signal) {
             };
         }),
     };
-    const body = JSON.stringify({
-        ...(access.model ? { model: access.model } : {}),
-        state,
-        questions,
-    });
-    for (let attempt = 1; attempt <= ATTEMPTS; attempt++) {
-        try {
-            const res = await fetch(access.url, {
-                method: "POST",
-                headers: { ...access.headers, "content-type": "application/json" },
-                body,
-                signal: signal
-                    ? AbortSignal.any([signal, AbortSignal.timeout(TIMEOUT_MS)])
-                    : AbortSignal.timeout(TIMEOUT_MS),
-            });
-            if (!res.ok) {
-                if ([429, 503, 529].includes(res.status) && attempt < ATTEMPTS) {
-                    continue;
-                }
-                console.warn(`[relevance] the classifier answered ${res.status}`);
-                return null;
-            }
-            const answer = (await res.json());
-            return candidates.map((_, index) => {
-                const a = answer.answers?.[`c${index}`];
-                return a?.type === "noul" && typeof a.noul === "number" && Number.isFinite(a.noul)
-                    ? Math.round(a.noul * 1000) / 1000
-                    : null;
-            });
-        }
-        catch (err) {
-            if (signal?.aborted || attempt >= ATTEMPTS) {
-                console.warn("[relevance] the classifier did not answer:", err.message);
-                return null;
-            }
-        }
+    try {
+        const decision = await decide({ state, questions, signal, deadlineMs: TIMEOUT_MS });
+        return candidates.map((_, index) => {
+            const a = decision.answers[`c${index}`];
+            return a?.type === "noul" ? Math.round(a.noul * 1000) / 1000 : null;
+        });
+    }
+    catch (err) {
+        console.warn("[relevance] no decision:", err.message);
+        return null;
     }
-    return null;
 }

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

@@ -1,4 +1,4 @@
-import { formatsFor } from "@engenty-wizards/shared/definition";
+import { formatsFor, optionsFromData, slotText, wizardLang, } from "@engenty-wizards/shared/definition";
 import { and, count, desc, eq, gte, inArray, max, or, sql } from "drizzle-orm";
 import { canSpend, MICROS_PER_CREDIT } from "../credits/credits.js";
 import { db, schema } from "../db/client.js";
@@ -159,7 +159,31 @@ const CHAT_KINDS = new Set([
     "color",
     "items",
     "location",
+    "slot",
 ]);
+/** A field's choices in this run: what its `optionsFrom` finds in earlier steps, else the fixed ones. */
+function choicesOf(run, field) {
+    const found = field.optionsFrom ? optionsFromData(field.optionsFrom, run.state.outputs) : [];
+    return found.length ? found : field.options;
+}
+/**
+ * What a client needs besides the plain field: a slot's times as the person reads them, and the
+ * one value of them to send back.
+ */
+function slotHints(run, field, options) {
+    if (field.kind !== "slot") {
+        return {};
+    }
+    const lang = wizardLang(run.definition);
+    const value = run.state.values[field.id];
+    return {
+        times: (options ?? []).map((o) => ({ value: o, label: slotText(o, lang) })),
+        ...(typeof value === "string" ? { valueText: slotText(value, lang) } : {}),
+        hint: options?.length
+            ? "One appointment time: show the person the labels, answer with the value of the one they pick, exactly as given."
+            : "No times are free right now: tell the person.",
+    };
+}
 /** Where the person can go on in a browser: the run page of a live run, the studio for a test. */
 /** The live run's page — the wizard itself, never the studio. A test run has none. */
 async function browserUrl(run) {
@@ -197,20 +221,24 @@ function waitingFor(run, current) {
         return {
             page: current.id,
             title: current.title,
-            fields: current.fields.map((f) => ({
-                id: f.id,
-                label: f.label,
-                kind: f.kind,
-                required: Boolean(f.required),
-                options: f.options,
-                placeholder: f.placeholder,
-                help: f.help,
-                default: f.default,
-                value: run.state.values[f.id],
-                columns: f.columns,
-                // A file, a recording or a signature comes from the person's device: the run page.
-                inChat: CHAT_KINDS.has(f.kind),
-            })),
+            fields: current.fields.map((f) => {
+                const options = choicesOf(run, f);
+                return {
+                    id: f.id,
+                    label: f.label,
+                    kind: f.kind,
+                    required: Boolean(f.required),
+                    options,
+                    placeholder: f.placeholder,
+                    help: f.help,
+                    default: f.default,
+                    value: run.state.values[f.id],
+                    columns: f.columns,
+                    // A file, a recording or a signature comes from the person's device: the run page.
+                    inChat: CHAT_KINDS.has(f.kind),
+                    ...slotHints(run, f, options),
+                };
+            }),
         };
     }
     if (current.type === "review") {