wizards 0.2.24 → 0.2.26

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

@@ -1,12 +1,20 @@
-import { isDecisionStep, MODEL_CLASSES, ruleMatches, } from "@engenty-wizards/shared/definition";
+import { conditionMatches, conditionsOf, isDecidedField, isDecisionStep, isOtherwise, MODEL_CLASSES, ruleMatches, } from "@engenty-wizards/shared/definition";
 import { classProblem, filmClient } from "../models.js";
 /**
  * What a wizard needs of the models before a run starts: each class its steps call, and whether
  * this runtime can serve it. A step every run passes through blocks the start when its class is
  * missing; a step behind a branch only warns, since the person may choose around it.
  */
-/** The classes a step calls, as ../engine/steps.ts and ../media/generate.ts call them. */
+/**
+ * The classes a step calls, as ../engine/steps.ts and ../media/generate.ts call them — and the
+ * classifier where a decision picks its next step or a page's fields.
+ */
 export function stepClasses(step) {
+    const own = ownClasses(step);
+    const decides = step.next?.some((r) => r.ask) || (step.type === "page" && step.fields.some(isDecidedField));
+    return decides && !own.includes("classifier") ? [...own, "classifier"] : own;
+}
+function ownClasses(step) {
     switch (step.type) {
         case "agent": {
             if (isDecisionStep(step)) {
@@ -19,6 +27,9 @@ export function stepClasses(step) {
             if (step.output.format === "json") {
                 classes.push("classifier");
             }
+            if (step.output.surface && !classes.includes("standard")) {
+                classes.push("standard");
+            }
             return classes;
         }
         case "generate":
@@ -64,8 +75,11 @@ export function unavoidableFrom(def, from, known) {
     const successors = (i) => {
         const out = [];
         for (const rule of def.steps[i].next ?? []) {
+            if (isOtherwise(rule)) {
+                continue;
+            }
             const target = rule.goto === "end" ? def.steps.length : (index.get(rule.goto) ?? -1);
-            if (!(rule.when.field in known)) {
+            if (rule.ask || !conditionsOf(rule.when).every((c) => c.field in known)) {
                 if (target >= 0) {
                     out.push(target);
                 }
@@ -76,8 +90,8 @@ export function unavoidableFrom(def, from, known) {
                 return target >= 0 ? [...out, target] : out;
             }
         }
-        // No rule matching goes on to the next step (or ends after the last).
-        out.push(i + 1);
+        // No rule matching goes on to the "otherwise" step, else the next (or ends after the last).
+        out.push(otherwiseIndex(def, i, index));
         return out;
     };
     const reachesEnd = (without) => {
@@ -102,11 +116,36 @@ export function unavoidableFrom(def, from, known) {
     };
     return new Set(def.steps.filter((_, i) => !reachesEnd(i)).map((s) => s.id));
 }
+/** Where step `i` goes when none of its rules holds, as an index; the length = the end. */
+function otherwiseIndex(def, i, index) {
+    const goto = def.steps[i].next?.find(isOtherwise)?.goto;
+    if (goto === undefined) {
+        return i + 1;
+    }
+    return goto === "end" ? def.steps.length : (index.get(goto) ?? i + 1);
+}
 /** 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) {
+    // A decision may go either way.
+    if (rule.ask) {
+        return null;
+    }
+    let all = true;
+    for (const c of conditionsOf(rule.when)) {
+        const holds = conditionHolds(c, facts);
+        if (holds === false) {
+            return false;
+        }
+        if (holds === null) {
+            all = null;
+        }
+    }
+    return all;
+}
+function conditionHolds(c, facts) {
+    const k = facts[c.field];
+    const value = c.value;
+    switch (c.op) {
         case "empty":
             return k?.filled === undefined ? (k?.is !== undefined ? false : null) : !k.filled;
         case "notEmpty":
@@ -130,15 +169,35 @@ function ruleHolds(rule, facts) {
             }
             return list.every((v) => k?.not.includes(v)) ? false : null;
         }
+        case "gt":
+        case "lt":
+        case "contains":
+            if (k?.is !== undefined) {
+                return conditionMatches(c, { [c.field]: k.is });
+            }
+            return k?.filled === false ? false : null;
     }
 }
-/** What is known once a rule did (`held`) or did not match. */
+/**
+ * What is known once a rule did (`held`) or did not match. A rule of several conditions that
+ * did not match says nothing about any one of them.
+ */
 function learn(rule, held, facts) {
-    const field = rule.when.field;
+    if (rule.ask) {
+        return facts;
+    }
+    const conditions = conditionsOf(rule.when);
+    if (held) {
+        return conditions.reduce((known, c) => learnCondition(c, true, known), facts);
+    }
+    return conditions.length === 1 ? learnCondition(conditions[0], false, facts) : facts;
+}
+function learnCondition(c, held, facts) {
+    const field = c.field;
     const k = { ...(facts[field] ?? { not: [] }) };
     k.not = [...k.not];
-    const value = String(rule.when.value);
-    const op = rule.when.op;
+    const value = String(c.value);
+    const op = c.op;
     if ((op === "equals" && held) || (op === "notEquals" && !held)) {
         k.is = value;
         k.filled = true;
@@ -146,12 +205,15 @@ function learn(rule, held, facts) {
     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 === "in" && !held && Array.isArray(c.value)) {
+        k.not.push(...c.value.map(String));
     }
     else if (op === "empty" || op === "notEmpty") {
         k.filled = (op === "notEmpty") === held;
     }
+    else if ((op === "gt" || op === "lt" || op === "contains") && held) {
+        k.filled = true;
+    }
     return { ...facts, [field]: k };
 }
 /**
@@ -185,6 +247,9 @@ export function mostAlongOnePath(def, cost, closed = new Set()) {
             let known = facts;
             let decided = false;
             for (const rule of step.next ?? []) {
+                if (isOtherwise(rule)) {
+                    continue;
+                }
                 const holds = ruleHolds(rule, known);
                 if (holds === false) {
                     continue;
@@ -197,7 +262,7 @@ export function mostAlongOnePath(def, cost, closed = new Set()) {
                 known = learn(rule, false, known);
             }
             if (!decided) {
-                consider(i + 1, known);
+                consider(otherwiseIndex(def, i, index), known);
             }
             return most === null ? null : most + cost(step);
         };

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

@@ -1,4 +1,5 @@
-import { branchValues, dataRef, formatsFor, LIST_FORMATS, listRef, nextStepId, } from "@engenty-wizards/shared/definition";
+import { marginOf, } from "@engenty-wizards/shared/decision";
+import { branchValues, conditionsOf, dataRef, followRules, formatsFor, isDecidedField, LIST_FORMATS, listRef, loopKey, MAX_SHOWN_FIELDS, optionsFromData, otherwiseOf, pageNeeds, whenHolds, } from "@engenty-wizards/shared/definition";
 import { eq } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { connectionViews } from "../connectors/index.js";
@@ -17,13 +18,14 @@ import { listRows, scopeOf } from "../store/index.js";
 import { activeRuns, indexRun, markRunActive } from "../tenants/control.js";
 import { currentTenant } from "../tenants/tenant.js";
 import { askPerson, clearStaleAsk, unattended } from "./asks.js";
+import { decide } from "./decide.js";
 import { emitEvent, recentEvents, signalChanged } from "./events.js";
 import { readPageInput } from "./input.js";
 import { pushRun } from "./push.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";
+import { answersAsText, resolveRef } from "./template.js";
 import { StepError } from "./types.js";
 /** A command the run cannot take in its current state. */
 export class RunConflict extends Error {
@@ -226,6 +228,45 @@ export function kick(runId) {
         signalChanged(runId);
     });
 }
+/** What conditions read in this run: answers, outputs, and how many rows each stored list has. */
+async function flowValues(run, state) {
+    const counts = {};
+    if (run.definition.lists?.length) {
+        for (const [id, list] of Object.entries(await storedLists(run))) {
+            counts[id] = list.rows.length;
+        }
+    }
+    return branchValues(state.values, state.outputs, counts);
+}
+/**
+ * What a page knows besides the person's input: what its fields' `when` read from before the
+ * page (its own earlier answers left out, so a revisit decides on what is typed now) and the
+ * choices its `optionsFrom` fields find in the run.
+ */
+async function pageContext(run, step) {
+    const needs = pageNeeds(step.fields);
+    const sourced = step.fields.filter((f) => f.optionsFrom);
+    const decided = step.fields.some(isDecidedField) ? (run.state.pages?.[step.id]?.shown ?? []) : [];
+    if (!needs.length && !sourced.length) {
+        return { known: {}, options: {}, decided };
+    }
+    const all = await flowValues(run, run.state);
+    const known = Object.fromEntries(needs.map((ref) => [ref, all[ref]]));
+    const lists = sourced.some((f) => f.optionsFrom?.startsWith("lists."))
+        ? await storedLists(run)
+        : {};
+    const options = {};
+    for (const field of sourced) {
+        const found = optionsFromData(field.optionsFrom ?? "", run.state.outputs, lists);
+        if (found.length) {
+            options[field.id] = found;
+        }
+    }
+    return { known, options, decided };
+}
+function viewContext(ctx) {
+    return { known: ctx.known, options: ctx.options, decidedFields: ctx.decided };
+}
 /** The wizard's lists with the person's rows, by list id. */
 async function storedLists(run) {
     const scope = scopeOf(run);
@@ -243,6 +284,7 @@ async function makeContext(run, project, state, signal) {
     return {
         runId: run.id,
         tenantId: run.tenantId,
+        test: run.mode === "test",
         stepId,
         store,
         def: run.definition,
@@ -271,6 +313,146 @@ async function makeContext(run, project, state, signal) {
         }),
     };
 }
+/** A decided branch is taken only when its pick leads the runner-up by this much. */
+const BRANCH_MARGIN = 0.1;
+/**
+ * Where the run goes after `stepId`: a `when` rule or the next step at once — counted, so a loop
+ * stops at its rule's max — or, for `ask` rules, a decision the drive loop makes (`deciding`).
+ */
+async function advance(run, stepId, state) {
+    const outcome = followRules(run.definition, stepId, await flowValues(run, state), state.loops);
+    if (outcome.kind === "decide") {
+        state.deciding = stepId;
+        return stepId;
+    }
+    return taken(run.definition, stepId, outcome.rule, outcome.cursor, state);
+}
+function taken(def, stepId, rule, cursor, state) {
+    const goto = rule === null ? null : stepOf(def, stepId)?.next?.[rule]?.goto;
+    if (goto) {
+        const key = loopKey(stepId, goto);
+        state.loops = { ...state.loops, [key]: (state.loops?.[key] ?? 0) + 1 };
+    }
+    return cursor;
+}
+/** What a decision about the run reads: the person's answers and what the steps made so far. */
+function runSummary(run, state) {
+    const results = {};
+    for (const step of run.definition.steps) {
+        const out = state.outputs[step.id];
+        const text = out?.text ?? (out?.json === undefined ? "" : JSON.stringify(out.json));
+        if (text) {
+            results[step.title] = text.slice(0, 6000);
+        }
+    }
+    return {
+        answers: answersAsText({ def: run.definition, state, brand: {} }),
+        results,
+    };
+}
+/**
+ * The decision over a step's open `ask` rules: one choice among their statements and "none".
+ * Kept in the run; a pick that does not lead clearly (where there are probabilities) is none.
+ */
+async function decideBranch(run, step, state, signal) {
+    const outcome = followRules(run.definition, step.id, {}, state.loops);
+    const rules = outcome.kind === "decide" ? outcome.rules : [];
+    const criteria = {};
+    for (const i of rules) {
+        criteria[`r${i}`] = step.next?.[i]?.ask ?? "";
+    }
+    criteria.none = "None of these clearly holds: go on with the next step.";
+    await emitEvent(run.id, step.id, "info", { code: "deciding" });
+    const decision = await decide({
+        state: runSummary(run, state),
+        questions: {
+            next: {
+                type: "choice",
+                instructions: "Which statement is true of this run? Answer none unless one clearly holds.",
+                criteria,
+            },
+        },
+        call: { runId: run.id, stepId: step.id },
+        signal,
+        charge: (usd) => addLocalCost(run.id, step.id, usd),
+    });
+    const answer = decision.answers.next;
+    const margin = marginOf(answer);
+    const pick = margin !== null && margin < BRANCH_MARGIN ? "none" : answer.choice;
+    const rule = pick === "none" ? null : Number(pick.slice(1));
+    state.decisions = {
+        ...state.decisions,
+        [step.id]: {
+            rule,
+            source: decision.source,
+            ...(answer.probabilities ? { probabilities: answer.probabilities } : {}),
+            at: new Date().toISOString(),
+        },
+    };
+    delete state.deciding;
+    if (rule === null) {
+        const otherwise = otherwiseOf(run.definition, step.id, state.loops);
+        return taken(run.definition, step.id, otherwise.rule, otherwise.cursor, state);
+    }
+    const goto = step.next?.[rule]?.goto ?? "end";
+    return taken(run.definition, step.id, rule, goto === "end" ? null : goto, state);
+}
+/**
+ * The decided fields (`ask`, `group`) of a page a decision keeps, in one call as the run reaches
+ * the page. A field whose condition on earlier data already fails is not asked about. With the
+ * fields always shown, at most MAX_SHOWN_FIELDS appear.
+ */
+async function decidePageFields(run, page, state, signal) {
+    const values = await flowValues(run, state);
+    const own = new Set(page.fields.map((f) => f.id));
+    const possible = page.fields.filter((f) => isDecidedField(f) &&
+        whenHolds(conditionsOf(f.when).filter((c) => !own.has(c.field)), values));
+    const questions = {};
+    for (const f of possible.filter((f) => f.ask)) {
+        questions[`f_${f.id}`] = {
+            type: "noul",
+            instructions: `Should the page ask "${f.label}"? It is asked when this holds: ${f.ask}`,
+        };
+    }
+    for (const g of page.groups ?? []) {
+        const members = possible.filter((f) => f.group === g.id);
+        if (members.length) {
+            questions[`g_${g.id}`] = {
+                type: "choice",
+                instructions: g.instructions,
+                criteria: {
+                    ...Object.fromEntries(members.map((f) => [f.id, f.help ? `${f.label} — ${f.help}` : f.label])),
+                    ...(g.optional ? { none: "None of these." } : {}),
+                },
+            };
+        }
+    }
+    if (!Object.keys(questions).length) {
+        return [];
+    }
+    await emitEvent(run.id, page.id, "info", { code: "choosingFields" });
+    const decision = await decide({
+        state: runSummary(run, state),
+        questions,
+        call: { runId: run.id, stepId: page.id },
+        signal,
+        charge: (usd) => addLocalCost(run.id, page.id, usd),
+    });
+    const kept = new Set();
+    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);
+        }
+    }
+    const room = MAX_SHOWN_FIELDS - page.fields.filter((f) => !isDecidedField(f)).length;
+    return page.fields
+        .filter((f) => isDecidedField(f) && kept.has(f.id))
+        .slice(0, Math.max(0, room))
+        .map((f) => f.id);
+}
 async function drive(runId, signal) {
     await clearStaleAsk(runId);
     while (!signal.aborted) {
@@ -279,11 +461,59 @@ async function drive(runId, signal) {
             return;
         }
         const def = run.definition;
+        // A step's `ask` branches wait on a decision before the run goes on.
+        const deciding = run.state.deciding ? stepOf(def, run.state.deciding) : undefined;
+        if (deciding) {
+            const state = structuredClone(run.state);
+            try {
+                const cursor = await decideBranch(run, deciding, state, signal);
+                if (signal.aborted) {
+                    return;
+                }
+                await syncRunCost(runId);
+                await updateRun(runId, { state, cursor, status: cursor ? "running" : "done", error: null });
+            }
+            catch (err) {
+                if (signal.aborted) {
+                    return;
+                }
+                console.error(`[run ${runId} deciding ${deciding.id}]`, err);
+                const message = friendly(err);
+                await emitEvent(runId, deciding.id, "error", message);
+                await updateRun(runId, { status: "failed", error: message });
+                return;
+            }
+            continue;
+        }
         const step = stepOf(def, run.cursor);
         if (!step) {
             await updateRun(runId, { status: "done" });
             return;
         }
+        // A page whose fields a decision picks: picked once, as the run reaches it.
+        if (step.type === "page" && step.fields.some(isDecidedField) && !run.state.pages?.[step.id]) {
+            const state = structuredClone(run.state);
+            try {
+                const shown = await decidePageFields(run, step, state, signal);
+                if (signal.aborted) {
+                    return;
+                }
+                state.pages = { ...state.pages, [step.id]: { shown } };
+                await syncRunCost(runId);
+                await updateRun(runId, { state, error: null });
+            }
+            catch (err) {
+                if (signal.aborted) {
+                    return;
+                }
+                console.error(`[run ${runId} fields of ${step.id}]`, err);
+                const message = friendly(err);
+                await emitEvent(runId, step.id, "error", message);
+                await updateRun(runId, { status: "failed", error: message });
+                return;
+            }
+            continue;
+        }
         if (step.type === "result") {
             await updateRun(runId, { status: "done" });
             return;
@@ -312,7 +542,7 @@ async function drive(runId, signal) {
             state.outputs[step.id] = output;
             delete state.notes[step.id];
             delete state.redo?.[step.id];
-            const cursor = nextStepId(def, step.id, branchValues(state.values, state.outputs));
+            const cursor = await advance(run, step.id, state);
             await updateRun(runId, { state, cursor, status: cursor ? "running" : "done", error: null });
             await emitEvent(runId, step.id, "step_done", step.title);
         }
@@ -363,7 +593,7 @@ export async function submitPage(runId, stepId, input) {
     if (step?.type !== "page") {
         throw new RunConflict("Not a page");
     }
-    const { values, errors } = readPageInput(step, input);
+    const { values, errors } = readPageInput(step, input, await pageContext(run, step));
     // 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)) {
@@ -408,8 +638,13 @@ export async function submitPage(runId, stepId, input) {
             delete state.values[field.id];
         }
     }
+    // Later pages decide their fields again on what is answered now.
+    const at = run.definition.steps.indexOf(step);
+    for (const later of run.definition.steps.slice(at + 1)) {
+        delete state.pages?.[later.id];
+    }
     state.history.push(stepId);
-    const cursor = nextStepId(run.definition, stepId, branchValues(state.values, state.outputs));
+    const cursor = await advance(run, stepId, state);
     await updateRun(runId, { state, cursor, status: "running", error: null });
     kick(runId);
 }
@@ -427,7 +662,7 @@ export async function reviewStep(runId, stepId, action) {
             }
         }
         state.history.push(stepId);
-        const cursor = nextStepId(run.definition, stepId, branchValues(state.values, state.outputs));
+        const cursor = await advance(run, stepId, state);
         await updateRun(runId, { state, cursor, status: "running", error: null });
         kick(runId);
         return;
@@ -458,6 +693,8 @@ export async function goBack(runId) {
     if (!previous) {
         throw new RunConflict("Kein vorheriger Schritt.");
     }
+    // A decision that failed belongs to the step left behind.
+    delete state.deciding;
     await updateRun(runId, { state, cursor: previous, status: "waiting_input", error: null });
 }
 export async function retry(runId) {
@@ -578,6 +815,15 @@ export async function runView(run, brand) {
         step,
         values: run.state.values,
         prefill: step?.type === "page" ? prefillOf(step, run, closed) : {},
+        ...(step?.type === "page" ? viewContext(await pageContext(run, step)) : {}),
+        ...(run.mode === "test" && run.state.decisions
+            ? {
+                decisions: Object.fromEntries(Object.entries(run.state.decisions).map(([id, d]) => [
+                    id,
+                    { ...d, over: def.steps.find((s) => s.id === id)?.next ?? [] },
+                ])),
+            }
+            : {}),
         closed,
         outputs: Object.fromEntries(shownIds.map((id) => [id, run.state.outputs[id]]).filter(([, o]) => o)),
         shown,