@juspay/neurolink 9.3.0 → 9.5.0

package/dist/workflow/workflows/adaptiveWorkflow.js

@@ -0,0 +1,366 @@
+/**
+ * Adaptive Quality Workflow
+ * =========================
+ *
+ * Layer-based execution optimizing for maximum quality:
+ * - Start with fast validation tier
+ * - Escalate to premium tier if needed
+ * - Final expert tier for complex cases
+ *
+ * Ideal for: Quality-critical tasks with cost awareness
+ *
+ * @module workflow/workflows/adaptiveWorkflow
+ */
+import { AIProviderName } from "../../constants/enums.js";
+import { WORKFLOW_CREATION_DATE } from "../config.js";
+import { logger } from "../../utils/logger.js";
+/**
+ * Quality-Max Adaptive Workflow
+ *
+ * Uses 3-tier layer-based execution:
+ * 1. Validation tier (parallel): 2 fast models check complexity
+ * 2. Premium tier (parallel): 2 high-quality models if validation uncertain
+ * 3. Expert tier (sequential): Best model for final polish
+ *
+ * Each tier evaluates if next tier is needed based on confidence
+ *
+ * @example
+ * ```typescript
+ * import { runWorkflow } from '../core/workflowRunner.js';
+ * import { QUALITY_MAX_WORKFLOW } from './adaptiveWorkflow.js';
+ *
+ * const result = await runWorkflow(QUALITY_MAX_WORKFLOW, {
+ *   prompt: 'Design a scalable microservices architecture',
+ *   verbose: true,
+ * });
+ *
+ * console.log('Quality score:', result.score);
+ * console.log('Tiers executed:', result.ensembleResponses.length);
+ * ```
+ */
+export const QUALITY_MAX_WORKFLOW = {
+    id: "quality-max",
+    name: "Quality-Max Adaptive",
+    description: "Adaptive 3-tier execution optimizing for maximum quality",
+    version: "1.0.0",
+    type: "adaptive",
+    // Placeholder (required, but modelGroups takes precedence)
+    models: [
+        {
+            provider: AIProviderName.OPENAI,
+            model: "gpt-4o",
+        },
+    ],
+    // Layer-based execution with quality escalation
+    modelGroups: [
+        {
+            id: "validation-tier",
+            name: "Validation Tier",
+            description: "Fast models to assess complexity and confidence",
+            models: [
+                {
+                    provider: AIProviderName.OPENAI,
+                    model: "gpt-4o-mini",
+                    label: "GPT-4o-mini",
+                    temperature: 0.7,
+                    timeout: 10000,
+                },
+                {
+                    provider: AIProviderName.GOOGLE_AI,
+                    model: "gemini-2.0-flash",
+                    label: "Gemini Flash",
+                    temperature: 0.7,
+                    timeout: 10000,
+                },
+            ],
+            executionStrategy: "parallel",
+            continueOnFailure: true, // Always try premium tier
+            minSuccessful: 1,
+            parallelism: 2,
+        },
+        {
+            id: "premium-tier",
+            name: "Premium Tier",
+            description: "High-quality models for thorough analysis",
+            models: [
+                {
+                    provider: AIProviderName.OPENAI,
+                    model: "gpt-4o",
+                    label: "GPT-4o",
+                    temperature: 0.7,
+                    systemPrompt: "Provide comprehensive, high-quality responses with deep analysis.",
+                    timeout: 20000,
+                },
+                {
+                    provider: AIProviderName.ANTHROPIC,
+                    model: "claude-3-5-sonnet-20241022",
+                    label: "Claude 3.5 Sonnet",
+                    temperature: 0.7,
+                    systemPrompt: "Think deeply and provide nuanced, well-reasoned responses.",
+                    timeout: 20000,
+                },
+            ],
+            executionStrategy: "parallel",
+            continueOnFailure: true,
+            minSuccessful: 1,
+            parallelism: 2,
+        },
+        {
+            id: "expert-tier",
+            name: "Expert Tier",
+            description: "Top-tier model for final quality assurance",
+            models: [
+                {
+                    provider: AIProviderName.ANTHROPIC,
+                    model: "claude-3-5-sonnet-20241022",
+                    label: "Claude 3.5 Sonnet Expert",
+                    temperature: 0.6, // Lower temp for consistency
+                    systemPrompt: "You are an expert. Provide the highest quality, most accurate response possible. Be thorough, precise, and authoritative.",
+                    timeout: 30000,
+                },
+            ],
+            executionStrategy: "sequential",
+            continueOnFailure: false,
+            minSuccessful: 1,
+        },
+    ],
+    // Judge evaluates all responses and selects best
+    judge: {
+        provider: AIProviderName.OPENAI,
+        model: "gpt-4o",
+        criteria: ["quality", "depth", "accuracy", "completeness"],
+        outputFormat: "detailed",
+        includeReasoning: true,
+        temperature: 0.1,
+        scoreScale: { min: 0, max: 100 },
+        customPrompt: "Evaluate responses for maximum quality. Prioritize depth, accuracy, and completeness. Be rigorous in assessment.",
+    },
+    // Execution configuration
+    execution: {
+        timeout: 70000, // 70 seconds for all tiers
+        minResponses: 2,
+        costThreshold: 0.12,
+    },
+    // Metadata
+    tags: ["adaptive", "quality", "tiered", "escalation"],
+    metadata: {
+        useCase: "Quality-critical tasks with adaptive execution",
+        recommendedFor: [
+            "complex analysis",
+            "expert consultation",
+            "high-stakes decisions",
+            "technical documentation",
+        ],
+        averageCost: 0.08, // Cost depends on how many tiers execute
+        averageLatency: 4500,
+    },
+    createdAt: WORKFLOW_CREATION_DATE,
+};
+/**
+ * Speed-First Adaptive Workflow
+ *
+ * Optimizes for speed with quality fallback:
+ * 1. Fast tier: Single fast model (GPT-4o-mini)
+ * 2. Balanced tier: If fast fails, use Gemini 2.0
+ * 3. Quality tier: If both fail, use GPT-4o
+ */
+export const SPEED_FIRST_WORKFLOW = {
+    id: "speed-first",
+    name: "Speed-First Adaptive",
+    description: "Fast execution with quality fallback",
+    version: "1.0.0",
+    type: "adaptive",
+    models: [
+        {
+            provider: AIProviderName.OPENAI,
+            model: "gpt-4o-mini",
+        },
+    ],
+    modelGroups: [
+        {
+            id: "fast-tier",
+            name: "Fast Tier",
+            models: [
+                {
+                    provider: AIProviderName.OPENAI,
+                    model: "gpt-4o-mini",
+                    temperature: 0.7,
+                    timeout: 5000, // 5 second timeout
+                },
+            ],
+            executionStrategy: "sequential",
+            continueOnFailure: true,
+            minSuccessful: 1,
+        },
+        {
+            id: "balanced-tier",
+            name: "Balanced Tier",
+            models: [
+                {
+                    provider: AIProviderName.GOOGLE_AI,
+                    model: "gemini-2.0-flash",
+                    temperature: 0.7,
+                    timeout: 10000,
+                },
+            ],
+            executionStrategy: "sequential",
+            continueOnFailure: true,
+            minSuccessful: 1,
+        },
+        {
+            id: "quality-tier",
+            name: "Quality Tier",
+            models: [
+                {
+                    provider: AIProviderName.OPENAI,
+                    model: "gpt-4o",
+                    temperature: 0.7,
+                    timeout: 15000,
+                },
+            ],
+            executionStrategy: "sequential",
+            continueOnFailure: false,
+            minSuccessful: 1,
+        },
+    ],
+    judge: {
+        provider: AIProviderName.OPENAI,
+        model: "gpt-4o-mini", // Fast judge
+        criteria: ["speed", "quality"],
+        outputFormat: "best",
+        includeReasoning: true,
+        temperature: 0.1,
+        scoreScale: { min: 0, max: 100 },
+    },
+    execution: {
+        timeout: 35000,
+        minResponses: 1,
+        costThreshold: 0.05,
+    },
+    tags: ["adaptive", "speed", "fallback"],
+    metadata: {
+        useCase: "Speed-optimized with quality guarantee",
+        recommendedFor: ["real-time applications", "quick queries"],
+        averageCost: 0.01,
+        averageLatency: 1500,
+    },
+    createdAt: WORKFLOW_CREATION_DATE,
+};
+/**
+ * Balanced Adaptive Workflow
+ *
+ * Balances speed, cost, and quality:
+ * 1. Standard tier (parallel): GPT-4o-mini + Gemini Flash
+ * 2. Premium tier (parallel): GPT-4o + Claude 3.5 if standard uncertain
+ */
+export const BALANCED_ADAPTIVE_WORKFLOW = {
+    id: "balanced-adaptive",
+    name: "Balanced Adaptive",
+    description: "Balanced 2-tier execution",
+    version: "1.0.0",
+    type: "adaptive",
+    models: [
+        {
+            provider: AIProviderName.OPENAI,
+            model: "gpt-4o-mini",
+        },
+    ],
+    modelGroups: [
+        {
+            id: "standard-tier",
+            name: "Standard Tier",
+            description: "Fast, cost-effective models",
+            models: [
+                {
+                    provider: AIProviderName.OPENAI,
+                    model: "gpt-4o-mini",
+                    temperature: 0.7,
+                },
+                {
+                    provider: AIProviderName.GOOGLE_AI,
+                    model: "gemini-2.0-flash",
+                    temperature: 0.7,
+                },
+            ],
+            executionStrategy: "parallel",
+            continueOnFailure: true,
+            minSuccessful: 1,
+            parallelism: 2,
+        },
+        {
+            id: "premium-tier",
+            name: "Premium Tier",
+            description: "High-quality models for complex cases",
+            models: [
+                {
+                    provider: AIProviderName.OPENAI,
+                    model: "gpt-4o",
+                    temperature: 0.7,
+                },
+                {
+                    provider: AIProviderName.ANTHROPIC,
+                    model: "claude-3-5-sonnet-20241022",
+                    temperature: 0.7,
+                },
+            ],
+            executionStrategy: "parallel",
+            continueOnFailure: false,
+            minSuccessful: 1,
+            parallelism: 2,
+        },
+    ],
+    judge: {
+        provider: AIProviderName.OPENAI,
+        model: "gpt-4o",
+        criteria: ["quality", "accuracy", "balance"],
+        outputFormat: "detailed",
+        includeReasoning: true,
+        temperature: 0.1,
+        scoreScale: { min: 0, max: 100 },
+    },
+    execution: {
+        timeout: 40000,
+        minResponses: 2,
+        costThreshold: 0.08,
+    },
+    tags: ["adaptive", "balanced", "tiered"],
+    metadata: {
+        useCase: "Balanced speed/quality/cost tradeoff",
+        recommendedFor: ["general purpose", "production applications"],
+        averageCost: 0.04,
+        averageLatency: 2500,
+    },
+    createdAt: WORKFLOW_CREATION_DATE,
+};
+/**
+ * Create custom adaptive workflow
+ *
+ * @param tiers - Number of quality tiers (2, 3, or 4)
+ * @param strategy - 'speed' | 'balanced' | 'quality'
+ * @returns Configured adaptive workflow
+ *
+ * @example
+ * ```typescript
+ * const workflow = createAdaptiveWorkflow(3, 'quality');
+ * const result = await runWorkflow(workflow, {
+ *   prompt: 'Complex technical analysis',
+ * });
+ * ```
+ */
+export function createAdaptiveWorkflow(tiers, strategy) {
+    const workflows = {
+        speed: SPEED_FIRST_WORKFLOW,
+        balanced: BALANCED_ADAPTIVE_WORKFLOW,
+        quality: QUALITY_MAX_WORKFLOW,
+    };
+    const actualTiers = strategy === "balanced" ? 2 : 3;
+    if (tiers !== actualTiers) {
+        logger.warn(`[AdaptiveWorkflow] Requested ${tiers} tiers but ${strategy} strategy uses ${actualTiers} tiers`);
+    }
+    return {
+        ...workflows[strategy],
+        id: `adaptive-${actualTiers}tier-${strategy}`,
+        name: `Adaptive ${actualTiers}-Tier (${strategy})`,
+        description: `${actualTiers}-tier adaptive execution optimized for ${strategy}`,
+    };
+}

