@juspay/neurolink 9.64.0 → 9.65.0

package/dist/lib/providers/groq.js

@@ -0,0 +1,181 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { stepCountIs, streamText } from "ai";
+import { GroqModels } 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, ProviderError, RateLimitError, } from "../types/index.js";
+import { logger } from "../utils/logger.js";
+import { createGroqConfig, 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 GROQ_DEFAULT_BASE_URL = "https://api.groq.com/openai/v1";
+const getGroqApiKey = () => validateApiKey(createGroqConfig());
+const getDefaultGroqModel = () => getProviderModel("GROQ_MODEL", GroqModels.LLAMA_3_3_70B_VERSATILE);
+/**
+ * Groq Provider
+ *
+ * Sub-100ms inference of Llama / Mistral / Gemma at api.groq.com/openai/v1
+ * (OpenAI-compatible). Best for low-latency tier; trade-off vs other open
+ * model hosts is throughput latency, not quality.
+ *
+ * @see https://console.groq.com/docs/quickstart
+ */
+export class GroqProvider extends BaseProvider {
+    model;
+    apiKey;
+    baseURL;
+    constructor(modelName, sdk, _region, credentials) {
+        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
+        super(modelName, "groq", validatedNeurolink);
+        const overrideApiKey = credentials?.apiKey?.trim();
+        this.apiKey =
+            overrideApiKey && overrideApiKey.length > 0
+                ? overrideApiKey
+                : getGroqApiKey();
+        this.baseURL =
+            credentials?.baseURL ??
+                process.env.GROQ_BASE_URL ??
+                GROQ_DEFAULT_BASE_URL;
+        const groq = createOpenAI({
+            apiKey: this.apiKey,
+            baseURL: this.baseURL,
+            fetch: createLoggingFetch("groq"),
+        });
+        this.model = groq.chat(this.modelName);
+        logger.debug("Groq 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]: "groq",
+                [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?.groq;
+        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 {
+            // Use the canonical BaseProvider helper: merges base tools (MCP/built-in)
+            // with user-provided tools (RAG, etc.) and applies per-call filtering.
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = await this.getToolsForStream(options);
+            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("groq"),
+                }).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("[GroqProvider] 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: `groq-stream-${Date.now()}`,
+                streamingMode: true,
+            });
+            return {
+                stream: transformedStream,
+                provider: this.providerName,
+                model: this.modelName,
+                analytics: analyticsPromise,
+                metadata: { startTime, streamId: `groq-${Date.now()}` },
+            };
+        }
+        catch (error) {
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
+        }
+    }
+    getProviderName() {
+        return this.providerName;
+    }
+    getDefaultModel() {
+        return getDefaultGroqModel();
+    }
+    getAISDKModel() {
+        return this.model;
+    }
+    formatProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new ProviderError(`Groq request timed out: ${error.message}`, "groq");
+        }
+        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") ||
+            message.includes("invalid_api_key")) {
+            return new AuthenticationError("Invalid Groq API key. Check GROQ_API_KEY. Get one at https://console.groq.com/keys", "groq");
+        }
+        if (message.includes("rate limit") || message.includes("429")) {
+            return new RateLimitError("Groq rate limit exceeded. Free tier limits are tight; consider upgrading or backing off.", "groq");
+        }
+        if (message.includes("model_not_found") ||
+            message.includes("404") ||
+            message.includes("model_decommissioned")) {
+            return new InvalidModelError(message.includes("model_decommissioned")
+                ? `Groq model '${this.modelName}' was decommissioned. Pick a current model from https://console.groq.com/docs/models.`
+                : `Groq model '${this.modelName}' not found. See https://console.groq.com/docs/models for the current catalog.`, "groq");
+        }
+        return new ProviderError(`Groq error: ${message}`, "groq");
+    }
+    async validateConfiguration() {
+        return typeof this.apiKey === "string" && this.apiKey.trim().length > 0;
+    }
+    getConfiguration() {
+        return {
+            provider: this.providerName,
+            model: this.modelName,
+            defaultModel: getDefaultGroqModel(),
+            baseURL: this.baseURL,
+        };
+    }
+}
+export default GroqProvider;
+//# sourceMappingURL=groq.js.map

package/dist/lib/providers/huggingFace.js

