@pikku/core 0.11.0 → 0.11.2

package/dist/wirings/workflow/graph/graph-node.d.ts

@@ -0,0 +1,122 @@
+import type { GraphNodeConfig, NextConfig, RefValue } from './workflow-graph.types.js';
+/**
+ * Standard RPC handler interface (matches generated FlattenedRPCMap entries)
+ */
+export interface RPCHandler<I = any, O = any> {
+    input: I;
+    output: O;
+}
+/**
+ * Compute output types for all nodes based on their func (RPC name)
+ */
+export type NodeOutputMap<Nodes extends Record<string, {
+    func: string;
+}>, RPCMap extends Record<string, RPCHandler>> = {
+    [K in keyof Nodes]: Nodes[K]['func'] extends keyof RPCMap ? RPCMap[Nodes[K]['func']]['output'] : unknown;
+};
+/**
+ * Node definition with RPC name reference
+ */
+export interface GraphNodeDef<RPCMap extends Record<string, RPCHandler>, NodeIds extends string = string, NodeOutputs extends Record<string, any> = Record<string, any>> {
+    /** RPC function name (must be a key in RPCMap) */
+    func: keyof RPCMap & string;
+    /** Input mapping - reference outputs from other nodes with autocomplete */
+    input?: (ref: <N extends keyof NodeOutputs & string>(nodeId: N, path: keyof NodeOutputs[N] & string) => RefValue) => Record<string, unknown>;
+    /** Next node(s) to execute */
+    next?: NextConfig<NodeIds>;
+    /** Error handling - node(s) to execute on error */
+    onError?: NodeIds | NodeIds[];
+}
+/**
+ * Helper to create a type-safe graph definition with RPC autocomplete.
+ * Pass node IDs as first type parameter for type-safe next/ref/output key completion.
+ *
+ * @example
+ * ```typescript
+ * // Import the typed graph from generated types
+ * import { pikkuWorkflowGraph, wireWorkflow } from './.pikku/workflow/pikku-workflow-types.gen.js'
+ *
+ * export const myGraph = pikkuWorkflowGraph({
+ *   name: 'myWorkflow',
+ *   nodes: {
+ *     entry: 'createUserProfile',  // autocompletes RPC names
+ *     sendWelcome: 'sendEmail',
+ *   },
+ *   config: {
+ *     entry: { next: 'sendWelcome' },
+ *     sendWelcome: {
+ *       input: (ref) => ({
+ *         to: ref('entry', 'email'),  // 'entry' and 'email' both autocomplete
+ *       }),
+ *     },
+ *   },
+ * })
+ *
+ * wireWorkflow({
+ *   wires: { http: { route: '/start', method: 'post' } },
+ *   graph: myGraph,
+ * })
+ * ```
+ */
+/**
+ * Type to compute output types for all nodes based on their func mapping
+ */
+type ComputeNodeOutputs<FuncMap extends Record<string, string>, RPCMap extends Record<string, RPCHandler>> = {
+    [K in keyof FuncMap]: FuncMap[K] extends keyof RPCMap ? RPCMap[FuncMap[K]]['output'] : unknown;
+};
+/**
+ * Type to compute input types for all nodes based on their func mapping
+ */
+type ComputeNodeInputs<FuncMap extends Record<string, string>, RPCMap extends Record<string, RPCHandler>> = {
+    [K in keyof FuncMap]: FuncMap[K] extends keyof RPCMap ? RPCMap[FuncMap[K]]['input'] : unknown;
+};
+/**
+ * Typed ref value - carries the type of the referenced field as a phantom type.
+ * At runtime this is just RefValue, but TypeScript tracks the type T.
+ */
+export type TypedRef<T> = RefValue & {
+    __phantomType?: T;
+};
+/**
+ * Map input type fields to allow TypedRef of matching type as an alternative
+ */
+type InputWithRefs<T> = {
+    [K in keyof T]: T[K] | TypedRef<T[K]>;
+};
+export declare function createGraph<RPCMap extends Record<string, RPCHandler>>(): <const FuncMap extends Record<string, keyof RPCMap & string>>(funcMap: FuncMap, nodesOrBuilder?: GraphNodeConfigMap<FuncMap, RPCMap> | ((nodes: FuncMap) => GraphNodeConfigMap<FuncMap, RPCMap>)) => Record<Extract<keyof FuncMap, string>, GraphNodeConfig<Extract<keyof FuncMap, string>>>;
+/**
+ * Type helper for node configuration map
+ */
+type GraphNodeConfigMap<FuncMap extends Record<string, string>, RPCMap extends Record<string, RPCHandler>> = {
+    [K in Extract<keyof FuncMap, string>]?: {
+        next?: NextConfig<Extract<keyof FuncMap, string>>;
+        input?: (ref: <N extends Extract<keyof FuncMap, string>, P extends keyof ComputeNodeOutputs<FuncMap, RPCMap>[N] & string>(nodeId: N, path: P) => TypedRef<ComputeNodeOutputs<FuncMap, RPCMap>[N][P]>) => InputWithRefs<ComputeNodeInputs<FuncMap, RPCMap>[K]>;
+        onError?: Extract<keyof FuncMap, string> | Extract<keyof FuncMap, string>[];
+    };
+};
+/**
+ * Untyped graph for use without RPC map.
+ * Pass node IDs as type parameter for type-safe next/ref, or omit for untyped usage.
+ *
+ * @example
+ * ```typescript
+ * // Typed usage - next and ref are type-checked
+ * graph<'entry' | 'sendWelcome'>({
+ *   entry: { func: 'createUserProfile', next: 'sendWelcome' },
+ *   sendWelcome: { func: 'sendEmail', input: (ref) => ({ to: ref('entry', 'email') }) },
+ * })
+ *
+ * // Untyped usage - no type checking on next/ref
+ * graph({
+ *   entry: { func: 'createUserProfile', next: 'sendWelcome' },
+ *   sendWelcome: { func: 'sendEmail' },
+ * })
+ * ```
+ */
+export declare function graph<NodeIds extends string = string>(nodes: Record<NodeIds, {
+    func: string;
+    next?: NextConfig<NodeIds>;
+    input?: (ref: (nodeId: NodeIds, path: string) => RefValue) => Record<string, unknown>;
+    onError?: NodeIds | NodeIds[];
+}>): Record<NodeIds, GraphNodeConfig<NodeIds>>;
+export {};

