@addai/node 0.24.1 → 0.26.0

package/dist/flows/host.js

@@ -0,0 +1,125 @@
+"use strict";
+// What the shared engine needs from this machine, and what it must ask the
+// server for.
+//
+// The engine itself is host-agnostic: it walks the graph and calls handlers.
+// This file is the half of the contract that only makes sense here — the
+// twenty-five local handlers run in this process, and the fifteen privileged
+// ones become a round trip to flow-node-host, because they need a
+// service-role Supabase client or the credential encryption key and this
+// machine has neither.
+//
+// It is worth being precise about why that split is not a limitation we are
+// working around. `httpRequest` and `code` running HERE is the entire feature:
+// they reach this machine's LAN, its VPN, its filesystem and its IP address,
+// which is the thing no amount of cloud capacity substitutes for. Everything
+// else is bookkeeping the server was always going to be better at.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRegistry = buildRegistry;
+exports.reportNodeLog = reportNodeLog;
+const engine_loader_1 = require("./engine-loader");
+const supabase_client_1 = require("../supabase-client");
+const store_1 = require("../store");
+const config_1 = require("../config");
+const PROXY_TIMEOUT_MS = 5 * 60_000;
+/**
+ * Ask the server to run one privileged node.
+ *
+ * Deliberately NOT retried in here. A privileged node is very often a write —
+ * enqueueing an agent request, creating a review task, sending a notification —
+ * and a transparent retry on a timeout would do it twice. The engine's own
+ * error handling decides what happens next, in the open, where the flow author
+ * can see it on the node.
+ */
+async function proxyOne(runId, node, inputs, parentOutputs, inputData, viaReturnEdge) {
+    const pairing = (0, store_1.readPairing)();
+    if (!pairing)
+        throw new Error('not paired — cannot reach flow-node-host');
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), PROXY_TIMEOUT_MS);
+    try {
+        const res = await fetch(`${config_1.SUPABASE_URL}/functions/v1/flow-node-host`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${config_1.SUPABASE_ANON_KEY}`,
+                'apikey': config_1.SUPABASE_ANON_KEY,
+                'x-daemon-token': pairing.daemonToken,
+            },
+            body: JSON.stringify({
+                run_id: runId,
+                node,
+                inputs,
+                parent_outputs: parentOutputs,
+                input_data: inputData,
+                via_return_edge: viaReturnEdge,
+            }),
+            signal: controller.signal,
+        });
+        const text = await res.text();
+        let body = null;
+        try {
+            body = text ? JSON.parse(text) : null;
+        }
+        catch { /* non-JSON below */ }
+        if (!res.ok || body?.success === false) {
+            // Carry the server's own message through. It is what lands on the failed
+            // node in the run view, and "proxy failed (500)" is the difference
+            // between a five-minute fix and an afternoon.
+            throw new Error(body?.error || `flow-node-host returned ${res.status}: ${text.slice(0, 300)}`);
+        }
+        return body?.output ?? {};
+    }
+    catch (err) {
+        if (err.name === 'AbortError') {
+            throw new Error(`"${node.type}" did not finish on the server within ${PROXY_TIMEOUT_MS / 60000} minutes.`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * The handler registry this machine runs a flow with.
+ *
+ * Built once per run so the proxy closes over that run's id — the server
+ * authorises each proxied node by checking this daemon still holds the claim
+ * on it.
+ */
+async function buildRegistry(run) {
+    const { createHandlerRegistry, findNodeInputs } = await (0, engine_loader_1.loadEngine)();
+    return createHandlerRegistry({
+        proxyFactory: (type) => async (args) => {
+            const node = args?.node ?? {};
+            const parentOutputs = args?.parentOutputs ?? {};
+            // The server's handlers take the `from_<sourceId>` input map that
+            // Engine A builds, not the whole outputs bag. Computing it here with the
+            // engine's own function is what keeps a proxied node seeing exactly what
+            // it would see running inline.
+            const inputs = findNodeInputs(node.id, run.edges || [], parentOutputs);
+            return proxyOne(run.id, { ...node, type }, inputs, parentOutputs, args?.inputData ?? {}, args?.context?.viaReturnEdge === true);
+        },
+    });
+}
+/**
+ * Write one node event to the same place a cloud run writes it.
+ *
+ * Not optional polish. If a run on this machine is not as legible in the run
+ * viewer as a cloud run, self-hosting becomes the option nobody can debug, and
+ * people go back to the cloud for reasons that have nothing to do with where
+ * the work belongs.
+ *
+ * Fire-and-forget on purpose: a lost log line must never fail a flow.
+ */
+function reportNodeLog(run, node, status, output) {
+    void (0, supabase_client_1.rpc)('insert_node_log', {
+        p_run_id: run.id,
+        p_node_id: node?.id ?? null,
+        p_node_type: node?.type ?? null,
+        p_node_label: node?.data?.label ?? null,
+        p_status: status,
+        p_output: output ?? null,
+        p_workspace_id: run.workspace_id,
+    }).catch(() => { });
+}

package/dist/flows/pump.d.ts

@@ -0,0 +1,31 @@
+export declare const DEFAULT_MAX_CONCURRENT_FLOWS = 4;
+/** Clamp whatever the server sent into something the pump can act on. */
+export declare function clampMaxConcurrentFlows(value: unknown): number;
+/** Called by the heartbeat. Lowering it never interrupts a run in flight —
+ *  those finish; the pump just stops claiming until it is back under the line. */
+export declare function setMaxConcurrentFlows(value: unknown): void;
+/** Called by the heartbeat. Turning flows on starts claiming immediately;
+ *  turning it off stops claiming but lets what is running finish. */
+export declare function setFlowsEnabled(value: unknown): void;
+export declare function flowsEnabled(): boolean;
+export declare function maxConcurrentFlows(): number;
+export declare function inflightFlowCount(): number;
+/** Runs this daemon is holding right now. Reported every 30s so the server's
+ *  reclaim never requeues a healthy run that simply has nothing to say — a
+ *  flow parked in a slow HTTP call is quiet, not dead. */
+export declare function activeFlowRunIds(): string[];
+export declare function start(): void;
+export declare function stop(): void;
+/**
+ * Claim right now, because something said there is work.
+ *
+ * Deliberately does not clear the backoff window: if the pump is backing off
+ * because Supabase is unhealthy, a nudge is no reason to start hammering it.
+ */
+export declare function pumpNow(): void;
+/** Wait for in-flight runs, with a ceiling so a wedged run cannot block
+ *  shutdown forever. */
+export declare function drain(timeoutMs: number): Promise<{
+    drained: number;
+    timedOut: number;
+}>;

package/dist/flows/pump.js

@@ -0,0 +1,264 @@
+"use strict";
+// Claims +Ai Flows runs targeted at this machine and executes them.
+//
+// A deliberate sibling of request-pump, not a variation on it. The two solve
+// the same problem — claim work from Supabase, hold a bounded number of it,
+// heartbeat what you are holding, drain on shutdown — and every difference
+// between them would be a difference in how the box behaves under load that
+// nobody chose. Where the shapes match, they match on purpose.
+//
+// The one thing that is genuinely different is the ceiling. Flow runs and
+// agent runs count separately, because they compete for the same machine but
+// answer to different people: a burst of flows must never mean a chat goes
+// unanswered, and a long agent session must never stall the flows queue.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MAX_CONCURRENT_FLOWS = void 0;
+exports.clampMaxConcurrentFlows = clampMaxConcurrentFlows;
+exports.setMaxConcurrentFlows = setMaxConcurrentFlows;
+exports.setFlowsEnabled = setFlowsEnabled;
+exports.flowsEnabled = flowsEnabled;
+exports.maxConcurrentFlows = maxConcurrentFlows;
+exports.inflightFlowCount = inflightFlowCount;
+exports.activeFlowRunIds = activeFlowRunIds;
+exports.start = start;
+exports.stop = stop;
+exports.pumpNow = pumpNow;
+exports.drain = drain;
+const supabase_client_1 = require("../supabase-client");
+const store_1 = require("../store");
+const node_health_1 = require("../node-health");
+const diskguard_1 = require("../diskguard");
+const run_1 = require("./run");
+// Same 2s cadence as request-pump, for the same reason: 250ms polling from a
+// handful of daemons was enough to saturate the project's connection pool.
+// Successful claims re-tick immediately so a queued burst still drains fast.
+const POLL_INTERVAL_MS = 2_000;
+// How many flow runs this machine holds at once. Mirrors max_concurrent_runs:
+// the server's number, pushed in by the heartbeat, defaulting to 4 and
+// specifically to 4 when the server says NOTHING. A server without the
+// migration must read as "the behaviour you had yesterday", never as 0 (a node
+// that accepts nothing) or unbounded.
+exports.DEFAULT_MAX_CONCURRENT_FLOWS = 4;
+const MAX_MAX_CONCURRENT_FLOWS = 32;
+let maxConcurrent = exports.DEFAULT_MAX_CONCURRENT_FLOWS;
+// Off until the server says otherwise. Unlike desktops — where "can this
+// machine?" is answered by whether Docker is installed — the engine ships
+// inside the daemon, so capability is never the question and consent is.
+let enabled = false;
+/** Clamp whatever the server sent into something the pump can act on. */
+function clampMaxConcurrentFlows(value) {
+    // Absent is NOT zero. Number(null) and Number('') are both 0, which would
+    // quietly throttle the node to a single run — or with a naive clamp, shut it.
+    if (typeof value !== 'number' && typeof value !== 'string')
+        return exports.DEFAULT_MAX_CONCURRENT_FLOWS;
+    if (typeof value === 'string' && value.trim() === '')
+        return exports.DEFAULT_MAX_CONCURRENT_FLOWS;
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n))
+        return exports.DEFAULT_MAX_CONCURRENT_FLOWS;
+    return Math.min(MAX_MAX_CONCURRENT_FLOWS, Math.max(1, Math.floor(n)));
+}
+/** Called by the heartbeat. Lowering it never interrupts a run in flight —
+ *  those finish; the pump just stops claiming until it is back under the line. */
+function setMaxConcurrentFlows(value) {
+    const next = clampMaxConcurrentFlows(value);
+    if (next === maxConcurrent)
+        return;
+    console.log(`[flows-pump] flows at once: ${maxConcurrent} -> ${next}`);
+    maxConcurrent = next;
+    // Raising it should take effect now, not in two seconds — the usual reason
+    // to raise it is that work is queued up behind it.
+    if (enabled && !stopped && inflight < maxConcurrent)
+        queueMicrotask(() => { void tick(); });
+}
+/** Called by the heartbeat. Turning flows on starts claiming immediately;
+ *  turning it off stops claiming but lets what is running finish. */
+function setFlowsEnabled(value) {
+    const next = value === true;
+    if (next === enabled)
+        return;
+    enabled = next;
+    console.log(`[flows-pump] flows ${next ? 'enabled' : 'disabled'} for this machine`);
+    if (next && !stopped)
+        queueMicrotask(() => { void tick(); });
+}
+function flowsEnabled() { return enabled; }
+function maxConcurrentFlows() { return maxConcurrent; }
+function inflightFlowCount() { return inflight; }
+/** Runs this daemon is holding right now. Reported every 30s so the server's
+ *  reclaim never requeues a healthy run that simply has nothing to say — a
+ *  flow parked in a slow HTTP call is quiet, not dead. */
+function activeFlowRunIds() { return [...activeRunIds]; }
+// Anti-leak backstop ONLY: how long the pump holds a slot for a run whose
+// promise never settles. It does not stop the run and is not a time limit.
+const SLOT_LEAK_BACKSTOP_MS = 12 * 60 * 60 * 1000;
+let timer = null;
+let stopped = false;
+let inflight = 0;
+const activeRunIds = new Set();
+const inflightPromises = new Set();
+// Failure backoff, deduped logging — same shape as request-pump so an outage
+// produces ten log lines rather than a quarter of a million.
+let consecutiveFailures = 0;
+let lastLoggedError = '';
+let lastLoggedAt = 0;
+let nextClaimAllowedAt = 0;
+let lastHealthBlock = '';
+let lastHealthBlockAt = 0;
+async function tick() {
+    if (stopped || !enabled)
+        return;
+    if (inflight >= maxConcurrent)
+        return;
+    if (Date.now() < nextClaimAllowedAt)
+        return;
+    // The daemon-wide circuit breaker: when Supabase is in distress every poller
+    // pauses, not just this one.
+    if ((0, supabase_client_1.rpcShouldSkip)())
+        return;
+    const pairing = (0, store_1.readPairing)();
+    if (!pairing)
+        return;
+    // Don't accept work this machine cannot finish. A full scratch disk fails
+    // every code node and every attachment write; refusing the claim leaves the
+    // run queued for a healthy machine instead of burning one of its three
+    // attempts here.
+    const health = (0, node_health_1.evaluateNodeHealth)({ diskUsedPct: (0, node_health_1.readDiskUsedPct)((0, diskguard_1.getDiskGuard)().config.tempRoot) });
+    if (!health.healthy) {
+        const msg = health.blockers.map(b => b.message).join('; ');
+        const now = Date.now();
+        if (msg !== lastHealthBlock || (now - lastHealthBlockAt) > 60_000) {
+            console.warn(`[flows-pump] refusing claim — node unhealthy: ${msg}`);
+            lastHealthBlock = msg;
+            lastHealthBlockAt = now;
+        }
+        void (0, diskguard_1.getDiskGuard)().sweep('flows-health-gate').catch(() => { });
+        return;
+    }
+    let row = null;
+    try {
+        const result = await (0, supabase_client_1.rpc)('flow_run_claim_next', {
+            p_token: pairing.daemonToken,
+        });
+        row = (result && result.id) ? result : null;
+        if (consecutiveFailures > 0) {
+            console.log(`[flows-pump] recovered after ${consecutiveFailures} consecutive failures`);
+            consecutiveFailures = 0;
+            lastLoggedError = '';
+        }
+    }
+    catch (err) {
+        if (err instanceof supabase_client_1.RpcError && err.status === 401) {
+            console.error('[flows-pump] unauthorized; will retry on next heartbeat.');
+            return;
+        }
+        consecutiveFailures++;
+        const backoffMs = Math.min(60_000, POLL_INTERVAL_MS * Math.pow(2, Math.min(consecutiveFailures, 8)));
+        nextClaimAllowedAt = Date.now() + backoffMs;
+        const msg = err.message;
+        const now = Date.now();
+        if (msg !== lastLoggedError || (now - lastLoggedAt) > 60_000) {
+            console.error(`[flows-pump] claim failed (#${consecutiveFailures}, backing off ${backoffMs}ms):`, msg);
+            lastLoggedError = msg;
+            lastLoggedAt = now;
+        }
+        return;
+    }
+    if (!row)
+        return;
+    // Never run the same run twice at once. The claim RPC should make this
+    // impossible, but a duplicate execution of a flow means duplicate writes to
+    // whatever it touches — the one failure here that is not recoverable by
+    // trying again.
+    if (activeRunIds.has(row.id)) {
+        console.warn(`[flows-pump] skipping re-claim of in-flight run [run=${row.id}]`);
+        return;
+    }
+    inflight++;
+    const runId = row.id;
+    activeRunIds.add(runId);
+    // Per-run liveness, on its own timer. The 30s fleet heartbeat covers the
+    // normal case; this one exists so a single run that outlives a heartbeat
+    // hiccup still refreshes its own claim.
+    const touch = setInterval(() => {
+        void (0, supabase_client_1.rpc)('flow_run_touch', {
+            p_token: pairing.daemonToken,
+            p_run_id: runId,
+        }).catch(() => { });
+    }, 60_000);
+    touch.unref?.();
+    let resolveInflight;
+    const inflightPromise = new Promise((r) => { resolveInflight = r; });
+    inflightPromises.add(inflightPromise);
+    let backstopFired = false;
+    const backstop = new Promise((resolve) => {
+        const t = setTimeout(() => {
+            backstopFired = true;
+            console.error(`[flows-pump] run exceeded the ${SLOT_LEAK_BACKSTOP_MS / 3600000}h slot backstop `
+                + `[run=${runId}] — freeing the slot. The run continues; the server's reclaim `
+                + 'handles the row only if it really is dead.');
+            resolve();
+        }, SLOT_LEAK_BACKSTOP_MS);
+        t.unref?.();
+    });
+    const runPromise = (0, run_1.runFlow)(row).catch(err => console.error(`[flows-pump] runFlow threw [run=${runId}]: ${err.message}`));
+    // Drain tracking follows the REAL run, not the slot: a run that outlives its
+    // backstop must still hold up a graceful shutdown, or a restart would hand
+    // over mid-flow.
+    void runPromise.finally(() => {
+        clearInterval(touch);
+        activeRunIds.delete(runId);
+        inflightPromises.delete(inflightPromise);
+        resolveInflight();
+    });
+    Promise.race([runPromise, backstop]).finally(() => {
+        inflight = backstopFired ? Math.max(0, inflight - 1) : inflight - 1;
+        if (!stopped && enabled && inflight < maxConcurrent) {
+            queueMicrotask(() => { void tick(); });
+        }
+    });
+    // Back-to-back claims should not wait for the next interval.
+    if (!stopped && enabled && inflight < maxConcurrent) {
+        queueMicrotask(() => { void tick(); });
+    }
+}
+function start() {
+    if (timer || stopped)
+        return;
+    void tick();
+    timer = setInterval(() => { void tick(); }, POLL_INTERVAL_MS);
+}
+function stop() {
+    stopped = true;
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+}
+/**
+ * Claim right now, because something said there is work.
+ *
+ * Deliberately does not clear the backoff window: if the pump is backing off
+ * because Supabase is unhealthy, a nudge is no reason to start hammering it.
+ */
+function pumpNow() {
+    if (stopped || !enabled)
+        return;
+    void tick();
+}
+/** Wait for in-flight runs, with a ceiling so a wedged run cannot block
+ *  shutdown forever. */
+async function drain(timeoutMs) {
+    if (inflightPromises.size === 0)
+        return { drained: 0, timedOut: 0 };
+    const started = inflightPromises.size;
+    const deadline = new Promise((resolve) => {
+        const t = setTimeout(resolve, timeoutMs);
+        t.unref?.();
+    });
+    await Promise.race([
+        Promise.allSettled([...inflightPromises]).then(() => undefined),
+        deadline,
+    ]);
+    return { drained: started - inflightPromises.size, timedOut: inflightPromises.size };
+}