@@ -3,6 +3,7 @@ import { NoOutputGeneratedError, stepCountIs, streamText, } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.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";
@@ -215,7 +216,7 @@ export class HuggingFaceProvider extends BaseProvider {
         // If model doesn't support tools, disable them completely
         if (!modelSupportsTools) {
             return {
-                prompt: options.input.text,
+                prompt: options.input.text ?? "",
                 system: options.systemPrompt,
                 tools: undefined,
                 toolChoice: undefined,
@@ -228,7 +229,7 @@ export class HuggingFaceProvider extends BaseProvider {
             ? this.formatToolsForHuggingFace(options.tools)
             : undefined;
         return {
-            prompt: options.input.text,
+            prompt: options.input.text ?? "",
             system: enhancedSystemPrompt,
             tools: formattedTools,
             toolChoice: formattedTools ? (options.toolChoice ?? "auto") : undefined,
@@ -305,7 +306,7 @@ Available tools will be provided in the function calling format. Use them when t
      */
     formatProviderError(error) {
         if (error instanceof TimeoutError) {
-            return new Error(`HuggingFace request timed out: ${error.message}`);
+            return new NetworkError(`Request timed out: ${error.message}`, "huggingface");
         }
         const errorObj = error;
         const message = errorObj?.message && typeof errorObj.message === "string"
@@ -314,18 +315,18 @@ Available tools will be provided in the function calling format. Use them when t
         // Enhanced error messages with tool calling context
         if (message.includes("API_TOKEN_INVALID") ||
             message.includes("Invalid token")) {
-            return new Error("❌ Invalid HuggingFace API token. Please check your HUGGINGFACE_API_KEY environment variable.");
+            return new AuthenticationError("Invalid HuggingFace API token. Please check your HUGGINGFACE_API_KEY environment variable.", "huggingface");
         }
         if (message.includes("rate limit")) {
-            return new Error("❌ HuggingFace rate limit exceeded. Consider using a paid plan or try again later.");
+            return new RateLimitError("HuggingFace rate limit exceeded. Consider using a paid plan or try again later.", "huggingface");
         }
         if (message.includes("model") && message.includes("not found")) {
-            return new Error(`❌ HuggingFace model '${this.modelName}' not found.\n\nSuggestions:\n1. Check model name spelling\n2. Ensure model exists on HuggingFace Hub\n3. For tool calling, use: Llama-3.1-8B-Instruct, Hermes-3-Llama-3.2-3B, or CodeLlama-34b-Instruct-hf`);
+            return new InvalidModelError(`HuggingFace model '${this.modelName}' not found.\n\nSuggestions:\n1. Check model name spelling\n2. Ensure model exists on HuggingFace Hub\n3. For tool calling, use: Llama-3.1-8B-Instruct, Hermes-3-Llama-3.2-3B, or CodeLlama-34b-Instruct-hf`, "huggingface");
         }
         if (message.includes("function") || message.includes("tool")) {
-            return new Error(`❌ HuggingFace tool calling error: ${message}\n\nNotes:\n1. Ensure you're using a tool-capable model (Llama-3.1+, Hermes-3+, CodeLlama)\n2. Check that your model supports function calling\n3. Verify tool schema format is correct`);
+            return new ProviderError(`HuggingFace tool calling error: ${message}\n\nNotes:\n1. Ensure you're using a tool-capable model (Llama-3.1+, Hermes-3+, CodeLlama)\n2. Check that your model supports function calling\n3. Verify tool schema format is correct`, "huggingface");
         }
-        return new Error(`❌ HuggingFace Provider Error: ${message}`);
+        return new ProviderError(`HuggingFace Provider Error: ${message}`, "huggingface");
     }
     getProviderName() {
         return "huggingface";

package/dist/lib/providers/ideogram.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";
+/**
+ * Ideogram Provider — direct image generation with strong typography.
+ *
+ * Hits api.ideogram.ai/api/v1/ideogram-v3/generate. Returns image URLs;
+ * we download and surface as base64 to keep the imageOutput contract
+ * uniform across image-gen providers.
+ *
+ * @see https://developer.ideogram.ai/api-reference/api-reference/post-v-1-ideogram-v-3-generate
+ */
+export declare class IdeogramProvider extends BaseProvider {
+    private readonly apiKey;
+    private readonly baseURL;
+    private readonly proxyFetch;
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["ideogram"]);
+    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 IdeogramProvider;

package/dist/lib/providers/ideogram.js

@@ -0,0 +1,184 @@
+import { IdeogramModels } from "../constants/enums.js";
+import { BaseProvider } from "../core/baseProvider.js";
+import { isNeuroLink } from "../neurolink.js";
+import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { AuthenticationError, ProviderError, RateLimitError, } from "../types/index.js";
+import { logger } from "../utils/logger.js";
+import { createIdeogramConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
+const IDEOGRAM_DEFAULT_BASE_URL = "https://api.ideogram.ai";
+const REQUEST_TIMEOUT_MS = 120_000;
+const getIdeogramApiKey = () => validateApiKey(createIdeogramConfig());
+const getDefaultIdeogramModel = () => getProviderModel("IDEOGRAM_MODEL", IdeogramModels.IDEOGRAM_V3);
+/**
+ * Ideogram Provider — direct image generation with strong typography.
+ *
+ * Hits api.ideogram.ai/api/v1/ideogram-v3/generate. Returns image URLs;
+ * we download and surface as base64 to keep the imageOutput contract
+ * uniform across image-gen providers.
+ *
+ * @see https://developer.ideogram.ai/api-reference/api-reference/post-v-1-ideogram-v-3-generate
+ */
+export class IdeogramProvider extends BaseProvider {
+    apiKey;
+    baseURL;
+    proxyFetch;
+    constructor(modelName, sdk, _region, credentials) {
+        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
+        super(modelName, "ideogram", validatedNeurolink);
+        const overrideKey = credentials?.apiKey?.trim();
+        this.apiKey =
+            overrideKey && overrideKey.length > 0 ? overrideKey : getIdeogramApiKey();
+        this.baseURL =
+            credentials?.baseURL ??
+                process.env.IDEOGRAM_BASE_URL ??
+                IDEOGRAM_DEFAULT_BASE_URL;
+        this.proxyFetch = createProxyFetch();
+        logger.debug("Ideogram Provider initialized (image-gen only)", {
+            modelName: this.modelName,
+            baseURL: this.baseURL,
+        });
+    }
+    getProviderName() {
+        return this.providerName;
+    }
+    getDefaultModel() {
+        return getDefaultIdeogramModel();
+    }
+    supportsTools() {
+        return false;
+    }
+    getAISDKModel() {
+        throw new Error("Ideogram is an image-generation-only provider; chat completions are not available.");
+    }
+    async executeStream(_options, _analysisSchema) {
+        throw new Error("Ideogram 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 Ideogram API key. Get one at https://developer.ideogram.ai/", "ideogram");
+        }
+        if (message.includes("429") ||
+            message.toLowerCase().includes("rate limit")) {
+            return new RateLimitError("Ideogram rate limit exceeded. Back off and retry.", "ideogram");
+        }
+        if (message.includes("safety") || message.includes("is_image_safe")) {
+            return new ProviderError("Ideogram declined the request due to safety filters. Adjust the prompt and retry.", "ideogram");
+        }
+        return new ProviderError(`Ideogram error: ${message}`, "ideogram");
+    }
+    async executeImageGeneration(options) {
+        const startTime = Date.now();
+        // Resolve per-call credentials first, then fall back to instance-level.
+        const perCallCreds = options.credentials?.ideogram;
+        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("Ideogram image generation requires a prompt (input.text or prompt)");
+        }
+        const extras = options;
+        const body = {
+            prompt,
+            model: this.modelName,
+            magic_prompt: extras.magicPrompt ?? "AUTO",
+        };
+        if (extras.aspectRatio) {
+            body.aspect_ratio = extras.aspectRatio;
+        }
+        if (extras.negativePrompt) {
+            body.negative_prompt = extras.negativePrompt;
+        }
+        if (extras.seed !== undefined) {
+            body.seed = extras.seed;
+        }
+        if (extras.style) {
+            body.style_type = extras.style;
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        let response;
+        try {
+            response = await this.proxyFetch(`${effectiveBaseURL}/v1/ideogram-v3/generate`, {
+                method: "POST",
+                headers: {
+                    "Api-Key": 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(`Ideogram 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(`Ideogram image-gen failed: ${response.status} — ${text}`));
+        }
+        const data = (await response.json());
+        const url = data.data?.[0]?.url;
+        if (!url) {
+            throw new Error("Ideogram returned no image URL");
+        }
+        // Download the image and convert to base64 to match the imageOutput
+        // contract used by other image-gen providers. Apply a 60s timeout so the
+        // download cannot hang indefinitely.
+        const dlController = new AbortController();
+        const dlTimeoutId = setTimeout(() => dlController.abort(), 60_000);
+        let dl;
+        try {
+            dl = await this.proxyFetch(url, { signal: dlController.signal });
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                throw new Error("Ideogram image download timed out after 60s", {
+                    cause: err,
+                });
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(dlTimeoutId);
+        }
+        if (!dl.ok) {
+            throw new Error(`Failed to download Ideogram image: ${dl.status}`);
+        }
+        const buffer = Buffer.from(await dl.arrayBuffer());
+        const base64 = buffer.toString("base64");
+        const generationTimeMs = Date.now() - startTime;
+        logger.info(`[IdeogramProvider] Generated image (${buffer.length} bytes) 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: getDefaultIdeogramModel(),
+            baseURL: this.baseURL,
+        };
+    }
+}
+export default IdeogramProvider;
+//# sourceMappingURL=ideogram.js.map

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

@@ -18,3 +18,16 @@ export { DeepSeekProvider as DeepSeek } from "./deepseek.js";
 export { NvidiaNimProvider as NvidiaNim } from "./nvidiaNim.js";
 export { LMStudioProvider as LMStudio } from "./lmStudio.js";
 export { LlamaCppProvider as LlamaCpp } from "./llamaCpp.js";
+export { XaiProvider as Xai } from "./xai.js";
+export { GroqProvider as Groq } from "./groq.js";
+export { CohereProvider as Cohere } from "./cohere.js";
+export { TogetherAIProvider as TogetherAI } from "./togetherAi.js";
+export { FireworksProvider as Fireworks } from "./fireworks.js";
+export { PerplexityProvider as Perplexity } from "./perplexity.js";
+export { CloudflareProvider as Cloudflare } from "./cloudflare.js";
+export { VoyageProvider as Voyage } from "./voyage.js";
+export { JinaProvider as Jina } from "./jina.js";
+export { StabilityProvider as Stability } from "./stability.js";
+export { IdeogramProvider as Ideogram } from "./ideogram.js";
+export { RecraftProvider as Recraft } from "./recraft.js";
+export { ReplicateProvider as Replicate } from "./replicate.js";

package/dist/lib/providers/index.js

@@ -18,4 +18,17 @@ export { DeepSeekProvider as DeepSeek } from "./deepseek.js";
 export { NvidiaNimProvider as NvidiaNim } from "./nvidiaNim.js";
 export { LMStudioProvider as LMStudio } from "./lmStudio.js";
 export { LlamaCppProvider as LlamaCpp } from "./llamaCpp.js";
+export { XaiProvider as Xai } from "./xai.js";
+export { GroqProvider as Groq } from "./groq.js";
+export { CohereProvider as Cohere } from "./cohere.js";
+export { TogetherAIProvider as TogetherAI } from "./togetherAi.js";
+export { FireworksProvider as Fireworks } from "./fireworks.js";
+export { PerplexityProvider as Perplexity } from "./perplexity.js";
+export { CloudflareProvider as Cloudflare } from "./cloudflare.js";
+export { VoyageProvider as Voyage } from "./voyage.js";
+export { JinaProvider as Jina } from "./jina.js";
+export { StabilityProvider as Stability } from "./stability.js";
+export { IdeogramProvider as Ideogram } from "./ideogram.js";
+export { RecraftProvider as Recraft } from "./recraft.js";
+export { ReplicateProvider as Replicate } from "./replicate.js";
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,59 @@
+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";
+/**
+ * Jina AI Provider — embeddings + reranking.
+ *
+ * Native API at api.jina.ai/v1. Chat / streaming / tool calling are not
+ * supported. Use `embed()` / `embedMany()` for embeddings, or call
+ * `rerank()` directly for retrieval reranking (Jina's strength).
+ *
+ * @see https://jina.ai/embeddings/
+ */
+export declare class JinaProvider extends BaseProvider {
+    private readonly apiKey;
+    private readonly baseURL;
+    private readonly proxyFetch;
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["jina"]);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    supportsTools(): boolean;
+    protected getDefaultEmbeddingModel(): string | undefined;
+    protected getAISDKModel(): LanguageModel;
+    protected executeStream(_options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
+    protected formatProviderError(error: unknown): Error;
+    embed(text: string, modelName?: string): Promise<number[]>;
+    embedMany(texts: string[], modelName?: string): Promise<number[][]>;
+    /**
+     * Rerank a list of documents against a query.
+     *
+     * Returns the documents sorted by relevance (highest first), with
+     * score and original index preserved so callers can map back.
+     *
+     * Note: not exposed on `BaseProvider` — accessed by casting to
+     * `JinaProvider` or via the dedicated rerank route on the public API
+     * (`POST /api/agent/rerank` in the server module, when added).
+     *
+     * Per-call credentials can be supplied via `options.credentials?.jina`,
+     * overriding the instance-level credentials for this request only.
+     */
+    rerank(query: string, documents: string[], options?: {
+        model?: string;
+        topN?: number;
+        credentials?: NeurolinkCredentials["jina"];
+    }): Promise<{
+        index: number;
+        score: number;
+        document: string;
+    }[]>;
+    private callEmbeddings;
+    validateConfiguration(): Promise<boolean>;
+    getConfiguration(): {
+        provider: AIProviderName;
+        model: string;
+        defaultModel: string;
+        baseURL: string;
+    };
+}
+export default JinaProvider;