package/dist/wirings/workflow/graph/graph-node.js

@@ -0,0 +1,58 @@
+export function createGraph() {
+    return (funcMap, nodesOrBuilder) => {
+        // If no nodes provided, return just the funcMap converted to graph nodes
+        if (!nodesOrBuilder) {
+            const result = {};
+            for (const [nodeId, rpcName] of Object.entries(funcMap)) {
+                result[nodeId] = {
+                    func: rpcName,
+                };
+            }
+            return result;
+        }
+        const nodes = typeof nodesOrBuilder === 'function'
+            ? nodesOrBuilder(funcMap)
+            : nodesOrBuilder;
+        const result = {};
+        for (const [nodeId, def] of Object.entries(nodes)) {
+            result[nodeId] = {
+                func: funcMap[nodeId],
+                input: def?.input,
+                next: def?.next,
+                onError: def?.onError,
+            };
+        }
+        return result;
+    };
+}
+/**
+ * Untyped graph for use without RPC map.
+ * Pass node IDs as type parameter for type-safe next/ref, or omit for untyped usage.
+ *
+ * @example
+ * ```typescript
+ * // Typed usage - next and ref are type-checked
+ * graph<'entry' | 'sendWelcome'>({
+ *   entry: { func: 'createUserProfile', next: 'sendWelcome' },
+ *   sendWelcome: { func: 'sendEmail', input: (ref) => ({ to: ref('entry', 'email') }) },
+ * })
+ *
+ * // Untyped usage - no type checking on next/ref
+ * graph({
+ *   entry: { func: 'createUserProfile', next: 'sendWelcome' },
+ *   sendWelcome: { func: 'sendEmail' },
+ * })
+ * ```
+ */
+export function graph(nodes) {
+    const result = {};
+    for (const [nodeId, def] of Object.entries(nodes)) {
+        result[nodeId] = {
+            func: def.func,
+            input: def.input,
+            next: def.next,
+            onError: def.onError,
+        };
+    }
+    return result;
+}

