@juspay/neurolink 9.59.5 → 9.60.0

package/dist/lib/utils/pricing.js

@@ -224,6 +224,67 @@ const PRICING = {
             output: 0.15 / 1_000_000,
         },
     },
+    deepseek: {
+        "deepseek-chat": {
+            input: 0.27 / 1_000_000,
+            output: 1.1 / 1_000_000,
+            cacheRead: 0.07 / 1_000_000,
+        },
+        "deepseek-reasoner": {
+            input: 0.55 / 1_000_000,
+            output: 2.19 / 1_000_000,
+            cacheRead: 0.14 / 1_000_000,
+        },
+    },
+    "nvidia-nim": {
+        "meta/llama-3.3-70b-instruct": {
+            input: 0.4 / 1_000_000,
+            output: 0.4 / 1_000_000,
+        },
+        "meta/llama-3.1-405b-instruct": {
+            input: 1.79 / 1_000_000,
+            output: 1.79 / 1_000_000,
+        },
+        "meta/llama-3.1-70b-instruct": {
+            input: 0.4 / 1_000_000,
+            output: 0.4 / 1_000_000,
+        },
+        "meta/llama-3.2-90b-vision-instruct": {
+            input: 0.5 / 1_000_000,
+            output: 0.5 / 1_000_000,
+        },
+        "nvidia/llama-3.3-nemotron-super-49b-v1": {
+            input: 0.3 / 1_000_000,
+            output: 0.3 / 1_000_000,
+        },
+        "deepseek-ai/deepseek-r1": {
+            input: 0.55 / 1_000_000,
+            output: 2.19 / 1_000_000,
+        },
+        "mistralai/mixtral-8x22b-instruct-v0.1": {
+            input: 0.6 / 1_000_000,
+            output: 0.6 / 1_000_000,
+        },
+        "mistralai/mixtral-8x7b-instruct-v0.1": {
+            input: 0.24 / 1_000_000,
+            output: 0.24 / 1_000_000,
+        },
+        "microsoft/phi-4": { input: 0.07 / 1_000_000, output: 0.07 / 1_000_000 },
+        "google/gemma-3-27b-it": {
+            input: 0.07 / 1_000_000,
+            output: 0.07 / 1_000_000,
+        },
+    },
+    "lm-studio": {
+        // Local inference — there is no upstream USD price. Reporting a fabricated
+        // symbolic rate here misstated spend in analytics/spans, so the rate is
+        // explicitly zero. `calculateCost()` returns 0 for zero rates and the CLI
+        // / span renderers already treat 0 as "no billable cost" (no $ shown).
+        _default: { input: 0, output: 0 },
+    },
+    llamacpp: {
+        _default: { input: 0, output: 0 },
+    },
 };
 /**
  * Map of normalized provider aliases to canonical PRICING keys.
@@ -246,6 +307,12 @@ const PROVIDER_ALIASES = {
     litellm: "__cross_provider__",
     openrouter: "__cross_provider__",
     openaicompatible: "__cross_provider__",
+    deepseek: "deepseek",
+    nvidianim: "nvidia-nim",
+    nim: "nvidia-nim",
+    nvidia: "nvidia-nim",
+    lmstudio: "lm-studio",
+    llamacpp: "llamacpp",
 };
 /**
  * Look up per-token rates for a provider/model combination.
@@ -287,14 +354,19 @@ function findRates(provider, model) {
     if (providerPricing[model]) {
         return providerPricing[model];
     }
-    // Longest-prefix match
-    const sortedKeys = Object.keys(providerPricing).sort((a, b) => b.length - a.length);
+    // Longest-prefix match (skip the synthetic "_default" sentinel below)
+    const sortedKeys = Object.keys(providerPricing)
+        .filter((k) => k !== "_default")
+        .sort((a, b) => b.length - a.length);
     const key = sortedKeys.find((k) => model.startsWith(k));
     if (key) {
         return providerPricing[key];
     }
     // Fallback: Vertex hosts both Claude and Gemini models.
     // If no match found under "vertex", try "google" pricing for Gemini models.
+    // (Run BEFORE the provider-level _default fallback so that Vertex Gemini
+    // requests get the more specific Google rates rather than a generic Vertex
+    // _default if one is ever added.)
     if (normalizedProvider === "vertex" && model.startsWith("gemini")) {
         const googlePricing = PRICING["google"];
         if (googlePricing) {
@@ -308,6 +380,13 @@ function findRates(provider, model) {
             }
         }
     }
+    // Provider-level fallback: when a pricing table only has _default (or has
+    // no entry matching the specific model), use _default. This is mainly for
+    // local/symbolic providers (lm-studio, llamacpp) that don't enumerate per-
+    // model pricing.
+    if (providerPricing["_default"]) {
+        return providerPricing["_default"];
+    }
     return undefined;
 }
 /**
@@ -334,8 +413,20 @@ export function calculateCost(provider, model, usage) {
  * Check if pricing is available for a provider/model combination.
  * Checks the rate table directly instead of computing a cost,
  * so even very cheap models (e.g. gemini-1.5-flash) are detected correctly.
+ *
+ * Zero-rate entries (the local-provider `_default` for lm-studio / llamacpp)
+ * count as "no pricing" — those providers explicitly don't have an upstream
+ * USD price, and any caller gated by `hasPricing()` should treat them as
+ * non-billable rather than zero-cost-billable.
  */
 export function hasPricing(provider, model) {
-    return findRates(provider, model) !== undefined;
+    const rates = findRates(provider, model);
+    if (!rates) {
+        return false;
+    }
+    return (rates.input > 0 ||
+        rates.output > 0 ||
+        (rates.cacheRead ?? 0) > 0 ||
+        (rates.cacheCreation ?? 0) > 0);
 }
 //# sourceMappingURL=pricing.js.map

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