package/dist/workflow/workflows/consensusWorkflow.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Consensus-3 Workflow
+ * ====================
+ *
+ * 3-model ensemble with judge selecting best response based on:
+ * - Accuracy
+ * - Clarity
+ * - Completeness
+ *
+ * Ideal for: Balanced quality across multiple providers
+ *
+ * @module workflow/workflows/consensusWorkflow
+ */
+import type { WorkflowConfig } from "../types.js";
+/**
+ * Consensus-3 Workflow Configuration
+ *
+ * Uses 3 high-quality models in parallel:
+ * - GPT-4o (OpenAI) - Strong reasoning
+ * - Claude 3.5 Sonnet (Anthropic) - Thoughtful analysis
+ * - Gemini 2.0 Flash (Google) - Fast and capable
+ *
+ * Judge: GPT-4o evaluates on accuracy, clarity, and completeness
+ *
+ * @example
+ * ```typescript
+ * import { runWorkflow } from '../core/workflowRunner.js';
+ * import { CONSENSUS_3_WORKFLOW } from './consensusWorkflow.js';
+ *
+ * const result = await runWorkflow(CONSENSUS_3_WORKFLOW, {
+ *   prompt: 'Explain the theory of relativity',
+ *   verbose: true,
+ * });
+ *
+ * console.log('Best response:', result.content);
+ * console.log('Score:', result.score);
+ * console.log('Reasoning:', result.reasoning);
+ * ```
+ */
+export declare const CONSENSUS_3_WORKFLOW: WorkflowConfig;
+/**
+ * Consensus-3 with Custom System Prompt
+ *
+ * Same as CONSENSUS_3_WORKFLOW but allows custom system prompt
+ *
+ * @param systemPrompt - Custom system prompt for all models
+ * @returns Workflow configuration with custom prompt
+ *
+ * @example
+ * ```typescript
+ * const workflow = createConsensus3WithPrompt(
+ *   'You are a technical expert. Provide detailed, accurate responses.'
+ * );
+ *
+ * const result = await runWorkflow(workflow, {
+ *   prompt: 'Explain async/await in JavaScript',
+ * });
+ * ```
+ */
+export declare function createConsensus3WithPrompt(systemPrompt: string): WorkflowConfig;
+/**
+ * Consensus-3 Fast (Lower Cost, Faster)
+ *
+ * Uses faster/cheaper models with same consensus approach:
+ * - GPT-4o-mini
+ * - Claude 3 Haiku
+ * - Gemini 2.0 Flash
+ */
+export declare const CONSENSUS_3_FAST_WORKFLOW: WorkflowConfig;

