@juspay/neurolink 9.59.5 → 9.60.0

package/dist/providers/nvidiaNim.d.ts

@@ -0,0 +1,31 @@
+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";
+/**
+ * NVIDIA NIM Provider
+ * Wraps NVIDIA's hosted (or self-hosted) inference endpoints via OpenAI-compat.
+ * Passes NIM-specific extras (top_k, min_p, repetition_penalty,
+ * chat_template_kwargs.reasoning_budget) via providerOptions.openai.body.
+ * Implements one-retry-on-400 to drop unsupported extras gracefully.
+ */
+export declare class NvidiaNimProvider extends BaseProvider {
+    private model;
+    private apiKey;
+    private baseURL;
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["nvidiaNim"]);
+    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 NvidiaNimProvider;

package/dist/providers/nvidiaNim.js

@@ -0,0 +1,353 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { stepCountIs, streamText } from "ai";
+import { NvidiaNimModels } 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 { createNvidiaNimConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.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) {
+            // If maskProxyUrl can't safely sanitize the URL (returns null), don't
+            // log the raw URL — that defeats the redaction. Use a placeholder so
+            // operators still get the warning without leaking credentials.
+            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;
+    });
+};
+import { resolveToolChoice } from "../utils/toolChoice.js";
+import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
+const NVIDIA_NIM_DEFAULT_BASE_URL = "https://integrate.api.nvidia.com/v1";
+const envInt = (k) => {
+    const v = process.env[k];
+    if (!v) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(v, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+};
+const envFloat = (k) => {
+    const v = process.env[k];
+    if (!v) {
+        return undefined;
+    }
+    const parsed = Number.parseFloat(v);
+    return Number.isFinite(parsed) ? parsed : undefined;
+};
+const buildNvidiaNimExtraBody = (thinkingEnabled, maxTokens) => {
+    const extra = {};
+    const topK = envInt("NVIDIA_NIM_TOP_K");
+    if (topK !== undefined && topK !== -1) {
+        extra.top_k = topK;
+    }
+    const minP = envFloat("NVIDIA_NIM_MIN_P");
+    if (minP !== undefined && minP !== 0) {
+        extra.min_p = minP;
+    }
+    const repPenalty = envFloat("NVIDIA_NIM_REPETITION_PENALTY");
+    if (repPenalty !== undefined && repPenalty !== 1) {
+        extra.repetition_penalty = repPenalty;
+    }
+    const minTokens = envInt("NVIDIA_NIM_MIN_TOKENS");
+    if (minTokens !== undefined && minTokens !== 0) {
+        extra.min_tokens = minTokens;
+    }
+    const chatTemplate = process.env.NVIDIA_NIM_CHAT_TEMPLATE;
+    if (chatTemplate) {
+        extra.chat_template = chatTemplate;
+    }
+    if (thinkingEnabled) {
+        extra.chat_template_kwargs = {
+            thinking: true,
+            enable_thinking: true,
+            ...(maxTokens ? { reasoning_budget: maxTokens } : {}),
+        };
+    }
+    return extra;
+};
+const stripReasoningBudget = (body) => {
+    const cloned = { ...body };
+    if (cloned.chat_template_kwargs) {
+        const { reasoning_budget: _ignored, ...rest } = cloned.chat_template_kwargs;
+        cloned.chat_template_kwargs = rest;
+        if (Object.keys(cloned.chat_template_kwargs).length === 0) {
+            delete cloned.chat_template_kwargs;
+        }
+    }
+    return cloned;
+};
+const stripChatTemplate = (body) => {
+    const { chat_template: _ignored, ...rest } = body;
+    return rest;
+};
+const getNimApiKey = () => {
+    return validateApiKey(createNvidiaNimConfig());
+};
+const getDefaultNimModel = () => {
+    return getProviderModel("NVIDIA_NIM_MODEL", NvidiaNimModels.LLAMA_3_3_70B_INSTRUCT);
+};
+/**
+ * NVIDIA NIM Provider
+ * Wraps NVIDIA's hosted (or self-hosted) inference endpoints via OpenAI-compat.
+ * Passes NIM-specific extras (top_k, min_p, repetition_penalty,
+ * chat_template_kwargs.reasoning_budget) via providerOptions.openai.body.
+ * Implements one-retry-on-400 to drop unsupported extras gracefully.
+ */
+export class NvidiaNimProvider extends BaseProvider {
+    model;
+    apiKey;
+    baseURL;
+    constructor(modelName, sdk, _region, credentials) {
+        const validatedNeurolink = sdk && typeof sdk === "object" && "getInMemoryServers" in sdk
+            ? sdk
+            : undefined;
+        super(modelName, "nvidia-nim", validatedNeurolink);
+        // Trim the override before applying precedence. A blank/whitespace
+        // `credentials.apiKey` should NOT bypass `getNimApiKey()` — 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
+                : getNimApiKey();
+        this.baseURL =
+            credentials?.baseURL ??
+                process.env.NVIDIA_NIM_BASE_URL ??
+                NVIDIA_NIM_DEFAULT_BASE_URL;
+        const nim = createOpenAI({
+            apiKey: this.apiKey,
+            baseURL: this.baseURL,
+            fetch: makeLoggingFetch("nvidia-nim"),
+        });
+        // .chat() — NIM exposes /v1/chat/completions, not /v1/responses
+        this.model = nim.chat(this.modelName);
+        logger.debug("NVIDIA NIM 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]: "nvidia-nim",
+                [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);
+            // Callers pass `thinkingLevel` directly on generate/stream options
+            // (matching Anthropic / Gemini 2.5+ / Gemini 3 conventions). Fall back
+            // to the legacy `thinkingConfig.thinkingLevel` shape for compatibility.
+            const tl = options.thinkingLevel ??
+                options.thinkingConfig?.thinkingLevel;
+            const thinkingEnabled = tl !== undefined && tl !== "minimal";
+            let extraBody = buildNvidiaNimExtraBody(thinkingEnabled, options.maxTokens);
+            // Inline the retry-strip union — CLAUDE.md rule 2 forbids type aliases
+            // outside src/lib/types/. The two literals match the 400 error keys NIM
+            // returns for the only two extras we know how to drop and retry.
+            const callStream = (body, stripped = []) => 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),
+                providerOptions: (() => {
+                    // StreamOptions doesn't formally type providerOptions but the
+                    // upstream Vercel AI SDK accepts it. Read it via an indexed access
+                    // and merge with NIM extras instead of overwriting any per-call
+                    // openai.body.
+                    const callerBase = options
+                        .providerOptions ?? {};
+                    const callerOpenai = callerBase.openai ?? {};
+                    const callerBody = callerOpenai.body ?? {};
+                    // Per-call overrides win over env/NIM defaults — defaults first,
+                    // overrides last. chat_template_kwargs is merged shallowly too so
+                    // a request that only sets `reasoning_budget` doesn't drop the
+                    // env-driven `thinking: true` flag (and vice versa).
+                    const defaultsBody = body;
+                    const mergedBody = {
+                        ...defaultsBody,
+                        ...callerBody,
+                    };
+                    const mergedKwargs = {
+                        ...(defaultsBody.chat_template_kwargs ?? {}),
+                        ...(callerBody.chat_template_kwargs ?? {}),
+                    };
+                    // Apply retry-strip AFTER merging so caller-supplied copies of
+                    // the offending field are also dropped (otherwise the retry would
+                    // re-send the field that NIM just rejected).
+                    if (stripped.includes("chat_template")) {
+                        delete mergedBody.chat_template;
+                    }
+                    if (stripped.includes("reasoning_budget")) {
+                        delete mergedKwargs.reasoning_budget;
+                    }
+                    if (Object.keys(mergedKwargs).length > 0) {
+                        mergedBody.chat_template_kwargs = mergedKwargs;
+                    }
+                    else {
+                        delete mergedBody.chat_template_kwargs;
+                    }
+                    if (Object.keys(callerBase).length === 0 &&
+                        Object.keys(mergedBody).length === 0) {
+                        return undefined;
+                    }
+                    return {
+                        ...callerBase,
+                        openai: {
+                            ...callerOpenai,
+                            body: mergedBody,
+                        },
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    };
+                })(),
+                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("[NvidiaNimProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
+            });
+            let result;
+            try {
+                result = await callStream(extraBody);
+            }
+            catch (error) {
+                const errMsg = error instanceof Error ? error.message : String(error);
+                const status = error?.statusCode;
+                if (status === 400) {
+                    const lower = errMsg.toLowerCase();
+                    if (lower.includes("reasoning_budget")) {
+                        logger.warn("NIM rejected reasoning_budget; retrying without it");
+                        extraBody = stripReasoningBudget(extraBody);
+                        result = await callStream(extraBody, ["reasoning_budget"]);
+                    }
+                    else if (lower.includes("chat_template")) {
+                        logger.warn("NIM rejected chat_template; retrying without it");
+                        extraBody = stripChatTemplate(extraBody);
+                        result = await callStream(extraBody, ["chat_template"]);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                else {
+                    throw error;
+                }
+            }
+            timeoutController?.cleanup();
+            const transformedStream = this.createTextStream(result);
+            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, toAnalyticsStreamResult(result), Date.now() - startTime, {
+                requestId: `nvidia-nim-stream-${Date.now()}`,
+                streamingMode: true,
+            });
+            return {
+                stream: transformedStream,
+                provider: this.providerName,
+                model: this.modelName,
+                analytics: analyticsPromise,
+                metadata: { startTime, streamId: `nvidia-nim-${Date.now()}` },
+            };
+        }
+        catch (error) {
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
+        }
+    }
+    getProviderName() {
+        return this.providerName;
+    }
+    getDefaultModel() {
+        return getDefaultNimModel();
+    }
+    getAISDKModel() {
+        return this.model;
+    }
+    formatProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`NVIDIA NIM 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("401") ||
+            message.includes("Unauthorized")) {
+            return new Error("Invalid NVIDIA NIM API key. Get one at https://build.nvidia.com/settings/api-keys");
+        }
+        if (message.includes("rate limit") || message.includes("429")) {
+            return new Error("NVIDIA NIM rate limit exceeded");
+        }
+        if (message.includes("404") || message.includes("model_not_found")) {
+            return new Error(`NVIDIA NIM model '${this.modelName}' not available. Browse the catalog at https://build.nvidia.com/models`);
+        }
+        if (message.includes("quota") || message.includes("403")) {
+            return new Error("NVIDIA NIM quota exceeded for your account");
+        }
+        return new Error(`NVIDIA NIM error: ${message}`);
+    }
+    async validateConfiguration() {
+        return typeof this.apiKey === "string" && this.apiKey.trim().length > 0;
+    }
+    getConfiguration() {
+        return {
+            provider: this.providerName,
+            model: this.modelName,
+            defaultModel: getDefaultNimModel(),
+            baseURL: this.baseURL,
+        };
+    }
+}
+export default NvidiaNimProvider;

