@bratsos/workflow-engine 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,11 +1,11 @@
-import { createAIHelper } from './chunk-P4KMGCT3.js';
+import { ModelKey } from './chunk-P4KMGCT3.js';
 export { AVAILABLE_MODELS, AnthropicBatchProvider, DEFAULT_MODEL_KEY, GoogleBatchProvider, ModelKey, ModelStatsTracker, NoInputSchema, OpenAIBatchProvider, calculateCost, createAIHelper, defineAsyncBatchStage, defineStage, getBestProviderForModel, getDefaultModel, getModel, getModelById, getRegisteredModel, listModels, listRegisteredModels, modelSupportsBatch, printAvailableModels, registerModels, requireStageOutput, resolveModelForProvider } from './chunk-P4KMGCT3.js';
 import './chunk-D7RVRRM2.js';
-export { PrismaAICallLogger, PrismaJobQueue, PrismaWorkflowPersistence, createPrismaAICallLogger, createPrismaJobQueue, createPrismaWorkflowPersistence } from './chunk-7IITBLFY.js';
-import { createLogger } from './chunk-MUWP5SF2.js';
+export { PrismaAICallLogger, PrismaJobQueue, PrismaWorkflowPersistence, createPrismaAICallLogger, createPrismaJobQueue, createPrismaWorkflowPersistence } from './chunk-NYKMT46J.js';
+import './chunk-MUWP5SF2.js';
+export { StaleVersionError } from './chunk-SPXBCZLB.js';
+export { IdempotencyInProgressError, createKernel, createPluginRunner, definePlugin } from './chunk-HL3OJG7W.js';
 import { z } from 'zod';
