@bratsos/workflow-engine 0.0.11 → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,569 @@
+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-BCnDUwIc.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-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';
+
+/**
+ * Config Presets - Common configuration patterns for workflow stages
+ *
+ * These presets provide standardized schemas for common stage configurations,
+ * reducing boilerplate and ensuring consistency across stages.
+ *
+ * @example
+ * ```typescript
+ * 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
+ *   },
+ * });
+ *
+ * // 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
+ *   },
+ * });
+ * ```
+ */
+
+/**
+ * AI/LLM configuration options
+ */
+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>;
+/**
+ * Concurrency and rate limiting configuration
+ */
+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>;
+/**
+ * Feature flag configuration for conditional behavior
+ */
+declare const FeatureFlagsConfigSchema: z.ZodObject<{
+    featureFlags: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+}, z.core.$strip>;
+type FeatureFlagsConfig = z.infer<typeof FeatureFlagsConfigSchema>;
+/**
+ * Logging and debugging configuration
+ */
+declare const DebugConfigSchema: z.ZodObject<{
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type DebugConfig = z.infer<typeof DebugConfigSchema>;
+/**
+ * Add AI configuration to any schema
+ *
+ * @example
+ * ```typescript
+ * const myConfig = withAIConfig(z.object({
+ *   customField: z.string(),
+ * }));
+ * // Result has: model, temperature, maxTokens, customField
+ * ```
+ */
+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>;
+/**
+ * Add concurrency configuration to any schema
+ *
+ * @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>;
+/**
+ * Add feature flags configuration to any schema
+ *
+ * @example
+ * ```typescript
+ * const myConfig = withFeatureFlags(z.object({
+ *   setting: z.boolean(),
+ * }));
+ * // Result has: featureFlags, setting
+ * ```
+ */
+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>;
+/**
+ * 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 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
+ *
+ * Dynamically maps models from the registry to provider-specific batch API identifiers.
+ * Uses the `supportsAsyncBatch` flag and OpenRouter ID prefix to determine compatibility.
+ */
+
+declare const BatchProviderName: z$1.ZodEnum<{
+    google: "google";
+    anthropic: "anthropic";
+    openai: "openai";
+}>;
+type BatchProviderName = z$1.infer<typeof BatchProviderName>;
+/**
+ * Get the provider-specific model ID, with fallback to default
+ *
+ * @param modelKey - The ModelKey from model-helper.ts (optional)
+ * @param provider - The batch provider
+ * @returns Provider-specific model ID
+ * @throws Error if model is not supported by the provider
+ */
+declare function resolveModelForProvider(modelKey: ModelKey | undefined, provider: BatchProviderName): string;
+/**
+ * Get the best provider for a given ModelKey
+ * Returns the provider that natively supports the model
+ */
+declare function getBestProviderForModel(modelKey: ModelKey): BatchProviderName | undefined;
+
+/**
+ * Low-Level Batch Provider Types
+ *
+ * These types are used internally by batch providers (Google, Anthropic, OpenAI).
+ * They have more fields than the high-level user-facing types in ai/ai-helper.ts.
+ *
+ * For the user-facing batch API, see:
+ * - AIBatchRequest - simple request with id, prompt, schema
+ * - AIBatchResult<T> - result with id, result, tokens
+ * - AIBatchHandle - handle with id, status, provider
+ *
+ * These provider-level types include additional fields like:
+ * - BatchHandle: requestCount, createdAt, metadata
+ * - BaseBatchRequest: model, system, maxTokens, temperature, tools
+ * - RawBatchResult: raw text before parsing, index
+ */
+
+/** Tool choice options compatible with AI SDK */
+type BatchToolChoice = "auto" | "required" | "none" | {
+    type: "tool";
+    toolName: string;
+};
+/**
+ * Handle returned when a batch is submitted
+ */
+interface BatchHandle {
+    /** Unique identifier for the batch (provider-specific format) */
+    id: string;
+    /** Provider name (google, anthropic, openai) */
+    provider: string;
+    /** Number of requests in the batch */
+    requestCount: number;
+    /** When the batch was created */
+    createdAt: Date;
+    /** Provider-specific metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Status of a batch job
+ */
+interface BatchStatus {
+    /** Current state of the batch */
+    state: BatchState;
+    /** Number of requests processed so far */
+    processedCount: number;
+    /** Total number of requests in the batch */
+    totalCount: number;
+    /** Number of successful requests (if available) */
+    succeededCount?: number;
+    /** Number of failed requests (if available) */
+    failedCount?: number;
+    /** Error message if batch failed */
+    error?: string;
+    /** Estimated completion time (if available) */
+    estimatedCompletion?: Date;
+    /** Total input tokens used (available when batch is complete) */
+    totalInputTokens?: number;
+    /** Total output tokens used (available when batch is complete) */
+    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)
+ */
+interface RawBatchResult {
+    index: number;
+    customId?: string;
+    text: string;
+    inputTokens: number;
+    outputTokens: number;
+    error?: string;
+}
+/**
+ * Base request configuration shared across providers
+ */
+interface BaseBatchRequest {
+    /** The prompt/content to send */
+    prompt: string;
+    /** Optional custom ID for tracking */
+    customId?: string;
+    /** Model to use - accepts ModelKey from model-helper.ts */
+    model?: ModelKey;
+    /** System prompt (if supported) */
+    system?: string;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Temperature for generation */
+    temperature?: number;
+    /** Optional Zod schema for structured output */
+    schema?: z.ZodTypeAny;
+    /** Tool definitions (same as AI SDK generateText/streamText) */
+    tools?: ToolSet;
+    /** Tool choice mode */
+    toolChoice?: BatchToolChoice;
+}
+/**
+ * Request with schema for structured output
+ */
+interface BatchRequestWithSchema<TSchema extends z.ZodTypeAny> extends BaseBatchRequest {
+    schema: TSchema;
+}
+/**
+ * Request without schema (plain text output)
+ */
+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
+ */
+interface BatchProvider<TRequest extends BaseBatchRequest = BaseBatchRequest, TRawResult extends RawBatchResult = RawBatchResult> {
+    /** Provider name (google, anthropic, openai) */
+    readonly name: string;
+    /** Whether this provider supports batching */
+    readonly supportsBatching: boolean;
+    /**
+     * Submit requests to batch processing
+     * @param requests Array of requests to process
+     * @param options Provider-specific options
+     * @returns Handle to track the batch
+     */
+    submit(requests: TRequest[], options?: BatchSubmitOptions): Promise<BatchHandle>;
+    /**
+     * Check the status of a batch
+     * @param handle Batch handle from submit()
+     * @returns Current status
+     */
+    checkStatus(handle: BatchHandle): Promise<BatchStatus>;
+    /**
+     * Retrieve results from a completed batch
+     * @param handle Batch handle from submit()
+     * @returns Array of raw results
+     */
+    getResults(handle: BatchHandle): Promise<TRawResult[]>;
+    /**
+     * Cancel a running batch (optional - not all providers support this)
+     * @param handle Batch handle from submit()
+     */
+    cancel?(handle: BatchHandle): Promise<void>;
+}
+interface BatchSubmitOptions {
+    /** Display name for the batch (if supported) */
+    displayName?: string;
+    /** Completion window (e.g., "24h" for OpenAI) */
+    completionWindow?: string;
+    /** Custom metadata to attach */
+    metadata?: Record<string, string>;
+}
+/**
+ * Serialized batch for persistence during workflow suspension
+ */
+interface SerializedBatch {
+    handle: BatchHandle;
+    providerName: string;
+    /** Serialized schema definitions (if any) */
+    schemaDefinitions?: unknown[];
+}
+/**
+ * Logger interface for batch operations
+ */
+interface BatchLogger {
+    log: (level: LogLevel, message: string, meta?: Record<string, unknown>) => void;
+}
+/**
+ * Aggregated metrics for a batch
+ */
+interface BatchMetrics {
+    provider: string;
+    model: string;
+    requestCount: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    estimatedCost: number;
+    actualDuration: number;
+    successRate: number;
+}
+interface GoogleBatchRequest extends BaseBatchRequest {
+}
+interface AnthropicBatchRequest extends BaseBatchRequest {
+}
+interface OpenAIBatchRequest extends BaseBatchRequest {
+}
+
+/**
+ * Google Batch Provider
+ *
+ * Implements batch processing using Google's GenAI Batch API.
+ * Uses inline requests for simpler API.
+ */
+
+interface GoogleBatchProviderConfig {
+    apiKey?: string;
+}
+declare class GoogleBatchProvider implements BatchProvider<GoogleBatchRequest, RawBatchResult> {
+    readonly name = "google";
+    readonly supportsBatching = true;
+    private ai;
+    private logger?;
+    constructor(config?: GoogleBatchProviderConfig, logger?: BatchLogger);
+    submit(requests: GoogleBatchRequest[], options?: BatchSubmitOptions): Promise<BatchHandle>;
+    checkStatus(handle: BatchHandle): Promise<BatchStatus>;
+    getResults(handle: BatchHandle, customIds?: string[]): Promise<RawBatchResult[]>;
+    cancel(handle: BatchHandle): Promise<void>;
+    private mapState;
+}
+
+/**
+ * Anthropic Batch Provider
+ *
+ * Implements batch processing using Anthropic's Message Batches API.
+ * Supports up to 10,000 requests per batch with 24h processing window.
+ */
+
+interface AnthropicBatchProviderConfig {
+    apiKey?: string;
+}
+declare class AnthropicBatchProvider implements BatchProvider<AnthropicBatchRequest, RawBatchResult> {
+    readonly name = "anthropic";
+    readonly supportsBatching = true;
+    private client;
+    private logger?;
+    constructor(config?: AnthropicBatchProviderConfig, logger?: BatchLogger);
+    submit(requests: AnthropicBatchRequest[], options?: BatchSubmitOptions): Promise<BatchHandle>;
+    checkStatus(handle: BatchHandle): Promise<BatchStatus>;
+    getResults(handle: BatchHandle): Promise<RawBatchResult[]>;
+    cancel(handle: BatchHandle): Promise<void>;
+    private mapStatus;
+}
+
+/**
+ * OpenAI Batch Provider
+ *
+ * Implements batch processing using OpenAI's Batch API.
+ * Note: OpenAI requires JSONL file uploads for batches.
+ * Supports up to 50,000 requests per batch with 24h processing window.
+ */
+
+interface OpenAIBatchProviderConfig {
+    apiKey?: string;
+}
+declare class OpenAIBatchProvider implements BatchProvider<OpenAIBatchRequest, RawBatchResult> {
+    readonly name = "openai";
+    readonly supportsBatching = true;
+    private client;
+    private logger?;
+    constructor(config?: OpenAIBatchProviderConfig, logger?: BatchLogger);
+    submit(requests: OpenAIBatchRequest[], options?: BatchSubmitOptions): Promise<BatchHandle>;
+    checkStatus(handle: BatchHandle): Promise<BatchStatus>;
+    getResults(handle: BatchHandle): Promise<RawBatchResult[]>;
+    cancel(handle: BatchHandle): Promise<void>;
+    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 };