@oni.bot/core 0.6.1

package/dist/pregel.d.ts

@@ -0,0 +1,48 @@
+import { type NodeDefinition, type Edge, type ChannelSchema, type ONIConfig, type ONIStreamEvent, type StreamMode, type InterruptConfig, type ONICheckpointer, type ONICheckpoint } from "./types.js";
+import type { BaseStore } from "./store/index.js";
+import { HITLSessionStore } from "./hitl/index.js";
+import { EventBus } from "./events/bus.js";
+import type { GuardrailsConfig } from "./guardrails/types.js";
+import type { EventListeners } from "./events/types.js";
+import { AuditLog } from "./guardrails/audit.js";
+import { BudgetTracker } from "./guardrails/budget.js";
+export declare class ONIPregelRunner<S extends Record<string, unknown>> {
+    private readonly nodes;
+    private readonly edges;
+    private readonly channels;
+    private readonly interruptConfig;
+    private readonly checkpointer;
+    private readonly store;
+    private hitlStore;
+    private nodeCache;
+    /** Set to true when this runner is being invoked as a subgraph */
+    private _isSubgraph;
+    /** Accumulated parent updates from Command.PARENT during subgraph execution */
+    _parentUpdates: Array<Partial<unknown>>;
+    readonly eventBus: EventBus;
+    readonly auditLog: AuditLog | null;
+    readonly budgetTracker: BudgetTracker | null;
+    constructor(nodes: Map<string, NodeDefinition<S>>, edges: Edge<S>[], channels: ChannelSchema<S>, interruptConfig?: InterruptConfig, checkpointer?: ONICheckpointer<S> | null, store?: BaseStore | null, guardrails?: GuardrailsConfig, listeners?: EventListeners);
+    private buildInitialState;
+    private applyUpdate;
+    private resetEphemeral;
+    private getNextNodes;
+    private executeNode;
+    private checkDynamicInterrupt;
+    _stream(input: Partial<S>, config?: ONIConfig, streamMode?: StreamMode | StreamMode[]): AsyncGenerator<ONIStreamEvent<S>>;
+    invoke(input: Partial<S>, config?: ONIConfig): Promise<S>;
+    stream(input: Partial<S>, config?: ONIConfig & {
+        streamMode?: StreamMode | StreamMode[];
+    }): AsyncGenerator<ONIStreamEvent<S>>;
+    batch(inputs: Partial<S>[], config?: ONIConfig): Promise<S[]>;
+    getState(threadId: string): Promise<S | null>;
+    updateState(threadId: string, update: Partial<S>): Promise<void>;
+    getStateAt(threadId: string, step: number): Promise<S | null>;
+    getHistory(threadId: string): Promise<ONICheckpoint<S>[]>;
+    forkFrom(threadId: string, step: number, newThreadId: string): Promise<void>;
+    getPendingInterrupts(threadId: string): import("./hitl/resume.js").HITLSession<S>[];
+    hitlSessionStore(): HITLSessionStore<S>;
+    private saveCheckpoint;
+    private evt;
+}
+//# sourceMappingURL=pregel.d.ts.map

package/dist/pregel.d.ts.map

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

package/dist/pregel.js