-import { EventEmitter } from 'events';
-import os from 'os';
 
 var Workflow = class {
   constructor(id, name, description, inputSchema, outputSchema, stages, contextType) {
@@ -350,2038 +350,50 @@ var WorkflowBuilder = class {
     return this.currentExecutionGroup;
   }
 };
-z.object({
-  batchId: z.string(),
-  statusUrl: z.string().optional(),
-  apiKey: z.string().optional(),
-  submittedAt: z.string(),
-  // ISO date string
-  pollInterval: z.number(),
-  // milliseconds
-  maxWaitTime: z.number(),
-  // milliseconds
-  metadata: z.record(z.string(), z.unknown()).optional()
-});
-function isSuspendedResult(result) {
-  return "suspended" in result && result.suspended === true;
-}
-var logger = createLogger("WorkflowEventBus");
-var WorkflowEventBus = class _WorkflowEventBus extends EventEmitter {
-  static instance;
-  pgNotify = null;
-  static PG_CHANNEL = "workflow_events";
-  pgListenerUnsubscribe = null;
-  // PostgreSQL NOTIFY has an 8000 byte limit for payloads
-  // We use 7500 to leave room for encoding overhead
-  static MAX_PAYLOAD_SIZE = 7500;
-  constructor() {
-    super();
-    this.setMaxListeners(1e3);
-  }
-  static getInstance() {
-    if (!_WorkflowEventBus.instance) {
-      _WorkflowEventBus.instance = new _WorkflowEventBus();
-    }
-    return _WorkflowEventBus.instance;
-  }
-  /**
-   * Enable cross-process event publishing via PostgreSQL NOTIFY
-   *
-   * Call this during process initialization to enable events to propagate
-   * across multiple workers and the React Router app.
-   *
-   * @param pgNotify - A connected PgNotify instance from @zertai/database
-   */
-  async enablePgNotify(pgNotify) {
-    if (this.pgNotify) {
-      logger.warn("PgNotify already enabled, skipping");
-      return;
-    }
-    this.pgNotify = pgNotify;
-    this.pgListenerUnsubscribe = await pgNotify.listen(
-      _WorkflowEventBus.PG_CHANNEL,
-      (_channel, payload) => {
-        try {
-          const event = JSON.parse(payload);
-          this.emitLocally(event);
-        } catch (err) {
-          logger.error("Failed to parse pg notification:", err);
-        }
-      }
-    );
-    logger.info("Cross-process events enabled via PostgreSQL NOTIFY");
-  }
-  /**
-   * Disable cross-process events (for cleanup)
-   */
-  disablePgNotify() {
-    if (this.pgListenerUnsubscribe) {
-      this.pgListenerUnsubscribe();
-      this.pgListenerUnsubscribe = null;
-    }
-    this.pgNotify = null;
-  }
-  /**
-   * Check if cross-process events are enabled
-   */
-  isPgNotifyEnabled() {
-    return this.pgNotify !== null && this.pgNotify.isConnected();
-  }
-  /**
-   * Truncate event payload to fit within PostgreSQL NOTIFY size limits.
-   * Large data fields (like workflow output) are replaced with a truncation marker.
-   */
-  truncatePayloadForNotify(event) {
-    const serialized = JSON.stringify(event);
-    if (serialized.length <= _WorkflowEventBus.MAX_PAYLOAD_SIZE) {
-      return event;
-    }
-    const truncatedData = {};
-    const keysToPreserve = [
-      "workflowRunId",
-      "stageId",
-      "stageName",
-      "stageNumber",
-      "error",
-      "level",
-      "message",
-      "duration",
-      "cost"
-    ];
-    for (const key of keysToPreserve) {
-      if (key in event.data) {
-        truncatedData[key] = event.data[key];
-      }
-    }
-    truncatedData._truncated = true;
-    truncatedData._originalSize = serialized.length;
-    return {
-      ...event,
-      data: truncatedData
-    };
-  }
-  /**
-   * Emit event locally only (used for re-emitting pg notifications)
-   */
-  emitLocally(event) {
-    const eventName = `workflow:${event.workflowRunId}:${event.type}`;
-    this.emit(eventName, event);
-    this.emit(`workflow:${event.workflowRunId}:*`, event);
-    this.emit(event.type, event);
-  }
-  /**
-   * Emit a workflow event with proper namespacing
-   *
-   * When PgNotify is enabled, also publishes to PostgreSQL for cross-process
-   * consumption by other workers and the React Router app.
-   */
-  emitWorkflowEvent(workflowRunId, eventType, payload) {
-    const sseEvent = {
-      type: eventType,
-      workflowRunId,
-      timestamp: /* @__PURE__ */ new Date(),
-      data: payload
-    };
-    this.emitLocally(sseEvent);
-    if (this.pgNotify) {
-      const notifyEvent = this.truncatePayloadForNotify(sseEvent);
-      this.pgNotify.notify(_WorkflowEventBus.PG_CHANNEL, JSON.stringify(notifyEvent)).catch((err) => {
-        logger.error("Pg notify failed:", err);
-      });
-    }
-  }
-  /**
-   * Subscribe to all events for a specific workflow run
-   */
-  subscribeToWorkflow(workflowRunId, handler) {
-    const eventName = `workflow:${workflowRunId}:*`;
-    this.on(eventName, handler);
-    return () => {
-      this.off(eventName, handler);
-    };
-  }
-  /**
-   * Subscribe to a specific event type globally (across all workflows)
-   */
-  subscribeGlobal(eventType, handler) {
-    this.on(eventType, handler);
-    return () => {
-      this.off(eventType, handler);
-    };
-  }
-  /**
-   * Subscribe to a specific event type for a workflow
-   */
-  subscribeToEvent(workflowRunId, eventType, handler) {
-    const eventName = `workflow:${workflowRunId}:${eventType}`;
-    this.on(eventName, handler);
-    return () => {
-      this.off(eventName, handler);
-    };
-  }
-};
-var workflowEventBus = WorkflowEventBus.getInstance();
-
-// src/core/executor.ts
-var logger2 = createLogger("Executor");
-var NoOpAICallLogger = class {
-  logCall() {
-  }
-  async logBatchResults() {
-  }
-  async getStats() {
-    return {
-      totalCalls: 0,
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalCost: 0,
-      perModel: {}
-    };
-  }
-  async isRecorded() {
-    return false;
-  }
-};
-var WorkflowExecutor = class extends EventEmitter {
-  constructor(workflow, workflowRunId, workflowType, storageProviderOrOptions) {
-    super();
-    this.workflow = workflow;
-    this.workflowRunId = workflowRunId;
-    this.workflowType = workflowType;
-    let persistence;
-    let aiLogger;
-    if (typeof storageProviderOrOptions === "object" && storageProviderOrOptions !== null) {
-      persistence = storageProviderOrOptions.persistence;
-      aiLogger = storageProviderOrOptions.aiLogger;
-    }
-    if (!persistence) {
-      throw new Error(
-        "WorkflowExecutor requires persistence to be provided via options. Create an instance using PrismaWorkflowPersistence or InMemoryWorkflowPersistence."
-      );
-    }
-    this.persistence = persistence;
-    this.aiLogger = aiLogger ?? new NoOpAICallLogger();
-  }
-  cancelled = false;
-  persistence;
-  aiLogger;
-  /**
-   * Override emit to also forward events to the global event bus for SSE
-   */
-  emit(eventName, ...args) {
-    const eventType = String(eventName);
-    if (args[0] && typeof args[0] === "object") {
-      workflowEventBus.emitWorkflowEvent(
-        this.workflowRunId,
-        eventType,
-        args[0]
-      );
-    }
-    return super.emit(eventName, ...args);
-  }
-  /**
-   * Check if the workflow has been interrupted (cancelled or suspended) externally
-   * This checks the database status to detect external requests
-   */
-  async checkExternalInterruption() {
-    if (this.cancelled) {
-      return { type: "cancelled", reason: "Cancelled by local request" };
-    }
-    try {
-      const status = await this.persistence.getRunStatus(this.workflowRunId);
-      if (status === "CANCELLED") {
-        this.cancelled = true;
-        return { type: "cancelled", reason: "Cancelled by external request" };
-      }
-      if (status === "SUSPENDED") {
-        return { type: "suspended", reason: "Suspended by external request" };
-      }
-      return null;
-    } catch (error) {
-      logger2.error("Error checking interruption status:", error);
-      return null;
-    }
-  }
-  /**
-   * Execute the workflow
-   *
-   * @param input - Workflow input data
-   * @param config - Configuration for each stage (keyed by stage ID)
-   * @param options - Execution options (resume, etc.)
-   * @returns Final output or 'suspended' if workflow is suspended
-   */
-  async execute(input, config, options = {}) {
-    try {
-      const configValidation = this.workflow.validateConfig(config);
-      if (!configValidation.valid) {
-        const errorMessages = configValidation.errors.map((e) => `  - ${e.stageId}: ${e.error}`).join("\n");
-        throw new Error(`Workflow config validation failed:
-${errorMessages}`);
-      }
-      await this.persistence.updateRun(this.workflowRunId, {
-        status: "RUNNING",
-        startedAt: /* @__PURE__ */ new Date()
-      });
-      this.emit("workflow:started", {
-        workflowRunId: this.workflowRunId,
-        workflowName: this.workflow.name
-      });
-      this.log("INFO", `Starting workflow: ${this.workflow.name}`);
-      let startGroupNumber = 1;
-      let currentOutput = input;
-      let workflowContext = {};
-      if (options.resume) {
-        const resumeData = await this.loadResumeState();
-        if (resumeData) {
-          startGroupNumber = resumeData.lastCompletedGroup + 1;
-          currentOutput = resumeData.lastOutput;
-          workflowContext = await this.loadWorkflowContext();
-          this.log("INFO", `Resuming from execution group ${startGroupNumber}`);
-          this.log(
-            "INFO",
-            `Loaded ${Object.keys(workflowContext).length} previous stage outputs into context`
-          );
-        }
-      }
-      if (options.fromStage) {
-        const fromStageData = await this.loadFromStageState(options.fromStage);
-        startGroupNumber = fromStageData.executionGroup;
-        currentOutput = fromStageData.input;
-        workflowContext = fromStageData.workflowContext;
-        this.log(
-          "INFO",
-          `Rerunning from stage "${options.fromStage}" (group ${startGroupNumber})`
-        );
-        this.log(
-          "INFO",
-          `Loaded ${Object.keys(workflowContext).length} previous stage outputs into context`
-        );
-      }
-      const executionPlan = this.workflow.getExecutionPlan();
-      for (let groupIdx = 0; groupIdx < executionPlan.length; groupIdx++) {
-        const group = executionPlan[groupIdx];
-        const interruption = await this.checkExternalInterruption();
-        if (interruption) {
-          if (interruption.type === "cancelled") {
-            this.log("WARN", "Workflow cancelled by external request");
-            this.emit("workflow:cancelled", {
-              workflowRunId: this.workflowRunId,
-              reason: interruption.reason || "Cancelled by user"
-            });
-            await this.persistence.updateRun(this.workflowRunId, {
-              status: "CANCELLED",
-              completedAt: /* @__PURE__ */ new Date()
-            });
-            return "cancelled";
-          } else if (interruption.type === "suspended") {
-            this.log("WARN", "Workflow suspended by external request");
-            return "suspended";
-          }
-        }
-        const groupNumber = group[0].executionGroup;
-        if (groupNumber < startGroupNumber) {
-          this.log("INFO", `Skipping already completed group ${groupNumber}`);
-          continue;
-        }
-        if (group.length === 1) {
-          const node = group[0];
-          const result = await this.executeStage(
-            node,
-            currentOutput,
-            config[node.stage.id] || {},
-            node.executionGroup,
-            workflowContext
-          );
-          if (result === "suspended") {
-            return "suspended";
-          }
-          currentOutput = result.output;
-          workflowContext[node.stage.id] = result.output;
-        } else {
-          const results = await Promise.all(
-            group.map(
-              (node) => this.executeStage(
-                node,
-                currentOutput,
-                config[node.stage.id] || {},
-                node.executionGroup,
-                workflowContext
-              )
-            )
-          );
-          const suspendedIdx = results.findIndex((r) => r === "suspended");
-          if (suspendedIdx !== -1) {
-            return "suspended";
-          }
-          currentOutput = results.reduce(
-            (acc, result, idx) => {
-              if (result !== "suspended") {
-                acc[idx] = result.output;
-                const stageId = group[idx].stage.id;
-                workflowContext[stageId] = result.output;
-              }
-              return acc;
-            },
-            {}
-          );
-        }
-      }
-      const endTime = /* @__PURE__ */ new Date();
-      const run = await this.persistence.getRun(this.workflowRunId);
-      const startTime = run?.startedAt;
-      const duration = startTime ? endTime.getTime() - startTime.getTime() : void 0;
-      const aggregatedStats = await this.getAggregatedStats();
-      await this.persistence.updateRun(this.workflowRunId, {
-        status: "COMPLETED",
-        completedAt: endTime,
-        duration,
-        output: currentOutput,
-        totalCost: aggregatedStats.totalCost,
-        totalTokens: aggregatedStats.totalTokens
-      });
-      this.emit("workflow:completed", {
-        workflowRunId: this.workflowRunId,
-        output: currentOutput
-      });
-      this.log("INFO", `Workflow completed in ${duration}ms`);
-      return currentOutput;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      await this.persistence.updateRun(this.workflowRunId, {
-        status: "FAILED",
-        completedAt: /* @__PURE__ */ new Date()
-      });
-      this.emit("workflow:failed", {
-        workflowRunId: this.workflowRunId,
-        error: errorMessage
-      });
-      this.log("ERROR", `Workflow failed: ${errorMessage}`);
-      throw error;
-    }
-  }
-  /**
-   * Execute a single stage
-   */
-  async executeStage(node, input, config, executionGroup, workflowContext) {
-    const { stage } = node;
-    const startTime = Date.now();
-    try {
-      const stageRecord = await this.persistence.upsertStage({
-        workflowRunId: this.workflowRunId,
-        stageId: stage.id,
-        create: {
-          workflowRunId: this.workflowRunId,
-          stageId: stage.id,
-          stageName: stage.name,
-          stageNumber: executionGroup,
-          executionGroup,
-          status: "RUNNING",
-          startedAt: /* @__PURE__ */ new Date(),
-          config,
-          inputData: input
-        },
-        update: {
-          status: "RUNNING",
-          startedAt: /* @__PURE__ */ new Date()
-        }
-      });
-      this.emit("stage:started", {
-        stageId: stage.id,
-        stageName: stage.name,
-        stageNumber: executionGroup
-      });
-      const isResuming = stageRecord.suspendedState !== null;
-      if (isResuming) {
-        this.log("INFO", `Resuming suspended stage: ${stage.name}`);
-      } else {
-        this.log("INFO", `Executing stage: ${stage.name}`);
-      }
-      const inputStr = JSON.stringify(input);
-      logger2.debug(`Stage ${stage.name} input`, {
-        stageId: stage.id,
-        executionGroup,
-        isResuming,
-        input: inputStr.substring(0, 1e3) + (inputStr.length > 1e3 ? "..." : "")
-      });
-      const validatedInput = stage.inputSchema.parse(input);
-      const logFn = (level, message, meta) => {
-        this.log(level, message, meta);
-        this.persistence.createLog({
-          workflowStageId: stageRecord.id,
-          workflowRunId: this.workflowRunId,
-          level,
-          message,
-          metadata: meta
-        }).catch((err) => logger2.error("Failed to persist log:", err));
-      };
-      const context = {
-        workflowRunId: this.workflowRunId,
-        stageId: stage.id,
-        stageNumber: executionGroup,
-        stageName: stage.name,
-        input: validatedInput,
-        config,
-        onProgress: (update) => {
-          this.emit("stage:progress", update);
-        },
-        onLog: logFn,
-        log: logFn,
-        storage: this.createStorageShim(),
-        workflowContext,
-        // If resuming from suspension, pass the suspended state
-        resumeState: isResuming ? stageRecord.suspendedState : void 0
-      };
-      const result = await stage.execute(context);
-      if (isSuspendedResult(result)) {
-        const { state, pollConfig, metrics } = result;
-        const stateStr = JSON.stringify(state);
-        logger2.debug(`Stage ${stage.name} suspended`, {
-          stageId: stage.id,
-          nextPollAt: pollConfig.nextPollAt.toISOString(),
-          pollInterval: pollConfig.pollInterval,
-          maxWaitTime: pollConfig.maxWaitTime,
-          state: stateStr.substring(0, 500) + (stateStr.length > 500 ? "..." : "")
-        });
-        await this.persistence.updateStage(stageRecord.id, {
-          status: "SUSPENDED",
-          suspendedState: state,
-          nextPollAt: pollConfig.nextPollAt,
-          pollInterval: pollConfig.pollInterval,
-          maxWaitUntil: new Date(Date.now() + pollConfig.maxWaitTime),
-          metrics
-        });
-        await this.persistence.updateRun(this.workflowRunId, {
-          status: "SUSPENDED"
-        });
-        this.emit("stage:suspended", {
-          stageId: stage.id,
-          stageName: stage.name,
-          resumeAt: pollConfig.nextPollAt
-        });
-        this.log(
-          "INFO",
-          `Stage suspended: ${stage.name}, next poll at ${pollConfig.nextPollAt.toISOString()}`
-        );
-        return "suspended";
-      }
-      const validatedOutput = stage.outputSchema.parse(result.output);
-      const outputKey = await this.persistence.saveStageOutput(
-        this.workflowRunId,
-        this.workflowType,
-        stage.id,
-        validatedOutput
-      );
-      const endTime = Date.now();
-      const duration = endTime - startTime;
-      await this.persistence.updateStage(stageRecord.id, {
-        status: "COMPLETED",
-        completedAt: /* @__PURE__ */ new Date(),
-        duration,
-        outputData: { _artifactKey: outputKey },
-        metrics: result.metrics,
-        embeddingInfo: result.embeddings
-      });
-      this.emit("stage:completed", {
-        stageId: stage.id,
-        stageName: stage.name,
-        duration
-      });
-      const outputStr = JSON.stringify(validatedOutput);
-      logger2.debug(`Stage ${stage.name} output`, {
-        stageId: stage.id,
-        duration,
-        output: outputStr.substring(0, 1e3) + (outputStr.length > 1e3 ? "..." : ""),
-        metrics: result.metrics
-      });
-      this.log("INFO", `Stage completed: ${stage.name} in ${duration}ms`);
-      return result;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const errorStack = error instanceof Error ? error.stack : void 0;
-      logger2.error(`Stage ${stage.name} error`, {
-        stageId: stage.id,
-        error: errorMessage,
-        stack: errorStack,
-        duration: Date.now() - startTime
-      });
-      await this.persistence.updateStageByRunAndStageId(
-        this.workflowRunId,
-        stage.id,
-        {
-          status: "FAILED",
-          completedAt: /* @__PURE__ */ new Date(),
-          errorMessage
-        }
-      );
-      this.emit("stage:failed", {
-        stageId: stage.id,
-        stageName: stage.name,
-        error: errorMessage
-      });
-      this.log("ERROR", `Stage failed: ${stage.name} - ${errorMessage}`);
-      throw error;
-    }
-  }
-  /**
-   * Load resume state from database
-   */
-  async loadResumeState() {
-    const suspendedStage = await this.persistence.getFirstSuspendedStageReadyToResume(
-      this.workflowRunId
-    );
-    logger2.debug(
-      `loadResumeState - found suspended stage: ${suspendedStage?.stageId} ${suspendedStage?.status} ${suspendedStage?.nextPollAt} ${suspendedStage?.suspendedState ? "(has suspendedState)" : "(no suspendedState)"}`
-    );
-    if (suspendedStage) {
-      logger2.debug(
-        `Resuming from suspended stage ${suspendedStage.stageId}, group ${suspendedStage.executionGroup}`
-      );
-      let lastOutput = suspendedStage.inputData;
-      if (!lastOutput) {
-        if (suspendedStage.executionGroup === 1) {
-          logger2.warn(
-            `Suspended stage ${suspendedStage.stageId} has no inputData. Falling back to workflow run input.`
-          );
-          const run = await this.persistence.getRun(this.workflowRunId);
-          lastOutput = run?.input;
-        } else {
-          logger2.warn(
-            `Suspended stage ${suspendedStage.stageId} (group ${suspendedStage.executionGroup}) has no inputData. Loading previous stage output.`
-          );
-          const previousCompleted = await this.persistence.getLastCompletedStageBefore(
-            this.workflowRunId,
-            suspendedStage.executionGroup
-          );
-          if (previousCompleted) {
-            const outputData2 = previousCompleted.outputData;
-            if (outputData2?._artifactKey) {
-              lastOutput = await this.persistence.loadArtifact(
-                this.workflowRunId,
-                outputData2._artifactKey
-              );
-              logger2.debug(
-                `Loaded previous stage output from artifact: ${outputData2._artifactKey}`
-              );
-            } else if (outputData2) {
-              lastOutput = outputData2;
-              logger2.debug(`Using previous stage outputData directly`);
-            }
-          }
-          if (!lastOutput) {
-            throw new Error(
-              `Cannot resume suspended stage ${suspendedStage.stageId}: no inputData stored and no previous stage output found`
-            );
-          }
-        }
-      }
-      return {
-        lastCompletedGroup: suspendedStage.executionGroup - 1,
-        lastOutput
-      };
-    }
-    logger2.debug(`No suspended stage found, looking for last completed stage`);
-    const failedStage = await this.persistence.getFirstFailedStage(
-      this.workflowRunId
-    );
-    if (failedStage) {
-      logger2.debug(
-        `Found failed stage: ${failedStage.stageId} in group ${failedStage.executionGroup}`
-      );
-      const lastCompletedBeforeFailed = await this.persistence.getLastCompletedStageBefore(
-        this.workflowRunId,
-        failedStage.executionGroup
-      );
-      if (lastCompletedBeforeFailed) {
-        logger2.debug(
-          `Found last completed stage before failure: ${lastCompletedBeforeFailed.stageId}`
-        );
-        const outputData2 = lastCompletedBeforeFailed.outputData;
-        let output2;
-        if (outputData2?._artifactKey) {
-          output2 = await this.persistence.loadArtifact(
-            this.workflowRunId,
-            outputData2._artifactKey
-          );
-        } else if (outputData2) {
-          output2 = outputData2;
-        } else {
-          throw new Error(
-            `No output data found for stage ${lastCompletedBeforeFailed.stageId}`
-          );
-        }
-        await this.persistence.deleteStage(failedStage.id);
-        logger2.debug(
-          `Deleted failed stage ${failedStage.stageId} for re-execution`
-        );
-        return {
-          lastCompletedGroup: lastCompletedBeforeFailed.executionGroup,
-          lastOutput: output2
-        };
-      }
-    }
-    const stages = await this.persistence.getStagesByRun(this.workflowRunId, {
-      status: "COMPLETED",
-      orderBy: "desc"
-    });
-    if (stages.length === 0) {
-      return null;
-    }
-    const lastStage = stages[0];
-    logger2.debug(`Found last completed stage: ${lastStage.stageId}`);
-    const outputData = lastStage.outputData;
-    let output;
-    if (outputData?._artifactKey) {
-      output = await this.persistence.loadArtifact(
-        this.workflowRunId,
-        outputData._artifactKey
-      );
-    } else if (outputData) {
-      output = outputData;
-    } else {
-      throw new Error(`No output data found for stage ${lastStage.stageId}`);
-    }
-    return {
-      lastCompletedGroup: lastStage.executionGroup,
-      lastOutput: output
-    };
-  }
-  /**
-   * Load workflow context from all completed stages
-   * This rebuilds the workflowContext object so resumed stages can access previous outputs
-   */
-  async loadWorkflowContext() {
-    const completedStages = await this.persistence.getStagesByRun(
-      this.workflowRunId,
-      {
-        status: "COMPLETED",
-        orderBy: "asc"
-      }
-    );
-    const workflowContext = {};
-    for (const stage of completedStages) {
-      const outputData = stage.outputData;
-      let output;
-      if (outputData?._artifactKey) {
-        output = await this.persistence.loadArtifact(
-          this.workflowRunId,
-          outputData._artifactKey
-        );
-      } else if (outputData) {
-        output = outputData;
-      } else {
-        logger2.warn(
-          `No output data found for completed stage ${stage.stageId}`
-        );
-        continue;
-      }
-      workflowContext[stage.stageId] = output;
-      logger2.debug(
-        `Loaded output for stage ${stage.stageId} into workflowContext`
-      );
-    }
-    logger2.debug(
-      `Rebuilt workflowContext with ${Object.keys(workflowContext).length} stage outputs`
-    );
-    return workflowContext;
-  }
-  /**
-   * Load state for rerunning from a specific stage.
-   * Requires that previous stages have already been executed and their outputs persisted.
-   *
-   * @param stageId - The stage ID to start execution from
-   * @returns The execution group, input data, and workflow context
-   */
-  async loadFromStageState(stageId) {
-    const stage = this.workflow.getStage(stageId);
-    if (!stage) {
-      throw new Error(
-        `Stage "${stageId}" not found in workflow "${this.workflow.id}"`
-      );
-    }
-    const executionPlan = this.workflow.getExecutionPlan();
-    let executionGroup = -1;
-    for (const group of executionPlan) {
-      const foundInGroup = group.find((node) => node.stage.id === stageId);
-      if (foundInGroup) {
-        executionGroup = foundInGroup.executionGroup;
-        break;
-      }
-    }
-    if (executionGroup === -1) {
-      throw new Error(
-        `Stage "${stageId}" not found in execution plan for workflow "${this.workflow.id}"`
-      );
-    }
-    logger2.debug(
-      `loadFromStageState: stage "${stageId}" is in execution group ${executionGroup}`
-    );
-    let input;
-    if (executionGroup === 1) {
-      const run = await this.persistence.getRun(this.workflowRunId);
-      if (!run) {
-        throw new Error(`WorkflowRun "${this.workflowRunId}" not found`);
-      }
-      input = run.input;
-      logger2.debug(`Using workflow input for first group stage`);
-    } else {
-      const previousCompleted = await this.persistence.getLastCompletedStageBefore(
-        this.workflowRunId,
-        executionGroup
-      );
-      if (!previousCompleted) {
-        throw new Error(
-          `Cannot rerun from stage "${stageId}": no completed stages found before execution group ${executionGroup}. You must run the workflow from the beginning first.`
-        );
-      }
-      const outputData = previousCompleted.outputData;
-      if (outputData?._artifactKey) {
-        input = await this.persistence.loadArtifact(
-          this.workflowRunId,
-          outputData._artifactKey
-        );
-        logger2.debug(`Loaded input from artifact: ${outputData._artifactKey}`);
-      } else if (outputData) {
-        input = outputData;
-        logger2.debug(
-          `Using outputData directly from stage ${previousCompleted.stageId}`
-        );
-      } else {
-        throw new Error(
-          `Cannot rerun from stage "${stageId}": no output data found for previous stage "${previousCompleted.stageId}"`
-        );
-      }
-    }
-    const completedStages = await this.persistence.getStagesByRun(
-      this.workflowRunId,
-      {
-        status: "COMPLETED",
-        orderBy: "asc"
-      }
-    );
-    const workflowContext = {};
-    for (const completedStage of completedStages) {
-      if (completedStage.executionGroup >= executionGroup) {
-        continue;
-      }
-      const outputData = completedStage.outputData;
-      let output;
-      if (outputData?._artifactKey) {
-        output = await this.persistence.loadArtifact(
-          this.workflowRunId,
-          outputData._artifactKey
-        );
-      } else if (outputData) {
-        output = outputData;
-      } else {
-        logger2.warn(
-          `No output data found for completed stage ${completedStage.stageId}`
-        );
-        continue;
-      }
-      workflowContext[completedStage.stageId] = output;
-      logger2.debug(
-        `Loaded output for stage ${completedStage.stageId} into workflowContext`
-      );
-    }
-    const stagesToDelete = await this.persistence.getStagesByRun(
-      this.workflowRunId,
-      {}
-    );
-    for (const stageToDelete of stagesToDelete) {
-      if (stageToDelete.executionGroup >= executionGroup) {
-        await this.persistence.deleteStage(stageToDelete.id);
-        logger2.debug(
-          `Deleted stage ${stageToDelete.stageId} (group ${stageToDelete.executionGroup}) for re-execution`
-        );
-      }
-    }
-    return {
-      executionGroup,
-      input,
-      workflowContext
-    };
-  }
-  /**
-   * Create a minimal storage shim for context.storage (for API compatibility).
-   * Stage implementations should not rely on this - it may be removed in future.
-   */
-  createStorageShim() {
-    const persistence = this.persistence;
-    const workflowRunId = this.workflowRunId;
-    const workflowType = this.workflowType;
-    return {
-      async save(key, data) {
-        await persistence.saveArtifact({
-          workflowRunId,
-          key,
-          type: "ARTIFACT",
-          data,
-          size: Buffer.byteLength(JSON.stringify(data), "utf8")
-        });
-      },
-      async load(key) {
-        return persistence.loadArtifact(workflowRunId, key);
-      },
-      async exists(key) {
-        return persistence.hasArtifact(workflowRunId, key);
-      },
-      async delete(key) {
-        return persistence.deleteArtifact(workflowRunId, key);
-      },
-      getStageKey(stageId, suffix) {
-        const base = `workflow-v2/${workflowType}/${workflowRunId}/${stageId}`;
-        return suffix ? `${base}/${suffix}` : `${base}/output.json`;
-      }
-    };
-  }
-  /**
-   * Get aggregated statistics for the workflow run
-   */
-  async getAggregatedStats() {
-    const stats = await this.aiLogger.getStats(
-      `workflow.${this.workflowRunId}`
-    );
-    return {
-      totalCost: stats.totalCost,
-      totalTokens: stats.totalInputTokens + stats.totalOutputTokens
-    };
-  }
-  /**
-   * Log a message with automatic database persistence
-   */
-  log(level, message, meta) {
-    this.emit("log", { level, message, meta });
-    this.persistence.createLog({
-      workflowRunId: this.workflowRunId,
-      level,
-      message,
-      metadata: meta
-    }).catch((err) => logger2.error("Failed to persist log:", err));
-  }
-};
-
-// src/core/stage-executor.ts
-var logger3 = createLogger("StageExecutor");
-var StageExecutor = class {
-  constructor(registry, persistence, workerId) {
-    this.registry = registry;
-    this.persistence = persistence;
-    this.workerId = workerId || `stage-executor-${process.pid}`;
-  }
-  workerId;
-  /**
-   * Execute a single stage
-   */
-  async execute(request) {
-    const { workflowRunId, workflowId, stageId, config } = request;
-    const startTime = Date.now();
-    logger3.debug(`Executing stage ${stageId} for workflow ${workflowRunId}`);
-    const workflow = this.registry.getWorkflow(workflowId);
-    if (!workflow) {
-      throw new Error(`Workflow ${workflowId} not found in registry`);
-    }
-    const stageDef = workflow.getStage(stageId);
-    if (!stageDef) {
-      throw new Error(`Stage ${stageId} not found in workflow ${workflowId}`);
-    }
-    const workflowRun = await this.persistence.getRun(workflowRunId);
-    if (!workflowRun) {
-      throw new Error(`WorkflowRun ${workflowRunId} not found`);
-    }
-    const workflowContext = await this.loadWorkflowContext(
-      workflowRunId,
-      workflowRun.workflowType
-    );
-    const stageRecord = await this.persistence.upsertStage({
-      workflowRunId,
-      stageId,
-      create: {
-        workflowRunId,
-        stageId,
-        stageName: stageDef.name,
-        stageNumber: this.getStageNumber(workflow, stageId),
-        executionGroup: this.getExecutionGroup(workflow, stageId),
-        status: "RUNNING",
-        startedAt: /* @__PURE__ */ new Date(),
-        config,
-        inputData: void 0
-        // Will be set later? Or needs to be passed?
-        // Note: original local code didn't set inputData in create? Wait, checking local code...
-      },
-      update: {
-        status: "RUNNING",
-        startedAt: /* @__PURE__ */ new Date()
-        // errorMessage: null, // Persistence interface might not support partial update of this field easily if not explicit?
-        // But upsertStage uses UpdateStageInput.
-      }
-    });
-    const input = await this.resolveStageInput(
-      workflow,
-      stageId,
-      workflowRun,
-      workflowContext
-    );
-    workflowEventBus.emitWorkflowEvent(workflowRunId, "stage:started", {
-      stageId,
-      stageName: stageDef.name,
-      stageNumber: stageRecord.stageNumber
-    });
-    try {
-      const validatedInput = stageDef.inputSchema.parse(input);
-      let stageConfig = config[stageId] || {};
-      try {
-        if (stageDef.configSchema) {
-          stageConfig = stageDef.configSchema.parse(stageConfig);
-        }
-      } catch (err) {
-        logger3.warn(
-          `Config parsing failed for ${stageId}, falling back to raw config`
-        );
-      }
-      const logFn = (level, message, meta) => this.log(workflowRunId, stageRecord.id, level, message, meta);
-      const context = {
-        workflowRunId,
-        stageId,
-        stageNumber: stageRecord.stageNumber,
-        stageName: stageDef.name,
-        stageRecordId: stageRecord.id,
-        input: validatedInput,
-        config: stageConfig,
-        resumeState: stageRecord.suspendedState,
-        onProgress: (update) => {
-          workflowEventBus.emitWorkflowEvent(
-            workflowRunId,
-            "stage:progress",
-            update
-          );
-        },
-        onLog: logFn,
-        log: logFn,
-        storage: this.createStorageShim(
-          workflowRunId,
-          workflowRun.workflowType
-        ),
-        workflowContext
-      };
-      const result = await stageDef.execute(context);
-      if (isSuspendedResult(result)) {
-        return await this.handleSuspended(stageRecord.id, result, startTime);
-      } else {
-        return await this.handleCompleted(
-          workflowRunId,
-          workflowRun.workflowType,
-          stageRecord.id,
-          stageId,
-          result,
-          startTime
-        );
-      }
-    } catch (error) {
-      return await this.handleFailed(stageRecord.id, stageId, error, startTime);
-    }
-  }
-  // -- Handlers --
-  async handleCompleted(workflowRunId, workflowType, stageRecordId, stageId, result, startTime) {
-    const duration = Date.now() - startTime;
-    const outputKey = await this.persistence.saveStageOutput(
-      workflowRunId,
-      workflowType,
-      stageId,
-      result.output
-    );
-    await this.persistence.updateStage(stageRecordId, {
-      status: "COMPLETED",
-      completedAt: /* @__PURE__ */ new Date(),
-      duration,
-      outputData: { _artifactKey: outputKey },
-      metrics: result.metrics,
-      embeddingInfo: result.embeddings
-    });
-    return {
-      type: "completed",
-      output: result.output,
-      metrics: result.metrics
-    };
-  }
-  async handleSuspended(stageRecordId, result, startTime) {
-    const { state, pollConfig, metrics } = result;
-    const nextPollAt = new Date(
-      pollConfig.nextPollAt || Date.now() + (pollConfig.pollInterval || 6e4)
-    );
-    await this.persistence.updateStage(stageRecordId, {
-      status: "SUSPENDED",
-      suspendedState: state,
-      nextPollAt,
-      pollInterval: pollConfig.pollInterval,
-      maxWaitUntil: pollConfig.maxWaitTime ? new Date(Date.now() + pollConfig.maxWaitTime) : void 0,
-      metrics
-    });
-    return {
-      type: "suspended",
-      suspendedState: state,
-      nextPollAt,
-      metrics
-    };
-  }
-  async handleFailed(stageRecordId, stageId, error, startTime) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const duration = Date.now() - startTime;
-    logger3.error(`Stage ${stageId} failed:`, error);
-    await this.persistence.updateStage(stageRecordId, {
-      status: "FAILED",
-      completedAt: /* @__PURE__ */ new Date(),
-      duration
-      // Note: updateStage input might not support duration? Check persistence interface. Assuming it does as StageRecord has it.
-      // errorMessage: errorMessage // Check if UpdateStageInput supports errorMessage.
-      // If not, use updateStageByRunAndStageId pattern or check interface.
-    });
-    await this.log(
-      "",
-      stageRecordId,
-      "ERROR",
-      errorMessage
-    );
-    return {
-      type: "failed",
-      error: errorMessage
-    };
-  }
-  // -- Helpers --
-  async loadWorkflowContext(workflowRunId, workflowType) {
-    const completedStages = await this.persistence.getStagesByRun(
-      workflowRunId,
-      {
-        status: "COMPLETED",
-        orderBy: "asc"
-      }
-    );
-    const context = {};
-    for (const stage of completedStages) {
-      const outputData = stage.outputData;
-      if (outputData?._artifactKey) {
-        context[stage.stageId] = await this.persistence.loadArtifact(
-          workflowRunId,
-          outputData._artifactKey
-        );
-      } else if (outputData && typeof outputData === "object") {
-        context[stage.stageId] = outputData;
-      }
-    }
-    return context;
-  }
-  /**
-   * Create a minimal storage shim for context.storage (for API compatibility).
-   * Stage implementations should not rely on this - it may be removed in future.
-   */
-  createStorageShim(workflowRunId, workflowType) {
-    const persistence = this.persistence;
-    return {
-      async save(key, data) {
-        await persistence.saveArtifact({
-          workflowRunId,
-          key,
-          type: "ARTIFACT",
-          data,
-          size: Buffer.byteLength(JSON.stringify(data), "utf8")
-        });
-      },
-      async load(key) {
-        return persistence.loadArtifact(workflowRunId, key);
-      },
-      async exists(key) {
-        return persistence.hasArtifact(workflowRunId, key);
-      },
-      async delete(key) {
-        return persistence.deleteArtifact(workflowRunId, key);
-      },
-      getStageKey(stageId, suffix) {
-        const base = `workflow-v2/${workflowType}/${workflowRunId}/${stageId}`;
-        return suffix ? `${base}/${suffix}` : `${base}/output.json`;
-      }
-    };
-  }
-  async resolveStageInput(workflow, stageId, workflowRun, workflowContext) {
-    const stageDef = workflow.getStage(stageId);
-    if (!stageDef) return {};
-    const groupIndex = workflow.getExecutionGroupIndex(stageId);
-    if (groupIndex === 0) {
-      return workflowRun.input;
-    }
-    const prevStageId = workflow.getPreviousStageId(stageId);
-    if (prevStageId) {
-      return workflowContext[prevStageId];
-    }
-    return workflowRun.input;
-  }
-  getStageNumber(workflow, stageId) {
-    return workflow.getStageIndex(stageId) + 1;
-  }
-  getExecutionGroup(workflow, stageId) {
-    return workflow.getExecutionGroupIndex(stageId);
-  }
-  async log(workflowRunId, stageRecordId, level, message, meta) {
-    logger3.debug(`[${level}] ${message}`);
-    await this.persistence.createLog({
-      workflowRunId,
-      workflowStageId: stageRecordId,
-      level,
-      message,
-      metadata: meta
-    }).catch((err) => logger3.error("Failed to write log:", err));
-  }
-};
-
-// src/core/storage-providers/memory-storage.ts
-var InMemoryStageStorage = class _InMemoryStageStorage {
-  constructor(workflowRunId, workflowType) {
-    this.workflowRunId = workflowRunId;
-    this.workflowType = workflowType;
-    if (!_InMemoryStageStorage.globalStorage.has(workflowRunId)) {
-      _InMemoryStageStorage.globalStorage.set(workflowRunId, /* @__PURE__ */ new Map());
-    }
-    const storage = _InMemoryStageStorage.globalStorage.get(workflowRunId);
-    if (!storage) {
-      throw new Error(
-        `Failed to initialize storage for workflow run ${workflowRunId}`
-      );
-    }
-    this.storage = storage;
-  }
-  providerType = "memory";
-  // Static storage for all workflow runs (for testing across instances)
-  static globalStorage = /* @__PURE__ */ new Map();
-  storage;
-  /**
-   * Generate storage key with consistent pattern:
-   * workflow-v2/{type}/{runId}/{stageId}/{suffix|output.json}
-   */
-  getStageKey(stageId, suffix) {
-    const base = `workflow-v2/${this.workflowType}/${this.workflowRunId}/${stageId}`;
-    return suffix ? `${base}/${suffix}` : `${base}/output.json`;
-  }
-  /**
-   * Save data to memory (deep clone to prevent mutations)
-   */
-  async save(key, data) {
-    this.storage.set(key, JSON.parse(JSON.stringify(data)));
-  }
-  /**
-   * Load data from memory (deep clone to prevent mutations)
-   */
-  async load(key) {
-    if (!this.storage.has(key)) {
-      throw new Error(`Artifact not found: ${key}`);
-    }
-    return JSON.parse(JSON.stringify(this.storage.get(key)));
-  }
-  /**
-   * Check if key exists in memory
-   */
-  async exists(key) {
-    return this.storage.has(key);
-  }
-  /**
-   * Delete data from memory
-   */
-  async delete(key) {
-    this.storage.delete(key);
-  }
-  /**
-   * Save stage output with standard key
-   */
-  async saveStageOutput(stageId, output) {
-    const key = this.getStageKey(stageId);
-    await this.save(key, output);
-    return key;
-  }
-  /**
-   * Load stage output with standard key
-   */
-  async loadStageOutput(stageId) {
-    const key = this.getStageKey(stageId);
-    return await this.load(key);
-  }
-  /**
-   * Save arbitrary artifact for a stage
-   */
-  async saveArtifact(stageId, artifactName, data) {
-    const key = this.getStageKey(stageId, `artifacts/${artifactName}.json`);
-    await this.save(key, data);
-    return key;
-  }
-  /**
-   * Load arbitrary artifact for a stage
-   */
-  async loadArtifact(stageId, artifactName) {
-    const key = this.getStageKey(stageId, `artifacts/${artifactName}.json`);
-    return await this.load(key);
-  }
-  /**
-   * List all artifacts for a workflow run
-   */
-  async listAllArtifacts() {
-    const artifacts = [];
-    for (const key of this.storage.keys()) {
-      const keyParts = key.split("/");
-      const stageId = keyParts.length >= 4 ? keyParts[3] : "unknown";
-      const name = keyParts[keyParts.length - 1] || "unknown";
-      artifacts.push({
-        key,
-        stageId,
-        name
-      });
-    }
-    return artifacts;
-  }
-  /**
-   * Testing helper: Clear all storage or specific workflow run
-   */
-  static clear(workflowRunId) {
-    if (workflowRunId) {
-      _InMemoryStageStorage.globalStorage.delete(workflowRunId);
-    } else {
-      _InMemoryStageStorage.globalStorage.clear();
-    }
-  }
-  /**
-   * Testing helper: Get all data for a workflow run
-   */
-  static getAll(workflowRunId) {
-    return _InMemoryStageStorage.globalStorage.get(workflowRunId) || /* @__PURE__ */ new Map();
-  }
-};
-
-// src/core/storage-providers/prisma-storage.ts
-var PrismaStageStorage = class {
-  constructor(prisma, workflowRunId, workflowType) {
-    this.prisma = prisma;
-    this.workflowRunId = workflowRunId;
-    this.workflowType = workflowType;
-  }
-  providerType = "prisma";
-  /**
-   * Generate storage key with consistent pattern:
-   * workflow-v2/{type}/{runId}/{stageId}/{suffix|output.json}
-   */
-  getStageKey(stageId, suffix) {
-    const base = `workflow-v2/${this.workflowType}/${this.workflowRunId}/${stageId}`;
-    return suffix ? `${base}/${suffix}` : `${base}/output.json`;
-  }
-  /**
-   * Save data as JSON to database
-   */
-  async save(key, data) {
-    const json = JSON.stringify(data);
-    const size = Buffer.byteLength(json, "utf8");
-    const type = key.includes("/artifacts/") ? "ARTIFACT" : "STAGE_OUTPUT";
-    const keyParts = key.split("/");
-    const stageId = keyParts.length >= 4 ? keyParts[3] : void 0;
-    let workflowStageId = null;
-    if (stageId) {
-      const stage = await this.prisma.workflowStage.findUnique({
-        where: {
-          workflowRunId_stageId: {
-            workflowRunId: this.workflowRunId,
-            stageId
-          }
-        },
-        select: { id: true }
-      });
-      workflowStageId = stage?.id ?? null;
-    }
-    await this.prisma.workflowArtifact.upsert({
-      where: {
-        workflowRunId_key: {
-          workflowRunId: this.workflowRunId,
-          key
-        }
-      },
-      update: {
-        data,
-        size,
-        type,
-        workflowStageId
-      },
-      create: {
-        workflowRunId: this.workflowRunId,
-        workflowStageId,
-        key,
-        type,
-        data,
-        size
-      }
-    });
-  }
-  /**
-   * Load and parse JSON from database
-   */
-  async load(key) {
-    const artifact = await this.prisma.workflowArtifact.findUnique({
-      where: {
-        workflowRunId_key: {
-          workflowRunId: this.workflowRunId,
-          key
-        }
-      }
-    });
-    if (!artifact) {
-      throw new Error(`Artifact not found: ${key}`);
-    }
-    return artifact.data;
-  }
-  /**
-   * Check if artifact exists in database
-   */
-  async exists(key) {
-    const artifact = await this.prisma.workflowArtifact.findUnique({
-      where: {
-        workflowRunId_key: {
-          workflowRunId: this.workflowRunId,
-          key
-        }
-      },
-      select: { id: true }
-    });
-    return artifact !== null;
-  }
-  /**
-   * Delete artifact from database
-   */
-  async delete(key) {
-    await this.prisma.workflowArtifact.delete({
-      where: {
-        workflowRunId_key: {
-          workflowRunId: this.workflowRunId,
-          key
-        }
-      }
-    });
-  }
-  /**
-   * Save stage output with standard key
-   */
-  async saveStageOutput(stageId, output) {
-    const key = this.getStageKey(stageId);
-    await this.save(key, output);
-    return key;
-  }
-  /**
-   * Load stage output with standard key
-   */
-  async loadStageOutput(stageId) {
-    const key = this.getStageKey(stageId);
-    return await this.load(key);
-  }
-  /**
-   * Save arbitrary artifact for a stage
-   */
-  async saveArtifact(stageId, artifactName, data) {
-    const key = this.getStageKey(stageId, `artifacts/${artifactName}.json`);
-    await this.save(key, data);
-    return key;
-  }
-  /**
-   * Load arbitrary artifact for a stage
-   */
-  async loadArtifact(stageId, artifactName) {
-    const key = this.getStageKey(stageId, `artifacts/${artifactName}.json`);
-    return await this.load(key);
-  }
-  /**
-   * List all artifacts for a workflow run (for export)
-   */
-  async listAllArtifacts() {
-    const artifacts = await this.prisma.workflowArtifact.findMany({
-      where: {
-        workflowRunId: this.workflowRunId
-      },
-      select: {
-        key: true,
-        workflowStageId: true
-      }
-    });
-    return artifacts.map(
-      (artifact) => {
-        const keyParts = artifact.key.split("/");
-        const stageId = keyParts.length >= 4 ? keyParts[3] : "unknown";
-        const name = keyParts[keyParts.length - 1] || "unknown";
-        return {
-          key: artifact.key,
-          stageId,
-          name
-        };
-      }
-    );
-  }
-};
-
-// src/core/storage-factory.ts
-function createStorage(options) {
-  const { provider, workflowRunId, workflowType, prisma } = options;
-  switch (provider) {
-    case "prisma":
-      if (!prisma) {
-        throw new Error(
-          'Prisma storage requires a prisma client. Pass it via options.prisma or use provider: "memory" for testing.'
-        );
-      }
-      return new PrismaStageStorage(prisma, workflowRunId, workflowType);
-    case "memory":
-      return new InMemoryStageStorage(workflowRunId, workflowType);
-    default:
-      throw new Error(`Unknown storage provider: ${provider}`);
-  }
+var AIConfigSchema = z.object({
+  /** The model to use for AI operations */
+  model: ModelKey.default("gemini-2.5-flash"),
+  /** Temperature for AI generations (0-2) */
+  temperature: z.number().min(0).max(2).default(0.7),
+  /** Maximum tokens to generate (undefined = model default) */
+  maxTokens: z.number().positive().optional()
+});
+var ConcurrencyConfigSchema = z.object({
+  /** Maximum concurrent operations (for parallel processing) */
+  concurrency: z.number().positive().default(5),
+  /** Delay between operations in milliseconds (rate limiting) */
+  delayMs: z.number().nonnegative().default(0),
+  /** Maximum retries on failure */
+  maxRetries: z.number().nonnegative().default(3)
+});
+var FeatureFlagsConfigSchema = z.object({
+  /** Feature flags for conditional stage behavior */
+  featureFlags: z.record(z.string(), z.boolean()).default({})
+});
+var DebugConfigSchema = z.object({
+  /** Enable verbose logging */
+  verbose: z.boolean().default(false),
+  /** Dry run mode (no side effects) */
+  dryRun: z.boolean().default(false)
+});
+function withAIConfig(schema) {
+  return schema.merge(AIConfigSchema);
 }
-function getDefaultStorageProvider() {
-  const provider = process.env.WORKFLOW_STORAGE_PROVIDER;
-  if (provider && ["prisma", "memory"].includes(provider)) {
-    return provider;
-  }
-  return "prisma";
+function withConcurrency(schema) {
+  return schema.merge(ConcurrencyConfigSchema);
 }
-var logger4 = createLogger("Runtime");
-var WorkflowRuntime = class {
-  isPolling = false;
-  isProcessingJobs = false;
-  isRunning = false;
-  pollIntervalMs;
-  jobPollIntervalMs;
-  staleJobThresholdMs;
-  workerId;
-  persistence;
-  jobQueue;
-  registry;
-  aiCallLogger;
-  getWorkflowPriority;
-  pollTimer = null;
-  stageExecutor;
-  jobsProcessed = 0;
-  constructor(config) {
-    this.pollIntervalMs = config.pollIntervalMs ?? 1e4;
-    this.jobPollIntervalMs = config.jobPollIntervalMs ?? 1e3;
-    this.staleJobThresholdMs = config.staleJobThresholdMs ?? 6e4;
-    this.workerId = config.workerId ?? `worker-${process.pid}-${os.hostname()}`;
-    this.persistence = config.persistence;
-    this.jobQueue = config.jobQueue;
-    this.registry = config.registry;
-    this.aiCallLogger = config.aiCallLogger;
-    this.getWorkflowPriority = config.getWorkflowPriority;
-    this.stageExecutor = new StageExecutor(
-      this.registry,
-      this.persistence,
-      this.workerId
-    );
-  }
-  // ==========================================================================
-  // AI Helper Factory
-  // ==========================================================================
-  /**
-   * Create an AI helper bound to this runtime's logger
-   * @param topic - Topic for logging (e.g., "workflow.abc123.stage.extraction")
-   * @param logContext - Optional log context for persistence logging in batch operations
-   */
-  createAIHelper(topic, logContext) {
-    if (!this.aiCallLogger) {
-      throw new Error(
-        "[Runtime] AICallLogger not configured. Pass aiCallLogger in config."
-      );
-    }
-    return createAIHelper(topic, this.aiCallLogger, logContext);
-  }
-  /**
-   * Create a LogContext for a workflow stage (for use with createAIHelper)
-   * This enables batch operations to log to the workflow persistence.
-   */
-  createLogContext(workflowRunId, stageRecordId) {
-    const persistence = this.persistence;
-    return {
-      workflowRunId,
-      stageRecordId,
-      createLog: (data) => persistence.createLog(data)
-    };
-  }
-  // ==========================================================================
-  // Lifecycle
-  // ==========================================================================
-  /**
-   * Start the runtime as a full worker (processes jobs + polls)
-   */
-  async start() {
-    if (this.isRunning) {
-      logger4.debug("Already running");
-      return;
-    }
-    logger4.info(`Starting worker ${this.workerId}`);
-    logger4.debug(
-      `Poll interval: ${this.pollIntervalMs}ms, Job poll: ${this.jobPollIntervalMs}ms`
-    );
-    this.isRunning = true;
-    this.pollTimer = setInterval(() => this.poll(), this.pollIntervalMs);
-    this.poll();
-    this.processJobs();
-    process.on("SIGTERM", () => this.stop());
-    process.on("SIGINT", () => this.stop());
-  }
-  /**
-   * Stop the runtime
-   */
-  stop() {
-    logger4.info(`Stopping worker ${this.workerId}...`);
-    this.isRunning = false;
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = null;
-    }
-    logger4.info(`Stopped. Processed ${this.jobsProcessed} jobs.`);
-  }
-  // ==========================================================================
-  // Create Run - The main API for starting workflows
-  // ==========================================================================
-  /**
-   * Create a new workflow run with validation.
-   * The runtime will pick it up on the next poll cycle and start execution.
-   */
-  async createRun(options) {
-    const { workflowId, input, config = {}, priority, metadata } = options;
-    const workflow = this.registry.getWorkflow(workflowId);
-    if (!workflow) {
-      throw new Error(`Workflow ${workflowId} not found in registry`);
-    }
-    try {
-      workflow.inputSchema.parse(input);
-    } catch (error) {
-      throw new Error(`Invalid workflow input: ${error}`);
-    }
-    const defaultConfig = workflow.getDefaultConfig?.() ?? {};
-    const mergedConfig = { ...defaultConfig, ...config };
-    const configValidation = workflow.validateConfig(mergedConfig);
-    if (!configValidation.valid) {
-      const errors = configValidation.errors.map((e) => `${e.stageId}: ${e.error}`).join(", ");
-      throw new Error(`Invalid workflow config: ${errors}`);
-    }
-    const effectivePriority = priority ?? this.getWorkflowPriority?.(workflowId) ?? 5;
-    const workflowRun = await this.persistence.createRun({
-      workflowId,
-      workflowName: workflow.name,
-      workflowType: workflowId,
-      input,
-      config: mergedConfig,
-      priority: effectivePriority,
-      metadata
-    });
-    logger4.debug(`Created WorkflowRun ${workflowRun.id} for ${workflowId}`);
-    return {
-      workflowRunId: workflowRun.id
-    };
-  }
-  // ==========================================================================
-  // Job Processing Loop
-  // ==========================================================================
-  /**
-   * Process jobs from the queue
-   */
-  async processJobs() {
-    await this.jobQueue.releaseStaleJobs(this.staleJobThresholdMs);
-    let lastStaleCheck = Date.now();
-    let lastLogTime = Date.now();
-    while (this.isRunning) {
-      try {
-        const now = Date.now();
-        if (now - lastStaleCheck > this.staleJobThresholdMs) {
-          await this.jobQueue.releaseStaleJobs(this.staleJobThresholdMs);
-          lastStaleCheck = now;
-        }
-        if (now - lastLogTime > 1e4) {
-          logger4.debug(
-            `Worker ${this.workerId}: processed ${this.jobsProcessed} jobs`
-          );
-          lastLogTime = now;
-        }
-        const job = await this.jobQueue.dequeue();
-        if (!job) {
-          await new Promise((r) => setTimeout(r, this.jobPollIntervalMs));
-          continue;
-        }
-        const { jobId, workflowRunId, stageId, payload } = job;
-        const config = payload.config || {};
-        logger4.debug(
-          `Processing stage ${stageId} for workflow ${workflowRunId}`
-        );
-        const workflowId = await this.getWorkflowId(workflowRunId);
-        if (!workflowId) {
-          await this.jobQueue.fail(jobId, "WorkflowRun not found", false);
-          continue;
-        }
-        const result = await this.stageExecutor.execute({
-          workflowRunId,
-          stageId,
-          workflowId,
-          config
-        });
-        this.jobsProcessed++;
-        if (result.type === "completed") {
-          logger4.debug(`Job completed`, {
-            jobId,
-            workflowRunId,
-            stageId
-          });
-          await this.jobQueue.complete(jobId);
-          await this.transitionWorkflow(workflowRunId);
-        } else if (result.type === "suspended") {
-          const nextPollAt = result.nextPollAt || new Date(Date.now() + 6e4);
-          logger4.debug(`Job suspended`, {
-            jobId,
-            workflowRunId,
-            stageId,
-            nextPollAt: nextPollAt.toISOString()
-          });
-          await this.jobQueue.suspend(jobId, nextPollAt);
-        } else if (result.type === "failed") {
-          const canRetry = job.attempt < 3;
-          logger4.debug(`Job failed`, {
-            jobId,
-            workflowRunId,
-            stageId,
-            error: result.error,
-            attempt: job.attempt,
-            canRetry
-          });
-          await this.jobQueue.fail(
-            jobId,
-            result.error || "Unknown error",
-            canRetry
-          );
-          if (!canRetry) {
-            await this.persistence.updateRun(workflowRunId, {
-              status: "FAILED"
-            });
-          }
-        }
-      } catch (error) {
-        logger4.error("Error in job loop:", error);
-        await new Promise((r) => setTimeout(r, 5e3));
-      }
-    }
-  }
-  async getWorkflowId(runId) {
-    const run = await this.persistence.getRun(runId);
-    return run?.workflowId ?? null;
-  }
-  // ==========================================================================
-  // Polling - Orchestration
-  // ==========================================================================
-  /**
-   * Poll for pending workflows and suspended stages
-   */
-  async poll() {
-    if (this.isPolling) return;
-    this.isPolling = true;
-    try {
-      await this.pollPendingWorkflows();
-      await this.pollSuspendedStages();
-    } finally {
-      this.isPolling = false;
-    }
-  }
-  /**
-   * Poll for pending workflows and enqueue their first stage.
-   * Uses claimNextPendingRun() for zero-contention claiming with FOR UPDATE SKIP LOCKED.
-   */
-  async pollPendingWorkflows() {
-    let claimedCount = 0;
-    while (true) {
-      const run = await this.persistence.claimNextPendingRun();
-      if (!run) {
-        break;
-      }
-      claimedCount++;
-      logger4.debug(`Claimed workflow ${run.id}`);
-      try {
-        const workflow = this.registry.getWorkflow(run.workflowId);
-        if (!workflow) {
-          await this.persistence.updateRun(run.id, { status: "FAILED" });
-          continue;
-        }
-        const firstStages = workflow.getStagesInExecutionGroup(1);
-        if (firstStages.length === 0) {
-          await this.persistence.updateRun(run.id, { status: "FAILED" });
-          continue;
-        }
-        await this.enqueueExecutionGroup(run, workflow, 1);
-        logger4.debug(`Started workflow ${run.id}`);
-      } catch (error) {
-        logger4.error(`Error starting workflow ${run.id}:`, error);
-        await this.persistence.updateRun(run.id, { status: "FAILED" });
-      }
-    }
-    if (claimedCount > 0) {
-      logger4.debug(`Processed ${claimedCount} pending workflow(s)`);
-    }
-  }
-  /**
-   * Poll suspended stages and resume if ready (public for manual triggering)
-   */
-  async pollSuspendedStages() {
-    const suspendedStages = await this.persistence.getSuspendedStages(
-      /* @__PURE__ */ new Date()
-    );
-    if (suspendedStages.length === 0) return;
-    logger4.debug(`Found ${suspendedStages.length} suspended stages`);
-    for (const stageRecord of suspendedStages) {
-      try {
-        const workflowRun = await this.persistence.getRun(
-          stageRecord.workflowRunId
-        );
-        if (!workflowRun) continue;
-        await this.checkAndResume({ ...stageRecord, workflowRun });
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logger4.error(`Error checking stage ${stageRecord.stageId}:`, error);
-        const isTransientError = errorMessage.includes("fetch failed") || errorMessage.includes("ECONNREFUSED") || errorMessage.includes("ETIMEDOUT") || errorMessage.includes("network") || errorMessage.includes("ENOTFOUND") || errorMessage.includes("socket hang up");
-        if (isTransientError) {
-          logger4.debug(
-            `Transient error for stage ${stageRecord.stageId}, will retry on next poll`
-          );
-          const nextPollAt = new Date(Date.now() + this.pollIntervalMs);
-          await this.persistence.updateStage(stageRecord.id, { nextPollAt }).catch((err) => logger4.error("Failed to update stage:", err));
-        } else {
-          await this.markStageFailed(
-            stageRecord.id,
-            `Runtime error: ${errorMessage}`
-          ).catch((err) => logger4.error("Failed to mark stage failed:", err));
-          await this.persistence.updateRun(stageRecord.workflowRunId, { status: "FAILED" }).catch((err) => logger4.error("Failed to update run:", err));
-        }
-      }
-    }
-  }
-  /**
-   * Transition a workflow to its next state (public for external calls)
-   */
-  async transitionWorkflow(workflowRunId) {
-    const workflowRun = await this.persistence.getRun(workflowRunId);
-    if (!workflowRun) return;
-    if (["FAILED", "CANCELLED", "COMPLETED"].includes(workflowRun.status))
-      return;
-    const workflow = this.registry.getWorkflow(workflowRun.workflowId);
-    if (!workflow) return;
-    const stages = await this.persistence.getStagesByRun(workflowRunId);
-    if (stages.length === 0) {
-      await this.enqueueExecutionGroup(workflowRun, workflow, 1);
-      return;
-    }
-    const activeStage = stages.find(
-      (s) => ["RUNNING", "PENDING", "SUSPENDED"].includes(s.status)
-    );
-    if (activeStage) return;
-    const maxGroup = Math.max(...stages.map((s) => s.executionGroup));
-    const nextStages = workflow.getStagesInExecutionGroup(maxGroup + 1);
-    if (nextStages.length > 0) {
-      await this.enqueueExecutionGroup(workflowRun, workflow, maxGroup + 1);
-    } else {
-      await this.completeWorkflow(workflowRun);
-    }
-  }
-  // ==========================================================================
-  // Private helpers
-  // ==========================================================================
-  async checkAndResume(stageRecord) {
-    const { workflowRun } = stageRecord;
-    const workflow = this.registry.getWorkflow(workflowRun.workflowId);
-    if (!workflow) {
-      await this.markStageFailed(
-        stageRecord.id,
-        "Workflow definition not found"
-      );
-      return;
-    }
-    const stageDef = workflow.getStage(stageRecord.stageId);
-    if (!stageDef || !stageDef.checkCompletion) {
-      await this.markStageFailed(
-        stageRecord.id,
-        "Stage does not support batch completion"
-      );
-      return;
-    }
-    const storage = this.createStorageShim(
-      workflowRun.id,
-      workflowRun.workflowType
-    );
-    const logFn = async (level, message) => {
-      await this.persistence.createLog({
-        workflowRunId: workflowRun.id,
-        workflowStageId: stageRecord.id,
-        level,
-        message: `[Runtime] ${message}`
-      }).catch((err) => logger4.error("Failed to create log:", err));
-    };
-    const completionResult = await stageDef.checkCompletion(
-      stageRecord.suspendedState,
-      {
-        workflowRunId: workflowRun.id,
-        stageId: stageRecord.stageId,
-        stageRecordId: stageRecord.id,
-        // For LogContext in AIHelper
-        config: stageRecord.config || {},
-        log: logFn,
-        onLog: logFn,
-        storage
-      }
-    );
-    logger4.debug("Stage completion result", completionResult);
-    if (completionResult.ready) {
-      if (completionResult.output !== void 0) {
-        const validatedOutput = stageDef.outputSchema.parse(
-          completionResult.output
-        );
-        const outputKey = await this.persistence.saveStageOutput(
-          workflowRun.id,
-          workflowRun.workflowType,
-          stageRecord.stageId,
-          validatedOutput
-        );
-        await this.persistence.updateStage(stageRecord.id, {
-          status: "COMPLETED",
-          completedAt: /* @__PURE__ */ new Date(),
-          duration: Date.now() - new Date(stageRecord.startedAt).getTime(),
-          outputData: { _artifactKey: outputKey },
-          metrics: completionResult.metrics,
-          embeddingInfo: completionResult.embeddings
-        });
-      } else {
-        await this.persistence.updateStage(stageRecord.id, {
-          nextPollAt: null
-        });
-      }
-      await this.resumeWorkflow(workflowRun, workflow);
-    } else if (completionResult.error) {
-      await this.markStageFailed(stageRecord.id, completionResult.error);
-      await this.persistence.updateRun(workflowRun.id, { status: "FAILED" });
-      workflowEventBus.emitWorkflowEvent(workflowRun.id, "workflow:failed", {
-        workflowRunId: workflowRun.id,
-        error: completionResult.error
-      });
-    } else {
-      const nextPollAt = new Date(
-        Date.now() + (completionResult.nextCheckIn || this.pollIntervalMs)
-      );
-      await this.persistence.updateStage(stageRecord.id, { nextPollAt });
-    }
-  }
-  async resumeWorkflow(workflowRun, workflow) {
-    try {
-      await this.persistence.updateRun(workflowRun.id, { status: "RUNNING" });
-      const executor = new WorkflowExecutor(
-        workflow,
-        workflowRun.id,
-        workflowRun.workflowType,
-        {
-          persistence: this.persistence,
-          aiLogger: this.aiCallLogger
-        }
-      );
-      await executor.execute(workflowRun.input, workflowRun.config || {}, {
-        resume: true
-      });
-    } catch (error) {
-      await this.persistence.updateRun(workflowRun.id, { status: "FAILED" });
-      workflowEventBus.emitWorkflowEvent(workflowRun.id, "workflow:failed", {
-        workflowRunId: workflowRun.id,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
-  /**
-   * Create a minimal storage shim for context.storage (for API compatibility).
-   */
-  createStorageShim(workflowRunId, workflowType) {
-    const persistence = this.persistence;
-    return {
-      async save(key, data) {
-        await persistence.saveArtifact({
-          workflowRunId,
-          key,
-          type: "ARTIFACT",
-          data,
-          size: Buffer.byteLength(JSON.stringify(data), "utf8")
-        });
-      },
-      async load(key) {
-        return persistence.loadArtifact(workflowRunId, key);
-      },
-      async exists(key) {
-        return persistence.hasArtifact(workflowRunId, key);
-      },
-      async delete(key) {
-        return persistence.deleteArtifact(workflowRunId, key);
-      },
-      getStageKey(stageId, suffix) {
-        const base = `workflow-v2/${workflowType}/${workflowRunId}/${stageId}`;
-        return suffix ? `${base}/${suffix}` : `${base}/output.json`;
-      }
-    };
-  }
-  async markStageFailed(stageId, errorMessage) {
-    await this.persistence.updateStage(stageId, {
-      status: "FAILED",
-      completedAt: /* @__PURE__ */ new Date(),
-      errorMessage
-    });
-  }
-  async enqueueExecutionGroup(workflowRun, workflow, groupIndex) {
-    const stages = workflow.getStagesInExecutionGroup(groupIndex);
-    if (stages.length === 0) return;
-    for (const stage of stages) {
-      await this.persistence.createStage({
-        workflowRunId: workflowRun.id,
-        stageId: stage.id,
-        stageName: stage.name,
-        stageNumber: workflow.getStageIndex(stage.id) + 1,
-        executionGroup: groupIndex,
-        status: "PENDING",
-        config: workflowRun.config?.[stage.id] || {}
-      });
-    }
-    await this.jobQueue.enqueueParallel(
-      stages.map((stage) => ({
-        workflowRunId: workflowRun.id,
-        stageId: stage.id,
-        priority: workflowRun.priority,
-        payload: { config: workflowRun.config || {} }
-      }))
-    );
-  }
-  async completeWorkflow(workflowRun) {
-    const stages = await this.persistence.getStagesByRun(workflowRun.id);
-    let totalCost = 0, totalTokens = 0;
-    for (const stage of stages) {
-      const metrics = stage.metrics;
-      if (metrics) {
-        totalCost += metrics.cost || 0;
-        totalTokens += (metrics.inputTokens || 0) + (metrics.outputTokens || 0);
-      }
-    }
-    await this.persistence.updateRun(workflowRun.id, {
-      status: "COMPLETED",
-      completedAt: /* @__PURE__ */ new Date(),
-      duration: Date.now() - new Date(workflowRun.createdAt).getTime(),
-      totalCost,
-      totalTokens
-    });
-    workflowEventBus.emitWorkflowEvent(workflowRun.id, "workflow:completed", {
-      workflowRunId: workflowRun.id,
-      output: workflowRun.output || {},
-      duration: Date.now() - new Date(workflowRun.createdAt).getTime(),
-      totalCost,
-      totalTokens
-    });
-    logger4.debug(`Workflow ${workflowRun.id} completed`);
-  }
-};
-function createWorkflowRuntime(config) {
-  return new WorkflowRuntime(config);
+function withFeatureFlags(schema) {
+  return schema.merge(FeatureFlagsConfigSchema);
+}
+function withStandardConfig(schema) {
+  return schema.merge(AIConfigSchema).merge(ConcurrencyConfigSchema).merge(FeatureFlagsConfigSchema);
 }
+z.object({});
+z.object({
+  model: ModelKey.default("gemini-2.5-flash"),
+  temperature: z.number().min(0).max(2).default(0.7)
+});
 
-export { StageExecutor, Workflow, WorkflowBuilder, WorkflowExecutor, WorkflowRuntime, createStorage, createWorkflowRuntime, getDefaultStorageProvider, workflowEventBus };
+export { AIConfigSchema, ConcurrencyConfigSchema, DebugConfigSchema, FeatureFlagsConfigSchema, Workflow, WorkflowBuilder, withAIConfig, withConcurrency, withFeatureFlags, withStandardConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map