@juspay/neurolink 12.37.4 → 12.38.0

package/dist/utils/decisionMedia.js

@@ -0,0 +1,160 @@
+import { promises as fs } from "node:fs";
+import { sniffImageMimeType } from "./imageDetection.js";
+import { detectIsoBmffImageMimeType, hasFtypBoxSignature } from "./isoBmff.js";
+const REMOTE_URL = /^https?:\/\//i;
+const URL_SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i;
+const MAX_ECHOED_PATH_CHARS = 200;
+const DATA_URL = {
+    image: /^data:image\/[a-z0-9.+-]+;base64,/i,
+    video: /^data:video\/[a-z0-9.+-]+;base64,/i,
+};
+const WEBM_HEADER = [0x1a, 0x45, 0xdf, 0xa3];
+const NOT_RECOGNISED = {
+    image: "is not a recognised image format",
+    video: "is not a recognised video format (MP4, MOV or WebM)",
+};
+/**
+ * MP4 and MOV share the ISO-BMFF box. An AVIF or HEIC image shares it too, and
+ * is not a video.
+ */
+function sniffVideoMimeType(buffer) {
+    if (hasFtypBoxSignature(buffer) &&
+        detectIsoBmffImageMimeType(buffer) === null) {
+        return "video/mp4";
+    }
+    return WEBM_HEADER.every((byte, i) => buffer[i] === byte)
+        ? "video/webm"
+        : null;
+}
+function encode(buffer, kind, label) {
+    const mime = kind === "image" ? sniffImageMimeType(buffer) : sniffVideoMimeType(buffer);
+    return mime === null
+        ? { status: "error", message: `${label} ${NOT_RECOGNISED[kind]}.` }
+        : {
+            status: "ok",
+            dataUrl: `data:${mime};base64,${buffer.toString("base64")}`,
+        };
+}
+/**
+ * A path can be echoed in an error. A stray base64 blob passed as a path cannot,
+ * so past a short length only its size is shown.
+ */
+function describePath(path) {
+    return path.length <= MAX_ECHOED_PATH_CHARS
+        ? `(${path})`
+        : `(a ${path.length}-character string)`;
+}
+/** A file over the limit is refused from `stat`, before it is read into memory. */
+async function readMediaFile(path, label, maxBytes) {
+    try {
+        const stats = await fs.stat(path);
+        if (!stats.isFile()) {
+            return {
+                status: "error",
+                message: `${label} ${describePath(path)} is not a file.`,
+            };
+        }
+        if (stats.size > maxBytes) {
+            return {
+                status: "error",
+                message: `${label} ${describePath(path)} is ${stats.size} bytes; a request may carry at most ${maxBytes}.`,
+            };
+        }
+        return { status: "ok", buffer: await fs.readFile(path) };
+    }
+    catch (error) {
+        const reason = error instanceof Error && "code" in error
+            ? String(error.code)
+            : "unreadable";
+        return {
+            status: "error",
+            message: `Could not read ${label} ${describePath(path)}: ${reason}.`,
+        };
+    }
+}
+/**
+ * Nothing here echoes a `data:` URL or a remote URL: either can carry a
+ * credential or megabytes of base64, and neither belongs in an error message.
+ */
+async function toDataUrl(source, kind, label, maxBytes) {
+    if (typeof source !== "string") {
+        return source.length === 0
+            ? { status: "error", message: `${label} is an empty Buffer.` }
+            : encode(source, kind, label);
+    }
+    const value = source.trim();
+    if (value === "") {
+        return { status: "error", message: `${label} is an empty string.` };
+    }
+    if (REMOTE_URL.test(value)) {
+        return {
+            status: "error",
+            message: `${label} is a remote URL. Media is not fetched for you; pass a Buffer, a file path or a data: URL.`,
+        };
+    }
+    if (/^data:/i.test(value)) {
+        return DATA_URL[kind].test(value)
+            ? { status: "ok", dataUrl: value }
+            : {
+                status: "error",
+                message: `${label} is a data: URL that is not base64 ${kind} content.`,
+            };
+    }
+    if (URL_SCHEME.test(value)) {
+        return {
+            status: "error",
+            message: `${label} uses an unsupported URL scheme. Pass a Buffer, a file path or a data: URL.`,
+        };
+    }
+    const file = await readMediaFile(value, label, maxBytes);
+    return file.status === "ok" ? encode(file.buffer, kind, label) : file;
+}
+/**
+ * Turn the caller's images and video into `data:` URLs, or say why not.
+ * Runs before any request, so every refusal costs nothing and none is retried.
+ */
+export async function prepareDecisionMedia(request, limits, vendor, alternatives) {
+    const images = request.images ?? [];
+    if (images.length === 0 && request.video === undefined) {
+        return { status: "prepared", media: undefined };
+    }
+    if (!limits) {
+        const use = alternatives.length > 0
+            ? ` Use a decision provider that does: ${alternatives.join(", ")}.`
+            : "";
+        return {
+            status: "refused",
+            message: `${vendor} does not accept images or video.${use}`,
+        };
+    }
+    if (images.length > limits.maxImages) {
+        return {
+            status: "refused",
+            message: `${vendor} accepts at most ${limits.maxImages} images per request; this one has ${images.length}.`,
+        };
+    }
+    if (request.video !== undefined && !limits.video) {
+        return { status: "refused", message: `${vendor} does not accept video.` };
+    }
+    const prepared = [];
+    for (const [index, image] of images.entries()) {
+        const converted = await toDataUrl(image, "image", `Image ${index + 1}`, limits.maxRequestBytes);
+        if (converted.status === "error") {
+            return { status: "refused", message: converted.message };
+        }
+        prepared.push(converted.dataUrl);
+    }
+    let video;
+    if (request.video !== undefined) {
+        const converted = await toDataUrl(request.video, "video", "The video", limits.maxRequestBytes);
+        if (converted.status === "error") {
+            return { status: "refused", message: converted.message };
+        }
+        video = converted.dataUrl;
+    }
+    const bytes = prepared.reduce((sum, url) => sum + url.length, video?.length ?? 0);
+    return {
+        status: "prepared",
+        media: { images: prepared, ...(video ? { video } : {}), bytes },
+    };
+}

