@juspay/neurolink 9.64.0 → 9.65.0

package/dist/lib/providers/stability.js

@@ -0,0 +1,191 @@
+import { StabilityModels } 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 { getProviderModel } from "../utils/providerConfig.js";
+const STABILITY_DEFAULT_BASE_URL = "https://api.stability.ai";
+const REQUEST_TIMEOUT_MS = 120_000;
+/**
+ * Returns the Stability AI API key from env vars, or `undefined` when none
+ * is set.  The constructor stores `undefined` instead of throwing so that
+ * callers who only supply per-call credentials via `options.credentials` can
+ * still instantiate the provider.  Validation is deferred to the actual
+ * call site inside `executeImageGeneration`.
+ */
+const getStabilityApiKeyOptional = () => (process.env.STABILITY_API_KEY ??
+    process.env.STABILITY_AI_API_KEY ??
+    "").trim() || undefined;
+const getDefaultStabilityModel = () => getProviderModel("STABILITY_MODEL", StabilityModels.STABLE_IMAGE_ULTRA);
+/**
+ * Stability AI Provider — direct image generation.
+ *
+ * Hits api.stability.ai/v2beta/stable-image/generate/{model}. Returns
+ * base64 PNG. No chat / streaming / tool calling.
+ *
+ * The constructor no longer throws when `STABILITY_API_KEY` is absent so
+ * that per-call credentials (passed via `options.credentials.stability`) can
+ * be used without requiring a global env var at startup.
+ *
+ * @see https://platform.stability.ai/docs/api-reference
+ */
+export class StabilityProvider extends BaseProvider {
+    apiKey;
+    baseURL;
+    proxyFetch;
+    constructor(modelName, sdk, _region, credentials) {
+        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
+        super(modelName, "stability", validatedNeurolink);
+        const overrideKey = credentials?.apiKey?.trim();
+        this.apiKey =
+            overrideKey && overrideKey.length > 0
+                ? overrideKey
+                : getStabilityApiKeyOptional();
+        this.baseURL =
+            credentials?.baseURL ??
+                process.env.STABILITY_BASE_URL ??
+                STABILITY_DEFAULT_BASE_URL;
+        this.proxyFetch = createProxyFetch();
+        logger.debug("Stability AI Provider initialized (image-gen only)", {
+            modelName: this.modelName,
+            baseURL: this.baseURL,
+        });
+    }
+    getProviderName() {
+        return this.providerName;
+    }
+    getDefaultModel() {
+        return getDefaultStabilityModel();
+    }
+    supportsTools() {
+        return false;
+    }
+    getAISDKModel() {
+        throw new Error("Stability AI is an image-generation-only provider; chat completions are not available.");
+    }
+    async executeStream(_options, _analysisSchema) {
+        throw new Error("Stability AI is an image-generation-only provider; streaming chat is not available. Use generate({output:{format:'binary'}}) with a Stable Image / SD 3.5 model.");
+    }
+    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 Stability AI API key. Get one at https://platform.stability.ai/account/keys", "stability");
+        }
+        if (message.includes("429") ||
+            message.toLowerCase().includes("rate limit")) {
+            return new RateLimitError("Stability AI rate limit exceeded. Back off and retry.", "stability");
+        }
+        if (message.includes("content_filtered") ||
+            message.includes("CONTENT_FILTERED")) {
+            return new ProviderError("Stability AI declined the request due to content policy. Adjust the prompt and retry.", "stability");
+        }
+        if (message.includes("404")) {
+            return new InvalidModelError(`Stability AI model '${this.modelName}' not found. Use stable-image-ultra, stable-image-core, sd3.5-large, sd3.5-large-turbo, or sd3.5-medium.`, "stability");
+        }
+        return new ProviderError(`Stability AI error: ${message}`, "stability");
+    }
+    async executeImageGeneration(options) {
+        const startTime = Date.now();
+        // Resolve per-call credentials first, then fall back to instance-level.
+        const perCallCreds = options.credentials?.stability;
+        const resolvedApiKey = perCallCreds?.apiKey?.trim() || this.apiKey;
+        if (!resolvedApiKey) {
+            throw new Error("Stability AI API key is required. Set STABILITY_API_KEY or pass credentials.stability.apiKey per-call.");
+        }
+        const effectiveApiKey = resolvedApiKey;
+        const effectiveBaseURL = perCallCreds?.baseURL || this.baseURL;
+        const prompt = options.prompt ?? options.input?.text ?? "";
+        if (!prompt.trim()) {
+            throw new Error("Stability AI image generation requires a prompt (input.text or prompt)");
+        }
+        // Stability's URL slugs are `ultra` / `core` / `sd3` — not the user-facing
+        // `stable-image-ultra` / `stable-image-core` model identifiers we expose
+        // via StabilityModels. Map both shapes onto the actual path here.
+        const modelPath = this.modelName.startsWith("sd3.5-")
+            ? "sd3"
+            : this.modelName === "stable-image-ultra"
+                ? "ultra"
+                : this.modelName === "stable-image-core"
+                    ? "core"
+                    : this.modelName;
+        // Image-gen extras live in `output` / image-specific fields. Cast
+        // to a permissive shape so we can read aspectRatio / negativePrompt
+        // / seed without polluting TextGenerationOptions.
+        const extras = options;
+        const form = new FormData();
+        form.append("prompt", prompt);
+        form.append("output_format", "png");
+        if (extras.aspectRatio) {
+            form.append("aspect_ratio", String(extras.aspectRatio));
+        }
+        if (extras.negativePrompt) {
+            form.append("negative_prompt", extras.negativePrompt);
+        }
+        if (this.modelName.startsWith("sd3.5-")) {
+            form.append("model", this.modelName);
+        }
+        if (extras.seed !== undefined) {
+            form.append("seed", String(extras.seed));
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        let response;
+        try {
+            response = await this.proxyFetch(`${effectiveBaseURL}/v2beta/stable-image/generate/${modelPath}`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${effectiveApiKey}`,
+                    Accept: "application/json", // base64 in body
+                },
+                body: form,
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === "AbortError") {
+                throw this.formatProviderError(new Error(`Stability 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(`Stability image-gen failed: ${response.status} — ${text}`));
+        }
+        const data = (await response.json());
+        if (!data.image) {
+            throw new Error(`Stability AI returned no image (finish_reason: ${data.finish_reason ?? "unknown"})`);
+        }
+        const generationTimeMs = Date.now() - startTime;
+        logger.info(`[StabilityProvider] Generated image (${data.image.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: data.image },
+        };
+    }
+    async validateConfiguration() {
+        return this.apiKey !== undefined && this.apiKey.trim().length > 0;
+    }
+    getConfiguration() {
+        return {
+            provider: this.providerName,
+            model: this.modelName,
+            defaultModel: getDefaultStabilityModel(),
+            baseURL: this.baseURL,
+        };
+    }
+}
+export default StabilityProvider;
+//# sourceMappingURL=stability.js.map

package/dist/lib/providers/togetherAi.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";
+/**
+ * Together AI Provider
+ *
+ * Hosted open-model gateway at api.together.xyz/v1 (OpenAI-compatible).
+ * Llama / Mistral / Qwen / DeepSeek / Gemma / WizardLM available
+ * server-less; pass any catalog id via `--model`.
+ *
+ * @see https://docs.together.ai/docs/openai-api-compatibility
+ */
+export declare class TogetherAIProvider extends BaseProvider {
+    private model;
+    private apiKey;
+    private baseURL;
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["together"]);
+    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 TogetherAIProvider;

package/dist/lib/providers/togetherAi.js

@@ -0,0 +1,176 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { stepCountIs, streamText } from "ai";
+import { TogetherAIModels } 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 { createTogetherAIConfig, 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 TOGETHER_DEFAULT_BASE_URL = "https://api.together.xyz/v1";
+const getTogetherApiKey = () => validateApiKey(createTogetherAIConfig());
+const getDefaultTogetherModel = () => getProviderModel("TOGETHER_MODEL", TogetherAIModels.LLAMA_3_3_70B_INSTRUCT_TURBO);
+/**
+ * Together AI Provider
+ *
+ * Hosted open-model gateway at api.together.xyz/v1 (OpenAI-compatible).
+ * Llama / Mistral / Qwen / DeepSeek / Gemma / WizardLM available
+ * server-less; pass any catalog id via `--model`.
+ *
+ * @see https://docs.together.ai/docs/openai-api-compatibility
+ */
+export class TogetherAIProvider extends BaseProvider {
+    model;
+    apiKey;
+    baseURL;
+    constructor(modelName, sdk, _region, credentials) {
+        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
+        super(modelName, "together-ai", validatedNeurolink);
+        const overrideApiKey = credentials?.apiKey?.trim();
+        this.apiKey =
+            overrideApiKey && overrideApiKey.length > 0
+                ? overrideApiKey
+                : getTogetherApiKey();
+        this.baseURL =
+            credentials?.baseURL ??
+                process.env.TOGETHER_BASE_URL ??
+                TOGETHER_DEFAULT_BASE_URL;
+        const together = createOpenAI({
+            apiKey: this.apiKey,
+            baseURL: this.baseURL,
+            fetch: createLoggingFetch("together-ai"),
+        });
+        this.model = together.chat(this.modelName);
+        logger.debug("Together AI 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]: "together-ai",
+                [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?.together;
+        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 {
+            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("together-ai"),
+                }).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("[TogetherAIProvider] 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: `together-stream-${Date.now()}`,
+                streamingMode: true,
+            });
+            return {
+                stream: transformedStream,
+                provider: this.providerName,
+                model: this.modelName,
+                analytics: analyticsPromise,
+                metadata: { startTime, streamId: `together-${Date.now()}` },
+            };
+        }
+        catch (error) {
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
+        }
+    }
+    getProviderName() {
+        return this.providerName;
+    }
+    getDefaultModel() {
+        return getDefaultTogetherModel();
+    }
+    getAISDKModel() {
+        return this.model;
+    }
+    formatProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new NetworkError(`Request timed out: ${error.message}`, "together-ai");
+        }
+        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 Together AI API key. Get one at https://api.together.xyz/settings/api-keys", "together-ai");
+        }
+        if (message.includes("rate limit") || message.includes("429")) {
+            return new RateLimitError("Together AI rate limit exceeded. Back off and retry.", "together-ai");
+        }
+        if (message.includes("model_not_found") || message.includes("404")) {
+            return new InvalidModelError(`Together AI model '${this.modelName}' not found. Browse the catalog at https://api.together.xyz/models`, "together-ai");
+        }
+        return new ProviderError(`Together AI error: ${message}`, "together-ai");
+    }
+    async validateConfiguration() {
+        return typeof this.apiKey === "string" && this.apiKey.trim().length > 0;
+    }
+    getConfiguration() {
+        return {
+            provider: this.providerName,
+            model: this.modelName,
+            defaultModel: getDefaultTogetherModel(),
+            baseURL: this.baseURL,
+        };
+    }
+}
+export default TogetherAIProvider;
+//# sourceMappingURL=togetherAi.js.map

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