package/dist/workflow/workflows/consensusWorkflow.js

@@ -0,0 +1,192 @@
+/**
+ * Consensus-3 Workflow
+ * ====================
+ *
+ * 3-model ensemble with judge selecting best response based on:
+ * - Accuracy
+ * - Clarity
+ * - Completeness
+ *
+ * Ideal for: Balanced quality across multiple providers
+ *
+ * @module workflow/workflows/consensusWorkflow
+ */
+import { AIProviderName } from "../../constants/enums.js";
+import { WORKFLOW_CREATION_DATE } from "../config.js";
+/**
+ * Consensus-3 Workflow Configuration
+ *
+ * Uses 3 high-quality models in parallel:
+ * - GPT-4o (OpenAI) - Strong reasoning
+ * - Claude 3.5 Sonnet (Anthropic) - Thoughtful analysis
+ * - Gemini 2.0 Flash (Google) - Fast and capable
+ *
+ * Judge: GPT-4o evaluates on accuracy, clarity, and completeness
+ *
+ * @example
+ * ```typescript
+ * import { runWorkflow } from '../core/workflowRunner.js';
+ * import { CONSENSUS_3_WORKFLOW } from './consensusWorkflow.js';
+ *
+ * const result = await runWorkflow(CONSENSUS_3_WORKFLOW, {
+ *   prompt: 'Explain the theory of relativity',
+ *   verbose: true,
+ * });
+ *
+ * console.log('Best response:', result.content);
+ * console.log('Score:', result.score);
+ * console.log('Reasoning:', result.reasoning);
+ * ```
+ */
+export const CONSENSUS_3_WORKFLOW = {
+    id: "consensus-3",
+    name: "Consensus-3 Ensemble",
+    description: "3-model parallel ensemble with judge-based selection",
+    version: "1.0.0",
+    type: "ensemble",
+    // 3 high-quality models running in parallel
+    models: [
+        {
+            provider: AIProviderName.OPENAI,
+            model: "gpt-4o",
+            label: "GPT-4o",
+            weight: 1.0,
+            temperature: 0.7,
+        },
+        {
+            provider: AIProviderName.ANTHROPIC,
+            model: "claude-3-5-sonnet-20241022",
+            label: "Claude 3.5 Sonnet",
+            weight: 1.0,
+            temperature: 0.7,
+        },
+        {
+            provider: AIProviderName.GOOGLE_AI,
+            model: "gemini-2.0-flash",
+            label: "Gemini 2.0 Flash",
+            weight: 1.0,
+            temperature: 0.7,
+        },
+    ],
+    // Judge configuration - evaluates all 3 responses
+    judge: {
+        provider: AIProviderName.OPENAI,
+        model: "gpt-4o",
+        criteria: ["accuracy", "clarity", "completeness"],
+        outputFormat: "detailed",
+        includeReasoning: true,
+        temperature: 0.1, // Low temperature for consistent judging
+        scoreScale: {
+            min: 0,
+            max: 100,
+        },
+    },
+    // Execution configuration
+    execution: {
+        parallelism: 3, // All 3 models run simultaneously
+        timeout: 30000, // 30 second total timeout
+        modelTimeout: 25000, // 25 second per-model timeout
+        minResponses: 2, // Need at least 2 successful responses
+        costThreshold: 0.1, // Warn if cost exceeds $0.10
+    },
+    // Metadata
+    tags: ["ensemble", "consensus", "balanced", "multi-provider"],
+    metadata: {
+        useCase: "Balanced quality across providers",
+        recommendedFor: ["general queries", "explanations", "analysis"],
+        averageCost: 0.02,
+        averageLatency: 2000,
+    },
+    createdAt: WORKFLOW_CREATION_DATE,
+};
+/**
+ * Consensus-3 with Custom System Prompt
+ *
+ * Same as CONSENSUS_3_WORKFLOW but allows custom system prompt
+ *
+ * @param systemPrompt - Custom system prompt for all models
+ * @returns Workflow configuration with custom prompt
+ *
+ * @example
+ * ```typescript
+ * const workflow = createConsensus3WithPrompt(
+ *   'You are a technical expert. Provide detailed, accurate responses.'
+ * );
+ *
+ * const result = await runWorkflow(workflow, {
+ *   prompt: 'Explain async/await in JavaScript',
+ * });
+ * ```
+ */
+export function createConsensus3WithPrompt(systemPrompt) {
+    return {
+        ...CONSENSUS_3_WORKFLOW,
+        id: `consensus-3-custom-${Date.now()}`,
+        defaultSystemPrompt: systemPrompt,
+    };
+}
+/**
+ * Consensus-3 Fast (Lower Cost, Faster)
+ *
+ * Uses faster/cheaper models with same consensus approach:
+ * - GPT-4o-mini
+ * - Claude 3 Haiku
+ * - Gemini 2.0 Flash
+ */
+export const CONSENSUS_3_FAST_WORKFLOW = {
+    id: "consensus-3-fast",
+    name: "Consensus-3 Fast",
+    description: "3-model fast ensemble (lower cost)",
+    version: "1.0.0",
+    type: "ensemble",
+    models: [
+        {
+            provider: AIProviderName.OPENAI,
+            model: "gpt-4o-mini",
+            label: "GPT-4o-mini",
+            weight: 1.0,
+            temperature: 0.7,
+        },
+        {
+            provider: AIProviderName.ANTHROPIC,
+            model: "claude-3-haiku-20240307",
+            label: "Claude 3 Haiku",
+            weight: 1.0,
+            temperature: 0.7,
+        },
+        {
+            provider: AIProviderName.GOOGLE_AI,
+            model: "gemini-2.0-flash",
+            label: "Gemini 2.0 Flash",
+            weight: 1.0,
+            temperature: 0.7,
+        },
+    ],
+    judge: {
+        provider: AIProviderName.OPENAI,
+        model: "gpt-4o-mini", // Also use fast judge
+        criteria: ["accuracy", "clarity"],
+        outputFormat: "best",
+        includeReasoning: true,
+        temperature: 0.1,
+        scoreScale: {
+            min: 0,
+            max: 100,
+        },
+    },
+    execution: {
+        parallelism: 3,
+        timeout: 20000, // 20 seconds
+        modelTimeout: 15000,
+        minResponses: 2,
+        costThreshold: 0.02, // Lower cost threshold
+    },
+    tags: ["ensemble", "fast", "low-cost", "consensus"],
+    metadata: {
+        useCase: "Fast consensus for simple queries",
+        recommendedFor: ["quick questions", "simple explanations"],
+        averageCost: 0.01,
+        averageLatency: 1500,
+    },
+    createdAt: WORKFLOW_CREATION_DATE,
+};

