@juspay/neurolink 7.29.2 → 7.29.3

package/dist/utils/evaluationUtils.js

@@ -0,0 +1,131 @@
+/**
+ * Evaluation utilities for normalizing EvaluationData objects
+ * Provides helper functions to handle partial evaluation data and ensure
+ * complete EvaluationData objects with safe defaults
+ */
+/**
+ * Default values for required EvaluationData fields
+ */
+const DEFAULT_EVALUATION_DATA = {
+    // Core scores (1-10 scale)
+    relevance: 0,
+    accuracy: 0,
+    completeness: 0,
+    overall: 0,
+    // Advanced insights
+    isOffTopic: false,
+    alertSeverity: "none",
+    reasoning: "",
+    // Metadata
+    evaluationModel: "unknown",
+    evaluationTime: 0,
+    // Enhanced metadata defaults
+    evaluationProvider: "unknown",
+    evaluationAttempt: 0,
+    evaluationConfig: {
+        mode: "default",
+        fallbackUsed: false,
+        costEstimate: 0,
+    },
+};
+/**
+ * Normalize partial EvaluationData into a complete EvaluationData object
+ * with safe defaults for missing required fields
+ */
+export function normalizeEvaluationData(partial) {
+    const normalized = {
+        ...DEFAULT_EVALUATION_DATA,
+        ...partial,
+    };
+    // Ensure scores are within valid range (0-10)
+    normalized.relevance = Math.max(0, Math.min(10, normalized.relevance));
+    normalized.accuracy = Math.max(0, Math.min(10, normalized.accuracy));
+    normalized.completeness = Math.max(0, Math.min(10, normalized.completeness));
+    normalized.overall = Math.max(0, Math.min(10, normalized.overall));
+    // Optional scores
+    if (normalized.domainAlignment !== undefined) {
+        normalized.domainAlignment = Math.max(0, Math.min(10, normalized.domainAlignment));
+    }
+    if (normalized.terminologyAccuracy !== undefined) {
+        normalized.terminologyAccuracy = Math.max(0, Math.min(10, normalized.terminologyAccuracy));
+    }
+    if (normalized.toolEffectiveness !== undefined) {
+        normalized.toolEffectiveness = Math.max(0, Math.min(10, normalized.toolEffectiveness));
+    }
+    // Validate alertSeverity enum
+    const validSeverities = ["low", "medium", "high", "none"];
+    if (!validSeverities.includes(normalized.alertSeverity)) {
+        normalized.alertSeverity = "none";
+    }
+    // Truncate reasoning and suggestedImprovements to enforce length constraints
+    normalized.reasoning = truncateString(normalized.reasoning, 150);
+    if (normalized.suggestedImprovements) {
+        normalized.suggestedImprovements = truncateString(normalized.suggestedImprovements, 100);
+    }
+    // Ensure evaluationTime is non-negative
+    normalized.evaluationTime = Math.max(0, normalized.evaluationTime);
+    // Ensure evaluationAttempt is positive
+    if (normalized.evaluationAttempt !== undefined) {
+        normalized.evaluationAttempt = Math.max(0, normalized.evaluationAttempt);
+    }
+    // Ensure evaluationConfig has required fields
+    if (normalized.evaluationConfig) {
+        normalized.evaluationConfig = {
+            mode: normalized.evaluationConfig.mode || "default",
+            fallbackUsed: Boolean(normalized.evaluationConfig.fallbackUsed),
+            costEstimate: Math.max(0, normalized.evaluationConfig.costEstimate || 0),
+        };
+    }
+    return normalized;
+}
+/**
+ * Create a default EvaluationData object for cases where no evaluation was performed
+ */
+export function createDefaultEvaluationData(overrides = {}) {
+    return normalizeEvaluationData({
+        ...overrides,
+        reasoning: overrides.reasoning || "No evaluation performed",
+        evaluationModel: overrides.evaluationModel || "none",
+    });
+}
+/**
+ * Check if EvaluationData indicates a successful evaluation
+ */
+export function isValidEvaluation(evaluation) {
+    return (evaluation.evaluationModel !== "unknown" &&
+        evaluation.evaluationModel !== "none" &&
+        evaluation.reasoning.length > 0 &&
+        evaluation.overall > 0);
+}
+/**
+ * Create EvaluationData for a failed evaluation attempt
+ */
+export function createFailedEvaluationData(error, overrides = {}) {
+    return normalizeEvaluationData({
+        ...overrides,
+        reasoning: `Evaluation failed: ${truncateString(error, 100)}`,
+        alertSeverity: "medium",
+        evaluationModel: overrides.evaluationModel || "error",
+        evaluationConfig: {
+            mode: "error",
+            fallbackUsed: true,
+            costEstimate: 0,
+        },
+    });
+}
+/**
+ * Helper function to truncate strings to a maximum length
+ */
+function truncateString(str, maxLength) {
+    if (str.length <= maxLength) {
+        return str;
+    }
+    return str.substring(0, maxLength - 3) + "...";
+}
+/**
+ * Merge multiple partial evaluation data objects into a normalized result
+ */
+export function mergeEvaluationData(...partials) {
+    const merged = partials.reduce((acc, partial) => ({ ...acc, ...partial }), {});
+    return normalizeEvaluationData(merged);
+}