@@ -0,0 +1,47 @@
+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";
+/**
+ * Voyage AI Provider — embedding-only.
+ *
+ * Top-tier RAG embedder. Native API at api.voyageai.com/v1/embeddings.
+ * Chat / streaming / tool calling are not supported — `executeStream` and
+ * `getAISDKModel` throw a friendly error so callers get an actionable
+ * message instead of a runtime crash deep in the streaming layer.
+ *
+ * @see https://docs.voyageai.com/docs/embeddings
+ */
+export declare class VoyageProvider extends BaseProvider {
+    private readonly apiKey;
+    private readonly baseURL;
+    private readonly proxyFetch;
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["voyage"]);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    supportsTools(): boolean;
+    protected getDefaultEmbeddingModel(): string | undefined;
+    /**
+     * Voyage is embedding-only — chat models do not exist on this endpoint.
+     * Caller surface stays consistent: returns an `AbortError`-shaped failure
+     * via `BaseProvider.handleProviderError`, not a TypeScript-level cast.
+     */
+    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[][]>;
+    /**
+     * POST /embeddings — Voyage accepts up to 128 inputs per request.
+     * Caller batches above that (see `embedMany`).
+     */
+    private callEmbeddings;
+    validateConfiguration(): Promise<boolean>;
+    getConfiguration(): {
+        provider: AIProviderName;
+        model: string;
+        defaultModel: string;
+        baseURL: string;
+    };
+}
+export default VoyageProvider;

