@juspay/neurolink 9.64.0 → 9.65.0

package/dist/lib/providers/nvidiaNim.js

@@ -1,15 +1,98 @@
-import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 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 { isNeuroLink } from "../neurolink.js";
 import { createProxyFetch, maskProxyUrl } from "../proxy/proxyFetch.js";
-import { tracers, ATTR, withClientSpan } from "../telemetry/index.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 { createNvidiaNimConfig, 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";
+/**
+ * Decide whether a NIM 400 response body is a rejection of the named
+ * field (as opposed to an unrelated 400 that happens to mention the
+ * field name — e.g. when the user's prompt is echoed back inside the
+ * error envelope).
+ *
+ * A rejection requires both:
+ *   - the field name appears in the body, and
+ *   - a rejection keyword (`unsupported`, `not supported`, `unknown`,
+ *     `invalid`, `unrecognized`, `does not support`) appears within
+ *     80 characters of any occurrence.
+ *
+ * The 80-character window is loose enough to absorb NIM's "Unsupported
+ * argument: `chat_template`" framing and tight enough that a 1KB error
+ * body mentioning the field once in a code sample plus an unrelated
+ * "invalid" elsewhere won't trigger a strip.
+ */
+const NIM_REJECTION_KEYWORDS = [
+    "unsupported",
+    "not supported",
+    "does not support",
+    "unrecognized",
+    "unknown field",
+    "unknown parameter",
+    "unknown argument",
+    "invalid field",
+    "invalid parameter",
+    "invalid argument",
+];
+const isNimFieldRejection = (body, field) => {
+    if (!body) {
+        return false;
+    }
+    const lower = body.toLowerCase();
+    const fieldLower = field.toLowerCase();
+    let idx = lower.indexOf(fieldLower);
+    while (idx !== -1) {
+        const windowStart = Math.max(0, idx - 80);
+        const windowEnd = Math.min(lower.length, idx + fieldLower.length + 80);
+        const slice = lower.slice(windowStart, windowEnd);
+        if (NIM_REJECTION_KEYWORDS.some((kw) => slice.includes(kw))) {
+            return true;
+        }
+        idx = lower.indexOf(fieldLower, idx + fieldLower.length);
+    }
+    return false;
+};
+/**
+ * Strip an offending field from a JSON request body and return the rebuilt
+ * stringified body. Returns `null` if the body isn't JSON-parseable or the
+ * field isn't present (signal: nothing to retry).
+ */
+const stripFieldFromJsonBody = (body, field) => {
+    try {
+        const parsed = JSON.parse(body);
+        let mutated = false;
+        if (field === "chat_template" && "chat_template" in parsed) {
+            delete parsed.chat_template;
+            mutated = true;
+        }
+        if (field === "reasoning_budget") {
+            const kw = parsed.chat_template_kwargs;
+            if (kw && "reasoning_budget" in kw) {
+                delete kw.reasoning_budget;
+                mutated = true;
+                if (Object.keys(kw).length === 0) {
+                    delete parsed.chat_template_kwargs;
+                }
+            }
+        }
+        if (!mutated) {
+            return null;
+        }
+        return JSON.stringify(parsed);
+    }
+    catch {
+        return null;
+    }
+};
 const makeLoggingFetch = (provider) => {
     const base = createProxyFetch();
     return (async (input, init) => {
@@ -19,7 +102,41 @@ const makeLoggingFetch = (provider) => {
                 ? input.toString()
                 : input.url;
         const reqSize = init?.body && typeof init.body === "string" ? init.body.length : 0;
-        const response = await base(input, init);
+        let response = await base(input, init);
+        // Generic NIM 400 retry-strip: works for BOTH generate and stream paths.
+        // NIM sometimes returns HTTP 400 when a model rejects `reasoning_budget`
+        // or `chat_template`. The stream path already retries by reconstructing
+        // its provider options; this fetch-level retry is the symmetric fix for
+        // generate (and any other transport that lands here).
+        //
+        // We require BOTH (a) the offending field name AND (b) a rejection
+        // keyword (unsupported / not supported / unknown / invalid /
+        // unrecognized / does not support) within 80 chars of it. Without the
+        // rejection-keyword guard, an unrelated 400 whose error body happened
+        // to mention `chat_template` (e.g. the user prompt got echoed back)
+        // would cause us to silently strip a field the user actually wanted
+        // sent, and either succeed for the wrong reason or fail with a
+        // misleading error.
+        if (response.status === 400 &&
+            typeof init?.body === "string" &&
+            init.body.length > 0) {
+            const cloned = response.clone();
+            const body = await cloned.text().catch(() => "");
+            let retryBody = null;
+            let stripped = null;
+            if (isNimFieldRejection(body, "reasoning_budget")) {
+                retryBody = stripFieldFromJsonBody(init.body, "reasoning_budget");
+                stripped = "reasoning_budget";
+            }
+            else if (isNimFieldRejection(body, "chat_template")) {
+                retryBody = stripFieldFromJsonBody(init.body, "chat_template");
+                stripped = "chat_template";
+            }
+            if (retryBody !== null && stripped !== null) {
+                logger.warn(`[${provider}] NIM rejected ${stripped}; retrying with field stripped`);
+                response = await base(input, { ...init, body: retryBody });
+            }
+        }
         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
@@ -41,8 +158,6 @@ const makeLoggingFetch = (provider) => {
         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];
@@ -124,9 +239,7 @@ export class NvidiaNimProvider extends BaseProvider {
     apiKey;
     baseURL;
     constructor(modelName, sdk, _region, credentials) {
-        const validatedNeurolink = sdk && typeof sdk === "object" && "getInMemoryServers" in sdk
-            ? sdk
-            : undefined;
+        const validatedNeurolink = isNeuroLink(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
@@ -141,13 +254,31 @@ export class NvidiaNimProvider extends BaseProvider {
             credentials?.baseURL ??
                 process.env.NVIDIA_NIM_BASE_URL ??
                 NVIDIA_NIM_DEFAULT_BASE_URL;
-        const nim = createOpenAI({
+        // We deliberately use `@ai-sdk/openai-compatible` rather than
+        // `@ai-sdk/openai`. Two upstream behaviors of `@ai-sdk/openai` break us:
+        //   1. It always sends `response_format: { type: "json_schema" }` when a
+        //      schema is provided. Most NIM-served chat models don't enforce
+        //      json_schema strictly — the schema goes through but `result.object`
+        //      stays empty because the SDK never gets the typed response back.
+        //   2. It does not parse the `reasoning_content` field that NIM-hosted
+        //      reasoning models (deepseek-r1, qwq, llama-nemotron-ultra) emit,
+        //      so chain-of-thought is silently dropped.
+        // `@ai-sdk/openai-compatible` honors `supportsStructuredOutputs: false`
+        // (falls back to `{ type: "json_object" }` and injects the schema into
+        // the prompt — works across the entire NIM model fleet) and parses both
+        // `choice.message.reasoning_content` and `delta.reasoning_content` into
+        // the SDK-standard `reasoning` part. NIM-specific extras (`min_tokens`,
+        // `chat_template_kwargs.reasoning_budget`, `chat_template`) are still
+        // injected via `providerOptions.openai.body` in `executeStreamInner`.
+        const nim = createOpenAICompatible({
+            name: "nvidia-nim",
             apiKey: this.apiKey,
             baseURL: this.baseURL,
             fetch: makeLoggingFetch("nvidia-nim"),
+            supportsStructuredOutputs: false,
+            includeUsage: true,
         });
-        // .chat() — NIM exposes /v1/chat/completions, not /v1/responses
-        this.model = nim.chat(this.modelName);
+        this.model = nim.chatModel(this.modelName);
         logger.debug("NVIDIA NIM Provider initialized", {
             modelName: this.modelName,
             providerName: this.providerName,
@@ -155,7 +286,7 @@ export class NvidiaNimProvider extends BaseProvider {
         });
     }
     async executeStream(options, _analysisSchema) {
-        return withClientSpan({
+        return withClientStreamSpan({
             name: "neurolink.provider.stream",
             tracer: tracers.provider,
             attributes: {
@@ -164,7 +295,7 @@ export class NvidiaNimProvider extends BaseProvider {
                 [ATTR.GEN_AI_OPERATION]: "stream",
                 [ATTR.NL_STREAM_MODE]: true,
             },
-        }, async () => this.executeStreamInner(options));
+        }, async () => this.executeStreamInner(options), (r) => r.stream, (r, wrapped) => ({ ...r, stream: wrapped }));
     }
     async executeStreamInner(options) {
         this.validateStreamOptions(options);
@@ -316,27 +447,37 @@ export class NvidiaNimProvider extends BaseProvider {
     }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {
-            return new Error(`NVIDIA NIM request timed out: ${error.message}`);
+            return new NetworkError(`Request timed out: ${error.message}`, "nvidia-nim");
         }
         const errorRecord = error;
         const message = typeof errorRecord?.message === "string"
             ? errorRecord.message
             : "Unknown error";
+        // NIM canonically returns HTTP 401/Unauthorized for invalid API keys,
+        // but its OpenAI-compatible gateway sometimes surfaces a bare 400 +
+        // "Bad Request" with no body details for both malformed-credentials
+        // and bad-parameter cases. Because the two are indistinguishable from
+        // the message alone, we DON'T promote bare 400/Bad Request to "invalid
+        // key" here — that would mis-classify legitimate parameter errors
+        // (e.g. unsupported `reasoning_budget`, unsupported `chat_template`)
+        // as auth failures. Tests that probe the auth path (K1) detect
+        // "bad request" / "400" themselves; tests that probe parameter retry
+        // (K5) need the original "Bad Request" message to surface.
         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");
+            return new AuthenticationError("Invalid NVIDIA NIM API key. Get one at https://build.nvidia.com/settings/api-keys", "nvidia-nim");
         }
         if (message.includes("rate limit") || message.includes("429")) {
-            return new Error("NVIDIA NIM rate limit exceeded");
+            return new RateLimitError("NVIDIA NIM rate limit exceeded", "nvidia-nim");
         }
         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`);
+            return new InvalidModelError(`NVIDIA NIM model '${this.modelName}' not available. Browse the catalog at https://build.nvidia.com/models`, "nvidia-nim");
         }
         if (message.includes("quota") || message.includes("403")) {
-            return new Error("NVIDIA NIM quota exceeded for your account");
+            return new ProviderError("NVIDIA NIM quota exceeded for your account", "nvidia-nim");
         }
-        return new Error(`NVIDIA NIM error: ${message}`);
+        return new ProviderError(`NVIDIA NIM error: ${message}`, "nvidia-nim");
     }
     async validateConfiguration() {
         return typeof this.apiKey === "string" && this.apiKey.trim().length > 0;

package/dist/lib/providers/ollama.js

@@ -8,7 +8,7 @@ import { buildMultimodalMessagesArray } from "../utils/messageBuilder.js";
 import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { InvalidModelError, NetworkError, ProviderError, } from "../types/index.js";
-import { tracers, ATTR, withClientSpan } from "../telemetry/index.js";
+import { tracers, ATTR, withClientStreamSpan } from "../telemetry/index.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { TimeoutError } from "../utils/timeout.js";
 // Model version constants (configurable via environment)
@@ -690,7 +690,7 @@ export class OllamaProvider extends BaseProvider {
      * Uses conversation loop to handle multi-step tool execution
      */
     async executeStreamWithTools(options, _analysisSchema) {
-        return withClientSpan({
+        return withClientStreamSpan({
             name: "neurolink.provider.stream",
             tracer: tracers.provider,
             attributes: {
@@ -741,7 +741,7 @@ export class OllamaProvider extends BaseProvider {
                 }
                 conversationHistory.push({
                     role: "user",
-                    content: options.input.text,
+                    content: options.input.text ?? "",
                 });
             }
             // Capture instance references before the stream for use in the finally block.
@@ -908,14 +908,14 @@ export class OllamaProvider extends BaseProvider {
                     streamId: `ollama-${Date.now()}`,
                 },
             };
-        });
+        }, (r) => r.stream, (r, wrapped) => ({ ...r, stream: wrapped }));
     }
     /**
      * Execute streaming without tools using the generate API
      * Fallback for non-tool scenarios or when chat API is unavailable
      */
     async executeStreamWithoutTools(options, _analysisSchema) {
-        return withClientSpan({
+        return withClientStreamSpan({
             name: "neurolink.provider.stream",
             tracer: tracers.provider,
             attributes: {
@@ -954,7 +954,7 @@ export class OllamaProvider extends BaseProvider {
                     messages.push({ role: "user", content });
                 }
                 else {
-                    messages.push({ role: "user", content: options.input.text });
+                    messages.push({ role: "user", content: options.input.text ?? "" });
                 }
                 const requestUrl = `${this.baseUrl}/v1/chat/completions`;
                 const requestBody = {
@@ -1064,7 +1064,7 @@ export class OllamaProvider extends BaseProvider {
                     model: this.modelName,
                 };
             }
-        });
+        }, (r) => r.stream, (r, wrapped) => ({ ...r, stream: wrapped }));
     }
     /**
      * Convert AI SDK tools format to Ollama's function calling format

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

@@ -2,7 +2,7 @@ import { type LanguageModel } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { NeuroLink } from "../neurolink.js";
-import type { ValidationSchema, StreamOptions, StreamResult } from "../types/index.js";
+import type { EnhancedGenerateResult, TextGenerationOptions, ValidationSchema, StreamOptions, StreamResult } from "../types/index.js";
 /**
  * OpenAI Provider v2 - BaseProvider Implementation
  * Migrated to use factory pattern with exact Google AI provider pattern
@@ -73,5 +73,26 @@ export declare class OpenAIProvider extends BaseProvider {
      * @returns Promise resolving to an array of embedding vectors
      */
     embedMany(texts: string[], modelName?: string): Promise<number[][]>;
+    /**
+     * Image generation via the OpenAI Images API (`/v1/images/generations`).
+     *
+     * Supports `gpt-image-1`, `dall-e-3`, and `dall-e-2`. The three models
+     * differ in which body params they accept:
+     *
+     * - `gpt-image-1` returns base64 by default; does NOT accept `response_format`.
+     * - `dall-e-3` / `dall-e-2` accept `response_format: "b64_json"` to get base64.
+     * - `dall-e-2` does NOT accept `quality` / `style`.
+     *
+     * The model is taken from `options.model || this.modelName`.
+     *
+     * @see https://platform.openai.com/docs/api-reference/images/create
+     */
+    protected executeImageGeneration(options: TextGenerationOptions): Promise<EnhancedGenerateResult>;
+    /**
+     * Map a NeuroLink-style aspect ratio (e.g. "16:9") to the OpenAI
+     * `size` parameter accepted by the active image model. Falls back to
+     * the per-model square default when the ratio is unknown.
+     */
+    private aspectRatioToOpenAISize;
 }
 export default OpenAIProvider;

package/dist/lib/providers/openAI.js

@@ -15,6 +15,8 @@ import { isZodSchema } from "../utils/schemaConversion.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
+import { MAX_IMAGE_BYTES, readBoundedBuffer } from "../utils/sizeGuard.js";
+import { assertSafeUrl } from "../utils/ssrfGuard.js";
 import { getModelId } from "./providerTypeUtils.js";
 /**
  * Retrieve a tool's schema, handling both AI SDK v6 (`inputSchema`) and
@@ -692,6 +694,185 @@ export class OpenAIProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    /**
+     * Image generation via the OpenAI Images API (`/v1/images/generations`).
+     *
+     * Supports `gpt-image-1`, `dall-e-3`, and `dall-e-2`. The three models
+     * differ in which body params they accept:
+     *
+     * - `gpt-image-1` returns base64 by default; does NOT accept `response_format`.
+     * - `dall-e-3` / `dall-e-2` accept `response_format: "b64_json"` to get base64.
+     * - `dall-e-2` does NOT accept `quality` / `style`.
+     *
+     * The model is taken from `options.model || this.modelName`.
+     *
+     * @see https://platform.openai.com/docs/api-reference/images/create
+     */
+    async executeImageGeneration(options) {
+        const startTime = Date.now();
+        const prompt = options.prompt ?? options.input?.text ?? "";
+        if (!prompt.trim()) {
+            throw new Error("OpenAI image generation requires a prompt (input.text or prompt)");
+        }
+        const model = options.model ?? this.modelName;
+        const apiKey = this.credentials?.apiKey ?? getOpenAIApiKey();
+        const baseURL = (this.credentials?.baseURL ??
+            process.env.OPENAI_BASE_URL ??
+            "https://api.openai.com/v1").replace(/\/$/, "");
+        // Image-gen extras live on `options` but are not part of the strict
+        // TextGenerationOptions shape — cast to a permissive type to read them.
+        const extras = options;
+        // Map aspect ratio to OpenAI's `size` parameter. gpt-image-1 supports
+        // 1024x1024 / 1024x1536 / 1536x1024 / auto; dall-e-3 supports
+        // 1024x1024 / 1792x1024 / 1024x1792; dall-e-2 supports 256x256 /
+        // 512x512 / 1024x1024. We pick safe defaults and let users override
+        // via `extras.size` directly.
+        const size = extras.size ?? this.aspectRatioToOpenAISize(extras.aspectRatio, model);
+        // Clamp n per-model: gpt-image-1 and dall-e-3 only support n=1;
+        // dall-e-2 supports n=1..10; default to 1 for any future models.
+        const rawN = extras.numberOfImages ?? 1;
+        let clampedN;
+        if (model === "gpt-image-1" || model.startsWith("dall-e-3")) {
+            clampedN = 1;
+        }
+        else if (model.startsWith("dall-e-2")) {
+            clampedN = Math.min(Math.max(rawN, 1), 10);
+        }
+        else {
+            clampedN = 1;
+        }
+        const n = clampedN;
+        const body = {
+            model,
+            prompt,
+            n,
+            size,
+        };
+        if (model === "gpt-image-1") {
+            // gpt-image-1 always returns base64; rejects `response_format`.
+            if (extras.quality) {
+                body.quality = extras.quality;
+            }
+        }
+        else if (model.startsWith("dall-e-3")) {
+            body.response_format = "b64_json";
+            if (extras.quality) {
+                body.quality = extras.quality;
+            }
+            if (extras.style) {
+                body.style = extras.style;
+            }
+        }
+        else {
+            // dall-e-2 (and forward-compat default).
+            body.response_format = "b64_json";
+        }
+        const REQUEST_TIMEOUT_MS = 120_000;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        let response;
+        try {
+            const proxyFetch = createProxyFetch();
+            response = await proxyFetch(`${baseURL}/images/generations`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                throw new Error(`OpenAI image generation timed out after ${REQUEST_TIMEOUT_MS / 1000}s`, { cause: err });
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`OpenAI image generation failed: ${response.status} — ${text}`);
+        }
+        const data = (await response.json());
+        const first = data.data?.[0];
+        if (!first) {
+            throw new Error("OpenAI image generation returned no images");
+        }
+        let base64 = first.b64_json;
+        // dall-e-2 with `response_format: "b64_json"` should always include
+        // b64_json. If a hosted URL came back instead (e.g. older keys, or
+        // url-mode), download it inline so callers always get base64.
+        if (!base64 && first.url) {
+            // Guard the API-returned URL before fetching (provider-returned URLs
+            // carry the same SSRF risk as caller-supplied ones).
+            await assertSafeUrl(first.url);
+            const proxyFetch = createProxyFetch();
+            const dlController = new AbortController();
+            const dlTimeoutId = setTimeout(() => dlController.abort(), 60_000);
+            let imgResp;
+            try {
+                imgResp = await proxyFetch(first.url, { signal: dlController.signal });
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === "AbortError") {
+                    throw new Error("OpenAI image URL download timed out after 60s", {
+                        cause: err,
+                    });
+                }
+                throw err;
+            }
+            finally {
+                clearTimeout(dlTimeoutId);
+            }
+            if (!imgResp.ok) {
+                throw new Error(`OpenAI image generation: failed to fetch hosted URL ${first.url} (${imgResp.status})`);
+            }
+            const buf = await readBoundedBuffer(imgResp, MAX_IMAGE_BYTES, "OpenAI image fallback");
+            base64 = buf.toString("base64");
+        }
+        if (!base64) {
+            throw new Error("OpenAI image generation returned neither b64_json nor a URL");
+        }
+        const generationTimeMs = Date.now() - startTime;
+        logger.info(`[OpenAIProvider] Generated image (${base64.length} base64 chars) in ${generationTimeMs}ms — model ${model}`);
+        return {
+            content: first.revised_prompt ?? prompt,
+            provider: this.providerName,
+            model,
+            usage: { input: 0, output: 0, total: 0 },
+            imageOutput: { base64 },
+        };
+    }
+    /**
+     * Map a NeuroLink-style aspect ratio (e.g. "16:9") to the OpenAI
+     * `size` parameter accepted by the active image model. Falls back to
+     * the per-model square default when the ratio is unknown.
+     */
+    aspectRatioToOpenAISize(aspectRatio, model) {
+        if (model === "gpt-image-1") {
+            if (aspectRatio === "16:9" || aspectRatio === "3:2") {
+                return "1536x1024";
+            }
+            if (aspectRatio === "9:16" || aspectRatio === "2:3") {
+                return "1024x1536";
+            }
+            return "1024x1024";
+        }
+        if (model.startsWith("dall-e-3")) {
+            if (aspectRatio === "16:9" || aspectRatio === "3:2") {
+                return "1792x1024";
+            }
+            if (aspectRatio === "9:16" || aspectRatio === "2:3") {
+                return "1024x1792";
+            }
+            return "1024x1024";
+        }
+        // dall-e-2 — only square sizes supported.
+        return "1024x1024";
+    }
 }
 // Export for factory registration
 export default OpenAIProvider;