@juspay/neurolink 9.67.3 → 9.68.1

package/dist/lib/providers/openaiChatCompletionsBase.js

@@ -28,7 +28,7 @@ import { composeAbortSignals, createTimeoutController, mergeAbortSignals, } from
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { transformToolExecutions } from "../utils/transformationUtils.js";
-import { buildAPIError, buildBody, buildToolsForOpenAI, createChunkQueue, createDeferredAnalytics, mapNeuroLinkToolChoice, mergeUsage, messageBuilderToOpenAI, parseSSEStream, stringifyToolOutput, stripTrailingSlash, v3ResponseFormatToOpenAI, v3ToolChoiceToOpenAI, v3ToolsToOpenAI, } from "./openaiChatCompletionsClient.js";
+import { buildAPIError, buildBody, buildToolsForOpenAI, createChunkQueue, createDeferredAnalytics, ensureJsonWordInBody, mapNeuroLinkToolChoice, mergeUsage, messageBuilderToOpenAI, parseSSEStream, stringifyToolOutput, stripTrailingSlash, v3ResponseFormatToOpenAI, v3ToolChoiceToOpenAI, v3ToolsToOpenAI, } from "./openaiChatCompletionsClient.js";
 /**
  * Abstract HTTP+SSE provider for OpenAI chat-completions-shaped endpoints.
  */
@@ -64,6 +64,28 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
     adjustBuildBodyOptions(_modelId, opts) {
         return opts;
     }
+    /**
+     * Hook to adjust the OpenAI `response_format` after it's converted from the
+     * V3 responseFormat (non-streaming `doGenerate` path). Default identity.
+     * Override for providers that don't support a given format type — e.g.
+     * DeepSeek rejects `response_format: { type: "json_schema" }` ("This
+     * response_format type is unavailable now"); the `@ai-sdk/openai-compatible`
+     * path this replaced declared `supportsStructuredOutputs: false`, which
+     * downgraded `json_schema` to `json_object`. Subclasses replicate that here.
+     */
+    adjustResponseFormat(rf, _modelId) {
+        return rf;
+    }
+    /**
+     * Hook to adjust the fully-built wire request body before it is sent, on
+     * both the streaming and non-streaming paths. Default identity. Override for
+     * provider/model quirks that can't be expressed through buildBody options —
+     * e.g. Azure's newer reasoning deployments (o-series, gpt-5+) reject
+     * `max_tokens` and require `max_completion_tokens`.
+     */
+    adjustRequestBody(body, _modelId) {
+        return body;
+    }
     /**
      * Hook called once at the start of every `executeStream` invocation.
      * Return lifecycle listeners (onUsage / onFinish) to receive deferred
@@ -82,6 +104,22 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
     shouldAutoDiscoverModel() {
         return true;
     }
+    /**
+     * Builds the chat-completions request URL for a model. Default is
+     * `${baseURL}/chat/completions`. Override for providers with a different
+     * routing scheme (e.g. Azure's deployment-based path + api-version query).
+     */
+    getChatCompletionsURL(_modelId) {
+        return `${stripTrailingSlash(this.config.baseURL)}/chat/completions`;
+    }
+    /**
+     * Auth headers merged into every request. Default is a Bearer token.
+     * Override for providers that authenticate differently (e.g. Azure, which
+     * uses an `api-key` header instead of `Authorization: Bearer`).
+     */
+    getAuthHeaders() {
+        return { Authorization: `Bearer ${this.config.apiKey}` };
+    }
     // ===========================================================================
     // Public/protected concrete methods (shared by all subclasses)
     // ===========================================================================