package/dist/lib/providers/voyage.js

@@ -0,0 +1,177 @@
+import { VoyageModels } 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 { withTimeout } from "../utils/errorHandling.js";
+import { logger } from "../utils/logger.js";
+import { createVoyageConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
+const VOYAGE_DEFAULT_BASE_URL = "https://api.voyageai.com/v1";
+const REQUEST_TIMEOUT_MS = 60_000;
+const getVoyageApiKey = () => validateApiKey(createVoyageConfig());
+const getDefaultVoyageModel = () => getProviderModel("VOYAGE_MODEL", VoyageModels.VOYAGE_3_5);
+/**
+ * Voyage AI Provider — embedding-only.
+ *
+ * Top-tier RAG embedder. Native API at api.voyageai.com/v1/embeddings.
+ * Chat / streaming / tool calling are not supported — `executeStream` and
+ * `getAISDKModel` throw a friendly error so callers get an actionable
+ * message instead of a runtime crash deep in the streaming layer.
+ *
+ * @see https://docs.voyageai.com/docs/embeddings
+ */
+export class VoyageProvider extends BaseProvider {
+    apiKey;
+    baseURL;
+    proxyFetch;
+    constructor(modelName, sdk, _region, credentials) {
+        const validatedNeurolink = isNeuroLink(sdk) ? sdk : undefined;
+        super(modelName, "voyage", validatedNeurolink);
+        const overrideKey = credentials?.apiKey?.trim();
+        this.apiKey =
+            overrideKey && overrideKey.length > 0 ? overrideKey : getVoyageApiKey();
+        this.baseURL =
+            credentials?.baseURL ??
+                process.env.VOYAGE_BASE_URL ??
+                VOYAGE_DEFAULT_BASE_URL;
+        this.proxyFetch = createProxyFetch();
+        logger.debug("Voyage Provider initialized (embeddings only)", {
+            modelName: this.modelName,
+            baseURL: this.baseURL,
+        });
+    }
+    // ===== Required abstract overrides =====
+    getProviderName() {
+        return this.providerName;
+    }
+    getDefaultModel() {
+        return getDefaultVoyageModel();
+    }
+    supportsTools() {
+        return false;
+    }
+    getDefaultEmbeddingModel() {
+        return getDefaultVoyageModel();
+    }
+    /**
+     * Voyage is embedding-only — chat models do not exist on this endpoint.
+     * Caller surface stays consistent: returns an `AbortError`-shaped failure
+     * via `BaseProvider.handleProviderError`, not a TypeScript-level cast.
+     */
+    getAISDKModel() {
+        throw new ProviderError("Voyage AI is an embedding-only provider; chat completions are not available. Use `embed()` or `embedMany()` instead, or pick a different provider for `generate()` / `stream()`.", "voyage");
+    }
+    async executeStream(_options, _analysisSchema) {
+        throw new ProviderError("Voyage AI is an embedding-only provider; streaming chat is not available. Use `embed()` / `embedMany()`, or pick another provider for `stream()`.", "voyage");
+    }
+    formatProviderError(error) {
+        const message = error instanceof Error
+            ? error.message
+            : typeof error === "string"
+                ? error
+                : "Unknown error";
+        if (message.includes("401") ||
+            message.toLowerCase().includes("unauthorized") ||
+            message.includes("invalid_api_key")) {
+            return new AuthenticationError("Invalid Voyage AI API key. Get one at https://dash.voyageai.com/api-keys", "voyage");
+        }
+        if (message.includes("429") ||
+            message.toLowerCase().includes("rate limit")) {
+            return new RateLimitError("Voyage AI rate limit exceeded. Back off and retry.", "voyage");
+        }
+        if (message.includes("404") ||
+            message.toLowerCase().includes("model_not_found")) {
+            return new InvalidModelError(`Voyage AI model '${this.modelName}' not found. Browse https://docs.voyageai.com/docs/embeddings`, "voyage");
+        }
+        return new ProviderError(`Voyage AI error: ${message}`, "voyage");
+    }
+    // ===== Embedding implementations =====
+    async embed(text, modelName) {
+        const vectors = await this.callEmbeddings([text], modelName);
+        if (!vectors[0]) {
+            throw new ProviderError("Voyage AI returned no embedding for the provided text", "voyage");
+        }
+        return vectors[0];
+    }
+    async embedMany(texts, modelName) {
+        if (texts.length === 0) {
+            return [];
+        }
+        // Voyage AI's /embeddings endpoint accepts up to 128 inputs per request.
+        // Split larger payloads into sequential batches to avoid API rejection.
+        const VOYAGE_MAX_BATCH_SIZE = 128;
+        const out = [];
+        for (let i = 0; i < texts.length; i += VOYAGE_MAX_BATCH_SIZE) {
+            const batch = texts.slice(i, i + VOYAGE_MAX_BATCH_SIZE);
+            const vectors = await this.callEmbeddings(batch, modelName);
+            out.push(...vectors);
+        }
+        return out;
+    }
+    /**
+     * POST /embeddings — Voyage accepts up to 128 inputs per request.
+     * Caller batches above that (see `embedMany`).
+     */
+    async callEmbeddings(inputs, modelName) {
+        const model = modelName ?? this.modelName;
+        let response;
+        try {
+            response = await withTimeout(this.proxyFetch(`${this.baseURL}/embeddings`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    input: inputs,
+                    model,
+                }),
+            }), REQUEST_TIMEOUT_MS, new ProviderError(`Voyage embeddings request timed out after ${REQUEST_TIMEOUT_MS / 1000}s`, "voyage"));
+        }
+        catch (err) {
+            // Re-throw typed provider errors produced by withTimeout (ProviderError
+            // subclasses: AuthenticationError, RateLimitError, InvalidModelError)
+            // so they are not double-wrapped by formatProviderError.
+            if (err instanceof ProviderError) {
+                throw err;
+            }
+            throw this.formatProviderError(err);
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            throw this.formatProviderError(new Error(`Voyage embeddings failed: ${response.status} — ${text}`));
+        }
+        const data = (await response.json());
+        if (!data.data || data.data.length === 0) {
+            throw new ProviderError("Voyage embeddings response missing data", "voyage");
+        }
+        // Validate that the response covers all requested inputs.
+        // Voyage may return partial results in edge-case error scenarios.
+        if (data.data.length !== inputs.length) {
+            throw new ProviderError(`Voyage embeddings response count mismatch: expected ${inputs.length}, got ${data.data.length}`, "voyage");
+        }
+        // Sort by index (Voyage returns out-of-order under some conditions)
+        // and drop to a flat number[][] result.
+        const sorted = data.data.slice().sort((a, b) => a.index - b.index);
+        // Verify that index coverage is complete (0 … n-1).
+        for (let i = 0; i < sorted.length; i++) {
+            if (sorted[i].index !== i) {
+                throw new ProviderError(`Voyage embeddings response has unexpected index ordering: position ${i} has index ${sorted[i].index}`, "voyage");
+            }
+        }
+        return sorted.map((d) => d.embedding);
+    }
+    async validateConfiguration() {
+        return typeof this.apiKey === "string" && this.apiKey.trim().length > 0;
+    }
+    getConfiguration() {
+        return {
+            provider: this.providerName,
+            model: this.modelName,
+            defaultModel: getDefaultVoyageModel(),
+            baseURL: this.baseURL,
+        };
+    }
+}
+export default VoyageProvider;
+//# sourceMappingURL=voyage.js.map

package/dist/lib/providers/xai.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";
+/**
+ * xAI Grok Provider
+ *
+ * OpenAI-compatible chat completions at api.x.ai/v1. Supports the Grok
+ * family: grok-2, grok-3, grok-3-mini, grok-2-vision-latest (multimodal),
+ * and grok-beta. Streaming and tool calling supported.
+ *
+ * @see https://docs.x.ai/api
+ */
+export declare class XaiProvider extends BaseProvider {
+    private model;
+    private apiKey;
+    private baseURL;
+    constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["xai"]);
+    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 XaiProvider;