package/dist/utils/optionsUtils.js

@@ -42,7 +42,7 @@ export class OptionsEnhancer {
             try {
                 return new SharedArrayBuffer(4); // 4 bytes for Int32
             }
-            catch (e) {
+            catch {
                 // SharedArrayBuffer is defined but not usable (browser CORS headers not set)
                 if (typeof logger !== "undefined" && logger?.warn) {
                     logger.warn("[OptionsEnhancer] SharedArrayBuffer is defined but not usable. " +
@@ -304,6 +304,15 @@ export class OptionsEnhancer {
     }
     static applyLegacyMigration(options, enhancementOptions) {
         const legacyMigration = enhancementOptions.legacyMigration;
+        if (!legacyMigration) {
+            throw new Error("Legacy migration configuration is required");
+        }
+        if (!legacyMigration.legacyContext) {
+            throw new Error("Legacy context is required for migration");
+        }
+        if (!legacyMigration.domainType) {
+            throw new Error("Domain type is required for migration");
+        }
         // Convert legacy context to execution context
         const executionContext = ContextConverter.convertBusinessContext(legacyMigration.legacyContext, legacyMigration.domainType, {
             preserveLegacyFields: legacyMigration.preserveFields,

package/dist/utils/performance.d.ts

@@ -84,7 +84,7 @@ export declare class MemoryManager {
 /**
  * Decorator for tracking performance of async functions
  */
-export declare function trackPerformance(operationName: string): <T extends (...args: unknown[]) => Promise<unknown>>(target: unknown, propertyName: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
+export declare function trackPerformance(operationName: string): <T extends (...args: unknown[]) => Promise<unknown>>(_target: unknown, _propertyName: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
 /**
  * Performance monitoring for CLI operations
  */

package/dist/utils/performance.js

@@ -63,11 +63,20 @@ export class PerformanceTracker {
             return `${operationName}: No metrics available`;
         }
         const memoryMB = (bytes) => (bytes / 1024 / 1024).toFixed(1);
+        if (!metric.memoryDelta) {
+            return [
+                `${operationName}:`,
+                `  Duration: ${metric.duration}ms`,
+                `  Memory Delta: Not available`,
+            ].join("\n");
+        }
+        const signHeap = metric.memoryDelta.heapUsed >= 0 ? "+" : "-";
+        const signRss = metric.memoryDelta.rss >= 0 ? "+" : "-";
         return [
             `${operationName}:`,
             `  Duration: ${metric.duration}ms`,
-            `  Memory Delta: +${memoryMB(metric.memoryDelta.heapUsed)}MB heap`,
-            `  RSS Delta: +${memoryMB(metric.memoryDelta.rss)}MB`,
+            `  Memory Delta: ${signHeap}${memoryMB(Math.abs(metric.memoryDelta.heapUsed))}MB heap`,
+            `  RSS Delta: ${signRss}${memoryMB(Math.abs(metric.memoryDelta.rss))}MB`,
         ].join("\n");
     }
 }
@@ -142,8 +151,11 @@ export class MemoryManager {
  * Decorator for tracking performance of async functions
  */
 export function trackPerformance(operationName) {
-    return function (target, propertyName, descriptor) {
+    return function (_target, _propertyName, descriptor) {
         const method = descriptor.value;
+        if (!method) {
+            throw new Error(`Method descriptor value is required for performance tracking`);
+        }
         descriptor.value = async function (...args) {
             globalTracker.start(operationName);
             try {

package/dist/utils/providerHealth.d.ts

@@ -72,6 +72,54 @@ export declare class ProviderHealthChecker {
      * Provider-specific configuration checks
      */
     private static checkProviderSpecificConfig;
+    /**
+     * Check Vertex AI configuration
+     */
+    private static checkVertexAIConfig;
+    /**
+     * Get Vertex AI project ID from environment variables
+     */
+    private static getVertexProjectId;
+    /**
+     * Check Vertex AI authentication
+     */
+    private static checkVertexAuthentication;
+    /**
+     * Check Google Application Credentials file
+     */
+    private static checkGoogleApplicationCredentials;
+    /**
+     * Check individual Google credentials
+     */
+    private static checkIndividualGoogleCredentials;
+    /**
+     * Check AWS Bedrock configuration
+     */
+    private static checkBedrockConfig;
+    /**
+     * Check AWS region configuration
+     */
+    private static checkAWSRegion;
+    /**
+     * Check AWS credentials
+     */
+    private static checkAWSCredentials;
+    /**
+     * Check Bedrock models
+     */
+    private static checkBedrockModels;
+    /**
+     * Check Bedrock endpoint
+     */
+    private static checkBedrockEndpoint;
+    /**
+     * Check Azure OpenAI configuration
+     */
+    private static checkAzureConfig;
+    /**
+     * Check Ollama configuration
+     */
+    private static checkOllamaConfig;
     /**
      * Get common models for a provider
      */