@juspay/neurolink 9.68.8 → 9.68.10

package/dist/lib/providers/lmStudio.js

@@ -1,19 +1,8 @@
-import { createOpenAI } from "@ai-sdk/openai";
-import { BaseProvider } from "../core/baseProvider.js";
-import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
-import { isNeuroLink } from "../neurolink.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
-import { createLoggingFetch } from "../utils/loggingFetch.js";
-import { tracers, ATTR, withClientStreamSpan } from "../telemetry/index.js";
 import { InvalidModelError, NetworkError, ProviderError, } from "../types/index.js";
 import { logger } from "../utils/logger.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";
-import { stepCountIs } from "../utils/tool.js";
-import { streamText } from "../utils/generation.js";
+import { TimeoutError } from "../utils/timeout.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 const LM_STUDIO_DEFAULT_BASE_URL = "http://localhost:1234/v1";
 const LM_STUDIO_PLACEHOLDER_KEY = "lm-studio";
 const FALLBACK_MODEL = "local-model";
@@ -21,200 +10,42 @@ const getLmStudioBaseURL = () => {
     return process.env.LM_STUDIO_BASE_URL || LM_STUDIO_DEFAULT_BASE_URL;
 };
 /**
- * LM Studio Provider
+ * LM Studio Provider — direct HTTP, no AI SDK.
+ *
  * Wraps the LM Studio local server (https://lmstudio.ai/) which exposes an
  * OpenAI-compatible API at http://localhost:1234/v1 by default.
- * Auto-discovers the loaded model via /v1/models if no model specified.
+ * Auto-discovers the loaded model via /v1/models if no model is specified.
+ * All request/stream/tool-loop orchestration lives in
+ * `OpenAIChatCompletionsProvider`; this class only declares configuration
+ * and provider-specific error mapping.
+ *
+ * @see https://lmstudio.ai/
  */
