@juspay/neurolink 9.54.2 → 9.54.3

package/dist/cli/factories/commandFactory.js

@@ -20,6 +20,7 @@ import { initializeCliParser } from "../parser.js";
 import { formatFileSize, saveAudioToFile } from "../utils/audioFileUtils.js";
 import { resolveFilePaths } from "../utils/pathResolver.js";
 import { animatedWrite } from "../utils/typewriter.js";
+import { createStreamAbortHandler } from "../utils/abortHandler.js";
 import { formatVideoFileSize, getVideoMetadataSummary, saveVideoToFile, } from "../utils/videoFileUtils.js";
 import { OllamaCommandFactory } from "./ollamaCommandFactory.js";
 import { SageMakerCommandFactory } from "./sagemakerCommandFactory.js";
@@ -2176,6 +2177,11 @@ export class CLICommandFactory {
         let lastImageBase64;
         let contentReceived = false;
         const abortController = new AbortController();
+        // BZ-667: Wire SIGINT to abort stream gracefully
+        const abortHandler = createStreamAbortHandler();
+        abortHandler.signal.addEventListener("abort", () => {
+            abortController.abort();
+        }, { once: true });
         // Create timeout promise for stream consumption (default: 30 seconds, respects user-provided timeout)
         const streamTimeout = options.timeout && typeof options.timeout === "number"
             ? options.timeout * 1000
@@ -2197,22 +2203,37 @@ export class CLICommandFactory {
                 clearTimeout(timeoutId);
             });
         });
