toolnexus 0.20.0 → 0.21.0

package/dist/client.js

@@ -254,8 +254,8 @@ export class Client {
     }
     /** §8 Gap 5. OpenAI-style body; omits tools/tool_choice when the tool list is empty. Key order
      * matches the pre-change body so a no-options call is byte-identical. */
-    openaiBody(messages, tools, stream) {
-        const b = { model: this.opts.model, messages: toOpenAIWire(messages, this.wireOpts()) };
+    openaiBody(messages, tools, stream, model = this.opts.model) {
+        const b = { model, messages: toOpenAIWire(messages, this.wireOpts()) };
         if (tools.length) {
             b.tools = tools;
             b.tool_choice = "auto";
@@ -267,8 +267,8 @@ export class Client {
         return this.finalizeBody(b);
     }
     /** §8 Gap 5. Anthropic-style body; omits tools when the tool list is empty. */
-    anthropicBody(system, messages, tools, stream) {
-        const b = { model: this.opts.model, max_tokens: 4096, system, messages: toAnthropicWire(messages, this.wireOpts()) };
+    anthropicBody(system, messages, tools, stream, model = this.opts.model) {
+        const b = { model, max_tokens: 4096, system, messages: toAnthropicWire(messages, this.wireOpts()) };
         if (tools.length)
             b.tools = tools;
         if (stream)
@@ -290,13 +290,13 @@ export class Client {
     }
     /** Emit the terminal `run` metric event and build the RunResult. `exhausted` marks a
      * maxTurns loop exit — with no final text that is a LOUD "incomplete", never "done" (§7D). */
-    endRun(runStart, text, messages, toolCalls, turns, usage, exhausted = false) {
-        this.emit({ event: "run", model: this.opts.model, turns, toolCalls: toolCalls.length, totalTokens: usage.totalTokens, ms: Date.now() - runStart });
-        return this.result(text, messages, toolCalls, turns, usage, exhausted);
+    endRun(runStart, model, text, messages, toolCalls, turns, usage, exhausted = false) {
+        this.emit({ event: "run", model, turns, toolCalls: toolCalls.length, totalTokens: usage.totalTokens, ms: Date.now() - runStart });
+        return this.result(model, text, messages, toolCalls, turns, usage, exhausted);
     }
     /** Emit a `run` error metric event (once, on a thrown run). */
-    emitRunError(runStart, toolCalls, turns, usage, e) {
-        this.emit({ event: "run", model: this.opts.model, turns, toolCalls: toolCalls.length, totalTokens: usage.totalTokens, ms: Date.now() - runStart, error: e instanceof Error ? e.message : String(e) });
+    emitRunError(runStart, model, toolCalls, turns, usage, e) {
+        this.emit({ event: "run", model, turns, toolCalls: toolCalls.length, totalTokens: usage.totalTokens, ms: Date.now() - runStart, error: e instanceof Error ? e.message : String(e) });
     }
     /**
      * Run the loop. `ctx` — and `ctx.toolkit` inside it — are OPTIONAL: an absent toolkit is a
@@ -334,14 +334,17 @@ export class Client {
         if (sys && !hasSystemMessage(messages))
             messages = [{ role: "system", content: sys }, ...messages];
         let tools = declared;
+        let turnModel = this.opts.model;
         if (this.opts.hooks?.beforeLLM) {
             const ov = await this.opts.hooks.beforeLLM({ messages, tools, model: this.opts.model, turn: 0 });
             if (ov?.messages)
                 messages = ov.messages;
             if (ov?.tools)
                 tools = ov.tools;
+            if (ov?.model)
+                turnModel = ov.model;
         }
-        const body = { model: this.opts.model, messages };
+        const body = { model: turnModel, messages };
         if (tools.length)
             body.tools = tools;
         if (req.toolChoice !== undefined)
@@ -354,9 +357,9 @@ export class Client {
                 method: "POST",
                 headers: { "content-type": "application/json", authorization: `Bearer ${key}`, ...this.opts.headers },
                 body: JSON.stringify(this.finalizeBody(body)),
-            }, signal, "openai");
+            }, signal, "openai", turnModel);
             if (this.opts.hooks?.afterLLM)
-                await this.opts.hooks.afterLLM({ response: data, model: this.opts.model, turn: 0 });
+                await this.opts.hooks.afterLLM({ response: data, model: turnModel, turn: 0 });
             const usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
             addUsage(usage, data.usage, "openai");
             const choice = data.choices?.[0];
@@ -370,7 +373,7 @@ export class Client {
                 toolCalls,
                 finishReason: choice?.finish_reason ?? finishReasonFor(toolCalls.length > 0),
                 usage,
-                model: this.opts.model,
+                model: turnModel,
                 raw: data,
             };
         }
@@ -390,15 +393,18 @@ export class Client {
             ...(req.toolkit ? req.toolkit.toAnthropic() : []),
             ...openAIToolsToAnthropic(req.tools),
         ];
+        let turnModel = this.opts.model;
         if (this.opts.hooks?.beforeLLM) {
             const ov = await this.opts.hooks.beforeLLM({ messages, tools, model: this.opts.model, turn: 0 });
             if (ov?.messages)
                 messages = ov.messages;
             if (ov?.tools)
                 tools = ov.tools;
+            if (ov?.model)
+                turnModel = ov.model;
         }
         const body = {
-            model: this.opts.model,
+            model: turnModel,
             max_tokens: req.maxTokens && req.maxTokens > 0 ? req.maxTokens : 4096,
             messages,
         };
@@ -420,9 +426,9 @@ export class Client {
                     ...this.opts.headers,
                 },
                 body: JSON.stringify(this.finalizeBody(body)),
-            }, signal, "anthropic");
+            }, signal, "anthropic", turnModel);
             if (this.opts.hooks?.afterLLM)
-                await this.opts.hooks.afterLLM({ response: data, model: this.opts.model, turn: 0 });
+                await this.opts.hooks.afterLLM({ response: data, model: turnModel, turn: 0 });
             const usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
             addUsage(usage, data.usage, "anthropic");
             const text = [];
@@ -443,7 +449,7 @@ export class Client {
                 toolCalls,
                 finishReason: finishReasonFor(toolCalls.length > 0, data.stop_reason),
                 usage,
-                model: this.opts.model,
+                model: turnModel,
                 raw: data,
             };
         }
@@ -618,7 +624,7 @@ export class Client {
         this.emit({ event: "tool", tool: name, source, isError: req ? false : result.isError, ms: Date.now() - t0, ...(req ? { pending: true } : {}) });
     }
     /** One non-streaming LLM call, with an `llm` metric event (ok/error + per-call tokens + ms). */
-    async llmCallJson(url, init, signal, style) {
+    async llmCallJson(url, init, signal, style, model) {
         const t0 = Date.now();
         try {
             const res = await this.llmFetch(url, init, signal);
@@ -626,11 +632,11 @@ export class Client {
                 throw await llmHttpError(res);
             const data = await res.json();
             const tok = perCall(data.usage, style);
-            this.emit({ event: "llm", model: this.opts.model, status: "ok", ms: Date.now() - t0, promptTokens: tok.prompt, completionTokens: tok.completion });
+            this.emit({ event: "llm", model, status: "ok", ms: Date.now() - t0, promptTokens: tok.prompt, completionTokens: tok.completion });
             return data;
         }
         catch (e) {
-            this.emit({ event: "llm", model: this.opts.model, status: "error", ms: Date.now() - t0, promptTokens: 0, completionTokens: 0 });
+            this.emit({ event: "llm", model, status: "error", ms: Date.now() - t0, promptTokens: 0, completionTokens: 0 });
             throw e;
         }
     }
@@ -687,29 +693,35 @@ export class Client {
         const toolCalls = [];
         const usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
         let turns = 0;
+        // The model of the last call this run made (a beforeLLM override when one applied) — §8.
+        let lastModel = this.opts.model;
         try {
             for (let turn = 0; turn < (this.opts.maxTurns ?? 10); turn++) {
                 turns++;
+                let turnModel = this.opts.model;
                 if (this.opts.hooks?.beforeLLM) {
                     const ov = await this.opts.hooks.beforeLLM({ messages, tools, model: this.opts.model, turn });
                     if (ov?.messages)
                         messages = ov.messages;
                     if (ov?.tools)
                         tools = ov.tools;
+                    if (ov?.model)
+                        turnModel = ov.model;
                 }
+                lastModel = turnModel;
                 const data = await this.llmCallJson(`${this.opts.baseUrl.replace(/\/$/, "")}/chat/completions`, {
                     method: "POST",
                     headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json", ...this.opts.headers },
-                    body: JSON.stringify(this.openaiBody(messages, tools, false)),
-                }, signal, "openai");
+                    body: JSON.stringify(this.openaiBody(messages, tools, false, turnModel)),
+                }, signal, "openai", turnModel);
                 addUsage(usage, data.usage, "openai");
                 if (this.opts.hooks?.afterLLM)
-                    await this.opts.hooks.afterLLM({ response: data, model: this.opts.model, turn });
+                    await this.opts.hooks.afterLLM({ response: data, model: turnModel, turn });
                 const msg = data.choices[0].message;
                 messages.push(msg);
                 const calls = msg.tool_calls ?? [];
                 if (calls.length === 0)
-                    return this.endRun(runStart, msg.content ?? "", messages, toolCalls, turns, usage);
+                    return this.endRun(runStart, lastModel, msg.content ?? "", messages, toolCalls, turns, usage);
                 // execute all tool calls in this turn concurrently (true parallel tool calling)
                 const settled = await Promise.all(calls.map(async (call) => {
                     let { args, result } = await this.runTool(toolkit, call.function.name, safeJson(call.function.arguments), call.id, turn);
@@ -729,27 +741,27 @@ export class Client {
                     toolCalls.push({ name: s.call.function.name, args: s.args, output: s.result.output, isError: s.result.isError, metadata: s.result.metadata });
                     messages.push(toolMessage(s.call.id, s.call.function.name, s.result));
                     if (s.halted)
-                        return this.pendingRun(runStart, s.halted, messages, toolCalls, turns, usage);
+                        return this.pendingRun(runStart, lastModel, s.halted, messages, toolCalls, turns, usage);
                 }
             }
-            return this.endRun(runStart, lastText(messages), messages, toolCalls, turns, usage, true);
+            return this.endRun(runStart, lastModel, lastText(messages), messages, toolCalls, turns, usage, true);
         }
         catch (e) {
-            this.emitRunError(runStart, toolCalls, turns, usage, e);
+            this.emitRunError(runStart, lastModel, toolCalls, turns, usage, e);
             throw e;
         }
     }
-    result(text, messages, toolCalls, turns, usage, exhausted = false) {
+    result(model, text, messages, toolCalls, turns, usage, exhausted = false) {
         const incomplete = exhausted && text === "";
-        const r = { text, messages, toolCalls, toolCallCount: toolCalls.length, turns, usage, model: this.opts.model, status: incomplete ? "incomplete" : "done" };
+        const r = { text, messages, toolCalls, toolCallCount: toolCalls.length, turns, usage, model, status: incomplete ? "incomplete" : "done" };
         if (incomplete)
             r.limit = "maxTurns";
         return r;
     }
     /** §10: a run halted because a tool suspended and no `waitFor` was configured. */
-    pendingRun(runStart, request, messages, toolCalls, turns, usage) {
-        this.emit({ event: "run", model: this.opts.model, turns, toolCalls: toolCalls.length, totalTokens: usage.totalTokens, ms: Date.now() - runStart });
-        return { text: request.prompt, messages, toolCalls, toolCallCount: toolCalls.length, turns, usage, model: this.opts.model, status: "pending", pending: request };
+    pendingRun(runStart, model, request, messages, toolCalls, turns, usage) {
+        this.emit({ event: "run", model, turns, toolCalls: toolCalls.length, totalTokens: usage.totalTokens, ms: Date.now() - runStart });
+        return { text: request.prompt, messages, toolCalls, toolCallCount: toolCalls.length, turns, usage, model, status: "pending", pending: request };
     }
     /**
      * §10: resolve a suspended tool result. Calls `waitFor(request)`, and on `ok` re-executes the
@@ -788,16 +800,22 @@ export class Client {
         const toolCalls = [];
         const usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
         let turns = 0;
+        // The model of the last call this run made (a beforeLLM override when one applied) — §8.
+        let lastModel = this.opts.model;
         try {
             for (let turn = 0; turn < (this.opts.maxTurns ?? 10); turn++) {
                 turns++;
+                let turnModel = this.opts.model;
                 if (this.opts.hooks?.beforeLLM) {
                     const ov = await this.opts.hooks.beforeLLM({ messages, tools, model: this.opts.model, turn });
                     if (ov?.messages)
                         messages = ov.messages;
                     if (ov?.tools)
                         tools = ov.tools;
+                    if (ov?.model)
+                        turnModel = ov.model;
                 }
+                lastModel = turnModel;
                 const data = await this.llmCallJson(endpoint, {
                     method: "POST",
                     headers: {
@@ -806,16 +824,16 @@ export class Client {
                         "Content-Type": "application/json",
                         ...this.opts.headers,
                     },
-                    body: JSON.stringify(this.anthropicBody(system, messages, tools, false)),
-                }, signal, "anthropic");
+                    body: JSON.stringify(this.anthropicBody(system, messages, tools, false, turnModel)),
+                }, signal, "anthropic", turnModel);
                 addUsage(usage, data.usage, "anthropic");
                 if (this.opts.hooks?.afterLLM)
-                    await this.opts.hooks.afterLLM({ response: data, model: this.opts.model, turn });
+                    await this.opts.hooks.afterLLM({ response: data, model: turnModel, turn });
                 messages.push({ role: "assistant", content: data.content });
                 const uses = (data.content ?? []).filter((b) => b.type === "tool_use");
                 if (uses.length === 0) {
                     const text = (data.content ?? []).filter((b) => b.type === "text").map((b) => b.text).join("");
-                    return this.endRun(runStart, text, messages, toolCalls, turns, usage);
+                    return this.endRun(runStart, lastModel, text, messages, toolCalls, turns, usage);
                 }
                 // execute all tool_use blocks in this turn concurrently (true parallel tool calling)
                 const settled = await Promise.all(uses.map(async (use) => {
@@ -844,12 +862,12 @@ export class Client {
                 }
                 messages.push({ role: "user", content });
                 if (halted)
-                    return this.pendingRun(runStart, halted, messages, toolCalls, turns, usage);
+                    return this.pendingRun(runStart, lastModel, halted, messages, toolCalls, turns, usage);
             }
-            return this.endRun(runStart, "", messages, toolCalls, turns, usage, true);
+            return this.endRun(runStart, lastModel, "", messages, toolCalls, turns, usage, true);
         }
         catch (e) {
-            this.emitRunError(runStart, toolCalls, turns, usage, e);
+            this.emitRunError(runStart, lastModel, toolCalls, turns, usage, e);
             throw e;
         }
     }
@@ -868,16 +886,22 @@ export class Client {
         const toolCalls = [];
         const usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
         let turns = 0;
+        // The model of the last call this run made (a beforeLLM override when one applied) — §8.
+        let lastModel = this.opts.model;
         try {
             for (let turn = 0; turn < (this.opts.maxTurns ?? 10); turn++) {
                 turns++;
+                let turnModel = this.opts.model;
                 if (this.opts.hooks?.beforeLLM) {
                     const ov = await this.opts.hooks.beforeLLM({ messages, tools, model: this.opts.model, turn });
                     if (ov?.messages)
                         messages = ov.messages;
                     if (ov?.tools)
                         tools = ov.tools;
+                    if (ov?.model)
+                        turnModel = ov.model;
                 }
+                lastModel = turnModel;
                 const t0 = Date.now();
                 const beforeP = usage.promptTokens, beforeC = usage.completionTokens;
                 let content = "";
@@ -886,7 +910,7 @@ export class Client {
                     const res = await this.llmFetch(`${this.opts.baseUrl.replace(/\/$/, "")}/chat/completions`, {
                         method: "POST",
                         headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json", ...this.opts.headers },
-                        body: JSON.stringify(this.openaiBody(messages, tools, true)),
+                        body: JSON.stringify(this.openaiBody(messages, tools, true, turnModel)),
                     }, signal);
                     if (!res.ok || !res.body)
                         throw await llmHttpError(res);
@@ -918,17 +942,17 @@ export class Client {
                     }
                 }
                 catch (e) {
-                    this.emit({ event: "llm", model: this.opts.model, status: "error", ms: Date.now() - t0, promptTokens: 0, completionTokens: 0 });
+                    this.emit({ event: "llm", model: turnModel, status: "error", ms: Date.now() - t0, promptTokens: 0, completionTokens: 0 });
                     throw e;
                 }
-                this.emit({ event: "llm", model: this.opts.model, status: "ok", ms: Date.now() - t0, promptTokens: usage.promptTokens - beforeP, completionTokens: usage.completionTokens - beforeC });
+                this.emit({ event: "llm", model: turnModel, status: "ok", ms: Date.now() - t0, promptTokens: usage.promptTokens - beforeP, completionTokens: usage.completionTokens - beforeC });
                 if (this.opts.hooks?.afterLLM)
-                    await this.opts.hooks.afterLLM({ response: { streamed: true, usage }, model: this.opts.model, turn });
+                    await this.opts.hooks.afterLLM({ response: { streamed: true, usage }, model: turnModel, turn });
                 const calls = [...acc.values()];
                 if (calls.length === 0) {
                     messages.push({ role: "assistant", content });
                     yield { type: "usage", usage };
-                    yield { type: "done", result: this.endRun(runStart, content, messages, toolCalls, turns, usage) };
+                    yield { type: "done", result: this.endRun(runStart, lastModel, content, messages, toolCalls, turns, usage) };
                     return;
                 }
                 messages.push({ role: "assistant", content: content || null, tool_calls: calls.map((c) => ({ id: c.id, type: "function", function: { name: c.name, arguments: c.args } })) });
@@ -946,7 +970,7 @@ export class Client {
                         if (r.halted) {
                             toolCalls.push({ name: c.name, args, output: result.output, isError: result.isError, metadata: result.metadata });
                             messages.push(toolMessage(c.id, c.name, result));
-                            yield { type: "done", result: this.pendingRun(runStart, r.halted, messages, toolCalls, turns, usage) };
+                            yield { type: "done", result: this.pendingRun(runStart, lastModel, r.halted, messages, toolCalls, turns, usage) };
                             return;
                         }
                     }
@@ -955,10 +979,10 @@ export class Client {
                     yield { type: "tool_result", id: c.id, name: c.name, output: result.output, isError: result.isError };
                 }
             }
-            yield { type: "done", result: this.endRun(runStart, lastText(messages), messages, toolCalls, turns, usage, true) };
+            yield { type: "done", result: this.endRun(runStart, lastModel, lastText(messages), messages, toolCalls, turns, usage, true) };
         }
         catch (e) {
-            this.emitRunError(runStart, toolCalls, turns, usage, e);
+            this.emitRunError(runStart, lastModel, toolCalls, turns, usage, e);
             throw e;
         }
     }
@@ -974,16 +998,22 @@ export class Client {
         const toolCalls = [];
         const usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
         let turns = 0;
+        // The model of the last call this run made (a beforeLLM override when one applied) — §8.
+        let lastModel = this.opts.model;
         try {
             for (let turn = 0; turn < (this.opts.maxTurns ?? 10); turn++) {
                 turns++;
+                let turnModel = this.opts.model;
                 if (this.opts.hooks?.beforeLLM) {
                     const ov = await this.opts.hooks.beforeLLM({ messages, tools, model: this.opts.model, turn });
                     if (ov?.messages)
                         messages = ov.messages;
                     if (ov?.tools)
                         tools = ov.tools;
+                    if (ov?.model)
+                        turnModel = ov.model;
                 }
+                lastModel = turnModel;
                 const t0 = Date.now();
                 const beforeP = usage.promptTokens, beforeC = usage.completionTokens;
                 const blocks = new Map();
@@ -992,7 +1022,7 @@ export class Client {
                     const res = await this.llmFetch(endpoint, {
                         method: "POST",
                         headers: { "x-api-key": key, "anthropic-version": "2023-06-01", "Content-Type": "application/json", ...this.opts.headers },
-                        body: JSON.stringify(this.anthropicBody(system, messages, tools, true)),
+                        body: JSON.stringify(this.anthropicBody(system, messages, tools, true, turnModel)),
                     }, signal);
                     if (!res.ok || !res.body)
                         throw await llmHttpError(res);
@@ -1022,19 +1052,19 @@ export class Client {
                     }
                 }
                 catch (e) {
-                    this.emit({ event: "llm", model: this.opts.model, status: "error", ms: Date.now() - t0, promptTokens: 0, completionTokens: 0 });
+                    this.emit({ event: "llm", model: turnModel, status: "error", ms: Date.now() - t0, promptTokens: 0, completionTokens: 0 });
                     throw e;
                 }
-                this.emit({ event: "llm", model: this.opts.model, status: "ok", ms: Date.now() - t0, promptTokens: usage.promptTokens - beforeP, completionTokens: usage.completionTokens - beforeC });
+                this.emit({ event: "llm", model: turnModel, status: "ok", ms: Date.now() - t0, promptTokens: usage.promptTokens - beforeP, completionTokens: usage.completionTokens - beforeC });
                 if (this.opts.hooks?.afterLLM)
-                    await this.opts.hooks.afterLLM({ response: { streamed: true, usage }, model: this.opts.model, turn });
+                    await this.opts.hooks.afterLLM({ response: { streamed: true, usage }, model: turnModel, turn });
                 const content = [...blocks.values()].map((b) => b.type === "tool_use" ? { type: "tool_use", id: b.id, name: b.name, input: safeJson(b.json || "{}") } : { type: "text", text: b.text });
                 messages.push({ role: "assistant", content });
                 const uses = content.filter((b) => b.type === "tool_use");
                 if (stopReason !== "tool_use" || uses.length === 0) {
                     const text = content.filter((b) => b.type === "text").map((b) => b.text).join("");
                     yield { type: "usage", usage };
-                    yield { type: "done", result: this.endRun(runStart, text, messages, toolCalls, turns, usage) };
+                    yield { type: "done", result: this.endRun(runStart, lastModel, text, messages, toolCalls, turns, usage) };
                     return;
                 }
                 for (const u of uses)
@@ -1053,7 +1083,7 @@ export class Client {
                             toolCalls.push({ name: u.name, args, output: result.output, isError: result.isError, metadata: result.metadata });
                             results.push(toolResultBlock(u.id, result));
                             messages.push({ role: "user", content: results });
-                            yield { type: "done", result: this.pendingRun(runStart, r.halted, messages, toolCalls, turns, usage) };
+                            yield { type: "done", result: this.pendingRun(runStart, lastModel, r.halted, messages, toolCalls, turns, usage) };
                             return;
                         }
                     }
@@ -1063,10 +1093,10 @@ export class Client {
                 }
                 messages.push({ role: "user", content: results });
             }
-            yield { type: "done", result: this.endRun(runStart, "", messages, toolCalls, turns, usage, true) };
+            yield { type: "done", result: this.endRun(runStart, lastModel, "", messages, toolCalls, turns, usage, true) };
         }
         catch (e) {
-            this.emitRunError(runStart, toolCalls, turns, usage, e);
+            this.emitRunError(runStart, lastModel, toolCalls, turns, usage, e);
             throw e;
         }
     }

package/dist/index.d.ts

@@ -16,3 +16,6 @@ export * from "./toolkit.js";
 export * from "./client.js";
 export * from "./classifier.js";
 export * as agents from "./agents/index.js";
+export * as judge from "./judge.js";
+export * from "./batteries.js";
+export { State, context, questionMap, ask, gate, decide, applyGate, applyPolicy, answersOf, staticClassifier, Tape, DEFAULT_BANDS, type NamedQuestion, type Band, type Bands, type Answers, type Rule, type GateOutcome, type Policy, } from "./judge.js";

package/dist/index.js

@@ -16,3 +16,9 @@ export * from "./toolkit.js";
 export * from "./client.js";
 export * from "./classifier.js";
 export * as agents from "./agents/index.js";
+// Simple judgments (§8B, add-judge-adapters). `judge.noul/choice/score` are the NAMED builders
+// (the bare `noul/choice/score` above stay the §8B wire builders); the rest is also top-level.
+export * as judge from "./judge.js";
+// Judge batteries (§8B "Batteries", add-judge-batteries): eight `*Classifier` values + latestUserText.
+export * from "./batteries.js";
+export { State, context, questionMap, ask, gate, decide, applyGate, applyPolicy, answersOf, staticClassifier, Tape, DEFAULT_BANDS, } from "./judge.js";

package/dist/judge.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Simple judgments (SPEC.md §8B "Simple judgments — ask / gate", change `add-judge-adapters`).
+ * A thin layer over any `Classifier`: named question builders, a role-carrying `State`,
+ * `ask` (answers by name with bands) and `gate` / `Policy` (rules that escalate instead of
+ * deciding when unsure). The wire is unchanged — the builders produce exactly the §8B
+ * `evaluate(state, questions)` inputs.
+ *
+ * A gate never authorises; it only declines to decide.
+ */
+import { Classifier, Decision, type DecisionAnswer, type NoulCriteria, type Question, type RecordedDecision } from "./classifier.js";
+import type { Request } from "./types.js";
+/** One named question of an ordered question list. */
+export interface NamedQuestion {
+    name: string;
+    question: Question;
+}
+/** `noul` question with a name. Name the state field it judges in `instructions`. */
+export declare function noul(name: string, instructions: string, criteria?: NoulCriteria): NamedQuestion;
+/** `choice` question with a name; `options` maps option -> what picking it MEANS. */
+export declare function choice(name: string, instructions: string, options: Record<string, string>): NamedQuestion;
+/** `score` question with a name; `levels` is the ordered rubric. */
+export declare function score(name: string, instructions: string, levels: string[]): NamedQuestion;
+/** Ordered list -> the §8B questions map. A duplicate name is an error naming it. */
+export declare function questionMap(questions: readonly NamedQuestion[]): Record<string, Question>;
+/** `role` next to the data's fields; a non-object value goes under `data`. */
+export declare function State(role: string, data: unknown): Record<string, unknown>;
+/** Sugar: `{context, message, ...extra}`. */
+export declare function context(ctx: string, message: string, extra?: Record<string, unknown>): Record<string, unknown>;
+export type Band = "yes" | "no" | "uncertain";
+export interface Bands {
+    low: number;
+    high: number;
+}
+/** Default cut-points; exclusive on the confident side. */
+export declare const DEFAULT_BANDS: Readonly<Bands>;
+/** One answer from `ask`: the §8B answer plus `band` (noul) or `sure` (choice/score). */
+export type Answer = DecisionAnswer & {
+    /** noul only. */
+    band?: Band;
+    /** choice / score only. */
+    sure?: boolean;
+    /** The one number: noul probability, score value, or choice confidence. */
+    value(): number;
+    /** The picked option of a choice answer ("" otherwise). JS keeps §8B's `choice` string FIELD on a
+     * choice answer (a method of the same name would shadow it), so this is `pick()`. */
+    pick(): string;
+};
+export type Answers = Record<string, Answer>;
+/** Band / sure every answer of a decision. */
+export declare function answersOf(decision: Decision, bands?: Bands): Answers;
+/** Evaluate once; answers by name, each with a band (noul) or `sure` (choice/score). */
+export declare function ask(classifier: Classifier, state: unknown, questions: readonly NamedQuestion[], bands?: Bands): Promise<Answers>;
+export interface Rule {
+    question: string;
+    below?: number;
+    at_least?: number;
+    is?: string;
+    action: string;
+    target?: string;
+}
+export interface GateOutcome {
+    action: string;
+    target: string;
+    escalated: boolean;
+    /** Present iff escalated: a §10 `input` Request. */
+    request?: Request;
+    answers: Answers;
+}
+export interface Policy {
+    rules: Rule[];
+    /** The no-rule-fired action; empty escalates with reason "no rule fired". */
+    default?: string;
+    bands?: Bands;
+    /** Skip a rule whose answer is uncertain instead of escalating on it. */
+    skipUncertain?: boolean;
+}
+/** Pure half of `gate`: first-match rules; an unsure or missing answer on rule i escalates and wins. */
+export declare function applyGate(answers: Answers, rules: readonly Rule[]): GateOutcome;
+/** Pure half of a `Policy`. */
+export declare function applyPolicy(answers: Answers, policy: Policy): GateOutcome;
+/** Ask, then apply rules; no rule fired -> empty action (use a `Policy` for a declared default). */
+export declare function gate(classifier: Classifier, state: unknown, questions: readonly NamedQuestion[], rules: readonly Rule[], bands?: Bands): Promise<GateOutcome>;
+/** Ask, then apply a `Policy` (rules, default, bands, skipUncertain). */
+export declare function decide(classifier: Classifier, state: unknown, questions: readonly NamedQuestion[], policy: Policy): Promise<GateOutcome>;
+/** One-line `static` classifier from recorded decisions. */
+export declare function staticClassifier(decisions: RecordedDecision[] | RecordedDecision, model?: string): Classifier;
+/**
+ * Records live decisions keyed by a caller-given call name, and replays them with no network.
+ * `tape.classifier(name)` returns a Classifier: recording (live given) or replaying (no live).
+ */
+export declare class Tape {
+    private readonly live?;
+    readonly entries: Record<string, RecordedDecision>;
+    constructor(live?: Classifier | undefined, entries?: Record<string, RecordedDecision>);
+    /** A replay-only tape from saved entries. */
+    static replay(entries: Record<string, RecordedDecision>): Tape;
+    classifier(name: string): Classifier;
+}