@noetic-tools/core 5.5.0 → 5.7.0

package/dist/builders/control-flow-builders.d.ts

@@ -1,5 +1,5 @@
 import type { ContextData } from '@noetic-tools/context';
-import type { Context, SettleResult, Step, StepConditional, StepInParallelAll, StepInParallelRace, StepInParallelSettle } from '@noetic-tools/types';
+import type { Context, ExecuteStepFn, SettleResult, Step, StepConditional, StepInParallelAll, StepInParallelRace, StepInParallelSettle } from '@noetic-tools/types';
 /**
  * Creates a parallel execution step that races paths and returns the first result.
  *
@@ -65,14 +65,16 @@ export declare function inParallel<TContext = ContextData, I = unknown, O = unkn
  *
  * @public
  * @param opts.id - Unique step identifier used in traces and error messages.
- * @param opts.route - Routing function `(input, ctx) => Step | null`. Returns the next step
- *   to execute, or `null` to skip (pass input through as output). May be async.
+ * @param opts.route - Routing function `(input, ctx, run) => Step | null`. Returns the next step
+ *   to execute, or `null` to skip (pass input through as output). May be async. `run`
+ *   executes a step through the interpreter, for routes that must run one to choose.
  * @returns A `StepConditional` step.
  * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
  * @throws `NoeticConfigError` with code `MISSING_ROUTE_FUNCTION` if `route` is not provided.
  */
 export declare function conditional<TContext = ContextData, I = unknown, O = unknown>(opts: {
     id: string;
-    route: (input: I, ctx: Context<TContext>) => Step<TContext, I, O> | null | Promise<Step<TContext, I, O> | null>;
+    route: (input: I, ctx: Context<TContext>, run: ExecuteStepFn) => Step<TContext, I, O> | null | Promise<Step<TContext, I, O> | null>;
     _optimizable?: Step<TContext>[];
+    _rebuild?: (children: Step<TContext>[]) => StepConditional<TContext, I, O>;
 }): StepConditional<TContext, I, O>;

package/dist/builders/control-flow-builders.js

