@juspay/neurolink 12.0.1 → 12.0.2

package/dist/cli/commands/models.js

@@ -320,6 +320,48 @@ export class ModelsCommandFactory {
             if (!argv.deprecated) {
                 models = models.filter((model) => !model.deprecated);
             }
+            // Live-discovery fallback: providers that resolve their catalog at
+            // runtime (litellm, ollama, openai-compatible gateways) have no static
+            // registry rows, so a scoped `models list --provider litellm` printed
+            // "Found 0 models" while generate/stream against those models worked.
+            // When the static registry is empty for a single requested provider,
+            // ask the provider itself.
+            if (models.length === 0 &&
+                argv.provider &&
+                (Array.isArray(argv.provider) ? argv.provider : [argv.provider])
+                    .length === 1) {
+                const providerName = String(Array.isArray(argv.provider) ? argv.provider[0] : argv.provider);
+                try {
+                    const { AIProviderFactory } = await import("../../core/factory.js");
+                    const provider = (await AIProviderFactory.createProvider(providerName));
+                    const liveIds = typeof provider.getAvailableModels === "function"
+                        ? await provider.getAvailableModels()
+                        : [];
+                    if (liveIds.length > 0) {
+                        if (spinner) {
+                            spinner.succeed(`Found ${liveIds.length} models (live from ${providerName})`);
+                        }
+                        if (argv.format === "json") {
+                            logger.always(JSON.stringify(liveIds.map((id) => ({
+                                id,
+                                provider: providerName,
+                                source: "live",
+                            })), null, 2));
+                        }
+                        else {
+                            logger.always(chalk.bold(`\n📋 Models exposed by ${providerName} (live discovery):\n`));
+                            for (const id of liveIds) {
+                                logger.always(`  ${id}`);
+                            }
+                        }
+                        return;
+                    }
+                }
+                catch {
+                    // Live discovery is best-effort — fall through to the static
+                    // (empty) listing rather than turning a listing into an error.
+                }
+            }
             if (spinner) {
                 spinner.succeed(`Found ${models.length} models`);
             }

package/dist/core/baseProvider.js

@@ -1,6 +1,7 @@
 import { context, SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { directAgentTools } from "../agent/directTools.js";
 import { defaultProviderFor } from "../factories/mediaHandlerCatalog.js";
+import { PROVIDER_DESCRIPTORS_BY_NAME } from "../factories/providerDescriptors.js";
 import { MiddlewareFactory } from "../middleware/factory.js";
 import { modelSupports } from "../models/modelRegistry.js";
 import { resolveRequestKind } from "./resolveRequestKind.js";
@@ -1243,14 +1244,23 @@ export class BaseProvider {
         }, options, startTime);
     }
     async executeStandardGenerateFlow(options, startTime, model, messages, tools) {
-        // Apply a defensive default timeout (3 min) when the caller didn't pass
-        // one. Without this guard, AI SDK's generateText() will wait forever on
+        // Apply a defensive default timeout when the caller didn't pass one.
+        // Without this guard, AI SDK's generateText() will wait forever on
         // an upstream that accepts the connection but never produces a response
         // (observed against the litellm gateway when a request triggers the
         // team-access denial path — connection stays open, no response is sent,
         // and the matrix test hangs the entire suite). Callers can still pass
         // a larger value (e.g. video generation passes 10 min).
-        const effectiveTimeout = options.timeout ?? 180_000;
+        //
+        // A provider descriptor may declare a LARGER generate budget than the
+        // 3-min floor (litellm: 300s — slow proxied models routinely need more
+        // than 180s end-to-end even while streaming). The declared value only
+        // ever raises the default, never lowers it: several descriptors carry
+        // aspirational sub-180s numbers (openai 30s, bedrock 45s) that were
+        // never enforced on this path, and enforcing them now would break
+        // long-running generations that have always been allowed.
+        const descriptorGenerateMs = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName)?.timeouts?.generateMs;
+        const effectiveTimeout = options.timeout ?? Math.max(descriptorGenerateMs ?? 0, 180_000);
         const timeoutController = createTimeoutController(effectiveTimeout, this.providerName, "generate");
         const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
         const composedOptions = composedSignal

