@nodetool-ai/agents 0.7.0-rc.23 → 0.8.1

package/dist/types.d.ts

@@ -1,47 +1,24 @@
 /**
  * Core type definitions for the agent system.
  */
-/**
- * Agent execution mode:
- * - "loop": Simple iterative LLM + tool calling loop (like SimpleAgent)
- * - "plan": LLM creates a task plan, then executes steps (like Agent)
- * - "multi-agent": Multiple sub-agents running in parallel (like TeamExecutor)
- */
-export type AgentMode = "loop" | "plan" | "multi-agent";
-/**
- * Configuration for a sub-agent in multi-agent mode.
- * Used when auto-specializing agents from an objective.
- */
-export interface SubAgentConfig {
-    /** Human-readable name for the sub-agent. */
-    name: string;
-    /** Role description for the sub-agent. */
-    role: string;
-    /** Skill tags for task matching. */
-    skills: string[];
-    /** Tool names this sub-agent can use (beyond team tools). */
-    tools?: string[];
-    /** Override model for this sub-agent. If not set, uses the parent agent's model. */
-    model?: string;
-    /** Override provider for this sub-agent. If not set, uses the parent agent's provider. */
-    provider?: string;
-}
 export interface Step {
     id: string;
     instructions: string;
+    /**
+     * True only when the step produced a valid result. A failed step is
+     * terminal but NOT completed — dependents must not run on its output.
+     */
     completed: boolean;
+    /** True when the step ended without a usable result. Mutually exclusive with {@link completed}. */
+    failed?: boolean;
+    /** Failure cause, set alongside {@link failed}. */
+    error?: string;
     startTime?: number;
     endTime?: number;
     dependsOn: string[];
     tools?: string[];
     outputSchema?: string;
     logs: string[];
-    /** Step execution mode: discover produces a list, process fans out over it, aggregate collects. */
-    mode?: "discover" | "process" | "aggregate";
-    /** Template with {field} placeholders, rendered per item for process-mode fan-out. */
-    perItemInstructions?: string;
-    /** JSON schema string applied to each ephemeral step's output in process mode. */
-    perItemSchema?: string;
 }
 export interface Task {
     id: string;
@@ -62,4 +39,12 @@ export interface TaskPlan {
     title: string;
     tasks: Task[];
 }
+/**
+ * ProcessingContext variable key under which a host publishes the
+ * `PermissionGateOptions` every loop under it must gate through. Declared in
+ * `@nodetool-ai/runtime` so the workflow hosts below this package can set a
+ * gate on the context they build; re-exported here for every existing import.
+ * Read it with `gateFromContext`, never directly.
+ */
+export { PERMISSION_GATE_CONTEXT_KEY } from "@nodetool-ai/runtime";
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,aAAa,CAAC;AAExD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,oFAAoF;IACpF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,mGAAmG;IACnG,IAAI,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,WAAW,CAAC;IAC5C,sFAAsF;IACtF,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,kFAAkF;IAClF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,uFAAuF;IACvF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,yEAAyE;IACzE,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,IAAI,EAAE,CAAC;CACf"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB,mGAAmG;IACnG,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,mDAAmD;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,uFAAuF;IACvF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,yEAAyE;IACzE,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,IAAI,EAAE,CAAC;CACf;AAED;;;;;;GAMG;AACH,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/types.js

@@ -1,5 +1,12 @@
 /**
  * Core type definitions for the agent system.
  */
-export {};
+/**
+ * ProcessingContext variable key under which a host publishes the
+ * `PermissionGateOptions` every loop under it must gate through. Declared in
+ * `@nodetool-ai/runtime` so the workflow hosts below this package can set a
+ * gate on the context they build; re-exported here for every existing import.
+ * Read it with `gateFromContext`, never directly.
+ */
+export { PERMISSION_GATE_CONTEXT_KEY } from "@nodetool-ai/runtime";
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AA2CH;;;;;;GAMG;AACH,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/utils/dag-scheduler.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Event-driven scheduling for a dependency graph.
+ *
+ * The task and step executors used to dispatch in barrier rounds: start every
+ * ready node, wait for the slowest, recompute the ready set. A chain behind a
+ * slow sibling therefore waited on the sibling in every round, and the round
+ * cap turned depth into failure. Here a node starts the moment its last
+ * dependency settles, and what bounds the work is the run's semaphore and the
+ * run budget rather than a count of rounds.
+ *
+ * The scheduler owns dependency state and event order; it knows nothing about
+ * tasks, steps, or messages. A caller supplies the nodes, a generator per node,
+ * and the events to emit when a node settles or is blocked.
+ *
+ * Order is the round loop's: a node's own events, then its settle events, then
+ * the blocked events of everything downstream of it, and only then are the
+ * nodes it unblocked started. Events of nodes running concurrently interleave,
+ * as they always did.
+ */
+import type { Semaphore } from "@nodetool-ai/runtime";
+/** Reason given to `settle` for a node nothing could ever run. */
+export declare const UNSATISFIABLE_DEPENDENCY = "unsatisfiable dependency";
+/** Reason given to `settle` for a node still unsettled when the signal fired. */
+export declare const ABORTED = "aborted";
+export interface DagNode {
+    id: string;
+    dependsOn: readonly string[];
+}
+export type DagOutcome = "ok" | "failed";
+/**
+ * How a node's generator settled. A generator that returns nothing settled
+ * `ok` — a run that fails reports it, since a failure that throws is an
+ * exception and propagates instead.
+ */
+export interface DagRunResult {
+    outcome: DagOutcome;
+    error?: string;
+}
+export interface DagScheduleOptions<N extends DagNode, E> {
+    nodes: readonly N[];
+    /** The node's event stream. Its return value carries how the node settled. */
+    run: (node: N) => AsyncGenerator<E, DagRunResult | void>;
+    /** Terminal events for a node that ran, or that could never run. */
+    settle: (node: N, outcome: DagOutcome, error?: string) => E[];
+    /** Permit pool bounding how many nodes run at once across the whole run. */
+    concurrency: Semaphore;
+    /**
+     * Bound on the nodes *this* schedule runs at once, on top of the pool. A
+     * pool shared by several schedules bounds them together; this bounds one of
+     * them. Unset, only the pool bounds it.
+     */
+    maxConcurrent?: number;
+    signal?: AbortSignal;
+    /**
+     * Events for a node that will never run because `by` failed. Called once per
+     * blocked node, naming the failed dependency immediately above it, and the
+     * blocked node counts as failed for everything below it (I-5: a failed
+     * dependency is never satisfied).
+     */
+    onBlocked: (node: N, by: N) => E[];
+}
+/**
+ * Run the graph, yielding every event its nodes produce.
+ *
+ * Ends when every node has settled. A state with unsettled nodes, nothing
+ * running and nothing ready cannot happen for a graph `PlanBuilder` accepted —
+ * it rejects cycles on the way in — so the scheduler asserts progress rather
+ * than hanging: those nodes settle failed with
+ * {@link UNSATISFIABLE_DEPENDENCY}.
+ *
+ * An exception thrown by a node's generator propagates once the other running
+ * generators have drained; that node never settles and the post-run settling
+ * is skipped, which is what the merge has always done.
+ *
+ * On abort the stream ends, every running generator is returned, and every
+ * node still unsettled — the ones that were running included — settles failed
+ * with {@link ABORTED}. A generator parked on an `await` that ignores the
+ * signal cannot be returned until that await resolves, so a node's own work
+ * must honour the signal; the merge has always required this of its producers.
+ *
+ * Work is O(nodes + edges): each node is settled once and each edge is walked
+ * once, whether it is decremented on success or followed by the block cascade.
+ */
+export declare function scheduleDag<N extends DagNode, E>(opts: DagScheduleOptions<N, E>): AsyncGenerator<E>;
+//# sourceMappingURL=dag-scheduler.d.ts.map

package/dist/utils/dag-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dag-scheduler.d.ts","sourceRoot":"","sources":["../../src/utils/dag-scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGtD,kEAAkE;AAClE,eAAO,MAAM,wBAAwB,6BAA6B,CAAC;AACnE,iFAAiF;AACjF,eAAO,MAAM,OAAO,YAAY,CAAC;AAEjC,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B;AAED,MAAM,MAAM,UAAU,GAAG,IAAI,GAAG,QAAQ,CAAC;AAEzC;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,UAAU,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC;IACtD,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC;IACpB,8EAA8E;IAC9E,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,cAAc,CAAC,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC,CAAC;IACzD,oEAAoE;IACpE,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC,EAAE,CAAC;IAC9D,4EAA4E;IAC5E,WAAW,EAAE,SAAS,CAAC;IACvB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;OAKG;IACH,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAuB,WAAW,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EACrD,IAAI,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,GAC7B,cAAc,CAAC,CAAC,CAAC,CAyInB"}

package/dist/utils/dag-scheduler.js

@@ -0,0 +1,180 @@
+/**
+ * Event-driven scheduling for a dependency graph.
+ *
+ * The task and step executors used to dispatch in barrier rounds: start every
+ * ready node, wait for the slowest, recompute the ready set. A chain behind a
+ * slow sibling therefore waited on the sibling in every round, and the round
+ * cap turned depth into failure. Here a node starts the moment its last
+ * dependency settles, and what bounds the work is the run's semaphore and the
+ * run budget rather than a count of rounds.
+ *
+ * The scheduler owns dependency state and event order; it knows nothing about
+ * tasks, steps, or messages. A caller supplies the nodes, a generator per node,
+ * and the events to emit when a node settles or is blocked.
+ *
+ * Order is the round loop's: a node's own events, then its settle events, then
+ * the blocked events of everything downstream of it, and only then are the
+ * nodes it unblocked started. Events of nodes running concurrently interleave,
+ * as they always did.
+ */
+import { createDynamicMerge } from "./merge-generators.js";
+/** Reason given to `settle` for a node nothing could ever run. */
+export const UNSATISFIABLE_DEPENDENCY = "unsatisfiable dependency";
+/** Reason given to `settle` for a node still unsettled when the signal fired. */
+export const ABORTED = "aborted";
+/**
+ * Run the graph, yielding every event its nodes produce.
+ *
+ * Ends when every node has settled. A state with unsettled nodes, nothing
+ * running and nothing ready cannot happen for a graph `PlanBuilder` accepted —
+ * it rejects cycles on the way in — so the scheduler asserts progress rather
+ * than hanging: those nodes settle failed with
+ * {@link UNSATISFIABLE_DEPENDENCY}.
+ *
+ * An exception thrown by a node's generator propagates once the other running
+ * generators have drained; that node never settles and the post-run settling
+ * is skipped, which is what the merge has always done.
+ *
+ * On abort the stream ends, every running generator is returned, and every
+ * node still unsettled — the ones that were running included — settles failed
+ * with {@link ABORTED}. A generator parked on an `await` that ignores the
+ * signal cannot be returned until that await resolves, so a node's own work
+ * must honour the signal; the merge has always required this of its producers.
+ *
+ * Work is O(nodes + edges): each node is settled once and each edge is walked
+ * once, whether it is decremented on success or followed by the block cascade.
+ */
+export async function* scheduleDag(opts) {
+    const { nodes, run, settle, concurrency, maxConcurrent, signal, onBlocked } = opts;
+    /** Nodes depending on the keyed id, in the order the caller listed them. */
+    const dependents = new Map();
+    /** Dependencies each node is still waiting on. */
+    const waitingOn = new Map();
+    for (const node of nodes) {
+        waitingOn.set(node.id, node.dependsOn.length);
+        for (const dep of node.dependsOn) {
+            const list = dependents.get(dep);
+            if (list) {
+                list.push(node);
+            }
+            else {
+                dependents.set(dep, [node]);
+            }
+        }
+    }
+    const settled = new Set();
+    /** Grows monotonically; `readyCursor` marks what has been started. */
+    const ready = [];
+    let readyCursor = 0;
+    let inFlight = 0;
+    const merge = createDynamicMerge({
+        semaphore: concurrency,
+        concurrency: maxConcurrent,
+        signal
+    });
+    /**
+     * Mark every unsettled node downstream of a failure and collect their
+     * blocked events. Breadth-first, so each node names the dependency directly
+     * above it, which is the id the round loop reported.
+     */
+    function blockDependents(failedNode) {
+        const events = [];
+        // A cursor, not a shift: `Array.shift` is O(length), which would make a
+        // wide cascade quadratic in the number of blocked nodes.
+        const frontier = [failedNode];
+        for (let i = 0; i < frontier.length; i++) {
+            const blocking = frontier[i];
+            for (const dependent of dependents.get(blocking.id) ?? []) {
+                if (settled.has(dependent.id))
+                    continue;
+                settled.add(dependent.id);
+                events.push(...onBlocked(dependent, blocking));
+                frontier.push(dependent);
+            }
+        }
+        return events;
+    }
+    function releaseDependents(node) {
+        for (const dependent of dependents.get(node.id) ?? []) {
+            if (settled.has(dependent.id))
+                continue;
+            const left = (waitingOn.get(dependent.id) ?? 0) - 1;
+            waitingOn.set(dependent.id, left);
+            if (left === 0)
+                ready.push(dependent);
+        }
+    }
+    function startReady() {
+        while (readyCursor < ready.length) {
+            const node = ready[readyCursor++];
+            inFlight++;
+            merge.add(wrap(node));
+        }
+    }
+    function wrap(node) {
+        return (async function* () {
+            let outcome = null;
+            try {
+                // Nothing past the `yield*` runs when the consumer stops early: an
+                // abort leaves this node unsettled on purpose, and the post-run pass
+                // settles it with the reason the run actually ended for.
+                const result = yield* run(node);
+                outcome = result ? result.outcome : "ok";
+                // Bookkeeping first, and in one uninterrupted stretch: a `yield`
+                // hands control to another node's wrapper, which must not see this
+                // node half-settled.
+                settled.add(node.id);
+                const terminal = settle(node, outcome, result ? result.error : undefined);
+                const cascade = outcome === "failed" ? blockDependents(node) : [];
+                for (const event of terminal) {
+                    yield event;
+                }
+                for (const event of cascade) {
+                    yield event;
+                }
+            }
+            finally {
+                inFlight--;
+                // A node whose generator threw releases nothing: the exception is on
+                // its way out of the merge, and this only keeps the stream from
+                // waiting on a node that will never settle. Dependents are released
+                // here, after the terminal events above, and not before them: a
+                // sibling's `finally` calls `startReady` too, and a dependent pushed
+                // to `ready` before its dependency's settle events were yielded could
+                // start between them.
+                if (outcome !== null) {
+                    if (outcome === "ok")
+                        releaseDependents(node);
+                    startReady();
+                }
+                // Every node settled, or nothing left that could start one: either
+                // way no further generator will be added, so let the stream end.
+                if (inFlight === 0)
+                    merge.close();
+            }
+        })();
+    }
+    for (const node of nodes) {
+        if (node.dependsOn.length === 0)
+            ready.push(node);
+    }
+    startReady();
+    if (inFlight === 0)
+        merge.close();
+    for await (const event of merge.stream()) {
+        yield event;
+    }
+    // Unsettled leftovers: a node the abort cut short, or one whose dependencies
+    // can never be satisfied. Neither may be left looking like it is still
+    // running.
+    const reason = signal?.aborted ? ABORTED : UNSATISFIABLE_DEPENDENCY;
+    for (const node of nodes) {
+        if (settled.has(node.id))
+            continue;
+        settled.add(node.id);
+        for (const event of settle(node, "failed", reason)) {
+            yield event;
+        }
+    }
+}
+//# sourceMappingURL=dag-scheduler.js.map

package/dist/utils/dag-scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dag-scheduler.js","sourceRoot":"","sources":["../../src/utils/dag-scheduler.ts"],"names":[],"mappings":"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"}

package/dist/utils/json-parser.d.ts

@@ -11,5 +11,36 @@
  *
  * Returns null if no valid JSON can be extracted.
  */
-export declare function extractJSON(text: string): unknown | null;
+/**
+ * A value `JSON.parse` can produce — the only shapes that survive a JSON round
+ * trip, and therefore the only ones that cross a text or WASM boundary.
+ */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare function extractJSON(text: string): JsonValue | null;
+/**
+ * Recover the complete prefix of a JSON object that was cut off mid-write.
+ *
+ * A vision judge asked for `{"verdict": …, "defects": […]}` and stopped at its
+ * token ceiling three defects in. {@link extractJSON} returns null for that —
+ * every strategy needs a balanced document — so the caller reported "did not
+ * return parseable JSON" and threw away a verdict and two usable defects that
+ * were fully written.
+ *
+ * This drops the incomplete tail: it walks back from the end to the last point
+ * where a value had just closed, closes the brackets that were still open
+ * there, and parses that. Returns null when nothing parses — a reply that is
+ * not JSON at all stays an error, and a *complete* document is
+ * {@link extractJSON}'s job, so try that first.
+ */
+export declare function salvageTruncatedJSON(text: string): JsonValue | null;
+/**
+ * {@link extractJSON}, falling back to {@link salvageTruncatedJSON}.
+ *
+ * For callers where a partial answer beats no answer — a critique whose
+ * defects list was cut short is still a critique. Never use it where a
+ * truncated document would be mistaken for a complete instruction.
+ */
+export declare function extractJSONAllowingTruncation(text: string): JsonValue | null;
 //# sourceMappingURL=json-parser.d.ts.map

package/dist/utils/json-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json-parser.d.ts","sourceRoot":"","sources":["../../src/utils/json-parser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CA6DxD"}
+{"version":3,"file":"json-parser.d.ts","sourceRoot":"","sources":["../../src/utils/json-parser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;GASG;AACH;;;GAGG;AACH,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,EAAE,GACX;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEjC,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAiF1D;AAiCD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CA0DnE;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAE5E"}

package/dist/utils/json-parser.js

@@ -1,17 +1,10 @@
 /**
  * Utility for extracting JSON from LLM text output.
  */
-/**
- * Attempt to extract a JSON value from a text string.
- *
- * Strategies (in order):
- * 1. Direct JSON.parse of the trimmed text.
- * 2. Extract from a fenced ```json code block.
- * 3. Find the first balanced { ... } substring.
- *
- * Returns null if no valid JSON can be extracted.
- */
 export function extractJSON(text) {
+    // Stryker disable next-line MethodExpression: JSON.parse already tolerates
+    // surrounding whitespace and strategy 3 scans via indexOf, so dropping trim()
+    // changes no observable result.
     const trimmed = text.trim();
     // Strategy 1: direct parse
     try {
@@ -21,9 +14,18 @@ export function extractJSON(text) {
         // continue
     }
     // Strategy 2: fenced code block
+    // Stryker disable next-line Regex: fence-regex variants are non-behavioral —
+    // strategy 3 (balanced braces) recovers any fenced object/array, and the
+    // captured group is .trim()'d before JSON.parse, so whitespace-class tweaks
+    // cannot change the parsed value.
     const fenceMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    // Stryker disable next-line ConditionalExpression: the `true` mutant only
+    // forces a JSON.parse on a missing/empty capture, which throws and is caught
+    // below — identical to skipping the fence path.
     if (fenceMatch?.[1]) {
         try {
+            // Stryker disable next-line MethodExpression: JSON.parse tolerates the
+            // surrounding whitespace, so trimming the captured group is cosmetic.
             return JSON.parse(fenceMatch[1].trim());
         }
         catch {
@@ -36,11 +38,16 @@ export function extractJSON(text) {
         ["[", "]"]
     ]) {
         const startIdx = trimmed.indexOf(open);
+        // Stryker disable next-line ConditionalExpression,UnaryOperator: when no
+        // opening bracket exists the scan below simply finds nothing, so skipping
+        // the `continue` only wastes a pass — the result is identical.
         if (startIdx === -1)
             continue;
         let depth = 0;
         let inString = false;
         let escape = false;
+        // Stryker disable next-line EqualityOperator: `< length`→`<= length` only
+        // visits one undefined trailing index that matches no branch (harmless).
         for (let i = startIdx; i < trimmed.length; i++) {
             const ch = trimmed[i];
             if (escape) {
@@ -61,6 +68,9 @@ export function extractJSON(text) {
                 depth++;
             if (ch === close) {
                 depth--;
+                // Stryker disable next-line ConditionalExpression: any close at depth>0
+                // yields an unbalanced prefix that never parses, so attempting a
+                // candidate there (the `true` mutant) is behaviorally equivalent.
                 if (depth === 0) {
                     const candidate = trimmed.slice(startIdx, i + 1);
                     try {
@@ -75,4 +85,129 @@ export function extractJSON(text) {
     }
     return null;
 }
+/**
+ * The largest reply {@link salvageTruncatedJSON} will try to repair.
+ *
+ * Repair walks candidate cut points and re-parses at each, so an unbounded
+ * input is quadratic. A judge reply that runs past this is not a truncated
+ * object; it is something else.
+ */
+const MAX_SALVAGE_CHARS = 200_000;
+/** How many cut points a single salvage may try before giving up. */
+const MAX_SALVAGE_ATTEMPTS = 300;
+/** Characters that can legally end a complete JSON value. */
+const VALUE_END = new Set([
+    "}",
+    "]",
+    '"',
+    "e", // true / false
+    "l", // null
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9"
+]);
+/**
+ * Recover the complete prefix of a JSON object that was cut off mid-write.
+ *
+ * A vision judge asked for `{"verdict": …, "defects": […]}` and stopped at its
+ * token ceiling three defects in. {@link extractJSON} returns null for that —
+ * every strategy needs a balanced document — so the caller reported "did not
+ * return parseable JSON" and threw away a verdict and two usable defects that
+ * were fully written.
+ *
+ * This drops the incomplete tail: it walks back from the end to the last point
+ * where a value had just closed, closes the brackets that were still open
+ * there, and parses that. Returns null when nothing parses — a reply that is
+ * not JSON at all stays an error, and a *complete* document is
+ * {@link extractJSON}'s job, so try that first.
+ */
+export function salvageTruncatedJSON(text) {
+    if (text.length > MAX_SALVAGE_CHARS)
+        return null;
+    const fence = text.match(/```(?:json)?\s*\n?([\s\S]*)$/);
+    const body = fence?.[1] ?? text;
+    const start = (() => {
+        const brace = body.indexOf("{");
+        const bracket = body.indexOf("[");
+        if (brace === -1)
+            return bracket;
+        if (bracket === -1)
+            return brace;
+        return Math.min(brace, bracket);
+    })();
+    if (start === -1)
+        return null;
+    // Forward pass: for every index, the bracket stack in force and whether the
+    // scanner is inside a string literal there.
+    const stacks = [];
+    const inString = [];
+    const stack = [];
+    let open = false;
+    let escape = false;
+    for (let i = start; i < body.length; i++) {
+        stacks.push([...stack]);
+        inString.push(open);
+        const ch = body[i];
+        if (escape) {
+            escape = false;
+            continue;
+        }
+        if (open) {
+            if (ch === "\\")
+                escape = true;
+            else if (ch === '"')
+                open = false;
+            continue;
+        }
+        if (ch === '"')
+            open = true;
+        else if (ch === "{")
+            stack.push("}");
+        else if (ch === "[")
+            stack.push("]");
+        else if (ch === "}" || ch === "]")
+            stack.pop();
+    }
+    stacks.push([...stack]);
+    inString.push(open);
+    let attempts = 0;
+    for (let cut = body.length; cut > start; cut--) {
+        const rel = cut - start;
+        if (inString[rel])
+            continue;
+        const prev = body[cut - 1];
+        if (!VALUE_END.has(prev))
+            continue;
+        const closers = stacks[rel];
+        if (closers.length === 0)
+            continue; // a balanced document is extractJSON's
+        if (++attempts > MAX_SALVAGE_ATTEMPTS)
+            break;
+        const candidate = body.slice(start, cut) + closers.slice().reverse().join("");
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+            // keep walking back
+        }
+    }
+    return null;
+}
+/**
+ * {@link extractJSON}, falling back to {@link salvageTruncatedJSON}.
+ *
+ * For callers where a partial answer beats no answer — a critique whose
+ * defects list was cut short is still a critique. Never use it where a
+ * truncated document would be mistaken for a complete instruction.
+ */
+export function extractJSONAllowingTruncation(text) {
+    return extractJSON(text) ?? salvageTruncatedJSON(text);
+}
 //# sourceMappingURL=json-parser.js.map

package/dist/utils/json-parser.js.map

@@ -1 +1 @@
-{"version":3,"file":"json-parser.js","sourceRoot":"","sources":["../../src/utils/json-parser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;GASG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IAE5B,2BAA2B;IAC3B,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAAC,MAAM,CAAC;QACP,WAAW;IACb,CAAC;IAED,gCAAgC;IAChC,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACvE,IAAI,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACpB,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAC1C,CAAC;QAAC,MAAM,CAAC;YACP,WAAW;QACb,CAAC;IACH,CAAC;IAED,0CAA0C;IAC1C,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI;QAC1B,CAAC,GAAG,EAAE,GAAG,CAAC;QACV,CAAC,GAAG,EAAE,GAAG,CAAC;KACF,EAAE,CAAC;QACX,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,QAAQ,KAAK,CAAC,CAAC;YAAE,SAAS;QAC9B,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAI,MAAM,GAAG,KAAK,CAAC;QACnB,KAAK,IAAI,CAAC,GAAG,QAAQ,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC/C,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YACtB,IAAI,MAAM,EAAE,CAAC;gBACX,MAAM,GAAG,KAAK,CAAC;gBACf,SAAS;YACX,CAAC;YACD,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC;gBAChB,MAAM,GAAG,IAAI,CAAC;gBACd,SAAS;YACX,CAAC;YACD,IAAI,EAAE,KAAK,GAAG,EAAE,CAAC;gBACf,QAAQ,GAAG,CAAC,QAAQ,CAAC;gBACrB,SAAS;YACX,CAAC;YACD,IAAI,QAAQ;gBAAE,SAAS;YACvB,IAAI,EAAE,KAAK,IAAI;gBAAE,KAAK,EAAE,CAAC;YACzB,IAAI,EAAE,KAAK,KAAK,EAAE,CAAC;gBACjB,KAAK,EAAE,CAAC;gBACR,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;oBAChB,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;oBACjD,IAAI,CAAC;wBACH,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;oBAC/B,CAAC;oBAAC,MAAM,CAAC;wBACP,qBAAqB;oBACvB,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}
+{"version":3,"file":"json-parser.js","sourceRoot":"","sources":["../../src/utils/json-parser.ts"],"names":[],"mappings":"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"}

package/dist/utils/json-schema-validate.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Host-side JSON-schema validation for structured step results.
+ *
+ * A step declares an `outputSchema`; the model answers through `finish_step`.
+ * The provider-side tool schema is a hint at best — several backends drop
+ * `enum`, flatten unions, or ignore `additionalProperties` — so whether the
+ * answer really matches the contract has to be decided here. A verdict schema
+ * makes that concrete: "one of five actions, and `substitute` also carries
+ * outputs" is a discriminated union, and a validator that only checks the
+ * top-level type and required keys accepts a verdict the kernel will reject.
+ *
+ * Deliberately a subset of JSON Schema — the keywords a step contract uses,
+ * validated exactly, rather than the full specification validated loosely.
+ */
+export interface SchemaViolation {
+    /** JSON-path-ish location, e.g. `result.outputs.text`. */
+    path: string;
+    message: string;
+}
+type Schema = Record<string, unknown>;
+/**
+ * Validate `value` against `schema`. Returns every violation found, so one
+ * bounce back to the model can fix everything rather than one thing per round.
+ */
+export declare function validateAgainstSchema(value: unknown, schema: Schema, path?: string): SchemaViolation[];
+/** One-line rendering of violations, for a tool-result bounce. */
+export declare function formatViolations(violations: SchemaViolation[]): string;
+export {};
+//# sourceMappingURL=json-schema-validate.d.ts.map