-export class LMStudioProvider extends BaseProvider {
-    model;
-    // The model name passed by the caller — never overwritten by auto-discovery,
-    // so a discovery-miss FALLBACK_MODEL never poisons the next call's branch
-    // through `if (explicit && explicit.trim() !== "")`.
-    requestedModelName;
-    baseURL;
-    apiKey;
-    discoveredModel;
-    lmstudioClient;
+export class LMStudioProvider extends OpenAIChatCompletionsProvider {
     constructor(modelName, sdk, _region, credentials) {
-        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
-        super(modelName, "lm-studio", validatedNeurolink);
-        this.requestedModelName = modelName;
-        this.baseURL = credentials?.baseURL ?? getLmStudioBaseURL();
-        // LM Studio's local server doesn't authenticate, but the AI SDK's
-        // createOpenAI() requires an apiKey. Allow override via credentials/env
-        // for users who run LM Studio behind an auth-proxying reverse-proxy.
-        this.apiKey =
-            credentials?.apiKey ??
-                process.env.LM_STUDIO_API_KEY ??
-                LM_STUDIO_PLACEHOLDER_KEY;
-        this.lmstudioClient = createOpenAI({
-            baseURL: this.baseURL,
-            apiKey: this.apiKey,
-            fetch: createLoggingFetch("lm-studio"),
-        });
+        // LM Studio's local server doesn't authenticate, but the base HTTP client
+        // requires an apiKey. Allow override via credentials/env for users who
+        // run LM Studio behind an auth-proxying reverse-proxy.
+        const apiKey = credentials?.apiKey ??
+            process.env.LM_STUDIO_API_KEY ??
+            LM_STUDIO_PLACEHOLDER_KEY;
+        const baseURL = credentials?.baseURL ?? getLmStudioBaseURL();
+        super("lm-studio", modelName, sdk, { baseURL, apiKey });
         logger.debug("LM Studio Provider initialized", {
             modelName: this.modelName,
             providerName: this.providerName,
-            baseURL: this.baseURL,
+            baseURL: this.config.baseURL,
         });
     }
-    async getAvailableModels(callerSignal) {
-        const url = `${this.baseURL.replace(/\/$/, "")}/models`;
-        // Use the proxy-aware fetch + bearer auth header so users running LM
-        // Studio behind an auth-proxying reverse-proxy can still discover models.
-        // Compose the caller's request signal (per-request timeout / abort) with
-        // a fixed 5s discovery cap so cancellation propagates AND a hung server
-        // can't stall provider initialization.
-        const proxyFetch = createProxyFetch();
-        const discoveryTimeout = AbortSignal.timeout(5000);
-        const composedSignal = callerSignal
-            ? AbortSignal.any([callerSignal, discoveryTimeout])
-            : discoveryTimeout;
-        const response = await proxyFetch(url, {
-            headers: this.apiKey && this.apiKey !== LM_STUDIO_PLACEHOLDER_KEY
-                ? { Authorization: `Bearer ${this.apiKey}` }
-                : undefined,
-            signal: composedSignal,
-        });
-        if (!response.ok) {
-            throw new Error(`LM Studio /v1/models returned ${response.status}: ${response.statusText}`);
-        }
-        const data = (await response.json());
-        return data.data.map((m) => m.id);
-    }
-    async getAISDKModel(signal) {
-        if (this.model) {
-            return this.model;
-        }
-        let modelToUse;
-        let discoverySucceeded = false;
-        // Use requestedModelName, not this.modelName — refreshHandlersForModel()
-        // mutates this.modelName, so on a retry after a discovery miss the
-        // FALLBACK_MODEL would look like an explicit user choice and we'd never
-        // re-attempt /v1/models. The constructor-captured name preserves intent.
-        const explicit = this.requestedModelName;
-        if (explicit && explicit.trim() !== "") {
-            modelToUse = explicit;
-            discoverySucceeded = true; // explicit user choice — treat as success
-        }
-        else {
-            try {
-                const models = await this.getAvailableModels(signal);
-                if (models.length > 0) {
-                    this.discoveredModel = models[0];
-                    modelToUse = this.discoveredModel;
-                    discoverySucceeded = true;
-                    logger.info(`LM Studio auto-discovered model: ${modelToUse} (${models.length} loaded)`);
-                }
-                else {
-                    modelToUse = FALLBACK_MODEL;
-                    logger.warn("LM Studio /v1/models returned no models. Load a model in the LM Studio app.");
-                }
-            }
-            catch (error) {
-                logger.warn(`LM Studio model auto-discovery failed: ${error instanceof Error ? error.message : String(error)}`);
-                modelToUse = FALLBACK_MODEL;
-            }
-        }
-        // Persist resolved model on the instance and rebuild the composed
-        // handlers (TelemetryHandler, MessageBuilder, etc.) so pricing /
-        // telemetry / span attributes report the discovered model name. Plain
-        // assignment to `this.modelName` is not enough — handlers cached the
-        // pre-discovery value at construction time.
-        this.refreshHandlersForModel(modelToUse);
-        // .chat() — LM Studio exposes /v1/chat/completions, not /v1/responses
-        const resolvedModel = this.lmstudioClient.chat(modelToUse);
-        // Only memoize on actual success. After a discovery miss (server down,
-        // empty /v1/models, /models 5xx), starting LM Studio or loading a model
-        // should let the next call re-attempt discovery instead of being stuck
-        // on FALLBACK_MODEL for the lifetime of this provider instance.
-        if (discoverySucceeded) {
-            this.model = resolvedModel;
-        }
-        return resolvedModel;
-    }
-    async executeStream(options, _analysisSchema) {
-        // Resolve the LM Studio model BEFORE opening the span so OTEL
-        // attributes, MessageBuilder, and downstream image/tool adapters all see
-        // the discovered model id rather than the empty pre-discovery placeholder.
-        // Pass the caller's abort signal so user cancellation / per-request
-        // timeouts are honored during the discovery probe (not just after it).
-        await this.getAISDKModel(options.abortSignal);
-        return withClientStreamSpan({
-            name: "neurolink.provider.stream",
-            tracer: tracers.provider,
-            attributes: {
-                [ATTR.GEN_AI_SYSTEM]: "lm-studio",
-                [ATTR.GEN_AI_MODEL]: this.modelName || this.discoveredModel || FALLBACK_MODEL,
-                [ATTR.GEN_AI_OPERATION]: "stream",
-                [ATTR.NL_STREAM_MODE]: true,
-            },
-        }, async () => this.executeStreamInner(options), (r) => r.stream, (r, wrapped) => ({ ...r, stream: wrapped }));
-    }
-    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())
-                : {};
-            // Resolve the AI SDK model BEFORE building messages so message/image
-            // adapters see the same handlers/model that streamText will use. Without
-            // this, a fallback warm-up + late-server-start pattern could build
-            // messages under FALLBACK_MODEL handlers and stream under a different
-            // discovered model — and pay an extra `/v1/models` probe each time.
-            const model = await this.getAISDKModelWithMiddleware(options);
-            const messages = await this.buildMessagesForStream(options);
-            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),
-                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("[LMStudioProvider] 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 || this.discoveredModel || FALLBACK_MODEL, toAnalyticsStreamResult(result), Date.now() - startTime, {
-                requestId: `lmstudio-stream-${Date.now()}`,
-                streamingMode: true,
-            });
-            return {
-                stream: transformedStream,
-                provider: this.providerName,
-                model: this.modelName || this.discoveredModel || FALLBACK_MODEL,
-                analytics: analyticsPromise,
-                metadata: { startTime, streamId: `lmstudio-${Date.now()}` },
-            };
-        }
-        catch (error) {
-            timeoutController?.cleanup();
-            throw this.handleProviderError(error);
-        }
-    }
     getProviderName() {
-        return this.providerName;
+        return "lm-studio";
     }
     getDefaultModel() {
         return process.env.LM_STUDIO_MODEL || "";
     }
