@juspay/neurolink 9.68.0 → 9.68.2

package/dist/lib/providers/xai.js

@@ -1,135 +1,59 @@
-import { createOpenAI } from "@ai-sdk/openai";
 import { XaiModels } 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 { isNeuroLink } from "../neurolink.js";
-import { createLoggingFetch } from "../utils/loggingFetch.js";
-import { tracers, ATTR, withClientStreamSpan } from "../telemetry/index.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
 import { logger } from "../utils/logger.js";
 import { createXaiConfig, 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";
-import { stepCountIs } from "../utils/tool.js";
-import { streamText } from "../utils/generation.js";
-/**
- * Logging fetch wrapper — masks the proxy URL on non-2xx responses so
- * stack traces and log lines don't leak the upstream's internal token /
- * tenant id (mirrors the deepseek/groq/etc. providers).
- */
+import { TimeoutError } from "../utils/timeout.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 const XAI_DEFAULT_BASE_URL = "https://api.x.ai/v1";
 const getXaiApiKey = () => validateApiKey(createXaiConfig());
 const getDefaultXaiModel = () => getProviderModel("XAI_MODEL", XaiModels.GROK_3);
 /**
- * xAI Grok Provider
+ * xAI Grok Provider — direct HTTP, no AI SDK.
  *
- * OpenAI-compatible chat completions at api.x.ai/v1. Supports the Grok
- * family: grok-2, grok-3, grok-3-mini, grok-2-vision-latest (multimodal),
- * and grok-beta. Streaming and tool calling supported.
+ * OpenAI-compatible chat completions at api.x.ai/v1 (Grok family:
+ * grok-3, grok-3-mini, grok-2-latest, grok-2-vision-latest, grok-beta).
+ * All request/stream/tool-loop orchestration lives in
+ * `OpenAIChatCompletionsProvider`; this class only declares configuration
+ * and provider-specific error mapping.
  *
  * @see https://docs.x.ai/api
  */
-export class XaiProvider extends BaseProvider {
-    model;
-    apiKey;
-    baseURL;
+export class XaiProvider extends OpenAIChatCompletionsProvider {
     constructor(modelName, sdk, _region, credentials) {
-        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
-        super(modelName, "xai", validatedNeurolink);
+        // Trim the override before applying precedence. A blank/whitespace
+        // `credentials.apiKey` must NOT bypass the env key — that would build a
+        // client with an unusable bearer token and fail at request time.
         const overrideApiKey = credentials?.apiKey?.trim();
-        this.apiKey =
-            overrideApiKey && overrideApiKey.length > 0
-                ? overrideApiKey
-                : getXaiApiKey();
-        this.baseURL =
-            credentials?.baseURL ?? process.env.XAI_BASE_URL ?? XAI_DEFAULT_BASE_URL;
-        const xai = createOpenAI({
-            apiKey: this.apiKey,
-            baseURL: this.baseURL,
-            fetch: createLoggingFetch("xai"),
-        });
-        this.model = xai.chat(this.modelName);
+        const apiKey = overrideApiKey && overrideApiKey.length > 0
+            ? overrideApiKey
+            : getXaiApiKey();
+        const baseURL = credentials?.baseURL?.trim() ||
+            process.env.XAI_BASE_URL?.trim() ||
+            XAI_DEFAULT_BASE_URL;
+        super("xai", modelName, sdk, { baseURL, apiKey });
         logger.debug("xAI Provider initialized", {
             modelName: this.modelName,
             providerName: this.providerName,
-            baseURL: this.baseURL,
+            baseURL: this.config.baseURL,
         });
     }
-    async executeStream(options, _analysisSchema) {
-        return withClientStreamSpan({
-            name: "neurolink.provider.stream",
-            tracer: tracers.provider,
-            attributes: {
-                [ATTR.GEN_AI_SYSTEM]: "xai",
-                [ATTR.GEN_AI_MODEL]: this.modelName,
-                [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())
-                : {};
-            const messages = await this.buildMessagesForStream(options);
-            const model = await this.getAISDKModelWithMiddleware(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("[XaiProvider] 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: `xai-stream-${Date.now()}`,
-                streamingMode: true,
-            });
-            return {
-                stream: transformedStream,
-                provider: this.providerName,
-                model: this.modelName,
-                analytics: analyticsPromise,
-                metadata: { startTime, streamId: `xai-${Date.now()}` },
-            };
-        }
-        catch (error) {
-            timeoutController?.cleanup();
-            throw this.handleProviderError(error);
-        }
-    }
     getProviderName() {
-        return this.providerName;
+        return "xai";
     }
     getDefaultModel() {
         return getDefaultXaiModel();
     }
-    getAISDKModel() {
-        return this.model;
+    getFallbackModelName() {
+        return XaiModels.GROK_3_MINI;
+    }
+    getFallbackModels() {
+        return [
+            XaiModels.GROK_3,
+            XaiModels.GROK_3_MINI,
+            XaiModels.GROK_2_LATEST,
+            XaiModels.GROK_2_VISION_LATEST,
+            XaiModels.GROK_BETA,
+        ];
     }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {
@@ -157,17 +81,5 @@ export class XaiProvider extends BaseProvider {
         }
         return new ProviderError(`xAI error: ${message}`, "xai");
     }
-    async validateConfiguration() {
-        return typeof this.apiKey === "string" && this.apiKey.trim().length > 0;
-    }
-    getConfiguration() {
-        return {
-            provider: this.providerName,
-            model: this.modelName,
-            defaultModel: getDefaultXaiModel(),
-            baseURL: this.baseURL,
-        };
-    }
 }
-export default XaiProvider;
 //# sourceMappingURL=xai.js.map

package/dist/lib/types/providers.d.ts

@@ -125,6 +125,7 @@ export type NeurolinkCredentials = {
         resourceName?: string;
         deploymentName?: string;
         apiVersion?: string;
+        useMaxCompletionTokens?: boolean;
     };
     mistral?: {
         apiKey?: string;

package/dist/providers/azureOpenai.d.ts

@@ -1,24 +1,61 @@
 import { type AIProviderName } from "../constants/enums.js";
-import { BaseProvider } from "../core/baseProvider.js";
-import type { StreamOptions, StreamResult, NeurolinkCredentials } from "../types/index.js";
-import type { LanguageModel } from "../types/index.js";
-export declare class AzureOpenAIProvider extends BaseProvider {
-    private apiKey;
-    private resourceName;
-    private deployment;
-    private apiVersion;
-    private azureProvider;
+import type { NeurolinkCredentials, OpenAICompatChatRequest } from "../types/index.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
+/**
+ * Azure OpenAI Provider — direct HTTP, no AI SDK.
+ *
+ * Supports both classic Azure OpenAI Service endpoints
+ * ("*.openai.azure.com", "*.cognitiveservices.azure.com") and the newer
+ * Azure AI Foundry endpoints ("*.services.ai.azure.com").
+ *
+ * All request/stream/tool-loop orchestration lives in
+ * `OpenAIChatCompletionsProvider`; this class overrides the URL builder and
+ * auth headers to accommodate Azure's deployment-based routing and
+ * `api-key` header (rather than Bearer tokens).
+ *
+ * @see https://learn.microsoft.com/azure/cognitive-services/openai/
+ */
+export declare class AzureOpenAIProvider extends OpenAIChatCompletionsProvider {
+    protected readonly azureDeployment: string;
+    protected readonly azureApiVersion: string;
+    protected readonly azureResourceOrigin: string;
+    protected readonly azureDeploymentPathPrefix: string;
+    protected readonly useMaxCompletionTokensOverride?: boolean;
     constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["azure"]);
-    getProviderName(): AIProviderName;
-    getDefaultModel(): string;
+    protected getProviderName(): AIProviderName;
     /**
-     * Returns the Vercel AI SDK model instance for Azure OpenAI.
-     * Uses .chat() explicitly because @ai-sdk/azure v3+ defaults the bare
-     * provider() call to the Responses API, which many Azure deployments
-     * do not support yet.
+     * The "default model" for Azure is the deployment name — it's the
+     * identifier callers pass to select a deployment.
      */
-    getAISDKModel(): LanguageModel;
+    protected getDefaultModel(): string;
     protected formatProviderError(error: unknown): Error;
-    protected executeStream(options: StreamOptions, _analysisSchema?: unknown): Promise<StreamResult>;
+    /**
+     * Builds the full Azure deployment chat completions URL.
+     *
+     * Pattern:
+     *   {resourceOrigin}{deploymentPathPrefix}/deployments/{deployment}/chat/completions?api-version={apiVersion}
+     *
+     * Examples:
+     *   Classic:  https://myresource.openai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2025-04-01-preview
+     *   Foundry:  https://myhost.services.ai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2025-04-01-preview
+     */
+    protected getChatCompletionsURL(modelId: string): string;
+    /**
+     * Azure uses `api-key` rather than the standard `Authorization: Bearer`
+     * header expected by OpenAI-compatible endpoints.
+     */
+    protected getAuthHeaders(): Record<string, string>;
+    /**
+     * Newer Azure deployments (o-series, gpt-5+) reject `max_tokens` and require
+     * `max_completion_tokens`. The `@ai-sdk/openai` path this migration replaced
+     * renamed the field automatically; replicate that here.
+     *
+     * Capability is taken from the explicit `useMaxCompletionTokens` override
+     * (credentials / `AZURE_OPENAI_USE_MAX_COMPLETION_TOKENS`) when set — Azure
+     * deployment names are user-defined, so a `chat-prod` gpt-5 deployment can't
+     * be detected from the name. When unset, fall back to a best-effort
+     * model-name heuristic for the common case where the deployment echoes the
+     * model (e.g. `gpt-5.4`).
+     */
+    protected adjustRequestBody(body: OpenAICompatChatRequest, modelId: string): OpenAICompatChatRequest;
 }
-export default AzureOpenAIProvider;