@bratsos/workflow-engine 0.1.0 → 0.2.1

package/dist/index.d.ts

@@ -1,633 +1,266 @@
-import { S as Stage, a as StageMetrics, W as WorkflowEventType, b as WorkflowSSEEvent, L as LogContext, A as AIHelper, M as ModelKey, c as LogLevel } from './client-5vz5Vv4A.js';
-export { d as AIBatch, e as AIBatchHandle, f as AIBatchProvider, g as AIBatchRequest, h as AIBatchResult, i as AICallType, j as AIEmbedResult, k as AIObjectResult, l as AIStreamResult, m as AITextResult, n as AVAILABLE_MODELS, o as AsyncBatchStageDefinition, B as BatchLogFn, D as DEFAULT_MODEL_KEY, E as EmbedOptions, p as EnhancedStageContext, I as InferInput, q as ModelConfig, r as ModelRegistry, s as ModelStats, t as ModelStatsTracker, u as ModelSyncConfig, N as NoInputSchema, O as ObjectOptions, R as RecordCallParams, v as SimpleStageResult, w as StageResult, x as StreamOptions, y as SyncStageDefinition, T as TextOptions, z as calculateCost, C as createAIHelper, F as defineAsyncBatchStage, G as defineStage, H as getDefaultModel, J as getModel, K as getModelById, P as getRegisteredModel, Q as listModels, U as listRegisteredModels, V as modelSupportsBatch, X as printAvailableModels, Y as registerModels, Z as requireStageOutput } from './client-5vz5Vv4A.js';
+import { M as ModelKey } from './client-D4PoxADF.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 registerModels, U as requireStageOutput } from './client-D4PoxADF.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-CPC-X0rR.js';
 import z$1, { z } from 'zod';
