@juspay/neurolink 9.42.0 → 9.43.0

package/dist/lib/utils/providerUtils.js

@@ -50,7 +50,8 @@ export async function getBestProvider(requestedProvider) {
         return process.env.DEFAULT_PROVIDER;
     }
     // Special case for Ollama - prioritize local when available
-    if (process.env.OLLAMA_BASE_URL && process.env.OLLAMA_MODEL) {
+    if ((process.env.OLLAMA_BASE_URL || process.env.OLLAMA_API_BASE) &&
+        process.env.OLLAMA_MODEL) {
         try {
             if (await isProviderAvailable("ollama")) {
                 logger.debug(`[getBestProvider] Prioritizing working local Ollama`);
@@ -64,7 +65,7 @@ export async function getBestProvider(requestedProvider) {
     /**
      * Provider priority order rationale:
      * - LiteLLM and Ollama are prioritized first for local/self-hosted deployments,
-     *   avoiding cloud quota/rate-limit issues during fallback scenarios.
+     *   avoiding unnecessary dependence on external providers during fallback scenarios.
      * - Vertex (Google Cloud AI) follows for enterprise-grade reliability.
      * - Google AI follows as second cloud priority for comprehensive Google AI ecosystem support.
      * - OpenAI maintains high priority due to its consistent reliability and broad model support.
@@ -72,8 +73,8 @@ export async function getBestProvider(requestedProvider) {
      * Please update this comment if the order is changed in the future, and document the rationale for maintainability.
      */
     const providers = [
-        "litellm", // Prioritize self-hosted/proxy (no rate limits)
-        "ollama", // Local models (no rate limits)
+        "litellm", // Prioritize self-hosted proxy deployments first
+        "ollama", // Local models when the configured runtime target is installed
         "vertex", // Google Cloud AI (enterprise)
         "google-ai", // Google AI ecosystem support
         "openai", // Reliable with broad model support
@@ -101,25 +102,13 @@ async function isProviderAvailable(providerName) {
     if (!hasProviderEnvVars(providerName) && providerName !== "ollama") {
         return false;
     }
+    if (providerName === "litellm") {
+        const availability = await ProviderHealthChecker.checkFallbackProviderAvailability(AIProviderName.LITELLM, process.env.LITELLM_MODEL || "openai/gpt-4o-mini");
+        return availability.available;
+    }
     if (providerName === "ollama") {
-        try {
-            const response = await fetch("http://localhost:11434/api/tags", {
-                method: "GET",
-                signal: AbortSignal.timeout(2000),
-            });
-            if (response.ok) {
-                const { models } = await response.json();
-                const defaultOllamaModel = process.env.OLLAMA_MODEL || "llama3.1:8b";
-                // Check for exact match first, then prefix match (e.g. "gemma3:27b" matches "gemma3:27b-fp16")
-                return models.some((m) => m.name === defaultOllamaModel ||
-                    (typeof m.name === "string" &&
-                        m.name.startsWith(defaultOllamaModel.split(":")[0] + ":")));
-            }
-            return false;
-        }
-        catch {
-            return false;
-        }
+        const availability = await ProviderHealthChecker.checkFallbackProviderAvailability(AIProviderName.OLLAMA, process.env.OLLAMA_MODEL || "llama3.1:8b");
+        return availability.available;
     }
     try {
         const provider = await AIProviderFactory.createProvider(providerName);

package/dist/lib/utils/schemaConversion.d.ts

@@ -20,6 +20,7 @@ export declare function inlineJsonSchema(schema: Record<string, unknown>, defini
  * 3. Plain JSON Schema objects (have `type`/`properties` but no `_def`) — returned as-is
  */
 export declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema): object;
+export declare function normalizeJsonSchemaObject(schema: Record<string, unknown> | undefined | null): Record<string, unknown>;
 /**
  * Check if a value is a Zod schema
  */

package/dist/lib/utils/schemaConversion.js

@@ -138,6 +138,9 @@ export function convertZodToJsonSchema(zodSchema) {
         return { type: "object", properties: {} };
     }
 }
+export function normalizeJsonSchemaObject(schema) {
+    return ensureTypeField(inlineJsonSchema(schema ? { ...schema } : { type: "object", properties: {} }));
+}
 /**
  * Ensure a JSON Schema object has a `type` field (required by Vertex/Gemini).
  */

package/dist/mcp/toolRegistry.d.ts

@@ -69,6 +69,8 @@ export declare class MCPToolRegistry extends MCPRegistry {
         permissions?: string[];
         context?: ExecutionContext;
     }): Promise<ToolInfo[]>;
+    private resolveToolExecutionTarget;
+    private createExecutionContext;
     /**
      * Get tool information with server details
      */

package/dist/mcp/toolRegistry.js

@@ -9,6 +9,7 @@ import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { directAgentTools } from "../agent/directTools.js";
 import { detectCategory, createMCPServerInfo } from "../utils/mcpDefaults.js";
 import { FlexibleToolValidator } from "./flexibleToolValidator.js";
+import { ErrorFactory } from "../utils/errorHandling.js";
 import { HITLUserRejectedError, HITLTimeoutError } from "../hitl/hitlErrors.js";
 import { withSpan, tracers, ATTR } from "../telemetry/index.js";
 import { getAuthContext } from "../auth/authContext.js";
@@ -263,22 +264,7 @@ export class MCPToolRegistry extends MCPRegistry {
                     hasContext: context !== undefined,
                     sessionId: context?.sessionId,
                 });
-                // Try to find the tool by fully-qualified name first
-                let tool = this.tools.get(toolName);
-                registryLogger.info(`🔍 [TOOL_LOOKUP] Direct lookup result for '${toolName}':`, !!tool);
-                // If not found, search for tool by name across all entries (for backward compatibility)
-                let toolId = toolName;
-                if (!tool) {
-                    const matches = Array.from(this.tools.entries()).filter(([, toolInfo]) => toolInfo.name === toolName);
-                    if (matches.length > 1) {
-                        throw new Error(`Ambiguous tool name '${toolName}'. Use fully-qualified name 'serverId.${toolName}'.`);
-                    }
-                    if (matches.length === 1) {
-                        const [candidateToolId, toolInfo] = matches[0];
-                        tool = toolInfo;
-                        toolId = candidateToolId;
-                    }
-                }
+                const { tool, toolId } = this.resolveToolExecutionTarget(toolName);
                 if (!tool) {
                     throw new Error(`Tool '${toolName}' not found in registry`);
                 }
@@ -291,21 +277,7 @@ export class MCPToolRegistry extends MCPRegistry {
                         : "mcp";
                 span.setAttribute("tool.type", toolType);
                 span.setAttribute(ATTR.MCP_SERVER_ID, serverId);
-                // Try to get auth context if available
-                let authUserId;
-                try {
-                    const authCtx = getAuthContext();
-                    authUserId = authCtx?.user?.id;
-                }
-                catch {
-                    // Auth context not available — that's fine
-                }
-                // Create execution context if not provided
-                const execContext = {
-                    ...context,
-                    sessionId: context?.sessionId ?? randomUUID(),
-                    userId: context?.userId ?? authUserId,
-                };
+                const execContext = this.createExecutionContext(context);
                 // Get the tool implementation using the resolved toolId
                 const toolImpl = this.toolImplementations.get(toolId);
                 registryLogger.debug(`Looking for tool '${toolName}' (toolId: '${toolId}'), found: ${!!toolImpl}, type: ${typeof toolImpl?.execute}`);
@@ -504,6 +476,35 @@ export class MCPToolRegistry extends MCPRegistry {
         registryLogger.debug(`Listed ${result.length} unique tools (${filter ? "filtered" : "unfiltered"})`);
         return result;
     }
+    resolveToolExecutionTarget(toolName) {
+        let tool = this.tools.get(toolName);
+        registryLogger.info(`🔍 [TOOL_LOOKUP] Direct lookup result for '${toolName}':`, !!tool);
+        let toolId = toolName;
+        if (!tool) {
+            const matches = Array.from(this.tools.entries()).filter(([, toolInfo]) => toolInfo.name === toolName);
+            if (matches.length > 1) {
+                throw ErrorFactory.toolExecutionFailed(toolName, new Error(`Ambiguous tool name '${toolName}'. Use fully-qualified name 'serverId.${toolName}'.`));
+            }
+            if (matches.length === 1) {
+                [toolId, tool] = matches[0];
+            }
+        }
+        return { tool, toolId };
+    }
+    createExecutionContext(context) {
+        let authUserId;
+        try {
+            authUserId = getAuthContext()?.user?.id;
+        }
+        catch {
+            // Auth context not available — that's fine
+        }
+        return {
+            ...context,
+            sessionId: context?.sessionId ?? randomUUID(),
+            userId: context?.userId ?? authUserId,
+        };
+    }
     /**
      * Get tool information with server details
      */

package/dist/neurolink.d.ts

@@ -81,6 +81,12 @@ export declare class NeuroLink {
      * Extract and set Langfuse context from options with proper async scoping
      */
     private setLangfuseContextFromOptions;
+    private createMetricsTraceContext;
+    private enforceSessionBudget;
+    private assertInputText;
+    private applyAuthenticatedRequestContext;
+    private applyGenerateLifecycleMiddleware;
+    private applyStreamLifecycleMiddleware;
     private initializeMemoryConfig;
     /**
      * Lazy initialization for memory — called during generate/stream.
@@ -526,6 +532,16 @@ export declare class NeuroLink {
      * @since 1.0.0
      */
     generate(optionsOrPrompt: GenerateOptions | string): Promise<GenerateResult>;
+    private executeGenerateWithMetricsContext;
+    private executeGenerateRequest;
+    private prepareGenerateRequest;
+    private maybeHandleEarlyGenerateResult;
+    private runStandardGenerateRequest;
+    private maybeApplyGenerateOrchestration;
+    private prepareGenerateAugmentations;
+    private buildGenerateTextOptions;
+    private finalizeGenerateRequestResult;
+    private emitGenerateErrorEvent;
     /**
      * Schedule non-blocking memory storage after generate completes.
      */
@@ -560,6 +576,13 @@ export declare class NeuroLink {
      * 5. Store conversation turn for future context
      */
     private generateTextInternal;
+    private executeGenerateTextInternalWithSpan;
+    private initializeGenerateTextInternalContext;
+    private runGenerateTextInternalFlow;
+    private captureOriginalConversationMessagesForRecovery;
+    private finalizeGenerateTextInternalResult;
+    private handleGenerateTextInternalFailure;
+    private tryRecoverGenerateTextOverflow;
     /**
      * Log generateTextInternal start with comprehensive analysis
      */
@@ -585,6 +608,11 @@ export declare class NeuroLink {
      * Try MCP-enhanced generation (no fallback recursion)
      */
     private tryMCPGeneration;
+    private prepareMCPGenerationContext;
+    private logMCPConversationSummary;
+    private ensureMCPGenerationBudget;
+    private compactMCPConversationForBudget;
+    private generateWithMCPProvider;
     /**
      * Direct provider generation (no MCP, no recursion)
      */
@@ -660,6 +688,10 @@ export declare class NeuroLink {
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
     stream(options: StreamOptions): Promise<StreamResult>;
+    private executeStreamRequest;
+    private validateStreamRequestOptions;
+    private maybeHandleWorkflowStreamRequest;
+    private runStandardStreamRequest;
     /**
      * Prepare stream options: initialize memory, MCP, retrieval, orchestration,
      * Ollama tool auto-disable, factory processing, and tool detection.
@@ -1061,6 +1093,12 @@ export declare class NeuroLink {
             [key: string]: unknown;
         };
     }): Promise<T>;
+    private createToolExecutionContext;
+    private executeToolWithSpan;
+    private prepareToolExecutionState;
+    private runPreparedToolExecution;
+    private handleSuccessfulToolExecution;
+    private handleFailedToolExecution;
     /**
      * Internal tool execution method with MCP enhancements wired in:
      * - ToolCache: check/store cached results for non-destructive tools