@@ -107,6 +107,22 @@ export declare function createAzureEndpointConfig(): ProviderConfigOptions;
  * Creates OpenAI Compatible provider configuration
  */
 export declare function createOpenAICompatibleConfig(): ProviderConfigOptions;
+/**
+ * Creates DeepSeek provider configuration
+ */
+export declare function createDeepSeekConfig(): ProviderConfigOptions;
+/**
+ * Creates NVIDIA NIM provider configuration
+ */
+export declare function createNvidiaNimConfig(): ProviderConfigOptions;
+/**
+ * Creates LM Studio provider configuration (local server)
+ */
+export declare function createLmStudioConfig(): ProviderConfigOptions;
+/**
+ * Creates llama.cpp provider configuration (local server)
+ */
+export declare function createLlamaCppConfig(): ProviderConfigOptions;
 /**
  * Creates Google Vertex Project ID configuration
  */

package/dist/lib/utils/providerConfig.js

@@ -85,6 +85,10 @@ export function validateApiKeyEnhanced(config, enableFormatValidation = false) {
         }
     }
     if (!apiKey) {
+        if (config.optional) {
+            // Local providers — base URL defaulted; treat as valid with empty value.
+            return { isValid: true, apiKey: "" };
+        }
         return {
             isValid: false,
             apiKey: "",
@@ -131,6 +135,12 @@ export function validateApiKey(config) {
         }
     }
     if (!apiKey) {
+        // Local providers (LM Studio, llama.cpp) treat envVarName as a base-URL
+        // override, not a credential. Returning "" lets callers fall back to the
+        // documented default URL without raising a configuration error.
+        if (config.optional) {
+            return "";
+        }
         throw new Error(createConfigErrorMessage(config));
     }
     return apiKey;
@@ -366,6 +376,78 @@ export function createOpenAICompatibleConfig() {
         ],
     };
 }