-import { EventEmitter } from 'node:events';
-import { W as WorkflowPersistence, A as AICallLogger, J as JobQueue } from './interface-Cv22wvLG.js';
-export { b as AICallRecord, a as AIHelperStats, p as ArtifactType, C as CreateAICallInput, m as CreateLogInput, e as CreateRunInput, h as CreateStageInput, D as DequeueResult, E as EnqueueJobInput, c as JobRecord, d as JobStatus, L as LogLevel, S as SaveArtifactInput, q as Status, U as UpdateRunInput, k as UpdateStageInput, j as UpsertStageInput, n as WorkflowArtifactRecord, o as WorkflowLogRecord, f as WorkflowRunRecord, i as WorkflowStageRecord, l as WorkflowStageStatus, g as WorkflowStatus } from './interface-Cv22wvLG.js';
-export { P as PrismaAICallLogger, a as PrismaJobQueue, c as PrismaWorkflowPersistence, e as createPrismaAICallLogger, f as createPrismaJobQueue, g as createPrismaWorkflowPersistence } from './index-DmR3E8D7.js';
+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-MMqhfQQK.js';
+export { P as PrismaAICallLogger, a as PrismaJobQueue, c as PrismaWorkflowPersistence, e as createPrismaAICallLogger, f as createPrismaJobQueue, g as createPrismaWorkflowPersistence } from './index-DAzCfO1R.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-tU3rzPXJ.js';
 
 /**
- * Workflow Builder - Fluent API for composing type-safe workflows
+ * Config Presets - Common configuration patterns for workflow stages
  *
- * Workflows are composed of stages that are executed sequentially or in parallel.
- * The builder ensures type safety: output of one stage matches input of next stage.
- *
- * ## Type System Features
- *
- * ### Automatic Context Inference
- * The workflow context type is automatically accumulated as you pipe stages.
- * Use `InferWorkflowContext<typeof workflow>` to extract the context type.
- *
- * ```typescript
- * const workflow = new WorkflowBuilder(...)
- *   .pipe(stage1)
- *   .pipe(stage2)
- *   .build();
- *
- * // Auto-generated type
- * type MyContext = InferWorkflowContext<typeof workflow>;
- * // = { "stage-1": Stage1Output, "stage-2": Stage2Output }
- * ```
- *
- * ### Stage ID Constants
- * Use `workflow.stageIds` for type-safe stage ID references.
- */
-
-interface StageNode {
-    stage: Stage<any, any, any>;
-    executionGroup: number;
-}
-declare class Workflow<TInput extends z.ZodTypeAny, TOutput extends z.ZodTypeAny, TContext extends Record<string, unknown> = {}> {
-    readonly id: string;
-    readonly name: string;
-    readonly description: string;
-    readonly inputSchema: TInput;
-    readonly outputSchema: TOutput;
-    private readonly stages;
-    readonly contextType?: TContext | undefined;
-    constructor(id: string, name: string, description: string, inputSchema: TInput, outputSchema: TOutput, stages: StageNode[], contextType?: TContext | undefined);
-    /**
-     * Get execution plan as groups of stages
-     * Stages in the same group can be executed in parallel
-     */
-    getExecutionPlan(): StageNode[][];
-    /**
-     * Get a specific stage by ID
-     */
-    getStage(stageId: string): Stage<any, any, any> | undefined;
-    /**
-     * Get all stages in order
-     */
-    getAllStages(): StageNode[];
-    /**
-     * Get a visual representation of the workflow execution order
-     */
-    getExecutionOrder(): string;
-    /**
-     * Get all stage IDs in execution order
-     *
-     * @returns Array of stage IDs
-     *
-     * @example
-     * ```typescript
-     * const ids = workflow.getStageIds();
-     * // ["data-extraction", "guidelines", "generator"]
-     * ```
-     */
-    getStageIds(): string[];
-    /**
-     * Check if a stage ID exists in this workflow
-     *
-     * @param stageId - The stage ID to check
-     * @returns true if the stage exists
-     */
-    hasStage(stageId: string): boolean;
-    /**
-     * Validate workflow configuration before execution
-     * Checks that all stage configs match their schemas
-     *
-     * @param config - Configuration object with keys matching stage IDs
-     * @returns Validation result with any errors
-     */
-    validateConfig(config: Record<string, unknown>): {
-        valid: boolean;
-        errors: Array<{
-            stageId: string;
-            error: string;
-        }>;
-    };
-    /**
-     * Estimate total cost for the workflow
-     */
-    estimateCost(input: z.infer<TInput>, config: Record<string, unknown>): number;
-    /**
-     * Get configuration schemas for all stages in this workflow
-     * Returns a map of stageId → { schema, defaults, name, description }
-     */
-    getStageConfigs(): Record<string, {
-        schema: z.ZodTypeAny;
-        defaults: Record<string, unknown>;
-        name: string;
-        description?: string;
-    }>;
-    /**
-     * Generate default configuration object for all stages
-     * Automatically discovers all stage configs - add/remove stages and this updates automatically
-     */
-    getDefaultConfig(): Record<string, Record<string, unknown>>;
-    /**
-     * Get all stages in a specific execution group
-     */
-    getStagesInExecutionGroup(groupIndex: number): Stage<any, any, any>[];
-    /**
-     * Get the sequential index of a stage (0-based)
-     */
-    getStageIndex(stageId: string): number;
-    /**
-     * Get the execution group index for a stage
-     */
-    getExecutionGroupIndex(stageId: string): number;
-    /**
-     * Get the ID of the stage immediately preceding the given stage
-     */
-    getPreviousStageId(stageId: string): string | undefined;
-}
-declare class WorkflowBuilder<TInput extends z.ZodTypeAny, TCurrentOutput extends z.ZodTypeAny, TContext extends Record<string, unknown> = {}> {
-    private id;
-    private name;
-    private description;
-    private inputSchema;
-    private currentOutputSchema;
-    private stages;
-    private currentExecutionGroup;
-    constructor(id: string, name: string, description: string, inputSchema: TInput, currentOutputSchema: TCurrentOutput);
-    /**
-     * Add a stage to the workflow (sequential execution)
-     *
-     * Automatically accumulates the stage's output in the context under its stage ID.
-     * This provides type-safe access to all previous stage outputs.
-     *
-     * Note: This accepts any stage regardless of strict input type matching.
-     * This is necessary because stages using passthrough() can accept objects
-     * with additional fields beyond what's declared in their input schema.
-     * Runtime validation via Zod ensures type safety at execution time.
-     *
-     * Validates that all declared dependencies exist in the workflow.
-     */
-    pipe<TStageInput extends z.ZodTypeAny, TStageOutput extends z.ZodTypeAny, TStageConfig extends z.ZodTypeAny, TStageContext extends Record<string, unknown>>(stage: Stage<TStageInput, TStageOutput, TStageConfig, TStageContext>): WorkflowBuilder<TInput, TStageOutput, TContext & {
-        [x: string]: z.infer<TStageOutput>;
-    }>;
-    /**
-     * Add a stage with strict input type checking
-     *
-     * Note: pipeStrict() and pipeLoose() have been removed as they were
-     * just aliases for pipe(). Use pipe() for all stage chaining.
-     */
-    /**
-     * Add multiple stages that execute in parallel
-     *
-     * All stages receive the same input (current output)
-     * Their outputs are merged into an object by index AND accumulated in context by stage ID.
-     *
-     * Note: This accepts stages regardless of strict input type matching.
-     * This is necessary because stages using passthrough() can accept objects
-     * with additional fields. Runtime validation via Zod ensures type safety.
-     *
-     * Validates that all declared dependencies exist in the workflow.
-     */
-    parallel<TStages extends {
-        id: string;
-        outputSchema: z.ZodTypeAny;
-        dependencies?: string[];
-    }[]>(stages: [...TStages]): WorkflowBuilder<TInput, z.ZodTypeAny, TContext & {
-        [K in TStages[number]["id"]]: TStages[number] extends {
-            outputSchema: infer O;
-        } ? O extends z.ZodTypeAny ? z.infer<O> : never : never;
-    }>;
-    /**
-     * Build the final workflow
-     */
-    build(): Workflow<TInput, TCurrentOutput, TContext>;
-    /**
-     * Get current stage count
-     */
-    getStageCount(): number;
-    /**
-     * Get execution group count
-     */
-    getExecutionGroupCount(): number;
-}
-/**
- * Extract stage IDs as a union type from a Workflow instance
- *
- * Useful for creating type-safe stage ID references.
+ * These presets provide standardized schemas for common stage configurations,
+ * reducing boilerplate and ensuring consistency across stages.
  *
  * @example
  * ```typescript
- * type StageId = InferWorkflowStageIds<typeof myWorkflow>;
- * // = "data-extraction" | "guidelines" | "generator"
+ * import { defineStage } from "./stage-factory";
+ * import { withAIConfig, withStandardConfig } from "./config-presets";
+ *
+ * // Use AI-focused config preset
+ * const myStage = defineStage({
+ *   id: "my-stage",
+ *   name: "My Stage",
+ *   schemas: {
+ *     input: z.object({ data: z.string() }),
+ *     output: z.object({ result: z.string() }),
+ *     config: withAIConfig(z.object({
+ *       customField: z.string(),
+ *     })),
+ *   },
+ *   async execute(ctx) {
+ *     // ctx.config.model, ctx.config.temperature available
+ *     // plus ctx.config.customField
+ *   },
+ * });
  *
- * function getStageOutput(stageId: StageId) { ... }
+ * // Use standard config preset (includes AI + concurrency + feature flags)
+ * const fullStage = defineStage({
+ *   id: "full-stage",
+ *   name: "Full Stage",
+ *   schemas: {
+ *     input: "none",
+ *     output: z.object({ result: z.string() }),
+ *     config: withStandardConfig(z.object({
+ *       specificOption: z.boolean().default(true),
+ *     })),
+ *   },
+ *   async execute(ctx) {
+ *     // All standard config + custom fields available
+ *   },
+ * });
  * ```
  */
