@juspay/neurolink 9.30.0 → 9.31.1

package/dist/client/workflow/core/responseConditioner.js

@@ -0,0 +1,225 @@
+/**
+ * workflow/core/responseConditioner.ts
+ * Response conditioning and synthesis
+ *
+ * Uses judge feedback and ensemble responses to synthesize an improved final response.
+ * Combines strengths from multiple responses based on evaluation insights.
+ */
+import { logger } from "../../utils/logger.js";
+import { AIProviderFactory } from "../../core/factory.js";
+const functionTag = "ResponseConditioner";
+// ============================================================================
+// CONDITIONING FUNCTIONS
+// ============================================================================
+/**
+ * Condition response by synthesizing improved version using judge feedback
+ *
+ * @param options - Conditioning options including all responses and judge feedback
+ * @returns Conditioned result with synthesized improved content
+ */
+export async function conditionResponse(options) {
+    const startTime = Date.now();
+    const { content, selectedResponse, allResponses, judgeScores, config, originalPrompt, } = options;
+    logger.debug(`[${functionTag}] Conditioning response with synthesis`, {
+        originalLength: content.length,
+        provider: selectedResponse.provider,
+        model: selectedResponse.model,
+        hasConfig: !!config,
+        numResponses: allResponses?.length || 0,
+    });
+    // Check if conditioning is enabled
+    if (!config || !config.useConfidence) {
+        logger.debug(`[${functionTag}] Conditioning disabled, returning original`);
+        return {
+            content,
+            conditioningTime: Date.now() - startTime,
+            metadata: {
+                conditioningApplied: false,
+                originalLength: content.length,
+                finalLength: content.length,
+            },
+        };
+    }
+    // If synthesis model not configured, fall back to original with metadata
+    if (!config.synthesisModel) {
+        logger.debug(`[${functionTag}] No synthesis model configured, returning original with metadata`);
+        return addMetadataOnly(content, selectedResponse, judgeScores, config, startTime);
+    }
+    try {
+        // Synthesize improved response using LLM
+        const synthesizedContent = await synthesizeImprovedResponse(content, allResponses, judgeScores, originalPrompt, config);
+        const conditioningTime = Date.now() - startTime;
+        logger.debug(`[${functionTag}] Response synthesized successfully`, {
+            conditioningTime,
+            originalLength: content.length,
+            finalLength: synthesizedContent.length,
+            improvement: synthesizedContent.length - content.length,
+        });
+        return {
+            content: synthesizedContent,
+            conditioningTime,
+            metadata: {
+                conditioningApplied: true,
+                originalLength: content.length,
+                finalLength: synthesizedContent.length,
+                confidenceStatementAdded: false,
+                modelAttributionAdded: false,
+                executionTimeAdded: false,
+                synthesisApplied: true,
+            },
+        };
+    }
+    catch (error) {
+        logger.warn(`[${functionTag}] Synthesis failed, falling back to original`, {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        // Fall back to original with metadata
+        return addMetadataOnly(content, selectedResponse, judgeScores, config, startTime);
+    }
+}
+/**
+ * Check if conditioning is enabled
+ * @param config - Conditioning configuration
+ * @returns True if conditioning should be applied
+ */
+export function isConditioningEnabled(config) {
+    return config?.useConfidence === true;
+}
+// ============================================================================
+// SYNTHESIS FUNCTIONS
+// ============================================================================
+/**
+ * Synthesize improved response using judge feedback and all ensemble responses
+ */
+async function synthesizeImprovedResponse(bestContent, allResponses, judgeScores, originalPrompt, config) {
+    const reasoning = judgeScores?.reasoning || "No specific feedback available";
+    // Build synthesis prompt
+    const synthesisPrompt = `You are a response synthesis expert. Your task is to create an improved, higher-quality response by combining the best elements from multiple AI-generated responses.
+
+ORIGINAL USER PROMPT:
+${originalPrompt || "Not provided"}
+
+JUDGE'S EVALUATION:
+${reasoning}
+
+AVAILABLE RESPONSES:
+${allResponses
+        .filter((r) => r.status === "success" && r.content)
+        .map((r, i) => `
+Response ${i + 1} (${r.provider}/${r.model}):
+${r.content}
+`)
+        .join("\n---\n")}
+
+BEST RESPONSE (Selected by Judge):
+${bestContent}
+
+YOUR TASK:
+Synthesize an improved final response that:
+1. Incorporates the judge's feedback and addresses any identified weaknesses
+2. Combines the strongest elements from all responses
+3. Maintains accuracy and technical correctness
+4. Improves clarity, completeness, and overall quality
+5. Maintains the same tone and format as the original responses
+6. Does NOT add meta-commentary, disclaimers, or explanatory notes
+7. Provides a direct, polished answer to the user's original question
+
+Output ONLY the synthesized response, nothing else.`;
+    logger.debug(`[${functionTag}] Calling synthesis model`, {
+        model: config?.synthesisModel?.model || "default",
+        provider: config?.synthesisModel?.provider || "default",
+    });
+    // Create provider for synthesis using AIProviderFactory
+    const synthesisProvider = config?.synthesisModel?.provider || "azure";
+    const synthesisModel = config?.synthesisModel?.model || "gpt-4o";
+    const provider = await AIProviderFactory.createProvider(synthesisProvider, synthesisModel);
+    // Generate improved response
+    const result = await provider.generate({
+        prompt: synthesisPrompt,
+        temperature: config?.synthesisModel?.temperature || 0.3,
+        maxTokens: 2000,
+        timeout: 30000,
+    });
+    if (!result || !result.content) {
+        throw new Error("Synthesis model returned empty response");
+    }
+    return result.content.trim();
+}
+/**
+ * Fallback: Add metadata only (original behavior)
+ */
+function addMetadataOnly(content, selectedResponse, judgeScores, config, startTime) {
+    let conditionedContent = content;
+    // Add confidence statement if enabled
+    if (config.addConfidenceStatement && judgeScores) {
+        const confidenceLevel = getConfidenceLevel(judgeScores.confidenceInJudgment || 0.5, config);
+        conditionedContent = addConfidenceStatement(conditionedContent, confidenceLevel, judgeScores.confidenceInJudgment || 0.5);
+    }
+    // Add model attribution if enabled
+    if (config.addModelAttribution) {
+        conditionedContent = addModelAttribution(conditionedContent, selectedResponse.provider, selectedResponse.model, judgeScores);
+    }
+    // Add execution time if enabled
+    if (config.addExecutionTime) {
+        conditionedContent = addExecutionMetrics(conditionedContent, selectedResponse.responseTime);
+    }
+    const conditioningTime = Date.now() - startTime;
+    return {
+        content: conditionedContent,
+        conditioningTime,
+        metadata: {
+            conditioningApplied: true,
+            originalLength: content.length,
+            finalLength: conditionedContent.length,
+            confidenceStatementAdded: config.addConfidenceStatement,
+            modelAttributionAdded: config.addModelAttribution,
+            executionTimeAdded: config.addExecutionTime,
+        },
+    };
+}
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Determine confidence level from score
+ */
+function getConfidenceLevel(confidence, config) {
+    const thresholds = config.confidenceThresholds || {
+        high: 0.8,
+        medium: 0.5,
+        low: 0.3,
+    };
+    if (confidence >= thresholds.high) {
+        return "high";
+    }
+    if (confidence >= thresholds.medium) {
+        return "medium";
+    }
+    return "low";
+}
+/**
+ * Add confidence statement to response
+ */
+function addConfidenceStatement(content, level, score) {
+    const statements = {
+        high: `\n\n---\n**Quality Assurance:** This response achieved a high confidence score (${(score * 100).toFixed(0)}%) through multi-model evaluation. The content has been validated for accuracy and completeness.`,
+        medium: `\n\n---\n**Quality Note:** This response received a moderate confidence score (${(score * 100).toFixed(0)}%) from the evaluation system. Consider cross-referencing critical details.`,
+        low: `\n\n---\n**Advisory:** This response has a lower confidence score (${(score * 100).toFixed(0)}%). Please verify important information independently.`,
+    };
+    return content + statements[level];
+}
+/**
+ * Add model attribution
+ */
+function addModelAttribution(content, provider, model, judgeScores) {
+    const score = Object.values(judgeScores?.scores || {}).reduce((max, curr) => Math.max(max, curr), 0);
+    return (content +
+        `\n\n---\n**Source:** Generated by ${provider}/${model} | Evaluation Score: ${score}/100`);
+}
+/**
+ * Add execution metrics
+ */
+function addExecutionMetrics(content, responseTime) {
+    return (content +
+        `\n\n---\n**Performance:** Response generated in ${responseTime}ms`);
+}

package/dist/client/workflow/core/types/conditionerTypes.js

@@ -0,0 +1,7 @@
+/**
+ * workflow/core/types/conditionerTypes.ts
+ * Type definitions for response conditioning
+ *
+ * Re-exports from the central types folder for backward compatibility
+ */
+export {};

package/dist/client/workflow/core/types/ensembleTypes.js

@@ -0,0 +1,7 @@
+/**
+ * workflow/core/types/ensembleTypes.ts
+ * Type definitions for ensemble execution
+ *
+ * Re-exports from the central types folder for backward compatibility
+ */
+export {};

package/dist/client/workflow/core/types/index.js

@@ -0,0 +1,7 @@
+/**
+ * workflow/core/types/index.ts
+ * Centralized export for all workflow core types
+ *
+ * Re-exports from the central types folder for backward compatibility
+ */
+export {};

package/dist/client/workflow/core/types/judgeTypes.js

@@ -0,0 +1,7 @@
+/**
+ * workflow/core/types/judgeTypes.ts
+ * Type definitions for judge scoring
+ *
+ * Re-exports from the central types folder for backward compatibility
+ */
+export {};

package/dist/client/workflow/core/types/layerTypes.js

@@ -0,0 +1,7 @@
+/**
+ * workflow/core/types/layerTypes.ts
+ * Type definitions for layer-based execution
+ *
+ * Re-exports from the central types folder for backward compatibility
+ */
+export {};

package/dist/client/workflow/core/types/registryTypes.js

@@ -0,0 +1,7 @@
+/**
+ * workflow/core/types/registryTypes.ts
+ * Type definitions for workflow registry
+ *
+ * Re-exports from the central types folder for backward compatibility
+ */
+export {};

package/dist/client/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}`,
+            },
+        ];
+    }
+}