@juspay/neurolink 9.63.1 → 9.65.0

package/dist/providers/openRouter.js

@@ -5,6 +5,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
 import { isAbortError } from "../utils/errorHandling.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
@@ -32,15 +33,23 @@ const getOpenRouterConfig = () => {
  *
  * OpenRouter uses a 'provider/model' format for model names.
  * For example:
- *   - 'anthropic/claude-3-5-sonnet'
+ *   - 'anthropic/claude-sonnet-4.5'
  *   - 'openai/gpt-4o'
- *   - 'google/gemini-2.0-flash'
+ *   - 'google/gemini-2.5-flash'
  *   - 'meta-llama/llama-3-70b-instruct'
  *
+ * The previous default `anthropic/claude-3-5-sonnet` was retired by OpenRouter
+ * in late 2025 and now returns "No endpoints found for model" for every
+ * caller. Default bumped to the current Anthropic mainline (Claude Sonnet
+ * 4.5) so callers without an `OPENROUTER_MODEL` env var don't hit a dead
+ * model. Must stay aligned with the registry default in
+ * `src/lib/factories/providerRegistry.ts` and `PROVIDER_DEFAULTS` in
+ * `src/lib/utils/modelChoices.ts`.
+ *
  * You can override the default by setting the OPENROUTER_MODEL environment variable.
  */
 const getDefaultOpenRouterModel = () => {
-    return getProviderModel("OPENROUTER_MODEL", "anthropic/claude-3-5-sonnet");
+    return getProviderModel("OPENROUTER_MODEL", "anthropic/claude-sonnet-4.5");
 };
 /**
  * OpenRouter Provider - BaseProvider Implementation
@@ -107,62 +116,62 @@ export class OpenRouterProvider extends BaseProvider {
     }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {
-            return new Error(`OpenRouter request timed out: ${error.message}`);
+            return new NetworkError(`Request timed out: ${error.message}`, "openrouter");
         }
         // Check for timeout by error name and message as fallback
         const errorRecord = error;
         if (errorRecord?.name === "TimeoutError" ||
             (typeof errorRecord?.message === "string" &&
                 errorRecord.message.includes("Timeout"))) {
-            return new Error(`OpenRouter request timed out: ${errorRecord?.message || "Unknown timeout"}`);
+            return new NetworkError(`Request timed out: ${errorRecord?.message || "Unknown timeout"}`, "openrouter");
         }
         if (typeof errorRecord?.message === "string") {
             if (errorRecord.message.includes("ECONNREFUSED") ||
                 errorRecord.message.includes("Failed to fetch")) {
-                return new Error("OpenRouter API not available. Please check your network connection and try again.");
+                return new NetworkError("OpenRouter API not available. Please check your network connection and try again.", "openrouter");
             }
             if (errorRecord.message.includes("API_KEY_INVALID") ||
                 errorRecord.message.includes("Invalid API key") ||
                 errorRecord.message.includes("invalid_api_key") ||
                 errorRecord.message.includes("Unauthorized")) {
-                return new Error("Invalid OpenRouter API key. Please check your OPENROUTER_API_KEY environment variable. " +
-                    "Get your key at https://openrouter.ai/keys");
+                return new AuthenticationError("Invalid OpenRouter API key. Please check your OPENROUTER_API_KEY environment variable. " +
+                    "Get your key at https://openrouter.ai/keys", "openrouter");
             }
             if (errorRecord.message.includes("rate limit")) {
-                return new Error("OpenRouter rate limit exceeded. Please try again later or upgrade your account at https://openrouter.ai/credits");
+                return new RateLimitError("OpenRouter rate limit exceeded. Please try again later or upgrade your account at https://openrouter.ai/credits", "openrouter");
             }
             if (errorRecord.message.includes("model") &&
                 errorRecord.message.includes("not found")) {
-                return new Error(`Model '${this.modelName}' not available on OpenRouter. ` +
-                    "Browse available models at https://openrouter.ai/models");
+                return new InvalidModelError(`Model '${this.modelName}' not available on OpenRouter. ` +
+                    "Browse available models at https://openrouter.ai/models", "openrouter");
             }
             if (errorRecord.message.includes("insufficient_credits")) {
-                return new Error("Insufficient OpenRouter credits. Add credits at https://openrouter.ai/credits");
+                return new ProviderError("Insufficient OpenRouter credits. Add credits at https://openrouter.ai/credits", "openrouter");
             }
             // "No endpoints found" — model temporarily unavailable or unsupported parameters
             // This is distinct from tool errors: it can happen on any request when the
             // model has no available providers on OpenRouter (e.g., free-tier model down).
             if (errorRecord.message.includes("No endpoints found")) {
-                return new Error(`No endpoints found for model '${this.modelName}' on OpenRouter. ` +
+                return new InvalidModelError(`No endpoints found for model '${this.modelName}' on OpenRouter. ` +
                     "The model may be temporarily unavailable or does not support the requested parameters. " +
-                    "Try a different model or check availability at https://openrouter.ai/models");
+                    "Try a different model or check availability at https://openrouter.ai/models", "openrouter");
             }
             // Tool/function calling errors
             if (errorRecord.message.includes("tool use") ||
                 errorRecord.message.includes("tool_use") ||
                 errorRecord.message.includes("function_call") ||
                 errorRecord.message.includes("tools are not supported")) {
-                return new Error(`Model '${this.modelName}' does not support tool calling. ` +
+                return new ProviderError(`Model '${this.modelName}' does not support tool calling. ` +
                     "Use a tool-capable model like:\n" +
                     "  • google/gemini-2.0-flash-exp:free (free)\n" +
                     "  • meta-llama/llama-3.3-70b-instruct:free (free)\n" +
-                    "  • anthropic/claude-3-5-sonnet (paid)\n" +
+                    "  • anthropic/claude-3.7-sonnet (paid)\n" +
                     "  • openai/gpt-4o (paid)\n" +
                     "Or use --disableTools flag. " +
-                    "See all tool-capable models at https://openrouter.ai/models?supported_parameters=tools");
+                    "See all tool-capable models at https://openrouter.ai/models?supported_parameters=tools", "openrouter");
             }
         }
-        return new Error(`OpenRouter error: ${errorRecord?.message || "Unknown error"}`);
+        return new ProviderError(`OpenRouter error: ${errorRecord?.message || "Unknown error"}`, "openrouter");
     }
     /**
      * OpenRouter supports tools for compatible models
@@ -207,7 +216,7 @@ export class OpenRouterProvider extends BaseProvider {
         // For unknown models, warn and disable tools (safe default)
         logger.warn("OpenRouter: Unknown model tool capability, disabling tools", {
             model: modelName,
-            suggestion: "Use a known tool-capable model like anthropic/claude-3-5-sonnet, openai/gpt-4o, or google/gemini-2.0-flash-exp:free",
+            suggestion: "Use a known tool-capable model like anthropic/claude-3.7-sonnet, openai/gpt-4o, or google/gemini-2.0-flash-exp:free",
         });
         return false;
     }
@@ -251,7 +260,12 @@ export class OpenRouterProvider extends BaseProvider {
                 messages: messages,
                 temperature: options.temperature,
                 maxRetries: 0, // Disable SDK retries - let caller handle rate limit retries with delays
-                ...(options.maxTokens && { maxTokens: options.maxTokens }),
+                // AI SDK v6 renamed `maxTokens` to `maxOutputTokens` — using the old
+                // name here is a silent no-op, so OpenRouter sees no cap and applies
+                // the model's full output max (typically 64K+ tokens) to its pre-bill
+                // affordability check. That trips "This request requires more credits"
+                // even on cheap models when the account balance is low.
+                ...(options.maxTokens && { maxOutputTokens: options.maxTokens }),
                 ...(shouldUseTools &&
                     Object.keys(tools).length > 0 && {
                     tools,
@@ -452,10 +466,12 @@ export class OpenRouterProvider extends BaseProvider {
                 error: error instanceof Error ? error.message : String(error),
             });
         }
-        // Fallback to hardcoded list if API fetch fails
+        // Fallback to hardcoded list if API fetch fails. Aligned with
+        // `getDefaultOpenRouterModel()` — `anthropic/claude-3-5-sonnet` was
+        // retired by OpenRouter late 2025 and would return a dead model here.
         const fallbackModels = [
             // Anthropic Claude models
-            "anthropic/claude-3-5-sonnet",
+            "anthropic/claude-3.7-sonnet",
             "anthropic/claude-3-5-haiku",
             "anthropic/claude-3-opus",
             // OpenAI models

package/dist/providers/openaiCompatible.js

@@ -4,6 +4,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/index.js";
 import { emitToolEndFromStepFinish } from "../utils/toolEndEmitter.js";
 import { logger } from "../utils/logger.js";
 import { buildNoOutputSentinel, detectPostStreamNoOutput, stampNoOutputSpan, } from "../utils/noOutputSentinel.js";
@@ -127,36 +128,36 @@ export class OpenAICompatibleProvider extends BaseProvider {
     }
     formatProviderError(error) {
         if (error instanceof TimeoutError) {
-            return new Error(`OpenAI Compatible request timed out: ${error.message}`);
+            return new NetworkError(`Request timed out: ${error.message}`, "openai-compatible");
         }
         // Check for timeout by error name and message as fallback
         const errorRecord = error;
         if (errorRecord?.name === "TimeoutError" ||
             (typeof errorRecord?.message === "string" &&
                 errorRecord.message.includes("Timeout"))) {
-            return new Error(`OpenAI Compatible request timed out: ${errorRecord?.message || "Unknown timeout"}`);
+            return new NetworkError(`Request timed out: ${errorRecord?.message || "Unknown timeout"}`, "openai-compatible");
         }
         if (typeof errorRecord?.message === "string") {
             if (errorRecord.message.includes("ECONNREFUSED") ||
                 errorRecord.message.includes("Failed to fetch")) {
-                return new Error(`OpenAI Compatible endpoint not available. Please check your OPENAI_COMPATIBLE_BASE_URL: ${this.config.baseURL}`);
+                return new NetworkError(`OpenAI Compatible endpoint not available. Please check your OPENAI_COMPATIBLE_BASE_URL: ${this.config.baseURL}`, "openai-compatible");
             }
             if (errorRecord.message.includes("API_KEY_INVALID") ||
                 errorRecord.message.includes("Invalid API key") ||
                 errorRecord.message.includes("Unauthorized")) {
-                return new Error("Invalid OpenAI Compatible API key. Please check your OPENAI_COMPATIBLE_API_KEY environment variable.");
+                return new AuthenticationError("Invalid OpenAI Compatible API key. Please check your OPENAI_COMPATIBLE_API_KEY environment variable.", "openai-compatible");
             }
             if (errorRecord.message.includes("rate limit")) {
-                return new Error("OpenAI Compatible rate limit exceeded. Please try again later.");
+                return new RateLimitError("OpenAI Compatible rate limit exceeded. Please try again later.", "openai-compatible");
             }
             if (errorRecord.message.includes("model") &&
                 (errorRecord.message.includes("not found") ||
                     errorRecord.message.includes("does not exist"))) {
-                return new Error(`Model '${this.modelName}' not available on OpenAI Compatible endpoint. ` +
-                    "Please check available models or use getAvailableModels() to see supported models.");
+                return new InvalidModelError(`Model '${this.modelName}' not available on OpenAI Compatible endpoint. ` +
+                    "Please check available models or use getAvailableModels() to see supported models.", "openai-compatible");
             }
         }
-        return new Error(`OpenAI Compatible error: ${errorRecord?.message || "Unknown error"}`);
+        return new ProviderError(`OpenAI Compatible error: ${errorRecord?.message || "Unknown error"}`, "openai-compatible");
     }
     /**
      * OpenAI Compatible endpoints support tools for compatible models

package/dist/providers/perplexity.d.ts

@@ -0,0 +1,33 @@
+import { type LanguageModel } from "ai";
+import type { AIProviderName } from "../constants/enums.js";
+import { BaseProvider } from "../core/baseProvider.js";
+import type { NeurolinkCredentials, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
+/**
+ * Perplexity Provider
+ *
+ * Sonar models with built-in web grounding. OpenAI-compatible chat
+ * completions at api.perplexity.ai. Best for queries that need fresh
+ * web context (search-augmented answers + citations).
+ *
+ * @see https://docs.perplexity.ai/api-reference/chat-completions
+ */
+export declare class PerplexityProvider extends BaseProvider {
+    private model;
+    private apiKey;
+    private baseURL;
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["perplexity"]);
+    protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
+    private executeStreamInner;
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    protected getAISDKModel(): LanguageModel;
+    protected formatProviderError(error: unknown): Error;
+    validateConfiguration(): Promise<boolean>;
+    getConfiguration(): {
+        provider: AIProviderName;
+        model: string;
+        defaultModel: string;
+        baseURL: string;
+    };
+}
+export default PerplexityProvider;

package/dist/providers/perplexity.js

@@ -0,0 +1,178 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { stepCountIs, streamText } from "ai";
+import { PerplexityModels } 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 { createPerplexityConfig, 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";
+const PERPLEXITY_DEFAULT_BASE_URL = "https://api.perplexity.ai";
+const getPerplexityApiKey = () => validateApiKey(createPerplexityConfig());
+const getDefaultPerplexityModel = () => getProviderModel("PERPLEXITY_MODEL", PerplexityModels.SONAR);
+/**
+ * Perplexity Provider
+ *
+ * Sonar models with built-in web grounding. OpenAI-compatible chat
+ * completions at api.perplexity.ai. Best for queries that need fresh
+ * web context (search-augmented answers + citations).
+ *
+ * @see https://docs.perplexity.ai/api-reference/chat-completions
+ */
+export class PerplexityProvider extends BaseProvider {
+    model;
+    apiKey;
+    baseURL;
+    constructor(modelName, sdk, _region, credentials) {
+        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
+        super(modelName, "perplexity", validatedNeurolink);
+        const overrideApiKey = credentials?.apiKey?.trim();
+        this.apiKey =
+            overrideApiKey && overrideApiKey.length > 0
+                ? overrideApiKey
+                : getPerplexityApiKey();
+        this.baseURL =
+            credentials?.baseURL ??
+                process.env.PERPLEXITY_BASE_URL ??
+                PERPLEXITY_DEFAULT_BASE_URL;
+        const perplexity = createOpenAI({
+            apiKey: this.apiKey,
+            baseURL: this.baseURL,
+            fetch: createLoggingFetch("perplexity"),
+        });
+        this.model = perplexity.chat(this.modelName);
+        logger.debug("Perplexity Provider initialized", {
+            modelName: this.modelName,
+            providerName: this.providerName,
+            baseURL: this.baseURL,
+        });
+    }
+    async executeStream(options, _analysisSchema) {
+        return withClientStreamSpan({
+            name: "neurolink.provider.stream",
+            tracer: tracers.provider,
+            attributes: {
+                [ATTR.GEN_AI_SYSTEM]: "perplexity",
+                [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);
+        // Resolve per-call credentials first, then fall back to instance-level.
+        const perCallCreds = options.credentials?.perplexity;
+        const effectiveApiKey = perCallCreds?.apiKey?.trim() || this.apiKey;
+        const effectiveBaseURL = perCallCreds?.baseURL || this.baseURL;
+        const startTime = Date.now();
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
+        try {
+            // Perplexity Sonar's tool support is limited; default to disabled when
+            // not explicitly requested by the caller. The web-grounding signal is
+            // baked into the model itself, not exposed as tool calls.
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools
+                ? options.tools || (await this.getAllTools())
+                : {};
+            const messages = await this.buildMessagesForStream(options);
+            // When per-call credentials differ from instance, build a fresh client.
+            const hasDifferentCreds = effectiveApiKey !== this.apiKey || effectiveBaseURL !== this.baseURL;
+            const model = hasDifferentCreds
+                ? createOpenAI({
+                    apiKey: effectiveApiKey,
+                    baseURL: effectiveBaseURL,
+                    fetch: createLoggingFetch("perplexity"),
+                }).chat(this.modelName)
+                : 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("[PerplexityProvider] 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: `perplexity-stream-${Date.now()}`,
+                streamingMode: true,
+            });
+            return {
+                stream: transformedStream,
+                provider: this.providerName,
+                model: this.modelName,
+                analytics: analyticsPromise,
+                metadata: { startTime, streamId: `perplexity-${Date.now()}` },
+            };
+        }
+        catch (error) {
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
+        }
+    }
+    getProviderName() {
+        return this.providerName;
+    }
+    getDefaultModel() {
+        return getDefaultPerplexityModel();
+    }
+    getAISDKModel() {
+        return this.model;
+    }
+    formatProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new NetworkError(`Request timed out: ${error.message}`, "perplexity");
+        }
+        const errorRecord = error;
+        const message = typeof errorRecord?.message === "string"
+            ? errorRecord.message
+            : "Unknown error";
+        if (message.includes("Invalid API key") ||
+            message.includes("Authentication") ||
+            message.includes("401")) {
+            return new AuthenticationError("Invalid Perplexity API key. Get one at https://www.perplexity.ai/settings/api", "perplexity");
+        }
+        if (message.includes("rate limit") || message.includes("429")) {
+            return new RateLimitError("Perplexity rate limit exceeded. Back off and retry.", "perplexity");
+        }
+        if (message.includes("model_not_found") || message.includes("404")) {
+            return new InvalidModelError(`Perplexity model '${this.modelName}' not found. Use sonar, sonar-pro, sonar-reasoning, sonar-reasoning-pro, or sonar-deep-research.`, "perplexity");
+        }
+        return new ProviderError(`Perplexity error: ${message}`, "perplexity");
+    }
+    async validateConfiguration() {
+        return typeof this.apiKey === "string" && this.apiKey.trim().length > 0;
+    }
+    getConfiguration() {
+        return {
+            provider: this.providerName,
+            model: this.modelName,
+            defaultModel: getDefaultPerplexityModel(),
+            baseURL: this.baseURL,
+        };
+    }
+}
+export default PerplexityProvider;

package/dist/providers/recraft.d.ts

@@ -0,0 +1,34 @@
+import type { LanguageModel } from "ai";
+import type { AIProviderName } from "../constants/enums.js";
+import { BaseProvider } from "../core/baseProvider.js";
+import type { EnhancedGenerateResult, NeurolinkCredentials, StreamOptions, StreamResult, TextGenerationOptions, ValidationSchema } from "../types/index.js";
+/**
+ * Recraft Provider — image generation with vector / illustration focus.
+ *
+ * Hits external.api.recraft.ai/v1/images/generations (OpenAI-compat
+ * shape). Returns either url or b64_json; we convert URL → base64 for
+ * the uniform imageOutput contract.
+ *
+ * @see https://www.recraft.ai/docs
+ */
+export declare class RecraftProvider extends BaseProvider {
+    private readonly apiKey;
+    private readonly baseURL;
+    private readonly proxyFetch;
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["recraft"]);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    supportsTools(): boolean;
+    protected getAISDKModel(): LanguageModel;
+    protected executeStream(_options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
+    protected formatProviderError(error: unknown): Error;
+    protected executeImageGeneration(options: TextGenerationOptions): Promise<EnhancedGenerateResult>;
+    validateConfiguration(): Promise<boolean>;
+    getConfiguration(): {
+        provider: AIProviderName;
+        model: string;
+        defaultModel: string;
+        baseURL: string;
+    };
+}
+export default RecraftProvider;

package/dist/providers/recraft.js

@@ -0,0 +1,196 @@
+import { RecraftModels } from "../constants/enums.js";
+import { BaseProvider } from "../core/baseProvider.js";
+import { isNeuroLink } from "../neurolink.js";
+import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { AuthenticationError, InvalidModelError, ProviderError, RateLimitError, } from "../types/index.js";
+import { logger } from "../utils/logger.js";
+import { createRecraftConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
+import { MAX_IMAGE_BYTES, readBoundedBuffer } from "../utils/sizeGuard.js";
+import { assertSafeUrl } from "../utils/ssrfGuard.js";
+const RECRAFT_DEFAULT_BASE_URL = "https://external.api.recraft.ai/v1";
+const REQUEST_TIMEOUT_MS = 120_000;
+const getRecraftApiKey = () => validateApiKey(createRecraftConfig());
+const getDefaultRecraftModel = () => getProviderModel("RECRAFT_MODEL", RecraftModels.RECRAFT_V3);
+/**
+ * Recraft Provider — image generation with vector / illustration focus.
+ *
+ * Hits external.api.recraft.ai/v1/images/generations (OpenAI-compat
+ * shape). Returns either url or b64_json; we convert URL → base64 for
+ * the uniform imageOutput contract.
+ *
+ * @see https://www.recraft.ai/docs
+ */
+export class RecraftProvider extends BaseProvider {
+    apiKey;
+    baseURL;
+    proxyFetch;
+    constructor(modelName, sdk, _region, credentials) {
+        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
+        super(modelName, "recraft", validatedNeurolink);
+        const overrideKey = credentials?.apiKey?.trim();
+        this.apiKey =
+            overrideKey && overrideKey.length > 0 ? overrideKey : getRecraftApiKey();
+        this.baseURL =
+            credentials?.baseURL ??
+                process.env.RECRAFT_BASE_URL ??
+                RECRAFT_DEFAULT_BASE_URL;
+        this.proxyFetch = createProxyFetch();
+        logger.debug("Recraft Provider initialized (image-gen only)", {
+            modelName: this.modelName,
+            baseURL: this.baseURL,
+        });
+    }
+    getProviderName() {
+        return this.providerName;
+    }
+    getDefaultModel() {
+        return getDefaultRecraftModel();
+    }
+    supportsTools() {
+        return false;
+    }
+    getAISDKModel() {
+        throw new Error("Recraft is an image-generation-only provider; chat completions are not available.");
+    }
+    async executeStream(_options, _analysisSchema) {
+        throw new Error("Recraft is an image-generation-only provider; streaming chat is not available.");
+    }
+    formatProviderError(error) {
+        const message = error instanceof Error
+            ? error.message
+            : typeof error === "string"
+                ? error
+                : "Unknown error";
+        if (message.includes("401") ||
+            message.toLowerCase().includes("unauthorized")) {
+            return new AuthenticationError("Invalid Recraft API key. Get one at https://www.recraft.ai/api", "recraft");
+        }
+        if (message.includes("429") ||
+            message.toLowerCase().includes("rate limit")) {
+            return new RateLimitError("Recraft rate limit exceeded. Back off and retry.", "recraft");
+        }
+        if (message.includes("404") || message.includes("model_not_found")) {
+            return new InvalidModelError(`Recraft model '${this.modelName}' not found. Use recraftv3, recraftv3-svg, or recraftv2.`, "recraft");
+        }
+        return new ProviderError(`Recraft error: ${message}`, "recraft");
+    }
+    async executeImageGeneration(options) {
+        const startTime = Date.now();
+        // Resolve per-call credentials first, then fall back to instance-level.
+        const perCallCreds = options.credentials?.recraft;
+        const effectiveApiKey = perCallCreds?.apiKey?.trim() || this.apiKey;
+        const effectiveBaseURL = perCallCreds?.baseURL || this.baseURL;
+        const prompt = options.prompt ?? options.input?.text ?? "";
+        if (!prompt.trim()) {
+            throw new Error("Recraft image generation requires a prompt (input.text or prompt)");
+        }
+        const extras = options;
+        const body = {
+            model: options.model ?? this.modelName,
+            prompt,
+            n: 1,
+            response_format: "b64_json",
+        };
+        if (extras.negativePrompt) {
+            body.negative_prompt = extras.negativePrompt;
+        }
+        if (extras.style) {
+            body.style = extras.style;
+        }
+        if (extras.styleId) {
+            body.style_id = extras.styleId;
+        }
+        if (extras.size) {
+            body.size = extras.size;
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        let response;
+        try {
+            response = await this.proxyFetch(`${effectiveBaseURL}/images/generations`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${effectiveApiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                throw this.formatProviderError(new Error(`Recraft image-gen request timed out after ${REQUEST_TIMEOUT_MS / 1000}s`));
+            }
+            throw this.formatProviderError(err);
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            throw this.formatProviderError(new Error(`Recraft image-gen failed: ${response.status} — ${text}`));
+        }
+        const data = (await response.json());
+        const entry = data.data?.[0];
+        if (!entry) {
+            throw new Error("Recraft returned no image data");
+        }
+        let base64;
+        if (entry.b64_json) {
+            base64 = entry.b64_json;
+        }
+        else if (entry.url) {
+            // Guard the API-returned URL before fetching (provider-returned URLs
+            // carry the same SSRF risk as caller-supplied ones).
+            await assertSafeUrl(entry.url);
+            // Fallback URL download — apply a 60s timeout so it cannot hang indefinitely.
+            const dlController = new AbortController();
+            const dlTimeoutId = setTimeout(() => dlController.abort(), 60_000);
+            let dl;
+            try {
+                dl = await this.proxyFetch(entry.url, { signal: dlController.signal });
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === "AbortError") {
+                    throw new Error("Recraft image download timed out after 60s", {
+                        cause: err,
+                    });
+                }
+                throw err;
+            }
+            finally {
+                clearTimeout(dlTimeoutId);
+            }
+            if (!dl.ok) {
+                throw new Error(`Failed to download Recraft image: ${dl.status}`);
+            }
+            const dlBuf = await readBoundedBuffer(dl, MAX_IMAGE_BYTES, "Recraft image");
+            base64 = dlBuf.toString("base64");
+        }
+        else {
+            throw new Error("Recraft response missing both b64_json and url");
+        }
+        const generationTimeMs = Date.now() - startTime;
+        logger.info(`[RecraftProvider] Generated image (${base64.length} base64 chars) in ${generationTimeMs}ms — model ${this.modelName}`);
+        return {
+            content: prompt,
+            provider: this.providerName,
+            model: this.modelName,
+            // output: 1000 = sentinel for per-image pricing (see pricing.ts)
+            usage: { input: 0, output: 1000, total: 1000 },
+            imageOutput: { base64 },
+        };
+    }
+    async validateConfiguration() {
+        return typeof this.apiKey === "string" && this.apiKey.trim().length > 0;
+    }
+    getConfiguration() {
+        return {
+            provider: this.providerName,
+            model: this.modelName,
+            defaultModel: getDefaultRecraftModel(),
+            baseURL: this.baseURL,
+        };
+    }
+}
+export default RecraftProvider;