@juspay/neurolink 9.41.0 → 9.42.1

package/dist/lib/providers/huggingFace.d.ts

@@ -1,8 +1,8 @@
+import { type LanguageModel, type Schema } from "ai";
 import type { ZodType } from "zod";
-import { type Schema, type LanguageModel } from "ai";
-import { AIProviderName } from "../constants/enums.js";
-import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 /**
  * HuggingFace Provider - BaseProvider Implementation
  * Using AI SDK with HuggingFace's OpenAI-compatible endpoint

package/dist/lib/providers/huggingFace.js

@@ -1,12 +1,12 @@
 import { createOpenAI } from "@ai-sdk/openai";
 import { NoOutputGeneratedError, stepCountIs, streamText, } from "ai";
-import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import { logger } from "../utils/logger.js";
-import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { validateApiKey, createHuggingFaceConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { logger } from "../utils/logger.js";
+import { createHuggingFaceConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 // Configuration helpers - now using consolidated utility
 const getHuggingFaceApiKey = () => {
     return validateApiKey(createHuggingFaceConfig());
@@ -136,9 +136,7 @@ export class HuggingFaceProvider extends BaseProvider {
                 tools: (shouldUseTools
                     ? streamOptions.tools || allTools
                     : {}),
-                toolChoice: (shouldUseTools
-                    ? streamOptions.toolChoice || "auto"
-                    : "none"),
+                toolChoice: resolveToolChoice(options, (shouldUseTools ? streamOptions.tools || allTools : {}), shouldUseTools),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
@@ -203,7 +201,7 @@ export class HuggingFaceProvider extends BaseProvider {
             prompt: options.input.text,
             system: enhancedSystemPrompt,
             tools: formattedTools,
-            toolChoice: formattedTools ? "auto" : undefined,
+            toolChoice: formattedTools ? (options.toolChoice ?? "auto") : undefined,
         };
     }
     /**

package/dist/lib/providers/litellm.d.ts

@@ -29,6 +29,7 @@ export declare class LiteLLMProvider extends BaseProvider {
      * Note: This is only used when tools are disabled
      */
     protected executeStream(options: StreamOptions, analysisSchema?: ZodType | Schema<unknown>): Promise<StreamResult>;
