@pikku/core 0.11.1 → 0.11.2

package/dist/wirings/workflow/pikku-workflow-service.d.ts

@@ -1,5 +1,35 @@
 import { CoreConfig, CoreSingletonServices, CreateWireServices, SerializedError } from '../../types/core.types.js';
-import type { StepState, WorkflowRun, WorkflowStatus, WorkflowService, WorkflowStepOptions } from './workflow.types.js';
+import type { StepState, WorkflowRun, WorkflowStatus, WorkflowStepOptions } from './workflow.types.js';
+import { WorkflowService } from '../../services/workflow-service.js';
+import { PikkuError } from '../../errors/error-handler.js';
+/**
+ * Exception thrown when workflow needs to pause for async step
+ */
+export declare class WorkflowAsyncException extends Error {
+    readonly runId: string;
+    readonly stepName: string;
+    constructor(runId: string, stepName: string);
+}
+/**
+ * Exception thrown when workflow is cancelled
+ */
+export declare class WorkflowCancelledException extends Error {
+    readonly runId: string;
+    readonly reason?: string | undefined;
+    constructor(runId: string, reason?: string | undefined);
+}
+/**
+ * Error class for workflow not found
+ */
+export declare class WorkflowNotFoundError extends PikkuError {
+    constructor(name: string);
+}
+/**
+ * Error class for workflow not found
+ */
+export declare class WorkflowRunNotFound extends PikkuError {
+    constructor(runId: string);
+}
 export declare class WorkflowServiceNotInitialized extends Error {
 }
 export declare class WorkflowStepNameNotString extends Error {
@@ -14,7 +44,20 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
     private config;
     private singletonServices;
     private createWireServices;
+    private inlineRuns;
     constructor();
+    /**
+     * Check if a run is executing inline (without queues)
+     */
+    protected isInline(runId: string): boolean;
+    /**
+     * Register a run as inline (for graph-runner to use)
+     */
+    registerInlineRun(runId: string): void;
+    /**
+     * Unregister a run from inline tracking
+     */
+    unregisterInlineRun(runId: string): void;
     setServices(singletonServices: CoreSingletonServices, createWireServices: CreateWireServices, { workflow }: CoreConfig): void;
     /**
      * Create a new workflow run
@@ -22,7 +65,7 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      * @param input - Input data for the workflow
      * @returns Run ID
      */
-    abstract createRun(workflowName: string, input: any): Promise<string>;
+    abstract createRun(workflowName: string, input: any, inline?: boolean): Promise<string>;
     /**
      * Get a workflow run by ID
      * @param id - Run ID
@@ -115,6 +158,48 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      * Close any open connections
      */
     abstract close(): Promise<void>;
+    /**
+     * Get completed graph state (lightweight - no results)
+     * @param runId - Run ID
+     * @returns Completed node IDs and their branch keys
+     */
+    abstract getCompletedGraphState(runId: string): Promise<{
+        completedNodeIds: string[];
+        branchKeys: Record<string, string>;
+    }>;
+    /**
+     * Filter candidate nodes to only those without existing steps
+     * @param runId - Run ID
+     * @param nodeIds - Candidate node IDs to check
+     * @returns Node IDs that don't have a step yet
+     */
+    abstract getNodesWithoutSteps(runId: string, nodeIds: string[]): Promise<string[]>;
+    /**
+     * Get results for specific nodes
+     * @param runId - Run ID
+     * @param nodeIds - Node IDs to fetch results for
+     * @returns Map of nodeId to result
+     */
+    abstract getNodeResults(runId: string, nodeIds: string[]): Promise<Record<string, any>>;
+    /**
+     * Set the branch key for a graph node step
+     * @param stepId - Step ID
+     * @param branchKey - Branch key selected by graph.branch()
+     */
+    abstract setBranchTaken(stepId: string, branchKey: string): Promise<void>;
+    /**
+     * Update a state variable in the workflow run's state
+     * @param runId - Run ID
+     * @param name - Variable name
+     * @param value - Value to store
+     */
+    abstract updateRunState(runId: string, name: string, value: unknown): Promise<void>;
+    /**
+     * Get the entire state object for a workflow run
+     * @param runId - Run ID
+     * @returns The state object with all variables
+     */
+    abstract getRunState(runId: string): Promise<Record<string, unknown>>;
     /**
      * Resume a paused workflow by triggering the orchestrator
      * @param runId - Run ID
@@ -125,7 +210,7 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      * Sets the step result to null and resumes the workflow
      * @param data - Sleeper input data
      */
-    executeWorkflowSleep(runId: string, stepId: string): Promise<void>;
+    executeWorkflowSleepCompleted(runId: string, stepId: string): Promise<void>;
     /**
      * Schedule orchestrator retry with delay
      * @param runId - Run ID
@@ -134,8 +219,14 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
     protected scheduleOrchestratorRetry(runId: string, retryDelay?: number | string): Promise<void>;
     /**
      * Start a new workflow run
-     */
-    startWorkflow<I>(name: string, input: I, rpcService: any): Promise<{
+     * Automatically detects workflow type (DSL or graph) from meta and executes accordingly
+     * @param options.inline - If true, execute workflow directly without queue service
+     * @param options.startNode - Starting node ID for graph workflows (from wire config)
+     */
+    startWorkflow<I>(name: string, input: I, rpcService: any, options?: {
+        inline?: boolean;
+        startNode?: string;
+    }): Promise<{
         runId: string;
     }>;
     runWorkflowJob(runId: string, rpcService: any): Promise<void>;
@@ -153,7 +244,6 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
     private rpcStep;
     private inlineStep;
     private sleepStep;
-    private cancelWorkflow;
     private createWorkflowWire;
     private verifyStepName;
     private getConfig;

package/dist/wirings/workflow/pikku-workflow-service.js

@@ -1,7 +1,50 @@
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { getDurationInMilliseconds } from '../../time-utils.js';
-import { WorkflowAsyncException, WorkflowCancelledException, WorkflowNotFoundError, WorkflowRunNotFound, } from './workflow-runner.js';
+import { executeGraphStep, runWorkflowGraph } from './graph/graph-runner.js';
+import { PikkuError } from '../../errors/error-handler.js';
+/**
+ * Exception thrown when workflow needs to pause for async step
+ */
+export class WorkflowAsyncException extends Error {
+    runId;
+    stepName;
+    constructor(runId, stepName) {
+        super(`Workflow paused at step: ${stepName}`);
+        this.runId = runId;
+        this.stepName = stepName;
+        this.name = 'WorkflowAsyncException';
+    }
+}
+/**
+ * Exception thrown when workflow is cancelled
+ */
+export class WorkflowCancelledException extends Error {
+    runId;
+    reason;
+    constructor(runId, reason) {
+        super(reason || 'Workflow cancelled');
+        this.runId = runId;
+        this.reason = reason;
+        this.name = 'WorkflowCancelledException';
+    }
+}
+/**
+ * Error class for workflow not found
+ */
+export class WorkflowNotFoundError extends PikkuError {
+    constructor(name) {
+        super(`Workflow not found: ${name}`);
+    }
+}
+/**
+ * Error class for workflow not found
+ */
+export class WorkflowRunNotFound extends PikkuError {
+    constructor(runId) {
+        super(`Workflow run not found: ${runId}`);
+    }
+}
 export class WorkflowServiceNotInitialized extends Error {
 }
 export class WorkflowStepNameNotString extends Error {
@@ -18,7 +61,26 @@ export class PikkuWorkflowService {
     config;
     singletonServices;
     createWireServices;
+    inlineRuns = new Set();
     constructor() { }
+    /**
+     * Check if a run is executing inline (without queues)
+     */
+    isInline(runId) {
+        return this.inlineRuns.has(runId);
+    }
+    /**
+     * Register a run as inline (for graph-runner to use)
+     */
+    registerInlineRun(runId) {
+        this.inlineRuns.add(runId);
+    }
+    /**
+     * Unregister a run from inline tracking
+     */
+    unregisterInlineRun(runId) {
+        this.inlineRuns.delete(runId);
+    }
     setServices(singletonServices, createWireServices, { workflow }) {
         this.singletonServices = singletonServices;
         this.createWireServices = createWireServices;
@@ -27,7 +89,7 @@ export class PikkuWorkflowService {
             retryDelay: workflow?.retryDelay ?? 0,
             orchestratorQueueName: workflow?.orchestratorQueueName ?? 'pikku-workflow-orchestrator',
             stepWorkerQueueName: workflow?.stepWorkerQueueName ?? 'pikku-workflow-step-worker',
-            sleeperRPCName: workflow?.sleeperRPCName ?? 'pikkuWorkflowStepSleeper',
+            sleeperRPCName: workflow?.sleeperRPCName ?? 'pikkuWorkflowSleeper',
         };
     }
     // ============================================================================
@@ -46,7 +108,7 @@ export class PikkuWorkflowService {
      * Sets the step result to null and resumes the workflow
      * @param data - Sleeper input data
      */
-    async executeWorkflowSleep(runId, stepId) {
+    async executeWorkflowSleepCompleted(runId, stepId) {
         await this.setStepResult(stepId, null);
         await this.resumeWorkflow(runId);
     }
@@ -61,44 +123,69 @@ export class PikkuWorkflowService {
     }
     /**
      * Start a new workflow run
+     * Automatically detects workflow type (DSL or graph) from meta and executes accordingly
+     * @param options.inline - If true, execute workflow directly without queue service
+     * @param options.startNode - Starting node ID for graph workflows (from wire config)
      */
-    async startWorkflow(name, input, rpcService) {
-        const registrations = pikkuState('workflows', 'registrations');
+    async startWorkflow(name, input, rpcService, options) {
+        // Check meta to determine workflow type
+        const meta = pikkuState(null, 'workflows', 'meta');
+        const workflowMeta = meta[name];
+        if (!workflowMeta) {
+            throw new WorkflowNotFoundError(name);
+        }
+        // Check if this is a graph workflow (source === 'graph')
+        if (workflowMeta.source === 'graph') {
+            // Graph workflows use the graph scheduler
+            return runWorkflowGraph(this, name, input, rpcService, options?.inline, options?.startNode);
+        }
+        // DSL workflow - check registration exists
+        const registrations = pikkuState(null, 'workflows', 'registrations');
         const workflow = registrations.get(name);
         if (!workflow) {
             throw new WorkflowNotFoundError(name);
         }
         // Create workflow run in state
-        const runId = await this.createRun(name, input);
-        // If queue service is available, use remote execution (queue-based)
-        // Otherwise, execute directly (inline/synchronous)
-        if (this.singletonServices?.queueService) {
-            // Queue orchestrator to start the workflow
-            await this.resumeWorkflow(runId);
+        const runId = await this.createRun(name, input, options?.inline);
+        // Register inline run for fast lookup
+        if (options?.inline) {
+            this.inlineRuns.add(runId);
         }
-        else {
-            // No queue service - execute directly via runWorkflowJob
-            await this.runWorkflowJob(runId, rpcService);
+        try {
+            // If inline mode or no queue service, execute directly
+            // Otherwise, use remote execution (queue-based)
+            if (options?.inline || !this.singletonServices?.queueService) {
+                await this.runWorkflowJob(runId, rpcService);
+            }
+            else {
+                await this.resumeWorkflow(runId);
+            }
+            return { runId };
+        }
+        finally {
+            // Clean up inline tracking
+            if (options?.inline) {
+                this.inlineRuns.delete(runId);
+            }
         }
-        return { runId };
     }
     async runWorkflowJob(runId, rpcService) {
         const run = await this.getRun(runId);
         if (!run) {
             throw new WorkflowRunNotFound(runId);
         }
-        const registrations = pikkuState('workflows', 'registrations');
+        const registrations = pikkuState(null, 'workflows', 'registrations');
         const workflow = registrations.get(run.workflow);
         if (!workflow) {
             throw new WorkflowNotFoundError(run.workflow);
         }
         await this.withRunLock(runId, async () => {
-            const meta = pikkuState('workflows', 'meta');
+            const meta = pikkuState(null, 'workflows', 'meta');
             const workflowMeta = meta[run.workflow];
             const workflowWire = this.createWorkflowWire(run.workflow, runId, rpcService);
             const wire = { workflow: workflowWire };
             try {
-                const result = await runPikkuFunc('workflow', workflowMeta.workflowName, workflowMeta.pikkuFuncName, {
+                const result = await runPikkuFunc('workflow', workflowMeta.name, workflowMeta.pikkuFuncName, {
                     singletonServices: this.singletonServices,
                     wire,
                     createWireServices: this.createWireServices,
@@ -113,7 +200,12 @@ export class PikkuWorkflowService {
                 }
                 // Check if it's a WorkflowCancelledException
                 if (error instanceof WorkflowCancelledException) {
-                    // Workflow was cancelled - status already updated, just rethrow
+                    // Workflow was cancelled - update status and rethrow
+                    await this.updateRunStatus(runId, 'cancelled', undefined, {
+                        message: error.message || 'Workflow cancelled',
+                        stack: '',
+                        code: 'WORKFLOW_CANCELLED',
+                    });
                     throw error;
                 }
                 await this.updateRunStatus(runId, 'failed', undefined, {
@@ -152,23 +244,32 @@ export class PikkuWorkflowService {
                 await this.setStepRunning(stepState.stepId);
             }
             try {
-                // Execute RPC with workflow step context
-                const result = await rpcService.rpcWithWire(rpcName, data, {
-                    workflowStep: {
-                        runId,
-                        stepId: stepState.stepId,
-                        attemptCount: stepState.attemptCount,
-                    },
-                });
+                let result;
+                // Check if this is a graph node step (step name starts with 'node:')
+                if (stepName.startsWith('node:')) {
+                    // Get the graph name from the workflow run
+                    const run = await this.getRun(runId);
+                    if (!run) {
+                        throw new Error(`Workflow run not found: ${runId}`);
+                    }
+                    const graphName = run.workflow;
+                    // Execute as graph step with graph wire context
+                    result = await executeGraphStep(this, rpcService, runId, stepState.stepId, stepName, rpcName, data, graphName);
+                }
+                else {
+                    // Execute RPC with workflow step context (regular workflow)
+                    result = await rpcService.rpcWithWire(rpcName, data, {
+                        workflowStep: {
+                            runId,
+                            stepId: stepState.stepId,
+                            attemptCount: stepState.attemptCount,
+                        },
+                    });
+                }
                 // Store result and mark succeeded
                 await this.setStepResult(stepState.stepId, result);
                 // Resume orchestrator to continue workflow
-                try {
-                    await this.resumeWorkflow(runId);
-                }
-                catch (resumeError) {
-                    throw resumeError;
-                }
+                await this.resumeWorkflow(runId);
             }
             catch (error) {
                 // Store error and mark failed
@@ -218,7 +319,7 @@ export class PikkuWorkflowService {
         try {
             stepState = await this.getStepState(runId, stepName);
         }
-        catch (error) {
+        catch {
             // Step doesn't exist - create it
             stepState = await this.insertStepState(runId, stepName, rpcName, data, stepOptions);
         }
@@ -242,8 +343,8 @@ export class PikkuWorkflowService {
         }
         // Step is pending - schedule it
         await this.setStepScheduled(stepState.stepId);
-        // Enqueue step worker
-        if (this.singletonServices.queueService) {
+        // Enqueue step worker (unless inline mode)
+        if (!this.isInline(runId) && this.singletonServices.queueService) {
             // Map step retry options to queue job options
             const retries = stepOptions?.retries ?? 0;
             const retryDelay = stepOptions?.retryDelay;
@@ -262,41 +363,47 @@ export class PikkuWorkflowService {
                         ? 'exponential'
                         : undefined,
             });
+            // Pause workflow - step will callback when done
+            throw new WorkflowAsyncException(runId, stepName);
         }
         else {
-            // No queue service - execute locally
+            // Inline or no queue service - execute locally with retry loop
             const retries = stepOptions?.retries ?? 0;
             const retryDelay = stepOptions?.retryDelay;
-            const attemptCount = stepState.attemptCount;
-            try {
-                const result = await rpcService.rpcWithWire(rpcName, data, {
-                    workflowStep: {
-                        runId,
-                        stepId: stepState.stepId,
-                        attemptCount: stepState.attemptCount,
-                    },
-                });
-                await this.setStepResult(stepState.stepId, result);
-                return result;
-            }
-            catch (error) {
-                // Record the error (marks step as failed)
-                await this.setStepError(stepState.stepId, error);
-                // Check if we should retry
-                if (attemptCount < retries) {
-                    // Create a new pending retry attempt (copies metadata from failed step)
-                    await this.createRetryAttempt(stepState.stepId, 'pending');
-                    // Schedule orchestrator to retry after delay
-                    await this.scheduleOrchestratorRetry(runId, retryDelay);
-                    // Pause workflow - orchestrator will replay and pick up new attempt
-                    throw new WorkflowAsyncException(runId, stepName);
+            let currentStepState = stepState;
+            while (true) {
+                try {
+                    await this.setStepRunning(currentStepState.stepId);
+                    const result = await rpcService.rpcWithWire(rpcName, data, {
+                        workflowStep: {
+                            runId,
+                            stepId: currentStepState.stepId,
+                            attemptCount: currentStepState.attemptCount,
+                        },
+                    });
+                    await this.setStepResult(currentStepState.stepId, result);
+                    return result;
+                }
+                catch (error) {
+                    // Record the error (marks step as failed)
+                    await this.setStepError(currentStepState.stepId, error);
+                    // Check if we should retry
+                    if (currentStepState.attemptCount < retries) {
+                        // Create a new pending retry attempt
+                        currentStepState = await this.createRetryAttempt(currentStepState.stepId, 'pending');
+                        // Wait for retry delay if specified
+                        if (retryDelay) {
+                            await new Promise((resolve) => setTimeout(resolve, getDurationInMilliseconds(retryDelay)));
+                        }
+                        // Continue loop to retry
+                    }
+                    else {
+                        // No more retries, fail the workflow
+                        throw error;
+                    }
                 }
-                // No more retries, fail the workflow
-                throw error;
             }
         }
-        // Pause workflow - step will callback when done
-        throw new WorkflowAsyncException(runId, stepName);
     }
     async inlineStep(runId, stepName, fn, stepOptions) {
         // Check if step already exists
@@ -304,7 +411,7 @@ export class PikkuWorkflowService {
         try {
             stepState = await this.getStepState(runId, stepName);
         }
-        catch (error) {
+        catch {
             // Step doesn't exist - create it (inline, no RPC)
             stepState = await this.insertStepState(runId, stepName, null, // No RPC for inline steps
             null, // No data for inline steps
@@ -317,26 +424,60 @@ export class PikkuWorkflowService {
         // Execute inline function
         const retries = stepOptions?.retries ?? this.getConfig().retries;
         const retryDelay = stepOptions?.retryDelay ?? this.getConfig().retryDelay;
-        const attemptCount = stepState.attemptCount;
-        try {
-            const result = await fn();
-            await this.setStepResult(stepState.stepId, result);
-            return result;
+        let currentStepState = stepState;
+        // Check if we're running inline (in-memory) or remote (queue-based)
+        if (this.isInline(runId)) {
+            // Inline mode - execute with retry loop
+            while (true) {
+                try {
+                    await this.setStepRunning(currentStepState.stepId);
+                    const result = await fn();
+                    await this.setStepResult(currentStepState.stepId, result);
+                    return result;
+                }
+                catch (error) {
+                    // Record the error (marks step as failed)
+                    await this.setStepError(currentStepState.stepId, error);
+                    // Check if we should retry
+                    if (currentStepState.attemptCount < retries) {
+                        // Create a new pending retry attempt
+                        currentStepState = await this.createRetryAttempt(currentStepState.stepId, 'pending');
+                        // Wait for retry delay if specified
+                        if (retryDelay) {
+                            await new Promise((resolve) => setTimeout(resolve, getDurationInMilliseconds(retryDelay)));
+                        }
+                        // Continue loop to retry
+                    }
+                    else {
+                        // No more retries, fail the workflow
+                        throw error;
+                    }
+                }
+            }
         }
-        catch (error) {
-            // Record the error (marks step as failed)
-            await this.setStepError(stepState.stepId, error);
-            // Check if we should retry
-            if (attemptCount < retries) {
-                // Create a new pending retry attempt (copies metadata from failed step)
-                await this.createRetryAttempt(stepState.stepId, 'pending');
-                // Schedule orchestrator to retry after delay
-                await this.scheduleOrchestratorRetry(runId, retryDelay);
-                // Pause workflow - orchestrator will replay and pick up new attempt
-                throw new WorkflowAsyncException(runId, stepName);
+        else {
+            // Remote mode - use queue-based retry
+            try {
+                await this.setStepRunning(currentStepState.stepId);
+                const result = await fn();
+                await this.setStepResult(currentStepState.stepId, result);
+                return result;
+            }
+            catch (error) {
+                // Record the error (marks step as failed)
+                await this.setStepError(currentStepState.stepId, error);
+                // Check if we should retry
+                if (currentStepState.attemptCount < retries) {
+                    // Create a new pending retry attempt (copies metadata from failed step)
+                    await this.createRetryAttempt(currentStepState.stepId, 'pending');
+                    // Schedule orchestrator to retry after delay
+                    await this.scheduleOrchestratorRetry(runId, retryDelay);
+                    // Pause workflow - orchestrator will replay and pick up new attempt
+                    throw new WorkflowAsyncException(runId, stepName);
+                }
+                // No more retries, fail the workflow
+                throw error;
             }
-            // No more retries, fail the workflow
-            throw error;
         }
     }
     async sleepStep(runId, stepName, duration) {
@@ -345,7 +486,7 @@ export class PikkuWorkflowService {
         try {
             stepState = await this.getStepState(runId, stepName);
         }
-        catch (error) {
+        catch {
             // Step doesn't exist - create it (sleep step, no RPC)
             stepState = await this.insertStepState(runId, stepName, null, // No RPC for sleep steps
             { duration }, // Store duration as data
@@ -362,13 +503,15 @@ export class PikkuWorkflowService {
         }
         // Step is pending - schedule it
         await this.setStepScheduled(stepState.stepId);
-        // Check if we have queue service (remote mode) or inline mode
-        if (this.singletonServices.schedulerService) {
-            // Remote mode - enqueue sleep worker with delay
+        // Check if inline mode or no scheduler service
+        if (!this.isInline(runId) && this.singletonServices.schedulerService) {
+            // Remote mode - schedule sleep via scheduler service
             await this.singletonServices.schedulerService.scheduleRPC(duration, this.getConfig().sleeperRPCName, {
                 runId,
                 stepId: stepState.stepId,
             });
+            // Pause workflow - sleep will callback when done
+            throw new WorkflowAsyncException(runId, stepName);
         }
         else {
             // Inline mode - use setTimeout with actual duration
@@ -376,18 +519,6 @@ export class PikkuWorkflowService {
             await this.setStepResult(stepState.stepId, null);
             return;
         }
-        // Pause workflow - sleep will callback when done
-        throw new WorkflowAsyncException(runId, stepName);
-    }
-    async cancelWorkflow(runId, reason) {
-        // Update workflow run status to cancelled
-        await this.updateRunStatus(runId, 'cancelled', undefined, {
-            message: reason || 'Workflow cancelled by user',
-            stack: '',
-            code: 'WORKFLOW_CANCELLED',
-        });
-        // Throw cancellation exception to stop workflow execution
-        throw new WorkflowCancelledException(runId, reason);
     }
     createWorkflowWire(workflowName, runId, rpcService) {
         const workflowWire = {
@@ -409,10 +540,6 @@ export class PikkuWorkflowService {
                 this.verifyStepName(stepName);
                 await this.sleepStep(runId, stepName, getDurationInMilliseconds(duration));
             },
-            // Implement workflow.cancel()
-            cancel: async (reason) => {
-                await this.cancelWorkflow(runId, reason);
-            },
         };
         return workflowWire;
     }

package/dist/wirings/workflow/wire-workflow.d.ts

@@ -0,0 +1,42 @@
+import type { WorkflowWires } from './workflow.types.js';
+import type { GraphNodeConfig } from './graph/workflow-graph.types.js';
+/**
+ * Workflow definition with DSL function
+ */
+export interface WorkflowDefinitionFunc {
+    wires: WorkflowWires;
+    func: {
+        func: (...args: any[]) => any;
+    } | ((...args: any[]) => any);
+}
+/**
+ * Workflow definition with graph
+ */
+export interface WorkflowDefinitionGraph<T extends Record<string, GraphNodeConfig<string>> = Record<string, GraphNodeConfig<string>>> {
+    wires: WorkflowWires;
+    graph: T;
+}
+/**
+ * Union type for workflow definitions
+ */
+export type WorkflowDefinition<T extends Record<string, GraphNodeConfig<string>> = Record<string, GraphNodeConfig<string>>> = WorkflowDefinitionFunc | WorkflowDefinitionGraph<T>;
+/**
+ * Wire a workflow with triggers.
+ * Accepts either a DSL function (func) or a graph definition (graph).
+ *
+ * @example
+ * ```typescript
+ * // DSL workflow
+ * wireWorkflow({
+ *   wires: { http: { route: '/start', method: 'post' } },
+ *   func: myWorkflowFunc,
+ * })
+ *
+ * // Graph workflow
+ * wireWorkflow({
+ *   wires: { http: { route: '/graph-start', method: 'post' } },
+ *   graph: myGraphWorkflow,
+ * })
+ * ```
+ */
+export declare function wireWorkflow<T extends Record<string, GraphNodeConfig<string>>>(definition: WorkflowDefinitionFunc | WorkflowDefinitionGraph<T>): void;