@od-oneapp/ai-platform 0.1.0

package/src/pipelines/pipeline-presets.ts

@@ -0,0 +1,339 @@
+/**
+ * @fileoverview Pipeline Presets
+ * Pipeline Presets
+ * Simplified API for common pipeline patterns
+ */
+
+import { logError } from '@repo/shared/logs';
+
+import { createMemoryTraceStorage } from './adapters/trace-storage-memory';
+import { executeCompliantPipeline } from './multi-step-wrapper';
+import { assertValidPipelineConfig } from './validation';
+
+import type { TraceStorage } from './trace-storage-interface';
+import type { PipelineConfig, PipelineResult, PipelineStep } from './types';
+import type { CoreMessage, ModelRef } from '../shared';
+
+/**
+ * Message type for pipeline steps.
+ * Aligned with SDK's CoreMessage type.
+ */
+type PipelineMessage = CoreMessage;
+
+/**
+ * Simple step configuration (minimal required fields)
+ */
+export interface SimpleStep {
+  /** Step name */
+  name: string;
+  /** AI model (string or model object) */
+  model: ModelRef;
+  /** System prompt */
+  systemPrompt?: string;
+  /** Temperature (0-1) */
+  temperature?: number;
+  /** Transform input from previous step */
+  transformInput?: (previousOutput: string | null) => PipelineMessage[];
+}
+
+/**
+ * Quick pipeline options
+ */
+export interface QuickPipelineOptions {
+  /** Pipeline name */
+  name: string;
+  /** Steps to execute */
+  steps: SimpleStep[];
+  /** Initial query/prompt */
+  query: string;
+  /** User ID for audit logging */
+  userId?: string;
+  /** Storage adapter (defaults to in-memory) */
+  storage?: TraceStorage;
+  /** Enable PHI redaction */
+  enablePHI?: boolean;
+  /** Enable ABAC */
+  enableABAC?: boolean;
+}
+
+/**
+ * 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);
+ * ```
+ */
+export async function quickPipeline(options: QuickPipelineOptions): Promise<PipelineResult> {
+  const {
+    name,
+    steps: simpleSteps,
+    query,
+    userId = 'default_user',
+    storage = createMemoryTraceStorage(),
+    enablePHI = true,
+    enableABAC = false,
+  } = options;
+
+  // Convert simple steps to full pipeline steps
+  const steps: PipelineStep[] = simpleSteps.map((step, index) => {
+    const { transformInput } = step;
+    return {
+      id: `step_${index + 1}`,
+      name: step.name,
+      model: step.model,
+      systemPrompt: step.systemPrompt,
+      temperature: step.temperature ?? 0.7,
+      streaming: true,
+      transformInput: transformInput
+        ? previousResults => {
+            const lastResult = previousResults.at(-1);
+            const previousOutput = (lastResult?.output as string | undefined) ?? null;
+            return transformInput(previousOutput);
+          }
+        : index === 0
+          ? () => [{ role: 'user' as const, content: query }]
+          : previousResults => {
+              const previousOutput = previousResults[previousResults.length - 1]?.output as string;
+              return [{ role: 'user' as const, content: previousOutput ?? query }];
+            },
+    };
+  });
+
+  // Create pipeline config
+  const config: PipelineConfig = {
+    id: `quick_${Date.now()}`,
+    name,
+    actorId: userId,
+    storage: 'blob', // Placeholder, we use provided storage directly
+    initialMessages: [{ role: 'user', content: query }],
+    compliance: {
+      enablePHIRedaction: enablePHI,
+      enableABAC,
+      policyVersion: 'v2.0',
+    },
+    steps,
+  };
+
+  // Validate config
+  assertValidPipelineConfig(config);
+
+  // Execute pipeline
+  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'),
+ * });
+ * ```
+ */
+export async function researchAndSynthesize(options: {
+  query: string;
+  researchModel: ModelRef;
+  synthesisModel: ModelRef;
+  userId?: string;
+  storage?: TraceStorage;
+}): Promise<PipelineResult> {
+  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: 0.3,
+      },
+      {
+        name: 'Synthesize',
+        model: options.synthesisModel,
+        systemPrompt:
+          'You are a synthesis expert. Create a clear, concise summary with key insights.',
+        temperature: 0.7,
+        transformInput: previousOutput => [
+          {
+            role: 'user' as const,
+            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'),
+ *   },
+ * });
+ * ```
+ */
+export async function deepResearchPipeline(options: {
+  query: string;
+  models: {
+    research: ModelRef;
+    analysis: ModelRef;
+    synthesis: ModelRef;
+  };
+  userId?: string;
+  storage?: TraceStorage;
+}): Promise<PipelineResult> {
+  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: 0.3,
+      },
+      {
+        name: 'Analyze',
+        model: options.models.analysis,
+        systemPrompt:
+          'You are an expert analyst. Provide deep analysis, identify patterns, and evaluate critically.',
+        temperature: 0.5,
+        transformInput: previousOutput => [
+          {
+            role: 'user' as const,
+            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: 0.7,
+        transformInput: previousOutput => [
+          {
+            role: 'user' as const,
+            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'),
+ * });
+ * ```
+ */
+export async function iterativeRefinement(options: {
+  initialContent: string;
+  refinementSteps: number;
+  model: ModelRef;
+  userId?: string;
+  storage?: TraceStorage;
+}): Promise<PipelineResult> {
+  const steps: SimpleStep[] = [];
+
+  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: 0.5,
+      transformInput:
+        i === 0
+          ? () => [{ role: 'user' as const, content: options.initialContent }]
+          : previousOutput => [
+              {
+                role: 'user' as const,
+                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,
+ * });
+ * ```
+ */
+export async function pipelineWithRetry(options: {
+  config: PipelineConfig;
+  storage: TraceStorage;
+  maxRetries?: number;
+  retryDelay?: number;
+}): Promise<PipelineResult> {
+  const { config, storage, maxRetries = 3, retryDelay = 2000 } = options;
+
+  let lastError: Error | null = null;
+
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await executeCompliantPipeline(config, storage);
+    } catch (error) {
+      lastError = error instanceof Error ? error : 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}`,
+  );
+}

package/src/pipelines/step-executor.ts

@@ -0,0 +1,257 @@
+/**
+ * @fileoverview Step Executor
+ * Step Executor
+ * Executes individual pipeline steps with compliance
+ * Leverages AI SDK v6 native features (AbortSignal for timeouts, usage Promise)
+ */
+
+import { getErrorCode } from '../server/errors';
+import { generateText, streamText } from '../shared';
+import {
+  logGeneration,
+  postprocessText,
+  preprocessMessages,
+} from '../tools/compliance/compliance-wrapper';
+
+import type { PipelineStep, StepResult, StepStatus } from './types';
+import type { ComplianceOptions } from '../governance/compliance/types';
+import type { CoreMessage } from '../shared';
+
+/**
+ * Message type for pipeline steps.
+ * Aligned with SDK's CoreMessage type.
+ */
+type PipelineMessage = CoreMessage;
+
+/**
+ * Execute a single pipeline step with compliance
+ * Uses AI SDK v6 native features:
+ * - AbortSignal for timeouts
+ * - usage Promise for token tracking
+ * - Native streaming APIs
+ */
+export async function executeStep(
+  step: PipelineStep,
+  previousResults: StepResult[],
+  globalCompliance: ComplianceOptions,
+  actorId: string,
+  runId: string,
+): Promise<StepResult> {
+  const startTime = Date.now();
+
+  // Initialize result
+  const result: StepResult = {
+    stepId: step.id,
+    stepName: step.name,
+    stepIndex: previousResults.length,
+    status: 'running' as StepStatus,
+    output: null,
+    phiDetections: [],
+    startedAt: new Date(),
+    metadata: step.transformOutput ? { hasTransform: true } : undefined,
+  };
+
+  // Create AbortController for native timeout support (AI SDK v6)
+  const abortController = new AbortController();
+  const timeoutMs = step.timeoutMs ?? 120000; // 2 minutes default
+  const timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+
+  try {
+    // Check if step should be skipped
+    if (step.skipIf) {
+      const shouldSkip = await step.skipIf(previousResults);
+      if (shouldSkip) {
+        clearTimeout(timeoutId);
+        result.status = 'skipped';
+        result.completedAt = new Date();
+        result.durationMs = Date.now() - startTime;
+        return result;
+      }
+    }
+
+    // Transform input from previous results
+    let messages: PipelineMessage[];
+    if (step.transformInput) {
+      messages = await step.transformInput(previousResults);
+    } else {
+      // Default: use output from last step as user message
+      const lastOutput = previousResults[previousResults.length - 1]?.output;
+      if (typeof lastOutput === 'string') {
+        messages = [{ role: 'user', content: lastOutput }];
+      } else {
+        messages = [{ role: 'user', content: 'Continue' }];
+      }
+    }
+
+    // Add system prompt if provided
+    if (step.systemPrompt) {
+      messages = [{ role: 'system', content: step.systemPrompt }, ...messages];
+    }
+
+    // Merge compliance options (step overrides global)
+    const compliance: ComplianceOptions = {
+      ...globalCompliance,
+      ...step.compliance,
+    };
+
+    // Preprocess messages (PHI redaction, ABAC)
+    const { messages: processedMessages, detections } = await preprocessMessages(
+      messages,
+      compliance,
+    );
+
+    result.phiDetections = detections;
+
+    // Execute using AI SDK v6 with native features
+    // Build options without conditional spread to maintain type safety
+    const baseOptions = {
+      model: step.model,
+      messages: processedMessages,
+      temperature: step.temperature,
+      tools: step.tools,
+      abortSignal: abortController.signal, // Native timeout support
+    };
+
+    // Add maxOutputTokens if specified
+    const options = step.maxTokens
+      ? { ...baseOptions, maxOutputTokens: step.maxTokens }
+      : baseOptions;
+
+    let output: string;
+    let usage: { inputTokens?: number; outputTokens?: number; totalTokens?: number };
+
+    if (step.streaming) {
+      // Streaming path
+      const streamResult = await streamText(options);
+      clearTimeout(timeoutId);
+
+      // Collect streamed text
+      output = '';
+      for await (const chunk of streamResult.textStream) {
+        output += chunk;
+      }
+      usage = await streamResult.usage;
+    } else {
+      // Non-streaming path
+      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,
+    };
+
+    // Transform output if needed
+    let finalOutput: unknown = output;
+    if (step.transformOutput) {
+      finalOutput = await step.transformOutput(output);
+    }
+
+    // Postprocess output (PHI redaction)
+    if (typeof finalOutput === 'string') {
+      const { text: sanitized, detections: outputDetections } = await postprocessText(
+        finalOutput,
+        compliance,
+      );
+      finalOutput = sanitized;
+      result.phiDetections.push(...outputDetections);
+    }
+
+    // Set result
+    result.output = finalOutput;
+    result.status = 'completed';
+    result.completedAt = new Date();
+    result.durationMs = Date.now() - startTime;
+
+    // Log generation (compliance audit)
+    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 = new Date();
+    result.durationMs = Date.now() - startTime;
+
+    // Check if timeout (AbortError from AbortSignal)
+    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 : undefined,
+    };
+
+    // Log error
+    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
+ */
+export async function executeStepWithRetry(
+  step: PipelineStep,
+  previousResults: StepResult[],
+  globalCompliance: ComplianceOptions,
+  actorId: string,
+  runId: string,
+): Promise<StepResult> {
+  const retry = step.retry ?? { maxAttempts: 1, delayMs: 0 };
+  let lastError: Error | null = null;
+
+  for (let attempt = 0; attempt < retry.maxAttempts; attempt++) {
+    try {
+      const result = await executeStep(step, previousResults, globalCompliance, actorId, runId);
+
+      // If succeeded, return
+      if (result.status === 'completed' || result.status === 'skipped') {
+        return result;
+      }
+
+      // If failed, retry
+      lastError = new Error(result.error?.message ?? 'Step failed');
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error('Unknown error');
+    }
+
+    // Wait before retry (with backoff)
+    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));
+    }
+  }
+
+  // All attempts failed
+  throw lastError ?? new Error('Step failed after retries');
+}

package/src/pipelines/storage-factory.ts

@@ -0,0 +1,85 @@
+/**
+ * @fileoverview Storage Factory Helpers
+ * Storage Factory Helpers
+ * DRY helpers for creating storage adapters from environment variables
+ */
+
+import { logInfo } from '@repo/shared/logs';
+
+import { createBlobTraceStorage } from './adapters/trace-storage-blob';
+import { createMemoryTraceStorage } from './adapters/trace-storage-memory';
+
+import type { TraceStorage } from './trace-storage-interface';
+
+/**
+ * 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
+ * ```
+ */
+export function createStorageFromEnv(type: 'blob' | 'memory' = 'blob'): TraceStorage {
+  if (type === 'memory') {
+    return createMemoryTraceStorage();
+  }
+
+  // Validate env vars exist
+  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
+ */
+export function createDevStorage(): TraceStorage {
+  return createMemoryTraceStorage();
+}
+
+/**
+ * Create storage for production (blob-based)
+ * Validates all required environment variables
+ */
+export function createProdStorage(): TraceStorage {
+  return createStorageFromEnv('blob');
+}
+
+/**
+ * Auto-detect storage type based on environment
+ * Development: memory storage
+ * Production: blob storage
+ */
+export function createAutoStorage(): TraceStorage {
+  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');
+}