+    private createLiteLLMTransformedStream;
     /**
      * Generate an embedding for a single text input
      * Uses the LiteLLM proxy with OpenAI-compatible embedding API

package/dist/lib/providers/litellm.js

@@ -11,6 +11,7 @@ import { logger } from "../utils/logger.js";
 import { calculateCost } from "../utils/pricing.js";
 import { getProviderModel } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 import { getModelId } from "./providerTypeUtils.js";
 const streamTracer = trace.getTracer("neurolink.provider.litellm");
 // Configuration helpers
@@ -59,7 +60,7 @@ export class LiteLLMProvider extends BaseProvider {
             apiKey: config.apiKey,
             fetch: createProxyFetch(),
         });
-        this.model = customOpenAI(this.modelName || getDefaultLiteLLMModel());
+        this.model = customOpenAI.chat(this.modelName || getDefaultLiteLLMModel());
         logger.debug("LiteLLM Provider initialized", {
             modelName: this.modelName,
             provider: this.providerName,
@@ -160,7 +161,7 @@ export class LiteLLMProvider extends BaseProvider {
                 ...(shouldUseTools &&
                     Object.keys(tools).length > 0 && {
                     tools,
-                    toolChoice: "auto",
+                    toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                     maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 }),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
@@ -186,6 +187,28 @@ export class LiteLLMProvider extends BaseProvider {
                 },
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     logger.info("Tool execution completed", { toolResults, toolCalls });
+                    for (const toolCall of toolCalls) {
+                        collectedToolCalls.push({
+                            toolCallId: toolCall.toolCallId,
+                            toolName: toolCall.toolName,
+                            args: toolCall.args ??
+                                toolCall.input ??
+                                toolCall
+                                    .parameters ??
+                                {},
+                        });
+                    }
+                    for (const toolResult of toolResults) {
+                        const rawToolResult = toolResult;
+                        collectedToolResults.push({
+                            toolName: toolResult.toolName,
+                            status: rawToolResult.error ? "failure" : "success",
+                            output: (rawToolResult.output ??
+                                rawToolResult.result) ?? undefined,
+                            error: rawToolResult.error,
+                            id: rawToolResult.toolCallId ?? toolResult.toolName,
+                        });
+                    }
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[LiteLLMProvider] Failed to store tool executions", {
                             provider: this.providerName,
@@ -219,6 +242,8 @@ export class LiteLLMProvider extends BaseProvider {
                 },
             });
             let result;
+            const collectedToolCalls = [];
+            const collectedToolResults = [];
             try {
                 result = streamText(streamOptions);
             }
@@ -269,58 +294,7 @@ export class LiteLLMProvider extends BaseProvider {
                 streamSpan.end();
             });
             timeoutController?.cleanup();
-            // Transform stream to content object stream using fullStream (handles both text and tool calls)
-            // Note: fullStream includes tool results, textStream only has text
-            const transformedStream = (async function* () {
-                try {
-                    // Try fullStream first (handles both text and tool calls), fallback to textStream
-                    const streamToUse = result.fullStream || result.textStream;
-                    for await (const chunk of streamToUse) {
-                        // Handle different chunk types from fullStream
-                        if (chunk && typeof chunk === "object") {
-                            // Check for error chunks first (critical error handling)
-                            if ("type" in chunk && chunk.type === "error") {
-                                const errorChunk = chunk;
-                                logger.error(`LiteLLM: Error chunk received:`, {
-                                    errorType: errorChunk.type,
-                                    errorDetails: errorChunk.error,
-                                });
-                                throw new Error(`LiteLLM streaming error: ${errorChunk.error?.message || "Unknown error"}`);
-                            }
-                            if ("textDelta" in chunk) {
-                                // Text delta from fullStream
-                                const textDelta = chunk.textDelta;
-                                if (textDelta) {
-                                    yield { content: textDelta };
-                                }
-                            }
-                            else if ("type" in chunk &&
-                                chunk.type === "tool-call" &&
-                                "toolCallId" in chunk) {
-                                // Tool call event - log for debugging
-                                const toolCallId = String(chunk.toolCallId);
-                                const toolName = "toolName" in chunk ? String(chunk.toolName) : "unknown";
-                                logger.debug("LiteLLM: Tool call", {
-                                    toolCallId,
-                                    toolName,
-                                });
-                            }
-                        }
-                        else if (typeof chunk === "string") {
-                            // Direct string chunk from textStream fallback
-                            yield { content: chunk };
-                        }
-                    }
-                }
-                catch (streamError) {
-                    // AI SDK v6 throws NoOutputGeneratedError when the stream produced no output.
-                    if (NoOutputGeneratedError.isInstance(streamError)) {
-                        logger.warn("LiteLLM: Stream produced no output (NoOutputGeneratedError)");
-                        return;
-                    }
-                    throw streamError;
-                }
-            })();
+            const transformedStream = this.createLiteLLMTransformedStream(result);
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
                 requestId: options.requestId ??
@@ -331,6 +305,10 @@ export class LiteLLMProvider extends BaseProvider {
                 stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
+                ...(shouldUseTools && {
+                    toolCalls: collectedToolCalls,
+                    toolResults: collectedToolResults,
+                }),
                 analytics: analyticsPromise,
                 metadata: {
                     startTime,
@@ -343,6 +321,47 @@ export class LiteLLMProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    async *createLiteLLMTransformedStream(result) {
+        try {
+            const streamToUse = result.fullStream || result.textStream;
+            for await (const chunk of streamToUse) {
+                if (chunk && typeof chunk === "object") {
+                    if ("type" in chunk && chunk.type === "error") {
+                        const errorChunk = chunk;
+                        logger.error(`LiteLLM: Error chunk received:`, {
+                            errorType: errorChunk.type,
+                            errorDetails: errorChunk.error,
+                        });
+                        throw this.formatProviderError(new Error(`LiteLLM streaming error: ${errorChunk.error?.message || "Unknown error"}`));
+                    }
+                    if ("textDelta" in chunk) {
+                        const textDelta = chunk.textDelta;
+                        if (textDelta) {
+                            yield { content: textDelta };
+                        }
+                    }
+                    else if ("type" in chunk &&
+                        chunk.type === "tool-call" &&
+                        "toolCallId" in chunk) {
+                        logger.debug("LiteLLM: Tool call", {
+                            toolCallId: String(chunk.toolCallId),
+                            toolName: "toolName" in chunk ? String(chunk.toolName) : "unknown",
+                        });
+                    }
+                }
+                else if (typeof chunk === "string") {
+                    yield { content: chunk };
+                }
+            }
+        }
+        catch (streamError) {
+            if (NoOutputGeneratedError.isInstance(streamError)) {
+                logger.warn("LiteLLM: Stream produced no output (NoOutputGeneratedError)");
+                return;
+            }
+            throw streamError;
+        }
+    }
     /**
      * Generate an embedding for a single text input
      * Uses the LiteLLM proxy with OpenAI-compatible embedding API
@@ -419,7 +438,9 @@ export class LiteLLMProvider extends BaseProvider {
             });
         }
         // Fallback to hardcoded list if API fetch fails
-        const fallbackModels = process.env.LITELLM_FALLBACK_MODELS?.split(",").map((m) => m.trim()) || [
+        const fallbackModels = process.env.LITELLM_FALLBACK_MODELS?.split(",")
+            .map((m) => m.trim())
+            .filter((m) => m.length > 0) || [
             "openai/gpt-4o", // minimal safe baseline
             "anthropic/claude-3-haiku",
             "meta-llama/llama-3.1-8b-instruct",

package/dist/lib/providers/mistral.js

@@ -7,6 +7,7 @@ import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { logger } from "../utils/logger.js";
 import { createMistralConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
 // Configuration helpers - now using consolidated utility
 const getMistralApiKey = () => {
@@ -63,7 +64,7 @@ export class MistralProvider extends BaseProvider {
                 maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified
                 tools,
                 stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
-                toolChoice: shouldUseTools ? "auto" : "none",
+                toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {

package/dist/lib/providers/ollama.js

@@ -11,7 +11,7 @@ import { InvalidModelError, NetworkError, ProviderError, } from "../types/errors
 import { tracers, ATTR, withClientSpan } from "../telemetry/index.js";
 import { TimeoutError } from "../utils/timeout.js";
 // Model version constants (configurable via environment)
-const DEFAULT_OLLAMA_MODEL = "llama3.1:8b";
+const DEFAULT_OLLAMA_MODEL = process.env.OLLAMA_MODEL || "llama3.1:8b";
 const FALLBACK_OLLAMA_MODEL = "llama3.2:latest"; // Used when primary model fails
 // Configuration helpers
 const getOllamaBaseUrl = () => {
@@ -40,6 +40,26 @@ const getOllamaTimeout = () => {
     // especially for larger models like aliafshar/gemma3-it-qat-tools:latest (12.2B parameters)
     return parseInt(process.env.OLLAMA_TIMEOUT || "240000", 10);
 };
+function isOllamaHttpError(error) {
+    return (error instanceof ProviderError &&
+        typeof error.statusCode === "number" &&
+        typeof error.responseBody === "string");
+}
+async function createOllamaHttpError(response) {
+    let responseBody = "";
+    try {
+        responseBody = (await response.text()).trim();
+    }
+    catch {
+        // Ignore unreadable bodies
+    }
+    const suffix = responseBody ? ` - ${responseBody.slice(0, 500)}` : "";
+    const error = new ProviderError(`Ollama API error: ${response.status} ${response.statusText}${suffix}`, "ollama");
+    error.statusCode = response.status;
+    error.statusText = response.statusText;
+    error.responseBody = responseBody;
+    return error;
+}
 // Create proxy-aware fetch instance
 const proxyFetch = createProxyFetch();
 // Custom LanguageModel implementation for Ollama
@@ -110,21 +130,37 @@ class OllamaLanguageModel {
                 signal: createAbortSignalWithTimeout(this.timeout),
             });
             if (!response.ok) {
-                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+                throw await createOllamaHttpError(response);
             }
             const data = await response.json();
             logger.debug("[OllamaLanguageModel] OpenAI API Response:", JSON.stringify(data, null, 2));
             const text = data.choices?.[0]?.message?.content || "";
             const usage = data.usage || {};
+            const promptTokens = usage.prompt_tokens ??
+                this.estimateTokenCount(JSON.stringify(messages));
+            const completionTokens = usage.completion_tokens ?? this.estimateTokenCount(text);
             return {
+                content: text ? [{ type: "text", text }] : [],
                 text,
                 usage: {
-                    promptTokens: usage.prompt_tokens ??
-                        this.estimateTokenCount(JSON.stringify(messages)),
-                    completionTokens: usage.completion_tokens ?? this.estimateTokenCount(text),
-                    totalTokens: usage.total_tokens,
+                    inputTokens: promptTokens,
+                    outputTokens: completionTokens,
+                    promptTokens,
+                    completionTokens,
+                    totalTokens: usage.total_tokens ?? promptTokens + completionTokens,
+                },
+                finishReason: data.choices?.[0]?.finish_reason ?? "stop",
+                warnings: [],
+                request: {
+                    body: JSON.stringify(requestBody),
+                },
+                response: {
+                    id: data.id,
+                    modelId: data.model,
+                    timestamp: new Date(),
+                    headers: {},
+                    body: data,
                 },
-                finishReason: "stop",
                 rawCall: {
                     rawPrompt: messages,
                     rawSettings: {
@@ -158,21 +194,45 @@ class OllamaLanguageModel {
                 signal: createAbortSignalWithTimeout(this.timeout),
             });
             if (!response.ok) {
-                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+                throw await createOllamaHttpError(response);
             }
             const data = await response.json();
             logger.debug("[OllamaLanguageModel] Native API Response:", JSON.stringify(data, null, 2));
+            const text = String(data.response ?? "");
+            const promptTokens = data.prompt_eval_count ?? this.estimateTokenCount(prompt);
+            const completionTokens = data.eval_count ?? this.estimateTokenCount(text);
+            const requestBody = {
+                model: this.modelId,
+                prompt,
+                stream: false,
+                system: messages.find((m) => m.role === "system")?.content,
+                options: {
+                    temperature: options.temperature,
+                    num_predict: options.maxTokens,
+                },
+            };
             return {
-                text: data.response,
+                content: text ? [{ type: "text", text }] : [],
+                text,
                 usage: {
-                    promptTokens: data.prompt_eval_count ?? this.estimateTokenCount(prompt),
-                    completionTokens: data.eval_count ??
-                        this.estimateTokenCount(String(data.response ?? "")),
-                    totalTokens: (data.prompt_eval_count ?? this.estimateTokenCount(prompt)) +
-                        (data.eval_count ??
-                            this.estimateTokenCount(String(data.response ?? ""))),
+                    inputTokens: promptTokens,
+                    outputTokens: completionTokens,
+                    promptTokens,
+                    completionTokens,
+                    totalTokens: promptTokens + completionTokens,
+                },
+                finishReason: data.done_reason ?? "stop",
+                warnings: [],
+                request: {
+                    body: JSON.stringify(requestBody),
+                },
+                response: {
+                    id: data.created_at,
+                    modelId: this.modelId,
+                    timestamp: data.created_at ? new Date(data.created_at) : new Date(),
+                    headers: {},
+                    body: data,
                 },
-                finishReason: "stop",
                 rawCall: {
                     rawPrompt: prompt,
                     rawSettings: {
@@ -220,7 +280,7 @@ class OllamaLanguageModel {
                 ok: response.ok,
             });
             if (!response.ok) {
-                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+                throw await createOllamaHttpError(response);
             }
             const self = this;
             return {
@@ -282,7 +342,7 @@ class OllamaLanguageModel {
                 ok: response.ok,
             });
             if (!response.ok) {
-                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+                throw await createOllamaHttpError(response);
             }
             const self = this;
             return {
@@ -705,7 +765,7 @@ export class OllamaProvider extends BaseProvider {
                                 signal: createAbortSignalWithTimeout(this.timeout),
                             });
                             if (!response.ok) {
-                                throw this.handleProviderError(new Error(`Ollama API error: ${response.status} ${response.statusText}`));
+                                throw this.handleProviderError(await createOllamaHttpError(response));
                             }
                             // Process response stream
                             const { content, toolCalls, finishReason } = await this.processOllamaResponse(response, controller);
@@ -870,7 +930,7 @@ export class OllamaProvider extends BaseProvider {
                     ok: response.ok,
                 });
                 if (!response.ok) {
-                    throw this.handleProviderError(new Error(`Ollama API error: ${response.status} ${response.statusText}`));
+                    throw this.handleProviderError(await createOllamaHttpError(response));
                 }
                 // Transform to async generator for OpenAI-compatible format
                 const self = this;
@@ -936,7 +996,7 @@ export class OllamaProvider extends BaseProvider {
                     ok: response.ok,
                 });
                 if (!response.ok) {
-                    throw this.handleProviderError(new Error(`Ollama API error: ${response.status} ${response.statusText}`));
+                    throw this.handleProviderError(await createOllamaHttpError(response));
                 }
                 // Transform to async generator to match other providers
                 const self = this;
@@ -1486,8 +1546,18 @@ export class OllamaProvider extends BaseProvider {
             error.message?.includes("not found")) {
             return new InvalidModelError(`❌ Ollama Model Not Found\n\nModel '${this.modelName}' is not available locally.\n\n🔧 Install Model:\n1. Run: ollama pull ${this.modelName}\n2. Or try a different model:\n   - ollama pull ${FALLBACK_OLLAMA_MODEL}\n   - ollama pull mistral:latest\n   - ollama pull codellama:latest\n\n🔧 List Available Models:\nollama list`, this.providerName);
         }
-        if (error.message?.includes("404")) {
-            return new NetworkError(`❌ Ollama API Endpoint Not Found\n\nThe API endpoint might have changed or Ollama version is incompatible.\n\n🔧 Check:\n1. Ollama version: 'ollama --version'\n2. Update Ollama to latest version\n3. Verify API is available: 'curl ${this.baseUrl}/api/version'`, this.providerName);
+        const errMsg = error.message ?? "";
+        const httpStatus = isOllamaHttpError(error) ? error.statusCode : undefined;
+        const responseBody = isOllamaHttpError(error) ? error.responseBody : "";
+        if (httpStatus === 404 &&
+            (responseBody.toLowerCase().includes("model") ||
+                responseBody.toLowerCase().includes("not found") ||
+                errMsg.toLowerCase().includes("model") ||
+                errMsg.toLowerCase().includes("not found"))) {
+            return new InvalidModelError(`❌ Ollama Returned HTTP 404\n\nThis usually means the configured model '${this.modelName}' is not installed locally, although a bad base URL or incompatible API mode can also cause it.\n\n🔧 Check:\n1. Verify the model exists: 'ollama list'\n2. Pull it if missing: 'ollama pull ${this.modelName}'\n3. Verify the service is healthy: 'curl ${this.baseUrl}/api/version'\n4. If you use OpenAI-compatible mode, confirm the base URL serves /v1/chat/completions`, this.providerName);
+        }
+        if (httpStatus === 404) {
+            return new ProviderError(`❌ Ollama Endpoint Returned HTTP 404\n\nThe configured base URL (${this.baseUrl}) did not serve the expected Ollama endpoint for model '${this.modelName}'. This is usually a configuration or API-mode mismatch rather than a missing model.\n\n🔧 Check:\n1. Verify the base URL: ${this.baseUrl}\n2. For native Ollama mode, confirm /api/generate exists\n3. For OpenAI-compatible mode, confirm /v1/chat/completions exists\n4. If the model is missing, the response body should explicitly say so`, this.providerName);
         }
         return new ProviderError(`❌ Ollama Provider Error\n\n${error.message || "Unknown error occurred"}\n\n🔧 Troubleshooting:\n1. Check if Ollama service is running\n2. Verify model is installed: 'ollama list'\n3. Check network connectivity to ${this.baseUrl}\n4. Review Ollama logs for details`, this.providerName);
     }

package/dist/lib/providers/openAI.d.ts

@@ -52,6 +52,8 @@ export declare class OpenAIProvider extends BaseProvider {
      * and the migration guide in the project repository.
      */
     protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
+    private createOpenAITransformedStream;
+    private extractOpenAIChunkContent;
     /**
      * Generate embeddings for text using OpenAI text-embedding models
      * @param text - The text to embed