+/**
+ * Creates DeepSeek provider configuration
+ */
+export function createDeepSeekConfig() {
+    return {
+        providerName: "DeepSeek",
+        envVarName: "DEEPSEEK_API_KEY",
+        setupUrl: "https://platform.deepseek.com/api_keys",
+        description: "API key",
+        instructions: [
+            "1. Visit: https://platform.deepseek.com/api_keys",
+            "2. Create or sign in to your DeepSeek account",
+            "3. Generate a new API key",
+            "4. Set DEEPSEEK_API_KEY in your .env file",
+        ],
+    };
+}
+/**
+ * Creates NVIDIA NIM provider configuration
+ */
+export function createNvidiaNimConfig() {
+    return {
+        providerName: "NVIDIA NIM",
+        envVarName: "NVIDIA_NIM_API_KEY",
+        setupUrl: "https://build.nvidia.com/settings/api-keys",
+        description: "API key",
+        instructions: [
+            "1. Visit: https://build.nvidia.com/",
+            "2. Sign in with your NVIDIA developer account",
+            "3. Open Settings → API Keys",
+            "4. Generate a new API key (Bearer token)",
+            "5. Set NVIDIA_NIM_API_KEY in your .env file",
+        ],
+    };
+}
+/**
+ * Creates LM Studio provider configuration (local server)
+ */
+export function createLmStudioConfig() {
+    return {
+        providerName: "LM Studio",
+        envVarName: "LM_STUDIO_BASE_URL",
+        setupUrl: "https://lmstudio.ai/",
+        description: "LM Studio server URL",
+        instructions: [
+            "1. Install LM Studio: https://lmstudio.ai/",
+            "2. Open LM Studio and download a model (e.g. Llama 3.2 3B Instruct)",
+            '3. Click "Local Server" → Start Server',
+            "4. Default URL is http://localhost:1234/v1 (override via LM_STUDIO_BASE_URL)",
+        ],
+        // Base URL is optional — defaults to http://localhost:1234/v1 if unset.
+        optional: true,
+    };
+}
+/**
+ * Creates llama.cpp provider configuration (local server)
+ */
+export function createLlamaCppConfig() {
+    return {
+        providerName: "llama.cpp",
+        envVarName: "LLAMACPP_BASE_URL",
+        setupUrl: "https://github.com/ggerganov/llama.cpp",
+        description: "llama.cpp server URL",
+        instructions: [
+            "1. Build llama.cpp: https://github.com/ggerganov/llama.cpp#build",
+            "2. Run: ./llama-server -m model.gguf --port 8080",
+            "3. Default URL is http://localhost:8080/v1 (override via LLAMACPP_BASE_URL)",
+        ],
+        // Base URL is optional — defaults to http://localhost:8080/v1 if unset.
+        optional: true,
+    };
+}
 /**
  * Creates Google Vertex Project ID configuration
  */

package/dist/neurolink.js

