@juspay/neurolink 9.67.3 → 9.68.1

package/dist/providers/azureOpenai.js

@@ -1,30 +1,64 @@
-import { createAzure } from "@ai-sdk/azure";
 import { APIVersions } from "../constants/enums.js";
-import { BaseProvider } from "../core/baseProvider.js";
-import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { createProxyFetch } from "../proxy/proxyFetch.js";
-import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { AuthenticationError, NetworkError, ProviderError, } from "../types/index.js";
 import { logger } from "../utils/logger.js";
 import { createAzureAPIKeyConfig, createAzureEndpointConfig, validateApiKey, } from "../utils/providerConfig.js";
-import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
-import { resolveToolChoice } from "../utils/toolChoice.js";
-import { stepCountIs } from "../utils/tool.js";
-import { streamText } from "../utils/generation.js";
-export class AzureOpenAIProvider extends BaseProvider {
-    apiKey;
-    resourceName;
-    deployment;
-    apiVersion;
-    azureProvider;
+import { TimeoutError } from "../utils/timeout.js";
+import { transformParamsForLogging } from "../utils/transformationUtils.js";
+import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
+import { requiresMaxCompletionTokens } from "./openaiChatCompletionsClient.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 class AzureOpenAIProvider extends OpenAIChatCompletionsProvider {
+    // Azure-specific routing state resolved once in the constructor.
+    azureDeployment;
+    azureApiVersion;
+    // Parsed from the endpoint — mutually exclusive: either resourceName (for
+    // classic hosts) or foundryBaseURL (for AI Foundry) is non-empty.
+    azureResourceOrigin;
+    azureDeploymentPathPrefix;
+    // Explicit `max_completion_tokens` capability. `undefined` ⇒ fall back to the
+    // deployment-name heuristic in adjustRequestBody().
+    useMaxCompletionTokensOverride;
     constructor(modelName, sdk, _region, credentials) {
-        super(modelName, "azure", sdk);
-        this.apiKey = credentials?.apiKey || process.env.AZURE_OPENAI_API_KEY || "";
+        const apiKey = credentials?.apiKey || process.env.AZURE_OPENAI_API_KEY || "";
+        // -----------------------------------------------------------------------
+        // Parse the AZURE_OPENAI_ENDPOINT environment variable (or credentials)
+        // into the pieces needed to build deployment-based chat completions URLs.
+        //
+        // Two supported endpoint formats:
+        //
+        //  1. Classic Azure OpenAI / Cognitive Services:
+        //       https://<resource>.openai.azure.com
+        //       https://<resource>.cognitiveservices.azure.com
+        //     The @ai-sdk/azure tradition was to pass the bare resource subdomain
+        //     and let the SDK reconstruct the full URL.  We instead keep the full
+        //     origin and emit the standard deployment path from it:
+        //       {origin}/openai/deployments/{deployment}/chat/completions
+        //
+        //  2. Azure AI Foundry:
+        //       https://<host>.services.ai.azure.com[/openai]
+        //     The host has no resource-name subdomain convention.  The operator
+        //     may or may not include the "/openai" path prefix; we normalise that.
+        //     Final URL pattern:
+        //       {origin}{normalisedPath}/deployments/{deployment}/chat/completions
+        //
+        // In both cases we pass the "resource origin" (scheme+host) as `baseURL`
+        // to super so that `getAvailableModels()` can still build a models URL
+        // from it if needed; `getChatCompletionsURL()` builds the real path.
+        // -----------------------------------------------------------------------
         const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "";
-        // Use URL parsing instead of string-replace so endpoints that already
-        // carry a path segment (e.g. "https://<host>/openai" — a valid Azure AI
-        // Foundry shape) don't end up duplicating it as "<host>/openai/openai".
-        // Tolerate missing scheme by prefixing https:// before parsing.
         let endpointUrl;
         if (endpoint) {
             try {
@@ -35,95 +69,85 @@ export class AzureOpenAIProvider extends BaseProvider {
             }
         }
         const endpointHost = endpointUrl?.hostname ?? "";
+        // Strip trailing slashes from the pathname; treat "/" as empty.
         const endpointPath = endpointUrl?.pathname && endpointUrl.pathname !== "/"
             ? endpointUrl.pathname.replace(/\/+$/, "")
             : "";
-        // Classic Azure OpenAI ("*.openai.azure.com") and Cognitive Services
-        // ("*.cognitiveservices.azure.com") endpoints encode the resource name as
-        // a subdomain that @ai-sdk/azure expects to receive verbatim. The newer
-        // Azure AI Foundry endpoint format ("*.services.ai.azure.com") does not
-        // round-trip through that subdomain rewrite, so passing the resource name
-        // would yield e.g. "<host>.services.ai.azure.com.openai.azure.com". For
-        // those hosts we hand the full URL back via baseURL instead.
+        // Classic hosts encode the resource name as a subdomain.
         const isClassicAzureHost = /\.(openai|cognitiveservices)\.azure\.com$/.test(endpointHost);
-        const envResourceName = isClassicAzureHost
-            ? endpointHost
-                .replace(".openai.azure.com", "")
-                .replace(".cognitiveservices.azure.com", "")
-            : "";
-        this.resourceName = credentials?.resourceName || envResourceName;
-        // For Azure AI Foundry the SDK still routes to the OpenAI-compatible API
-        // (deployments/{deployment}/chat/completions); the `/openai` path suffix
-        // mirrors what the SDK derives in classic mode
-        // (`https://${resource}.openai.azure.com/openai`). Reuse the path the
-        // operator already supplied if it already terminates in `/openai` *or*
-        // a versioned form like `/openai/v1`; otherwise append `/openai`. Never
-        // duplicate.
-        const hasOpenAIPathSuffix = /\/openai(?:\/v\d+)?$/.test(endpointPath);
-        const baseURLForFoundry = !this.resourceName && endpointUrl
-            ? `${endpointUrl.origin}${hasOpenAIPathSuffix ? endpointPath : `${endpointPath}/openai`}`
-            : undefined;
-        this.deployment =
-            credentials?.deploymentName ||
-                modelName ||
-                process.env.AZURE_OPENAI_MODEL ||
-                process.env.AZURE_OPENAI_DEPLOYMENT ||
-                process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
-                "gpt-4o";
-        this.apiVersion =
-            credentials?.apiVersion ||
-                process.env.AZURE_API_VERSION ||
-                APIVersions.AZURE_LATEST;
-        // Configuration validation - now using consolidated utility
-        if (!this.apiKey) {
+        // For classic hosts the deployment URL path always starts with "/openai".
+        // For Foundry hosts we reuse whatever the operator supplied, appending
+        // "/openai" only when the path doesn't already end with it (or a
+        // versioned variant like "/openai/v1").
+        let deploymentPathPrefix;
+        if (isClassicAzureHost) {
+            deploymentPathPrefix = "/openai";
+        }
+        else {
+            const hasOpenAIPathSuffix = /\/openai(?:\/v\d+)?$/.test(endpointPath);
+            deploymentPathPrefix = hasOpenAIPathSuffix
+                ? endpointPath
+                : `${endpointPath}/openai`;
+        }
+        const resourceOrigin = endpointUrl?.origin ?? "";
+        const deployment = credentials?.deploymentName ||
+            modelName ||
+            process.env.AZURE_OPENAI_MODEL ||
+            process.env.AZURE_OPENAI_DEPLOYMENT ||
+            process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
+            "gpt-4o";
+        const apiVersion = credentials?.apiVersion ||
+            process.env.AZURE_API_VERSION ||
+            APIVersions.AZURE_LATEST;
+        // Deployment names are user-defined, so a model-name heuristic can't
+        // reliably tell whether the backing model needs max_completion_tokens.
+        // Prefer an explicit signal (credentials or env); fall back to the
+        // heuristic only when unset.
+        const envMaxCompletion = process.env.AZURE_OPENAI_USE_MAX_COMPLETION_TOKENS;
+        const maxCompletionOverride = credentials?.useMaxCompletionTokens ??
+            (envMaxCompletion === undefined
+                ? undefined
+                : /^(1|true|yes)$/i.test(envMaxCompletion));
+        // Validate required credentials before committing.
+        if (!apiKey) {
             validateApiKey(createAzureAPIKeyConfig());
         }
-        if (!this.resourceName && !baseURLForFoundry) {
+        if (!resourceOrigin) {
             validateApiKey(createAzureEndpointConfig());
         }
-        // Create the Azure provider instance with proxy support.
-        // For classic *.openai.azure.com / *.cognitiveservices.azure.com hosts we
-        // pass `resourceName`, which @ai-sdk/azure rewrites into the canonical
-        // subdomain. For Azure AI Foundry hosts ("*.services.ai.azure.com") we
-        // pass the full URL via `baseURL` so no rewrite happens.
-        // useDeploymentBasedUrls is required because @ai-sdk/azure v3+ defaults to
-        // the /v1/ URL format, but most Azure deployments still require the legacy
-        // /deployments/{deployment}/ URL pattern.
-        this.azureProvider = baseURLForFoundry
-            ? createAzure({
-                baseURL: baseURLForFoundry,
-                apiKey: this.apiKey,
-                apiVersion: this.apiVersion,
-                useDeploymentBasedUrls: true,
-                fetch: createProxyFetch(),
-            })
-            : createAzure({
-                resourceName: this.resourceName,
-                apiKey: this.apiKey,
-                apiVersion: this.apiVersion,
-                useDeploymentBasedUrls: true,
-                fetch: createProxyFetch(),
-            });
-        logger.debug("Azure Vercel Provider initialized", {
-            deployment: this.deployment,
-            resourceName: this.resourceName,
-            provider: "azure-vercel",
+        // Pass the resource origin as baseURL so the base class can construct
+        // auxiliary URLs (e.g. /models) from it when needed.
+        super("azure", modelName, sdk, {
+            baseURL: resourceOrigin,
+            apiKey,
         });
+        this.azureDeployment = deployment;
+        this.azureApiVersion = apiVersion;
+        this.azureResourceOrigin = resourceOrigin;
+        this.azureDeploymentPathPrefix = deploymentPathPrefix;
+        this.useMaxCompletionTokensOverride = maxCompletionOverride;
+        if (logger.shouldLog("debug")) {
+            logger.debug("Azure OpenAI Provider initialized", transformParamsForLogging({
+                deployment: this.azureDeployment,
+                resourceOrigin: this.azureResourceOrigin,
+                deploymentPathPrefix: this.azureDeploymentPathPrefix,
+                apiVersion: this.azureApiVersion,
+                provider: "azure",
+            }));
+        }
     }
+    // ===========================================================================
+    // Abstract-hook implementations
+    // ===========================================================================
     getProviderName() {
         return "azure";
     }
-    getDefaultModel() {
-        return this.deployment;
-    }
     /**
-     * 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() {
-        return this.azureProvider.chat(this.deployment);
+    getDefaultModel() {
+        return this.azureDeployment;
     }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {
@@ -140,80 +164,56 @@ export class AzureOpenAIProvider extends BaseProvider {
             : "Unknown error";
         return new ProviderError(`Azure OpenAI error: ${message}`, "azure");
     }
-    // executeGenerate removed - BaseProvider handles all generation with tools
-    async executeStream(options, _analysisSchema) {
-        const timeout = this.getTimeout(options);
-        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
-        try {
-            // Get tools - options.tools is pre-merged by BaseProvider.stream()
-            const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools
-                ? options.tools || (await this.getAllTools())
-                : {};
-            logger.debug("Azure Stream - Tool Loading Debug", {
-                shouldUseTools,
-                toolCount: Object.keys(tools).length,
-                toolNames: Object.keys(tools).slice(0, 10),
-                disableTools: options.disableTools,
-                supportsTools: this.supportsTools(),
-            });
-            // Build message array from options with multimodal support
-            // Using protected helper from BaseProvider to eliminate code duplication
-            const messages = await this.buildMessagesForStream(options);
-            const model = await this.getAISDKModelWithMiddleware(options);
-            // Reviewer follow-up: capture upstream provider errors via onError
-            // so the post-stream NoOutput sentinel carries the real cause.
-            let capturedProviderError;
-            const stream = await streamText({
-                model,
-                messages: messages,
-                ...(options.maxTokens !== null && options.maxTokens !== undefined
-                    ? { maxOutputTokens: options.maxTokens }
-                    : {}),
-                ...(options.temperature !== null && options.temperature !== undefined
-                    ? { temperature: options.temperature }
-                    : {}),
-                tools,
-                toolChoice: resolveToolChoice(options, tools, shouldUseTools),
-                stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
-                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
-                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
-                experimental_repairToolCall: this.getToolCallRepairFn(options),
-                onError: (event) => {
-                    capturedProviderError = event.error;
-                    logger.error("AzureOpenAI: Stream error", {
-                        error: event.error instanceof Error
-                            ? event.error.message
-                            : String(event.error),
-                    });
-                },
-                onStepFinish: (event) => {
-                    emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), event.toolResults);
-                    this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
-                        logger.warn("[AzureOpenaiProvider] Failed to store tool executions", {
-                            provider: this.providerName,
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    });
-                },
-            });
-            timeoutController?.cleanup();
-            // Transform string stream to content object stream using BaseProvider method
-            const transformedStream = this.createTextStream(stream, () => capturedProviderError);
+    // ===========================================================================
+    // New overridable hooks (provided by the base-enhancement branch)
+    // ===========================================================================
+    /**
+     * 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
+     */
+    getChatCompletionsURL(modelId) {
+        // modelId is the deployment name when it has been resolved; fall back to
+        // the stored deployment when the base passes a generic placeholder.
+        const deployment = modelId || this.azureDeployment;
+        const prefix = this.azureDeploymentPathPrefix.replace(/\/+$/, "");
+        return (`${this.azureResourceOrigin}${prefix}/deployments/${deployment}` +
+            `/chat/completions?api-version=${this.azureApiVersion}`);
+    }
+    /**
+     * Azure uses `api-key` rather than the standard `Authorization: Bearer`
+     * header expected by OpenAI-compatible endpoints.
+     */
+    getAuthHeaders() {
+        return { "api-key": this.config.apiKey };
+    }
+    /**
+     * 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`).
+     */
+    adjustRequestBody(body, modelId) {
+        const needsMaxCompletion = this.useMaxCompletionTokensOverride ??
+            requiresMaxCompletionTokens(modelId);
+        if (body.max_tokens !== undefined && needsMaxCompletion) {
             return {
-                stream: transformedStream,
-                provider: "azure",
-                model: this.deployment,
-                metadata: {
-                    streamId: `azure-${Date.now()}`,
-                    startTime: Date.now(),
-                },
+                ...body,
+                max_completion_tokens: body.max_tokens,
+                max_tokens: undefined,
             };
         }
-        catch (error) {
-            timeoutController?.cleanup();
-            throw this.handleProviderError(error);
-        }
+        return body;
     }
 }
-export default AzureOpenAIProvider;

package/dist/providers/openaiChatCompletionsBase.d.ts

@@ -19,7 +19,7 @@
  */
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import type { LanguageModel, OpenAICompatBuildBodyArgs, OpenAICompatStreamLifecycleListeners, Schema, StreamOptions, StreamResult, ZodUnknownSchema } from "../types/index.js";
+import type { LanguageModel, OpenAICompatBuildBodyArgs, OpenAICompatChatRequest, OpenAICompatResponseFormat, OpenAICompatStreamLifecycleListeners, Schema, StreamOptions, StreamResult, ZodUnknownSchema } from "../types/index.js";
 /**
  * Abstract HTTP+SSE provider for OpenAI chat-completions-shaped endpoints.
  */
@@ -52,6 +52,24 @@ export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider
      * (e.g. LiteLLM's Gemini 2.5 maxTokens skip).
      */
     protected adjustBuildBodyOptions(_modelId: string, opts: OpenAICompatBuildBodyArgs["options"]): OpenAICompatBuildBodyArgs["options"];
+    /**
+     * 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.
+     */
+    protected adjustResponseFormat(rf: OpenAICompatResponseFormat | undefined, _modelId: string): OpenAICompatResponseFormat | undefined;
+    /**
+     * 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`.
+     */
+    protected adjustRequestBody(body: OpenAICompatChatRequest, _modelId: string): OpenAICompatChatRequest;
     /**
      * Hook called once at the start of every `executeStream` invocation.
      * Return lifecycle listeners (onUsage / onFinish) to receive deferred
@@ -66,6 +84,18 @@ export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider
      * `getDefaultModel()` will never hit this branch anyway.
      */
     protected shouldAutoDiscoverModel(): boolean;
+    /**
+     * 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).
+     */
+    protected getChatCompletionsURL(_modelId: string): string;
+    /**
+     * 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`).
+     */
+    protected getAuthHeaders(): Record<string, string>;
     supportsTools(): boolean;
     /**
      * Returns a minimal V3-shaped model used by BaseProvider's `generate()`

package/dist/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/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>;