package/dist/proxy/proxyFetch.d.ts

@@ -8,6 +8,15 @@
  * Supports HTTP/HTTPS, SOCKS4/5, authentication, and NO_PROXY bypass
  */
 export declare function createProxyFetch(): typeof fetch;
+/**
+ * Mask credentials in a proxy URL for safe logging/reporting.
+ *
+ * Exported so provider-side fetch loggers (lmStudio, llamaCpp, deepseek,
+ * nvidiaNim) can sanitize upstream URLs before emitting warnings — reverse-
+ * proxied deployments can embed credentials or signed query params in the
+ * base URL, and those should never reach application logs verbatim.
+ */
+export declare function maskProxyUrl(url: string | null | undefined): string | null;
 /**
  * Get enhanced proxy status information
  */

package/dist/proxy/proxyFetch.js

@@ -614,8 +614,13 @@ export function createProxyFetch() {
 }
 /**
  * Mask credentials in a proxy URL for safe logging/reporting.
+ *
+ * Exported so provider-side fetch loggers (lmStudio, llamaCpp, deepseek,
+ * nvidiaNim) can sanitize upstream URLs before emitting warnings — reverse-
+ * proxied deployments can embed credentials or signed query params in the
+ * base URL, and those should never reach application logs verbatim.
  */