package/dist/flows/run.d.ts

@@ -0,0 +1,7 @@
+import { type FlowRunRow } from './host';
+/**
+ * Run it. Resolves when the run has reached a terminal or paused state and
+ * that state has been reported; never throws, because the pump's slot
+ * accounting is built on this settling exactly once.
+ */
+export declare function runFlow(run: FlowRunRow): Promise<void>;

package/dist/flows/run.js

@@ -0,0 +1,219 @@
+"use strict";
+// Execute one claimed flow run on this machine.
+//
+// The engine does the walking. What this file owns is the part the engine
+// deliberately knows nothing about: turning a database row into a graph call,
+// keeping the server informed while it runs, and writing exactly one terminal
+// answer at the end.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFlow = runFlow;
+const os = __importStar(require("os"));
+const engine_loader_1 = require("./engine-loader");
+const supabase_client_1 = require("../supabase-client");
+const store_1 = require("../store");
+const host_1 = require("./host");
+/**
+ * What the engine's result means for the run row.
+ *
+ * An end condition outranks the walk's own verdict: a flow that hit a goal
+ * "completed" as far as the graph is concerned, but goal and exit are the
+ * answers the runs list and the stats are counted on, and a node run that
+ * reported plain 'completed' for a goal would quietly skew both.
+ */
+function resolveStatus(result) {
+    const endType = result?.endConditionResult?.type;
+    if (endType === 'goal')
+        return 'goal';
+    if (endType === 'exit')
+        return 'exit';
+    switch (result?.status) {
+        case 'completed': return 'completed';
+        case 'cancelled': return 'cancelled';
+        case 'paused': return 'paused';
+        case 'failed': return 'failed';
+        default: return 'completed';
+    }
+}
+async function complete(run, status, fields = {}) {
+    const pairing = (0, store_1.readPairing)();
+    if (!pairing)
+        return;
+    try {
+        await (0, supabase_client_1.rpc)('flow_run_complete', {
+            p_token: pairing.daemonToken,
+            p_run_id: run.id,
+            p_status: status,
+            p_node_outputs: fields.nodeOutputs ?? null,
+            p_error: fields.error ?? null,
+            p_current_node_id: fields.currentNodeId ?? null,
+            p_metadata: fields.metadata ?? null,
+        });
+    }
+    catch (err) {
+        // The run is finished on this machine either way. Losing this write means
+        // the server's reclaim sweep eventually requeues it, which is the correct
+        // fallback — better a second attempt than a run stuck 'running' forever.
+        console.error(`[flows] could not report ${status} [run=${run.id}]:`, err.message);
+    }
+}
+/**
+ * Run it. Resolves when the run has reached a terminal or paused state and
+ * that state has been reported; never throws, because the pump's slot
+ * accounting is built on this settling exactly once.
+ */
+async function runFlow(run) {
+    const label = `${run.flow_id?.slice(0, 8) ?? '?'} run=${run.id.slice(0, 8)}`;
+    const started = Date.now();
+    console.log(`[flows] starting ${label}`);
+    // Resuming: the row carries what already ran, so a run that paused on a form
+    // and came back does not re-execute the nodes before it. This is also what
+    // makes a run survive being handed to a different machine mid-flight.
+    const previousOutputs = run.node_outputs || {};
+    const previouslyExecuted = new Set(Object.keys(previousOutputs));
+    let lastNodeId = run.current_node_id;
+    try {
+        // Inside the try, deliberately. If the engine cannot load — a broken
+        // install, a native sandbox that never built — this run has to be marked
+        // failed with that message on it. Loading above the try would throw past
+        // every handler below and leave the run sitting 'running' until the
+        // server's reclaim sweep noticed, three minutes later, with no reason
+        // attached.
+        //
+        // The error classes must come from the loaded module too: `instanceof`
+        // against a separately imported copy would never match, and every paused
+        // flow would be recorded as a failure.
+        const { executeWorkflowGraph, FlowPausedError, FlowCancelledError } = await (0, engine_loader_1.loadEngine)();
+        const result = await executeWorkflowGraph({
+            nodes: run.nodes || [],
+            edges: run.edges || [],
+            inputData: run.trigger_data || {},
+            // Where to pick up. A fresh run has none and starts at its trigger; a
+            // run the cloud handed back after a form or a wait carries the node it
+            // stopped at. Without this a resumed flow would walk from the top —
+            // previouslyExecuted stops it re-running anything, but a flow whose
+            // trigger is a webhook has nothing to walk from.
+            startFromNode: run.resume_from_node_id || null,
+            previousOutputs,
+            previouslyExecuted,
+            endConditions: null,
+            hooks: {
+                onNodeStarted: (node) => {
+                    lastNodeId = node?.id ?? lastNodeId;
+                },
+                onNodeCompleted: (node, output) => {
+                    (0, host_1.reportNodeLog)(run, node, 'success', output);
+                },
+                onNodeError: (node, error) => {
+                    (0, host_1.reportNodeLog)(run, node, 'error', {
+                        error: error?.message || String(error),
+                        success: false,
+                    });
+                },
+            },
+            context: {
+                handlers: await (0, host_1.buildRegistry)(run),
+                workspaceId: run.workspace_id,
+                flowRunId: run.id,
+                flowId: run.flow_id,
+                versionId: run.aiflow_version_id,
+                isTest: run.is_test === true,
+                variables: run.resolved_variables || [],
+                // Cancellation. The engine asks between nodes, so a cancel from the
+                // runs list stops this machine at the next boundary rather than after
+                // the whole flow. Failures here answer "unknown" rather than throwing:
+                // a blip talking to Supabase must not kill a healthy run.
+                checkRunStatus: async (rid) => {
+                    try {
+                        const pairing = (0, store_1.readPairing)();
+                        if (!pairing)
+                            return undefined;
+                        return await (0, supabase_client_1.rpc)('flow_run_status', {
+                            p_token: pairing.daemonToken,
+                            p_run_id: rid,
+                        }) ?? undefined;
+                    }
+                    catch {
+                        return undefined;
+                    }
+                },
+            },
+        });
+        const status = resolveStatus(result);
+        await complete(run, status, {
+            nodeOutputs: result?.nodeOutputs ?? null,
+            // A flow can fail without throwing: the engine catches a handled node
+            // error and RETURNS status 'failed' with the reason on `error`. Missing
+            // it meant a node run showed "failed" in the runs list with nothing
+            // beside it, which is the least useful thing a failed run can say.
+            error: result?.error ?? null,
+            currentNodeId: lastNodeId,
+            metadata: {
+                // So the run view can say which machine ran it, and why it is not in
+                // the cloud's logs.
+                ran_on: 'node',
+                runtime_hostname: os.hostname(),
+                duration_ms: Date.now() - started,
+            },
+        });
+        console.log(`[flows] ${status} ${label} in ${((Date.now() - started) / 1000).toFixed(1)}s`);
+    }
+    catch (err) {
+        // A pause is a normal outcome, not a failure: the flow is sitting on a
+        // form, a webhook or a timer. It releases the slot and the claim; whichever
+        // machine is free when it resumes picks it up.
+        //
+        // Named rather than `instanceof` because the classes live inside the try's
+        // scope, and because a run that failed to load the engine at all has no
+        // classes to compare against.
+        const kind = err?.constructor?.name;
+        if (kind === 'FlowPausedError') {
+            await complete(run, 'waiting', {
+                nodeOutputs: err?.nodeOutputs ?? null,
+                currentNodeId: lastNodeId,
+            });
+            console.log(`[flows] waiting ${label}`);
+            return;
+        }
+        if (kind === 'FlowCancelledError') {
+            await complete(run, 'cancelled', { currentNodeId: lastNodeId });
+            console.log(`[flows] cancelled ${label}`);
+            return;
+        }
+        const message = err?.message || String(err);
+        await complete(run, 'failed', { error: message, currentNodeId: lastNodeId });
+        console.error(`[flows] failed ${label}: ${message}`);
+    }
+}