+        const streamIterator = stream.stream[Symbol.asyncIterator]();
         try {
             // Process the stream with timeout handling
-            const streamIterator = stream.stream[Symbol.asyncIterator]();
             let timeoutActive = true;
+            // BZ-667: Create an abort promise that rejects when the user presses Ctrl+C,
+            // so we can race it against streamIterator.next() and unblock pending reads.
+            const abortPromise = new Promise((_, reject) => {
+                if (abortHandler.signal.aborted) {
+                    reject(new DOMException("Stream aborted", "AbortError"));
+                    return;
+                }
+                abortHandler.signal.addEventListener("abort", () => {
+                    reject(new DOMException("Stream aborted", "AbortError"));
+                }, { once: true });
+            });
             while (true) {
                 let nextResult;
                 if (timeoutActive && !contentReceived) {
-                    // Race between next chunk and timeout for first chunk only
+                    // Race between next chunk, timeout, and abort signal
                     nextResult = await Promise.race([
                         streamIterator.next(),
                         timeoutPromise,
+                        abortPromise,
                     ]);
                 }
                 else {
-                    // No timeout for subsequent chunks
-                    nextResult = await streamIterator.next();
+                    // Race between next chunk and abort signal
+                    nextResult = await Promise.race([
+                        streamIterator.next(),
+                        abortPromise,
+                    ]);
                 }
                 if (nextResult.done) {
                     break;
@@ -2266,8 +2287,26 @@ export class CLICommandFactory {
         }
         catch (error) {
             abortController.abort(); // Clean up timeout
+            // BZ-667: Close the stream iterator so the provider connection is released.
+            // Wrap in try/catch to prevent cleanup failures from masking the original error.
+            try {
+                await streamIterator.return?.();
+            }
+            catch {
+                // Iterator cleanup failed — swallow so the original error propagates
+            }
+            abortHandler.cleanup();
+            // BZ-667: Handle graceful abort — return partial content instead of throwing
+            if (abortHandler.signal.aborted ||
+                (error instanceof Error && error.name === "AbortError")) {
+                if (!options.quiet) {
+                    process.stdout.write("\n");
+                }
+                return { content: fullContent, imageBase64: lastImageBase64 };
+            }
             throw error;
         }
+        abortHandler.cleanup();
         if (!contentReceived) {
             throw new Error("\n❌ No content received from stream\n" +
                 "Check your credentials and provider configuration");

package/dist/cli/utils/abortHandler.d.ts

@@ -0,0 +1,22 @@
+/**
+ * CLI Abort Handler (BZ-667)
+ *
+ * Bridges SIGINT (Ctrl+C) to an AbortController for graceful stream cancellation.
+ * First Ctrl+C aborts the stream and shows "Stream cancelled."
+ * Second Ctrl+C within 1 second force-exits the process.
+ *
+ * Uses `prependListener` so the stream handler fires BEFORE the top-level
+ * SIGINT handler in cli/index.ts (which calls process.exit). The listener
+ * remains registered until `cleanup()` removes it. On the first Ctrl+C the
+ * stream is cancelled gracefully; only a rapid second press exits.
+ *
+ * @module cli/utils/abortHandler
+ */
+/**
+ * Create an abort handler that wires SIGINT to an AbortController.
+ * Call cleanup() when the stream finishes (success or error) to remove listeners.
+ */
+export declare function createStreamAbortHandler(): {
+    signal: AbortSignal;
+    cleanup: () => void;
+};

package/dist/cli/utils/abortHandler.js

@@ -0,0 +1,53 @@
+/**
+ * CLI Abort Handler (BZ-667)
+ *
+ * Bridges SIGINT (Ctrl+C) to an AbortController for graceful stream cancellation.
+ * First Ctrl+C aborts the stream and shows "Stream cancelled."
+ * Second Ctrl+C within 1 second force-exits the process.
+ *
+ * Uses `prependListener` so the stream handler fires BEFORE the top-level
+ * SIGINT handler in cli/index.ts (which calls process.exit). The listener
+ * remains registered until `cleanup()` removes it. On the first Ctrl+C the
+ * stream is cancelled gracefully; only a rapid second press exits.
+ *
+ * @module cli/utils/abortHandler
+ */
+import chalk from "chalk";
+/**
+ * Create an abort handler that wires SIGINT to an AbortController.
+ * Call cleanup() when the stream finishes (success or error) to remove listeners.
+ */
+export function createStreamAbortHandler() {
+    const controller = new AbortController();
+    let aborted = false;
+    let forceExitTimer = null;
+    const sigintHandler = () => {
+        if (aborted) {
+            // Second Ctrl+C — force exit
+            if (forceExitTimer) {
+                clearTimeout(forceExitTimer);
+            }
+            // Let the top-level SIGINT handler in cli/index.ts handle the exit
+            return;
+        }
+        aborted = true;
+        controller.abort();
+        process.stderr.write(chalk.yellow("\nStream cancelled.\n"));
+        // Allow force exit on second Ctrl+C within 1 second
+        forceExitTimer = setTimeout(() => {
+            forceExitTimer = null;
+        }, 1000);
+    };
+    // Use prependListener so our handler fires before the top-level
+    // SIGINT handler in cli/index.ts. cleanup() removes it after the stream ends.
+    process.prependListener("SIGINT", sigintHandler);
+    const cleanup = () => {
+        process.removeListener("SIGINT", sigintHandler);
+        if (forceExitTimer) {
+            clearTimeout(forceExitTimer);
+            forceExitTimer = null;
+        }
+    };
+    return { signal: controller.signal, cleanup };
+}
+//# sourceMappingURL=abortHandler.js.map

package/dist/core/baseProvider.d.ts

@@ -1,4 +1,4 @@
-import type { LanguageModel, ModelMessage, Tool } from "ai";
+import type { LanguageModel, ModelMessage, Tool, ToolCallRepairFunction, ToolSet } from "ai";
 import type { AIProviderName } from "../constants/enums.js";
 import type { EvaluationData } from "../index.js";
 import type { NeuroLink } from "../neurolink.js";
@@ -189,6 +189,12 @@ export declare abstract class BaseProvider implements AIProvider {
      * @returns The default embedding model name, or undefined if not supported
      */
     protected getDefaultEmbeddingModel(): string | undefined;
+    /**
+     * Create an `experimental_repairToolCall` handler for streamText/generateText.
+     * Dynamically reads the tool's JSON schema to repair wrong names and params.
+     * Returns undefined when repair is disabled via options.
+     */
+    protected getToolCallRepairFn(options?: StreamOptions | TextGenerationOptions): ToolCallRepairFunction<ToolSet> | undefined;
     /**
      * Provider-specific streaming implementation (only used when tools are disabled)
      */

package/dist/core/baseProvider.js

@@ -861,6 +861,25 @@ export class BaseProvider {
         // Default implementation returns undefined - providers override this
         return undefined;
     }
+    // ===================
+    // ===================
+    // BZ-665: Schema-driven tool call repair
+    // ===================
+    /**
+     * Create an `experimental_repairToolCall` handler for streamText/generateText.
+     * Dynamically reads the tool's JSON schema to repair wrong names and params.
+     * Returns undefined when repair is disabled via options.
+     */
+    getToolCallRepairFn(options) {
+        if (options?.disableToolCallRepair) {
+            return undefined;
+        }
+        // Lazy import to avoid circular dependency at module load time
+        return (async (...args) => {
+            const { createToolCallRepair } = await import("../utils/toolCallRepair.js");
+            return createToolCallRepair()(...args);
+        });
+    }
     /**
      * Get AI SDK model with middleware applied
      * This method wraps the base model with any configured middleware

package/dist/lib/core/baseProvider.d.ts

@@ -1,4 +1,4 @@
-import type { LanguageModel, ModelMessage, Tool } from "ai";
+import type { LanguageModel, ModelMessage, Tool, ToolCallRepairFunction, ToolSet } from "ai";
 import type { AIProviderName } from "../constants/enums.js";
 import type { EvaluationData } from "../index.js";
 import type { NeuroLink } from "../neurolink.js";
@@ -189,6 +189,12 @@ export declare abstract class BaseProvider implements AIProvider {
      * @returns The default embedding model name, or undefined if not supported
      */
     protected getDefaultEmbeddingModel(): string | undefined;
+    /**
+     * Create an `experimental_repairToolCall` handler for streamText/generateText.
+     * Dynamically reads the tool's JSON schema to repair wrong names and params.
+     * Returns undefined when repair is disabled via options.
+     */
+    protected getToolCallRepairFn(options?: StreamOptions | TextGenerationOptions): ToolCallRepairFunction<ToolSet> | undefined;
     /**
      * Provider-specific streaming implementation (only used when tools are disabled)
      */

package/dist/lib/core/baseProvider.js

@@ -861,6 +861,25 @@ export class BaseProvider {
         // Default implementation returns undefined - providers override this
         return undefined;
     }
+    // ===================
+    // ===================
+    // BZ-665: Schema-driven tool call repair
+    // ===================
+    /**
+     * Create an `experimental_repairToolCall` handler for streamText/generateText.
+     * Dynamically reads the tool's JSON schema to repair wrong names and params.
+     * Returns undefined when repair is disabled via options.
+     */
+    getToolCallRepairFn(options) {
+        if (options?.disableToolCallRepair) {
+            return undefined;
+        }
+        // Lazy import to avoid circular dependency at module load time
+        return (async (...args) => {
+            const { createToolCallRepair } = await import("../utils/toolCallRepair.js");
+            return createToolCallRepair()(...args);
+        });
+    }
     /**
      * Get AI SDK model with middleware applied
      * This method wraps the base model with any configured middleware

package/dist/lib/neurolink.js

@@ -4831,15 +4831,31 @@ Current user's request: ${currentInput}`;
         catch {
             /* non-blocking */
         }
-        const fallbackRoute = ModelRouter.getFallbackRoute(originalPrompt || enhancedOptions.input.text || "", {
+        // BZ-1341: Support fallback provider override via options or env vars
+        const optFallbackProvider = enhancedOptions.fallbackProvider?.trim() || undefined;
+        const optFallbackModel = enhancedOptions.fallbackModel?.trim() || undefined;
+        const envFallbackProvider = process.env.FALLBACK_PROVIDER?.trim() || undefined;
+        const envFallbackModel = process.env.FALLBACK_MODEL?.trim() || undefined;
+        const modelConfigRoute = ModelRouter.getFallbackRoute(originalPrompt || enhancedOptions.input.text || "", {
             provider: providerName,
             model: enhancedOptions.model || "gpt-4o",
             reasoning: "primary failed",
             confidence: 0.5,
         }, { fallbackStrategy: "auto" });
+        const fallbackRoute = {
+            ...modelConfigRoute,
+            provider: optFallbackProvider ?? envFallbackProvider ?? modelConfigRoute.provider,
+            model: optFallbackModel ?? envFallbackModel ?? modelConfigRoute.model,
+        };
         logger.warn("Retrying with fallback provider", {
             originalProvider: providerName,
             fallbackProvider: fallbackRoute.provider,
+            fallbackModel: fallbackRoute.model,
+            fallbackSource: optFallbackProvider || optFallbackModel
+                ? "options"
+                : envFallbackProvider || envFallbackModel
+                    ? "env"
+                    : "model_config",
             reason: errorMsg,
         });
         try {

package/dist/lib/providers/anthropic.js

@@ -799,6 +799,7 @@ export class AnthropicProvider extends BaseProvider {
                     stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                     toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                    experimental_repairToolCall: this.getToolCallRepairFn(options),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                     onStepFinish: ({ toolCalls, toolResults }) => {
                         this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {

package/dist/lib/providers/anthropicBaseProvider.js

@@ -94,6 +94,7 @@ export class AnthropicProviderV2 extends BaseProvider {
                     toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                    experimental_repairToolCall: this.getToolCallRepairFn(options),
                     onStepFinish: ({ toolCalls, toolResults }) => {
                         this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                             logger.warn("[AnthropicBaseProvider] Failed to store tool executions", {

package/dist/lib/providers/azureOpenai.js

@@ -124,6 +124,7 @@ export class AzureOpenAIProvider extends BaseProvider {
                 stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: (event) => {
                     this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
                         logger.warn("[AzureOpenaiProvider] Failed to store tool executions", {

package/dist/lib/providers/googleAiStudio.js

@@ -478,6 +478,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 // Gemini 3: use thinkingLevel via providerOptions
                 // Gemini 2.5: use thinkingBudget via providerOptions
                 ...(options.thinkingConfig?.enabled && {

package/dist/lib/providers/googleVertex.js

@@ -994,6 +994,7 @@ export class GoogleVertexProvider extends BaseProvider {
             }),
             abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
             experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+            experimental_repairToolCall: this.getToolCallRepairFn(options),
             ...(options.thinkingConfig?.enabled && {
                 providerOptions: {
                     vertex: {

package/dist/lib/providers/huggingFace.js

@@ -139,6 +139,7 @@ export class HuggingFaceProvider extends BaseProvider {
                 toolChoice: resolveToolChoice(options, (shouldUseTools ? streamOptions.tools || allTools : {}), shouldUseTools),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[HuggingFaceProvider] Failed to store tool executions", {

package/dist/lib/providers/litellm.js

@@ -169,6 +169,7 @@ export class LiteLLMProvider extends BaseProvider {
                 }),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/lib/providers/mistral.js

@@ -67,6 +67,7 @@ export class MistralProvider extends BaseProvider {
                 toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[MistralProvider] Failed to store tool executions", {

package/dist/lib/providers/openAI.js

@@ -330,6 +330,7 @@ export class OpenAIProvider extends BaseProvider {
                     stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                     toolChoice: resolvedToolChoice,
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                    experimental_repairToolCall: this.getToolCallRepairFn(options),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                     onStepFinish: ({ toolCalls, toolResults }) => {
                         logger.info("Tool execution completed", {

package/dist/lib/providers/openRouter.js

@@ -252,6 +252,7 @@ export class OpenRouterProvider extends BaseProvider {
                 }),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/lib/providers/openaiCompatible.js

@@ -195,6 +195,7 @@ export class OpenAICompatibleProvider extends BaseProvider {
                 stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
                 onStepFinish: (event) => {
                     this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
                         logger.warn("[OpenAiCompatibleProvider] Failed to store tool executions", {

package/dist/lib/types/streamTypes.d.ts

@@ -325,6 +325,8 @@ export type StreamOptions = {
     /** AbortSignal for external cancellation of the AI call */
     abortSignal?: AbortSignal;
     disableTools?: boolean;
+    /** Disable the schema-driven tool call repair mechanism (BZ-665). Default: false (repair enabled). */
+    disableToolCallRepair?: boolean;
     maxSteps?: number;
     /**
      * Tool choice configuration for streaming generation.
@@ -432,6 +434,10 @@ export type StreamOptions = {
      * @internal Set by NeuroLink SDK — not typically used directly by consumers.
      */
     fileRegistry?: unknown;
+    /** BZ-1341: Override fallback provider name (takes precedence over env/model config). */
+    fallbackProvider?: string;
+    /** BZ-1341: Override fallback model name (takes precedence over env/model config). */
+    fallbackModel?: string;
     /** Callback invoked when streaming completes successfully. */
     onFinish?: OnFinishCallback;
     /** Callback invoked when streaming encounters an error. */

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

@@ -0,0 +1,21 @@
+/**
+ * Schema-Driven Tool Call Repair (BZ-665)
+ *
+ * Implements `experimental_repairToolCall` for the Vercel AI SDK.
+ * When an LLM sends a wrong tool name or wrong parameter names,
+ * this module attempts deterministic, schema-driven repair:
+ *
+ *  1. Tool name: case-insensitive → substring → Levenshtein
+ *  2. Param names: compare against JSON schema properties dynamically
+ *  3. Type coercion: string→number, JSON string→object/array per schema
+ *
+ * Zero static alias maps. The tool's JSON schema is the only source of truth.
+ *
+ * @module utils/toolCallRepair
+ */
+import type { ToolCallRepairFunction, ToolSet } from "ai";
+/**
+ * Create an `experimental_repairToolCall` handler for streamText/generateText.
+ * Fully dynamic — reads the tool schema at repair time, no configuration needed.
+ */
+export declare function createToolCallRepair(): ToolCallRepairFunction<ToolSet>;