@@ -7255,7 +7255,7 @@ Current user's request: ${currentInput}`;
         const finalOptions = {
             timeout: options?.timeout ??
                 toolInfo?.tool?.timeoutMs ??
-                TOOL_TIMEOUTS.EXECUTION_DEFAULT_MS,
+                TOOL_TIMEOUTS.EXECUTION_BATCH_MS,
             maxRetries: options?.maxRetries ??
                 toolInfo?.tool?.maxRetries ??
                 RETRY_ATTEMPTS.DEFAULT,

package/dist/providers/deepseek.d.ts

@@ -0,0 +1,29 @@
+import { type LanguageModel } from "ai";
+import type { AIProviderName } from "../constants/enums.js";
+import { BaseProvider } from "../core/baseProvider.js";
+import type { NeurolinkCredentials, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
+/**
+ * DeepSeek Provider
+ * OpenAI-compatible chat completions; supports deepseek-chat (V3) and
+ * deepseek-reasoner (R1, exposes reasoning_content).
+ */
+export declare class DeepSeekProvider extends BaseProvider {
+    private model;
+    private apiKey;
+    private baseURL;
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["deepseek"]);
+    protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
+    private executeStreamInner;
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    protected getAISDKModel(): LanguageModel;
+    protected formatProviderError(error: unknown): Error;
+    validateConfiguration(): Promise<boolean>;
+    getConfiguration(): {
+        provider: AIProviderName;
+        model: string;
+        defaultModel: string;
+        baseURL: string;
+    };
+}
+export default DeepSeekProvider;

package/dist/providers/deepseek.js

@@ -0,0 +1,215 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { stepCountIs, streamText } from "ai";
+import { DeepSeekModels } from "../constants/enums.js";
+import { BaseProvider } from "../core/baseProvider.js";
+import { DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { createProxyFetch, maskProxyUrl } from "../proxy/proxyFetch.js";
+import { tracers, ATTR, withClientSpan } from "../telemetry/index.js";
+import { logger } from "../utils/logger.js";
+import { createDeepSeekConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
+import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
+const makeLoggingFetch = (provider) => {
+    const base = createProxyFetch();
+    return (async (input, init) => {
+        const url = typeof input === "string"
+            ? input
+            : input instanceof URL
+                ? input.toString()
+                : input.url;
+        const reqSize = init?.body && typeof init.body === "string" ? init.body.length : 0;
+        const response = await base(input, init);
+        if (!response.ok) {
+            // Don't fall back to the raw URL — that would defeat the redaction.
+            const safeUrl = maskProxyUrl(url) ?? "<redacted>";
+            if (process.env.NEUROLINK_DEBUG_HTTP === "1") {
+                const clone = response.clone();
+                const body = await clone.text().catch(() => "<unreadable>");
+                logger.warn(`[${provider}] upstream ${response.status}`, {
+                    url: safeUrl,
+                    body: body.slice(0, 800),
+                    reqSize,
+                });
+            }
+            else {
+                logger.warn(`[${provider}] upstream ${response.status} url=${safeUrl} reqSize=${reqSize}`);
+            }
+        }
+        return response;
+    });
+};
+const DEEPSEEK_DEFAULT_BASE_URL = "https://api.deepseek.com";
+const getDeepSeekApiKey = () => {
+    return validateApiKey(createDeepSeekConfig());
+};
+const getDefaultDeepSeekModel = () => {
+    return getProviderModel("DEEPSEEK_MODEL", DeepSeekModels.DEEPSEEK_CHAT);
+};
+/**
+ * DeepSeek Provider
+ * OpenAI-compatible chat completions; supports deepseek-chat (V3) and
+ * deepseek-reasoner (R1, exposes reasoning_content).
+ */
+export class DeepSeekProvider extends BaseProvider {
+    model;
+    apiKey;
+    baseURL;
+    constructor(modelName, sdk, _region, credentials) {
+        const validatedNeurolink = sdk && typeof sdk === "object" && "getInMemoryServers" in sdk
+            ? sdk
+            : undefined;
+        super(modelName, "deepseek", validatedNeurolink);
+        // Trim the override before applying precedence. A blank/whitespace
+        // `credentials.apiKey` should NOT bypass `getDeepSeekApiKey()` — that
+        // would build a client with an unusable bearer token and fail at request
+        // time with a confusing 401 instead of at construction time.
+        const overrideApiKey = credentials?.apiKey?.trim();
+        this.apiKey =
+            overrideApiKey && overrideApiKey.length > 0
+                ? overrideApiKey
+                : getDeepSeekApiKey();
+        this.baseURL =
+            credentials?.baseURL ??
+                process.env.DEEPSEEK_BASE_URL ??
+                DEEPSEEK_DEFAULT_BASE_URL;
+        const deepseek = createOpenAI({
+            apiKey: this.apiKey,
+            baseURL: this.baseURL,
+            fetch: makeLoggingFetch("deepseek"),
+        });
+        // .chat() returns a Chat Completions model. The default factory call
+        // returns a Responses API model which OpenAI-compat providers don't implement.
+        this.model = deepseek.chat(this.modelName);
+        logger.debug("DeepSeek Provider initialized", {
+            modelName: this.modelName,
+            providerName: this.providerName,
+            baseURL: this.baseURL,
+        });
+    }
+    async executeStream(options, _analysisSchema) {
+        return withClientSpan({
+            name: "neurolink.provider.stream",
+            tracer: tracers.provider,
+            attributes: {
+                [ATTR.GEN_AI_SYSTEM]: "deepseek",
+                [ATTR.GEN_AI_MODEL]: this.modelName,
+                [ATTR.GEN_AI_OPERATION]: "stream",
+                [ATTR.NL_STREAM_MODE]: true,
+            },
+        }, async () => this.executeStreamInner(options));
+    }
+    async executeStreamInner(options) {
+        this.validateStreamOptions(options);
+        const startTime = Date.now();
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
+        try {
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools
+                ? options.tools || (await this.getAllTools())
+                : {};
+            const messages = await this.buildMessagesForStream(options);
+            const model = await this.getAISDKModelWithMiddleware(options);
+            const isReasoner = this.modelName === DeepSeekModels.DEEPSEEK_REASONER;
+            const result = await streamText({
+                model,
+                messages,
+                temperature: options.temperature,
+                maxOutputTokens: options.maxTokens,
+                tools,
+                stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
+                toolChoice: resolveToolChoice(options, tools, shouldUseTools),
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                // DeepSeek's `thinking` mode is opt-in for chat models — only enable
+                // when the caller explicitly asks for it via `thinkingConfig.enabled`.
+                // Forcing it on every chat call would trigger extended reasoning for
+                // simple prompts (and ignore reasoner models which control it natively).
+                providerOptions: !isReasoner && options.thinkingConfig?.enabled
+                    ? {
+                        openai: {
+                            thinking: { type: "enabled" },
+                        },
+                    }
+                    : undefined,
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
+                experimental_repairToolCall: this.getToolCallRepairFn(options),
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResults);
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
+                        logger.warn("[DeepSeekProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
+            });
+            timeoutController?.cleanup();
+            const transformedStream = this.createTextStream(result);
+            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, toAnalyticsStreamResult(result), Date.now() - startTime, {
+                requestId: `deepseek-stream-${Date.now()}`,
+                streamingMode: true,
+            });
+            return {
+                stream: transformedStream,
+                provider: this.providerName,
+                model: this.modelName,
+                analytics: analyticsPromise,
+                metadata: { startTime, streamId: `deepseek-${Date.now()}` },
+            };
+        }
+        catch (error) {
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
+        }
+    }
+    getProviderName() {
+        return this.providerName;
+    }
+    getDefaultModel() {
+        return getDefaultDeepSeekModel();
+    }
+    getAISDKModel() {
+        return this.model;
+    }
+    formatProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`DeepSeek request timed out: ${error.message}`);
+        }
+        const errorRecord = error;
+        const message = typeof errorRecord?.message === "string"
+            ? errorRecord.message
+            : "Unknown error";
+        if (message.includes("Invalid API key") ||
+            message.includes("Authentication") ||
+            message.includes("401")) {
+            return new Error("Invalid DeepSeek API key. Please check your DEEPSEEK_API_KEY environment variable.");
+        }
+        if (message.includes("rate limit") || message.includes("429")) {
+            return new Error("DeepSeek rate limit exceeded");
+        }
+        if (message.includes("Insufficient Balance") ||
+            message.includes("insufficient_balance") ||
+            message.includes("402")) {
+            return new Error("DeepSeek account has insufficient balance. Top up at https://platform.deepseek.com/usage");
+        }
+        if (message.includes("model_not_found") || message.includes("404")) {
+            return new Error(`DeepSeek model '${this.modelName}' not found. Use 'deepseek-chat' or 'deepseek-reasoner'.`);
+        }
+        return new Error(`DeepSeek error: ${message}`);
+    }
+    async validateConfiguration() {
+        return typeof this.apiKey === "string" && this.apiKey.trim().length > 0;
+    }
+    getConfiguration() {
+        return {
+            provider: this.providerName,
+            model: this.modelName,
+            defaultModel: getDefaultDeepSeekModel(),
+            baseURL: this.baseURL,
+        };
+    }
+}
+export default DeepSeekProvider;