package/dist/wirings/workflow/graph/graph-runner.d.ts

@@ -0,0 +1,35 @@
+import type { PikkuWorkflowService } from '../pikku-workflow-service.js';
+import type { GraphNodeConfig, WorkflowGraphDefinition } from './workflow-graph.types.js';
+/**
+ * Add a workflow graph to the system
+ * This is called by the generated workflow wirings
+ */
+export declare const addWorkflowGraph: (workflowName: string, graphResult: {
+    graph: Record<string, GraphNodeConfig<string>>;
+    wires?: any;
+}) => void;
+/**
+ * Get a registered workflow graph by name
+ */
+export declare function getWorkflowGraph(name: string): WorkflowGraphDefinition<any> | undefined;
+/**
+ * Continue graph execution
+ * Non-blocking - finds pending nodes, resolves inputs, queues them for execution
+ */
+export declare function continueGraph(workflowService: PikkuWorkflowService, runId: string, graphName: string): Promise<void>;
+/**
+ * Execute a graph step with wire context.
+ * Called by the step worker when executing graph nodes.
+ */
+export declare function executeGraphStep(workflowService: PikkuWorkflowService, rpcService: any, runId: string, stepId: string, stepName: string, rpcName: string, data: any, graphName: string): Promise<any>;
+/**
+ * Handle node completion - re-triggers graph continuation
+ */
+export declare function onGraphNodeComplete(workflowService: PikkuWorkflowService, runId: string, graphName: string): Promise<void>;
+/**
+ * Start a workflow graph execution
+ * @param startNode - Optional starting node ID (from wire config). If not provided, uses wires.api from graph definition.
+ */
+export declare function runWorkflowGraph(workflowService: PikkuWorkflowService, graphName: string, triggerInput: any, rpcService?: any, inline?: boolean, startNode?: string): Promise<{
+    runId: string;
+}>;

package/dist/wirings/workflow/graph/graph-runner.js