-type InferWorkflowStageIds<W> = W extends Workflow<any, any, infer C> ? keyof C & string : never;
 
 /**
- * Workflow Executor - Executes workflows with support for resume and suspension
- *
- * Key features:
- * - Sequential and parallel stage execution
- * - Automatic state persistence to R2 and database
- * - Resume from last completed stage
- * - Suspend/resume for long-running batch jobs
- * - Event emission for real-time updates
- *
- * Note: Stages should import createAIHelper directly from ~/lib/ai-helper
- * and create their own AI helper instances with appropriate topics.
- * The executor creates a helper for tracking aggregate stats per stage.
+ * AI/LLM configuration options
  */
-
-interface WorkflowExecutorOptions {
-    persistence?: WorkflowPersistence;
-    /** Optional AI call logger. If not provided, AI tracking is disabled. */
-    aiLogger?: AICallLogger;
-}
-declare class WorkflowExecutor extends EventEmitter {
-    private workflow;
-    private workflowRunId;
-    private workflowType;
-    private cancelled;
-    private persistence;
-    private aiLogger;
-    constructor(workflow: Workflow<any, any>, workflowRunId: string, workflowType: string, storageProviderOrOptions?: WorkflowExecutorOptions);
-    /**
-     * Override emit to also forward events to the global event bus for SSE
-     */
-    emit(eventName: string | symbol, ...args: any[]): boolean;
-    /**
-     * Check if the workflow has been interrupted (cancelled or suspended) externally
-     * This checks the database status to detect external requests
-     */
-    private checkExternalInterruption;
-    /**
-     * 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
-     */
-    execute<TInput, TOutput>(input: TInput, config: Record<string, unknown>, options?: {
-        resume?: boolean;
-        fromStage?: string;
-    }): Promise<TOutput | "suspended">;
-    /**
-     * Execute a single stage
-     */
-    private executeStage;
-    /**
-     * Load resume state from database
-     */
-    private loadResumeState;
-    /**
-     * Load workflow context from all completed stages
-     * This rebuilds the workflowContext object so resumed stages can access previous outputs
-     */
-    private loadWorkflowContext;
-    /**
-     * 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
-     */
-    private loadFromStageState;
-    /**
-     * Create a minimal storage shim for context.storage (for API compatibility).
-     * Stage implementations should not rely on this - it may be removed in future.
-     */
-    private createStorageShim;
-    /**
-     * Get aggregated statistics for the workflow run
-     */
-    private getAggregatedStats;
-    /**
-     * Log a message with automatic database persistence
-     */
-    private log;
-}
-
+declare const AIConfigSchema: z.ZodObject<{
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type AIConfig = z.infer<typeof AIConfigSchema>;
 /**
- * Stage Executor - Executes a single stage
- *
- * Unlike WorkflowExecutor which runs entire workflows,
- * this executes exactly ONE stage and returns.
- *
- * Designed for distributed workers.
+ * Concurrency and rate limiting configuration
  */
-
-interface WorkflowRegistry {
-    getWorkflow(id: string): Workflow<any, any> | undefined;
-}
-interface StageExecutionRequest {
-    workflowRunId: string;
-    workflowId: string;
-    stageId: string;
-    config: Record<string, unknown>;
-}
-interface StageExecutionResult {
-    type: "completed" | "suspended" | "failed";
-    output?: unknown;
-    suspendedState?: unknown;
-    nextPollAt?: Date;
-    error?: string;
-    metrics?: StageMetrics;
-}
-declare class StageExecutor {
-    private registry;
-    private persistence;
-    private workerId;
-    constructor(registry: WorkflowRegistry, persistence: WorkflowPersistence, workerId?: string);
-    /**
-     * Execute a single stage
-     */
-    execute(request: StageExecutionRequest): Promise<StageExecutionResult>;
-    private handleCompleted;
-    private handleSuspended;
-    private handleFailed;
-    private loadWorkflowContext;
-    /**
-     * Create a minimal storage shim for context.storage (for API compatibility).
-     * Stage implementations should not rely on this - it may be removed in future.
-     */
-    private createStorageShim;
-    private resolveStageInput;
-    private getStageNumber;
-    private getExecutionGroup;
-    private log;
-}
-
+declare const ConcurrencyConfigSchema: z.ZodObject<{
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    delayMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type ConcurrencyConfig = z.infer<typeof ConcurrencyConfigSchema>;
 /**
- * Storage abstraction for stage artifacts and outputs
- *
- * Modified to support Prisma/Memory storage only (R2 removed)
+ * Feature flag configuration for conditional behavior
  */
-interface StageStorage {
-    /**
-     * Save data to storage
-     */
-    save<T>(key: string, data: T): Promise<void>;
-    /**
-     * Load data from storage
-     */
-    load<T>(key: string): Promise<T>;
-    /**
-     * Check if key exists in storage
-     */
-    exists(key: string): Promise<boolean>;
-    /**
-     * Delete data from storage
-     */
-    delete(key: string): Promise<void>;
-    /**
-     * Generate a storage key for a stage
-     */
-    getStageKey(stageId: string, suffix?: string): string;
-    /**
-     * Save stage output with standard key
-     */
-    saveStageOutput<T>(stageId: string, output: T): Promise<string>;
-    /**
-     * Load stage output with standard key
-     */
-    loadStageOutput<T>(stageId: string): Promise<T>;
-    /**
-     * Save arbitrary artifact for a stage
-     */
-    saveArtifact<T>(stageId: string, artifactName: string, data: T): Promise<string>;
-    /**
-     * Load arbitrary artifact for a stage
-     */
-    loadArtifact<T>(stageId: string, artifactName: string): Promise<T>;
-    /**
-     * List all artifacts for a workflow run (for export)
-     */
-    listAllArtifacts(): Promise<Array<{
-        key: string;
-        stageId: string;
-        name: string;
-    }>>;
-    /**
-     * Provider metadata
-     */
-    readonly providerType: "prisma" | "memory";
-}
-
+declare const FeatureFlagsConfigSchema: z.ZodObject<{
+    featureFlags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+}, z.core.$strip>;
+type FeatureFlagsConfig = z.infer<typeof FeatureFlagsConfigSchema>;
 /**
- * Factory for creating storage provider instances
- *
- * Prisma storage requires a PrismaClient to be passed via options.
+ * Logging and debugging configuration
  */
-
-type PrismaClient = any;
-type StorageProviderType = "prisma" | "memory";
-interface StorageFactoryOptions {
-    provider: StorageProviderType;
-    workflowRunId: string;
-    workflowType: string;
-    /** Required when provider is "prisma" */
-    prisma?: PrismaClient;
-}
+declare const DebugConfigSchema: z.ZodObject<{
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type DebugConfig = z.infer<typeof DebugConfigSchema>;
 /**
- * Create a storage instance based on the provider type
- */
-declare function createStorage(options: StorageFactoryOptions): StageStorage;
-/**
- * Get default provider from environment or config
- * Falls back to 'prisma' for database-backed persistence
+ * Add AI configuration to any schema
+ *
+ * @example
+ * ```typescript
+ * const myConfig = withAIConfig(z.object({
+ *   customField: z.string(),
+ * }));
+ * // Result has: model, temperature, maxTokens, customField
+ * ```
  */
-declare function getDefaultStorageProvider(): StorageProviderType;
-
+declare function withAIConfig<T extends z.ZodRawShape>(schema: z.ZodObject<T>): z.ZodObject<(keyof T & ("model" | "temperature" | "maxTokens") extends never ? T & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+} : { [K in keyof T as K extends "model" | "temperature" | "maxTokens" ? never : K]: T[K]; } & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}) extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.core.$strip>;
 /**
- * Workflow Event Bus - Global event emitter for workflow events
- *
- * This singleton allows SSE endpoints to subscribe to real-time workflow events
- * emitted by WorkflowExecutor instances running in the same process.
- *
- * Supports cross-process events via PostgreSQL LISTEN/NOTIFY when enabled.
+ * Add concurrency configuration to any schema
  *
- * Events are namespaced by workflowRunId:
- * - workflow:{runId}:stage:started
- * - workflow:{runId}:stage:completed
- * - workflow:{runId}:log
- * - etc.
+ * @example
+ * ```typescript
+ * const myConfig = withConcurrency(z.object({
+ *   items: z.array(z.string()),
+ * }));
+ * // Result has: concurrency, delayMs, maxRetries, items
+ * ```
  */
-
+declare function withConcurrency<T extends z.ZodRawShape>(schema: z.ZodObject<T>): z.ZodObject<(keyof T & ("concurrency" | "delayMs" | "maxRetries") extends never ? T & {
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    delayMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+} : { [K in keyof T as K extends "concurrency" | "delayMs" | "maxRetries" ? never : K]: T[K]; } & {
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    delayMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+}) extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.core.$strip>;
 /**
- * Interface matching PgNotify from @zertai/database
- * Defined here to avoid importing the database package into workflow-engine
- */
-interface PgNotifyLike {
-    listen(channel: string, handler: (channel: string, payload: string) => void): Promise<() => void>;
-    notify(channel: string, payload: string): Promise<void>;
-    isConnected(): boolean;
-}
-declare class WorkflowEventBus extends EventEmitter {
-    private static instance;
-    private pgNotify;
-    private static readonly PG_CHANNEL;
-    private pgListenerUnsubscribe;
-    private static readonly MAX_PAYLOAD_SIZE;
-    private constructor();
-    static getInstance(): WorkflowEventBus;
-    /**
-     * 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
-     */
-    enablePgNotify(pgNotify: PgNotifyLike): Promise<void>;
-    /**
-     * Disable cross-process events (for cleanup)
-     */
-    disablePgNotify(): void;
-    /**
-     * Check if cross-process events are enabled
-     */
-    isPgNotifyEnabled(): boolean;
-    /**
-     * Truncate event payload to fit within PostgreSQL NOTIFY size limits.
-     * Large data fields (like workflow output) are replaced with a truncation marker.
-     */
-    private truncatePayloadForNotify;
-    /**
-     * Emit event locally only (used for re-emitting pg notifications)
-     */
-    private emitLocally;
-    /**
-     * 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: string, eventType: WorkflowEventType, payload: Record<string, unknown>): void;
-    /**
-     * Subscribe to all events for a specific workflow run
-     */
-    subscribeToWorkflow(workflowRunId: string, handler: (event: WorkflowSSEEvent) => void): () => void;
-    /**
-     * Subscribe to a specific event type globally (across all workflows)
-     */
-    subscribeGlobal(eventType: WorkflowEventType, handler: (event: WorkflowSSEEvent) => void): () => void;
-    /**
-     * Subscribe to a specific event type for a workflow
-     */
-    subscribeToEvent(workflowRunId: string, eventType: WorkflowEventType, handler: (event: WorkflowSSEEvent) => void): () => void;
-}
-declare const workflowEventBus: WorkflowEventBus;
-
-/**
- * Workflow Runtime - Unified API for workflow execution
+ * Add feature flags configuration to any schema
  *
- * The main entry point for the workflow engine. Handles everything:
- * - Creating new workflow runs (with validation)
- * - Polling for pending workflows → enqueuing first stage
- * - Processing jobs from the queue (executing stages)
- * - Polling for suspended stages → resuming execution
- * - Transitioning workflows between stages
+ * @example
+ * ```typescript
+ * const myConfig = withFeatureFlags(z.object({
+ *   setting: z.boolean(),
+ * }));
+ * // Result has: featureFlags, setting
+ * ```
  */
-
-interface WorkflowRuntimeConfig {
-    /** Persistence implementation */
-    persistence: WorkflowPersistence;
-    /** Job queue implementation */
-    jobQueue: JobQueue;
-    /** Workflow registry */
-    registry: WorkflowRegistry;
-    /** AI call logger for createAIHelper */
-    aiCallLogger?: AICallLogger;
-    /** Interval between poll cycles in milliseconds (default: 10000) */
-    pollIntervalMs?: number;
-    /** Interval between job dequeue attempts in milliseconds (default: 1000) */
-    jobPollIntervalMs?: number;
-    /** Worker ID (default: auto-generated) */
-    workerId?: string;
-    /** Stale job threshold in milliseconds (default: 60000) */
-    staleJobThresholdMs?: number;
-    /** Function to determine workflow priority */
-    getWorkflowPriority?: (workflowId: string) => number;
-}
-interface CreateRunOptions {
-    workflowId: string;
-    input: Record<string, unknown>;
-    config?: Record<string, unknown>;
-    priority?: number;
-    /** Domain-specific metadata */
-    metadata?: Record<string, unknown>;
-}
-interface CreateRunResult {
-    workflowRunId: string;
-}
-declare class WorkflowRuntime {
-    private isPolling;
-    private isProcessingJobs;
-    private isRunning;
-    private pollIntervalMs;
-    private jobPollIntervalMs;
-    private staleJobThresholdMs;
-    private workerId;
-    private persistence;
-    private jobQueue;
-    private registry;
-    private aiCallLogger?;
-    private getWorkflowPriority?;
-    private pollTimer;
-    private stageExecutor;
-    private jobsProcessed;
-    constructor(config: WorkflowRuntimeConfig);
-    /**
-     * 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: string, logContext?: LogContext): AIHelper;
-    /**
-     * Create a LogContext for a workflow stage (for use with createAIHelper)
-     * This enables batch operations to log to the workflow persistence.
-     */
-    createLogContext(workflowRunId: string, stageRecordId: string): LogContext;
-    /**
-     * Start the runtime as a full worker (processes jobs + polls)
-     */
-    start(): Promise<void>;
-    /**
-     * Stop the runtime
-     */
-    stop(): void;
-    /**
-     * Create a new workflow run with validation.
-     * The runtime will pick it up on the next poll cycle and start execution.
-     */
-    createRun(options: CreateRunOptions): Promise<CreateRunResult>;
-    /**
-     * Process jobs from the queue
-     */
-    private processJobs;
-    private getWorkflowId;
-    /**
-     * Poll for pending workflows and suspended stages
-     */
-    private poll;
-    /**
-     * Poll for pending workflows and enqueue their first stage.
-     * Uses claimNextPendingRun() for zero-contention claiming with FOR UPDATE SKIP LOCKED.
-     */
-    private pollPendingWorkflows;
-    /**
-     * Poll suspended stages and resume if ready (public for manual triggering)
-     */
-    pollSuspendedStages(): Promise<void>;
-    /**
-     * Transition a workflow to its next state (public for external calls)
-     */
-    transitionWorkflow(workflowRunId: string): Promise<void>;
-    private checkAndResume;
-    private resumeWorkflow;
-    /**
-     * Create a minimal storage shim for context.storage (for API compatibility).
-     */
-    private createStorageShim;
-    private markStageFailed;
-    private enqueueExecutionGroup;
-    private completeWorkflow;
-}
+declare function withFeatureFlags<T extends z.ZodRawShape>(schema: z.ZodObject<T>): z.ZodObject<(keyof T & "featureFlags" extends never ? T & {
+    featureFlags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+} : { [K in keyof T as K extends "featureFlags" ? never : K]: T[K]; } & {
+    featureFlags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+}) extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.core.$strip>;
 /**
- * Factory function to create a WorkflowRuntime instance
+ * Standard config preset combining AI + Concurrency + Feature Flags
+ *
+ * This is the recommended preset for most stages that need:
+ * - AI/LLM operations
+ * - Parallel processing
+ * - Feature flagging
+ *
+ * @example
+ * ```typescript
+ * const myConfig = withStandardConfig(z.object({
+ *   customOption: z.boolean().default(true),
+ * }));
+ * // Result has all standard fields plus customOption
+ * ```
  */
-declare function createWorkflowRuntime(config: WorkflowRuntimeConfig): WorkflowRuntime;
+declare function withStandardConfig<T extends z.ZodRawShape>(schema: z.ZodObject<T>): z.ZodObject<(keyof (keyof (keyof T & ("model" | "temperature" | "maxTokens") extends never ? T & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+} : { [K in keyof T as K extends "model" | "temperature" | "maxTokens" ? never : K]: T[K]; } & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}) & ("concurrency" | "delayMs" | "maxRetries") extends never ? ((keyof T & ("model" | "temperature" | "maxTokens") extends never ? T & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+} : { [K in keyof T as K extends "model" | "temperature" | "maxTokens" ? never : K]: T[K]; } & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}) extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never) & {
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    delayMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+} : (((keyof T & ("model" | "temperature" | "maxTokens") extends never ? T & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+} : { [K in keyof T as K extends "model" | "temperature" | "maxTokens" ? never : K]: T[K]; } & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}) extends infer T_4 ? { [k_1 in keyof T_4]: T_4[k_1]; } : never) extends infer T_3 extends z.core.util.SomeObject ? { [K_1 in keyof T_3 as K_1 extends "concurrency" | "delayMs" | "maxRetries" ? never : K_1]: T_3[K_1]; } : never) & {
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    delayMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+}) & "featureFlags" extends never ? ((keyof (keyof T & ("model" | "temperature" | "maxTokens") extends never ? T & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+} : { [K in keyof T as K extends "model" | "temperature" | "maxTokens" ? never : K]: T[K]; } & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}) & ("concurrency" | "delayMs" | "maxRetries") extends never ? ((keyof T & ("model" | "temperature" | "maxTokens") extends never ? T & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+} : { [K in keyof T as K extends "model" | "temperature" | "maxTokens" ? never : K]: T[K]; } & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}) extends infer T_6 ? { [k_1 in keyof T_6]: T_6[k_1]; } : never) & {
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    delayMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+} : (((keyof T & ("model" | "temperature" | "maxTokens") extends never ? T & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+} : { [K in keyof T as K extends "model" | "temperature" | "maxTokens" ? never : K]: T[K]; } & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}) extends infer T_8 ? { [k_1 in keyof T_8]: T_8[k_1]; } : never) extends infer T_7 extends z.core.util.SomeObject ? { [K_1 in keyof T_7 as K_1 extends "concurrency" | "delayMs" | "maxRetries" ? never : K_1]: T_7[K_1]; } : never) & {
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    delayMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+}) extends infer T_5 ? { [k_2 in keyof T_5]: T_5[k_2]; } : never) & {
+    featureFlags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+} : (((keyof (keyof T & ("model" | "temperature" | "maxTokens") extends never ? T & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+} : { [K in keyof T as K extends "model" | "temperature" | "maxTokens" ? never : K]: T[K]; } & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}) & ("concurrency" | "delayMs" | "maxRetries") extends never ? ((keyof T & ("model" | "temperature" | "maxTokens") extends never ? T & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+} : { [K in keyof T as K extends "model" | "temperature" | "maxTokens" ? never : K]: T[K]; } & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}) extends infer T_11 ? { [k_1 in keyof T_11]: T_11[k_1]; } : never) & {
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    delayMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+} : (((keyof T & ("model" | "temperature" | "maxTokens") extends never ? T & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+} : { [K in keyof T as K extends "model" | "temperature" | "maxTokens" ? never : K]: T[K]; } & {
+    model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"gemini-2.5-flash", string>>>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}) extends infer T_13 ? { [k_1 in keyof T_13]: T_13[k_1]; } : never) extends infer T_12 extends z.core.util.SomeObject ? { [K_1 in keyof T_12 as K_1 extends "concurrency" | "delayMs" | "maxRetries" ? never : K_1]: T_12[K_1]; } : never) & {
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    delayMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+}) extends infer T_10 ? { [k_2 in keyof T_10]: T_10[k_2]; } : never) extends infer T_9 extends z.core.util.SomeObject ? { [K_2 in keyof T_9 as K_2 extends "featureFlags" ? never : K_2]: T_9[K_2]; } : never) & {
+    featureFlags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+}) extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.core.$strip>;
 
 /**
  * Model Mapping for Batch Providers
@@ -933,4 +566,4 @@ declare class OpenAIBatchProvider implements BatchProvider<OpenAIBatchRequest, R
     private mapStatus;
 }
 
-export { AICallLogger, AIHelper, 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 CreateRunOptions, type CreateRunResult, GoogleBatchProvider, type GoogleBatchProviderConfig, type GoogleBatchRequest, type InferWorkflowStageIds, JobQueue, LogContext, ModelKey, OpenAIBatchProvider, type OpenAIBatchProviderConfig, type OpenAIBatchRequest, type PgNotifyLike, type RawBatchResult, type SerializedBatch, Stage, type StageExecutionRequest, type StageExecutionResult, StageExecutor, Workflow, WorkflowBuilder, WorkflowEventType, WorkflowExecutor, WorkflowPersistence, type WorkflowRegistry, WorkflowRuntime, type WorkflowRuntimeConfig, WorkflowSSEEvent, createStorage, createWorkflowRuntime, getBestProviderForModel, getDefaultStorageProvider, resolveModelForProvider, workflowEventBus };
+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 };