@juspay/neurolink 9.32.0 → 9.32.1

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

@@ -1,225 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,304 +0,0 @@
-/**
- * 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}`,
-            },
-        ];
-    }
-}