package/dist/workflow/workflows/fallbackWorkflow.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Fallback Workflow
+ * =================
+ *
+ * Sequential fallback chain using layer-based execution:
+ * - Try fast model first
+ * - Fall back to mid-tier if needed
+ * - Final fallback to premium model
+ *
+ * Ideal for: Cost-optimization with quality guarantee
+ *
+ * @module workflow/workflows/fallbackWorkflow
+ */
+import type { WorkflowConfig } from "../types.js";
+/**
+ * Fast-Fallback Workflow Configuration
+ *
+ * Uses layer-based execution with sequential groups:
+ * 1. Fast tier: GPT-4o-mini (try first)
+ * 2. Mid tier: Gemini 2.0 Flash (if fast fails)
+ * 3. Premium tier: GPT-4o or Claude 3.5 Sonnet (last resort)
+ *
+ * Each group runs sequentially - only proceeds if previous fails
+ *
+ * @example
+ * ```typescript
+ * import { runWorkflow } from '../core/workflowRunner.js';
+ * import { FAST_FALLBACK_WORKFLOW } from './fallbackWorkflow.js';
+ *
+ * const result = await runWorkflow(FAST_FALLBACK_WORKFLOW, {
+ *   prompt: 'What is 2+2?',
+ *   verbose: true,
+ * });
+ *
+ * // Usually completes with fast tier, saving cost
+ * console.log('Executed models:', result.ensembleResponses.length);
+ * ```
+ */
+export declare const FAST_FALLBACK_WORKFLOW: WorkflowConfig;
+/**
+ * Aggressive Fallback Workflow
+ *
+ * More aggressive fallback with parallel premium tier:
+ * 1. Fast tier: GPT-4o-mini (sequential)
+ * 2. Premium tier: GPT-4o + Claude 3.5 (parallel, both execute)
+ *
+ * Guarantees high quality if fast tier fails
+ */
+export declare const AGGRESSIVE_FALLBACK_WORKFLOW: WorkflowConfig;