@juspay/neurolink 9.2.0 → 9.4.0

package/dist/workflow/core/workflowRegistry.js

@@ -0,0 +1,304 @@
+/**
+ * workflow/core/workflowRegistry.ts
+ * Registry for managing workflow configurations
+ */
+import { logger } from "../../utils/logger.js";
+import { validateForRegistration } from "../utils/workflowValidation.js";
+const functionTag = "WorkflowRegistry";
+// ============================================================================
+// REGISTRY STORAGE
+// ============================================================================
+/**
+ * In-memory workflow registry
+ * TODO: Consider persistent storage in future phases
+ */
+const workflowRegistry = new Map();
+// ============================================================================
+// REGISTRY OPERATIONS
+// ============================================================================
+/**
+ * Register a new workflow
+ * @param config - Workflow configuration to register
+ * @param options - Registration options
+ * @returns Registration result
+ */
+export function registerWorkflow(config, options = {}) {
+    const { validateBeforeRegister = true, allowOverwrite = false } = options;
+    logger.info(`[${functionTag}] Registering workflow`, {
+        workflowId: config.id,
+        name: config.name,
+        type: config.type,
+    });
+    // Validate if requested
+    if (validateBeforeRegister) {
+        const validation = validateForRegistration(config);
+        if (!validation.valid) {
+            logger.error(`[${functionTag}] Workflow validation failed`, {
+                workflowId: config.id,
+                errors: validation.errors,
+            });
+            return {
+                success: false,
+                workflowId: config.id,
+                validation,
+                error: "Workflow validation failed",
+            };
+        }
+    }
+    // Check for existing workflow
+    if (workflowRegistry.has(config.id) && !allowOverwrite) {
+        logger.warn(`[${functionTag}] Workflow already exists`, {
+            workflowId: config.id,
+        });
+        return {
+            success: false,
+            workflowId: config.id,
+            error: "Workflow already exists. Set allowOverwrite=true to replace.",
+        };
+    }
+    // Register workflow
+    const entry = {
+        config: { ...config },
+        registeredAt: new Date().toISOString(),
+        usageCount: 0,
+    };
+    workflowRegistry.set(config.id, entry);
+    logger.info(`[${functionTag}] Workflow registered successfully`, {
+        workflowId: config.id,
+        name: config.name,
+    });
+    return {
+        success: true,
+        workflowId: config.id,
+    };
+}
+/**
+ * Unregister a workflow
+ * @param workflowId - ID of workflow to unregister
+ * @returns True if workflow was unregistered
+ */
+export function unregisterWorkflow(workflowId) {
+    const exists = workflowRegistry.has(workflowId);
+    if (exists) {
+        workflowRegistry.delete(workflowId);
+        logger.info(`[${functionTag}] Workflow unregistered`, { workflowId });
+    }
+    else {
+        logger.warn(`[${functionTag}] Workflow not found for unregistration`, {
+            workflowId,
+        });
+    }
+    return exists;
+}
+/**
+ * Get workflow configuration by ID
+ * @param workflowId - ID of workflow to retrieve
+ * @returns Workflow configuration or undefined
+ */
+export function getWorkflow(workflowId) {
+    const entry = workflowRegistry.get(workflowId);
+    if (entry) {
+        // Update last used timestamp
+        entry.lastUsed = new Date().toISOString();
+        entry.usageCount++;
+        logger.debug(`[${functionTag}] Workflow retrieved`, {
+            workflowId,
+            usageCount: entry.usageCount,
+        });
+        return entry.config;
+    }
+    logger.warn(`[${functionTag}] Workflow not found`, { workflowId });
+    return undefined;
+}
+/**
+ * Check if workflow exists
+ * @param workflowId - ID of workflow to check
+ * @returns True if workflow exists
+ */
+export function hasWorkflow(workflowId) {
+    return workflowRegistry.has(workflowId);
+}
+/**
+ * List all registered workflows
+ * @param options - Listing options for filtering
+ * @returns Array of workflow configurations
+ */
+export function listWorkflows(options = {}) {
+    const { type, tags, limit, offset = 0 } = options;
+    let workflows = Array.from(workflowRegistry.values()).map((entry) => entry.config);
+    // Filter by type
+    if (type) {
+        workflows = workflows.filter((w) => w.type === type);
+    }
+    // Filter by tags
+    if (tags && tags.length > 0) {
+        workflows = workflows.filter((w) => {
+            if (!w.tags || w.tags.length === 0) {
+                return false;
+            }
+            return tags.some((tag) => w.tags?.includes(tag));
+        });
+    }
+    // Apply pagination
+    if (limit !== undefined) {
+        workflows = workflows.slice(offset, offset + limit);
+    }
+    logger.debug(`[${functionTag}] Listed workflows`, {
+        count: workflows.length,
+        type,
+        tags,
+    });
+    return workflows;
+}
+/**
+ * Get workflow metadata (usage stats, timestamps)
+ * @param workflowId - ID of workflow
+ * @returns Metadata or undefined
+ */
+export function getWorkflowMetadata(workflowId) {
+    const entry = workflowRegistry.get(workflowId);
+    if (!entry) {
+        return undefined;
+    }
+    return {
+        registeredAt: entry.registeredAt,
+        lastUsed: entry.lastUsed,
+        usageCount: entry.usageCount,
+    };
+}
+/**
+ * Update workflow configuration
+ * @param workflowId - ID of workflow to update
+ * @param updates - Partial workflow config with updates
+ * @param options - Update options
+ * @returns Update result
+ */
+export function updateWorkflow(workflowId, updates, options = {}) {
+    const existing = workflowRegistry.get(workflowId);
+    if (!existing) {
+        logger.warn(`[${functionTag}] Workflow not found for update`, {
+            workflowId,
+        });
+        return {
+            success: false,
+            workflowId,
+            error: "Workflow not found",
+        };
+    }
+    // Merge updates with existing config
+    const updatedConfig = {
+        ...existing.config,
+        ...updates,
+        id: workflowId, // Ensure ID doesn't change
+        updatedAt: new Date().toISOString(),
+    };
+    // Validate if requested
+    const { validateBeforeRegister = true } = options;
+    if (validateBeforeRegister) {
+        const validation = validateForRegistration(updatedConfig);
+        if (!validation.valid) {
+            logger.error(`[${functionTag}] Updated workflow validation failed`, {
+                workflowId,
+                errors: validation.errors,
+            });
+            return {
+                success: false,
+                workflowId,
+                validation,
+                error: "Updated workflow validation failed",
+            };
+        }
+    }
+    // Update registry entry
+    existing.config = updatedConfig;
+    logger.info(`[${functionTag}] Workflow updated successfully`, {
+        workflowId,
+    });
+    return {
+        success: true,
+        workflowId,
+    };
+}
+/**
+ * Clear all workflows from registry
+ * WARNING: This will remove all registered workflows
+ */
+export function clearRegistry() {
+    const count = workflowRegistry.size;
+    workflowRegistry.clear();
+    logger.info(`[${functionTag}] Registry cleared`, {
+        workflowsRemoved: count,
+    });
+}
+/**
+ * Get registry statistics
+ * @returns Statistics about registered workflows
+ */
+export function getRegistryStats() {
+    const entries = Array.from(workflowRegistry.values());
+    const byType = {};
+    let totalUsage = 0;
+    let mostUsed;
+    entries.forEach((entry) => {
+        // Count by type
+        const type = entry.config.type;
+        byType[type] = (byType[type] || 0) + 1;
+        // Sum usage
+        totalUsage += entry.usageCount;
+        // Track most used
+        if (!mostUsed || entry.usageCount > mostUsed.count) {
+            mostUsed = {
+                id: entry.config.id,
+                name: entry.config.name,
+                count: entry.usageCount,
+            };
+        }
+    });
+    return {
+        totalWorkflows: workflowRegistry.size,
+        byType,
+        totalUsage,
+        mostUsed: mostUsed && mostUsed.count > 0 ? mostUsed : undefined,
+    };
+}
+/**
+ * Export registry as JSON for backup/sharing
+ * @returns JSON string of all workflows
+ */
+export function exportRegistry() {
+    const workflows = Array.from(workflowRegistry.values()).map((entry) => entry.config);
+    return JSON.stringify(workflows, null, 2);
+}
+/**
+ * Import workflows from JSON
+ * @param json - JSON string of workflow configs
+ * @param options - Import options
+ * @returns Array of registration results
+ */
+export function importRegistry(json, options = {}) {
+    try {
+        const workflows = JSON.parse(json);
+        const results = [];
+        workflows.forEach((config) => {
+            const result = registerWorkflow(config, options);
+            results.push(result);
+        });
+        logger.info(`[${functionTag}] Registry import completed`, {
+            total: workflows.length,
+            successful: results.filter((r) => r.success).length,
+        });
+        return results;
+    }
+    catch (error) {
+        logger.error(`[${functionTag}] Registry import failed`, {
+            error: error.message,
+        });
+        return [
+            {
+                success: false,
+                workflowId: "import-error",
+                error: `Import failed: ${error.message}`,
+            },
+        ];
+    }
+}