@@ -0,0 +1,452 @@
+import { createRef, isRef } from './workflow-graph.types.js';
+import { pikkuState } from '../../../pikku-state.js';
+/**
+ * Add a workflow graph to the system
+ * This is called by the generated workflow wirings
+ */
+export const addWorkflowGraph = (workflowName, graphResult) => {
+    // Get workflow metadata from inspector
+    const meta = pikkuState(null, 'workflows', 'meta');
+    const workflowMeta = meta[workflowName];
+    if (!workflowMeta) {
+        throw new Error(`Workflow metadata not found for '${workflowName}'. Make sure to run the CLI to generate metadata.`);
+    }
+    // Store workflow graph definition in state
+    const registrations = pikkuState(null, 'workflows', 'graphRegistrations');
+    registrations.set(workflowName, {
+        name: workflowName,
+        wires: graphResult.wires || {},
+        graph: graphResult.graph,
+    });
+};
+/**
+ * Get a registered workflow graph by name
+ */
+export function getWorkflowGraph(name) {
+    const registrations = pikkuState(null, 'workflows', 'graphRegistrations');
+    return registrations.get(name);
+}
+/**
+ * Resolve next config to array of node IDs
+ * For branching (Record), uses the branch key from step
+ */
+function resolveNextFromConfig(next, branchKey) {
+    if (!next)
+        return [];
+    if (typeof next === 'string')
+        return [next];
+    if (Array.isArray(next))
+        return next;
+    // Record (branching) - use branch key set by graph.branch()
+    if (!branchKey || !(branchKey in next))
+        return [];
+    const branchNext = next[branchKey];
+    return Array.isArray(branchNext) ? branchNext : [branchNext];
+}
+/**
+ * Check if a value is a template
+ */
+function isTemplate(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '$template' in value &&
+        typeof value.$template === 'object');
+}
+/**
+ * Create a template function for use in input callbacks
+ */
+function createTemplate(templateStr, refs) {
+    const parts = [];
+    const expressions = [];
+    const regex = /\$(\d+)/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = regex.exec(templateStr)) !== null) {
+        parts.push(templateStr.slice(lastIndex, match.index));
+        const refIndex = parseInt(match[1], 10);
+        const refValue = refs[refIndex];
+        if (refValue) {
+            expressions.push({ $ref: refValue.nodeId, path: refValue.path });
+        }
+        else {
+            expressions.push({ $ref: 'unknown' });
+        }
+        lastIndex = regex.lastIndex;
+    }
+    parts.push(templateStr.slice(lastIndex));
+    return { $template: { parts, expressions } };
+}
+/**
+ * Evaluate a node's input callback to get the input mapping
+ */
+function evaluateInputCallback(node) {
+    if (!node.input)
+        return {};
+    const ref = (targetNodeId, path) => createRef(targetNodeId, path);
+    const template = (templateStr, refs) => createTemplate(templateStr, refs);
+    // Call with both ref and template - input callback may accept 1 or 2 params
+    return node.input(ref, template);
+}
+/**
+ * Extract node IDs referenced in an input mapping (including from templates)
+ */
+function extractReferencedNodeIds(inputMapping) {
+    const nodeIds = [];
+    for (const value of Object.values(inputMapping)) {
+        if (isRef(value)) {
+            nodeIds.push(value.nodeId);
+        }
+        else if (isTemplate(value)) {
+            for (const expr of value.$template.expressions) {
+                nodeIds.push(expr.$ref);
+            }
+        }
+    }
+    return [...new Set(nodeIds)];
+}
+/**
+ * Resolve a template value using node results
+ */
+function resolveTemplate(template, nodeResults) {
+    const { parts, expressions } = template.$template;
+    let result = '';
+    for (let i = 0; i < parts.length; i++) {
+        result += parts[i];
+        if (i < expressions.length) {
+            const expr = expressions[i];
+            const nodeResult = nodeResults[expr.$ref];
+            const value = expr.path
+                ? getValueAtPath(nodeResult, expr.path)
+                : nodeResult;
+            result += String(value ?? '');
+        }
+    }
+    return result;
+}
+/**
+ * Resolve input mapping using node results
+ */
+function resolveInputMapping(inputMapping, nodeResults) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(inputMapping)) {
+        if (isRef(value)) {
+            const nodeResult = nodeResults[value.nodeId];
+            resolved[key] = value.path
+                ? getValueAtPath(nodeResult, value.path)
+                : nodeResult;
+        }
+        else if (isTemplate(value)) {
+            resolved[key] = resolveTemplate(value, nodeResults);
+        }
+        else {
+            resolved[key] = value;
+        }
+    }
+    return resolved;
+}
+/**
+ * Get value at a dot-notation path from an object
+ */
+function getValueAtPath(obj, path) {
+    if (!path)
+        return obj;
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current == null)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Get the RPC name from a graph node's func
+ * Supports both function references (func.name) and string RPC names
+ */
+function getRpcName(node) {
+    const func = node.func;
+    // If func is a string, use it directly as the RPC name
+    if (typeof func === 'string') {
+        return func;
+    }
+    // Otherwise, it's a function reference - use its name
+    return func?.name || 'unknown';
+}
+/**
+ * Queue a graph node for execution
+ */
+async function queueGraphNode(workflowService, runId, _graphName, nodeId, rpcName, input) {
+    // Step name convention: node:<nodeId>
+    // Graph name is stored as the workflow name on the run
+    await workflowService.insertStepState(runId, `node:${nodeId}`, rpcName, input, { retries: 3 });
+    await workflowService.resumeWorkflow(runId);
+}
+/**
+ * Continue graph execution
+ * Non-blocking - finds pending nodes, resolves inputs, queues them for execution
+ */
+export async function continueGraph(workflowService, runId, graphName) {
+    const definition = getWorkflowGraph(graphName);
+    if (!definition) {
+        throw new Error(`Workflow graph '${graphName}' not found`);
+    }
+    const graph = definition.graph;
+    // Get completed node IDs + branch keys (lightweight, no results)
+    const { completedNodeIds, branchKeys } = await workflowService.getCompletedGraphState(runId);
+    // Find candidate next nodes from completed nodes
+    const candidateNodes = [];
+    for (const nodeId of completedNodeIds) {
+        const node = graph[nodeId];
+        if (!node?.next)
+            continue;
+        const nextNodes = resolveNextFromConfig(node.next, branchKeys[nodeId]);
+        candidateNodes.push(...nextNodes);
+    }
+    if (candidateNodes.length === 0 && completedNodeIds.length > 0) {
+        // No more nodes to run - graph complete
+        await workflowService.updateRunStatus(runId, 'completed');
+        return;
+    }
+    // Filter to only nodes that don't have a step yet
+    const nodesToQueue = await workflowService.getNodesWithoutSteps(runId, candidateNodes);
+    // Queue each node for execution
+    for (const nodeId of nodesToQueue) {
+        const node = graph[nodeId];
+        if (!node)
+            continue;
+        // Evaluate input callback to get the mapping
+        const inputMapping = evaluateInputCallback(node);
+        // Only fetch results for nodes referenced in this node's input
+        const referencedNodeIds = extractReferencedNodeIds(inputMapping);
+        const nodeResults = await workflowService.getNodeResults(runId, referencedNodeIds);
+        const resolvedInput = resolveInputMapping(inputMapping, nodeResults);
+        const rpcName = getRpcName(node);
+        await queueGraphNode(workflowService, runId, graphName, nodeId, rpcName, resolvedInput);
+    }
+}
+/**
+ * Execute a graph step with wire context.
+ * Called by the step worker when executing graph nodes.
+ */
+export async function executeGraphStep(workflowService, rpcService, runId, stepId, stepName, rpcName, data, graphName) {
+    const nodeId = stepName.replace(/^node:/, '');
+    const wireState = {};
+    const graphWire = {
+        runId,
+        graphName,
+        nodeId,
+        branch: (key) => {
+            wireState.branchKey = key;
+        },
+        setState: (name, value) => workflowService.updateRunState(runId, name, value),
+        getState: () => workflowService.getRunState(runId),
+    };
+    try {
+        // Execute the RPC with graph wire context
+        const result = await rpcService.rpcWithWire(rpcName, data, {
+            graph: graphWire,
+        });
+        // If branch was called, store the branch key
+        if (wireState.branchKey) {
+            await workflowService.setBranchTaken(stepId, wireState.branchKey);
+        }
+        return result;
+    }
+    catch (error) {
+        // Check if this node has an onError handler
+        const definition = getWorkflowGraph(graphName);
+        if (definition) {
+            const node = definition.graph[nodeId];
+            if (node?.onError) {
+                // Route to error handler nodes
+                const errorNodes = Array.isArray(node.onError)
+                    ? node.onError
+                    : [node.onError];
+                for (const errorNodeId of errorNodes) {
+                    const errorNode = definition.graph[errorNodeId];
+                    if (errorNode) {
+                        const errorRpcName = getRpcName(errorNode);
+                        // Queue error node with the error as input
+                        await queueGraphNode(workflowService, runId, graphName, errorNodeId, errorRpcName, { error: { message: error.message } });
+                    }
+                }
+                // Don't rethrow - error was handled by routing to error nodes
+                return;
+            }
+        }
+        // No error handler - rethrow
+        throw error;
+    }
+}
+/**
+ * Handle node completion - re-triggers graph continuation
+ */
+export async function onGraphNodeComplete(workflowService, runId, graphName) {
+    await continueGraph(workflowService, runId, graphName);
+}
+/**
+ * Execute a graph node inline (without queue)
+ */
+async function executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, input, graph) {
+    const node = graph[nodeId];
+    if (!node)
+        return;
+    const rpcName = getRpcName(node);
+    const stepName = `node:${nodeId}`;
+    // Insert step state
+    const stepState = await workflowService.insertStepState(runId, stepName, rpcName, input, { retries: 3 });
+    await workflowService.setStepRunning(stepState.stepId);
+    // Execute with graph wire context
+    const wireState = {};
+    const graphWire = {
+        runId,
+        graphName,
+        nodeId,
+        branch: (key) => {
+            wireState.branchKey = key;
+        },
+        setState: (name, value) => workflowService.updateRunState(runId, name, value),
+        getState: () => workflowService.getRunState(runId),
+    };
+    try {
+        const result = await rpcService.rpcWithWire(rpcName, input, {
+            graph: graphWire,
+        });
+        // If branch was called, store the branch key
+        if (wireState.branchKey) {
+            await workflowService.setBranchTaken(stepState.stepId, wireState.branchKey);
+        }
+        await workflowService.setStepResult(stepState.stepId, result);
+    }
+    catch (error) {
+        await workflowService.setStepError(stepState.stepId, error);
+        // Check if this node has an onError handler
+        const definition = getWorkflowGraph(graphName);
+        if (definition) {
+            const node = definition.graph[nodeId];
+            if (node?.onError) {
+                // Route to error handler nodes (inline)
+                const errorNodes = Array.isArray(node.onError)
+                    ? node.onError
+                    : [node.onError];
+                await Promise.all(errorNodes.map((errorNodeId) => executeGraphNodeInline(workflowService, rpcService, runId, graphName, errorNodeId, { error: { message: error.message } }, graph)));
+                return;
+            }
+        }
+        // No error handler - rethrow
+        throw error;
+    }
+}
+/**
+ * Continue graph execution inline (without queue)
+ * Executes nodes in parallel where possible using Promise.all
+ */
+async function continueGraphInline(workflowService, rpcService, runId, graphName, graph, triggerInput) {
+    while (true) {
+        // Get completed node IDs + branch keys (lightweight, no results)
+        const { completedNodeIds, branchKeys } = await workflowService.getCompletedGraphState(runId);
+        // Find candidate next nodes from completed nodes
+        const candidateNodes = [];
+        for (const nodeId of completedNodeIds) {
+            const node = graph[nodeId];
+            if (!node?.next)
+                continue;
+            const nextNodes = resolveNextFromConfig(node.next, branchKeys[nodeId]);
+            candidateNodes.push(...nextNodes);
+        }
+        if (candidateNodes.length === 0 && completedNodeIds.length > 0) {
+            // No more nodes to run - graph complete
+            await workflowService.updateRunStatus(runId, 'completed');
+            return;
+        }
+        // Filter to only nodes that don't have a step yet
+        const nodesToExecute = await workflowService.getNodesWithoutSteps(runId, candidateNodes);
+        if (nodesToExecute.length === 0) {
+            // No more nodes to execute - if we've completed at least one node, we're done
+            // This handles branching where only some paths are taken
+            if (completedNodeIds.length > 0) {
+                await workflowService.updateRunStatus(runId, 'completed');
+            }
+            return;
+        }
+        // Execute all nodes in parallel
+        await Promise.all(nodesToExecute.map(async (nodeId) => {
+            const node = graph[nodeId];
+            if (!node)
+                return;
+            // Evaluate input callback to get the mapping
+            const inputMapping = evaluateInputCallback(node);
+            // Only fetch results for nodes referenced in this node's input (excluding trigger)
+            const referencedNodeIds = extractReferencedNodeIds(inputMapping).filter((id) => id !== 'trigger');
+            const fetchedResults = await workflowService.getNodeResults(runId, referencedNodeIds);
+            // Merge fetched results with trigger input
+            const nodeResults = { trigger: triggerInput, ...fetchedResults };
+            const resolvedInput = resolveInputMapping(inputMapping, nodeResults);
+            await executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, resolvedInput, graph);
+        }));
+    }
+}
+/**
+ * Start a workflow graph execution
+ * @param startNode - Optional starting node ID (from wire config). If not provided, uses wires.api from graph definition.
+ */
+export async function runWorkflowGraph(workflowService, graphName, triggerInput, rpcService, inline, startNode) {
+    const definition = getWorkflowGraph(graphName);
+    if (!definition) {
+        throw new Error(`Workflow graph '${graphName}' not found`);
+    }
+    // Use startNode from caller if provided, otherwise use wires.api from graph definition
+    const apiStartNode = startNode ?? definition.wires?.api;
+    const entryNodes = apiStartNode ? [apiStartNode] : [];
+    if (entryNodes.length === 0) {
+        throw new Error(`Workflow graph '${graphName}' has no wires.api defined and no startNode was provided`);
+    }
+    const graph = definition.graph;
+    const runId = await workflowService.createRun(graphName, triggerInput, inline);
+    // Register as inline for fast lookup
+    if (inline) {
+        workflowService.registerInlineRun(runId);
+    }
+    // Create nodeResults with trigger for resolving entry node inputs
+    const triggerNodeResults = { trigger: triggerInput };
+    try {
+        if (inline && rpcService) {
+            // Inline mode - execute entry nodes in parallel
+            await Promise.all(entryNodes.map(async (nodeId) => {
+                const node = graph[nodeId];
+                if (!node)
+                    return;
+                // Evaluate and resolve entry node input
+                const inputMapping = evaluateInputCallback(node);
+                const resolvedInput = Object.keys(inputMapping).length > 0
+                    ? resolveInputMapping(inputMapping, triggerNodeResults)
+                    : triggerInput;
+                await executeGraphNodeInline(workflowService, rpcService, runId, graphName, nodeId, resolvedInput, graph);
+            }));
+            // Continue executing remaining nodes inline
+            await continueGraphInline(workflowService, rpcService, runId, graphName, graph, triggerInput);
+        }
+        else {
+            // Queue-based mode
+            for (const nodeId of entryNodes) {
+                const node = graph[nodeId];
+                if (!node)
+                    continue;
+                // Evaluate and resolve entry node input
+                const inputMapping = evaluateInputCallback(node);
+                const resolvedInput = Object.keys(inputMapping).length > 0
+                    ? resolveInputMapping(inputMapping, triggerNodeResults)
+                    : triggerInput;
+                const rpcName = getRpcName(node);
+                await queueGraphNode(workflowService, runId, graphName, nodeId, rpcName, resolvedInput);
+            }
+        }
+        return { runId };
+    }
+    finally {
+        // Clean up inline tracking
+        if (inline) {
+            workflowService.unregisterInlineRun(runId);
+        }
+    }
+}

package/dist/wirings/workflow/graph/index.d.ts

@@ -0,0 +1,3 @@
+export * from './workflow-graph.types.js';
+export * from './graph-node.js';
+export * from './graph-runner.js';

package/dist/wirings/workflow/graph/index.js

@@ -0,0 +1,3 @@
+export * from './workflow-graph.types.js';
+export * from './graph-node.js';
+export * from './graph-runner.js';