-function maskProxyUrl(url) {
+export function maskProxyUrl(url) {
     if (!url) {
         return null;
     }

package/dist/types/providers.d.ts

@@ -3,7 +3,7 @@
  */
 import type { UnknownRecord, JsonValue, StreamingCapability } from "./common.js";
 import type { ProviderError } from "./errors.js";
-import { AIProviderName, AnthropicModels, BedrockModels, GoogleAIModels, OpenAIModels, VertexModels } from "../constants/enums.js";
+import { AIProviderName, AnthropicModels, BedrockModels, DeepSeekModels, GoogleAIModels, LlamaCppModels, LMStudioModels, NvidiaNimModels, OpenAIModels, VertexModels } from "../constants/enums.js";
 import type { Tool } from "ai";
 import type { ValidationSchema } from "./aliases.js";
 import type { EnhancedGenerateResult, GenerateResult, TextGenerationOptions } from "./generate.js";
@@ -20,7 +20,7 @@ export type AISDKModel = {
 /**
  * Union type of all supported model names
  */
-export type SupportedModelName = BedrockModels | OpenAIModels | VertexModels | GoogleAIModels | AnthropicModels;
+export type SupportedModelName = BedrockModels | DeepSeekModels | OpenAIModels | VertexModels | GoogleAIModels | AnthropicModels | NvidiaNimModels | LMStudioModels | LlamaCppModels;
 /**
  * Extract provider names from enum
  */
@@ -147,6 +147,40 @@ export type NeurolinkCredentials = {
     ollama?: {
         baseURL?: string;
     };
+    deepseek?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    nvidiaNim?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    lmStudio?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    llamacpp?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+};
+/**
+ * NVIDIA NIM extra request body parameters passed via `providerOptions.openai.body`.
+ * Lives here (not in providers/nvidiaNim.ts) per CLAUDE.md rule 2.
+ */
+export type NvidiaNimExtraBody = {
+    top_k?: number;
+    min_p?: number;
+    repetition_penalty?: number;
+    min_tokens?: number;
+    chat_template?: string;
+    request_id?: string;
+    ignore_eos?: boolean;
+    chat_template_kwargs?: {
+        thinking?: boolean;
+        enable_thinking?: boolean;
+        reasoning_budget?: number;
+    };
 };
 /**
  * AWS Credential Validation Result
@@ -398,6 +432,7 @@ export type ProviderConfigOptions = {
     description: string;
     instructions: string[];
     fallbackEnvVars?: string[];
+    optional?: boolean;
 };
 /**
  * AI Provider type with flexible parameter support

package/dist/utils/modelChoices.js

@@ -2,7 +2,7 @@
  * Centralized model choices for CLI commands
  * Derives choices from model enums to ensure consistency
  */
-import { AIProviderName, OpenAIModels, AnthropicModels, GoogleAIModels, BedrockModels, VertexModels, MistralModels, OllamaModels, AzureOpenAIModels, LiteLLMModels, HuggingFaceModels, SageMakerModels, OpenRouterModels, } from "../constants/enums.js";
+import { AIProviderName, OpenAIModels, AnthropicModels, GoogleAIModels, BedrockModels, VertexModels, MistralModels, OllamaModels, AzureOpenAIModels, LiteLLMModels, HuggingFaceModels, SageMakerModels, OpenRouterModels, DeepSeekModels, NvidiaNimModels, } from "../constants/enums.js";
 /**
  * Top models per provider with descriptions for CLI prompts
  * These are curated lists of the most commonly used/recommended models
@@ -230,6 +230,47 @@ const TOP_MODELS_CONFIG = {
         { model: "gpt-4-turbo", description: "Turbo compatible model" },
         { model: "gpt-3.5-turbo", description: "Legacy compatible model" },
     ],
+    [AIProviderName.DEEPSEEK]: [
+        { model: "deepseek-chat", description: "DeepSeek-V3 general chat" },
+        {
+            model: "deepseek-reasoner",
+            description: "DeepSeek-R1 reasoning (slower, deeper)",
+        },
+    ],
+    [AIProviderName.NVIDIA_NIM]: [
+        {
+            model: "meta/llama-3.3-70b-instruct",
+            description: "Recommended - Llama 3.3 70B",
+        },
+        {
+            model: "nvidia/llama-3.3-nemotron-super-49b-v1",
+            description: "Nemotron Super (reasoning)",
+        },
+        {
+            model: "deepseek-ai/deepseek-r1",
+            description: "DeepSeek-R1 hosted on NIM",
+        },
+        {
+            model: "meta/llama-3.2-90b-vision-instruct",
+            description: "Llama 3.2 vision",
+        },
+        {
+            model: "mistralai/mixtral-8x22b-instruct-v0.1",
+            description: "Mixtral 8x22B",
+        },
+    ],
+    [AIProviderName.LM_STUDIO]: [
+        {
+            model: "",
+            description: "Auto-discover loaded model from /v1/models",
+        },
+    ],
+    [AIProviderName.LLAMACPP]: [
+        {
+            model: "",
+            description: "Use whatever model llama-server has loaded",
+        },
+    ],
     [AIProviderName.AUTO]: [],
 };
 /**
@@ -249,6 +290,12 @@ export const DEFAULT_MODELS = {
     [AIProviderName.SAGEMAKER]: SageMakerModels.LLAMA_4_MAVERICK_17B_128E,
     [AIProviderName.OPENROUTER]: OpenRouterModels.CLAUDE_3_5_SONNET,
     [AIProviderName.OPENAI_COMPATIBLE]: "gpt-4o",
+    [AIProviderName.DEEPSEEK]: DeepSeekModels.DEEPSEEK_CHAT,
+    [AIProviderName.NVIDIA_NIM]: NvidiaNimModels.LLAMA_3_3_70B_INSTRUCT,
+    // LM Studio + llama.cpp auto-discover their loaded model from /v1/models;
+    // an empty default is the documented signal to use that path.
+    [AIProviderName.LM_STUDIO]: "",
+    [AIProviderName.LLAMACPP]: "",
 };
 /**
  * Model enum mappings for getAllModels
@@ -267,6 +314,10 @@ const MODEL_ENUMS = {
     [AIProviderName.SAGEMAKER]: SageMakerModels,
     [AIProviderName.OPENROUTER]: OpenRouterModels,
     [AIProviderName.OPENAI_COMPATIBLE]: null,
+    [AIProviderName.DEEPSEEK]: DeepSeekModels,
+    [AIProviderName.NVIDIA_NIM]: NvidiaNimModels,
+    [AIProviderName.LM_STUDIO]: null,
+    [AIProviderName.LLAMACPP]: null,
     [AIProviderName.AUTO]: null,
 };
 /**
@@ -283,7 +334,14 @@ export function getTopModelChoices(provider, limit = 5) {
         return [];
     }
     const choices = config.slice(0, limit).map((item) => ({
-        name: `${item.model} (${item.description})`,
+        // Empty-string entries are auto-discovery sentinels for LM Studio /
+        // llama.cpp. Surface them with a friendly label so the CLI doesn't show a
+        // blank row, but keep `value: ""` so it matches `DEFAULT_MODELS` (which
+        // also uses `""`) and any caller that preselects the active choice via
+        // the default model still resolves to this entry.
+        name: item.model.length > 0
+            ? `${item.model} (${item.description})`
+            : `Auto-discover loaded model (${item.description})`,
         value: item.model,
         description: item.description,
     }));
@@ -387,8 +445,14 @@ export function getPopularModelsAcrossProviders() {
     const popularModels = [];
     for (const [provider, config] of Object.entries(TOP_MODELS_CONFIG)) {
         if (config && config.length > 0) {
-            // Take top 2 from each provider
-            config.slice(0, 2).forEach((item) => {
+            // Take top 2 from each provider, ignoring blank auto-discovery sentinels.
+            // (Auto-discovery is surfaced separately by `getTopModelChoices` for
+            // LM Studio / llama.cpp; we don't want it to appear in the cross-
+            // provider popular-models list as an empty value.)
+            config
+                .filter((item) => item.model.length > 0)
+                .slice(0, 2)
+                .forEach((item) => {
                 popularModels.push({
                     provider: provider,
                     model: item.model,

package/dist/utils/pricing.d.ts

@@ -8,5 +8,10 @@ export declare function calculateCost(provider: string, model: string, usage: To
  * 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 declare function hasPricing(provider: string, model: string): boolean;