package/dist/workflow/core/workflowRunner.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Workflow Runner - Main Orchestrator
+ * ===================================
+ *
+ * Coordinates the complete workflow execution pipeline:
+ * 1. Model execution (layer-based or flat)
+ * 2. Judge scoring with hierarchical prompts
+ * 3. Response conditioning (stub)
+ * 4. Metrics collection
+ * 5. Result assembly
+ *
+ * @module workflow/core/workflowRunner
+ */
+import type { JsonValue } from "../../types/common.js";
+import type { WorkflowConfig, WorkflowResult } from "../types.js";
+/**
+ * Progressive workflow response for streaming
+ */
+export type WorkflowStreamChunk = {
+    /**
+     * Type of response chunk
+     */
+    type: "preliminary" | "final";
+    /**
+     * Response content
+     */
+    content: string;
+    /**
+     * Partial workflow result (only ensemble data for preliminary)
+     */
+    partialResult?: Partial<WorkflowResult>;
+};
+/**
+ * Options for workflow execution
+ */
+export type RunWorkflowOptions = {
+    /**
+     * The user's prompt/query to send to models
+     */
+    prompt: string;
+    /**
+     * Optional conversation history for context
+     */
+    conversationHistory?: Array<{
+        role: "user" | "assistant";
+        content: string;
+    }>;
+    /**
+     * Override default timeout (ms) for this execution
+     */
+    timeout?: number;
+    /**
+     * Override default parallelism for this execution
+     */
+    parallelism?: number;
+    /**
+     * Enable verbose logging for debugging
+     */
+    verbose?: boolean;
+    /**
+     * Optional context/metadata to pass through
+     */
+    metadata?: Record<string, JsonValue>;
+    /**
+     * Enable progressive streaming (yield preliminary response)
+     */
+    streaming?: boolean;
+};
+/**
+ * Execute a complete workflow
+ *
+ * This is the main entry point that orchestrates:
+ * - Model execution (respects modelGroups or flat models)
+ * - Judge scoring (with hierarchical prompt resolution)
+ * - Response conditioning (currently stub)
+ * - Metrics calculation
+ * - Result assembly
+ *
+ * @param config - Validated workflow configuration
+ * @param options - Execution options including prompt
+ * @returns Complete workflow result with scores and metrics
+ *
+ * @example
+ * ```typescript
+ * const result = await runWorkflow(config, {
+ *   prompt: 'Explain quantum entanglement',
+ *   timeout: 30000,
+ *   verbose: true,
+ * });
+ *
+ * console.log('Best response:', result.content);
+ * console.log('Score:', result.score);
+ * ```
+ */
+export declare function runWorkflow(config: WorkflowConfig, options: RunWorkflowOptions): Promise<WorkflowResult>;
+/**
+ * Execute workflow with progressive streaming support
+ * Yields preliminary response (first completed model) and final synthesized response
+ *
+ * @param config - Validated workflow configuration
+ * @param options - Execution options with streaming enabled
+ * @returns AsyncGenerator yielding preliminary and final responses
+ *
+ * @example
+ * ```typescript
+ * for await (const chunk of runWorkflowWithStreaming(config, options)) {
+ *   if (chunk.type === 'preliminary') {
+ *     console.log('Fast response:', chunk.content);
+ *   } else {
+ *     console.log('Final synthesis:', chunk.content);
+ *   }
+ * }
+ * ```
+ */
+export declare function runWorkflowWithStreaming(config: WorkflowConfig, options: RunWorkflowOptions): AsyncGenerator<WorkflowStreamChunk, void, undefined>;