package/dist/utils/modelChoices.js

@@ -2,7 +2,7 @@
  * Centralized model choices for CLI commands
  * Derives choices from model enums to ensure consistency
  */
-import { AIProviderName, OpenAIModels, AnthropicModels, GoogleAIModels, BedrockModels, VertexModels, OllamaModels, AzureOpenAIModels, LiteLLMModels, SageMakerModels, OpenRouterModels, NvidiaNimModels, CohereModels, VoyageModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, TypeSafeModels, LayaModels, ReplicateModels, } from "../constants/enums.js";
+import { AIProviderName, OpenAIModels, AnthropicModels, GoogleAIModels, BedrockModels, VertexModels, OllamaModels, AzureOpenAIModels, LiteLLMModels, SageMakerModels, OpenRouterModels, NvidiaNimModels, CohereModels, VoyageModels, JinaModels, StabilityModels, IdeogramModels, RecraftModels, TypeSafeModels, LayaModels, XorModels, ReplicateModels, } from "../constants/enums.js";
 import { getCatalogJsonEntries } from "../providers/catalog/loader.js";
 /**
  * Looks up the JSON catalog entry for a provider, if it is one of the 11
@@ -387,6 +387,12 @@ const TOP_MODELS_CONFIG = {
             description: "Let Laya pick a checkpoint by language",
         },
     ],
+    [AIProviderName.XOR]: [
+        {
+            model: XorModels.XOR_1_1,
+            description: "Recommended - XOR 1.1, decision model that also reads images and video",
+        },
+    ],
     [AIProviderName.AUTO]: [],
 };
 /**
@@ -427,6 +433,7 @@ export const DEFAULT_MODELS = {
     [AIProviderName.RECRAFT]: RecraftModels.RECRAFT_V3,
     [AIProviderName.TYPESAFE]: TypeSafeModels.JEV_LATEST,
     [AIProviderName.LAYA]: LayaModels.TYPED_DECISIONS,
+    [AIProviderName.XOR]: XorModels.XOR_1_1,
 };
 /**
  * Model enum mappings for getAllModels.
@@ -460,6 +467,7 @@ const MODEL_ENUMS = {
     [AIProviderName.RECRAFT]: RecraftModels,
     [AIProviderName.TYPESAFE]: TypeSafeModels,
     [AIProviderName.LAYA]: LayaModels,
+    [AIProviderName.XOR]: XorModels,
     [AIProviderName.AUTO]: null,
 };
 /**

package/dist/utils/providerConfig.d.ts

@@ -405,3 +405,8 @@ export declare function createTypeSafeConfig(): ProviderConfigOptions;
  * built-in endpoint: LAYA_BASE_URL is required alongside the key.
  */
 export declare function createLayaConfig(): ProviderConfigOptions;
+/**
+ * XOR — the `decide` inference type. Not a text provider, and it has no
+ * built-in endpoint: XOR_BASE_URL is required alongside the key.
+ */
+export declare function createXorConfig(): ProviderConfigOptions;

package/dist/utils/providerConfig.js

@@ -1341,3 +1341,20 @@ export function createLayaConfig() {
         ],
     };
 }
+/**
+ * XOR — the `decide` inference type. Not a text provider, and it has no
+ * built-in endpoint: XOR_BASE_URL is required alongside the key.
+ */
+export function createXorConfig() {
+    return {
+        providerName: "XOR",
+        envVarName: "XOR_API_KEY",
+        setupUrl: "https://huggingface.co/juspay/xor",
+        description: "API key for your XOR endpoint",
+        instructions: [
+            "1. Reach an XOR deployment, or use a LiteLLM proxy with a pass-through route to one",
+            "2. Set XOR_BASE_URL to its origin (NeuroLink calls <XOR_BASE_URL>/v1/systemone)",
+            "3. Set XOR_API_KEY to the key it accepts (on LiteLLM, a virtual key whose team allows xor-1.1)",
+        ],
+    };
+}