package/dist/core/modules/GenerationHandler.js

@@ -731,7 +731,11 @@ export class GenerationHandler {
                             toolName;
                         toolsUsed.push(toolName);
                         let callArgs = {};
-                        if (tcRecord.args) {
+                        if (tcRecord.input) {
+                            // AI SDK v6 carries tool-call arguments as `input`.
+                            callArgs = tcRecord.input;
+                        }
+                        else if (tcRecord.args) {
                             callArgs = tcRecord.args;
                         }
                         else if (tcRecord.arguments) {

package/dist/neurolink.js

@@ -102,7 +102,7 @@ import { getWorkflow } from "./workflow/core/workflowRegistry.js";
 import { runWorkflow } from "./workflow/core/workflowRunner.js";
 import { ModelPool, classifyProviderError } from "./routing/index.js";
 import { ClassifierRouter } from "./routing/classifierRouter.js";
-import { looksLikeModelAccessDenied as sharedLooksLikeModelAccessDenied, isNonRetryableProviderError as sharedIsNonRetryableProviderError, isNonRetryableForPool as sharedIsNonRetryableForPool, } from "./utils/providerErrorClassification.js";
+import { looksLikeModelAccessDenied as sharedLooksLikeModelAccessDenied, looksLikeModelNotFound as sharedLooksLikeModelNotFound, isNonRetryableProviderError as sharedIsNonRetryableProviderError, isNonRetryableForPool as sharedIsNonRetryableForPool, } from "./utils/providerErrorClassification.js";
 import { getErrorStatusCode } from "./utils/providerRetry.js";
 import { detectAndRedactPII } from "./utils/piiDetector.js";
 import { validateResponse } from "./utils/responseValidator.js";
@@ -3211,6 +3211,16 @@ Current user's request: ${currentInput}`;
         // String prompts are immutable, so they pass through.
         if (typeof optionsOrPrompt !== "string") {
             optionsOrPrompt = cloneOptionsForCallIsolation(optionsOrPrompt);
+            // The deprecated `conversationHistory` field is not wired into message
+            // building — messages passed there never reach the model, which reads
+            // as "the SDK forgot my context" rather than a caller bug. Warn loudly
+            // instead of failing silently; `conversationMessages` is the wired path.
+            const legacyOpts = optionsOrPrompt;
+            if (Array.isArray(legacyOpts.conversationHistory) &&
+                legacyOpts.conversationHistory.length > 0 &&
+                !legacyOpts.conversationMessages) {
+                logger.warn("[NeuroLink.generate] `conversationHistory` is deprecated and NOT passed to the model — use `conversationMessages` (ChatMessage[]) instead.");
+            }
         }
         // Retrieve once at the public call boundary so fallback attempts reuse the
         // same grounding block and internal preparation cannot inject it twice.
@@ -3347,9 +3357,14 @@ Current user's request: ${currentInput}`;
         // mid-fallback; cloneOptionsForCallIsolation keeps abortSignal
         // by-reference, so the retried options observe the same signal.
         const callerAborted = () => callOpts.abortSignal?.aborted === true;
+        // modelChain-only orchestration advances on two error shapes the next
+        // member can actually fix: access-denied (the original gate) and
+        // model-not-found ("Invalid model name" from a gateway that doesn't
+        // serve that member — a chain written for one LiteLLM deployment must
+        // not hard-fail on another just because a member is absent there).
         const shouldOrchestrateFallback = (err) => effectiveCallback
             ? !(isAbortError(err) && callerAborted())
-            : looksLikeModelAccessDenied(err);
+            : looksLikeModelAccessDenied(err) || sharedLooksLikeModelNotFound(err);
         if (!shouldOrchestrateFallback(lastError)) {
             throw lastError;
         }

package/dist/providers/litellm/client.js

@@ -367,8 +367,11 @@ export class LiteLLMProvider extends OpenAIChatCompletionsProvider {
             {
                 match: (ctx) => /ECONNREFUSED|Failed to fetch/.test(ctx.message),
                 errorClass: NetworkError,
+                // Name the base URL this instance actually dialed — per-request
+                // credentials can override LITELLM_BASE_URL, and an error pointing
+                // at the env value sends the caller debugging the wrong host.
                 message: () => "LiteLLM proxy server not available. Please start the LiteLLM proxy server at " +
-                    `${process.env.LITELLM_BASE_URL || "http://localhost:4000"}`,
+                    redactUrlCredentials(this.config.baseURL),
             },
             {
                 match: (ctx) => /API_KEY_INVALID|Invalid API key/.test(ctx.message),
@@ -420,7 +423,12 @@ export class LiteLLMProvider extends OpenAIChatCompletionsProvider {
         return this.getFallbackModels();
     }
     async fetchModelsFromAPI() {
-        const modelsUrl = `${stripTrailingSlash(this.config.baseURL)}/v1/models`;
+        // Tolerate a `/v1`-suffixed base URL. Chat appends /chat/completions, so
+        // deployments are commonly configured with base = https://host/v1 — but
+        // appending /v1/models to that yields /v1/v1/models, which LiteLLM 404s,
+        // and discovery silently degrades to the hardcoded fallback list.
+        const root = stripTrailingSlash(this.config.baseURL).replace(/\/v1$/, "");
+        const modelsUrl = `${root}/v1/models`;
         const proxyFetch = createProxyFetch();
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), 5000);

package/dist/utils/providerErrorClassification.js

@@ -67,7 +67,11 @@ export function looksLikeModelNotFound(error) {
         lower.includes("not_found_error") ||
         msg.includes("NOT_FOUND") ||
         lower.includes("does not exist") ||
-        lower.includes("unknown model")) &&
+        lower.includes("unknown model") ||
+        // LiteLLM's phrasing for a model id its router doesn't serve — a 400,
+        // not a 404: "Invalid model name passed in model=... Call `/v1/models`
+        // to view available models for your key."
+        lower.includes("invalid model name")) &&
         namesAModel);
 }
 /**

package/dist/utils/providerHealth.js

@@ -808,13 +808,37 @@ export class ProviderHealthChecker {
             healthStatus.recommendations.push("Set LITELLM_BASE_URL to a valid URL (e.g., http://localhost:4000)");
             return;
         }
-        const availability = await this.checkLiteLLMAvailability({
-            model: this.getConfiguredLiteLLMModel(),
-            timeout,
-        });
-        if (!availability.available) {
+        // Only pin the availability check to a specific model when the user
+        // explicitly configured one. The fallback default ("openai/gpt-4o-mini")
+        // is a guess, not configuration — proxies that serve a different model
+        // set (every self-hosted gateway) were reported "Not configured" here
+        // while generate/stream against them worked fine with explicit models.
+        const configuredModel = process.env.LITELLM_MODEL;
+        let failureReason;
+        if (configuredModel) {
+            const availability = await this.checkLiteLLMAvailability({
+                model: configuredModel,
+                timeout,
+            });
+            if (!availability.available) {
+                failureReason = availability.reason ?? "unknown error";
+            }
+        }
+        else {
+            // No configured model: a reachable proxy with any models counts.
+            try {
+                const models = await this.getLiteLLMAvailableModels(timeout);
+                if (models.length === 0) {
+                    failureReason = "LiteLLM returned an empty model list";
+                }
+            }
+            catch (error) {
+                failureReason = error instanceof Error ? error.message : String(error);
+            }
+        }
+        if (failureReason !== undefined) {
             healthStatus.isConfigured = false;
-            healthStatus.configurationIssues.push(`LiteLLM runtime check failed: ${availability.reason ?? "unknown error"}`);
+            healthStatus.configurationIssues.push(`LiteLLM runtime check failed: ${failureReason}`);
             healthStatus.recommendations.push("Start the LiteLLM proxy and ensure the configured model is available from /v1/models");
             return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.0.1",
+  "version": "12.0.2",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {