@alpic80/rivet-core 1.19.1-aidon.3 → 1.24.0-aidon.3

package/dist/esm/model/GraphProcessor.js

@@ -1,16 +1,20 @@
 import { max, range, sum, uniqBy } from 'lodash-es';
 import { isArrayDataValue, arrayizeDataValue, getScalarTypeOf, } from './DataValue.js';
+import { IF_PORT, } from './NodeBase.js';
 import PQueueImport from 'p-queue';
 import { getError } from '../utils/errors.js';
 import Emittery from 'emittery';
 import { entries, fromEntries, values } from '../utils/typeSafety.js';
 import { isNotNull } from '../utils/genericUtilFunctions.js';
+import {} from './Project.js';
 import { nanoid } from 'nanoid/non-secure';
 import { P, match } from 'ts-pattern';
 import { coerceTypeOptional } from '../utils/coerceType.js';
 import { globalRivetNodeRegistry } from './Nodes.js';
 import { getPluginConfig } from '../utils/index.js';
 import { GptTokenizerTokenizer } from '../integrations/GptTokenizerTokenizer.js';
+// eslint-disable-next-line import/no-cycle -- There has to be a cycle because CodeRunner needs to import the entirety of Rivet
+import { IsomorphicCodeRunner } from '../integrations/CodeRunner.js';
 // CJS compatibility, gets default.default for whatever reason
 let PQueue = PQueueImport;
 if (typeof PQueue !== 'function') {
@@ -23,28 +27,28 @@ export class GraphProcessor {
     #nodesById;
     #nodeInstances;
     #connections;
-    #definitions;
     #emitter = new Emittery();
     #running = false;
     #isSubProcessor = false;
-    #scc;
-    #nodesNotInCycle;
     #externalFunctions = {};
     slowMode = false;
     #isPaused = false;
     #parent;
     #registry;
     id = nanoid();
+    #includeTrace = true;
     executor;
     /** If set, specifies the node(s) that the graph will run TO, instead of the nodes without any dependents. */
     runToNodeIds;
+    /** If set, specifies the node that the graph will run FROM, instead of the start nodes. Requires preloading data. */
+    runFromNodeId;
     /** The node that is executing this graph, almost always a subgraph node. Undefined for root. */
     #executor;
     /** The interval between nodeFinish events when playing back a recording. I.e. how fast the playback is. */
     recordingPlaybackChatLatency = 1000;
     warnOnInvalidGraph = false;
     // Per-process state
-    #erroredNodes = undefined;
+    #erroredNodes = undefined; // Values are strings in recordings
     #remainingNodes = undefined;
     #visitedNodes = undefined;
     #currentlyProcessing = undefined;
@@ -68,13 +72,19 @@ export class GraphProcessor {
     #totalResponseTokens = 0;
     #totalCost = 0;
     #ignoreNodes = undefined;
+    #hasPreloadedData = false;
+    #loadedProjects = undefined;
+    #definitions = undefined;
+    #scc = undefined;
+    // @ts-expect-error
+    #nodesNotInCycle = undefined;
     #nodeAbortControllers = new Map();
     /** User input nodes that are pending user input. */
     #pendingUserInputs = undefined;
     get isRunning() {
         return this.#running;
     }
-    constructor(project, graphId, registry) {
+    constructor(project, graphId, registry, includeTrace) {
         this.#project = project;
         const graph = graphId
             ? project.graphs[graphId]
@@ -85,11 +95,19 @@ export class GraphProcessor {
             throw new Error(`Graph ${graphId} not found in project`);
         }
         this.#graph = graph;
+        this.#includeTrace = includeTrace;
         this.#nodeInstances = {};
         this.#connections = {};
         this.#nodesById = {};
         this.#registry = registry ?? globalRivetNodeRegistry;
         this.#emitter.bindMethods(this, ['on', 'off', 'once', 'onAny', 'offAny']);
+        this.setExternalFunction('echo', async (value) => ({ type: 'any', value }));
+        this.#emitter.on('globalSet', ({ id, value }) => {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            this.#emitter.emit(`globalSet:${id}`, value);
+        });
+    }
+    #preprocessGraph() {
         // Create node instances and store them in a lookup table
         for (const node of this.#graph.nodes) {
             this.#nodeInstances[node.id] = this.#registry.createDynamicImpl(node);
@@ -100,10 +118,10 @@ export class GraphProcessor {
             if (!this.#nodesById[conn.inputNodeId] || !this.#nodesById[conn.outputNodeId]) {
                 if (this.warnOnInvalidGraph) {
                     if (!this.#nodesById[conn.inputNodeId]) {
-                        console.warn(`Missing node ${conn.inputNodeId} in graph ${graphId} (connection from ${this.#nodesById[conn.outputNodeId]?.title})`);
+                        console.warn(`Missing node ${conn.inputNodeId} in graph ${this.#graph} (connection from ${this.#nodesById[conn.outputNodeId]?.title})`);
                     }
                     else {
-                        console.warn(`Missing node ${conn.outputNodeId} in graph ${graphId} (connection to ${this.#nodesById[conn.inputNodeId]?.title}) `);
+                        console.warn(`Missing node ${conn.outputNodeId} in graph ${this.#graph} (connection to ${this.#nodesById[conn.inputNodeId]?.title}) `);
                     }
                 }
                 continue;
@@ -113,12 +131,17 @@ export class GraphProcessor {
             this.#connections[conn.inputNodeId].push(conn);
             this.#connections[conn.outputNodeId].push(conn);
         }
+        this.#loadInputOutputDefinitions();
+        this.#scc = this.#tarjanSCC();
+        this.#nodesNotInCycle = this.#scc.filter((cycle) => cycle.length === 1).flat();
+    }
+    #loadInputOutputDefinitions() {
         // Store input and output definitions in a lookup table
         this.#definitions = {};
         for (const node of this.#graph.nodes) {
             const connectionsForNode = this.#connections[node.id] ?? [];
-            const inputDefs = this.#nodeInstances[node.id].getInputDefinitions(connectionsForNode, this.#nodesById, this.#project);
-            const outputDefs = this.#nodeInstances[node.id].getOutputDefinitions(connectionsForNode, this.#nodesById, this.#project);
+            const inputDefs = this.#nodeInstances[node.id].getInputDefinitionsIncludingBuiltIn(connectionsForNode, this.#nodesById, this.#project, this.#loadedProjects);
+            const outputDefs = this.#nodeInstances[node.id].getOutputDefinitions(connectionsForNode, this.#nodesById, this.#project, this.#loadedProjects);
             this.#definitions[node.id] = { inputs: inputDefs, outputs: outputDefs };
             // Find all invalid connections to or from the node, then remove them from consideration
             const invalidConnections = connectionsForNode.filter((connection) => {
@@ -153,12 +176,12 @@ export class GraphProcessor {
                 }
             }
         }
-        this.#scc = this.#tarjanSCC();
-        this.#nodesNotInCycle = this.#scc.filter((cycle) => cycle.length === 1).flat();
-        this.setExternalFunction('echo', async (value) => ({ type: 'any', value }));
-        this.#emitter.on('globalSet', ({ id, value }) => {
-            this.#emitter.emit(`globalSet:${id}`, value);
-        });
+    }
+    #emitTraceEvent(eventData) {
+        if (this.#includeTrace) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            this.#emitter.emit('trace', eventData);
+        }
     }
     on = undefined;
     off = undefined;
@@ -199,8 +222,10 @@ export class GraphProcessor {
         this.#abortController.abort();
         this.#abortSuccessfully = successful;
         this.#abortError = error;
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         this.#emitter.emit('graphAbort', { successful, error, graph: this.#graph });
         if (!this.#isSubProcessor) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             this.#emitter.emit('abort', { successful, error });
         }
         await this.#processingQueue.onIdle();
@@ -208,12 +233,14 @@ export class GraphProcessor {
     pause() {
         if (this.#isPaused === false) {
             this.#isPaused = true;
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             this.#emitter.emit('pause', void 0);
         }
     }
     resume() {
         if (this.#isPaused) {
             this.#isPaused = false;
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             this.#emitter.emit('resume', void 0);
         }
     }
@@ -234,6 +261,38 @@ export class GraphProcessor {
             }
         }
     }
+    preloadNodeData(nodeId, data) {
+        this.#nodeResults ??= new Map();
+        this.#visitedNodes ??= new Set();
+        for (const value of Object.values(data)) {
+            if (!value || !('type' in value) || !value.type) {
+                throw new Error(`Invalid data value for node ${nodeId}, must be a DataValue`);
+            }
+        }
+        this.#nodeResults.set(nodeId, data);
+        this.#visitedNodes.add(nodeId);
+        this.#hasPreloadedData = true;
+    }
+    /** Gets all node IDs that a given node ID depends on being complete before the given node ID can start. */
+    getDependencyNodesDeep(nodeId) {
+        const node = this.#nodesById[nodeId];
+        if (!node) {
+            return [];
+        }
+        const connections = this.#connections[nodeId];
+        if (!connections) {
+            return [];
+        }
+        const dependencyNodes = connections
+            .map((conn) => {
+            if (conn.inputNodeId === nodeId) {
+                return this.getDependencyNodesDeep(conn.outputNodeId);
+            }
+            return [];
+        })
+            .flat();
+        return [...new Set([nodeId, ...dependencyNodes])];
+    }
     async replayRecording(recorder) {
         const { events } = recorder;
         this.#initProcessState();
@@ -265,6 +324,7 @@ export class GraphProcessor {
                 await this.#waitUntilUnpaused();
                 await match(event)
                     .with({ type: 'start' }, ({ data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('start', {
                         project: this.#project,
                         contextValues: data.contextValues,
@@ -275,43 +335,52 @@ export class GraphProcessor {
                     this.#graphInputs = data.inputs;
                 })
                     .with({ type: 'abort' }, ({ data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('abort', data);
                 })
                     .with({ type: 'pause' }, () => { })
                     .with({ type: 'resume' }, () => { })
                     .with({ type: 'done' }, ({ data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('done', data);
                     this.#graphOutputs = data.results;
                     this.#running = false;
                 })
                     .with({ type: 'error' }, ({ data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('error', data);
                 })
                     .with({ type: 'globalSet' }, ({ data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('globalSet', data);
                 })
                     .with({ type: 'trace' }, ({ data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('trace', data);
                 })
                     .with({ type: 'graphStart' }, ({ data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('graphStart', {
                         graph: getGraph(data.graphId),
                         inputs: data.inputs,
                     });
                 })
                     .with({ type: 'graphFinish' }, ({ data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('graphFinish', {
                         graph: getGraph(data.graphId),
                         outputs: data.outputs,
                     });
                 })
                     .with({ type: 'graphError' }, ({ data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('graphError', {
                         graph: getGraph(data.graphId),
                         error: data.error,
                     });
                 })
                     .with({ type: 'graphAbort' }, ({ data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('graphAbort', {
                         graph: getGraph(data.graphId),
                         error: data.error,
@@ -320,6 +389,7 @@ export class GraphProcessor {
                 })
                     .with({ type: 'nodeStart' }, async ({ data }) => {
                     const node = getNode(data.nodeId);
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('nodeStart', {
                         node: getNode(data.nodeId),
                         inputs: data.inputs,
@@ -332,6 +402,7 @@ export class GraphProcessor {
                 })
                     .with({ type: 'nodeFinish' }, ({ data }) => {
                     const node = getNode(data.nodeId);
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('nodeFinish', {
                         node,
                         outputs: data.outputs,
@@ -341,6 +412,7 @@ export class GraphProcessor {
                     this.#visitedNodes.add(data.nodeId);
                 })
                     .with({ type: 'nodeError' }, ({ data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('nodeError', {
                         node: getNode(data.nodeId),
                         error: data.error,
@@ -350,6 +422,7 @@ export class GraphProcessor {
                     this.#visitedNodes.add(data.nodeId);
                 })
                     .with({ type: 'nodeExcluded' }, ({ data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('nodeExcluded', {
                         node: getNode(data.nodeId),
                         processId: data.processId,
@@ -362,28 +435,35 @@ export class GraphProcessor {
                     .with({ type: 'nodeOutputsCleared' }, () => { })
                     .with({ type: 'partialOutput' }, () => { })
                     .with({ type: 'userInput' }, ({ data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('userInput', {
                         callback: undefined,
+                        inputStrings: data.inputStrings,
                         inputs: data.inputs,
                         node: getNode(data.nodeId),
                         processId: data.processId,
+                        renderingType: data.renderingType,
                     });
                 })
                     .with({ type: P.string.startsWith('globalSet:') }, ({ type, data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit(type, data);
                 })
                     .with({ type: P.string.startsWith('userEvent:') }, ({ type, data }) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit(type, data);
                 })
                     .with({ type: 'newAbortController' }, () => { })
                     .with({ type: 'finish' }, () => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('finish', undefined);
                 })
-                    //          .with(undefined, () => {})
+                    .with(P.nullish, () => { })
                     .exhaustive();
             }
         }
         catch (err) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             this.#emitter.emit('error', { error: getError(err) });
         }
         finally {
@@ -393,9 +473,11 @@ export class GraphProcessor {
     }
     #initProcessState() {
         this.#running = true;
-        this.#nodeResults = new Map();
+        if (!this.#hasPreloadedData) {
+            this.#nodeResults = new Map();
+            this.#visitedNodes = new Set();
+        }
         this.#erroredNodes = new Map();
-        this.#visitedNodes = new Set();
         this.#currentlyProcessing = new Set();
         this.#remainingNodes = new Set(this.#graph.nodes.map((n) => n.id));
         this.#pendingUserInputs = {};
@@ -416,6 +498,7 @@ export class GraphProcessor {
         this.#abortError = undefined;
         this.#abortSuccessfully = false;
         this.#nodeAbortControllers = new Map();
+        this.#loadedProjects = {};
     }
     /** Main function for running a graph. Runs a graph and returns the outputs from the output nodes of the graph. */
     async processGraph(
@@ -435,27 +518,49 @@ export class GraphProcessor {
             this.#contextValues ??= contextValues;
             if (this.#context.tokenizer) {
                 this.#context.tokenizer.on('error', (error) => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     this.#emitter.emit('error', { error });
                 });
             }
+            await this.#loadProjectReferences();
+            this.#preprocessGraph();
             if (!this.#isSubProcessor) {
-                this.#emitter.emit('start', {
+                await this.#emitter.emit('start', {
                     contextValues: this.#contextValues,
                     inputs: this.#graphInputs,
                     project: this.#project,
                     startGraph: this.#graph,
                 });
             }
-            this.#emitter.emit('graphStart', { graph: this.#graph, inputs: this.#graphInputs });
+            await this.#emitter.emit('graphStart', { graph: this.#graph, inputs: this.#graphInputs });
+            if (this.#hasPreloadedData) {
+                for (const node of this.#graph.nodes) {
+                    if (this.#nodeResults.has(node.id)) {
+                        this.#emitTraceEvent(`Node ${node.title} has preloaded data`);
+                        await this.#emitter.emit('nodeStart', {
+                            node,
+                            inputs: {},
+                            processId: 'preload',
+                        });
+                        await this.#emitter.emit('nodeFinish', {
+                            node,
+                            outputs: this.#nodeResults.get(node.id),
+                            processId: 'preload',
+                        });
+                    }
+                }
+            }
             const startNodes = this.runToNodeIds
                 ? this.#graph.nodes.filter((node) => this.runToNodeIds?.includes(node.id))
                 : this.#graph.nodes.filter((node) => this.#outputNodesFrom(node).nodes.length === 0);
             await this.#waitUntilUnpaused();
             for (const startNode of startNodes) {
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this.#processingQueue.add(async () => {
                     await this.#fetchNodeDataAndProcessNode(startNode);
                 });
             }
+            await this.#processingQueue.onIdle();
             // Anything not queued at this phase here should be ignored
             if (this.runToNodeIds) {
                 // For safety, we'll only activate this if runToNodeIds is set, in case there are bugs in the first pass
@@ -465,20 +570,28 @@ export class GraphProcessor {
                     }
                 }
             }
-            await this.#processingQueue.onIdle();
             // If we've aborted successfully, we can treat the graph like it succeeded
             const erroredNodes = [...this.#erroredNodes.entries()].filter(([nodeId]) => {
                 const erroredNodeAttachedData = this.#getAttachedDataTo(nodeId);
                 return erroredNodeAttachedData.races == null || erroredNodeAttachedData.races.completed === false;
             });
             if (erroredNodes.length && !this.#abortSuccessfully) {
-                const error = this.#abortError ??
-                    Error(`Graph ${this.#graph.metadata.name} (${this.#graph.metadata.id}) failed to process due to errors in nodes: ${erroredNodes
-                        .map(([nodeId, error]) => `${this.#nodesById[nodeId].title} (${nodeId}): ${error}`)
-                        .join(', ')}`);
-                this.#emitter.emit('graphError', { graph: this.#graph, error });
+                let error = this.#abortError;
+                if (!error) {
+                    const message = `Graph ${this.#graph.metadata.name} (${this.#graph.metadata.id}) failed to process due to errors in nodes:\n${erroredNodes
+                        .map(([nodeId]) => `- ${this.#nodesById[nodeId].title} (${nodeId})`)
+                        .join('\n')}`;
+                    if (erroredNodes.length === 1) {
+                        const [, nodeError] = erroredNodes[0];
+                        error = new Error(message, { cause: nodeError });
+                    }
+                    else {
+                        error = new AggregateError(erroredNodes.map(([, nodeError]) => nodeError), message);
+                    }
+                }
+                await this.#emitter.emit('graphError', { graph: this.#graph, error });
                 if (!this.#isSubProcessor) {
-                    this.#emitter.emit('error', { error });
+                    await this.#emitter.emit('error', { error });
                 }
                 throw error;
             }
@@ -502,17 +615,39 @@ export class GraphProcessor {
             }
             const outputValues = this.#graphOutputs;
             this.#running = false;
-            this.#emitter.emit('graphFinish', { graph: this.#graph, outputs: outputValues });
+            await this.#emitter.emit('graphFinish', { graph: this.#graph, outputs: outputValues });
             if (!this.#isSubProcessor) {
-                this.#emitter.emit('done', { results: outputValues });
-                this.#emitter.emit('finish', undefined);
+                await this.#emitter.emit('done', { results: outputValues });
+                await this.#emitter.emit('finish', undefined);
             }
             return outputValues;
         }
         finally {
             this.#running = false;
             if (!this.#isSubProcessor) {
-                this.#emitter.emit('finish', undefined);
+                await this.#emitter.emit('finish', undefined);
+            }
+        }
+    }
+    async #loadProjectReferences() {
+        if ((this.#project.references?.length ?? 0) > 0) {
+            if (!this.#context.projectReferenceLoader) {
+                throw new Error('Project references are set, but no projectReferenceLoader is set in the context. Since this project uses project references, you must provide a projectReferenceLoader in the context.');
+            }
+            const seenProjectIds = new Set();
+            const loadProject = async (ref) => {
+                if (seenProjectIds.has(ref.id)) {
+                    return;
+                }
+                seenProjectIds.add(ref.id);
+                const project = await this.#context.projectReferenceLoader.loadProject(this.#context.projectPath, ref);
+                this.#loadedProjects[project.metadata.id] = project;
+                for (const reference of project.references ?? []) {
+                    await loadProject(reference);
+                }
+            };
+            for (const reference of this.#project.references) {
+                await loadProject(reference);
             }
         }
     }
@@ -539,7 +674,7 @@ export class GraphProcessor {
         if (!inputsReady) {
             return;
         }
-        this.#emitter.emit('trace', `Node ${node.title} has required inputs nodes: ${inputNodes.map((n) => n.title).join(', ')}`);
+        this.#emitTraceEvent(`Node ${node.title} has required inputs nodes: ${inputNodes.map((n) => n.title).join(', ')}`);
         const attachedData = this.#getAttachedDataTo(node);
         if (node.type === 'raceInputs' || attachedData.races) {
             for (const inputNode of inputNodes) {
@@ -556,9 +691,10 @@ export class GraphProcessor {
             }
         }
         this.#queuedNodes.add(node.id);
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         this.#processingQueue.addAll(inputNodes.map((inputNode) => {
             return async () => {
-                this.#emitter.emit('trace', `Fetching required data for node ${inputNode.title} (${inputNode.id})`);
+                this.#emitTraceEvent(`Fetching required data for node ${inputNode.title} (${inputNode.id})`);
                 await this.#fetchNodeDataAndProcessNode(inputNode);
             };
         }));
@@ -568,27 +704,34 @@ export class GraphProcessor {
     async #processNodeIfAllInputsAvailable(node) {
         const builtInNode = node;
         if (this.#ignoreNodes.has(node.id)) {
-            this.#emitter.emit('trace', `Node ${node.title} is ignored`);
+            this.#emitTraceEvent(`Node ${node.title} is ignored`);
             return;
         }
+        if (this.runToNodeIds) {
+            const dependencyNodes = this.getDependencyNodesDeep(node.id);
+            if (this.runToNodeIds.some((runTo) => runTo !== node.id && dependencyNodes.includes(runTo))) {
+                this.#emitTraceEvent(`Node ${node.title} is excluded due to runToNodeIds`);
+                return;
+            }
+        }
         if (this.#currentlyProcessing.has(node.id)) {
-            this.#emitter.emit('trace', `Node ${node.title} is already being processed`);
+            this.#emitTraceEvent(`Node ${node.title} is already being processed`);
             return;
         }
         // For a loop controller, it can run multiple times, otherwise we already processed this node so bail out
         if (this.#visitedNodes.has(node.id) && node.type !== 'loopController') {
-            this.#emitter.emit('trace', `Node ${node.title} has already been processed`);
+            this.#emitTraceEvent(`Node ${node.title} has already been processed`);
             return;
         }
         if (this.#erroredNodes.has(node.id)) {
-            this.#emitter.emit('trace', `Node ${node.title} has already errored`);
+            this.#emitTraceEvent(`Node ${node.title} has already errored`);
             return;
         }
         const inputNodes = this.#inputNodesTo(node);
         // Check if all input nodes are free of errors
         for (const inputNode of inputNodes) {
             if (this.#erroredNodes.has(inputNode.id)) {
-                this.#emitter.emit('trace', `Node ${node.title} has errored input node ${inputNode.title}`);
+                this.#emitTraceEvent(`Node ${node.title} has errored input node ${inputNode.title}`);
                 return;
             }
         }
@@ -599,13 +742,13 @@ export class GraphProcessor {
             return connectionToInput || !input.required;
         });
         if (!inputsReady) {
-            this.#emitter.emit('trace', `Node ${node.title} has required inputs nodes: ${inputNodes.map((n) => n.title).join(', ')}`);
+            this.#emitTraceEvent(`Node ${node.title} has required inputs nodes: ${inputNodes.map((n) => n.title).join(', ')}`);
             return;
         }
         // Excluded because control flow is still in a loop - difference between "will not execute" and "has not executed yet"
         const inputValues = this.#getInputValuesForNode(node);
         if (this.#excludedDueToControlFlow(node, inputValues, nanoid(), 'loop-not-broken')) {
-            this.#emitter.emit('trace', `Node ${node.title} is excluded due to control flow`);
+            this.#emitTraceEvent(`Node ${node.title} is excluded due to control flow`);
             return;
         }
         let waitingForInputNode = false;
@@ -628,7 +771,7 @@ export class GraphProcessor {
             }
         }
         if (waitingForInputNode) {
-            this.#emitter.emit('trace', `Node ${node.title} is waiting for input node ${waitingForInputNode}`);
+            this.#emitTraceEvent(`Node ${node.title} is waiting for input node ${waitingForInputNode}`);
             return;
         }
         this.#currentlyProcessing.add(node.id);
@@ -640,14 +783,14 @@ export class GraphProcessor {
             attachedData.loopInfo.nodes.add(node.id);
         }
         if (attachedData.races?.completed) {
-            this.#emitter.emit('trace', `Node ${node.title} is part of a race that was completed`);
+            this.#emitTraceEvent(`Node ${node.title} is part of a race that was completed`);
             return;
         }
         const processId = await this.#processNode(node);
         if (this.slowMode) {
             await new Promise((resolve) => setTimeout(resolve, 250));
         }
-        this.#emitter.emit('trace', `Finished processing node ${node.title} (${node.id})`);
+        this.#emitTraceEvent(`Finished processing node ${node.title} (${node.id})`);
         this.#visitedNodes.add(node.id);
         this.#currentlyProcessing.delete(node.id);
         this.#remainingNodes.delete(node.id);
@@ -657,13 +800,15 @@ export class GraphProcessor {
             const loopControllerResults = this.#nodeResults.get(node.id);
             // If the loop controller is excluded, we have to "break" it or else it'll loop forever...
             const breakValue = loopControllerResults['break'];
-            const didBreak = !(breakValue?.type === 'control-flow-excluded' && breakValue?.value === 'loop-not-broken') ??
+            const didBreak = 
+            // @ts-ignore
+            !(breakValue?.type === 'control-flow-excluded' && breakValue?.value === 'loop-not-broken') ??
                 this.#excludedDueToControlFlow(node, this.#getInputValuesForNode(node), nanoid());
             if (!didBreak) {
-                this.#emitter.emit('trace', `Loop controller ${node.title} did not break, so we're looping again`);
+                this.#emitTraceEvent(`Loop controller ${node.title} did not break, so we're looping again`);
                 for (const loopNodeId of attachedData.loopInfo?.nodes ?? []) {
                     const cycleNode = this.#nodesById[loopNodeId];
-                    this.#emitter.emit('trace', `Clearing cycle node ${cycleNode.title} (${cycleNode.id})`);
+                    this.#emitTraceEvent(`Clearing cycle node ${cycleNode.title} (${cycleNode.id})`);
                     this.#visitedNodes.delete(cycleNode.id);
                     this.#currentlyProcessing.delete(cycleNode.id);
                     this.#remainingNodes.add(cycleNode.id);
@@ -678,7 +823,7 @@ export class GraphProcessor {
             for (const [nodeId] of allNodesForRace) {
                 for (const [key, abortController] of this.#nodeAbortControllers.entries()) {
                     if (key.startsWith(nodeId)) {
-                        this.#emitter.emit('trace', `Aborting node ${nodeId} because other race branch won`);
+                        this.#emitTraceEvent(`Aborting node ${nodeId} because other race branch won`);
                         abortController.abort();
                     }
                 }
@@ -727,8 +872,9 @@ export class GraphProcessor {
             }
         }
         // Node is finished, check if we can run any more nodes that depend on this one
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         this.#processingQueue.addAll(outputNodes.nodes.map((outputNode) => async () => {
-            this.#emitter.emit('trace', `Trying to run output node from ${node.title}: ${outputNode.title} (${outputNode.id})`);
+            this.#emitTraceEvent(`Trying to run output node from ${node.title}: ${outputNode.title} (${outputNode.id})`);
             await this.#processNodeIfAllInputsAvailable(outputNode);
         }));
     }
@@ -756,10 +902,7 @@ export class GraphProcessor {
             this.#nodeErrored(node, error, processId);
             return processId;
         }
-        if (this.#isNodeOfType('userInput', node)) {
-            await this.#processUserInputNode(node, processId);
-        }
-        else if (node.isSplitRun) {
+        if (node.isSplitRun) {
             await this.#processSplitRunNode(node, processId);
         }
         else {
@@ -767,50 +910,13 @@ export class GraphProcessor {
         }
         return processId;
     }
-    #isNodeOfType(type, node) {
-        return node.type === type;
-    }
-    async #processUserInputNode(node, processId) {
-        try {
-            const inputValues = this.#getInputValuesForNode(node);
-            if (this.#excludedDueToControlFlow(node, inputValues, processId)) {
-                return;
-            }
-            this.#emitter.emit('nodeStart', { node, inputs: inputValues, processId });
-            const results = await new Promise((resolve, reject) => {
-                this.#pendingUserInputs[node.id] = {
-                    resolve,
-                    reject,
-                };
-                this.#abortController.signal.addEventListener('abort', () => {
-                    delete this.#pendingUserInputs[node.id];
-                    reject(new Error('Processing aborted'));
-                });
-                this.#emitter.emit('userInput', {
-                    node,
-                    inputs: inputValues,
-                    callback: (results) => {
-                        resolve(results);
-                        delete this.#pendingUserInputs[node.id];
-                    },
-                    processId,
-                });
-            });
-            const outputValues = this.#nodeInstances[node.id].getOutputValuesFromUserInput(inputValues, results);
-            this.#nodeResults.set(node.id, outputValues);
-            this.#visitedNodes.add(node.id);
-            this.#emitter.emit('nodeFinish', { node, outputs: outputValues, processId });
-        }
-        catch (e) {
-            this.#nodeErrored(node, e, processId);
-        }
-    }
     async #processSplitRunNode(node, processId) {
         const inputValues = this.#getInputValuesForNode(node);
         if (this.#excludedDueToControlFlow(node, inputValues, processId)) {
             return;
         }
         const splittingAmount = Math.min(max(values(inputValues).map((value) => (Array.isArray(value?.value) ? value?.value.length : 1))) ?? 1, node.splitRunMax ?? 10);
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         this.#emitter.emit('nodeStart', { node, inputs: inputValues, processId });
         try {
             let results = [];
@@ -824,7 +930,10 @@ export class GraphProcessor {
                         isArrayDataValue(value) ? arrayizeDataValue(value)[i] ?? undefined : value,
                     ]));
                     try {
-                        const output = await this.#processNodeWithInputData(node, inputs, i, processId, (node, partialOutputs, index) => this.#emitter.emit('partialOutput', { node, outputs: partialOutputs, index, processId }));
+                        const output = await this.#processNodeWithInputData(node, inputs, i, processId, (node, partialOutputs, index) => {
+                            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                            this.#emitter.emit('partialOutput', { node, outputs: partialOutputs, index, processId });
+                        });
                         if (output['requestTokens']?.type === 'number') {
                             this.#totalRequestTokens += coerceTypeOptional(output['requestTokens'], 'number') ?? 0;
                         }
@@ -848,7 +957,10 @@ export class GraphProcessor {
                         isArrayDataValue(value) ? arrayizeDataValue(value)[i] ?? undefined : value,
                     ]));
                     try {
-                        const output = await this.#processNodeWithInputData(node, inputs, i, processId, (node, partialOutputs, index) => this.#emitter.emit('partialOutput', { node, outputs: partialOutputs, index, processId }));
+                        const output = await this.#processNodeWithInputData(node, inputs, i, processId, (node, partialOutputs, index) => {
+                            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                            this.#emitter.emit('partialOutput', { node, outputs: partialOutputs, index, processId });
+                        });
                         if (output['requestTokens']?.type === 'number') {
                             this.#totalRequestTokens += coerceTypeOptional(output['requestTokens'], 'number') ?? 0;
                         }
@@ -871,7 +983,7 @@ export class GraphProcessor {
                 throw e;
             }
             else if (errors.length > 0) {
-                throw new Error(errors.join('\n'));
+                throw new AggregateError(errors);
             }
             // Combine the parallel results into the final output
             // Turn a Record<PortId, DataValue[]> into a Record<PortId, AnyArrayDataValue>
@@ -887,6 +999,7 @@ export class GraphProcessor {
             this.#totalRequestTokens += sum(results.map((r) => coerceTypeOptional(r.output?.['requestTokens'], 'number') ?? 0));
             this.#totalResponseTokens += sum(results.map((r) => coerceTypeOptional(r.output?.['responseTokens'], 'number') ?? 0));
             this.#totalCost += sum(results.map((r) => coerceTypeOptional(r.output?.['cost'], 'number') ?? 0));
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             this.#emitter.emit('nodeFinish', { node, outputs: aggregateResults, processId });
         }
         catch (error) {
@@ -898,9 +1011,13 @@ export class GraphProcessor {
         if (this.#excludedDueToControlFlow(node, inputValues, processId)) {
             return;
         }
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         this.#emitter.emit('nodeStart', { node, inputs: inputValues, processId });
         try {
-            const outputValues = await this.#processNodeWithInputData(node, inputValues, 0, processId, (node, partialOutputs, index) => this.#emitter.emit('partialOutput', { node, outputs: partialOutputs, index, processId }));
+            const outputValues = await this.#processNodeWithInputData(node, inputValues, 0, processId, (node, partialOutputs, index) => {
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                this.#emitter.emit('partialOutput', { node, outputs: partialOutputs, index, processId });
+            });
             this.#nodeResults.set(node.id, outputValues);
             this.#visitedNodes.add(node.id);
             if (outputValues['requestTokens']?.type === 'number') {
@@ -912,6 +1029,7 @@ export class GraphProcessor {
             if (outputValues['cost']?.type === 'number') {
                 this.#totalCost += coerceTypeOptional(outputValues['cost'], 'number') ?? 0;
             }
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             this.#emitter.emit('nodeFinish', { node, outputs: outputValues, processId });
         }
         catch (error) {
@@ -920,9 +1038,10 @@ export class GraphProcessor {
     }
     #nodeErrored(node, e, processId) {
         const error = getError(e);
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         this.#emitter.emit('nodeError', { node, error, processId });
-        this.#emitter.emit('trace', `Node ${node.title} (${node.id}-${processId}) errored: ${error.stack}`);
-        this.#erroredNodes.set(node.id, error.toString());
+        this.#emitTraceEvent(`Node ${node.title} (${node.id}-${processId}) errored: ${error.stack}`);
+        this.#erroredNodes.set(node.id, error);
     }
     getRootProcessor() {
         let processor = this;
@@ -933,6 +1052,7 @@ export class GraphProcessor {
     }
     /** Raise a user event on the processor, all subprocessors, and their children. */
     raiseEvent(event, data) {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         this.#emitter.emit(`userEvent:${event}`, data);
         for (const subprocessor of this.#subprocessors) {
             subprocessor.raiseEvent(event, data);
@@ -940,6 +1060,7 @@ export class GraphProcessor {
     }
     #newAbortController() {
         const controller = new AbortController();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         this.#emitter.emit('newAbortController', controller);
         return controller;
     }
@@ -955,7 +1076,10 @@ export class GraphProcessor {
         let tokenizer = this.#context.tokenizer;
         if (!tokenizer) {
             tokenizer = new GptTokenizerTokenizer();
-            tokenizer.on('error', (e) => this.#emitter.emit('error', { error: e }));
+            tokenizer.on('error', (e) => {
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                this.#emitter.emit('error', { error: e });
+            });
         }
         const context = {
             ...this.#context,
@@ -967,6 +1091,8 @@ export class GraphProcessor {
             graphInputs: this.#graphInputs,
             graphOutputs: this.#graphOutputs,
             attachedData: this.#getAttachedDataTo(node),
+            codeRunner: this.#context.codeRunner ?? new IsomorphicCodeRunner(),
+            referencedProjects: this.#loadedProjects,
             waitEvent: async (event) => {
                 return new Promise((resolve, reject) => {
                     this.#emitter.once(`userEvent:${event}`).then(resolve).catch(reject);
@@ -986,6 +1112,7 @@ export class GraphProcessor {
                 if (useAsGraphPartialOutput && this.#executor && this.#parent) {
                     const executorNode = this.#parent.#nodesById[this.#executor.nodeId];
                     if (executorNode) {
+                        // eslint-disable-next-line @typescript-eslint/no-floating-promises
                         this.#emitter.emit('partialOutput', {
                             index: this.#executor.index,
                             node: executorNode,
@@ -1000,6 +1127,7 @@ export class GraphProcessor {
             getGlobal: (id) => this.#globals.get(id),
             setGlobal: (id, value) => {
                 this.#globals.set(id, value);
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this.#emitter.emit('globalSet', { id, value, processId });
             },
             waitForGlobal: async (id) => {
@@ -1009,8 +1137,8 @@ export class GraphProcessor {
                 await this.getRootProcessor().#emitter.once(`globalSet:${id}`);
                 return this.#globals.get(id);
             },
-            createSubProcessor: (subGraphId, { signal } = {}) => {
-                const processor = new GraphProcessor(this.#project, subGraphId, this.#registry);
+            createSubProcessor: (subGraphId, { signal, project } = {}) => {
+                const processor = new GraphProcessor(project ?? this.#project, subGraphId, this.#registry);
                 processor.executor = this.executor;
                 processor.#isSubProcessor = true;
                 processor.#executionCache = this.#executionCache;
@@ -1033,6 +1161,7 @@ export class GraphProcessor {
                 processor.on('graphStart', (e) => this.#emitter.emit('graphStart', e));
                 processor.on('graphFinish', (e) => this.#emitter.emit('graphFinish', e));
                 processor.on('globalSet', (e) => this.#emitter.emit('globalSet', e));
+                processor.on('newAbortController', (e) => this.#emitter.emit('newAbortController', e));
                 processor.on('pause', () => {
                     if (!this.#isPaused) {
                         this.pause();
@@ -1045,26 +1174,59 @@ export class GraphProcessor {
                 });
                 processor.onAny((event, data) => {
                     if (event.startsWith('globalSet:')) {
+                        // eslint-disable-next-line @typescript-eslint/no-floating-promises
                         this.#emitter.emit(event, data);
                     }
                 });
                 this.#subprocessors.add(processor);
                 if (signal) {
-                    signal.addEventListener('abort', () => processor.abort());
+                    signal.addEventListener('abort', () => {
+                        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                        processor.abort();
+                    });
                 }
                 // If parent is aborted, abort subgraph with error (it's fine, success state is on the parent)
-                this.#abortController.signal.addEventListener('abort', () => processor.abort());
+                this.#abortController.signal.addEventListener('abort', () => {
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    processor.abort();
+                });
                 this.on('pause', () => processor.pause());
                 this.on('resume', () => processor.resume());
                 return processor;
             },
             trace: (message) => {
-                this.#emitter.emit('trace', message);
+                this.#emitTraceEvent(message);
             },
             abortGraph: (error) => {
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this.abort(error === undefined, error);
             },
             getPluginConfig: (name) => getPluginConfig(plugin, this.#context.settings, name),
+            requestUserInput: async (inputStrings, renderingType) => {
+                const results = await new Promise((resolve, reject) => {
+                    this.#pendingUserInputs[node.id] = {
+                        resolve,
+                        reject,
+                    };
+                    this.#abortController.signal.addEventListener('abort', () => {
+                        delete this.#pendingUserInputs[node.id];
+                        reject(new Error('Processing aborted'));
+                    });
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    this.#emitter.emit('userInput', {
+                        node,
+                        inputStrings,
+                        inputs: inputValues,
+                        renderingType,
+                        callback: (results) => {
+                            resolve(results);
+                            delete this.#pendingUserInputs[node.id];
+                        },
+                        processId,
+                    });
+                });
+                return results;
+            },
         };
         await this.#waitUntilUnpaused();
         const results = await instance.process(inputValues, context);
@@ -1077,11 +1239,20 @@ export class GraphProcessor {
     }
     #excludedDueToControlFlow(node, inputValues, processId, typeOfExclusion = undefined) {
         if (node.disabled) {
-            this.#emitter.emit('trace', `Excluding node ${node.title} because it's disabled`);
+            this.#emitTraceEvent(`Excluding node ${node.title} because it's disabled`);
             this.#visitedNodes.add(node.id);
             this.#markAsExcluded(node, processId, inputValues, 'disabled');
             return true;
         }
+        if (node.isConditional && typeOfExclusion === undefined) {
+            const ifValue = coerceTypeOptional(inputValues[IF_PORT.id], 'boolean');
+            if (ifValue === false) {
+                this.#emitTraceEvent(`Excluding node ${node.title} because if port is false`);
+                this.#visitedNodes.add(node.id);
+                this.#markAsExcluded(node, processId, inputValues, 'if port is false');
+                return true;
+            }
+        }
         const inputsWithValues = entries(inputValues);
         const controlFlowExcludedValues = inputsWithValues.filter(([, value]) => value &&
             getScalarTypeOf(value.type) === 'control-flow-excluded' &&
@@ -1100,7 +1271,7 @@ export class GraphProcessor {
         if (inputIsExcludedValue && !allowedToConsumedExcludedValue) {
             if (!isWaitingForLoop) {
                 if (inputIsExcludedValue) {
-                    this.#emitter.emit('trace', `Excluding node ${node.title} because of control flow. Input is has excluded value: ${controlFlowExcludedValues[0]?.[0]}`);
+                    this.#emitTraceEvent(`Excluding node ${node.title} because of control flow. Input is has excluded value: ${controlFlowExcludedValues[0]?.[0]}`);
                 }
                 this.#visitedNodes.add(node.id);
                 this.#markAsExcluded(node, processId, inputValues, 'input is excluded value');
@@ -1119,6 +1290,7 @@ export class GraphProcessor {
             outputs['break'] = { type: 'control-flow-excluded', value: 'loop-not-broken' };
         }
         this.#nodeResults.set(node.id, outputs);
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         this.#emitter.emit('nodeExcluded', {
             node,
             processId,
@@ -1223,9 +1395,6 @@ export class GraphProcessor {
         }
         return sccs;
     }
-    #nodeIsInCycle(nodeId) {
-        return this.#nodesNotInCycle.find((node) => node.id === nodeId) == null;
-    }
     #nodesAreInSameCycle(a, b) {
         return this.#scc.find((cycle) => cycle.find((node) => node.id === a) && cycle.find((node) => node.id === b));
     }