@juspay/neurolink 7.29.1 → 7.29.3

package/dist/cli/utils/ollamaUtils.js

@@ -16,6 +16,55 @@ export class OllamaUtils {
         };
         return spawnSync(command, args, defaultOptions);
     }
+    /**
+     * Check if Ollama command line is available
+     */
+    static isOllamaCommandReady() {
+        const cmdCheck = this.safeSpawn("ollama", ["list"]);
+        return !cmdCheck.error && cmdCheck.status === 0;
+    }
+    /**
+     * Validate HTTP API response from Ollama
+     */
+    static validateApiResponse(output) {
+        const httpCodeMatch = output.match(/(\d{3})$/);
+        if (!httpCodeMatch || httpCodeMatch[1] !== "200") {
+            return false;
+        }
+        // Try to parse the JSON response (excluding HTTP code)
+        const jsonResponse = output.replace(/\d{3}$/, "");
+        try {
+            const parsedResponse = JSON.parse(jsonResponse);
+            return parsedResponse && typeof parsedResponse === "object";
+        }
+        catch {
+            // JSON parsing failed, but HTTP 200 is good enough
+            return true;
+        }
+    }
+    /**
+     * Check if Ollama HTTP API is ready
+     */
+    static isOllamaApiReady() {
+        try {
+            const apiCheck = this.safeSpawn("curl", [
+                "-s",
+                "--max-time",
+                "3",
+                "--fail", // Fail on HTTP error codes
+                "-w",
+                "%{http_code}",
+                "http://localhost:11434/api/tags",
+            ]);
+            if (apiCheck.error || apiCheck.status !== 0 || !apiCheck.stdout.trim()) {
+                return false;
+            }
+            return this.validateApiResponse(apiCheck.stdout.trim());
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Wait for Ollama service to become ready with exponential backoff
      */
@@ -23,49 +72,16 @@ export class OllamaUtils {
         let delay = initialDelay;
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
             try {
-                // Try both command line and HTTP API checks
-                const cmdCheck = this.safeSpawn("ollama", ["list"]);
-                if (!cmdCheck.error && cmdCheck.status === 0) {
-                    // Stronger HTTP API probe with response validation
-                    try {
-                        const apiCheck = this.safeSpawn("curl", [
-                            "-s",
-                            "--max-time",
-                            "3",
-                            "--fail", // Fail on HTTP error codes
-                            "-w",
-                            "%{http_code}",
-                            "http://localhost:11434/api/tags",
-                        ]);
-                        if (!apiCheck.error &&
-                            apiCheck.status === 0 &&
-                            apiCheck.stdout.trim()) {
-                            // Validate that we get a proper HTTP 200 response and JSON structure
-                            const output = apiCheck.stdout.trim();
-                            const httpCodeMatch = output.match(/(\d{3})$/);
-                            if (httpCodeMatch && httpCodeMatch[1] === "200") {
-                                // Try to parse the JSON response (excluding HTTP code)
-                                const jsonResponse = output.replace(/\d{3}$/, "");
-                                try {
-                                    const parsedResponse = JSON.parse(jsonResponse);
-                                    // Verify it has the expected structure
-                                    if (parsedResponse && typeof parsedResponse === "object") {
-                                        return true; // Strong verification passed
-                                    }
-                                }
-                                catch {
-                                    // JSON parsing failed, but HTTP 200 is good enough
-                                    return true;
-                                }
-                            }
-                        }
-                    }
-                    catch {
-                        // If curl fails, fall back to command check only
-                        return true;
-                    }
-                    return true; // Command check passed
+                // Try command line check first
+                if (!this.isOllamaCommandReady()) {
+                    continue;
+                }
+                // If command check passes, verify HTTP API
+                if (this.isOllamaApiReady()) {
+                    return true;
                 }
+                // Command check passed but API not ready, still consider ready
+                return true;
             }
             catch {
                 // Service not ready yet

package/dist/config/configManager.js

@@ -6,6 +6,7 @@ import { promises as fs } from "fs";
 import path from "path";
 import crypto from "crypto";
 import { logger } from "../utils/logger.js";
+import { DEFAULT_CONFIG } from "./types.js";
 const { readFile, writeFile, readdir, mkdir, unlink, access } = fs;
 /**
  * Enhanced Config Manager with automatic backup/restore capabilities
@@ -237,7 +238,6 @@ export default ${JSON.stringify(currentConfig, null, 2)};`;
      * Generate default configuration
      */
     async generateDefaultConfig() {
-        const { DEFAULT_CONFIG } = await import("./types.js");
         return {
             ...DEFAULT_CONFIG,
             lastUpdated: Date.now(),
@@ -266,7 +266,10 @@ export default ${JSON.stringify(currentConfig, null, 2)};`;
             throw new Error("Invalid config file format");
         }
         catch (error) {
-            logger.info("Config file not found, generating default...");
+            logger.info("Config file not found or invalid, generating default...", {
+                error: error instanceof Error ? error.message : String(error),
+                configPath: this.configPath,
+            });
             return await this.generateDefaultConfig();
         }
     }

package/dist/core/analytics.d.ts

@@ -4,30 +4,8 @@
  * Provides lightweight analytics tracking for AI provider usage,
  * including tokens, costs, performance metrics, and custom context.
  */
-import type { JsonValue, UnknownRecord } from "../types/common.js";
-export interface AnalyticsData {
-    provider: string;
-    model: string;
-    tokens: {
-        input: number;
-        output: number;
-        total: number;
-    };
-    cost?: number;
-    responseTime: number;
-    context?: Record<string, JsonValue>;
-    timestamp: string;
-    evaluation?: {
-        relevanceScore: number;
-        accuracyScore: number;
-        completenessScore: number;
-        overall: number;
-        evaluationProvider?: string;
-        evaluationTime?: number;
-        evaluationAttempt?: number;
-    };
-    costDetails?: UnknownRecord;
-}
+import type { AnalyticsData } from "../types/providers.js";
+export type { AnalyticsData, TokenUsage } from "../types/providers.js";
 /**
  * Create analytics data structure from AI response
  */

package/dist/core/analytics.js

@@ -19,9 +19,9 @@ export function createAnalytics(provider, model, result, responseTime, context)
         const analytics = {
             provider,
             model,
-            tokens,
+            tokenUsage: tokens,
             cost,
-            responseTime,
+            requestDuration: responseTime,
             context: context,
             timestamp: new Date().toISOString(),
         };
@@ -40,8 +40,8 @@ export function createAnalytics(provider, model, result, responseTime, context)
         return {
             provider,
             model,
-            tokens: { input: 0, output: 0, total: 0 },
-            responseTime,
+            tokenUsage: { input: 0, output: 0, total: 0 },
+            requestDuration: responseTime,
             context: context,
             timestamp: new Date().toISOString(),
         };
@@ -56,14 +56,11 @@ function extractTokenUsage(result) {
         typeof result.usage === "object" &&
         result.usage !== null) {
         const usage = result.usage;
-        // Try BaseProvider normalized format first (inputTokens/outputTokens)
-        if (typeof usage.inputTokens === "number" ||
-            typeof usage.outputTokens === "number") {
-            const input = typeof usage.inputTokens === "number" ? usage.inputTokens : 0;
-            const output = typeof usage.outputTokens === "number" ? usage.outputTokens : 0;
-            const total = typeof usage.totalTokens === "number"
-                ? usage.totalTokens
-                : input + output;
+        // Try BaseProvider normalized format first (input/output/total)
+        if (typeof usage.input === "number" || typeof usage.output === "number") {
+            const input = typeof usage.input === "number" ? usage.input : 0;
+            const output = typeof usage.output === "number" ? usage.output : 0;
+            const total = typeof usage.total === "number" ? usage.total : input + output;
             return { input, output, total };
         }
         // Try OpenAI/Mistral format (promptTokens/completionTokens)
@@ -71,14 +68,12 @@ function extractTokenUsage(result) {
             typeof usage.completionTokens === "number") {
             const input = typeof usage.promptTokens === "number" ? usage.promptTokens : 0;
             const output = typeof usage.completionTokens === "number" ? usage.completionTokens : 0;
-            const total = typeof usage.totalTokens === "number"
-                ? usage.totalTokens
-                : input + output;
+            const total = typeof usage.total === "number" ? usage.total : input + output;
             return { input, output, total };
         }
         // Handle total-only case
-        if (typeof usage.totalTokens === "number") {
-            return { input: 0, output: 0, total: usage.totalTokens };
+        if (typeof usage.total === "number") {
+            return { input: 0, output: 0, total: usage.total };
         }
     }
     // Fallback for edge cases

package/dist/core/baseProvider.d.ts

@@ -1,6 +1,7 @@
 import type { ValidationSchema } from "../types/typeAliases.js";
 import type { Tool, LanguageModelV1 } from "ai";
-import type { AIProvider, TextGenerationOptions, TextGenerationResult, EnhancedGenerateResult, AnalyticsData, AIProviderName, EvaluationData } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, TextGenerationResult, EnhancedGenerateResult, AnalyticsData, AIProviderName } from "../core/types.js";
+import type { EvaluationData } from "../index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import type { UnknownRecord } from "../types/common.js";
 import type { NeuroLink } from "../neurolink.js";
@@ -76,6 +77,34 @@ export declare abstract class BaseProvider implements AIProvider {
      * Determine if middleware should be skipped for this request
      */
     private shouldSkipMiddleware;
+    /**
+     * Check if a schema is a Zod schema
+     */
+    private isZodSchema;
+    /**
+     * Convert tool execution result from MCP format to standard format
+     */
+    private convertToolResult;
+    /**
+     * Create a custom tool from tool definition
+     */
+    private createCustomToolFromDefinition;
+    /**
+     * Process custom tools from setupToolExecutor
+     */
+    private processCustomTools;
+    /**
+     * Create an external MCP tool
+     */
+    private createExternalMCPTool;
+    /**
+     * Process external MCP tools
+     */
+    private processExternalMCPTools;
+    /**
+     * Process MCP tools integration
+     */
+    private processMCPTools;
     /**
      * Get all available tools - direct tools are ALWAYS available
      * MCP tools are added when available (without blocking)