@@ -27,8 +27,9 @@ export function inParallel(opts) {
  *
  * @public
  * @param opts.id - Unique step identifier used in traces and error messages.
- * @param opts.route - Routing function `(input, ctx) => Step | null`. Returns the next step
- *   to execute, or `null` to skip (pass input through as output). May be async.
+ * @param opts.route - Routing function `(input, ctx, run) => Step | null`. Returns the next step
+ *   to execute, or `null` to skip (pass input through as output). May be async. `run`
+ *   executes a step through the interpreter, for routes that must run one to choose.
  * @returns A `StepConditional` step.
  * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
  * @throws `NoeticConfigError` with code `MISSING_ROUTE_FUNCTION` if `route` is not provided.

package/dist/builders/decide-builders.d.ts

@@ -0,0 +1,86 @@
+import type { AnsweredAll, CaseKeyOf, Context, ContextData, DecideQuestions, DecideStep, DecideView, Lazy, ProjectionPolicy, Step, StepConditional } from '@noetic-tools/types';
+/** @public Options for `decide()`. */
+export interface StepDecideOpts<TContext, Q extends DecideQuestions> {
+    id: string;
+    /** Decision model id. Falls back to `harness.config.decisionModel`. */
+    model?: Lazy<string, TContext>;
+    /** Shared framing for every question. */
+    instructions?: Lazy<string | undefined, TContext>;
+    questions: Q & NonEmpty<Q>;
+    /** Which part of the assembled view the model sees. Default `'full'`. */
+    view?: DecideView;
+    /**
+     * Typed state read from context layers, sent under one `context` state entry.
+     * Annotate the parameter (`(ctx: Context<MyContext>) => …`) to type `ctx.context`.
+     */
+    context?: (ctx: Context<TContext>) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** Budget for the decision's view. Defaults to `DECISION_PROJECTION`. */
+    projection?: ProjectionPolicy;
+    /** Runs averaged on the estimated path. Ignored on the native path. Default 1. */
+    samples?: number;
+    emit?: boolean | ((eventType: string, data: Record<string, unknown>) => boolean);
+}
+/** An empty question map is a type error, not just a build-time one. */
+type NonEmpty<Q> = keyof Q extends never ? {
+    'decide needs at least one question': never;
+} : unknown;
+/** @public The input a step takes. */
+export type StepInput<S> = S extends Step<infer _C, infer I, infer _O> ? I : never;
+/** @public The output a step produces. */
+export type StepOutput<S> = S extends Step<infer _C, infer _I, infer O> ? O : never;
+/** A step of any kind, as far as a case needs to be one. */
+type CaseStep = Pick<Step, 'kind' | 'id'>;
+/** Maps every key the switch does not route to onto `never`, so a misspelled case is a type error. */
+type OnlyKeys<Cases, Keys extends PropertyKey> = {
+    [P in Exclude<keyof Cases, Keys>]: never;
+};
+/**
+ * @public `routeSwitch` options that route by one question. `cases` needs exactly
+ * one step per outcome; refusals and low-confidence answers take `uncertain`.
+ */
+export interface RouteSwitchByKeyOpts<TContext, Q extends DecideQuestions, K extends keyof Q & string, Cases extends Record<CaseKeyOf<Q[K]>, CaseStep>, U extends CaseStep> {
+    id: string;
+    decide: DecideStep<TContext, unknown, Q>;
+    on: K;
+    cases: Cases & OnlyKeys<Cases, CaseKeyOf<Q[K]>>;
+    /** Below this confidence, take `uncertain`. */
+    minConfidence?: number;
+    /** Taken on refusal, or when confidence is below `minConfidence`. */
+    uncertain: U;
+}
+/** @public `routeSwitch` options that combine answers in a function; `default` catches the rest. */
+export interface RouteSwitchByFunctionOpts<TContext, Q extends DecideQuestions, C extends string, Cases extends Partial<Record<C, CaseStep>>, D extends CaseStep, U extends CaseStep> {
+    id: string;
+    decide: DecideStep<TContext, unknown, Q>;
+    /** Receives answers with refusals already handled. */
+    on: (answers: AnsweredAll<Q>) => C;
+    cases: Cases & OnlyKeys<Cases, C>;
+    default: D;
+    /** Taken when any answer is refused. Defaults to `default`. */
+    uncertain?: U;
+}
+/**
+ * Creates a step that asks a model typed questions and returns typed answers
+ * with probabilities. See spec 32.
+ *
+ * The question map comes first among the type parameters so it is always
+ * inferred: pass no type arguments, and get a typed `ctx.context` by annotating
+ * the selector — `context: (ctx: Context<MyContext>) => …`.
+ *
+ * @public
+ * @throws `NoeticConfigError` `EMPTY_STEP_ID`, `MISSING_MODEL` (empty eager model),
+ *   `INVALID_DECIDE_QUESTIONS`, or `INVALID_DECIDE_SAMPLES`.
+ */
+export declare function decide<const Q extends DecideQuestions, TContext = ContextData, I = unknown>(opts: StepDecideOpts<TContext, Q>): DecideStep<TContext, I, Q>;
+/**
+ * Creates a conditional step that runs a decide step and routes the original input to
+ * the case its answers pick. The output type is the union of every case's
+ * output. See spec 32.
+ *
+ * @public
+ * @throws `NoeticConfigError` `EMPTY_STEP_ID`, `UNKNOWN_ROUTE_QUESTION`,
+ *   `INCOMPLETE_ROUTE_CASES`, `INVALID_MIN_CONFIDENCE`, or `MISSING_UNCERTAIN_STEP`.
+ */
+export declare function routeSwitch<TContext, const Q extends DecideQuestions, const C extends string, const Cases extends Partial<Record<C, CaseStep>>, D extends CaseStep, U extends CaseStep = D>(opts: RouteSwitchByFunctionOpts<TContext, Q, C, Cases, D, U>): StepConditional<TContext, StepInput<Cases[keyof Cases] | D | U>, StepOutput<Cases[keyof Cases] | D | U>>;
+export declare function routeSwitch<TContext, const Q extends DecideQuestions, const K extends keyof Q & string, const Cases extends Record<CaseKeyOf<Q[K]>, CaseStep>, U extends CaseStep>(opts: RouteSwitchByKeyOpts<TContext, Q, K, Cases, U>): StepConditional<TContext, StepInput<Cases[keyof Cases] | U>, StepOutput<Cases[keyof Cases] | U>>;
+export {};

package/dist/builders/decide-builders.js

@@ -0,0 +1,230 @@
+import { DecideQuestionsSchema, frameworkCast, NoeticConfigError, routeOutcomes, } from '@noetic-tools/types';
+import { getDefaultRegistrar } from '../types/step-registrar.js';
+import { conditional } from './control-flow-builders.js';
+//#endregion
+//#region Public API
+/**
+ * Creates a step that asks a model typed questions and returns typed answers
+ * with probabilities. See spec 32.
+ *
+ * The question map comes first among the type parameters so it is always
+ * inferred: pass no type arguments, and get a typed `ctx.context` by annotating
+ * the selector — `context: (ctx: Context<MyContext>) => …`.
+ *
+ * @public
+ * @throws `NoeticConfigError` `EMPTY_STEP_ID`, `MISSING_MODEL` (empty eager model),
+ *   `INVALID_DECIDE_QUESTIONS`, or `INVALID_DECIDE_SAMPLES`.
+ */
+export function decide(opts) {
+    requireId('decide', opts.id);
+    if (typeof opts.model === 'string' && opts.model.trim() === '') {
+        throw new NoeticConfigError({
+            code: 'MISSING_MODEL',
+            message: 'decide() was given an empty model.',
+            hint: "Pass a model id, e.g. model: 'typesafe/jev-1.14', or omit it to use the harness `decisionModel`.",
+        });
+    }
+    const parsed = DecideQuestionsSchema.safeParse(opts.questions);
+    if (!parsed.success) {
+        throw new NoeticConfigError({
+            code: 'INVALID_DECIDE_QUESTIONS',
+            message: `decide(${JSON.stringify(opts.id)}) has invalid questions: ${parsed.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; ')}`,
+            hint: 'Give 1+ questions; booleans need instructions or criteria, choices 1–255 unique values, scores 2–10 unique levels.',
+        });
+    }
+    const samples = opts.samples ?? 1;
+    if (!Number.isInteger(samples) || samples < 1) {
+        throw new NoeticConfigError({
+            code: 'INVALID_DECIDE_SAMPLES',
+            message: `decide(${JSON.stringify(opts.id)}) has samples=${samples}; it must be a positive integer.`,
+            hint: 'Omit samples, or pass a whole number of runs to average, e.g. samples: 3.',
+        });
+    }
+    const built = {
+        ...opts,
+        kind: 'decide',
+        view: opts.view ?? 'full',
+        samples,
+    };
+    getDefaultRegistrar().register(built);
+    return built;
+}
+export function routeSwitch(opts) {
+    requireId('routeSwitch', opts.id);
+    return buildSwitch({
+        id: opts.id,
+        decide: opts.decide,
+        on: opts.on,
+        cases: opts.cases,
+        minConfidence: 'minConfidence' in opts ? opts.minConfidence : undefined,
+        uncertain: opts.uncertain,
+        default: 'default' in opts ? opts.default : undefined,
+    });
+}
+/**
+ * Builds the conditional. Its route closes over the plan, so `_rebuild` rebuilds it
+ * around new children for the optimizer, in the same order as `_optimizable`.
+ */
+function buildSwitch(plan) {
+    const keys = Object.keys(plan.cases).filter((k) => plan.cases[k] !== undefined);
+    const pick = typeof plan.on === 'function' ? byFunction(plan, plan.on) : byKey(plan, plan.on);
+    const children = [
+        plan.decide,
+        ...keys.map((k) => plan.cases[k]),
+        ...(plan.uncertain
+            ? [
+                plan.uncertain,
+            ]
+            : []),
+        ...(plan.default
+            ? [
+                plan.default,
+            ]
+            : []),
+    ];
+    return conditional({
+        id: plan.id,
+        route: async (input, ctx, run) => {
+            const answers = frameworkCast(await run(plan.decide, input, ctx));
+            const picked = pick(answers);
+            ctx.span.addEvent('route_switch', {
+                stepId: plan.id,
+                case: picked.label,
+            });
+            return picked.step;
+        },
+        _optimizable: frameworkCast(children),
+        _rebuild: (next) => {
+            let i = 1;
+            const take = () => frameworkCast(next[i++]);
+            return buildSwitch({
+                ...plan,
+                decide: frameworkCast(next[0]),
+                cases: Object.fromEntries(keys.map((k) => [
+                    k,
+                    take(),
+                ])),
+                uncertain: plan.uncertain ? take() : undefined,
+                default: plan.default ? take() : undefined,
+            });
+        },
+    });
+}
+function byKey(plan, on) {
+    const questions = plan.decide.questions;
+    const question = Object.hasOwn(questions, on) ? questions[on] : undefined;
+    if (!question) {
+        throw new NoeticConfigError({
+            code: 'UNKNOWN_ROUTE_QUESTION',
+            message: `routeSwitch(${JSON.stringify(plan.id)}) routes on '${on}', which its decide step does not ask.`,
+            hint: `Set \`on\` to one of: ${Object.keys(questions).join(', ')}.`,
+        });
+    }
+    const missing = routeOutcomes(question).filter((o) => !caseFor(plan, o));
+    if (missing.length > 0) {
+        throw new NoeticConfigError({
+            code: 'INCOMPLETE_ROUTE_CASES',
+            message: `routeSwitch(${JSON.stringify(plan.id)}) has no case for: ${missing.join(', ')}.`,
+            hint: `Give a case for every outcome of '${on}'.`,
+        });
+    }
+    const uncertain = requireUncertain(plan);
+    return (answers) => {
+        const answer = Object.hasOwn(answers, on) ? answers[on] : undefined;
+        if (!answer || answer.type === 'refusal') {
+            return uncertain;
+        }
+        if (plan.minConfidence !== undefined && confidenceOf(answer) < plan.minConfidence) {
+            return uncertain;
+        }
+        const key = caseKey(answer);
+        return {
+            step: caseFor(plan, key),
+            label: key,
+        };
+    };
+}
+function byFunction(plan, on) {
+    const fallback = {
+        step: frameworkCast(plan.default ?? null),
+        label: 'default',
+    };
+    const refused = plan.uncertain
+        ? {
+            step: frameworkCast(plan.uncertain),
+            label: 'uncertain',
+        }
+        : fallback;
+    return (answers) => {
+        if (Object.values(answers).some((a) => a.type === 'refusal')) {
+            return refused;
+        }
+        const key = on(frameworkCast(answers));
+        const step = caseFor(plan, key);
+        return step
+            ? {
+                step,
+                label: key,
+            }
+            : fallback;
+    };
+}
+/** Own keys only: a choice named `constructor` must not find `Object.prototype.constructor`. */
+function caseFor(plan, key) {
+    return Object.hasOwn(plan.cases, key)
+        ? frameworkCast(plan.cases[key] ?? null)
+        : null;
+}
+function caseKey(answer) {
+    switch (answer.type) {
+        case 'boolean':
+            return String(answer.value);
+        case 'choice':
+            return answer.value;
+        case 'score':
+            return answer.level;
+    }
+}
+/**
+ * Choice and score use the provider's `confidence`. A boolean has none, so it
+ * uses the probability of the side `value` picked — which respects the
+ * question's `threshold`, unlike distance from a coin flip.
+ */
+function confidenceOf(answer) {
+    if (answer.type !== 'boolean') {
+        return answer.confidence;
+    }
+    return answer.value ? answer.probability : 1 - answer.probability;
+}
+//#endregion
+//#region Helpers
+function requireId(builder, id) {
+    if (!id || id.trim() === '') {
+        throw new NoeticConfigError({
+            code: 'EMPTY_STEP_ID',
+            message: `${builder}() requires a non-empty id.`,
+            hint: `Pass a unique string as the id field, e.g. ${builder}({ id: "triage", ... }).`,
+        });
+    }
+}
+function requireUncertain(plan) {
+    if (plan.minConfidence !== undefined && (plan.minConfidence < 0 || plan.minConfidence > 1)) {
+        throw new NoeticConfigError({
+            code: 'INVALID_MIN_CONFIDENCE',
+            message: `routeSwitch(${JSON.stringify(plan.id)}) has minConfidence=${plan.minConfidence}; it must be in [0, 1].`,
+            hint: 'Pass a confidence between 0 and 1, e.g. minConfidence: 0.6.',
+        });
+    }
+    if (!plan.uncertain) {
+        throw new NoeticConfigError({
+            code: 'MISSING_UNCERTAIN_STEP',
+            message: `routeSwitch(${JSON.stringify(plan.id)}) has no uncertain step.`,
+            hint: 'Pass `uncertain`: the step to run when the model refuses or is not confident enough.',
+        });
+    }
+    return {
+        step: frameworkCast(plan.uncertain),
+        label: 'uncertain',
+    };
+}
+//#endregion

package/dist/builders/dynamic-workflow.js

@@ -31,6 +31,7 @@ A WorkflowNode is one of:
 - { "kind": "spawn", "id": "<unique>", "child": <WorkflowNode>, "timeout": <optional ms> } (run the child in an isolated sub-context)
 - { "kind": "withContext", "id": "<unique>", "child": <WorkflowNode>, "layers": ["<layer-name>", ...] } (run the child with named context layers; only emit if the task names layers that exist, since this planner provides no layer registry and unknown names resolve to NO layers)
 - { "kind": "schedule", "id": "<unique>", "step": <WorkflowNode>, "interval": <ms>, "onError": "continue"|"fail" } (re-runs the step forever on an interval and never returns — only emit for an explicitly daemon-style task)
+- { "kind": "routeSwitch", "id": "<unique>", "decide": { "kind": "decide", "id": "<unique>", "questions": { "<question-id>": { "type": "choice", "instructions": "<question>", "choices": ["<option>", ...] } } }, "on": "<question-id>", "cases": { "<option>": <WorkflowNode>, ... }, "uncertain": <WorkflowNode>, "minConfidence": <optional 0-1> } (a model decides, then the input goes to the matching case; a "boolean" question has cases "true" and "false"; a "score" question has "levels": ["<low>", ..., "<high>"] and routes by level; every outcome needs a case)
 - { "kind": "subflow", "id": "<unique>", "document": { "version": 1, "root": <WorkflowNode> } } (an inline sub-workflow run as one step; only emit the inline form — named refs require a registry this planner does not provide)
 - { "kind": "acp-agent", "id": "<unique>", "agent": "<registered agent id, e.g. claude-code>", "prompt": "<turn prompt>", "mode": "<optional session mode>", "model": "<optional>" }
 

package/dist/builders/workflow-hydrator.js

@@ -10,6 +10,7 @@ import { all, any } from '../until/combinators.js';
 import { until } from '../until/predicates.js';
 import { DetachedHandleImpl } from '../util/detached-handle.js';
 import { conditional, inParallel } from './control-flow-builders.js';
+import { decide, routeSwitch } from './decide-builders.js';
 import { schedule } from './every.js';
 import { loop } from './loop-builder.js';
 import { withContext } from './provide-builder.js';
@@ -207,7 +208,7 @@ function hydrateConditionalNode(node, ctx) {
     return conditional({
         id: node.id,
         route: (input) => {
-            const trimmed = input.trim().toLowerCase();
+            const trimmed = routeText(input).trim().toLowerCase();
             for (const r of hydratedRoutes) {
                 if (trimmed.includes(r.match.toLowerCase())) {
                     return r.target;
@@ -218,6 +219,40 @@ function hydrateConditionalNode(node, ctx) {
         _optimizable: frameworkCast(allTargets),
     });
 }
+function hydrateDecideNode(node, _ctx) {
+    if (node.kind !== 'decide') {
+        return frameworkCast(undefined);
+    }
+    return frameworkCast(decideFromNode(node));
+}
+function decideFromNode(node) {
+    return decide({
+        id: node.id,
+        model: node.model,
+        instructions: node.instructions,
+        questions: node.questions,
+        view: node.view,
+        samples: node.samples,
+    });
+}
+function hydrateRouteSwitchNode(node, ctx) {
+    if (node.kind !== 'routeSwitch') {
+        return frameworkCast(undefined);
+    }
+    const cases = {};
+    for (const [key, target] of Object.entries(node.cases)) {
+        cases[key] = hydrateNode(target, ctx);
+    }
+    // A JSON node's outcomes are only known at runtime; the builder checks them.
+    return frameworkCast(routeSwitch({
+        id: node.id,
+        decide: decideFromNode(node.decide),
+        on: node.on,
+        cases: frameworkCast(cases),
+        minConfidence: node.minConfidence,
+        uncertain: hydrateNode(node.uncertain, ctx),
+    }));
+}
 function hydrateInParallelNode(node, ctx) {
     if (node.kind !== 'inParallel') {
         return frameworkCast(undefined);
@@ -475,6 +510,8 @@ const NODE_HYDRATORS = {
     invokeTool: hydrateInvokeToolNode,
     runCode: hydrateRunCodeNode,
     conditional: hydrateConditionalNode,
+    decide: hydrateDecideNode,
+    routeSwitch: hydrateRouteSwitchNode,
     inParallel: hydrateInParallelNode,
     spawn: hydrateSpawnNode,
     withContext: hydrateWithContextNode,
@@ -504,15 +541,57 @@ function resolveTools(toolNames, registry) {
         return resolved;
     });
 }
+/** Paths may return objects (a `decide` node's answers): `concat` writes them as JSON, `first`/`last` pass them through. */
 function buildMerge(strategy) {
     if (strategy === 'first') {
         return (r) => r[0] ?? '';
     }
     if (strategy === 'concat') {
-        return (r) => r.join('\n');
+        return (r) => r.map(stringifyResult).join('\n');
     }
     return (r) => r[r.length - 1] ?? '';
 }
+/**
+ * The text a branch matches against. An object input — a `decide` node's
+ * answers, or their JSON once a sequence has stringified them — matches on its
+ * string values only: its keys and probability maps name every choice, so
+ * matching the JSON would hit every route.
+ */
+function routeText(input) {
+    const value = typeof input === 'string' ? parseJsonObject(input) : input;
+    if (typeof value === 'string') {
+        return value;
+    }
+    const values = [];
+    const walk = (value) => {
+        if (typeof value === 'string') {
+            values.push(value);
+            return;
+        }
+        if (typeof value !== 'object' || value === null) {
+            return;
+        }
+        for (const child of Object.values(value)) {
+            walk(child);
+        }
+    };
+    walk(value);
+    return values.join('\n');
+}
+/** The parsed object or array when `text` is one in JSON, else `text` itself. */
+function parseJsonObject(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
+        return text;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return typeof parsed === 'object' && parsed !== null ? parsed : text;
+    }
+    catch {
+        return text;
+    }
+}
 function stringifyResult(value) {
     if (typeof value === 'string') {
         return value;

package/dist/conditions/conditions.d.ts

@@ -100,14 +100,20 @@ export declare function anyCondition<I>(...conditions: Condition<I>[]): Conditio
  */
 export declare function allCondition<I>(...conditions: Condition<I>[]): Condition<I>;
 /**
- * Creates a condition that uses an LLM to classify the input as true or false.
+ * Creates a condition that asks a model a yes/no question about the input — a
+ * one-question `decide`. Works with decision models natively and with chat
+ * models through estimated probabilities.
  *
  * @public
- * @param opts - Configuration with model identifier and classification prompt.
- * @returns A `Condition` that delegates boolean classification to the model.
+ * @param opts.model - Decision or chat model id.
+ * @param opts.prompt - The yes/no question.
+ * @param opts.threshold - Probability of yes at or above which the condition holds. Default 0.5.
+ * @returns A `Condition` that is true when the model answers yes. A refusal counts as no.
+ * @throws `NoeticError` `model_parse_error` when the response is not a boolean answer.
  */
 export declare function aiCondition<I>(opts: {
     model: string;
     prompt: string;
+    threshold?: number;
 }): Condition<I>;
 export {};

package/dist/conditions/conditions.js

@@ -1,5 +1,5 @@
 import { storageGetMany } from '@noetic-tools/context';
-import { createMessage, extractAssistantText, trackUsage } from '@noetic-tools/types';
+import { DecideOutputError, isNoeticError, NoeticErrorImpl, trackUsage } from '@noetic-tools/types';
 import { z } from 'zod';
 import { cosineSimilarity } from './cosine-similarity.js';
 //#endregion
@@ -234,41 +234,100 @@ export function allCondition(...conditions) {
 }
 //#endregion
 //#region aiCondition
-const AiConditionResponseSchema = z.object({
-    answer: z.boolean(),
-});
 /**
- * Creates a condition that uses an LLM to classify the input as true or false.
+ * Creates a condition that asks a model a yes/no question about the input — a
+ * one-question `decide`. Works with decision models natively and with chat
+ * models through estimated probabilities.
  *
  * @public
- * @param opts - Configuration with model identifier and classification prompt.
- * @returns A `Condition` that delegates boolean classification to the model.
+ * @param opts.model - Decision or chat model id.
+ * @param opts.prompt - The yes/no question.
+ * @param opts.threshold - Probability of yes at or above which the condition holds. Default 0.5.
+ * @returns A `Condition` that is true when the model answers yes. A refusal counts as no.
+ * @throws `NoeticError` `model_parse_error` when the response is not a boolean answer.
  */
 export function aiCondition(opts) {
     return async (input, ctx) => {
-        const text = serializeInput(input);
-        const systemPrompt = `You are a boolean classifier. Given the user's input, answer the following question with JSON: {"answer": true} or {"answer": false}.\n\nQuestion: ${opts.prompt}`;
-        const items = [
-            createMessage(systemPrompt, 'developer'),
-            createMessage(text, 'user'),
-        ];
-        const response = await ctx.harness.callModel({
+        const response = await askDecide(ctx, {
             model: opts.model,
-            items,
-            params: {
-                temperature: 0,
+            state: [
+                {
+                    type: 'text',
+                    name: 'input',
+                    text: serializeInput(input),
+                },
+            ],
+            questions: {
+                answer: {
+                    type: 'boolean',
+                    instructions: opts.prompt,
+                    threshold: opts.threshold,
+                },
             },
         });
-        trackUsage(ctx, response);
-        const responseText = extractAssistantText(response.items);
-        try {
-            const parsed = JSON.parse(responseText);
-            const validated = AiConditionResponseSchema.parse(parsed);
-            return validated.answer;
-        }
-        catch {
+        trackUsage(ctx, {
+            items: [],
+            usage: response.usage,
+            cost: response.cost,
+        });
+        const answer = response.answers.answer;
+        if (answer?.type === 'refusal') {
             return false;
         }
+        const parsed = AiConditionAnswerSchema.safeParse(answer);
+        if (!parsed.success) {
+            throw new NoeticErrorImpl({
+                kind: 'model_parse_error',
+                stepId: 'aiCondition',
+                raw: JSON.stringify(answer),
+                schema: AiConditionAnswerSchema,
+                zodError: parsed.error,
+            });
+        }
+        return parsed.data.value;
     };
 }
+async function askDecide(ctx, request) {
+    try {
+        return await ctx.harness.decide(request);
+    }
+    catch (e) {
+        if (isNoeticError(e)) {
+            throw e;
+        }
+        if (ctx.aborted) {
+            throw new NoeticErrorImpl({
+                kind: 'cancelled',
+                reason: ctx.abortReason ?? 'context aborted',
+            });
+        }
+        if (e instanceof DecideOutputError) {
+            if (e.usage) {
+                trackUsage(ctx, {
+                    items: [],
+                    usage: e.usage,
+                    cost: e.cost,
+                });
+            }
+            throw new NoeticErrorImpl({
+                kind: 'model_parse_error',
+                stepId: 'aiCondition',
+                raw: e.raw,
+                schema: e.schema,
+                zodError: e.zodError,
+            });
+        }
+        throw new NoeticErrorImpl({
+            kind: 'step_failed',
+            stepId: 'aiCondition',
+            cause: e instanceof Error ? e : new Error(String(e)),
+            retriesExhausted: false,
+        });
+    }
+}
+const AiConditionAnswerSchema = z.object({
+    type: z.literal('boolean'),
+    value: z.boolean(),
+    probability: z.number().min(0).max(1),
+});
 //#endregion