@bratsos/workflow-engine 0.0.11 → 0.1.0

package/dist/interface-Cv22wvLG.d.ts

@@ -0,0 +1,344 @@
+/**
+ * Persistence Interfaces for Workflow Engine
+ *
+ * These interfaces abstract database operations to enable:
+ * - Testing with mock implementations
+ * - Future extraction into @bratsos/workflow-engine package
+ * - Alternative database backends
+ *
+ * Implementations:
+ * - PrismaWorkflowPersistence (default, in ./prisma/)
+ * - InMemoryPersistence (for testing)
+ */
+/**
+ * Unified status type for workflows, stages, and jobs.
+ *
+ * - PENDING: Not started yet
+ * - RUNNING: Currently executing
+ * - SUSPENDED: Paused, waiting for external event (e.g., batch job completion)
+ * - COMPLETED: Finished successfully
+ * - FAILED: Finished with error
+ * - CANCELLED: Manually stopped by user
+ * - SKIPPED: Stage-specific - bypassed due to condition
+ */
+type Status = "PENDING" | "RUNNING" | "SUSPENDED" | "COMPLETED" | "FAILED" | "CANCELLED" | "SKIPPED";
+/** @deprecated Use Status instead */
+type WorkflowStatus = Status;
+/** @deprecated Use Status instead */
+type WorkflowStageStatus = Status;
+/** @deprecated Use Status instead. Note: PROCESSING is now RUNNING. */
+type JobStatus = Status;
+type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR";
+type ArtifactType = "STAGE_OUTPUT" | "ARTIFACT" | "METADATA";
+interface WorkflowRunRecord {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    workflowId: string;
+    workflowName: string;
+    workflowType: string;
+    status: WorkflowStatus;
+    startedAt: Date | null;
+    completedAt: Date | null;
+    duration: number | null;
+    input: unknown;
+    output: unknown | null;
+    config: unknown;
+    totalCost: number;
+    totalTokens: number;
+    priority: number;
+}
+interface WorkflowStageRecord {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    workflowRunId: string;
+    stageId: string;
+    stageName: string;
+    stageNumber: number;
+    executionGroup: number;
+    status: WorkflowStageStatus;
+    startedAt: Date | null;
+    completedAt: Date | null;
+    duration: number | null;
+    inputData: unknown | null;
+    outputData: unknown | null;
+    config: unknown | null;
+    suspendedState: unknown | null;
+    resumeData: unknown | null;
+    nextPollAt: Date | null;
+    pollInterval: number | null;
+    maxWaitUntil: Date | null;
+    metrics: unknown | null;
+    embeddingInfo: unknown | null;
+    errorMessage: string | null;
+}
+interface WorkflowLogRecord {
+    id: string;
+    createdAt: Date;
+    workflowStageId: string | null;
+    workflowRunId: string | null;
+    level: LogLevel;
+    message: string;
+    metadata: unknown | null;
+}
+interface WorkflowArtifactRecord {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    workflowRunId: string;
+    workflowStageId: string | null;
+    key: string;
+    type: ArtifactType;
+    data: unknown;
+    size: number;
+    metadata: unknown | null;
+}
+interface AICallRecord {
+    id: string;
+    createdAt: Date;
+    topic: string;
+    callType: string;
+    modelKey: string;
+    modelId: string;
+    prompt: string;
+    response: string;
+    inputTokens: number;
+    outputTokens: number;
+    cost: number;
+    metadata: unknown | null;
+}
+interface JobRecord {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    workflowRunId: string;
+    stageId: string;
+    status: JobStatus;
+    priority: number;
+    workerId: string | null;
+    lockedAt: Date | null;
+    startedAt: Date | null;
+    completedAt: Date | null;
+    attempt: number;
+    maxAttempts: number;
+    lastError: string | null;
+    nextPollAt: Date | null;
+    payload: Record<string, unknown>;
+}
+interface CreateRunInput {
+    id?: string;
+    workflowId: string;
+    workflowName: string;
+    workflowType: string;
+    input: unknown;
+    config?: unknown;
+    priority?: number;
+    /** Optional metadata for domain-specific fields */
+    metadata?: Record<string, unknown>;
+}
+interface UpdateRunInput {
+    status?: WorkflowStatus;
+    startedAt?: Date;
+    completedAt?: Date;
+    duration?: number;
+    output?: unknown;
+    totalCost?: number;
+    totalTokens?: number;
+}
+interface CreateStageInput {
+    workflowRunId: string;
+    stageId: string;
+    stageName: string;
+    stageNumber: number;
+    executionGroup: number;
+    status?: WorkflowStageStatus;
+    startedAt?: Date;
+    config?: unknown;
+    inputData?: unknown;
+}
+interface UpdateStageInput {
+    status?: WorkflowStageStatus;
+    startedAt?: Date;
+    completedAt?: Date;
+    duration?: number;
+    outputData?: unknown;
+    config?: unknown;
+    suspendedState?: unknown;
+    resumeData?: unknown;
+    nextPollAt?: Date | null;
+    pollInterval?: number;
+    maxWaitUntil?: Date;
+    metrics?: unknown;
+    embeddingInfo?: unknown;
+    artifacts?: unknown;
+    errorMessage?: string;
+}
+interface UpsertStageInput {
+    workflowRunId: string;
+    stageId: string;
+    create: CreateStageInput;
+    update: UpdateStageInput;
+}
+interface CreateLogInput {
+    workflowRunId?: string;
+    workflowStageId?: string;
+    level: LogLevel;
+    message: string;
+    metadata?: unknown;
+}
+interface SaveArtifactInput {
+    workflowRunId: string;
+    workflowStageId?: string;
+    key: string;
+    type: ArtifactType;
+    data: unknown;
+    size: number;
+    metadata?: unknown;
+}
+interface CreateAICallInput {
+    topic: string;
+    callType: string;
+    modelKey: string;
+    modelId: string;
+    prompt: string;
+    response: string;
+    inputTokens: number;
+    outputTokens: number;
+    cost: number;
+    metadata?: unknown;
+}
+interface EnqueueJobInput {
+    workflowRunId: string;
+    stageId: string;
+    priority?: number;
+    payload?: Record<string, unknown>;
+    scheduledFor?: Date;
+}
+interface DequeueResult {
+    jobId: string;
+    workflowRunId: string;
+    stageId: string;
+    priority: number;
+    attempt: number;
+    payload: Record<string, unknown>;
+}
+interface WorkflowPersistence {
+    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[]>;
+    /**
+     * Atomically claim a pending workflow run for processing.
+     * Uses atomic update with WHERE status = 'PENDING' to prevent race conditions.
+     *
+     * @param id - The workflow run ID to claim
+     * @returns true if successfully claimed, false if already claimed by another worker
+     */
+    claimPendingRun(id: string): Promise<boolean>;
+    /**
+     * Atomically find and claim the next pending workflow run.
+     * Uses FOR UPDATE SKIP LOCKED pattern (in Postgres) to prevent race conditions
+     * when multiple workers try to claim workflows simultaneously.
+     *
+     * Priority ordering: higher priority first, then oldest (FIFO within same priority).
+     *
+     * @returns The claimed workflow run (now with status RUNNING), or null if no pending runs
+     */
+    claimNextPendingRun(): Promise<WorkflowRunRecord | null>;
+    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>;
+    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>;
+}
+interface AIHelperStats {
+    totalCalls: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCost: number;
+    perModel: Record<string, {
+        calls: number;
+        inputTokens: number;
+        outputTokens: number;
+        cost: number;
+    }>;
+}
+interface AICallLogger {
+    /**
+     * Log a single AI call (fire and forget)
+     */
+    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>;
+}
+interface JobQueue {
+    /**
+     * 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
+     */
+    dequeue(): Promise<DequeueResult | null>;
+    /**
+     * 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>;
+}
+
+export type { AICallLogger as A, CreateAICallInput as C, DequeueResult as D, EnqueueJobInput as E, JobQueue as J, LogLevel as L, SaveArtifactInput as S, UpdateRunInput as U, WorkflowPersistence as W, AIHelperStats as a, AICallRecord as b, JobRecord as c, JobStatus as d, CreateRunInput as e, WorkflowRunRecord as f, WorkflowStatus as g, CreateStageInput as h, WorkflowStageRecord as i, UpsertStageInput as j, UpdateStageInput as k, WorkflowStageStatus as l, CreateLogInput as m, WorkflowArtifactRecord as n, WorkflowLogRecord as o, ArtifactType as p, Status as q };

package/dist/persistence/index.d.ts

@@ -0,0 +1,2 @@
+export { A as AICallLogger, 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, J as JobQueue, 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, W as WorkflowPersistence, 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';

package/dist/persistence/index.js

@@ -0,0 +1,5 @@
+import '../chunk-D7RVRRM2.js';
+export { PrismaAICallLogger, PrismaJobQueue, PrismaWorkflowPersistence, createPrismaAICallLogger, createPrismaJobQueue, createPrismaWorkflowPersistence } from '../chunk-7IITBLFY.js';
+import '../chunk-MUWP5SF2.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/persistence/index.js.map

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

package/dist/persistence/prisma/index.d.ts

@@ -0,0 +1,37 @@
+export { D as DatabaseType, P as PrismaAICallLogger, a as PrismaJobQueue, b as PrismaJobQueueOptions, c as PrismaWorkflowPersistence, d as PrismaWorkflowPersistenceOptions, e as createPrismaAICallLogger, f as createPrismaJobQueue, g as createPrismaWorkflowPersistence } from '../../index-DmR3E8D7.js';
+import '../../interface-Cv22wvLG.js';
+
+/**
+ * Prisma Enum Compatibility Layer
+ *
+ * Provides compatibility between Prisma 6.x (string enums) and Prisma 7.x (typed enums).
+ * Prisma 7.x introduced runtime enum validation, requiring actual enum values instead of strings.
+ *
+ * This utility resolves enum values from the Prisma client's $Enums property when available,
+ * falling back to string values for older Prisma versions.
+ *
+ * @example
+ * ```typescript
+ * const helper = createEnumHelper(prisma);
+ *
+ * // Instead of: status: "PENDING"
+ * // Use: status: helper.status("PENDING")
+ * ```
+ */
+type PrismaClient = any;
+interface PrismaEnumHelper {
+    /** Resolve Status enum value (unified enum for workflows, stages, and jobs) */
+    status(value: string): unknown;
+    /** Resolve ArtifactType enum value */
+    artifactType(value: string): unknown;
+    /** Resolve LogLevel enum value */
+    logLevel(value: string): unknown;
+}
+/**
+ * Creates an enum helper that resolves enum values from the Prisma client.
+ *
+ * Supports both Prisma 6.x (returns string) and Prisma 7.x (returns typed enum).
+ */
+declare function createEnumHelper(prisma: PrismaClient): PrismaEnumHelper;
+
+export { type PrismaEnumHelper, createEnumHelper };

package/dist/persistence/prisma/index.js

@@ -0,0 +1,4 @@
+export { PrismaAICallLogger, PrismaJobQueue, PrismaWorkflowPersistence, createEnumHelper, createPrismaAICallLogger, createPrismaJobQueue, createPrismaWorkflowPersistence } from '../../chunk-7IITBLFY.js';
+import '../../chunk-MUWP5SF2.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/persistence/prisma/index.js.map

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

package/dist/testing/index.d.ts

@@ -0,0 +1,242 @@
+import { A as AICallLogger, C as CreateAICallInput, a as AIHelperStats, b as AICallRecord, J as JobQueue, E as EnqueueJobInput, D as DequeueResult, c as JobRecord, d as JobStatus, W as WorkflowPersistence, e as CreateRunInput, f as WorkflowRunRecord, U as UpdateRunInput, g as WorkflowStatus, h as CreateStageInput, i as WorkflowStageRecord, j as UpsertStageInput, k as UpdateStageInput, l as WorkflowStageStatus, m as CreateLogInput, S as SaveArtifactInput, n as WorkflowArtifactRecord, o as WorkflowLogRecord } from '../interface-Cv22wvLG.js';
+
+/**
+ * In-Memory AI Call Logger
+ *
+ * A complete in-memory implementation of AICallLogger for testing.
+ * Tracks all AI calls with full cost/token tracking and topic-based aggregation.
+ *
+ * @example
+ * ```typescript
+ * import { InMemoryAICallLogger } from '@bratsos/workflow-engine/testing';
+ *
+ * const aiLogger = new InMemoryAICallLogger();
+ * // Use in tests...
+ * aiLogger.clear(); // Reset between tests
+ * ```
+ */
+
+declare class InMemoryAICallLogger implements AICallLogger {
+    private calls;
+    private recordedBatches;
+    /**
+     * Log a single AI call (fire and forget)
+     */
+    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>;
+    /**
+     * Clear all data - useful between tests
+     */
+    clear(): void;
+    /**
+     * Get all calls for inspection
+     */
+    getAllCalls(): AICallRecord[];
+    /**
+     * Get calls by topic for inspection
+     */
+    getCallsByTopic(topic: string): AICallRecord[];
+    /**
+     * Get calls by topic prefix for inspection
+     */
+    getCallsByTopicPrefix(prefix: string): AICallRecord[];
+    /**
+     * Get calls by model for inspection
+     */
+    getCallsByModel(modelKey: string): AICallRecord[];
+    /**
+     * Get calls by call type for inspection
+     */
+    getCallsByType(callType: string): AICallRecord[];
+    /**
+     * Get total cost across all calls
+     */
+    getTotalCost(): number;
+    /**
+     * Get total tokens across all calls
+     */
+    getTotalTokens(): {
+        input: number;
+        output: number;
+    };
+    /**
+     * Get call count
+     */
+    getCallCount(): number;
+    /**
+     * Get all recorded batch IDs
+     */
+    getRecordedBatchIds(): string[];
+    /**
+     * Get the last call made (useful for assertions)
+     */
+    getLastCall(): AICallRecord | null;
+    /**
+     * Assert a call was made with specific properties
+     */
+    hasCallMatching(predicate: (call: AICallRecord) => boolean): boolean;
+}
+
+/**
+ * In-Memory Job Queue
+ *
+ * A complete in-memory implementation of JobQueue for testing.
+ * Supports priority ordering, locking, and stale job recovery.
+ *
+ * @example
+ * ```typescript
+ * import { InMemoryJobQueue } from '@bratsos/workflow-engine/testing';
+ *
+ * const jobQueue = new InMemoryJobQueue();
+ * // Use in tests...
+ * jobQueue.clear(); // Reset between tests
+ * ```
+ */
+
+declare class InMemoryJobQueue implements JobQueue {
+    private jobs;
+    private workerId;
+    private defaultMaxAttempts;
+    constructor(workerId?: string);
+    enqueue(options: EnqueueJobInput): Promise<string>;
+    enqueueParallel(jobs: EnqueueJobInput[]): Promise<string[]>;
+    dequeue(): Promise<DequeueResult | null>;
+    complete(jobId: string): Promise<void>;
+    suspend(jobId: string, nextPollAt: Date): Promise<void>;
+    fail(jobId: string, error: string, shouldRetry?: boolean): Promise<void>;
+    getSuspendedJobsReadyToPoll(): Promise<Array<{
+        jobId: string;
+        stageId: string;
+        workflowRunId: string;
+    }>>;
+    releaseStaleJobs(staleThresholdMs?: number): Promise<number>;
+    /**
+     * Clear all jobs - useful between tests
+     */
+    clear(): void;
+    /**
+     * Get all jobs for inspection
+     */
+    getAllJobs(): JobRecord[];
+    /**
+     * Get jobs by status for inspection
+     */
+    getJobsByStatus(status: JobStatus): JobRecord[];
+    /**
+     * Get a specific job by ID
+     */
+    getJob(jobId: string): JobRecord | null;
+    /**
+     * Get the worker ID for this queue instance
+     */
+    getWorkerId(): string;
+    /**
+     * Set max attempts for new jobs
+     */
+    setDefaultMaxAttempts(maxAttempts: number): void;
+    /**
+     * Simulate a worker crash by releasing a job's lock without completing it
+     */
+    simulateCrash(jobId: string): void;
+    /**
+     * Move a suspended job back to pending (for manual resume testing)
+     */
+    resumeJob(jobId: string): void;
+    /**
+     * Set lockedAt for testing stale job scenarios
+     */
+    setJobLockedAt(jobId: string, lockedAt: Date): void;
+    /**
+     * Set nextPollAt for testing suspended job polling
+     */
+    setJobNextPollAt(jobId: string, nextPollAt: Date | null): void;
+}
+
+/**
+ * In-Memory Workflow Persistence
+ *
+ * A complete in-memory implementation of WorkflowPersistence for testing.
+ * All data is stored in Maps and lost when the instance is garbage collected.
+ *
+ * @example
+ * ```typescript
+ * import { InMemoryWorkflowPersistence } from '@bratsos/workflow-engine/testing';
+ *
+ * const persistence = new InMemoryWorkflowPersistence();
+ * // Use in tests...
+ * persistence.clear(); // Reset between tests
+ * ```
+ */
+
+declare class InMemoryWorkflowPersistence implements WorkflowPersistence {
+    private runs;
+    private stages;
+    private logs;
+    private artifacts;
+    private stageKey;
+    private artifactKey;
+    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>;
+    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>;
+    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>;
+    /**
+     * Clear all data - useful between tests
+     */
+    clear(): void;
+    /**
+     * Get all runs for inspection
+     */
+    getAllRuns(): WorkflowRunRecord[];
+    /**
+     * Get all stages for inspection
+     */
+    getAllStages(): WorkflowStageRecord[];
+    /**
+     * Get all logs for inspection
+     */
+    getAllLogs(): WorkflowLogRecord[];
+    /**
+     * Get all artifacts for inspection
+     */
+    getAllArtifacts(): WorkflowArtifactRecord[];
+}
+
+export { InMemoryAICallLogger, InMemoryJobQueue, InMemoryWorkflowPersistence };