@spendgraph/graph 0.5.0 → 0.7.0

package/dist/execute/execute.js

@@ -1,92 +0,0 @@
-import { FieldValidationError, validateFields } from "@spendgraph/sdk";
-import { nestedSteps, outputOf, tokensOf, totalTokens } from "./outcome.js";
-import { failedStep, message } from "./step.js";
-function ended(node, index, status, latencyMs, output, error) {
-    return { type: "node_end", node, index, status, output, error, latencyMs };
-}
-export async function executeGraph(byName, edgesFrom, entry, maxSteps, values, now, sink = () => { }) {
-    const startedAt = now();
-    const steps = [];
-    const outputs = {};
-    const context = (node) => ({
-        values,
-        outputs,
-        steps: [...steps],
-        emit: (text) => sink({ type: "token", node, text }),
-    });
-    const finish = (status, error) => ({
-        status,
-        output: status === "completed" ? (steps.at(-1)?.output ?? "") : "",
-        error,
-        steps,
-        outputs,
-        latencyMs: now() - startedAt,
-        ...totalTokens(steps),
-    });
-    let current = entry;
-    while (current) {
-        if (steps.length >= maxSteps) {
-            return finish("failed", `Ran ${maxSteps} steps without reaching an end, stopping at "${current}". ` +
-                `Either a conditional edge never turns false, or maxSteps is too low for this graph.`);
-        }
-        const node = byName.get(current);
-        const startedNode = now();
-        const ctx = context(current);
-        const index = steps.length;
-        let input;
-        try {
-            input = node.input ? node.input(ctx) : values;
-        }
-        catch (err) {
-            steps.push(failedStep(index, node.name, {}, now() - startedNode, message(err)));
-            sink(ended(node.name, index, "failed", now() - startedNode, undefined, message(err)));
-            return finish("failed", `Building the input for "${node.name}" threw: ${message(err)}`);
-        }
-        sink({ type: "node_start", node: node.name, index, input });
-        if (node.args?.length) {
-            const errors = validateFields(input, node.args);
-            if (errors.length > 0) {
-                const detail = new FieldValidationError(errors).message;
-                steps.push(failedStep(index, node.name, input, now() - startedNode, detail));
-                sink(ended(node.name, index, "failed", now() - startedNode, undefined, detail));
-                return finish("failed", `"${node.name}" was given ${detail}`);
-            }
-        }
-        let value;
-        try {
-            value = await node.run(input, ctx);
-        }
-        catch (err) {
-            steps.push(failedStep(index, node.name, input, now() - startedNode, message(err)));
-            sink(ended(node.name, index, "failed", now() - startedNode, undefined, message(err)));
-            return finish("failed", `"${node.name}" failed: ${message(err)}`);
-        }
-        outputs[node.name] = value;
-        steps.push({
-            index,
-            source: node.name,
-            input,
-            output: outputOf(value),
-            status: "completed",
-            latencyMs: now() - startedNode,
-            ...tokensOf(value),
-        });
-        steps.push(...nestedSteps(value, steps.length, node.name));
-        sink(ended(node.name, index, "completed", now() - startedNode, value));
-        let next = null;
-        try {
-            const after = context(node.name);
-            for (const e of edgesFrom.get(node.name) ?? []) {
-                if (e.when && !e.when(after))
-                    continue;
-                next = e.to;
-                break;
-            }
-        }
-        catch (err) {
-            return finish("failed", `Choosing what runs after "${node.name}" threw: ${message(err)}`);
-        }
-        current = next;
-    }
-    return finish("completed");
-}

package/dist/execute/step.d.ts

@@ -1,5 +0,0 @@
-import type { RolloutStep } from "@spendgraph/sdk";
-/** Same convention as a tool result: a string is itself, anything else is JSON. */
-export declare function stringify(value: unknown): string;
-export declare function failedStep(index: number, source: string, input: Record<string, unknown>, latencyMs: number, error: string): RolloutStep;
-export declare function message(err: unknown): string;

package/dist/execute/step.js

@@ -1,19 +0,0 @@
-export function stringify(value) {
-    if (value === undefined || value === null)
-        return "";
-    return typeof value === "string" ? value : JSON.stringify(value);
-}
-export function failedStep(index, source, input, latencyMs, error) {
-    return {
-        index,
-        source,
-        input,
-        output: "",
-        status: "failed",
-        error,
-        latencyMs,
-    };
-}
-export function message(err) {
-    return err instanceof Error ? err.message : String(err);
-}

package/dist/execute/stream.d.ts

@@ -1,19 +0,0 @@
-import type { Edge, GraphEvent, GraphResult, Node } from "../types/index.js";
-/** A run as it happens, and the same run once it is over. */
-export interface GraphStream extends AsyncIterable<GraphEvent> {
-    /**
-     * The finished run.
-     *
-     * Resolves whether or not anyone iterated, so a caller can pipe the events to
-     * a client and still record the rollout from the same run.
-     */
-    result: Promise<GraphResult>;
-}
-/**
- * Runs a compiled graph, narrating it as it goes.
- *
- * The run starts immediately rather than on the first read: a caller who only
- * wants the result should not have to iterate to get one, and a client that
- * connects late should see what already happened.
- */
-export declare function streamGraph(byName: Map<string, Node<never>>, edgesFrom: Map<string, Edge[]>, entry: string, maxSteps: number, values: Record<string, unknown>, now: () => number): GraphStream;

package/dist/execute/stream.js

@@ -1,49 +0,0 @@
-import { executeGraph } from "./execute.js";
-class Events {
-    waiting = [];
-    wake = null;
-    closed = false;
-    push(event) {
-        this.waiting.push(event);
-        this.release();
-    }
-    close() {
-        this.closed = true;
-        this.release();
-    }
-    release() {
-        const wake = this.wake;
-        this.wake = null;
-        wake?.();
-    }
-    async *drain() {
-        while (true) {
-            while (this.waiting.length > 0) {
-                yield this.waiting.shift();
-            }
-            if (this.closed)
-                return;
-            await new Promise((resolve) => {
-                this.wake = resolve;
-            });
-        }
-    }
-}
-export function streamGraph(byName, edgesFrom, entry, maxSteps, values, now) {
-    const events = new Events();
-    const result = (async () => {
-        try {
-            const finished = await executeGraph(byName, edgesFrom, entry, maxSteps, values, now, (e) => events.push(e));
-            events.push({ type: "result", result: finished });
-            return finished;
-        }
-        finally {
-            events.close();
-        }
-    })();
-    void result.catch(() => { });
-    return {
-        result,
-        [Symbol.asyncIterator]: () => events.drain(),
-    };
-}