+    getFallbackModelName() {
+        return FALLBACK_MODEL;
+    }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {
             return new NetworkError(`Request timed out: ${error.message}`, "lm-studio");
@@ -229,7 +60,7 @@ export class LMStudioProvider extends BaseProvider {
             message.includes("ECONNREFUSED") ||
             message.includes("Failed to fetch") ||
             message.includes("fetch failed")) {
-            return new NetworkError(`LM Studio server not reachable at ${this.baseURL}. ` +
+            return new NetworkError(`LM Studio server not reachable at ${this.config.baseURL}. ` +
                 `Open the LM Studio app, load a model, and click "Start Server".`, "lm-studio");
         }
         if (message.includes("model_not_found") || message.includes("404")) {
@@ -239,11 +70,11 @@ export class LMStudioProvider extends BaseProvider {
     }
     async validateConfiguration() {
         try {
-            const url = `${this.baseURL.replace(/\/$/, "")}/models`;
+            const url = `${this.config.baseURL.replace(/\/$/, "")}/models`;
             const proxyFetch = createProxyFetch();
             const r = await proxyFetch(url, {
-                headers: this.apiKey && this.apiKey !== LM_STUDIO_PLACEHOLDER_KEY
-                    ? { Authorization: `Bearer ${this.apiKey}` }
+                headers: this.config.apiKey && this.config.apiKey !== LM_STUDIO_PLACEHOLDER_KEY
+                    ? { Authorization: `Bearer ${this.config.apiKey}` }
                     : undefined,
                 signal: AbortSignal.timeout(5000),
             });
@@ -251,7 +82,7 @@ export class LMStudioProvider extends BaseProvider {
                 return false;
             }
             // A 200 with an empty data array means LM Studio is up but no model is
-            // loaded — `getAISDKModel()` will fall back to FALLBACK_MODEL and the
+            // loaded — `resolveModelName()` will fall back to FALLBACK_MODEL and the
             // first real request will fail. Require at least one loaded model so
             // health checks honestly reflect whether the provider is usable.
             const data = (await r.json().catch(() => null));
@@ -264,11 +95,10 @@ export class LMStudioProvider extends BaseProvider {
     getConfiguration() {
         return {
             provider: this.providerName,
-            model: this.modelName || this.discoveredModel || FALLBACK_MODEL,
+            model: this.modelName || this.resolvedModel || FALLBACK_MODEL,
             defaultModel: this.getDefaultModel(),
-            baseURL: this.baseURL,
+            baseURL: this.config.baseURL,
         };
     }
 }
-export default LMStudioProvider;
 //# sourceMappingURL=lmStudio.js.map

package/dist/providers/huggingFace.d.ts

@@ -1,79 +1,31 @@
-import type { ZodType } from "zod";
 import type { AIProviderName } from "../constants/enums.js";
-import { BaseProvider } from "../core/baseProvider.js";
-import type { NeurolinkCredentials, StreamOptions, StreamResult } from "../types/index.js";
-import type { LanguageModel, Schema } from "../types/index.js";
+import type { NeurolinkCredentials } from "../types/index.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 /**
- * HuggingFace Provider - BaseProvider Implementation
- * Using AI SDK with HuggingFace's OpenAI-compatible endpoint
+ * HuggingFace Provider — direct HTTP, no AI SDK.
+ *
+ * OpenAI-compatible chat completions at router.huggingface.co/v1 (unified
+ * router endpoint, 2025). Supports the full HuggingFace model hub including
+ * Llama 3.x, Qwen 2.5, Mistral, DeepSeek, and tool-calling capable variants.
+ * All request/stream/tool-loop orchestration lives in
+ * `OpenAIChatCompletionsProvider`; this class only declares configuration
+ * and provider-specific error mapping.
+ *
+ * @see https://huggingface.co/docs/api-inference/index
  */
-export declare class HuggingFaceProvider extends BaseProvider {
-    private model;
-    constructor(modelName?: string, _sdk?: unknown, credentials?: NeurolinkCredentials["huggingFace"]);
+export declare class HuggingFaceProvider extends OpenAIChatCompletionsProvider {
+    constructor(modelName?: string, sdk?: unknown, credentials?: NeurolinkCredentials["huggingFace"]);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    protected getFallbackModelName(): string;
     /**
-     * HuggingFace Tool Calling Support (Enhanced 2025)
-     *
-     * **Supported Models (Tool Calling Enabled):**
-     * - meta-llama/Llama-3.1-8B-Instruct - Post-trained for tool calling
-     * - meta-llama/Llama-3.1-70B-Instruct - Advanced tool calling capabilities
-     * - meta-llama/Llama-3.1-405B-Instruct - Full tool calling support
-     * - nvidia/Llama-3.1-Nemotron-Ultra-253B-v1 - Optimized for tool calling
-     * - NousResearch/Hermes-3-Llama-3.2-3B - Function calling trained
-     * - codellama/CodeLlama-34b-Instruct-hf - Code-focused tool calling
-     * - mistralai/Mistral-7B-Instruct-v0.3 - Basic tool support
-     *
-     * **Unsupported Models (Tool Calling Disabled):**
-     * - microsoft/DialoGPT-* - Treats tools as conversation context
-     * - gpt2, bert, roberta variants - No tool calling training
-     * - Most pre-2024 models - Limited function calling capabilities
-     *
-     * **Implementation Details:**
-     * - Intelligent model detection based on known capabilities
-     * - Custom tool schema formatting for HuggingFace models
-     * - Enhanced response parsing for function call extraction
-     * - Graceful fallback for unsupported models
-     *
-     * @returns true for supported models, false for unsupported models
+     * HuggingFace serves a huge variety of models, many of which reject the
+     * OpenAI `tools` field. The base reports supportsTools() === true
+     * unconditionally, which would merge tools into requests for models
+     * (including the default DialoGPT-medium) that don't accept them. Preserve
+     * the pre-migration allowlist: only known tool-calling-capable model
+     * families opt in; everything else runs tool-free.
      */
     supportsTools(): boolean;
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType | Schema<unknown>): Promise<StreamResult>;
-    /**
-     * Prepare stream options with HuggingFace-specific enhancements
-     * Handles tool calling optimizations and model-specific formatting
-     */
-    private prepareStreamOptions;
-    /**
-     * Enhance system prompt with tool calling instructions for HuggingFace models
-     * Many HF models benefit from explicit tool calling guidance
-     */
-    private enhanceSystemPromptForTools;
-    /**
-     * Format tools for HuggingFace model compatibility
-     * Some models require specific tool schema formatting
-     */
-    private formatToolsForHuggingFace;
-    /**
-     * Get recommendations for tool-calling capable HuggingFace models
-     * Provides guidance for users who want to use function calling
-     */
-    static getToolCallingRecommendations(): {
-        recommended: string[];
-        performance: Record<string, {
-            speed: number;
-            quality: number;
-            cost: number;
-        }>;
-        notes: Record<string, string>;
-    };
-    /**
-     * Enhanced error handling with HuggingFace-specific guidance
-     */
-    formatProviderError(error: unknown): Error;
-    getProviderName(): AIProviderName;
-    getDefaultModel(): string;
-    /**
-     * Returns the Vercel AI SDK model instance for HuggingFace
-     */
-    getAISDKModel(): LanguageModel;
+    protected formatProviderError(error: unknown): Error;
 }
-export default HuggingFaceProvider;