@od-oneapp/ai-platform 0.1.0

package/dist/pipelines.mjs

@@ -0,0 +1,1534 @@
+import { t as __exportAll } from "./chunk-CkzbjWQW.mjs";
+import { Nt as streamText, Z as generateId, a as isModelRef, et as generateText } from "./ai-runtime-CDzQztTt.mjs";
+import { r as getErrorCode } from "./errors-Dtn-UeRi.mjs";
+import { r as logGeneration } from "./audit-logger-CHIP8bRO.mjs";
+import { n as postprocessText, r as preprocessMessages } from "./compliance-wrapper-CrOMHhHN.mjs";
+import { n as createVercelBlobClient } from "./vercel-blob-adapter-CkOXLT2D.mjs";
+import { t as createUpstashRedis } from "./upstash-adapter-D96Caq2O.mjs";
+import { logError, logInfo, logWarn } from "@od-oneapp/shared/logs";
+
+//#region src/pipelines/step-executor.ts
+/**
+* @fileoverview Step Executor
+* Step Executor
+* Executes individual pipeline steps with compliance
+* Leverages AI SDK v6 native features (AbortSignal for timeouts, usage Promise)
+*/
+/**
+* Execute a single pipeline step with compliance
+* Uses AI SDK v6 native features:
+* - AbortSignal for timeouts
+* - usage Promise for token tracking
+* - Native streaming APIs
+*/
+async function executeStep(step, previousResults, globalCompliance, actorId, runId) {
+	const startTime = Date.now();
+	const result = {
+		stepId: step.id,
+		stepName: step.name,
+		stepIndex: previousResults.length,
+		status: "running",
+		output: null,
+		phiDetections: [],
+		startedAt: /* @__PURE__ */ new Date(),
+		metadata: step.transformOutput ? { hasTransform: true } : void 0
+	};
+	const abortController = new AbortController();
+	const timeoutMs = step.timeoutMs ?? 12e4;
+	const timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+	try {
+		if (step.skipIf) {
+			if (await step.skipIf(previousResults)) {
+				clearTimeout(timeoutId);
+				result.status = "skipped";
+				result.completedAt = /* @__PURE__ */ new Date();
+				result.durationMs = Date.now() - startTime;
+				return result;
+			}
+		}
+		let messages;
+		if (step.transformInput) messages = await step.transformInput(previousResults);
+		else {
+			const lastOutput = previousResults[previousResults.length - 1]?.output;
+			if (typeof lastOutput === "string") messages = [{
+				role: "user",
+				content: lastOutput
+			}];
+			else messages = [{
+				role: "user",
+				content: "Continue"
+			}];
+		}
+		if (step.systemPrompt) messages = [{
+			role: "system",
+			content: step.systemPrompt
+		}, ...messages];
+		const compliance = {
+			...globalCompliance,
+			...step.compliance
+		};
+		const { messages: processedMessages, detections } = await preprocessMessages(messages, compliance);
+		result.phiDetections = detections;
+		const baseOptions = {
+			model: step.model,
+			messages: processedMessages,
+			temperature: step.temperature,
+			tools: step.tools,
+			abortSignal: abortController.signal
+		};
+		const options = step.maxTokens ? {
+			...baseOptions,
+			maxOutputTokens: step.maxTokens
+		} : baseOptions;
+		let output;
+		let usage;
+		if (step.streaming) {
+			const streamResult = await streamText(options);
+			clearTimeout(timeoutId);
+			output = "";
+			for await (const chunk of streamResult.textStream) output += chunk;
+			usage = await streamResult.usage;
+		} else {
+			const generateResult = await generateText(options);
+			clearTimeout(timeoutId);
+			output = generateResult.text;
+			usage = await generateResult.usage;
+		}
+		result.usage = {
+			promptTokens: usage.inputTokens ?? 0,
+			completionTokens: usage.outputTokens ?? 0,
+			totalTokens: usage.totalTokens ?? 0
+		};
+		let finalOutput = output;
+		if (step.transformOutput) finalOutput = await step.transformOutput(output);
+		if (typeof finalOutput === "string") {
+			const { text: sanitized, detections: outputDetections } = await postprocessText(finalOutput, compliance);
+			finalOutput = sanitized;
+			result.phiDetections.push(...outputDetections);
+		}
+		result.output = finalOutput;
+		result.status = "completed";
+		result.completedAt = /* @__PURE__ */ new Date();
+		result.durationMs = Date.now() - startTime;
+		await logGeneration(actorId, JSON.stringify(messages), finalOutput, {
+			runId,
+			stepId: step.id,
+			stepName: step.name,
+			phiDetections: result.phiDetections.length,
+			usage: result.usage
+		});
+		return result;
+	} catch (error) {
+		clearTimeout(timeoutId);
+		result.status = "failed";
+		result.completedAt = /* @__PURE__ */ new Date();
+		result.durationMs = Date.now() - startTime;
+		const isTimeout = error instanceof Error && error.name === "AbortError";
+		result.error = {
+			message: isTimeout ? `Step timeout after ${timeoutMs}ms` : error instanceof Error ? error.message : "Unknown error",
+			code: isTimeout ? "TIMEOUT" : getErrorCode(error),
+			stack: error instanceof Error ? error.stack : void 0
+		};
+		await logGeneration(actorId, JSON.stringify({ step: step.id }), { error: result.error }, {
+			runId,
+			stepId: step.id,
+			stepName: step.name,
+			failed: true
+		});
+		return result;
+	}
+}
+/**
+* Execute step with retry logic
+* Note: Custom retry wrapper - AI SDK v6 doesn't have built-in retry yet
+*/
+async function executeStepWithRetry(step, previousResults, globalCompliance, actorId, runId) {
+	const retry = step.retry ?? {
+		maxAttempts: 1,
+		delayMs: 0
+	};
+	let lastError = null;
+	for (let attempt = 0; attempt < retry.maxAttempts; attempt++) {
+		try {
+			const result = await executeStep(step, previousResults, globalCompliance, actorId, runId);
+			if (result.status === "completed" || result.status === "skipped") return result;
+			lastError = new Error(result.error?.message ?? "Step failed");
+		} catch (error) {
+			lastError = error instanceof Error ? error : /* @__PURE__ */ new Error("Unknown error");
+		}
+		if (attempt < retry.maxAttempts - 1) {
+			const delay = retry.backoff === "exponential" ? retry.delayMs * Math.pow(2, attempt) : retry.delayMs;
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+	}
+	throw lastError ?? /* @__PURE__ */ new Error("Step failed after retries");
+}
+
+//#endregion
+//#region src/pipelines/validation.ts
+/**
+* @fileoverview Pipeline Validation Utilities
+* Pipeline Validation Utilities
+* Validate pipeline configurations before execution
+*/
+/**
+* Validate pipeline configuration
+*/
+function validatePipelineConfig(config) {
+	const errors = [];
+	const warnings = [];
+	if (!config.id || config.id.trim() === "") errors.push({
+		field: "id",
+		message: "Pipeline ID is required",
+		severity: "error"
+	});
+	if (!config.name || config.name.trim() === "") errors.push({
+		field: "name",
+		message: "Pipeline name is required",
+		severity: "error"
+	});
+	if (!config.actorId || config.actorId.trim() === "") errors.push({
+		field: "actorId",
+		message: "Actor ID is required for audit compliance",
+		severity: "error"
+	});
+	if (!config.storage) errors.push({
+		field: "storage",
+		message: "Storage type is required",
+		severity: "error"
+	});
+	if (!config.steps || config.steps.length === 0) errors.push({
+		field: "steps",
+		message: "Pipeline must have at least one step",
+		severity: "error"
+	});
+	else {
+		config.steps.forEach((step, index) => {
+			const stepErrors = validatePipelineStep(step, index);
+			errors.push(...stepErrors.filter((e) => e.severity === "error"));
+			warnings.push(...stepErrors.filter((e) => e.severity === "warning"));
+		});
+		const stepIds = config.steps.map((s) => s.id);
+		const duplicates = stepIds.filter((id, index) => stepIds.indexOf(id) !== index);
+		if (duplicates.length > 0) errors.push({
+			field: "steps",
+			message: `Duplicate step IDs found: ${duplicates.join(", ")}`,
+			severity: "error"
+		});
+	}
+	if (!config.compliance) warnings.push({
+		field: "compliance",
+		message: "No compliance configuration provided",
+		severity: "warning"
+	});
+	if (!config.initialMessages || config.initialMessages.length === 0) warnings.push({
+		field: "initialMessages",
+		message: "No initial messages provided",
+		severity: "warning"
+	});
+	if (config.enableResumption && !config.resumeFromRunId) {}
+	if (config.resumeFromRunId && !config.enableResumption) warnings.push({
+		field: "resumeFromRunId",
+		message: "resumeFromRunId provided but enableResumption is false",
+		severity: "warning"
+	});
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings
+	};
+}
+/**
+* Validate individual pipeline step
+*/
+function validatePipelineStep(step, index) {
+	const errors = [];
+	const field = `steps[${index}]`;
+	if (!step.id || step.id.trim() === "") errors.push({
+		field: `${field}.id`,
+		message: `Step ${index}: ID is required`,
+		severity: "error"
+	});
+	if (!step.name || step.name.trim() === "") errors.push({
+		field: `${field}.name`,
+		message: `Step ${index}: Name is required`,
+		severity: "error"
+	});
+	if (!step.model) errors.push({
+		field: `${field}.model`,
+		message: `Step ${index}: Model is required`,
+		severity: "error"
+	});
+	else if (!isModelRef(step.model)) errors.push({
+		field: `${field}.model`,
+		message: `Step ${index}: Model must be a string or a language model instance`,
+		severity: "error"
+	});
+	if (step.temperature !== void 0 && (step.temperature < 0 || step.temperature > 2)) errors.push({
+		field: `${field}.temperature`,
+		message: `Step ${index}: Temperature must be between 0 and 2`,
+		severity: "error"
+	});
+	if (step.maxTokens !== void 0) {
+		if (step.maxTokens < 1) errors.push({
+			field: `${field}.maxTokens`,
+			message: `Step ${index}: maxTokens must be positive`,
+			severity: "error"
+		});
+		if (step.maxTokens > 1e5) errors.push({
+			field: `${field}.maxTokens`,
+			message: `Step ${index}: maxTokens seems unusually high (${step.maxTokens})`,
+			severity: "warning"
+		});
+	}
+	if (step.timeoutMs !== void 0) {
+		if (step.timeoutMs < 1e3) errors.push({
+			field: `${field}.timeoutMs`,
+			message: `Step ${index}: Timeout too short (minimum 1000ms recommended)`,
+			severity: "warning"
+		});
+		if (step.timeoutMs > 6e5) errors.push({
+			field: `${field}.timeoutMs`,
+			message: `Step ${index}: Timeout very long (${step.timeoutMs}ms = ${step.timeoutMs / 6e4} minutes)`,
+			severity: "warning"
+		});
+	}
+	if (step.retry) {
+		if (step.retry.maxAttempts < 1) errors.push({
+			field: `${field}.retry.maxAttempts`,
+			message: `Step ${index}: maxAttempts must be at least 1`,
+			severity: "error"
+		});
+		if (step.retry.maxAttempts > 10) errors.push({
+			field: `${field}.retry.maxAttempts`,
+			message: `Step ${index}: maxAttempts very high (${step.retry.maxAttempts})`,
+			severity: "warning"
+		});
+		if (step.retry.delayMs < 0) errors.push({
+			field: `${field}.retry.delayMs`,
+			message: `Step ${index}: Retry delay must be non-negative`,
+			severity: "error"
+		});
+	}
+	return errors;
+}
+/**
+* Assert pipeline config is valid (throws on error)
+*/
+function assertValidPipelineConfig(config) {
+	const result = validatePipelineConfig(config);
+	if (!result.valid) {
+		const errorMessages = result.errors.map((e) => `  - ${e.field}: ${e.message}`);
+		throw new Error(`Invalid pipeline configuration:\n${errorMessages.join("\n")}`);
+	}
+	if (result.warnings.length > 0) {
+		logWarn("Pipeline configuration warnings", { warnings: result.warnings });
+		result.warnings.forEach((w) => {
+			logWarn(`  - ${w.field}: ${w.message}`, {
+				field: w.field,
+				message: w.message
+			});
+		});
+	}
+}
+/**
+* Validate storage configuration
+*/
+function validateStorageConfig(config) {
+	const errors = [];
+	const warnings = [];
+	if (config.type === "blob") {
+		if (!config.blob?.token) errors.push({
+			field: "blob.token",
+			message: "Blob token is required for blob storage",
+			severity: "error"
+		});
+		if (!config.redis?.url || !config.redis?.token) errors.push({
+			field: "redis",
+			message: "Redis configuration is required for blob storage",
+			severity: "error"
+		});
+	}
+	if (config.type === "postgres") {
+		if (!config.postgres?.connectionString) errors.push({
+			field: "postgres.connectionString",
+			message: "Connection string is required for postgres storage",
+			severity: "error"
+		});
+		if (!config.blob?.token) errors.push({
+			field: "blob.token",
+			message: "Blob token is required for postgres storage (artifacts)",
+			severity: "error"
+		});
+	}
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings
+	};
+}
+
+//#endregion
+//#region src/pipelines/multi-step-wrapper.ts
+/**
+* @fileoverview Multi-Step Pipeline Executor
+* Multi-Step Pipeline Executor
+* Orchestrates execution of multi-step AI pipelines with compliance
+*/
+/**
+* Execute a compliant multi-step pipeline
+*
+* @throws {Error} If pipeline configuration is invalid
+* @throws {Error} If storage initialization fails
+* @throws {Error} If any step fails and cannot be retried
+*/
+async function executeCompliantPipeline(config, storage) {
+	try {
+		assertValidPipelineConfig(config);
+	} catch (error) {
+		throw new Error(`Pipeline configuration validation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+	try {
+		await storage.initialize();
+	} catch (error) {
+		throw new Error(`Storage initialization failed: ${error instanceof Error ? error.message : "Unknown error"}. Check your storage configuration and credentials.`);
+	}
+	let run;
+	let startStepIndex = 0;
+	let previousResults = [];
+	if (config.resumeFromRunId) {
+		const existingRun = await storage.getRun(config.resumeFromRunId);
+		if (!existingRun) throw new Error(`Run ${config.resumeFromRunId} not found`);
+		run = existingRun;
+		startStepIndex = run.currentStepIndex;
+		previousResults = await storage.getStepResults(run.runId);
+		await storage.updateRun(run.runId, { status: "running" });
+	} else run = await storage.createRun(config);
+	const startTime = Date.now();
+	try {
+		const initialStep = config.steps[startStepIndex];
+		if (config.hooks?.onStepStart && initialStep) await config.hooks.onStepStart(initialStep, run.runId);
+		for (let i = startStepIndex; i < config.steps.length; i++) {
+			const step = config.steps[i];
+			if (!step) continue;
+			if (config.hooks?.onStepStart) await config.hooks.onStepStart(step, run.runId);
+			const result = await executeStepWithRetry(step, previousResults, config.compliance, config.actorId, run.runId);
+			if (result.output && typeof result.output === "string") result.artifacts = { output: await storage.storeArtifact(run.runId, step.id, {
+				type: "output",
+				content: result.output,
+				contentType: "text/plain"
+			}) };
+			await storage.addStepResult(run.runId, result);
+			previousResults.push(result);
+			await storage.updateRun(run.runId, {
+				currentStepIndex: i + 1,
+				totalPHIDetections: run.totalPHIDetections + result.phiDetections.length,
+				totalTokens: run.totalTokens + (result.usage?.totalTokens ?? 0)
+			});
+			if (config.hooks?.onStepComplete) await config.hooks.onStepComplete(result, run.runId);
+			if (result.status === "failed") throw new Error(`Step ${step.name} failed: ${result.error?.message}`);
+		}
+		const totalDurationMs = Date.now() - startTime;
+		await storage.updateRun(run.runId, {
+			status: "completed",
+			completedAt: /* @__PURE__ */ new Date(),
+			totalDurationMs
+		});
+		const finalResult = {
+			run: {
+				...run,
+				status: "completed",
+				completedAt: /* @__PURE__ */ new Date(),
+				totalDurationMs,
+				steps: previousResults
+			},
+			output: previousResults[previousResults.length - 1]?.output,
+			steps: previousResults,
+			success: true,
+			compliance: {
+				totalPHIRedacted: previousResults.reduce((sum, r) => sum + r.phiDetections.length, 0),
+				phiByType: previousResults.flatMap((r) => r.phiDetections).reduce((acc, d) => {
+					acc[d.type] = (acc[d.type] || 0) + 1;
+					return acc;
+				}, {}),
+				totalAuditEvents: previousResults.length,
+				policyViolations: 0
+			}
+		};
+		if (config.hooks?.onPipelineComplete) await config.hooks.onPipelineComplete(previousResults, run.runId);
+		return finalResult;
+	} catch (error) {
+		const totalDurationMs = Date.now() - startTime;
+		await storage.updateRun(run.runId, {
+			status: "failed",
+			completedAt: /* @__PURE__ */ new Date(),
+			totalDurationMs,
+			error: {
+				message: error instanceof Error ? error.message : "Unknown error",
+				code: getErrorCode(error),
+				stack: error instanceof Error ? error.stack : void 0,
+				failedStep: config.steps[run.currentStepIndex]?.id
+			}
+		});
+		if (config.hooks?.onPipelineError) await config.hooks.onPipelineError(error instanceof Error ? error : /* @__PURE__ */ new Error("Unknown error"), run.runId);
+		return {
+			run: {
+				...run,
+				status: "failed",
+				completedAt: /* @__PURE__ */ new Date(),
+				totalDurationMs,
+				steps: previousResults,
+				error: {
+					message: error instanceof Error ? error.message : "Unknown error",
+					code: getErrorCode(error),
+					stack: error instanceof Error ? error.stack : void 0,
+					failedStep: config.steps[run.currentStepIndex]?.id
+				}
+			},
+			output: null,
+			steps: previousResults,
+			success: false,
+			compliance: {
+				totalPHIRedacted: previousResults.reduce((sum, r) => sum + r.phiDetections.length, 0),
+				phiByType: previousResults.flatMap((r) => r.phiDetections).reduce((acc, d) => {
+					acc[d.type] = (acc[d.type] || 0) + 1;
+					return acc;
+				}, {}),
+				totalAuditEvents: previousResults.length,
+				policyViolations: 0
+			}
+		};
+	}
+}
+/**
+* Execute pipeline with streaming updates
+*/
+async function executeCompliantPipelineStream(config, storage) {
+	return new ReadableStream({ async start(controller) {
+		try {
+			await storage.initialize();
+			const run = await storage.createRun(config);
+			controller.enqueue({
+				type: "step_start",
+				runId: run.runId,
+				stepId: config.steps[0]?.id,
+				timestamp: /* @__PURE__ */ new Date(),
+				data: { step: config.steps[0] }
+			});
+			const previousResults = [];
+			for (let i = 0; i < config.steps.length; i++) {
+				const step = config.steps[i];
+				if (!step) continue;
+				controller.enqueue({
+					type: "step_start",
+					runId: run.runId,
+					stepId: step.id,
+					timestamp: /* @__PURE__ */ new Date(),
+					data: {
+						stepIndex: i,
+						stepName: step.name
+					}
+				});
+				try {
+					const result = await executeStepWithRetry(step, previousResults, config.compliance, config.actorId, run.runId);
+					if (result.output && typeof result.output === "string") result.artifacts = { output: await storage.storeArtifact(run.runId, step.id, {
+						type: "output",
+						content: result.output,
+						contentType: "text/plain"
+					}) };
+					await storage.addStepResult(run.runId, result);
+					previousResults.push(result);
+					await storage.updateRun(run.runId, { currentStepIndex: i + 1 });
+					controller.enqueue({
+						type: "step_complete",
+						runId: run.runId,
+						stepId: step.id,
+						timestamp: /* @__PURE__ */ new Date(),
+						data: result
+					});
+					if (result.phiDetections.length > 0) controller.enqueue({
+						type: "phi_detection",
+						runId: run.runId,
+						stepId: step.id,
+						timestamp: /* @__PURE__ */ new Date(),
+						data: { count: result.phiDetections.length }
+					});
+				} catch (error) {
+					controller.enqueue({
+						type: "step_error",
+						runId: run.runId,
+						stepId: step.id,
+						timestamp: /* @__PURE__ */ new Date(),
+						data: { error: error instanceof Error ? error.message : "Unknown error" }
+					});
+					await storage.updateRun(run.runId, {
+						status: "failed",
+						completedAt: /* @__PURE__ */ new Date()
+					});
+					controller.enqueue({
+						type: "pipeline_error",
+						runId: run.runId,
+						timestamp: /* @__PURE__ */ new Date(),
+						data: { error: error instanceof Error ? error.message : "Unknown error" }
+					});
+					controller.close();
+					return;
+				}
+			}
+			await storage.updateRun(run.runId, {
+				status: "completed",
+				completedAt: /* @__PURE__ */ new Date()
+			});
+			controller.enqueue({
+				type: "pipeline_complete",
+				runId: run.runId,
+				timestamp: /* @__PURE__ */ new Date(),
+				data: {
+					totalSteps: previousResults.length,
+					totalPHI: previousResults.reduce((sum, r) => sum + r.phiDetections.length, 0)
+				}
+			});
+			controller.close();
+		} catch (error) {
+			controller.error(error);
+		}
+	} });
+}
+/**
+* Create resumption point for a paused pipeline
+*/
+async function createResumptionPoint(runId, storage) {
+	const run = await storage.getRun(runId);
+	if (!run) throw new Error(`Run ${runId} not found`);
+	const previousResults = await storage.getStepResults(runId);
+	return (await storage.createResumptionPoint(runId, run.currentStepIndex, previousResults)).token;
+}
+/**
+* Resume pipeline from token
+*/
+async function resumePipeline(token, config, storage) {
+	const resumption = await storage.getResumptionPoint(token);
+	if (!resumption) throw new Error("Invalid or expired resumption token");
+	return executeCompliantPipeline({
+		...config,
+		resumeFromRunId: resumption.runId
+	}, storage);
+}
+
+//#endregion
+//#region src/pipelines/defaults.ts
+/**
+* Default compliance options for HIPAA-compliant pipelines
+*/
+const HIPAA_COMPLIANCE = {
+	enablePHIRedaction: true,
+	enableABAC: true,
+	policyVersion: "v2.0"
+};
+/**
+* Default compliance options for general use (PHI redaction only)
+*/
+const BASIC_COMPLIANCE = {
+	enablePHIRedaction: true,
+	enableABAC: false,
+	policyVersion: "v2.0"
+};
+/**
+* No compliance (for non-sensitive data)
+*/
+const NO_COMPLIANCE = {
+	enablePHIRedaction: false,
+	enableABAC: false,
+	policyVersion: "v2.0"
+};
+/**
+* Common temperature settings
+*/
+const TEMPERATURES = {
+	factual: .1,
+	balanced: .4,
+	creative: .7,
+	experimental: .9
+};
+/**
+* Common system prompts
+*/
+const SYSTEM_PROMPTS = {
+	research: `You are a research assistant. Provide comprehensive, well-researched information.
+Include key facts, concepts, and context. Be thorough and cite sources when possible.`,
+	analysis: `You are an expert analyst. Provide deep analysis with:
+- Key insights and patterns
+- Critical evaluation
+- Implications and recommendations
+- Knowledge gaps
+
+Be thorough and analytical.`,
+	synthesis: `You are a synthesis expert. Create clear, actionable summaries with:
+- Executive summary (3-5 sentences)
+- Key findings
+- Actionable recommendations
+- Next steps
+
+Write clearly for a general audience.`,
+	editor: `You are an expert editor. Improve clarity, coherence, and impact.
+Focus on structure, flow, and readability. Preserve the author's voice.`,
+	critic: `You are a constructive critic. Identify areas for improvement while acknowledging strengths.
+Be specific, actionable, and balanced in your feedback.`
+};
+/**
+* Common timeouts (milliseconds)
+*/
+const TIMEOUTS = {
+	quick: 3e4,
+	standard: 12e4,
+	long: 3e5,
+	veryLong: 6e5
+};
+/**
+* Common retry configurations
+*/
+const RETRY_CONFIGS = {
+	none: {
+		maxAttempts: 1,
+		delayMs: 0
+	},
+	standard: {
+		maxAttempts: 3,
+		delayMs: 1e3,
+		backoff: "exponential"
+	},
+	aggressive: {
+		maxAttempts: 5,
+		delayMs: 2e3,
+		backoff: "exponential"
+	},
+	quick: {
+		maxAttempts: 2,
+		delayMs: 500,
+		backoff: "linear"
+	}
+};
+
+//#endregion
+//#region src/pipelines/message-transforms.ts
+/**
+* Use previous step's output as next input
+* Most common pattern in pipelines
+*/
+function usePreviousOutput(previousResults) {
+	const lastOutput = previousResults[previousResults.length - 1]?.output;
+	if (typeof lastOutput === "string") return [{
+		role: "user",
+		content: lastOutput
+	}];
+	return [{
+		role: "user",
+		content: "Continue with the previous result."
+	}];
+}
+/**
+* Combine all previous outputs into one message
+*/
+function combineAllOutputs(previousResults, separator = "\n\n---\n\n") {
+	return [{
+		role: "user",
+		content: previousResults.map((r) => r.output).filter((o) => typeof o === "string").join(separator)
+	}];
+}
+/**
+* Create a message with context from previous step
+*/
+function withContext(prompt, previousResults) {
+	const lastOutput = previousResults[previousResults.length - 1]?.output;
+	if (typeof lastOutput === "string") return [{
+		role: "user",
+		content: `${prompt}\n\nContext:\n${lastOutput}`
+	}];
+	return [{
+		role: "user",
+		content: prompt
+	}];
+}
+/**
+* Create analysis prompt from research output
+*/
+function analyzeResearch(previousResults) {
+	return [{
+		role: "user",
+		content: `Research findings:\n\n${previousResults[0]?.output}\n\nProvide your analysis.`
+	}];
+}
+/**
+* Create synthesis prompt from research and analysis
+*/
+function synthesizeResults(previousResults) {
+	return [{
+		role: "user",
+		content: `Research:\n${previousResults[0]?.output}\n\nAnalysis:\n${previousResults[1]?.output}\n\nProvide your synthesis.`
+	}];
+}
+/**
+* Create refinement prompt
+*/
+function refine(instruction, previousResults) {
+	const lastOutput = previousResults[previousResults.length - 1]?.output;
+	if (typeof lastOutput === "string") return [{
+		role: "user",
+		content: `Previous version:\n\n${lastOutput}\n\n${instruction}`
+	}];
+	return [{
+		role: "user",
+		content: instruction
+	}];
+}
+
+//#endregion
+//#region src/pipelines/adapters/trace-storage-memory.ts
+/**
+* @fileoverview In-Memory Trace Storage Adapter
+* In-Memory Trace Storage Adapter
+* For testing and development (no persistence)
+*/
+/**
+* In-memory storage adapter
+* - Fast for testing and development
+* - No external dependencies
+* - Data lost on process restart
+*/
+var MemoryTraceStorage = class {
+	runs = /* @__PURE__ */ new Map();
+	steps = /* @__PURE__ */ new Map();
+	artifacts = /* @__PURE__ */ new Map();
+	resumptionPoints = /* @__PURE__ */ new Map();
+	actorIndex = /* @__PURE__ */ new Map();
+	pipelineIndex = /* @__PURE__ */ new Map();
+	async initialize() {}
+	async createRun(config) {
+		const runId = `${config.id}-${generateId()}`;
+		const run = {
+			runId,
+			pipelineId: config.id,
+			actorId: config.actorId,
+			status: "running",
+			steps: [],
+			currentStepIndex: 0,
+			startedAt: /* @__PURE__ */ new Date(),
+			totalPHIDetections: 0,
+			totalTokens: 0,
+			complianceMetrics: {
+				phiRedacted: 0,
+				abacChecks: 0,
+				auditEvents: 0,
+				approvalRequests: 0
+			},
+			metadata: config.metadata
+		};
+		this.runs.set(runId, run);
+		let actorRuns = this.actorIndex.get(config.actorId);
+		if (!actorRuns) {
+			actorRuns = /* @__PURE__ */ new Set();
+			this.actorIndex.set(config.actorId, actorRuns);
+		}
+		actorRuns.add(runId);
+		let pipelineRuns = this.pipelineIndex.get(config.id);
+		if (!pipelineRuns) {
+			pipelineRuns = /* @__PURE__ */ new Set();
+			this.pipelineIndex.set(config.id, pipelineRuns);
+		}
+		pipelineRuns.add(runId);
+		return run;
+	}
+	async getRun(runId) {
+		return this.runs.get(runId) ?? null;
+	}
+	async updateRun(runId, updates) {
+		const run = this.runs.get(runId);
+		if (!run) throw new Error(`Run ${runId} not found`);
+		Object.assign(run, updates);
+		this.runs.set(runId, run);
+	}
+	async addStepResult(runId, result) {
+		let runSteps = this.steps.get(runId);
+		if (!runSteps) {
+			runSteps = [];
+			this.steps.set(runId, runSteps);
+		}
+		runSteps.push(result);
+	}
+	async getStepResults(runId) {
+		return this.steps.get(runId) ?? [];
+	}
+	async storeArtifact(runId, stepId, artifact) {
+		const artifactId = `${runId}/${stepId}/${artifact.type}`;
+		this.artifacts.set(artifactId, artifact.content);
+		return `memory://${artifactId}`;
+	}
+	async getArtifact(url) {
+		const artifactId = url.replace("memory://", "");
+		const artifact = this.artifacts.get(artifactId);
+		if (!artifact) throw new Error(`Artifact not found: ${url}`);
+		return artifact;
+	}
+	async createResumptionPoint(runId, stepIndex, previousResults) {
+		const token = generateId();
+		const resumption = {
+			runId,
+			stepIndex,
+			previousResults,
+			token,
+			expiresAt: new Date(Date.now() + 3600 * 1e3)
+		};
+		this.resumptionPoints.set(token, resumption);
+		return resumption;
+	}
+	async getResumptionPoint(token) {
+		const resumption = this.resumptionPoints.get(token);
+		if (!resumption) return null;
+		if (resumption.expiresAt < /* @__PURE__ */ new Date()) {
+			this.resumptionPoints.delete(token);
+			return null;
+		}
+		return resumption;
+	}
+	async cleanupExpiredResumptionPoints() {
+		const now = /* @__PURE__ */ new Date();
+		let count = 0;
+		for (const [token, resumption] of this.resumptionPoints.entries()) if (resumption.expiresAt < now) {
+			this.resumptionPoints.delete(token);
+			count++;
+		}
+		return count;
+	}
+	async queryRunsByActor(actorId, options) {
+		let runs = [...this.actorIndex.get(actorId) ?? /* @__PURE__ */ new Set()].flatMap((id) => {
+			const run = this.runs.get(id);
+			return run ? [run] : [];
+		});
+		if (options?.status) runs = runs.filter((r) => r.status === options.status);
+		runs.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+		const offset = options?.offset ?? 0;
+		const limit = options?.limit || 10;
+		return runs.slice(offset, offset + limit);
+	}
+	async queryRunsByPipeline(pipelineId, options) {
+		let runs = [...this.pipelineIndex.get(pipelineId) ?? /* @__PURE__ */ new Set()].flatMap((id) => {
+			const run = this.runs.get(id);
+			return run ? [run] : [];
+		});
+		if (options?.status) runs = runs.filter((r) => r.status === options.status);
+		runs.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+		const offset = options?.offset ?? 0;
+		const limit = options?.limit || 10;
+		return runs.slice(offset, offset + limit);
+	}
+	async getComplianceMetrics(startDate, endDate, options) {
+		let runs = [...this.runs.values()];
+		runs = runs.filter((r) => r.startedAt >= startDate && r.startedAt <= endDate);
+		if (options?.actorId) runs = runs.filter((r) => r.actorId === options.actorId);
+		if (options?.pipelineId) runs = runs.filter((r) => r.pipelineId === options.pipelineId);
+		const metrics = {
+			totalRuns: runs.length,
+			totalPHIDetections: runs.reduce((sum, r) => sum + r.totalPHIDetections, 0),
+			totalAuditEvents: runs.reduce((sum, r) => sum + (r.complianceMetrics.auditEvents ?? 0), 0),
+			totalApprovals: runs.reduce((sum, r) => sum + (r.complianceMetrics.approvalRequests ?? 0), 0),
+			phiByType: {},
+			runsByStatus: {}
+		};
+		for (const run of runs) metrics.runsByStatus[run.status] = (metrics.runsByStatus[run.status] || 0) + 1;
+		return metrics;
+	}
+	async close() {}
+	/**
+	* Clear all data (useful for testing)
+	*/
+	clear() {
+		this.runs.clear();
+		this.steps.clear();
+		this.artifacts.clear();
+		this.resumptionPoints.clear();
+		this.actorIndex.clear();
+		this.pipelineIndex.clear();
+	}
+	/**
+	* Get storage statistics
+	*/
+	getStats() {
+		return {
+			runs: this.runs.size,
+			steps: [...this.steps.values()].reduce((sum, steps) => sum + steps.length, 0),
+			artifacts: this.artifacts.size,
+			resumptionPoints: this.resumptionPoints.size
+		};
+	}
+};
+/**
+* Create in-memory storage adapter
+*/
+function createMemoryTraceStorage() {
+	return new MemoryTraceStorage();
+}
+
+//#endregion
+//#region src/pipelines/pipeline-presets.ts
+/**
+* @fileoverview Pipeline Presets
+* Pipeline Presets
+* Simplified API for common pipeline patterns
+*/
+/**
+* Execute a simple pipeline with sensible defaults
+*
+* @example
+* ```typescript
+* const result = await quickPipeline({
+*   name: 'Research Pipeline',
+*   query: 'What is AI safety?',
+*   steps: [
+*     { name: 'Research', model: openai('gpt-5.1-instant') },
+*     { name: 'Analyze', model: anthropic('claude-sonnet-4-5') },
+*   ],
+* });
+* console.log(result.output);
+* ```
+*/
+async function quickPipeline(options) {
+	const { name, steps: simpleSteps, query, userId = "default_user", storage = createMemoryTraceStorage(), enablePHI = true, enableABAC = false } = options;
+	const steps = simpleSteps.map((step, index) => {
+		const { transformInput } = step;
+		return {
+			id: `step_${index + 1}`,
+			name: step.name,
+			model: step.model,
+			systemPrompt: step.systemPrompt,
+			temperature: step.temperature ?? .7,
+			streaming: true,
+			transformInput: transformInput ? (previousResults) => {
+				return transformInput(previousResults.at(-1)?.output ?? null);
+			} : index === 0 ? () => [{
+				role: "user",
+				content: query
+			}] : (previousResults) => {
+				return [{
+					role: "user",
+					content: previousResults[previousResults.length - 1]?.output ?? query
+				}];
+			}
+		};
+	});
+	const config = {
+		id: `quick_${Date.now()}`,
+		name,
+		actorId: userId,
+		storage: "blob",
+		initialMessages: [{
+			role: "user",
+			content: query
+		}],
+		compliance: {
+			enablePHIRedaction: enablePHI,
+			enableABAC,
+			policyVersion: "v2.0"
+		},
+		steps
+	};
+	assertValidPipelineConfig(config);
+	return executeCompliantPipeline(config, storage);
+}
+/**
+* Create a two-step pipeline: Research → Synthesis
+*
+* @example
+* ```typescript
+* const result = await researchAndSynthesize({
+*   query: 'What are the latest trends in AI?',
+*   researchModel: openai('gpt-5.1-instant'),
+*   synthesisModel: anthropic('claude-sonnet-4-5'),
+* });
+* ```
+*/
+async function researchAndSynthesize(options) {
+	return quickPipeline({
+		name: "Research & Synthesis Pipeline",
+		query: options.query,
+		userId: options.userId,
+		storage: options.storage,
+		steps: [{
+			name: "Research",
+			model: options.researchModel,
+			systemPrompt: "You are a research assistant. Provide comprehensive, well-researched information.",
+			temperature: .3
+		}, {
+			name: "Synthesize",
+			model: options.synthesisModel,
+			systemPrompt: "You are a synthesis expert. Create a clear, concise summary with key insights.",
+			temperature: .7,
+			transformInput: (previousOutput) => [{
+				role: "user",
+				content: `Research findings:\n\n${previousOutput}\n\nProvide a synthesis with key insights.`
+			}]
+		}]
+	});
+}
+/**
+* Create a three-step pipeline: Research → Analyze → Synthesize
+*
+* @example
+* ```typescript
+* const result = await deepResearchPipeline({
+*   query: 'Explain quantum computing',
+*   models: {
+*     research: openai('gpt-5.1-instant'),
+*     analysis: anthropic('claude-sonnet-4-5'),
+*     synthesis: openai('gpt-5.1-thinking'),
+*   },
+* });
+* ```
+*/
+async function deepResearchPipeline(options) {
+	return quickPipeline({
+		name: "Deep Research Pipeline",
+		query: options.query,
+		userId: options.userId,
+		storage: options.storage,
+		steps: [
+			{
+				name: "Research",
+				model: options.models.research,
+				systemPrompt: "You are a research assistant. Gather comprehensive information.",
+				temperature: .3
+			},
+			{
+				name: "Analyze",
+				model: options.models.analysis,
+				systemPrompt: "You are an expert analyst. Provide deep analysis, identify patterns, and evaluate critically.",
+				temperature: .5,
+				transformInput: (previousOutput) => [{
+					role: "user",
+					content: `Research findings:\n\n${previousOutput}\n\nProvide your expert analysis.`
+				}]
+			},
+			{
+				name: "Synthesize",
+				model: options.models.synthesis,
+				systemPrompt: "You are a synthesis expert. Create an executive summary with actionable insights.",
+				temperature: .7,
+				transformInput: (previousOutput) => [{
+					role: "user",
+					content: `Analysis:\n\n${previousOutput}\n\nCreate a final synthesis with actionable insights.`
+				}]
+			}
+		]
+	});
+}
+/**
+* Create a pipeline for iterative refinement
+*
+* @example
+* ```typescript
+* const result = await iterativeRefinement({
+*   initialContent: 'Draft blog post about AI...',
+*   refinementSteps: 3,
+*   model: anthropic('claude-sonnet-4-5'),
+* });
+* ```
+*/
+async function iterativeRefinement(options) {
+	const steps = [];
+	for (let i = 0; i < options.refinementSteps; i++) steps.push({
+		name: `Refinement ${i + 1}`,
+		model: options.model,
+		systemPrompt: `You are an expert editor. Improve clarity, coherence, and impact. This is iteration ${i + 1} of ${options.refinementSteps}.`,
+		temperature: .5,
+		transformInput: i === 0 ? () => [{
+			role: "user",
+			content: options.initialContent
+		}] : (previousOutput) => [{
+			role: "user",
+			content: `Previous version:\n\n${previousOutput}\n\nRefine and improve this further.`
+		}]
+	});
+	return quickPipeline({
+		name: "Iterative Refinement Pipeline",
+		query: options.initialContent,
+		userId: options.userId,
+		storage: options.storage,
+		steps
+	});
+}
+/**
+* Execute pipeline with custom retry logic
+*
+* @example
+* ```typescript
+* const result = await pipelineWithRetry({
+*   config: myPipelineConfig,
+*   storage: myStorage,
+*   maxRetries: 3,
+* });
+* ```
+*/
+async function pipelineWithRetry(options) {
+	const { config, storage, maxRetries = 3, retryDelay = 2e3 } = options;
+	let lastError = null;
+	for (let attempt = 0; attempt < maxRetries; attempt++) try {
+		return await executeCompliantPipeline(config, storage);
+	} catch (error) {
+		lastError = error instanceof Error ? error : /* @__PURE__ */ new Error("Unknown error");
+		logError(`Pipeline attempt ${attempt + 1} failed`, {
+			error: lastError,
+			attempt: attempt + 1,
+			config
+		});
+		if (attempt < maxRetries - 1) await new Promise((resolve) => setTimeout(resolve, retryDelay * (attempt + 1)));
+	}
+	throw new Error(`Pipeline failed after ${maxRetries} attempts. Last error: ${lastError?.message}`);
+}
+
+//#endregion
+//#region src/pipelines/trace-storage-interface.ts
+/**
+* Helper to create storage adapter
+*
+* For ESM compatibility, import adapters directly:
+* ```typescript
+* import { createBlobTraceStorage } from '#/lib/ai-onedigital/adapters/trace-storage-blob';
+* const storage = createBlobTraceStorage(config);
+* ```
+*/
+function createTraceStorage(config) {
+	switch (config.type) {
+		case "blob": throw new Error("Use createBlobTraceStorage() directly from #/lib/ai-onedigital/adapters/trace-storage-blob");
+		case "postgres": throw new Error("PostgresTraceStorage not yet implemented. See adapters/trace-storage-postgres/README.md");
+		default: throw new Error(`Unknown storage type: ${config.type}. Use 'blob' or 'postgres'`);
+	}
+}
+
+//#endregion
+//#region src/pipelines/adapters/trace-storage-blob.ts
+/**
+* @fileoverview Blob Trace Storage Adapter
+* Blob Trace Storage Adapter
+* Uses Vercel Blob for artifacts + Upstash Redis for metadata
+*/
+const DEFAULT_MAX_ARTIFACT_BYTES = 5 * 1024 * 1024;
+const stringifyArtifact = (value) => {
+	const seen = /* @__PURE__ */ new WeakSet();
+	return JSON.stringify(value, (key, current) => {
+		if (typeof current === "bigint") return current.toString();
+		if (typeof current === "object" && current !== null) {
+			if (seen.has(current)) throw new Error("Artifact content contains a circular reference");
+			seen.add(current);
+		}
+		return current;
+	});
+};
+const serializeArtifactContent = (artifact, maxBytes) => {
+	try {
+		const { content: artifactContent } = artifact;
+		let content;
+		if (typeof artifactContent === "string") content = Buffer.from(artifactContent);
+		else if (Buffer.isBuffer(artifactContent)) content = artifactContent;
+		else content = Buffer.from(stringifyArtifact(artifactContent));
+		if (content.byteLength > maxBytes) throw new Error(`Artifact content exceeds max size (${maxBytes} bytes)`);
+		return content;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		throw new Error(`Failed to serialize artifact content: ${message}`);
+	}
+};
+/**
+* Blob storage adapter
+* - Metadata: Upstash Redis (fast queries)
+* - Artifacts: Vercel Blob (large files)
+*/
+var BlobTraceStorage = class {
+	redis;
+	blob;
+	cacheTTL;
+	artifactRetentionDays;
+	artifactMaxBytes;
+	resumptionTTL;
+	constructor(config) {
+		if (!config.redis) throw new Error("Redis configuration required for BlobTraceStorage");
+		if (!config.blob) throw new Error("Blob configuration required for BlobTraceStorage");
+		this.redis = createUpstashRedis({
+			url: config.redis.url,
+			token: config.redis.token
+		});
+		this.blob = createVercelBlobClient({
+			token: config.blob.token,
+			baseUrl: config.blob.baseUrl
+		});
+		this.cacheTTL = config.cacheTTL ?? 3600;
+		this.artifactRetentionDays = config.artifactRetentionDays ?? 90;
+		this.artifactMaxBytes = config.artifactMaxBytes ?? DEFAULT_MAX_ARTIFACT_BYTES;
+		this.resumptionTTL = config.resumptionTTL || 3600;
+	}
+	async initialize() {
+		try {
+			await this.redis.ping();
+		} catch (error) {
+			throw new Error(`Failed to connect to Redis: ${error instanceof Error ? error.message : "Unknown error"}`);
+		}
+	}
+	async createRun(config) {
+		const runId = `${config.id}-${generateId()}`;
+		const run = {
+			runId,
+			pipelineId: config.id,
+			actorId: config.actorId,
+			status: "running",
+			steps: [],
+			currentStepIndex: 0,
+			startedAt: /* @__PURE__ */ new Date(),
+			totalPHIDetections: 0,
+			totalTokens: 0,
+			complianceMetrics: {
+				phiRedacted: 0,
+				abacChecks: 0,
+				auditEvents: 0,
+				approvalRequests: 0
+			},
+			metadata: config.metadata
+		};
+		await this.redis.set(`run:${runId}`, JSON.stringify(run), { ex: this.cacheTTL });
+		await this.redis.zadd(`actor:${config.actorId}:runs`, {
+			score: Date.now(),
+			member: runId
+		});
+		await this.redis.zadd(`pipeline:${config.id}:runs`, {
+			score: Date.now(),
+			member: runId
+		});
+		await this.redis.zadd("global:runs", {
+			score: Date.now(),
+			member: runId
+		});
+		return run;
+	}
+	async getRun(runId) {
+		const data = await this.redis.get(`run:${runId}`);
+		if (!data) return null;
+		const run = JSON.parse(data);
+		run.startedAt = new Date(run.startedAt);
+		if (run.completedAt) run.completedAt = new Date(run.completedAt);
+		return run;
+	}
+	async updateRun(runId, updates) {
+		const run = await this.getRun(runId);
+		if (!run) throw new Error(`Run ${runId} not found`);
+		const updated = {
+			...run,
+			...updates
+		};
+		await this.redis.set(`run:${runId}`, JSON.stringify(updated), { ex: this.cacheTTL });
+	}
+	async addStepResult(runId, result) {
+		await this.redis.set(`run:${runId}:step:${result.stepId}`, JSON.stringify(result), { ex: this.cacheTTL });
+		await this.redis.zadd(`run:${runId}:steps`, {
+			score: result.stepIndex,
+			member: result.stepId
+		});
+	}
+	async getStepResults(runId) {
+		const stepIds = await this.redis.zrange(`run:${runId}:steps`, 0, -1);
+		return (await Promise.all(stepIds.map(async (stepId) => {
+			const data = await this.redis.get(`run:${runId}:step:${stepId}`);
+			if (!data) return null;
+			const step = JSON.parse(data);
+			step.startedAt = new Date(step.startedAt);
+			if (step.completedAt) step.completedAt = new Date(step.completedAt);
+			return step;
+		}))).filter((r) => r !== null);
+	}
+	async storeArtifact(runId, stepId, artifact) {
+		const pathname = `pipelines/${runId}/${stepId}/${artifact.type}`;
+		const content = serializeArtifactContent(artifact, this.artifactMaxBytes);
+		return (await this.blob.put(pathname, content, {
+			access: "public",
+			contentType: artifact.contentType
+		})).url;
+	}
+	async getArtifact(url) {
+		const response = await fetch(url);
+		if (!response.ok) throw new Error(`Failed to fetch artifact: ${response.statusText}`);
+		const contentType = response.headers.get("content-type") ?? "";
+		if (contentType.includes("application/json")) return await response.json();
+		else if (contentType.includes("text/")) return await response.text();
+		else return Buffer.from(await response.arrayBuffer());
+	}
+	async createResumptionPoint(runId, stepIndex, previousResults) {
+		const token = generateId();
+		const resumption = {
+			runId,
+			stepIndex,
+			previousResults,
+			token,
+			expiresAt: new Date(Date.now() + this.resumptionTTL * 1e3)
+		};
+		await this.redis.set(`resumption:${token}`, JSON.stringify(resumption), { ex: this.resumptionTTL });
+		return resumption;
+	}
+	async getResumptionPoint(token) {
+		const data = await this.redis.get(`resumption:${token}`);
+		if (!data) return null;
+		const resumption = JSON.parse(data);
+		resumption.expiresAt = new Date(resumption.expiresAt);
+		resumption.previousResults = resumption.previousResults.map((r) => ({
+			...r,
+			startedAt: new Date(r.startedAt),
+			completedAt: r.completedAt ? new Date(r.completedAt) : void 0
+		}));
+		return resumption;
+	}
+	async cleanupExpiredResumptionPoints() {
+		return 0;
+	}
+	async queryRunsByActor(actorId, options) {
+		const limit = options?.limit ?? 10;
+		const offset = options?.offset || 0;
+		const runIds = await this.redis.zrange(`actor:${actorId}:runs`, offset, offset + limit - 1, { rev: true });
+		let filtered = (await Promise.all(runIds.map((id) => this.getRun(id)))).filter((r) => r !== null);
+		if (options?.status) filtered = filtered.filter((r) => r.status === options.status);
+		return filtered;
+	}
+	async queryRunsByPipeline(pipelineId, options) {
+		const limit = options?.limit ?? 10;
+		const offset = options?.offset || 0;
+		const runIds = await this.redis.zrange(`pipeline:${pipelineId}:runs`, offset, offset + limit - 1, { rev: true });
+		let filtered = (await Promise.all(runIds.map((id) => this.getRun(id)))).filter((r) => r !== null);
+		if (options?.status) filtered = filtered.filter((r) => r.status === options.status);
+		return filtered;
+	}
+	async getComplianceMetrics(startDate, endDate, options) {
+		let runIds;
+		if (options?.actorId) runIds = await this.redis.zrange(`actor:${options.actorId}:runs`, startDate.getTime(), endDate.getTime(), { byScore: true });
+		else if (options?.pipelineId) runIds = await this.redis.zrange(`pipeline:${options.pipelineId}:runs`, startDate.getTime(), endDate.getTime(), { byScore: true });
+		else runIds = await this.redis.zrange("global:runs", startDate.getTime(), endDate.getTime(), { byScore: true });
+		const validRuns = (await Promise.all(runIds.map((id) => this.getRun(id)))).filter((r) => r !== null);
+		const metrics = {
+			totalRuns: validRuns.length,
+			totalPHIDetections: validRuns.reduce((sum, r) => sum + r.totalPHIDetections, 0),
+			totalAuditEvents: validRuns.reduce((sum, r) => sum + r.complianceMetrics.auditEvents, 0),
+			totalApprovals: validRuns.reduce((sum, r) => sum + r.complianceMetrics.approvalRequests, 0),
+			phiByType: {},
+			runsByStatus: {}
+		};
+		for (const run of validRuns) metrics.runsByStatus[run.status] = (metrics.runsByStatus[run.status] || 0) + 1;
+		return metrics;
+	}
+	async close() {}
+};
+/**
+* Create blob storage adapter
+*/
+function createBlobTraceStorage(config) {
+	return new BlobTraceStorage(config);
+}
+
+//#endregion
+//#region src/pipelines/storage-factory.ts
+/**
+* @fileoverview Storage Factory Helpers
+* Storage Factory Helpers
+* DRY helpers for creating storage adapters from environment variables
+*/
+/**
+* Create storage adapter from environment variables
+* No config needed - reads from process.env automatically
+*
+* @example
+* ```typescript
+* const storage = createStorageFromEnv();
+* // Uses VERCEL_BLOB_READ_WRITE_TOKEN, UPSTASH_REDIS_URL, UPSTASH_REDIS_TOKEN
+* ```
+*/
+function createStorageFromEnv(type = "blob") {
+	if (type === "memory") return createMemoryTraceStorage();
+	const blobToken = process.env.VERCEL_BLOB_READ_WRITE_TOKEN;
+	const redisUrl = process.env.UPSTASH_REDIS_URL;
+	const redisToken = process.env.UPSTASH_REDIS_TOKEN;
+	if (!blobToken || !redisUrl || !redisToken) throw new Error(`Missing required environment variables for blob storage:\n${!blobToken ? "  - VERCEL_BLOB_READ_WRITE_TOKEN\n" : ""}${!redisUrl ? "  - UPSTASH_REDIS_URL\n" : ""}${!redisToken ? "  - UPSTASH_REDIS_TOKEN\n" : ""}Set these in your .env file or use createMemoryTraceStorage() for testing.`);
+	return createBlobTraceStorage({
+		type: "blob",
+		blob: { token: blobToken },
+		redis: {
+			url: redisUrl,
+			token: redisToken
+		}
+	});
+}
+/**
+* Create storage for development (memory-based)
+* No environment variables required
+*/
+function createDevStorage() {
+	return createMemoryTraceStorage();
+}
+/**
+* Create storage for production (blob-based)
+* Validates all required environment variables
+*/
+function createProdStorage() {
+	return createStorageFromEnv("blob");
+}
+/**
+* Auto-detect storage type based on environment
+* Development: memory storage
+* Production: blob storage
+*/
+function createAutoStorage() {
+	const isDev = process.env.NODE_ENV === "development";
+	const hasEnvVars = process.env.VERCEL_BLOB_READ_WRITE_TOKEN && process.env.UPSTASH_REDIS_URL && process.env.UPSTASH_REDIS_TOKEN;
+	if (isDev && !hasEnvVars) {
+		logInfo("[Pipeline] Using in-memory storage (development mode)");
+		return createMemoryTraceStorage();
+	}
+	return createStorageFromEnv("blob");
+}
+
+//#endregion
+//#region src/pipelines/index.ts
+var pipelines_exports = /* @__PURE__ */ __exportAll({
+	BASIC_COMPLIANCE: () => BASIC_COMPLIANCE,
+	BlobTraceStorage: () => BlobTraceStorage,
+	HIPAA_COMPLIANCE: () => HIPAA_COMPLIANCE,
+	MemoryTraceStorage: () => MemoryTraceStorage,
+	NO_COMPLIANCE: () => NO_COMPLIANCE,
+	RETRY_CONFIGS: () => RETRY_CONFIGS,
+	SYSTEM_PROMPTS: () => SYSTEM_PROMPTS,
+	TEMPERATURES: () => TEMPERATURES,
+	TIMEOUTS: () => TIMEOUTS,
+	analyzeResearch: () => analyzeResearch,
+	assertValidPipelineConfig: () => assertValidPipelineConfig,
+	combineAllOutputs: () => combineAllOutputs,
+	createAutoStorage: () => createAutoStorage,
+	createBlobTraceStorage: () => createBlobTraceStorage,
+	createDevStorage: () => createDevStorage,
+	createMemoryTraceStorage: () => createMemoryTraceStorage,
+	createProdStorage: () => createProdStorage,
+	createResumptionPoint: () => createResumptionPoint,
+	createStorageFromEnv: () => createStorageFromEnv,
+	createTraceStorage: () => createTraceStorage,
+	deepResearchPipeline: () => deepResearchPipeline,
+	executeCompliantPipeline: () => executeCompliantPipeline,
+	executeCompliantPipelineStream: () => executeCompliantPipelineStream,
+	executeStep: () => executeStep,
+	executeStepWithRetry: () => executeStepWithRetry,
+	iterativeRefinement: () => iterativeRefinement,
+	pipelineWithRetry: () => pipelineWithRetry,
+	quickPipeline: () => quickPipeline,
+	refine: () => refine,
+	researchAndSynthesize: () => researchAndSynthesize,
+	resumePipeline: () => resumePipeline,
+	synthesizeResults: () => synthesizeResults,
+	usePreviousOutput: () => usePreviousOutput,
+	validatePipelineConfig: () => validatePipelineConfig,
+	validatePipelineStep: () => validatePipelineStep,
+	validateStorageConfig: () => validateStorageConfig,
+	withContext: () => withContext
+});
+
+//#endregion
+export { BASIC_COMPLIANCE, BlobTraceStorage, HIPAA_COMPLIANCE, MemoryTraceStorage, NO_COMPLIANCE, RETRY_CONFIGS, SYSTEM_PROMPTS, TEMPERATURES, TIMEOUTS, analyzeResearch, assertValidPipelineConfig, combineAllOutputs, createAutoStorage, createBlobTraceStorage, createDevStorage, createMemoryTraceStorage, createProdStorage, createResumptionPoint, createStorageFromEnv, createTraceStorage, deepResearchPipeline, executeCompliantPipeline, executeCompliantPipelineStream, executeStep, executeStepWithRetry, iterativeRefinement, pipelineWithRetry, quickPipeline, refine, researchAndSynthesize, resumePipeline, synthesizeResults, pipelines_exports as t, usePreviousOutput, validatePipelineConfig, validatePipelineStep, validateStorageConfig, withContext };
+//# sourceMappingURL=pipelines.mjs.map