@@ -129,11 +167,13 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         return fallback;
     }
     buildDelegatingModel(modelId) {
-        const url = `${stripTrailingSlash(this.config.baseURL)}/chat/completions`;
+        const url = this.getChatCompletionsURL(modelId);
         const fetchImpl = createProxyFetch();
-        const apiKey = this.config.apiKey;
+        const getAuthHeaders = this.getAuthHeaders.bind(this);
         const providerName = this.providerName;
         const adjustBuildBodyOptions = this.adjustBuildBodyOptions.bind(this);
+        const adjustResponseFormat = this.adjustResponseFormat.bind(this);
+        const adjustRequestBody = this.adjustRequestBody.bind(this);
         const getTimeoutForOptions = (opts) => this.getTimeout((opts ?? {}));
         return {
             specificationVersion: "v3",
@@ -141,10 +181,17 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             modelId,
             supportedUrls: {},
             doGenerate: async (options) => {
-                const messages = messageBuilderToOpenAI(options.prompt);
-                const body = buildBody({
+                const baseMessages = messageBuilderToOpenAI(options.prompt);
+                const responseFormat = options.responseFormat
+                    ? adjustResponseFormat(v3ResponseFormatToOpenAI(options.responseFormat), modelId)
+                    : undefined;
+                // ensureJsonWordInBody runs LAST — on the body after adjustRequestBody —
+                // so the json_object word guard reflects whatever a subclass left on
+                // the wire (it may rewrite response_format/messages), not an
+                // intermediate state.
+                const body = ensureJsonWordInBody(adjustRequestBody(buildBody({
                     modelId,
-                    messages,
+                    messages: baseMessages,
                     options: adjustBuildBodyOptions(modelId, {
                         maxTokens: options.maxOutputTokens,
                         temperature: options.temperature,
@@ -159,12 +206,8 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                         ? { toolChoice: v3ToolChoiceToOpenAI(options.toolChoice) }
                         : {}),
                     streaming: false,
-                    ...(options.responseFormat
-                        ? {
-                            responseFormat: v3ResponseFormatToOpenAI(options.responseFormat),
-                        }
-                        : {}),
-                });
+                    ...(responseFormat ? { responseFormat } : {}),
+                }), modelId));
                 const timeoutController = createTimeoutController(getTimeoutForOptions(options), providerName, "generate");
                 const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
                 let res;
@@ -173,7 +216,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                         method: "POST",
                         headers: {
                             "Content-Type": "application/json",
-                            Authorization: `Bearer ${apiKey}`,
+                            ...getAuthHeaders(),
                         },
                         body: JSON.stringify(body),
                         ...(composedSignal ? { signal: composedSignal } : {}),
@@ -282,7 +325,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             timeoutController?.cleanup();
             throw setupErr;
         }
-        const url = `${stripTrailingSlash(this.config.baseURL)}/chat/completions`;
+        const url = this.getChatCompletionsURL(modelId);
         const fetchImpl = createProxyFetch();
         const maxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
         const emitter = this.neurolink?.getEventEmitter();
@@ -296,7 +339,6 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             maxSteps,
             modelId,
             url,
-            apiKey: this.config.apiKey,
             fetchImpl,
             abortSignal,
             options,
@@ -424,7 +466,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         return result;
     }
     async runStreamLoop(args) {
-        const { maxSteps, modelId, url, apiKey, fetchImpl, abortSignal, options, conversation, openAITools, openAIToolChoice, toolsRecord, emitter, toolsUsed, toolExecutionSummaries, pushChunk, resolveUsage, resolveFinish, } = args;
+        const { maxSteps, modelId, url, fetchImpl, abortSignal, options, conversation, openAITools, openAIToolChoice, toolsRecord, emitter, toolsUsed, toolExecutionSummaries, pushChunk, resolveUsage, resolveFinish, } = args;
         try {
             let stepFinish = null;
             let stepUsage;
@@ -432,7 +474,6 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 const stepResult = await this.streamOneStep({
                     modelId,
                     url,
-                    apiKey,
                     fetchImpl,
                     abortSignal,
                     options,
@@ -481,7 +522,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         }
     }
     async streamOneStep(args) {
-        const body = buildBody({
+        const body = ensureJsonWordInBody(this.adjustRequestBody(buildBody({
             modelId: args.modelId,
             messages: args.conversation,
             options: this.adjustBuildBodyOptions(args.modelId, args.options),
@@ -490,12 +531,12 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 ? { toolChoice: args.openAIToolChoice }
                 : {}),
             streaming: true,
-        });
+        }), args.modelId));
         const res = await args.fetchImpl(args.url, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
-                Authorization: `Bearer ${args.apiKey}`,
+                ...this.getAuthHeaders(),
             },
             body: JSON.stringify(body),
             ...(args.abortSignal ? { signal: args.abortSignal } : {}),
@@ -610,7 +651,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             const t = setTimeout(() => controller.abort(), 5000);
             const response = await proxyFetch(modelsUrl, {
                 headers: {
-                    Authorization: `Bearer ${this.config.apiKey}`,
+                    ...this.getAuthHeaders(),
                     "Content-Type": "application/json",
                 },
                 signal: controller.signal,

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

@@ -31,6 +31,9 @@ export declare const v3ResponseFormatToOpenAI: (rf: {
     description?: string;
 }) => OpenAICompatResponseFormat | undefined;
 export declare const mapNeuroLinkToolChoice: (choice: unknown) => OpenAICompatToolChoiceWire | undefined;
+export declare const messagesContainJsonWord: (messages: ReadonlyArray<OpenAICompatChatMessage>) => boolean;
+export declare const ensureJsonWordInBody: (body: OpenAICompatChatRequest) => OpenAICompatChatRequest;
+export declare const requiresMaxCompletionTokens: (modelId: string) => boolean;
 export declare const buildBody: (args: OpenAICompatBuildBodyArgs) => OpenAICompatChatRequest;
 export declare const parseSSEStream: (body: ReadableStream<Uint8Array>, onTextDelta: (delta: string) => void) => Promise<OpenAICompatSSEResult>;
 export declare const buildAPIError: (url: string, body: OpenAICompatChatRequest, res: Response) => Promise<Error>;

package/dist/lib/providers/openaiChatCompletionsClient.js

@@ -318,6 +318,45 @@ export const mapNeuroLinkToolChoice = (choice) => {
     }
     return undefined;
 };
+// OpenAI-compatible endpoints (OpenAI, DeepSeek, …) reject
+// `response_format: { type: "json_object" }` unless the literal word "json"
+// appears somewhere in the messages. The `@ai-sdk/openai-compatible` wrapper
+// this client replaced injected that instruction for us; the native client
+// must do the same or json_object requests 400.
+export const messagesContainJsonWord = (messages) => messages.some((m) => {
+    const c = m.content;
+    if (typeof c === "string") {
+        return /\bjson\b/i.test(c);
+    }
+    if (Array.isArray(c)) {
+        return c.some((part) => typeof part?.text === "string" &&
+            /\bjson\b/i.test(part.text));
+    }
+    return false;
+});
+// Prepends a minimal JSON-instruction system message to the FINAL wire body
+// when json_object mode is requested and its messages don't already mention
+// "json". Operates on the post-`adjustRequestBody` body so the guard reflects
+// whatever a subclass left on the wire (response_format/messages it may have
+// rewritten), not an intermediate state. No-op otherwise.
+export const ensureJsonWordInBody = (body) => body.response_format?.type === "json_object" &&
+    !messagesContainJsonWord(body.messages)
+    ? {
+        ...body,
+        messages: [
+            {
+                role: "system",
+                content: "Respond with valid JSON only — no prose, no markdown fencing.",
+            },
+            ...body.messages,
+        ],
+    }
+    : body;
+// Reasoning-class OpenAI models (o-series, gpt-5+) reject `max_tokens` and
+// require `max_completion_tokens`. The OpenAI + Azure providers use this to
+// rename the field on the wire body; third-party OpenAI-compatible endpoints
+// keep `max_tokens`, so it is opt-in per provider, never applied by default.
+export const requiresMaxCompletionTokens = (modelId) => /^(o\d|gpt-5)/i.test(modelId.replace(/^.*\//, ""));
 export const buildBody = (args) => {
     const { modelId, messages, options, tools, toolChoice, streaming, responseFormat, } = args;
     const body = {

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

@@ -212,7 +212,6 @@ export type StreamLoopArgs = {
     maxSteps: number;
     modelId: string;
     url: string;
-    apiKey: string;
     fetchImpl: typeof fetch;
     abortSignal: AbortSignal | undefined;
     options: StreamOptions;

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;