@bratsos/workflow-engine 0.5.1 → 0.7.0

package/dist/{client-oLD5ilXp.d.ts → client-DYs5wlHp.d.ts}

@@ -1,8 +1,10 @@
+import * as _ai_sdk_provider from '@ai-sdk/provider';
 import { EmbeddingModelV3 } from '@ai-sdk/provider';
 import { ToolSet, generateText, StepResult, streamText } from 'ai';
 import z$1, { z } from 'zod';
-import { A as AICallLogger } from './interface-TsryH4d7.js';
-import { b as StageContext, c as SuspendedStateSchema, C as CheckCompletionContext, d as CompletionCheckResult, S as Stage } from './stage-BPw7m9Wx.js';
+import { A as AICallLogger } from './interface-BeEPzTFy.js';
+import { b as StageContext, c as SuspendedStateSchema, C as CheckCompletionContext, d as CompletionCheckResult, S as Stage } from './stage-_7BKqqUG.js';
+import './events-D_P24UaY.js';
 
 /**
  * Schema Helpers and Utilities
@@ -152,9 +154,9 @@ interface SimpleSuspendedResult {
 /**
  * Sync stage definition
  */
-interface SyncStageDefinition<TInput extends z.ZodTypeAny | "none", TOutput extends z.ZodTypeAny, TConfig extends z.ZodTypeAny, TContext extends Record<string, unknown> = Record<string, unknown>> {
+interface SyncStageDefinition<TInput extends z.ZodTypeAny | "none", TOutput extends z.ZodTypeAny, TConfig extends z.ZodTypeAny, TContext extends Record<string, unknown> = Record<string, unknown>, TId extends string = string> {
     /** Unique stage identifier */
-    id: string;
+    id: TId;
     /** Human-readable name */
     name: string;
     /** Optional description */
@@ -183,7 +185,7 @@ interface SyncStageDefinition<TInput extends z.ZodTypeAny | "none", TOutput exte
 /**
  * Async-batch stage definition (for long-running batch jobs)
  */
-interface AsyncBatchStageDefinition<TInput extends z.ZodTypeAny | "none", TOutput extends z.ZodTypeAny, TConfig extends z.ZodTypeAny, TContext extends Record<string, unknown> = Record<string, unknown>> extends Omit<SyncStageDefinition<TInput, TOutput, TConfig, TContext>, "execute"> {
+interface AsyncBatchStageDefinition<TInput extends z.ZodTypeAny | "none", TOutput extends z.ZodTypeAny, TConfig extends z.ZodTypeAny, TContext extends Record<string, unknown> = Record<string, unknown>, TId extends string = string> extends Omit<SyncStageDefinition<TInput, TOutput, TConfig, TContext, TId>, "execute"> {
     /** Mark as async-batch mode */
     mode: "async-batch";
     /**
@@ -207,18 +209,18 @@ interface AsyncBatchStageDefinition<TInput extends z.ZodTypeAny | "none", TOutpu
 /**
  * Define a sync stage with simplified API
  */
-declare function defineStage<TInput extends z.ZodTypeAny | "none", TOutput extends z.ZodTypeAny, TConfig extends z.ZodTypeAny, TContext extends Record<string, unknown> = Record<string, unknown>>(definition: SyncStageDefinition<TInput, TOutput, TConfig, TContext>): Stage<TInput extends "none" ? typeof NoInputSchema : TInput, TOutput, TConfig, TContext>;
+declare function defineStage<TId extends string, TInput extends z.ZodTypeAny | "none", TOutput extends z.ZodTypeAny, TConfig extends z.ZodTypeAny, TContext extends Record<string, unknown> = Record<string, unknown>>(definition: SyncStageDefinition<TInput, TOutput, TConfig, TContext, TId>): Stage<TInput extends "none" ? typeof NoInputSchema : TInput, TOutput, TConfig, TContext, TId>;
 /**
  * Define an async-batch stage with simplified API
  */
-declare function defineStage<TInput extends z.ZodTypeAny | "none", TOutput extends z.ZodTypeAny, TConfig extends z.ZodTypeAny, TContext extends Record<string, unknown> = Record<string, unknown>>(definition: AsyncBatchStageDefinition<TInput, TOutput, TConfig, TContext>): Stage<TInput extends "none" ? typeof NoInputSchema : TInput, TOutput, TConfig, TContext>;
+declare function defineStage<TId extends string, TInput extends z.ZodTypeAny | "none", TOutput extends z.ZodTypeAny, TConfig extends z.ZodTypeAny, TContext extends Record<string, unknown> = Record<string, unknown>>(definition: AsyncBatchStageDefinition<TInput, TOutput, TConfig, TContext, TId>): Stage<TInput extends "none" ? typeof NoInputSchema : TInput, TOutput, TConfig, TContext, TId>;
 /**
  * Define an async-batch stage with proper type inference for checkCompletion
  *
  * This is a dedicated function (not an alias) to ensure TypeScript properly
  * infers callback parameter types without overload resolution ambiguity.
  */
-declare function defineAsyncBatchStage<TInput extends z.ZodTypeAny | "none", TOutput extends z.ZodTypeAny, TConfig extends z.ZodTypeAny, TContext extends Record<string, unknown> = Record<string, unknown>>(definition: AsyncBatchStageDefinition<TInput, TOutput, TConfig, TContext>): Stage<TInput extends "none" ? typeof NoInputSchema : TInput, TOutput, TConfig, TContext>;
+declare function defineAsyncBatchStage<TId extends string, TInput extends z.ZodTypeAny | "none", TOutput extends z.ZodTypeAny, TConfig extends z.ZodTypeAny, TContext extends Record<string, unknown> = Record<string, unknown>>(definition: AsyncBatchStageDefinition<TInput, TOutput, TConfig, TContext, TId>): Stage<TInput extends "none" ? typeof NoInputSchema : TInput, TOutput, TConfig, TContext, TId>;
 
 /**
  * Model Helper - Centralized model selection and cost tracking for AI scripts
@@ -389,21 +391,6 @@ declare class ModelStatsTracker {
      * Perfect for parallel execution where different calls use different models
      */
     static createAggregating(): ModelStatsTracker;
-    /**
-     * Get the model ID for use with AI SDK
-     * @deprecated Use getModelById(modelKey).id instead for parallel execution
-     */
-    getModelId(): string;
-    /**
-     * Get the model configuration
-     * @deprecated Use getModelById(modelKey) instead for parallel execution
-     */
-    getModelConfig(): ModelConfig;
-    /**
-     * Switch model (useful for sequential model switching)
-     * @deprecated For parallel execution, pass model key to recordCall() instead
-     */
-    switchModel(modelKey: ModelKey): void;
     /**
      * Get a model helper with bound recordCall for parallel execution
      * Perfect for running multiple AI calls in parallel with different models
@@ -497,23 +484,6 @@ declare class ModelStatsTracker {
  */
 declare function printAvailableModels(): void;
 
-/**
- * AI Helper - Unified AI interaction tracking with hierarchical topics
- *
- * This is the new unified AI tracking system that replaces workflow-specific tracking.
- * It supports:
- * - Hierarchical topics for flexible categorization (e.g., "workflow.abc.stage.extraction")
- * - All AI call types: generateText, generateObject, embed, streamText, batch
- * - Automatic cost calculation with batch discounts
- * - Persistent DB logging to AICall table
- *
- * @example
- * ```typescript
- * const ai = createAIHelper("workflow.abc123").createChild("stage", "extraction");
- * const result = await ai.generateText("gemini-2.5-flash", prompt);
- * ```
- */
-
 /**
  * Register a custom embedding provider factory.
  *
@@ -530,6 +500,11 @@ declare function printAvailableModels(): void;
  * ```
  */
 declare function registerEmbeddingProvider(providerName: string, factory: (modelId: string) => EmbeddingModelV3): void;
+/**
+ * Custom provider resolver. Given a ModelConfig, return an AI SDK
+ * LanguageModel to use, or null/undefined to fall back to built-in resolution.
+ */
+type ProviderResolver = (modelConfig: ModelConfig) => _ai_sdk_provider.LanguageModelV3 | null | undefined;
 type AICallType = "text" | "object" | "embed" | "stream" | "batch";
 interface AITextResult {
     text: string;
@@ -755,63 +730,6 @@ interface AIHelper {
  * const result = await ai.generateText("gemini-2.5-flash", prompt);
  * ```
  */
-declare function createAIHelper(topic: string, logger: AICallLogger, logContext?: LogContext): AIHelper;
-
-/**
- * Workflow Event Types for SSE Streaming
- *
- * This file contains ONLY types and interfaces for workflow events.
- * It is safe to use in both client and server environments.
- */
-interface WorkflowSSEEvent {
-    type: WorkflowEventType;
-    workflowRunId: string;
-    timestamp: Date;
-    data: Record<string, unknown>;
-}
-type WorkflowEventType = "connected" | "workflow:started" | "workflow:completed" | "workflow:suspended" | "workflow:cancelled" | "workflow:failed" | "stage:started" | "stage:progress" | "stage:completed" | "stage:suspended" | "stage:failed" | "log";
-interface WorkflowStartedPayload {
-    workflowRunId: string;
-    workflowName: string;
-}
-interface WorkflowCompletedPayload {
-    workflowRunId: string;
-    output: unknown;
-    duration?: number;
-    totalCost?: number;
-    totalTokens?: number;
-}
-interface WorkflowSuspendedPayload {
-    workflowRunId: string;
-    stageId: string;
-}
-interface WorkflowFailedPayload {
-    workflowRunId: string;
-    error: string;
-}
-interface StageStartedPayload {
-    stageId: string;
-    stageName: string;
-    stageNumber: number;
-}
-interface StageCompletedPayload {
-    stageId: string;
-    stageName: string;
-    duration: number;
-    cost?: number;
-    inputTokens?: number;
-    outputTokens?: number;
-    outputCount?: number;
-}
-interface StageFailedPayload {
-    stageId: string;
-    stageName: string;
-    error: string;
-}
-interface LogPayload {
-    level: string;
-    message: string;
-    meta?: Record<string, unknown>;
-}
+declare function createAIHelper(topic: string, logger: AICallLogger, logContext?: LogContext, providerResolver?: ProviderResolver): AIHelper;
 
-export { type StageStartedPayload as $, type AIBatch as A, type BatchLogFn as B, getModel as C, DEFAULT_MODEL_KEY as D, type EmbedOptions as E, getModelById as F, getRegisteredModel as G, listModels as H, type InferInput as I, listRegisteredModels as J, modelSupportsBatch as K, type LogContext as L, ModelKey as M, NoInputSchema as N, type ObjectOptions as O, printAvailableModels as P, registerEmbeddingProvider as Q, type RecordCallParams as R, type SimpleStageResult as S, type TextOptions as T, registerModels as U, requireStageOutput as V, type WorkflowEventType as W, type LogPayload as X, type ModelFilter as Y, type StageCompletedPayload as Z, type StageFailedPayload as _, type AIBatchHandle as a, type WorkflowCompletedPayload as a0, type WorkflowFailedPayload as a1, type WorkflowStartedPayload as a2, type WorkflowSuspendedPayload as a3, type AIBatchProvider as b, type AIBatchRequest as c, type AIBatchResult as d, type AICallType as e, type AIEmbedResult as f, type AIHelper as g, type AIObjectResult as h, type AIStreamResult as i, type AITextResult as j, AVAILABLE_MODELS as k, type AsyncBatchStageDefinition as l, type EnhancedStageContext as m, type ModelConfig as n, type ModelRegistry as o, type ModelStats as p, ModelStatsTracker as q, type ModelSyncConfig as r, type StreamOptions as s, type SyncStageDefinition as t, type WorkflowSSEEvent as u, calculateCost as v, createAIHelper as w, defineAsyncBatchStage as x, defineStage as y, getDefaultModel as z };
+export { type AIBatch as A, type BatchLogFn as B, getModelById as C, DEFAULT_MODEL_KEY as D, type EmbedOptions as E, getRegisteredModel as F, listModels as G, listRegisteredModels as H, type InferInput as I, modelSupportsBatch as J, printAvailableModels as K, type LogContext as L, ModelKey as M, NoInputSchema as N, type ObjectOptions as O, registerEmbeddingProvider as P, registerModels as Q, type RecordCallParams as R, type SimpleStageResult as S, type TextOptions as T, requireStageOutput as U, type ModelFilter as V, type AIBatchHandle as a, type AIBatchProvider as b, type AIBatchRequest as c, type AIBatchResult as d, type AICallType as e, type AIEmbedResult as f, type AIHelper as g, type AIObjectResult as h, type AIStreamResult as i, type AITextResult as j, AVAILABLE_MODELS as k, type AsyncBatchStageDefinition as l, type EnhancedStageContext as m, type ModelConfig as n, type ModelRegistry as o, type ModelStats as p, ModelStatsTracker as q, type ModelSyncConfig as r, type StreamOptions as s, type SyncStageDefinition as t, calculateCost as u, createAIHelper as v, defineAsyncBatchStage as w, defineStage as x, getDefaultModel as y, getModel as z };

package/dist/client.d.ts

@@ -1,6 +1,7 @@
-export { g as AIHelper, k as AVAILABLE_MODELS, l as AsyncBatchStageDefinition, D as DEFAULT_MODEL_KEY, m as EnhancedStageContext, I as InferInput, X as LogPayload, n as ModelConfig, Y as ModelFilter, M as ModelKey, o as ModelRegistry, N as NoInputSchema, S as SimpleStageResult, Z as StageCompletedPayload, _ as StageFailedPayload, $ as StageStartedPayload, t as SyncStageDefinition, a0 as WorkflowCompletedPayload, W as WorkflowEventType, a1 as WorkflowFailedPayload, u as WorkflowSSEEvent, a2 as WorkflowStartedPayload, a3 as WorkflowSuspendedPayload, v as calculateCost, x as defineAsyncBatchStage, y as defineStage, H as listModels, K as modelSupportsBatch, U as registerModels } from './client-oLD5ilXp.js';
+export { g as AIHelper, k as AVAILABLE_MODELS, l as AsyncBatchStageDefinition, D as DEFAULT_MODEL_KEY, m as EnhancedStageContext, I as InferInput, n as ModelConfig, V as ModelFilter, M as ModelKey, o as ModelRegistry, N as NoInputSchema, S as SimpleStageResult, t as SyncStageDefinition, u as calculateCost, w as defineAsyncBatchStage, x as defineStage, G as listModels, J as modelSupportsBatch, Q as registerModels } from './client-DYs5wlHp.js';
+export { K as KernelEvent, a as KernelEventType, S as StageCompletedEvent, b as StageFailedEvent, c as StageProgressEvent, d as StageStartedEvent, e as StageSuspendedEvent, W as WorkflowCancelledEvent, f as WorkflowCompletedEvent, g as WorkflowCreatedEvent, h as WorkflowFailedEvent, i as WorkflowStartedEvent, j as WorkflowSuspendedEvent } from './events-D_P24UaY.js';
 import '@ai-sdk/provider';
 import 'ai';
 import 'zod';
-import './interface-TsryH4d7.js';
-import './stage-BPw7m9Wx.js';
+import './interface-BeEPzTFy.js';
+import './stage-_7BKqqUG.js';

package/dist/client.js

@@ -1,4 +1,4 @@
-export { AVAILABLE_MODELS, DEFAULT_MODEL_KEY, ModelKey, NoInputSchema, calculateCost, defineAsyncBatchStage, defineStage, listModels, modelSupportsBatch, registerModels } from './chunk-ZYMT2PAO.js';
+export { AVAILABLE_MODELS, DEFAULT_MODEL_KEY, ModelKey, NoInputSchema, calculateCost, defineAsyncBatchStage, defineStage, listModels, modelSupportsBatch, registerModels } from './chunk-WWK2SPN7.js';
 import './chunk-MUWP5SF2.js';
 //# sourceMappingURL=client.js.map
 //# sourceMappingURL=client.js.map

package/dist/events-D_P24UaY.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Kernel Event Types
+ *
+ * Discriminated union of all events emitted by the workflow kernel.
+ * Each event carries a string literal `type` discriminant, a `timestamp`,
+ * and a `workflowRunId` that scopes the event to a specific run.
+ *
+ * This file contains ONLY types -- no runtime code.
+ */
+/** Emitted when a new workflow run record is created. */
+interface WorkflowCreatedEvent {
+    readonly type: "workflow:created";
+    readonly timestamp: Date;
+    readonly workflowRunId: string;
+    readonly workflowId: string;
+}
+/** Emitted when a workflow run begins execution. */
+interface WorkflowStartedEvent {
+    readonly type: "workflow:started";
+    readonly timestamp: Date;
+    readonly workflowRunId: string;
+}
+/** Emitted when a workflow run finishes successfully. */
+interface WorkflowCompletedEvent {
+    readonly type: "workflow:completed";
+    readonly timestamp: Date;
+    readonly workflowRunId: string;
+    readonly duration?: number;
+    readonly totalCost?: number;
+    readonly totalTokens?: number;
+    readonly output?: unknown;
+}
+/** Emitted when a workflow run terminates due to an unrecoverable error. */
+interface WorkflowFailedEvent {
+    readonly type: "workflow:failed";
+    readonly timestamp: Date;
+    readonly workflowRunId: string;
+    readonly error: string;
+}
+/** Emitted when a workflow run is cancelled by an external request. */
+interface WorkflowCancelledEvent {
+    readonly type: "workflow:cancelled";
+    readonly timestamp: Date;
+    readonly workflowRunId: string;
+    readonly reason?: string;
+}
+/** Emitted when a workflow run suspends, waiting on an external signal. */
+interface WorkflowSuspendedEvent {
+    readonly type: "workflow:suspended";
+    readonly timestamp: Date;
+    readonly workflowRunId: string;
+    readonly stageId: string;
+}
+/** Emitted when a stage begins execution. */
+interface StageStartedEvent {
+    readonly type: "stage:started";
+    readonly timestamp: Date;
+    readonly workflowRunId: string;
+    readonly stageId: string;
+    readonly stageName: string;
+    readonly stageNumber: number;
+}
+/** Emitted when a stage completes successfully. */
+interface StageCompletedEvent {
+    readonly type: "stage:completed";
+    readonly timestamp: Date;
+    readonly workflowRunId: string;
+    readonly stageId: string;
+    readonly stageName: string;
+    readonly duration: number;
+}
+/** Emitted when a stage suspends, awaiting a future poll. */
+interface StageSuspendedEvent {
+    readonly type: "stage:suspended";
+    readonly timestamp: Date;
+    readonly workflowRunId: string;
+    readonly stageId: string;
+    readonly stageName: string;
+    readonly nextPollAt: Date;
+}
+/** Emitted when a stage fails with an error. */
+interface StageFailedEvent {
+    readonly type: "stage:failed";
+    readonly timestamp: Date;
+    readonly workflowRunId: string;
+    readonly stageId: string;
+    readonly stageName: string;
+    readonly error: string;
+}
+/** Emitted to report incremental progress within a stage. */
+interface StageProgressEvent {
+    readonly type: "stage:progress";
+    readonly timestamp: Date;
+    readonly workflowRunId: string;
+    readonly stageId: string;
+    readonly progress: number;
+    readonly message: string;
+    readonly details?: Record<string, unknown>;
+}
+/** Discriminated union of every kernel event. */
+type KernelEvent = WorkflowCreatedEvent | WorkflowStartedEvent | WorkflowCompletedEvent | WorkflowFailedEvent | WorkflowCancelledEvent | WorkflowSuspendedEvent | StageStartedEvent | StageCompletedEvent | StageSuspendedEvent | StageFailedEvent | StageProgressEvent;
+/** String literal union of all kernel event type discriminants. */
+type KernelEventType = KernelEvent["type"];
+
+export type { KernelEvent as K, StageCompletedEvent as S, WorkflowCancelledEvent as W, KernelEventType as a, StageFailedEvent as b, StageProgressEvent as c, StageStartedEvent as d, StageSuspendedEvent as e, WorkflowCompletedEvent as f, WorkflowCreatedEvent as g, WorkflowFailedEvent as h, WorkflowStartedEvent as i, WorkflowSuspendedEvent as j };

package/dist/{index-CVkkGnxx.d.ts → index-aNuJ2QgN.d.ts}

@@ -1,4 +1,4 @@
-import { A as AICallLogger, g as CreateAICallInput, h as AIHelperStats, l as WorkflowPersistence, a as CreateRunInput, W as WorkflowRunRecord, U as UpdateRunInput, m as WorkflowStatus, b as CreateStageInput, c as WorkflowStageRecord, d as UpsertStageInput, e as UpdateStageInput, n as WorkflowStageStatus, f as CreateLogInput, o as SaveArtifactInput, p as WorkflowArtifactRecord, C as CreateOutboxEventInput, O as OutboxRecord, J as JobQueue, E as EnqueueJobInput, D as DequeueResult } from './interface-TsryH4d7.js';
+import { A as AICallLogger, g as CreateAICallInput, h as AIHelperStats, l as WorkflowPersistence, C as CreateRunInput, W as WorkflowRunRecord, U as UpdateRunInput, m as WorkflowStatus, a as CreateStageInput, b as WorkflowStageRecord, c as UpsertStageInput, d as UpdateStageInput, n as WorkflowStageStatus, e as CreateLogInput, o as SaveArtifactInput, p as WorkflowArtifactRecord, f as CreateOutboxEventInput, O as OutboxRecord, J as JobQueue, E as EnqueueJobInput, D as DequeueResult } from './interface-BeEPzTFy.js';
 
 /**
  * PrismaAICallLogger - Prisma implementation of AICallLogger
@@ -46,11 +46,17 @@ interface PrismaWorkflowPersistenceOptions {
      * Set to "sqlite" when using SQLite (uses optimistic locking instead of FOR UPDATE SKIP LOCKED).
      */
     databaseType?: DatabaseType;
+    /**
+     * Skip interactive transactions. Defaults to false.
+     * Set to true in single-process environments where transactions are not needed.
+     */
+    skipInteractiveTransactions?: boolean;
 }
 declare class PrismaWorkflowPersistence implements WorkflowPersistence {
     private readonly prisma;
     private enums;
     private databaseType;
+    private skipTransactions;
     constructor(prisma: PrismaClient$1, options?: PrismaWorkflowPersistenceOptions);
     withTransaction<T>(fn: (tx: WorkflowPersistence) => Promise<T>): Promise<T>;
     createRun(data: CreateRunInput): Promise<WorkflowRunRecord>;
@@ -202,6 +208,10 @@ declare class PrismaJobQueue implements JobQueue {
         stageId: string;
         workflowRunId: string;
     }>>;
+    /**
+     * Cancel all pending/suspended jobs for a workflow run.
+     */
+    cancelByRun(workflowRunId: string): Promise<number>;
     /**
      * Release stale locks (for crashed workers)
      */

package/dist/index.d.ts

@@ -1,15 +1,190 @@
-import { M as ModelKey } from './client-oLD5ilXp.js';
-export { A as AIBatch, a as AIBatchHandle, b as AIBatchProvider, c as AIBatchRequest, d as AIBatchResult, e as AICallType, f as AIEmbedResult, g as AIHelper, h as AIObjectResult, i as AIStreamResult, j as AITextResult, k as AVAILABLE_MODELS, l as AsyncBatchStageDefinition, B as BatchLogFn, D as DEFAULT_MODEL_KEY, E as EmbedOptions, m as EnhancedStageContext, I as InferInput, L as LogContext, n as ModelConfig, o as ModelRegistry, p as ModelStats, q as ModelStatsTracker, r as ModelSyncConfig, N as NoInputSchema, O as ObjectOptions, R as RecordCallParams, S as SimpleStageResult, s as StreamOptions, t as SyncStageDefinition, T as TextOptions, W as WorkflowEventType, u as WorkflowSSEEvent, v as calculateCost, w as createAIHelper, x as defineAsyncBatchStage, y as defineStage, z as getDefaultModel, C as getModel, F as getModelById, G as getRegisteredModel, H as listModels, J as listRegisteredModels, K as modelSupportsBatch, P as printAvailableModels, Q as registerEmbeddingProvider, U as registerModels, V as requireStageOutput } from './client-oLD5ilXp.js';
-import { L as LogLevel } from './stage-BPw7m9Wx.js';
-export { S as Stage, a as StageResult } from './stage-BPw7m9Wx.js';
-export { C as CommandResult, I as IdempotencyInProgressError, y as InferWorkflowStageIds, J as JobExecuteCommand, a as JobExecuteResult, b as Kernel, c as KernelCommand, d as KernelCommandType, e as KernelConfig, W as KernelWorkflowRegistry, L as LeaseReapStaleCommand, f as LeaseReapStaleResult, O as OutboxFlushCommand, g as OutboxFlushResult, P as PluginDefinition, h as PluginReplayDLQCommand, i as PluginReplayDLQResult, j as PluginRunner, k as PluginRunnerConfig, R as RunCancelCommand, l as RunCancelResult, m as RunClaimPendingCommand, n as RunClaimPendingResult, o as RunCreateCommand, p as RunCreateResult, q as RunRerunFromCommand, r as RunRerunFromResult, s as RunTransitionCommand, t as RunTransitionResult, S as StagePollSuspendedCommand, u as StagePollSuspendedResult, z as Workflow, A as WorkflowBuilder, v as createKernel, w as createPluginRunner, x as definePlugin } from './plugins-C94AT8Wr.js';
+import { M as ModelKey } from './client-DYs5wlHp.js';
+export { A as AIBatch, a as AIBatchHandle, b as AIBatchProvider, c as AIBatchRequest, d as AIBatchResult, e as AICallType, f as AIEmbedResult, g as AIHelper, h as AIObjectResult, i as AIStreamResult, j as AITextResult, k as AVAILABLE_MODELS, l as AsyncBatchStageDefinition, B as BatchLogFn, D as DEFAULT_MODEL_KEY, E as EmbedOptions, m as EnhancedStageContext, I as InferInput, L as LogContext, n as ModelConfig, o as ModelRegistry, p as ModelStats, q as ModelStatsTracker, r as ModelSyncConfig, N as NoInputSchema, O as ObjectOptions, R as RecordCallParams, S as SimpleStageResult, s as StreamOptions, t as SyncStageDefinition, T as TextOptions, u as calculateCost, v as createAIHelper, w as defineAsyncBatchStage, x as defineStage, y as getDefaultModel, z as getModel, C as getModelById, F as getRegisteredModel, G as listModels, H as listRegisteredModels, J as modelSupportsBatch, K as printAvailableModels, P as registerEmbeddingProvider, Q as registerModels, U as requireStageOutput } from './client-DYs5wlHp.js';
+import { L as LogLevel } from './stage-_7BKqqUG.js';
+export { S as Stage, a as StageResult } from './stage-_7BKqqUG.js';
+import { y as Workflow } from './plugins-Cl0WVVrE.js';
+export { C as CommandResult, I as IdempotencyInProgressError, z as InferWorkflowStageIds, J as JobExecuteCommand, a as JobExecuteResult, b as Kernel, c as KernelCommand, d as KernelCommandType, e as KernelConfig, W as KernelWorkflowRegistry, L as LeaseReapStaleCommand, f as LeaseReapStaleResult, O as OutboxFlushCommand, g as OutboxFlushResult, P as PluginDefinition, h as PluginReplayDLQCommand, i as PluginReplayDLQResult, j as PluginRunner, k as PluginRunnerConfig, R as RunCancelCommand, l as RunCancelResult, m as RunClaimPendingCommand, n as RunClaimPendingResult, o as RunCreateCommand, p as RunCreateResult, q as RunRerunFromCommand, r as RunRerunFromResult, s as RunTransitionCommand, t as RunTransitionResult, S as StagePollSuspendedCommand, u as StagePollSuspendedResult, A as WorkflowBuilder, v as createKernel, w as createPluginRunner, x as definePlugin } from './plugins-Cl0WVVrE.js';
 import z$1, { z } from 'zod';
-export { A as AICallLogger, i as AICallRecord, h as AIHelperStats, r as ArtifactType, g as CreateAICallInput, f as CreateLogInput, C as CreateOutboxEventInput, a as CreateRunInput, b as CreateStageInput, D as DequeueResult, E as EnqueueJobInput, I as IdempotencyRecord, J as JobQueue, j as JobRecord, k as JobStatus, L as LogLevel, O as OutboxRecord, o as SaveArtifactInput, s as StaleVersionError, S as Status, U as UpdateRunInput, e as UpdateStageInput, d as UpsertStageInput, p as WorkflowArtifactRecord, q as WorkflowLogRecord, l as WorkflowPersistence, W as WorkflowRunRecord, c as WorkflowStageRecord, n as WorkflowStageStatus, m as WorkflowStatus } from './interface-TsryH4d7.js';
-export { P as PrismaAICallLogger, a as PrismaJobQueue, c as PrismaWorkflowPersistence, e as createPrismaAICallLogger, f as createPrismaJobQueue, g as createPrismaWorkflowPersistence } from './index-CVkkGnxx.js';
+export { A as AICallLogger, i as AICallRecord, h as AIHelperStats, r as ArtifactType, g as CreateAICallInput, e as CreateLogInput, f as CreateOutboxEventInput, C as CreateRunInput, a as CreateStageInput, D as DequeueResult, E as EnqueueJobInput, I as IdempotencyRecord, J as JobQueue, j as JobRecord, L as LogLevel, O as OutboxRecord, o as SaveArtifactInput, s as StaleVersionError, S as Status, U as UpdateRunInput, d as UpdateStageInput, c as UpsertStageInput, p as WorkflowArtifactRecord, q as WorkflowLogRecord, l as WorkflowPersistence, W as WorkflowRunRecord, b as WorkflowStageRecord } from './interface-BeEPzTFy.js';
+export { P as PrismaAICallLogger, a as PrismaJobQueue, c as PrismaWorkflowPersistence, e as createPrismaAICallLogger, f as createPrismaJobQueue, g as createPrismaWorkflowPersistence } from './index-aNuJ2QgN.js';
 import { ToolSet } from 'ai';
-export { B as BlobStore, C as Clock, E as EventSink, J as JobTransport, K as KernelEvent, a as KernelEventType, P as Persistence, S as Scheduler } from './ports-855bktyD.js';
+export { K as KernelEvent, a as KernelEventType } from './events-D_P24UaY.js';
+export { B as BlobStore, C as Clock, E as EventSink, J as JobTransport, P as Persistence, S as Scheduler } from './ports-swhiWFw4.js';
 import '@ai-sdk/provider';
 
+/**
+ * Stage ID Utilities - Type-safe stage ID management
+ *
+ * Provides utilities for creating type-safe stage ID constants and
+ * branded types to prevent typos in stage ID references.
+ *
+ * ## Usage Patterns
+ *
+ * ### Pattern 1: Create Stage IDs from a Workflow (Recommended)
+ *
+ * ```typescript
+ * import { createStageIds } from "~/lib/workflow-v2/core/stage-ids";
+ *
+ * export const STAGE_IDS = createStageIds(certificateWorkflow);
+ * // = {
+ * //   DATA_EXTRACTION: "data-extraction",
+ * //   GUIDELINES: "guidelines",
+ * //   GENERATOR: "generator",
+ * // } as const
+ *
+ * // Use in stage definitions
+ * dependencies: [STAGE_IDS.DATA_EXTRACTION],  // Autocomplete!
+ * ```
+ *
+ * ### Pattern 2: Define Stage IDs First (For Complex Workflows)
+ *
+ * ```typescript
+ * export const CERTIFICATE_STAGES = defineStageIds([
+ *   "data-extraction",
+ *   "guidelines",
+ *   "legal-guidance",
+ *   "unified-smart-retrieval",
+ *   "analysis-synthesis",
+ *   "generator",
+ * ] as const);
+ *
+ * // Type: { DATA_EXTRACTION: "data-extraction", ... }
+ * // With validation that stages match workflow definition
+ * ```
+ *
+ * ### Pattern 3: Use with InferWorkflowStageIds
+ *
+ * ```typescript
+ * import type { InferWorkflowStageIds } from "~/lib/workflow-v2/core/workflow";
+ *
+ * type CertificateStageId = InferWorkflowStageIds<typeof certificateWorkflow>;
+ * // = "data-extraction" | "guidelines" | "generator" | ...
+ *
+ * function requireStage(stageId: CertificateStageId) { ... }
+ * ```
+ */
+
+/**
+ * Create a type-safe stage ID constants object from a workflow
+ *
+ * Extracts all stage IDs from a workflow and creates a frozen object
+ * with SCREAMING_SNAKE_CASE keys for autocomplete and type safety.
+ *
+ * @example
+ * ```typescript
+ * import { certificateWorkflow } from "./certificate-workflow";
+ *
+ * export const STAGE_IDS = createStageIds(certificateWorkflow);
+ * // = {
+ * //   DATA_EXTRACTION: "data-extraction",
+ * //   GUIDELINES: "guidelines",
+ * //   LEGAL_GUIDANCE: "legal-guidance",
+ * //   GENERATOR: "generator",
+ * // } as const
+ *
+ * // Use in code with autocomplete:
+ * const data = ctx.require(STAGE_IDS.DATA_EXTRACTION);
+ * ```
+ */
+declare function createStageIds<W extends Workflow<any, any, any>>(workflow: W): StageIdConstants<W>;
+/**
+ * Define stage IDs from a tuple of string literals
+ *
+ * Use this when you want to define stage IDs before building the workflow,
+ * or when you need to share stage IDs across multiple files.
+ *
+ * @example
+ * ```typescript
+ * // Define stage IDs first
+ * export const CERTIFICATE_STAGES = defineStageIds([
+ *   "data-extraction",
+ *   "guidelines",
+ *   "legal-guidance",
+ *   "generator",
+ * ] as const);
+ *
+ * // Use in stage definitions
+ * dependencies: [CERTIFICATE_STAGES.DATA_EXTRACTION],
+ *
+ * // Type-safe access
+ * type StageId = typeof CERTIFICATE_STAGES[keyof typeof CERTIFICATE_STAGES];
+ * // = "data-extraction" | "guidelines" | ...
+ * ```
+ */
+declare function defineStageIds<const T extends readonly string[]>(stageIds: T): DefineStageIdsResult<T>;
+/**
+ * Validate that a stage ID exists in a workflow
+ *
+ * Use this for runtime validation when the stage ID comes from user input.
+ *
+ * @example
+ * ```typescript
+ * const stageId = request.params.stageId;
+ *
+ * if (!isValidStageId(certificateWorkflow, stageId)) {
+ *   throw new Error(`Invalid stage ID: ${stageId}`);
+ * }
+ * ```
+ */
+declare function isValidStageId<W extends Workflow<any, any, any>>(workflow: W, stageId: string): stageId is WorkflowStageId<W>;
+/**
+ * Assert that a stage ID exists in a workflow
+ *
+ * Throws an error with helpful message if the stage ID is invalid.
+ *
+ * @example
+ * ```typescript
+ * assertValidStageId(certificateWorkflow, stageId);
+ * // Now TypeScript knows stageId is a valid stage ID
+ * ```
+ */
+declare function assertValidStageId<W extends Workflow<any, any, any>>(workflow: W, stageId: string): asserts stageId is WorkflowStageId<W>;
+/**
+ * Extract stage IDs as a string union from a Workflow type
+ *
+ * @example
+ * ```typescript
+ * type StageId = WorkflowStageId<typeof certificateWorkflow>;
+ * // = "data-extraction" | "guidelines" | "generator" | ...
+ * ```
+ */
+type WorkflowStageId<W extends Workflow<any, any, any>> = W extends Workflow<any, any, infer C> ? keyof C & string : never;
+/**
+ * Result type for createStageIds function
+ *
+ * Maps each stage ID to a SCREAMING_SNAKE_CASE key.
+ */
+type StageIdConstants<W extends Workflow<any, any, any>> = {
+    readonly [K in WorkflowStageId<W> as Uppercase<K extends string ? ReplaceHyphens<K> : never>]: K;
+};
+/**
+ * Result type for defineStageIds function
+ */
+type DefineStageIdsResult<T extends readonly string[]> = {
+    readonly [K in T[number] as Uppercase<K extends string ? ReplaceHyphens<K> : never>]: K;
+};
+/**
+ * Helper type to replace hyphens with underscores
+ */
+type ReplaceHyphens<S extends string> = S extends `${infer Head}-${infer Tail}` ? `${Head}_${ReplaceHyphens<Tail>}` : S;
+/**
+ * Validate that stage IDs match a workflow's expected stages
+ *
+ * Use this to ensure stage ID constants are in sync with the workflow.
+ *
+ * @example
+ * ```typescript
+ * // This will cause a compile error if stage IDs don't match
+ * const STAGE_IDS: ValidateStageIds<
+ *   typeof certificateWorkflow,
+ *   typeof CERTIFICATE_STAGES
+ * > = CERTIFICATE_STAGES;
+ * ```
+ */
+type ValidateStageIds<W extends Workflow<any, any, any>, T extends Record<string, string>> = {
+    [K in keyof T]: T[K] extends WorkflowStageId<W> ? T[K] : `Error: "${T[K] & string}" is not a valid stage ID in workflow`;
+};
+
 /**
  * Config Presets - Common configuration patterns for workflow stages
  *
@@ -352,25 +527,6 @@ interface BatchStatus {
     totalOutputTokens?: number;
 }
 type BatchState = "pending" | "processing" | "completed" | "failed" | "cancelled";
-/**
- * Result of a single request in a batch
- */
-interface BatchResult<T> {
-    /** Index in the original request array */
-    index: number;
-    /** Custom ID if provided */
-    customId?: string;
-    /** Parsed/validated data */
-    data: T;
-    /** Input tokens used */
-    inputTokens: number;
-    /** Output tokens used */
-    outputTokens: number;
-    /** Status of this individual result */
-    status: "succeeded" | "failed";
-    /** Error message if this specific request failed */
-    error?: string;
-}
 /**
  * Raw result from a provider (before schema validation)
  */
@@ -417,10 +573,6 @@ interface BatchRequestWithSchema<TSchema extends z.ZodTypeAny> extends BaseBatch
 interface BatchRequestText extends BaseBatchRequest {
     schema?: never;
 }
-/**
- * Union type for batch requests
- */
-type BatchRequest<TSchema extends z.ZodTypeAny = z.ZodTypeAny> = BatchRequestWithSchema<TSchema> | BatchRequestText;
 /**
  * Interface that all batch providers must implement
  */
@@ -567,4 +719,4 @@ declare class OpenAIBatchProvider implements BatchProvider<OpenAIBatchRequest, R
     private mapStatus;
 }
 
-export { type AIConfig, AIConfigSchema, AnthropicBatchProvider, type AnthropicBatchProviderConfig, type AnthropicBatchRequest, type BaseBatchRequest, type BatchHandle, type BatchLogger, type BatchMetrics, type BatchProvider, type BatchRequest, type BatchRequestText, type BatchRequestWithSchema, type BatchResult, type BatchState, type BatchStatus, type BatchSubmitOptions, type ConcurrencyConfig, ConcurrencyConfigSchema, type DebugConfig, DebugConfigSchema, type FeatureFlagsConfig, FeatureFlagsConfigSchema, GoogleBatchProvider, type GoogleBatchProviderConfig, type GoogleBatchRequest, ModelKey, OpenAIBatchProvider, type OpenAIBatchProviderConfig, type OpenAIBatchRequest, type RawBatchResult, type SerializedBatch, getBestProviderForModel, resolveModelForProvider, withAIConfig, withConcurrency, withFeatureFlags, withStandardConfig };
+export { type AIConfig, AIConfigSchema, AnthropicBatchProvider, type AnthropicBatchProviderConfig, type AnthropicBatchRequest, type BaseBatchRequest, type BatchLogger, type BatchMetrics, type BatchRequestText, type BatchRequestWithSchema, type BatchState, type BatchStatus, type BatchSubmitOptions, type ConcurrencyConfig, ConcurrencyConfigSchema, type DebugConfig, DebugConfigSchema, type FeatureFlagsConfig, FeatureFlagsConfigSchema, GoogleBatchProvider, type GoogleBatchProviderConfig, type GoogleBatchRequest, ModelKey, OpenAIBatchProvider, type OpenAIBatchProviderConfig, type OpenAIBatchRequest, type RawBatchResult, type SerializedBatch, type ValidateStageIds, Workflow, type WorkflowStageId, assertValidStageId, createStageIds, defineStageIds, getBestProviderForModel, isValidStageId, resolveModelForProvider, withAIConfig, withConcurrency, withFeatureFlags, withStandardConfig };