@@ -0,0 +1,583 @@
+// ============================================================
+// @oni.bot/core — Pregel Execution Engine v3
+// New: interrupt() context management, HITL resume, token streaming
+// ============================================================
+import { START, END, Send, Command, } from "./types.js";
+import { RecursionLimitError, NodeNotFoundError, ONIInterrupt } from "./errors.js";
+import { withRetry } from "./retry.js";
+import { NamespacedCheckpointer } from "./checkpointers/namespaced.js";
+import { _runWithContext } from "./context.js";
+import { StreamWriterImpl } from "./streaming.js";
+import { NodeInterruptSignal, HITLInterruptException, HITLSessionStore, _installInterruptContext, _clearInterruptContext, } from "./hitl/index.js";
+import { EventBus } from "./events/bus.js";
+import { AuditLog } from "./guardrails/audit.js";
+import { BudgetTracker } from "./guardrails/budget.js";
+const DEFAULT_RECURSION_LIMIT = 25;
+export class ONIPregelRunner {
+    nodes;
+    edges;
+    channels;
+    interruptConfig;
+    checkpointer;
+    store;
+    hitlStore = new HITLSessionStore();
+    nodeCache = new Map();
+    /** Set to true when this runner is being invoked as a subgraph */
+    _isSubgraph = false;
+    /** Accumulated parent updates from Command.PARENT during subgraph execution */
+    _parentUpdates = [];
+    eventBus;
+    auditLog;
+    budgetTracker;
+    constructor(nodes, edges, channels, interruptConfig = {}, checkpointer = null, store = null, guardrails, listeners) {
+        this.nodes = nodes;
+        this.edges = edges;
+        this.channels = channels;
+        this.interruptConfig = interruptConfig;
+        this.checkpointer = checkpointer;
+        this.store = store;
+        this.eventBus = new EventBus(listeners);
+        this.auditLog = guardrails?.audit ? new AuditLog() : null;
+        this.budgetTracker = guardrails?.budget ? new BudgetTracker(guardrails.budget) : null;
+    }
+    // ----------------------------------------------------------------
+    // State helpers
+    // ----------------------------------------------------------------
+    buildInitialState() {
+        const state = {};
+        for (const key of Object.keys(this.channels)) {
+            state[key] = this.channels[key].default();
+        }
+        return state;
+    }
+    applyUpdate(current, update) {
+        const next = { ...current };
+        for (const key of Object.keys(update)) {
+            if (update[key] !== undefined) {
+                const ch = this.channels[key];
+                next[key] = ch
+                    ? ch.reducer(current[key], update[key])
+                    : update[key];
+            }
+        }
+        return next;
+    }
+    resetEphemeral(state) {
+        const next = { ...state };
+        for (const key of Object.keys(this.channels)) {
+            if (this.channels[key].ephemeral)
+                next[key] = this.channels[key].default();
+        }
+        return next;
+    }
+    // ----------------------------------------------------------------
+    // Edge resolution
+    // ----------------------------------------------------------------
+    getNextNodes(fromNode, state, config) {
+        const outgoing = this.edges.filter((e) => e.from === fromNode);
+        const nodes = [];
+        const sends = [];
+        for (const edge of outgoing) {
+            if (edge.type === "static") {
+                nodes.push(edge.to);
+            }
+            else {
+                const result = edge.condition(state, config);
+                const resolved = Array.isArray(result) ? result : [result];
+                for (const r of resolved) {
+                    if (r instanceof Send)
+                        sends.push({ node: r.node, args: r.args });
+                    else
+                        nodes.push(edge.pathMap?.[r] ?? r);
+                }
+            }
+        }
+        return { nodes, sends };
+    }
+    // ----------------------------------------------------------------
+    // Execute a node with interrupt() context installed
+    // ----------------------------------------------------------------
+    async executeNode(nodeDef, state, config, resumeValue, hasResume, writer, step, recursionLimit) {
+        // Check cache
+        if (nodeDef.cache) {
+            const policy = typeof nodeDef.cache === "object" ? nodeDef.cache : {};
+            const keyFn = policy.key ?? ((s) => JSON.stringify(s));
+            const cacheKey = `${nodeDef.name}::${keyFn(state)}`;
+            const cached = this.nodeCache.get(cacheKey);
+            if (cached) {
+                const ttl = policy.ttl ?? Infinity;
+                if (Date.now() - cached.timestamp < ttl) {
+                    return cached.result;
+                }
+                this.nodeCache.delete(cacheKey);
+            }
+        }
+        const ctx = {
+            config: config ?? {},
+            store: this.store,
+            writer: writer ?? null,
+            state: state,
+            parentGraph: null,
+            parentUpdates: [],
+            step: step ?? 0,
+            recursionLimit: recursionLimit ?? DEFAULT_RECURSION_LIMIT,
+        };
+        return _runWithContext(ctx, async () => {
+            _installInterruptContext({
+                nodeName: nodeDef.name,
+                resumeValue: resumeValue,
+                hasResume: hasResume ?? false,
+            });
+            try {
+                const run = () => Promise.resolve(nodeDef.fn(state, config));
+                let result;
+                if (nodeDef.retry)
+                    result = await withRetry(run, nodeDef.name, nodeDef.retry);
+                else
+                    result = await run();
+                // Store in cache
+                if (nodeDef.cache) {
+                    const policy = typeof nodeDef.cache === "object" ? nodeDef.cache : {};
+                    const keyFn = policy.key ?? ((s) => JSON.stringify(s));
+                    const cacheKey = `${nodeDef.name}::${keyFn(state)}`;
+                    this.nodeCache.set(cacheKey, { result, timestamp: Date.now() });
+                }
+                return result;
+            }
+            finally {
+                _clearInterruptContext();
+            }
+        });
+    }
+    // ----------------------------------------------------------------
+    // Dynamic interrupt check
+    // ----------------------------------------------------------------
+    checkDynamicInterrupt(node, timing, state, config) {
+        const dynamics = config?.dynamicInterrupts;
+        if (!dynamics)
+            return;
+        for (const di of dynamics) {
+            if (di.node === node && di.timing === timing && di.condition(state)) {
+                throw new ONIInterrupt(node, timing, state);
+            }
+        }
+    }
+    // ----------------------------------------------------------------
+    // Core stream generator
+    // ----------------------------------------------------------------
+    async *_stream(input, config, streamMode = "updates") {
+        const threadId = config?.threadId ?? `oni-${Date.now()}`;
+        const recursionLimit = config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT;
+        const agentId = config?.agentId;
+        const modes = new Set(Array.isArray(streamMode) ? streamMode : [streamMode]);
+        const isMultiMode = Array.isArray(streamMode);
+        const tag = (evt, mode) => isMultiMode ? { ...evt, mode } : evt;
+        // Load resume values from config (set by resume() call)
+        const resumeMap = config?.__resumeValues ?? {};
+        // Load or init state
+        let state;
+        let step = 0;
+        let pendingNodes = [];
+        let pendingSends = [];
+        if (this.checkpointer && config?.threadId) {
+            const cp = await this.checkpointer.get(threadId);
+            if (cp) {
+                state = this.applyUpdate(cp.state, input);
+                step = cp.step;
+                pendingNodes = cp.nextNodes;
+                pendingSends = cp.pendingSends ?? [];
+            }
+            else {
+                state = this.applyUpdate(this.buildInitialState(), input);
+                const init = this.getNextNodes(START, state, config);
+                pendingNodes = init.nodes;
+                pendingSends = init.sends;
+            }
+        }
+        else {
+            state = this.applyUpdate(this.buildInitialState(), input);
+            const init = this.getNextNodes(START, state, config);
+            pendingNodes = init.nodes;
+            pendingSends = init.sends;
+        }
+        if (modes.has("values"))
+            yield tag(this.evt("state_update", state, step, agentId), "values");
+        // ---- Main superstep loop ----
+        while (true) {
+            const nextNodes = [];
+            const nextSends = [];
+            // Drain sends — group by target node for parallel fan-out execution
+            const sendGroups = new Map();
+            for (const send of pendingSends) {
+                if (!sendGroups.has(send.node))
+                    sendGroups.set(send.node, []);
+                sendGroups.get(send.node).push(send);
+                if (modes.has("debug"))
+                    yield tag(this.evt("send", send, step, agentId, send.node), "debug");
+            }
+            // Execute fan-out sends (each Send → separate node execution with its own state)
+            if (sendGroups.size > 0) {
+                const sendResults = await Promise.all([...sendGroups.entries()].flatMap(([node, sends]) => sends.map(async (send) => {
+                    const nodeDef = this.nodes.get(node);
+                    if (!nodeDef)
+                        throw new NodeNotFoundError(node);
+                    const sendState = this.applyUpdate(state, send.args);
+                    const result = await this.executeNode(nodeDef, sendState, config, undefined, undefined, undefined, step, recursionLimit);
+                    return { name: node, result };
+                })));
+                // Reduce all send results through channels
+                for (const { name, result } of sendResults) {
+                    if (result instanceof Command) {
+                        if (result.update)
+                            state = this.applyUpdate(state, result.update);
+                        const gotos = result.goto
+                            ? (Array.isArray(result.goto) ? result.goto : [result.goto])
+                            : this.getNextNodes(name, state, config).nodes;
+                        nextNodes.push(...gotos);
+                    }
+                    else if (result && typeof result === "object") {
+                        state = this.applyUpdate(state, result);
+                        const { nodes, sends } = this.getNextNodes(name, state, config);
+                        nextNodes.push(...nodes);
+                        nextSends.push(...sends);
+                    }
+                    else {
+                        const { nodes, sends } = this.getNextNodes(name, state, config);
+                        nextNodes.push(...nodes);
+                        nextSends.push(...sends);
+                    }
+                    if (modes.has("updates") || modes.has("debug")) {
+                        const delta = result instanceof Command ? (result.update ?? {}) : (result ?? {});
+                        if (modes.has("updates"))
+                            yield tag(this.evt("node_end", delta, step, agentId, name), "updates");
+                        if (modes.has("debug"))
+                            yield tag(this.evt("node_end", delta, step, agentId, name), "debug");
+                    }
+                }
+            }
+            pendingSends = [];
+            // Filter executable nodes (non-END), excluding nodes already handled by sends
+            const executableNodes = pendingNodes.filter((n) => n !== END && !sendGroups.has(n));
+            if (executableNodes.length === 0 && sendGroups.size === 0)
+                break;
+            if (step >= recursionLimit)
+                throw new RecursionLimitError(recursionLimit);
+            state = this.resetEphemeral(state);
+            // Emit debug node_start events before parallel execution
+            if (modes.has("debug")) {
+                for (const nodeName of executableNodes) {
+                    const name = nodeName;
+                    if (!this.nodes.has(name))
+                        throw new NodeNotFoundError(name);
+                    // Static interrupt BEFORE (check before emitting start)
+                    if (this.interruptConfig.interruptBefore?.includes(name))
+                        throw new ONIInterrupt(name, "before", state);
+                    this.checkDynamicInterrupt(name, "before", state, config);
+                    yield tag(this.evt("node_start", {}, step, agentId, name), "debug");
+                }
+            }
+            // Execute all active nodes in parallel
+            const allCustomEvents = [];
+            const allMessageEvents = [];
+            const allSubgraphEvents = [];
+            const nodeWriters = new Map();
+            const nodeResults = await Promise.all(executableNodes.map(async (nodeName) => {
+                const name = nodeName;
+                const nodeDef = this.nodes.get(name);
+                if (!nodeDef)
+                    throw new NodeNotFoundError(name);
+                // Static interrupt BEFORE (non-debug mode)
+                if (!modes.has("debug")) {
+                    if (this.interruptConfig.interruptBefore?.includes(name))
+                        throw new ONIInterrupt(name, "before", state);
+                    this.checkDynamicInterrupt(name, "before", state, config);
+                }
+                // Create a StreamWriter for this node
+                const messageId = `msg-${threadId}-${step}-${name}`;
+                const customEvents = [];
+                const messageEvents = [];
+                const writerImpl = new StreamWriterImpl((evt) => customEvents.push(evt), (token) => { }, (evt) => messageEvents.push(evt), name, step, messageId, agentId);
+                nodeWriters.set(name, writerImpl);
+                // Check if this node has a pending resume value
+                const resumeValue = resumeMap[name];
+                const hasResume = name in resumeMap;
+                // Emit agent.start lifecycle event
+                const nodeStartTime = Date.now();
+                this.eventBus.emit({ type: "agent.start", agent: name, timestamp: nodeStartTime, step });
+                let result;
+                let subParentUpdates = [];
+                try {
+                    if (nodeDef.subgraph) {
+                        // Mark child runner as a subgraph so Command.PARENT works
+                        const childRunner = nodeDef.subgraph._runner;
+                        if (childRunner) {
+                            childRunner._isSubgraph = true;
+                            childRunner._parentUpdates = [];
+                        }
+                        // Namespace the subgraph's checkpointer for isolation
+                        if (this.checkpointer && childRunner) {
+                            childRunner.checkpointer = new NamespacedCheckpointer(this.checkpointer, name);
+                        }
+                        // Stream the subgraph instead of invoke — buffer events for yielding after Promise.all
+                        // Use debug+values so we capture ALL event types AND state_update for final state
+                        let subFinalState;
+                        const childStreamMode = ["debug", "values"];
+                        for await (const evt of nodeDef.subgraph.stream(state, {
+                            ...config,
+                            parentRunId: config?.threadId,
+                            streamMode: childStreamMode,
+                        })) {
+                            // Namespace-prefix the node name
+                            allSubgraphEvents.push({
+                                ...evt,
+                                node: evt.node ? `${name}:${evt.node}` : name,
+                            });
+                            // Track the last state_update as the final subgraph state
+                            if (evt.event === "state_update") {
+                                subFinalState = evt.data;
+                            }
+                        }
+                        // Collect parent updates from child
+                        if (childRunner) {
+                            subParentUpdates = childRunner._parentUpdates;
+                            childRunner._isSubgraph = false;
+                            childRunner._parentUpdates = [];
+                        }
+                        result = subFinalState ?? {};
+                    }
+                    else {
+                        result = await this.executeNode(nodeDef, state, config, resumeValue, hasResume, writerImpl, step, recursionLimit);
+                    }
+                }
+                catch (err) {
+                    // Catch interrupt() signals thrown from inside nodes
+                    if (err instanceof NodeInterruptSignal) {
+                        const iv = {
+                            value: err.value,
+                            node: name,
+                            resumeId: err.resumeId,
+                            timestamp: Date.now(),
+                        };
+                        // Save checkpoint before surfacing interrupt
+                        await this.saveCheckpoint(threadId, step, state, [name], pendingSends, agentId, config?.metadata);
+                        // Record HITL session if checkpointer exists
+                        if (this.checkpointer) {
+                            const cp = await this.checkpointer.get(threadId);
+                            if (cp)
+                                this.hitlStore.record(threadId, iv, cp);
+                        }
+                        throw new HITLInterruptException(threadId, iv, state);
+                    }
+                    throw err;
+                }
+                // Emit agent.end lifecycle event
+                this.eventBus.emit({ type: "agent.end", agent: name, timestamp: Date.now(), step, duration: Date.now() - nodeStartTime });
+                // Collect events for yielding after parallel execution
+                allCustomEvents.push(...customEvents);
+                allMessageEvents.push(...messageEvents);
+                return { name, result, subParentUpdates };
+            }));
+            // Yield buffered subgraph events — filtered by parent's active modes
+            for (const evt of allSubgraphEvents) {
+                const e = evt;
+                if (modes.has("debug")) {
+                    yield tag(e, "debug");
+                }
+                else if (modes.has("updates") && (e.event === "node_end")) {
+                    yield tag(e, "updates");
+                }
+                else if (modes.has("values") && e.event === "state_update") {
+                    yield tag(e, "values");
+                }
+                // Custom and message events from subgraphs are forwarded if those modes are active
+                if (modes.has("custom") && e.event === "custom") {
+                    yield tag(e, "custom");
+                }
+                if (modes.has("messages") && (e.event === "messages" || e.event === "messages/complete")) {
+                    yield tag(e, "messages");
+                }
+            }
+            // Apply results
+            const stepWrites = [];
+            for (const { name, result, subParentUpdates: parentUpdates } of nodeResults) {
+                if (result instanceof Command) {
+                    if (result.graph === Command.PARENT) {
+                        // Push update to parent — do NOT apply locally
+                        if (!this._isSubgraph) {
+                            throw new Error("Command.PARENT used but graph is not running as a subgraph");
+                        }
+                        if (result.update)
+                            this._parentUpdates.push(result.update);
+                        // Still resolve next nodes normally
+                        const { nodes, sends } = this.getNextNodes(name, state, config);
+                        nextNodes.push(...nodes);
+                        nextSends.push(...sends);
+                    }
+                    else {
+                        if (result.update) {
+                            state = this.applyUpdate(state, result.update);
+                            if (Object.keys(result.update).length > 0) {
+                                stepWrites.push({ nodeId: name, writes: result.update });
+                            }
+                        }
+                        const gotos = result.goto
+                            ? (Array.isArray(result.goto) ? result.goto : [result.goto])
+                            : this.getNextNodes(name, state, config).nodes;
+                        nextNodes.push(...gotos);
+                        if (result.send)
+                            nextSends.push(...result.send.map((s) => ({ node: s.node, args: s.args })));
+                    }
+                }
+                else if (result && typeof result === "object") {
+                    state = this.applyUpdate(state, result);
+                    const writes = result;
+                    if (Object.keys(writes).length > 0) {
+                        stepWrites.push({ nodeId: name, writes });
+                    }
+                    const { nodes, sends } = this.getNextNodes(name, state, config);
+                    nextNodes.push(...nodes);
+                    nextSends.push(...sends);
+                }
+                else {
+                    const { nodes, sends } = this.getNextNodes(name, state, config);
+                    nextNodes.push(...nodes);
+                    nextSends.push(...sends);
+                }
+                // Apply parent updates from subgraph Command.PARENT (after normal result)
+                for (const pu of parentUpdates) {
+                    state = this.applyUpdate(state, pu);
+                }
+                if (modes.has("updates") || modes.has("debug")) {
+                    const delta = result instanceof Command ? (result.update ?? {}) : (result ?? {});
+                    if (modes.has("updates"))
+                        yield tag(this.evt("node_end", delta, step, agentId, name), "updates");
+                    if (modes.has("debug"))
+                        yield tag(this.evt("node_end", delta, step, agentId, name), "debug");
+                }
+                // Static interrupt AFTER
+                if (this.interruptConfig.interruptAfter?.includes(name)) {
+                    await this.saveCheckpoint(threadId, step, state, nextNodes, nextSends, agentId, config?.metadata);
+                    throw new ONIInterrupt(name, "after", state);
+                }
+                this.checkDynamicInterrupt(name, "after", state, config);
+            }
+            // Yield buffered custom/message events based on stream mode
+            if (modes.has("custom") || modes.has("debug")) {
+                for (const evt of allCustomEvents) {
+                    if (modes.has("custom"))
+                        yield tag(evt, "custom");
+                    if (modes.has("debug"))
+                        yield tag(evt, "debug");
+                }
+            }
+            if (modes.has("messages") || modes.has("debug")) {
+                for (const evt of allMessageEvents) {
+                    if (modes.has("messages"))
+                        yield tag(evt, "messages");
+                    if (modes.has("debug"))
+                        yield tag(evt, "debug");
+                }
+                // Emit messages/complete for each node that produced tokens
+                for (const [, writer] of nodeWriters) {
+                    const complete = writer._complete();
+                    if (complete) {
+                        if (modes.has("messages"))
+                            yield tag(complete, "messages");
+                        if (modes.has("debug"))
+                            yield tag(complete, "debug");
+                    }
+                }
+            }
+            if (modes.has("values"))
+                yield tag(this.evt("state_update", state, step, agentId), "values");
+            pendingNodes = [...new Set(nextNodes)];
+            pendingSends = nextSends;
+            step++;
+            await this.saveCheckpoint(threadId, step, state, pendingNodes, pendingSends, agentId, config?.metadata, stepWrites);
+        }
+        if (modes.has("values"))
+            yield tag(this.evt("state_update", state, step, agentId), "values");
+    }
+    // ----------------------------------------------------------------
+    // Public API
+    // ----------------------------------------------------------------
+    async invoke(input, config) {
+        let finalState;
+        for await (const evt of this._stream(input, config, "values")) {
+            if (evt.event === "state_update")
+                finalState = evt.data;
+        }
+        return finalState;
+    }
+    async *stream(input, config) {
+        yield* this._stream(input, config, config?.streamMode ?? "updates");
+    }
+    async batch(inputs, config) {
+        return Promise.all(inputs.map((inp, i) => this.invoke(inp, {
+            ...config,
+            threadId: config?.threadId ? `${config.threadId}-${i}` : undefined,
+        })));
+    }
+    // ---- State ----
+    async getState(threadId) {
+        if (!this.checkpointer)
+            return null;
+        return (await this.checkpointer.get(threadId))?.state ?? null;
+    }
+    async updateState(threadId, update) {
+        if (!this.checkpointer)
+            return;
+        const cp = await this.checkpointer.get(threadId);
+        if (!cp)
+            return;
+        await this.checkpointer.put({ ...cp, state: this.applyUpdate(cp.state, update), timestamp: Date.now() });
+    }
+    // ---- Time-travel ----
+    async getStateAt(threadId, step) {
+        if (!this.checkpointer)
+            return null;
+        const history = await this.checkpointer.list(threadId);
+        return history.find((c) => c.step === step)?.state ?? null;
+    }
+    async getHistory(threadId) {
+        if (!this.checkpointer)
+            return [];
+        return this.checkpointer.list(threadId);
+    }
+    async forkFrom(threadId, step, newThreadId) {
+        if (!this.checkpointer)
+            return;
+        const cp = this.checkpointer;
+        if (typeof cp.fork === "function") {
+            await cp.fork(threadId, step, newThreadId);
+        }
+        else {
+            const history = await this.checkpointer.list(threadId);
+            for (const c of history.filter((x) => x.step <= step)) {
+                await this.checkpointer.put({ ...c, threadId: newThreadId });
+            }
+        }
+    }
+    // ---- HITL ----
+    getPendingInterrupts(threadId) {
+        return this.hitlStore.getByThread(threadId);
+    }
+    hitlSessionStore() {
+        return this.hitlStore;
+    }
+    // ---- Helpers ----
+    async saveCheckpoint(threadId, step, state, nextNodes, pendingSends, agentId, metadata, pendingWrites) {
+        if (!this.checkpointer)
+            return;
+        await this.checkpointer.put({
+            threadId, step, state, agentId, metadata, pendingWrites,
+            nextNodes: nextNodes.map(String),
+            pendingSends: pendingSends,
+            timestamp: Date.now(),
+        });
+    }
+    evt(event, data, step, agentId, node) {
+        return { event, data, step, timestamp: Date.now(), agentId, node };
+    }
+}
+//# sourceMappingURL=pregel.js.map