@bratsos/workflow-engine 0.0.11 → 0.2.0

package/dist/client.d.ts

@@ -0,0 +1,5 @@
+export { g as AIHelper, k as AVAILABLE_MODELS, l as AsyncBatchStageDefinition, D as DEFAULT_MODEL_KEY, m as EnhancedStageContext, I as InferInput, V as LogPayload, n as ModelConfig, X as ModelFilter, M as ModelKey, o as ModelRegistry, N as NoInputSchema, S as SimpleStageResult, Y as StageCompletedPayload, Z as StageFailedPayload, _ as StageStartedPayload, t as SyncStageDefinition, $ as WorkflowCompletedPayload, W as WorkflowEventType, a0 as WorkflowFailedPayload, u as WorkflowSSEEvent, a1 as WorkflowStartedPayload, a2 as WorkflowSuspendedPayload, v as calculateCost, x as defineAsyncBatchStage, y as defineStage, H as listModels, K as modelSupportsBatch, Q as registerModels } from './client-D4PoxADF.js';
+import 'ai';
+import 'zod';
+import './interface-MMqhfQQK.js';
+import './stage-BPw7m9Wx.js';

package/dist/client.js

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

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"client.js"}

package/dist/index-DAzCfO1R.d.ts

@@ -0,0 +1,217 @@
+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-MMqhfQQK.js';
+
+/**
+ * PrismaAICallLogger - Prisma implementation of AICallLogger
+ *
+ * Handles AI call logging to the database. Uses fire-and-forget pattern
+ * for non-blocking logging during AI operations.
+ */
+
+type PrismaClient$2 = any;
+declare class PrismaAICallLogger implements AICallLogger {
+    private readonly prisma;
+    constructor(prisma: PrismaClient$2);
+    /**
+     * Log a single AI call (fire and forget)
+     * Does not await - logs asynchronously to avoid blocking AI operations
+     */
+    logCall(call: CreateAICallInput): void;
+    /**
+     * Log batch results (for recording batch API results)
+     */
+    logBatchResults(batchId: string, results: CreateAICallInput[]): Promise<void>;
+    /**
+     * Get aggregated stats for a topic prefix
+     */
+    getStats(topicPrefix: string): Promise<AIHelperStats>;
+    /**
+     * Check if batch results are already recorded
+     */
+    isRecorded(batchId: string): Promise<boolean>;
+}
+declare function createPrismaAICallLogger(prisma: PrismaClient$2): AICallLogger;
+
+/**
+ * PrismaWorkflowPersistence - Prisma implementation of WorkflowPersistence
+ *
+ * This is the default persistence implementation used by the workflow engine.
+ * It wraps Prisma client operations to match the WorkflowPersistence interface.
+ */
+
+type PrismaClient$1 = any;
+type DatabaseType = "postgresql" | "sqlite";
+interface PrismaWorkflowPersistenceOptions {
+    /**
+     * Database type. Defaults to "postgresql".
+     * Set to "sqlite" when using SQLite (uses optimistic locking instead of FOR UPDATE SKIP LOCKED).
+     */
+    databaseType?: DatabaseType;
+}
+declare class PrismaWorkflowPersistence implements WorkflowPersistence {
+    private readonly prisma;
+    private enums;
+    private databaseType;
+    constructor(prisma: PrismaClient$1, options?: PrismaWorkflowPersistenceOptions);
+    withTransaction<T>(fn: (tx: WorkflowPersistence) => Promise<T>): Promise<T>;
+    createRun(data: CreateRunInput): Promise<WorkflowRunRecord>;
+    updateRun(id: string, data: UpdateRunInput): Promise<void>;
+    getRun(id: string): Promise<WorkflowRunRecord | null>;
+    getRunStatus(id: string): Promise<WorkflowStatus | null>;
+    getRunsByStatus(status: WorkflowStatus): Promise<WorkflowRunRecord[]>;
+    claimPendingRun(id: string): Promise<boolean>;
+    claimNextPendingRun(): Promise<WorkflowRunRecord | null>;
+    /**
+     * PostgreSQL implementation using FOR UPDATE SKIP LOCKED for zero-contention claiming.
+     * This atomically:
+     * 1. Finds the highest priority PENDING run (FIFO within same priority)
+     * 2. Locks it exclusively (other workers skip locked rows)
+     * 3. Updates it to RUNNING
+     * 4. Returns the claimed run
+     */
+    private claimNextPendingRunPostgres;
+    /**
+     * SQLite implementation using optimistic locking.
+     * SQLite doesn't support FOR UPDATE SKIP LOCKED, so we use a two-step approach:
+     * 1. Find a PENDING run
+     * 2. Atomically update it (only succeeds if still PENDING)
+     * 3. If another worker claimed it, retry
+     */
+    private claimNextPendingRunSqlite;
+    createStage(data: CreateStageInput): Promise<WorkflowStageRecord>;
+    upsertStage(data: UpsertStageInput): Promise<WorkflowStageRecord>;
+    updateStage(id: string, data: UpdateStageInput): Promise<void>;
+    updateStageByRunAndStageId(workflowRunId: string, stageId: string, data: UpdateStageInput): Promise<void>;
+    private buildRunUpdateData;
+    private buildStageUpdateData;
+    getStage(runId: string, stageId: string): Promise<WorkflowStageRecord | null>;
+    getStageById(id: string): Promise<WorkflowStageRecord | null>;
+    getStagesByRun(runId: string, options?: {
+        status?: WorkflowStageStatus;
+        orderBy?: "asc" | "desc";
+    }): Promise<WorkflowStageRecord[]>;
+    getSuspendedStages(beforeDate: Date): Promise<WorkflowStageRecord[]>;
+    getFirstSuspendedStageReadyToResume(runId: string): Promise<WorkflowStageRecord | null>;
+    getFirstFailedStage(runId: string): Promise<WorkflowStageRecord | null>;
+    getLastCompletedStage(runId: string): Promise<WorkflowStageRecord | null>;
+    getLastCompletedStageBefore(runId: string, executionGroup: number): Promise<WorkflowStageRecord | null>;
+    deleteStage(id: string): Promise<void>;
+    createLog(data: CreateLogInput): Promise<void>;
+    saveArtifact(data: SaveArtifactInput): Promise<void>;
+    loadArtifact(runId: string, key: string): Promise<unknown>;
+    hasArtifact(runId: string, key: string): Promise<boolean>;
+    deleteArtifact(runId: string, key: string): Promise<void>;
+    listArtifacts(runId: string): Promise<WorkflowArtifactRecord[]>;
+    getStageIdForArtifact(runId: string, stageId: string): Promise<string | null>;
+    saveStageOutput(runId: string, workflowType: string, stageId: string, output: unknown): Promise<string>;
+    appendOutboxEvents(events: CreateOutboxEventInput[]): Promise<void>;
+    getUnpublishedOutboxEvents(limit?: number): Promise<OutboxRecord[]>;
+    markOutboxEventsPublished(ids: string[]): Promise<void>;
+    incrementOutboxRetryCount(id: string): Promise<number>;
+    moveOutboxEventToDLQ(id: string): Promise<void>;
+    replayDLQEvents(maxEvents: number): Promise<number>;
+    acquireIdempotencyKey(key: string, commandType: string): Promise<{
+        status: "acquired";
+    } | {
+        status: "replay";
+        result: unknown;
+    } | {
+        status: "in_progress";
+    }>;
+    completeIdempotencyKey(key: string, commandType: string, result: unknown): Promise<void>;
+    releaseIdempotencyKey(key: string, commandType: string): Promise<void>;
+    private mapWorkflowRun;
+    private mapWorkflowStage;
+    private mapOutboxEvent;
+    private mapWorkflowArtifact;
+}
+/**
+ * Factory function to create PrismaWorkflowPersistence
+ */
+declare function createPrismaWorkflowPersistence(prisma: PrismaClient$1, options?: PrismaWorkflowPersistenceOptions): PrismaWorkflowPersistence;
+
+/**
+ * PrismaJobQueue - Prisma implementation of JobQueue
+ *
+ * Provides atomic job queue operations using PostgreSQL
+ * with FOR UPDATE SKIP LOCKED for safe concurrent access.
+ *
+ * This is migrated from the original services/job-queue.server.ts
+ */
+
+type PrismaClient = any;
+interface PrismaJobQueueOptions {
+    /**
+     * Unique worker identifier. Defaults to auto-generated ID.
+     */
+    workerId?: string;
+    /**
+     * Database type. Defaults to "postgresql".
+     * Set to "sqlite" when using SQLite (uses optimistic locking instead of FOR UPDATE SKIP LOCKED).
+     */
+    databaseType?: DatabaseType;
+}
+declare class PrismaJobQueue implements JobQueue {
+    private workerId;
+    private prisma;
+    private enums;
+    private databaseType;
+    constructor(prisma: PrismaClient, options?: PrismaJobQueueOptions);
+    /**
+     * Add a new job to the queue
+     */
+    enqueue(options: EnqueueJobInput): Promise<string>;
+    /**
+     * Enqueue multiple stages in parallel (same execution group)
+     */
+    enqueueParallel(jobs: EnqueueJobInput[]): Promise<string[]>;
+    /**
+     * Atomically dequeue the next available job
+     * Uses FOR UPDATE SKIP LOCKED (PostgreSQL) or optimistic locking (SQLite)
+     */
+    dequeue(): Promise<DequeueResult | null>;
+    /**
+     * PostgreSQL implementation using FOR UPDATE SKIP LOCKED for safe concurrency
+     */
+    private dequeuePostgres;
+    /**
+     * SQLite implementation using optimistic locking.
+     * SQLite doesn't support FOR UPDATE SKIP LOCKED, so we use a two-step approach:
+     * 1. Find a PENDING job
+     * 2. Atomically update it (only succeeds if still PENDING)
+     * 3. If another worker claimed it, retry
+     */
+    private dequeueSqlite;
+    /**
+     * Mark job as completed
+     */
+    complete(jobId: string): Promise<void>;
+    /**
+     * Mark job as suspended (for async-batch)
+     */
+    suspend(jobId: string, nextPollAt: Date): Promise<void>;
+    /**
+     * Mark job as failed
+     */
+    fail(jobId: string, error: string, shouldRetry?: boolean): Promise<void>;
+    /**
+     * Get suspended jobs that are ready to be checked
+     */
+    getSuspendedJobsReadyToPoll(): Promise<Array<{
+        jobId: string;
+        stageId: string;
+        workflowRunId: string;
+    }>>;
+    /**
+     * Release stale locks (for crashed workers)
+     */
+    releaseStaleJobs(staleThresholdMs?: number): Promise<number>;
+}
+/**
+ * Factory function to create PrismaJobQueue with prisma client
+ *
+ * @param prisma - Prisma client instance
+ * @param optionsOrWorkerId - Options object or workerId string (for backwards compatibility)
+ */
+declare function createPrismaJobQueue(prisma: PrismaClient, optionsOrWorkerId?: PrismaJobQueueOptions | string): JobQueue;
+
+export { type DatabaseType as D, PrismaAICallLogger as P, PrismaJobQueue as a, type PrismaJobQueueOptions as b, PrismaWorkflowPersistence as c, type PrismaWorkflowPersistenceOptions as d, createPrismaAICallLogger as e, createPrismaJobQueue as f, createPrismaWorkflowPersistence as g };