package/dist/providers/index.d.ts

@@ -14,3 +14,7 @@ export { HuggingFaceProvider as HuggingFace } from "./huggingFace.js";
 export { OllamaProvider as Ollama } from "./ollama.js";
 export { MistralProvider as MistralAI } from "./mistral.js";
 export { LiteLLMProvider as LiteLLM } from "./litellm.js";
+export { DeepSeekProvider as DeepSeek } from "./deepseek.js";
+export { NvidiaNimProvider as NvidiaNim } from "./nvidiaNim.js";
+export { LMStudioProvider as LMStudio } from "./lmStudio.js";
+export { LlamaCppProvider as LlamaCpp } from "./llamaCpp.js";

package/dist/providers/index.js

@@ -14,3 +14,7 @@ export { HuggingFaceProvider as HuggingFace } from "./huggingFace.js";
 export { OllamaProvider as Ollama } from "./ollama.js";
 export { MistralProvider as MistralAI } from "./mistral.js";
 export { LiteLLMProvider as LiteLLM } from "./litellm.js";
+export { DeepSeekProvider as DeepSeek } from "./deepseek.js";
+export { NvidiaNimProvider as NvidiaNim } from "./nvidiaNim.js";
+export { LMStudioProvider as LMStudio } from "./lmStudio.js";
+export { LlamaCppProvider as LlamaCpp } from "./llamaCpp.js";

package/dist/providers/llamaCpp.d.ts

@@ -0,0 +1,34 @@
+import { type LanguageModel } from "ai";
+import type { AIProviderName } from "../constants/enums.js";
+import { BaseProvider } from "../core/baseProvider.js";
+import type { NeurolinkCredentials, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
+/**
+ * llama.cpp Provider
+ * Wraps a llama-server process (https://github.com/ggerganov/llama.cpp) that
+ * exposes an OpenAI-compatible API at http://localhost:8080/v1 by default.
+ * llama-server hosts ONE model loaded at startup; /v1/models returns just that.
+ */
+export declare class LlamaCppProvider extends BaseProvider {
+    private model?;
+    private readonly requestedModelName?;
+    private baseURL;
+    private apiKey;
+    private discoveredModel?;
+    private llamaCppClient;
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["llamacpp"]);
+    private getAvailableModels;
+    protected getAISDKModel(signal?: AbortSignal): Promise<LanguageModel>;
+    protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
+    private executeStreamInner;
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    protected formatProviderError(error: unknown): Error;
+    validateConfiguration(): Promise<boolean>;
+    getConfiguration(): {
+        provider: AIProviderName;
+        model: string;
+        defaultModel: string;
+        baseURL: string;
+    };
+}
+export default LlamaCppProvider;