@juspay/neurolink 9.59.6 → 9.60.1

package/dist/lib/constants/contextWindows.d.ts

@@ -36,9 +36,13 @@ export declare function getContextWindowSize(provider: string, model?: string):
 /**
  * Calculate output token reserve for a given context window.
  *
+ * Returns the *real* token count that will be reserved for output so callers
+ * (`getAvailableInputTokens`, `BudgetChecker`, conversation-memory pruning, file
+ * summarisation) compute input budget against the actual outgoing maxTokens.
+ *
  * @param contextWindow - Total context window size
  * @param maxTokens - Explicit maxTokens from user config (if set)
- * @returns Number of tokens reserved for output
+ * @returns Number of tokens reserved for output (matches what's sent upstream)
  */
 export declare function getOutputReserve(contextWindow: number, maxTokens?: number): number;
 /**

package/dist/lib/constants/contextWindows.js

@@ -23,6 +23,34 @@ export const DEFAULT_OUTPUT_RESERVE_RATIO = 0.35;
  * The "_default" key is the fallback for unknown models within a provider.
  */
 export const MODEL_CONTEXT_WINDOWS = {
+    deepseek: {
+        _default: 64_000,
+        "deepseek-chat": 64_000,
+        "deepseek-reasoner": 64_000,
+    },
+    "nvidia-nim": {
+        _default: 128_000,
+        "meta/llama-3.3-70b-instruct": 128_000,
+        "meta/llama-3.1-405b-instruct": 128_000,
+        "meta/llama-3.1-70b-instruct": 128_000,
+        "meta/llama-3.2-90b-vision-instruct": 128_000,
+        "meta/llama-3.2-11b-vision-instruct": 128_000,
+        "nvidia/llama-3.3-nemotron-super-49b-v1": 128_000,
+        "nvidia/llama-3.1-nemotron-nano-8b-v1": 128_000,
+        "nvidia/llama-3.1-nemotron-70b-instruct": 128_000,
+        "deepseek-ai/deepseek-r1": 128_000,
+        "deepseek-ai/deepseek-r1-distill-llama-70b": 128_000,
+        "mistralai/mixtral-8x22b-instruct-v0.1": 65_536,
+        "mistralai/mixtral-8x7b-instruct-v0.1": 32_768,
+        "microsoft/phi-4": 16_384,
+        "google/gemma-3-27b-it": 8_192,
+    },
+    "lm-studio": {
+        _default: 8_192,
+    },
+    llamacpp: {
+        _default: 8_192,
+    },
     anthropic: {
         _default: 200_000,
         // Claude 4.6 (Feb 2026) — 1M context window
@@ -223,6 +251,36 @@ export const MODEL_CONTEXT_WINDOWS = {
         "qwen3-vl-8b-instruct": 32_768,
     },
 };
+/**
+ * Map of provider aliases to canonical MODEL_CONTEXT_WINDOWS keys.
+ *
+ * Callers reach `getContextWindowSize` via the unnormalized form on
+ * `options.provider` (e.g. CLI `--provider lmstudio`, alias `llama.cpp`),
+ * and `ProviderFactory.normalizeProviderName` runs only at instantiation —
+ * its output never reaches budget calculations. Without this normalization
+ * those alias forms miss the table and fall back to `DEFAULT_CONTEXT_WINDOW`,
+ * understating the budget for LM Studio / llama.cpp / NVIDIA NIM.
+ *
+ * The keys here are the result of stripping non-alpha characters, so
+ * `lm-studio` -> `lmstudio`, `nvidia-nim` -> `nvidianim`, `llama.cpp` -> `llamacpp`.
+ */
+const PROVIDER_ALIAS_MAP = {
+    googleaistudio: "google-ai-studio",
+    lmstudio: "lm-studio",
+    llamacpp: "llamacpp",
+    nvidianim: "nvidia-nim",
+    nim: "nvidia-nim",
+    nvidia: "nvidia-nim",
+    deepseek: "deepseek",
+};
+function normalizeProviderForLookup(provider) {
+    const stripped = provider.toLowerCase().replace(/[^a-z]/g, "");
+    // On alias miss, return the *stripped* key — not the raw input — so case /
+    // separator variants ("OpenAI", "open-ai", "Vertex AI") still find their
+    // table entry under the lowercase canonical key instead of falling through
+    // to DEFAULT_CONTEXT_WINDOW.
+    return PROVIDER_ALIAS_MAP[stripped] ?? stripped;
+}
 /**
  * Resolve context window size for a provider/model combination.
  *
@@ -252,8 +310,10 @@ export function getContextWindowSize(provider, model) {
             // Dynamic registry not initialized yet — fall through to static lookup
         }
     }
-    // Static fallback chain
-    const providerWindows = MODEL_CONTEXT_WINDOWS[provider];
+    // Static fallback chain — normalize aliases first so "lmstudio" / "llama.cpp" /
+    // "nvidianim" find their canonical entries instead of falling back to default.
+    const canonical = normalizeProviderForLookup(provider);
+    const providerWindows = MODEL_CONTEXT_WINDOWS[canonical] ?? MODEL_CONTEXT_WINDOWS[provider];
     if (!providerWindows) {
         return DEFAULT_CONTEXT_WINDOW;
     }
@@ -273,9 +333,13 @@ export function getContextWindowSize(provider, model) {
 /**
  * Calculate output token reserve for a given context window.
  *
+ * Returns the *real* token count that will be reserved for output so callers
+ * (`getAvailableInputTokens`, `BudgetChecker`, conversation-memory pruning, file
+ * summarisation) compute input budget against the actual outgoing maxTokens.
+ *
  * @param contextWindow - Total context window size
  * @param maxTokens - Explicit maxTokens from user config (if set)
- * @returns Number of tokens reserved for output
+ * @returns Number of tokens reserved for output (matches what's sent upstream)
  */
 export function getOutputReserve(contextWindow, maxTokens) {
     if (maxTokens !== undefined && maxTokens > 0) {

package/dist/lib/constants/enums.d.ts

@@ -15,6 +15,10 @@ export declare enum AIProviderName {
     MISTRAL = "mistral",
     LITELLM = "litellm",
     SAGEMAKER = "sagemaker",
+    DEEPSEEK = "deepseek",
+    NVIDIA_NIM = "nvidia-nim",
+    LM_STUDIO = "lm-studio",
+    LLAMACPP = "llamacpp",
     AUTO = "auto"
 }
 /**
@@ -622,6 +626,54 @@ export declare enum AnthropicBetaFeature {
     INTERLEAVED_THINKING = "interleaved-thinking-2025-05-14",
     FINE_GRAINED_STREAMING = "fine-grained-tool-streaming-2025-05-14"
 }
+/**
+ * Supported Models for DeepSeek
+ * Docs: https://api-docs.deepseek.com/quick_start/pricing
+ */
+export declare enum DeepSeekModels {
+    /** General-purpose chat (DeepSeek-V3) */
+    DEEPSEEK_CHAT = "deepseek-chat",
+    /** Reasoning model (DeepSeek-R1) — exposes reasoning_content */
+    DEEPSEEK_REASONER = "deepseek-reasoner"
+}
+/**
+ * Selected NVIDIA NIM Models
+ * Full catalog: https://build.nvidia.com/models
+ * Note: NIM hosts hundreds of models; pass arbitrary IDs via --model.
+ */
+export declare enum NvidiaNimModels {
+    LLAMA_3_3_70B_INSTRUCT = "meta/llama-3.3-70b-instruct",
+    LLAMA_3_1_405B_INSTRUCT = "meta/llama-3.1-405b-instruct",
+    LLAMA_3_1_70B_INSTRUCT = "meta/llama-3.1-70b-instruct",
+    LLAMA_3_2_90B_VISION = "meta/llama-3.2-90b-vision-instruct",
+    LLAMA_3_2_11B_VISION = "meta/llama-3.2-11b-vision-instruct",
+    NEMOTRON_SUPER_49B = "nvidia/llama-3.3-nemotron-super-49b-v1",
+    NEMOTRON_NANO_8B = "nvidia/llama-3.1-nemotron-nano-8b-v1",
+    NEMOTRON_70B_INSTRUCT = "nvidia/llama-3.1-nemotron-70b-instruct",
+    DEEPSEEK_R1 = "deepseek-ai/deepseek-r1",
+    DEEPSEEK_R1_DISTILL_LLAMA_70B = "deepseek-ai/deepseek-r1-distill-llama-70b",
+    MIXTRAL_8X22B_INSTRUCT = "mistralai/mixtral-8x22b-instruct-v0.1",
+    MIXTRAL_8X7B_INSTRUCT = "mistralai/mixtral-8x7b-instruct-v0.1",
+    PHI_4 = "microsoft/phi-4",
+    GEMMA_3_27B_IT = "google/gemma-3-27b-it",
+    GLM_4_5 = "z-ai/glm4.5"
+}
+/**
+ * LM Studio loads any GGUF model the user has downloaded.
+ * Default: empty string → triggers /v1/models auto-discovery.
+ */
+export declare enum LMStudioModels {
+    /** Sentinel value — triggers auto-discovery from /v1/models */
+    AUTO_DISCOVER = ""
+}
+/**
+ * llama.cpp serves a single model loaded at server startup.
+ * Default: empty string → uses whatever is loaded.
+ */
+export declare enum LlamaCppModels {
+    /** Sentinel value — uses the model loaded by the llama-server process */
+    AUTO_DISCOVER = ""
+}
 /**
  * Buffer time in milliseconds before token expiry to trigger refresh
  *

package/dist/lib/constants/enums.js

@@ -19,6 +19,10 @@ export var AIProviderName;
     AIProviderName["MISTRAL"] = "mistral";
     AIProviderName["LITELLM"] = "litellm";
     AIProviderName["SAGEMAKER"] = "sagemaker";
+    AIProviderName["DEEPSEEK"] = "deepseek";
+    AIProviderName["NVIDIA_NIM"] = "nvidia-nim";
+    AIProviderName["LM_STUDIO"] = "lm-studio";
+    AIProviderName["LLAMACPP"] = "llamacpp";
     AIProviderName["AUTO"] = "auto";
 })(AIProviderName || (AIProviderName = {}));
 /**
@@ -848,6 +852,65 @@ export var AnthropicBetaFeature;
     AnthropicBetaFeature["INTERLEAVED_THINKING"] = "interleaved-thinking-2025-05-14";
     AnthropicBetaFeature["FINE_GRAINED_STREAMING"] = "fine-grained-tool-streaming-2025-05-14";
 })(AnthropicBetaFeature || (AnthropicBetaFeature = {}));
+/**
+ * Supported Models for DeepSeek
+ * Docs: https://api-docs.deepseek.com/quick_start/pricing
+ */
+export var DeepSeekModels;
+(function (DeepSeekModels) {
+    /** General-purpose chat (DeepSeek-V3) */
+    DeepSeekModels["DEEPSEEK_CHAT"] = "deepseek-chat";
+    /** Reasoning model (DeepSeek-R1) — exposes reasoning_content */
+    DeepSeekModels["DEEPSEEK_REASONER"] = "deepseek-reasoner";
+})(DeepSeekModels || (DeepSeekModels = {}));
+/**
+ * Selected NVIDIA NIM Models
+ * Full catalog: https://build.nvidia.com/models
+ * Note: NIM hosts hundreds of models; pass arbitrary IDs via --model.
+ */
+export var NvidiaNimModels;
+(function (NvidiaNimModels) {
+    // Meta Llama
+    NvidiaNimModels["LLAMA_3_3_70B_INSTRUCT"] = "meta/llama-3.3-70b-instruct";
+    NvidiaNimModels["LLAMA_3_1_405B_INSTRUCT"] = "meta/llama-3.1-405b-instruct";
+    NvidiaNimModels["LLAMA_3_1_70B_INSTRUCT"] = "meta/llama-3.1-70b-instruct";
+    NvidiaNimModels["LLAMA_3_2_90B_VISION"] = "meta/llama-3.2-90b-vision-instruct";
+    NvidiaNimModels["LLAMA_3_2_11B_VISION"] = "meta/llama-3.2-11b-vision-instruct";
+    // NVIDIA Nemotron (reasoning)
+    NvidiaNimModels["NEMOTRON_SUPER_49B"] = "nvidia/llama-3.3-nemotron-super-49b-v1";
+    NvidiaNimModels["NEMOTRON_NANO_8B"] = "nvidia/llama-3.1-nemotron-nano-8b-v1";
+    NvidiaNimModels["NEMOTRON_70B_INSTRUCT"] = "nvidia/llama-3.1-nemotron-70b-instruct";
+    // DeepSeek hosted on NIM
+    NvidiaNimModels["DEEPSEEK_R1"] = "deepseek-ai/deepseek-r1";
+    NvidiaNimModels["DEEPSEEK_R1_DISTILL_LLAMA_70B"] = "deepseek-ai/deepseek-r1-distill-llama-70b";
+    // Mistral / Mixtral
+    NvidiaNimModels["MIXTRAL_8X22B_INSTRUCT"] = "mistralai/mixtral-8x22b-instruct-v0.1";
+    NvidiaNimModels["MIXTRAL_8X7B_INSTRUCT"] = "mistralai/mixtral-8x7b-instruct-v0.1";
+    // Microsoft Phi
+    NvidiaNimModels["PHI_4"] = "microsoft/phi-4";
+    // Google Gemma
+    NvidiaNimModels["GEMMA_3_27B_IT"] = "google/gemma-3-27b-it";
+    // Z.AI GLM
+    NvidiaNimModels["GLM_4_5"] = "z-ai/glm4.5";
+})(NvidiaNimModels || (NvidiaNimModels = {}));
+/**
+ * LM Studio loads any GGUF model the user has downloaded.
+ * Default: empty string → triggers /v1/models auto-discovery.
+ */
+export var LMStudioModels;
+(function (LMStudioModels) {
+    /** Sentinel value — triggers auto-discovery from /v1/models */
+    LMStudioModels["AUTO_DISCOVER"] = "";
+})(LMStudioModels || (LMStudioModels = {}));
+/**
+ * llama.cpp serves a single model loaded at server startup.
+ * Default: empty string → uses whatever is loaded.
+ */
+export var LlamaCppModels;
+(function (LlamaCppModels) {
+    /** Sentinel value — uses the model loaded by the llama-server process */
+    LlamaCppModels["AUTO_DISCOVER"] = "";
+})(LlamaCppModels || (LlamaCppModels = {}));
 // ============================================================================
 // ANTHROPIC OAUTH CONSTANTS
 // ============================================================================

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

@@ -9,7 +9,7 @@ import { TelemetryHandler } from "./modules/TelemetryHandler.js";
  * Tools are integrated as first-class citizens - always available by default
  */
 export declare abstract class BaseProvider implements AIProvider {
-    protected readonly modelName: string;
+    protected modelName: string;
     protected readonly providerName: AIProviderName;
     protected readonly defaultTimeout: number;
     protected middlewareOptions?: MiddlewareFactoryOptions;
@@ -29,13 +29,22 @@ export declare abstract class BaseProvider implements AIProvider {
         traceId: string;
         parentSpanId: string;
     } | null): void;
-    private readonly messageBuilder;
-    private readonly streamHandler;
-    private readonly generationHandler;
-    protected readonly telemetryHandler: TelemetryHandler;
-    private readonly utilities;
+    private messageBuilder;
+    private streamHandler;
+    private generationHandler;
+    protected telemetryHandler: TelemetryHandler;
+    private utilities;
     private readonly toolsManager;
     constructor(modelName?: string, providerName?: AIProviderName, neurolink?: NeuroLink, middleware?: MiddlewareFactoryOptions);
+    /**
+     * Update modelName and rebuild composition handlers with the new value.
+     *
+     * Auto-discovery providers (lm-studio, llamacpp) call this once they have
+     * resolved the loaded model from `/v1/models`. Without this, handlers
+     * (TelemetryHandler, MessageBuilder, ...) keep the pre-discovery name and
+     * pricing / span / log metadata reports the stale value.
+     */
+    protected refreshHandlersForModel(model: string): void;
     /**
      * Check if this provider supports tool/function calling
      * Override in subclasses to disable tools for specific providers or models

package/dist/lib/core/baseProvider.js

@@ -23,6 +23,10 @@ import { Utilities } from "./modules/Utilities.js";
  * Tools are integrated as first-class citizens - always available by default
  */
 export class BaseProvider {
+    // Not `readonly` because providers that auto-discover the model from a
+    // /v1/models endpoint (lm-studio, llamacpp) need to update modelName after
+    // construction so handlers (TelemetryHandler, MessageBuilder) cache the
+    // resolved name. All other providers treat this as effectively readonly.
     modelName;
     providerName;
     defaultTimeout = 30000; // 30 seconds
@@ -43,6 +47,11 @@ export class BaseProvider {
         this._traceContext = ctx;
     }
     // Composition modules - Single Responsibility Principle
+    // Handlers below are not `readonly` so that providers which auto-discover
+    // their model after construction (lm-studio, llamacpp) can rebuild them
+    // via `refreshHandlersForModel(...)` and propagate the resolved name into
+    // pricing / telemetry / span attributes. All other providers leave these
+    // alone.
     messageBuilder;
     streamHandler;
     generationHandler;
@@ -67,6 +76,25 @@ export class BaseProvider {
             fixSchemaForOpenAIStrictMode: (schema) => this.fixSchemaForOpenAIStrictMode(schema),
         });
     }
+    /**
+     * Update modelName and rebuild composition handlers with the new value.
+     *
+     * Auto-discovery providers (lm-studio, llamacpp) call this once they have
+     * resolved the loaded model from `/v1/models`. Without this, handlers
+     * (TelemetryHandler, MessageBuilder, ...) keep the pre-discovery name and
+     * pricing / span / log metadata reports the stale value.
+     */
+    refreshHandlersForModel(model) {
+        this.modelName = model;
+        trace
+            .getSpan(context.active())
+            ?.setAttribute(ATTR.GEN_AI_MODEL, this.modelName);
+        this.messageBuilder = new MessageBuilder(this.providerName, this.modelName);
+        this.streamHandler = new StreamHandler(this.providerName, this.modelName);
+        this.telemetryHandler = new TelemetryHandler(this.providerName, this.modelName, this.neurolink);
+        this.generationHandler = new GenerationHandler(this.providerName, this.modelName, () => this.supportsTools(), (options, type) => this.telemetryHandler.getTelemetryConfig(options, type), (toolCalls, toolResults, options, timestamp) => this.handleToolExecutionStorage(toolCalls, toolResults, options, timestamp), () => this.neurolink?.getEventEmitter());
+        this.utilities = new Utilities(this.providerName, this.modelName, this.defaultTimeout, this.middlewareOptions);
+    }
     /**
      * Check if this provider supports tool/function calling
      * Override in subclasses to disable tools for specific providers or models

package/dist/lib/factories/providerRegistry.js

@@ -1,6 +1,6 @@
 import { ProviderFactory } from "./providerFactory.js";
 import { logger } from "../utils/logger.js";
-import { AIProviderName, GoogleAIModels, OpenAIModels, AnthropicModels, VertexModels, MistralModels, OllamaModels, LiteLLMModels, HuggingFaceModels, } from "../constants/enums.js";
+import { AIProviderName, GoogleAIModels, OpenAIModels, AnthropicModels, VertexModels, MistralModels, OllamaModels, LiteLLMModels, HuggingFaceModels, DeepSeekModels, NvidiaNimModels, } from "../constants/enums.js";
 /**
  * Provider Registry - registers all providers with the factory
  * This is where we migrate providers one by one to the new pattern
@@ -128,6 +128,30 @@ export class ProviderRegistry {
                 const { AmazonSageMakerProvider } = await import("../providers/amazonSagemaker.js");
                 return new AmazonSageMakerProvider(modelName, undefined, region, undefined, sagemakerCreds);
             }, process.env.SAGEMAKER_MODEL || "sagemaker-model", ["sagemaker", "aws-sagemaker"]);
+            // Register DeepSeek provider
+            ProviderFactory.registerProvider(AIProviderName.DEEPSEEK, async (modelName, _providerName, sdk, _region, credentials) => {
+                const deepseekCreds = credentials;
+                const { DeepSeekProvider } = await import("../providers/deepseek.js");
+                return new DeepSeekProvider(modelName, sdk, undefined, deepseekCreds);
+            }, process.env.DEEPSEEK_MODEL || DeepSeekModels.DEEPSEEK_CHAT, ["deepseek", "ds"]);
+            // Register NVIDIA NIM provider
+            ProviderFactory.registerProvider(AIProviderName.NVIDIA_NIM, async (modelName, _providerName, sdk, _region, credentials) => {
+                const nimCreds = credentials;
+                const { NvidiaNimProvider } = await import("../providers/nvidiaNim.js");
+                return new NvidiaNimProvider(modelName, sdk, undefined, nimCreds);
+            }, process.env.NVIDIA_NIM_MODEL || NvidiaNimModels.LLAMA_3_3_70B_INSTRUCT, ["nvidia", "nim", "nvidia-nim"]);
+            // Register LM Studio provider (local)
+            ProviderFactory.registerProvider(AIProviderName.LM_STUDIO, async (modelName, _providerName, sdk, _region, credentials) => {
+                const lmStudioCreds = credentials;
+                const { LMStudioProvider } = await import("../providers/lmStudio.js");
+                return new LMStudioProvider(modelName, sdk, undefined, lmStudioCreds);
+            }, process.env.LM_STUDIO_MODEL || undefined, ["lmstudio", "lm-studio", "lms"]);
+            // Register llama.cpp provider (local)
+            ProviderFactory.registerProvider(AIProviderName.LLAMACPP, async (modelName, _providerName, sdk, _region, credentials) => {
+                const llamaCppCreds = credentials;
+                const { LlamaCppProvider } = await import("../providers/llamaCpp.js");
+                return new LlamaCppProvider(modelName, sdk, undefined, llamaCppCreds);
+            }, process.env.LLAMACPP_MODEL || undefined, ["llamacpp", "llama.cpp", "llama-cpp"]);
             logger.debug("All providers registered successfully");
             this.registered = true;
             // ===== TTS HANDLER REGISTRATION =====

package/dist/lib/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/lib/providers/deepseek.js

@@ -0,0 +1,216 @@
+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;
+//# sourceMappingURL=deepseek.js.map

package/dist/lib/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/lib/providers/index.js

@@ -14,4 +14,8 @@ 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";
 //# sourceMappingURL=index.js.map