@juspay/neurolink 12.37.5 → 12.38.0

package/dist/providers/xor.js

@@ -0,0 +1,192 @@
+import { XorModels } from "../constants/enums.js";
+import { logger } from "../utils/logger.js";
+import { redactUrlForError } from "../utils/logSanitize.js";
+import { getProviderModel } from "../utils/providerConfig.js";
+import { describeValidationErrors, isRecord, redactCredentials, SystemOneDecisionProvider, } from "./systemOneDecision.js";
+const XOR_ROUTE = "/v1/systemone";
+/**
+ * XOR_BASE_URL is the origin of a deployment, but a `LITELLM_BASE_URL`-style
+ * value ends in `/v1`, which the route already carries. Both spellings reduce
+ * to the same base.
+ */
+function normalizeBaseURL(raw) {
+    return raw.replace(/\/+$/, "").replace(/\/v1$/i, "");
+}
+/** What a 500 says when the prefill was too long for the model to read. */
+const CONTEXT_LENGTH_MESSAGE = /(context|prefill|prompt).{0,40}(length|limit|too long|exceed)|(too long|exceeds?).{0,40}(context|tokens)/i;
+/**
+ * A base URL that cannot work is refused up front, and its text is never
+ * repeated: `fetch` rejects a URL with userinfo and echoes it in the error, the
+ * route is appended after a query string or fragment, and any of them can hold a
+ * credential.
+ */
+function baseURLProblem(baseURL) {
+    const fix = "Set XOR_BASE_URL or pass credentials.xor.baseURL to the origin, and give the key through XOR_API_KEY or credentials.xor.apiKey.";
+    try {
+        const url = new URL(baseURL);
+        // `new URL()` accepts any scheme, so a host:port with no scheme parses as
+        // one (`xor.internal:8080` has the scheme `xor.internal:`) and would reach
+        // `fetch` as a network error instead of this message.
+        if (url.protocol !== "https:" && url.protocol !== "http:") {
+            return `The XOR base URL must start with https:// or http://. ${fix}`;
+        }
+        return url.username || url.password || url.search || url.hash
+            ? `The XOR base URL must not carry credentials, a query string or a fragment. ${fix}`
+            : undefined;
+    }
+    catch {
+        return `The XOR base URL is not a valid absolute URL. ${fix}`;
+    }
+}
+function xorErrorKind(status, message) {
+    if (status === 401) {
+        return "authentication";
+    }
+    if (status === 413) {
+        return "max_tokens_exceeded";
+    }
+    if (status === 429) {
+        return "rate_limit";
+    }
+    if (status === 503) {
+        return "overloaded";
+    }
+    if (status >= 500) {
+        return CONTEXT_LENGTH_MESSAGE.test(message)
+            ? "max_tokens_exceeded"
+            : "server";
+    }
+    return "invalid_request";
+}
+/**
+ * Two envelopes reach the client. A LiteLLM proxy answers its own rejections
+ * (a bad key, a team without the model, a budget) as
+ * `{"error":{"message","type","code"}}`; XOR's own server answers as
+ * `{"error":"<string>"}` — a shape that neither TypeSafe's nor Laya's parser
+ * recognises, since both require `body.error` to be an object. FastAPI's
+ * `{"detail":…}` is read too, in case something in front speaks it.
+ */
+function readXorErrorMessage(body) {
+    if (!isRecord(body)) {
+        return undefined;
+    }
+    const { error, detail } = body;
+    if (isRecord(error) &&
+        typeof error.message === "string" &&
+        error.message.length > 0) {
+        return error.message;
+    }
+    if (typeof error === "string" && error.length > 0) {
+        return error;
+    }
+    if (Array.isArray(detail)) {
+        return `Request failed validation — ${describeValidationErrors(detail)}`;
+    }
+    return typeof detail === "string" && detail.length > 0 ? detail : undefined;
+}
+/**
+ * XOR Provider — the `decide` inference type only.
+ *
+ * XOR is Juspay's open-weights "System One" decision model, post-trained from
+ * Qwen3.6-35B-A3B: the same typed `noul` / `choice` / `score` questions as
+ * TypeSafe's Jev, on the same wire, in one batched pass. Unlike Jev and Laya it
+ * also reads images and one video. The request loop, retries, auth circuit
+ * breaker and answer parsing are shared with every decision provider in
+ * {@link SystemOneDecisionProvider}.
+ *
+ * @see https://huggingface.co/juspay/xor
+ */
+export class XorProvider extends SystemOneDecisionProvider {
+    apiKey;
+    baseURL;
+    constructor(modelName, sdk, _region, credentials) {
+        super(modelName, "xor", sdk);
+        this.apiKey =
+            credentials?.apiKey?.trim() || (process.env.XOR_API_KEY?.trim() ?? "");
+        // No built-in endpoint: XOR is reached at a deployment or through a proxy
+        // route to one, so the base URL comes only from config. `||`, not `??`, so
+        // a blank one counts as unset.
+        this.baseURL = normalizeBaseURL(credentials?.baseURL?.trim() || process.env.XOR_BASE_URL?.trim() || "");
+        // A base URL with `user:pass@` or a `?token=` is refused when a request is
+        // made, but it is redacted here as well so a misconfigured value cannot leak
+        // through this line either.
+        logger.debug("XOR Provider initialized (decide only)", {
+            modelName: this.modelName,
+            baseURL: this.baseURL ? redactUrlForError(this.baseURL) : "(not set)",
+        });
+    }
+    getDefaultModel() {
+        return getProviderModel("XOR_MODEL", XorModels.XOR_1_1);
+    }
+    vendorLabel() {
+        return "XOR";
+    }
+    vendorDisplayName() {
+        return "XOR";
+    }
+    decisionApiKey() {
+        return this.apiKey;
+    }
+    missingKeyMessage() {
+        return "XOR requires an API key. Set XOR_API_KEY or pass credentials.xor.apiKey.";
+    }
+    missingConfigMessage() {
+        return this.baseURL
+            ? baseURLProblem(this.baseURL)
+            : "XOR requires a base URL. Set XOR_BASE_URL or pass credentials.xor.baseURL.";
+    }
+    decisionEndpoint() {
+        return `${this.baseURL}${XOR_ROUTE}`;
+    }
+    decisionHeaders() {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+        };
+    }
+    /**
+     * `model` is always sent. A LiteLLM proxy checks team access against the
+     * body's `model`, and refuses a request that names none. `images` is
+     * omitted rather than sent empty, which the server rejects.
+     */
+    buildDecisionBody(state, questions, model, media) {
+        return {
+            model,
+            state,
+            questions,
+            ...(media && media.images.length > 0 ? { images: media.images } : {}),
+            ...(media?.video ? { video: media.video } : {}),
+        };
+    }
+    /**
+     * A 403 is deliberately NOT `authentication`: on a LiteLLM proxy it means the
+     * team's allow-list lacks the model, which an admin can fix at any time, and
+     * `authentication` would trip the per-instance breaker and keep XOR disabled
+     * until restart even after access is granted. A 402 (a budget) is the same
+     * kind of fixable gap. `DecisionErrorKind` has no billing kind, so both map
+     * to `invalid_request`.
+     */
+    parseDecisionError(status, payload, requestId) {
+        const fallback = `XOR request failed with HTTP ${status}`;
+        const message = redactCredentials(readXorErrorMessage(payload) ?? fallback, this.apiKey) || fallback;
+        const kind = xorErrorKind(status, message);
+        return {
+            kind,
+            message,
+            status,
+            requestId,
+            retryable: kind === "rate_limit" || kind === "overloaded" || kind === "server",
+        };
+    }
+    /**
+     * XOR's server sets `x-request-id` and `x-typesafe-request-id` to one value.
+     * A proxy in front may replace or drop them, so its own call id is the last
+     * resort.
+     */
+    readRequestId(headers) {
+        return (headers.get("x-request-id") ??
+            headers.get("x-typesafe-request-id") ??
+            headers.get("x-litellm-call-id") ??
+            undefined);
+    }
+}

package/dist/types/classifierRouter.d.ts

@@ -25,8 +25,9 @@ export type ClassifierDifficulty = "trivial" | "simple" | "moderate" | "hard" |
  * - `jev` — TypeSafe's System One model; one ~400ms round trip that returns a
  *   *calibrated* confidence rather than a self-reported one.
  * - `auto` — `jev` when a decision provider is configured, in the environment
- *   or in SDK credentials (`TYPESAFE_API_KEY`, or `LAYA_API_KEY` with
- *   `LAYA_BASE_URL`), otherwise `heuristic`.
+ *   or in SDK credentials (`TYPESAFE_API_KEY`, `LAYA_API_KEY` with
+ *   `LAYA_BASE_URL`, or `XOR_API_KEY` with `XOR_BASE_URL`), otherwise
+ *   `heuristic`.
  */
 export type ClassifierStrategyKind = "heuristic" | "llm" | "jev" | "auto";
 /**
@@ -186,8 +187,8 @@ export type ClassifierRouterConfig = {
     /**
      * Classification strategy. Default: "auto" — which resolves to "jev" when a
      * decision provider is configured, in the environment or in SDK credentials
-     * (`TYPESAFE_API_KEY`, or `LAYA_API_KEY` with `LAYA_BASE_URL`) and
-     * "heuristic" otherwise, so configuring one
+     * (`TYPESAFE_API_KEY`, `LAYA_API_KEY` with `LAYA_BASE_URL`, or
+     * `XOR_API_KEY` with `XOR_BASE_URL`) and "heuristic" otherwise, so configuring one
      * upgrades routing without any code change. Behaviour for callers with no
      * key is unchanged.
      */

package/dist/types/cli.d.ts

@@ -1310,6 +1310,10 @@ export type CliDecideArgs = {
     stateFile?: string;
     questions?: string;
     questionsFile?: string;
+    /** Image files (or data: URLs) for a provider that reads images. */
+    image?: string[];
+    /** One video file (or data: URL) for a provider that reads video. */
+    video?: string;
     provider?: string;
     model?: string;
     timeout?: number;
@@ -1722,8 +1726,8 @@ export type CliClassifierRouterFlags = {
     /**
      * Strategy: "auto" (default), "heuristic", "llm" or "jev"
      * (--classifier-strategy). "auto" resolves to "jev" when a decision
-     * provider is configured (TYPESAFE_API_KEY, or LAYA_API_KEY with
-     * LAYA_BASE_URL) and "heuristic" otherwise.
+     * provider is configured (TYPESAFE_API_KEY, LAYA_API_KEY with
+     * LAYA_BASE_URL, or XOR_API_KEY with XOR_BASE_URL) and "heuristic" otherwise.
      */
     classifierStrategy?: string;
     /**

package/dist/types/decision.d.ts

@@ -95,9 +95,19 @@ export type DecisionUsage = {
     inputTokens: number;
     outputTokens: number;
 };
+/** An image or video as the caller supplies it: raw bytes, a file path, or a data URL. */
+export type DecisionMediaSource = Buffer | string;
 export type DecisionRequest = {
     state: DecisionState;
     questions: DecisionQuestionMap;
+    /**
+     * Images the model reads alongside `state`. Each is a Buffer, a local file
+     * path or a `data:image/…;base64,` URL; an http(s) URL is refused. Only a
+     * provider whose descriptor declares `decisionLimits.media` accepts them.
+     */
+    images?: readonly DecisionMediaSource[];
+    /** One video, in the same forms. Sending images as well is allowed. */
+    video?: DecisionMediaSource;
     /** Overrides the provider's configured model for this call only. */
     model?: string;
     signal?: AbortSignal;
@@ -116,6 +126,8 @@ export type DecisionResult = {
     latencyMs: number;
     /** Server-side time behind the edge; isolates model time from network. */
     upstreamMs?: number;
+    /** Encoded size of the images and video sent. Absent for a text-only request. */
+    mediaBytes?: number;
 };
 /**
  * Input a decision provider can actually read, declared on its descriptor.
@@ -132,7 +144,8 @@ export type DecisionLimits = {
      * name — so it should be the tightest window the provider has.
      */
     maxStateTokens: number;
-    maxQuestions: number;
+    /** Absent when the provider has no cap on questions per request. */
+    maxQuestions?: number;
     /**
      * Tokens charged per non-ASCII character. The default estimate assumes ~4
      * characters per token, which holds for English and is several times too
@@ -145,6 +158,52 @@ export type DecisionLimits = {
         maxStateTokens: number;
         nonAsciiTokensPerChar?: number;
     }>>;
+    /** What the provider accepts besides text. Absent means text only. */
+    media?: DecisionMediaLimits;
+};
+export type DecisionMediaLimits = {
+    /** Most images one request may carry. */
+    maxImages: number;
+    /** Whether a video is accepted (at most one). */
+    video: boolean;
+    /** Ceiling on the encoded request body, in bytes. */
+    maxRequestBytes: number;
+};
+/** Media after preparation: everything is a `data:` URL, ready for the wire. */
+export type DecisionPreparedMedia = {
+    images: string[];
+    video?: string;
+    /** Encoded size of every URL above. */
+    bytes: number;
+};
+/**
+ * Discriminated by a string literal, not a boolean: the package is also
+ * compiled without strictNullChecks, where a boolean discriminant does not
+ * narrow.
+ */
+export type DecisionMediaResult = {
+    status: "prepared";
+    media: DecisionPreparedMedia | undefined;
+} | {
+    status: "refused";
+    message: string;
+};
+export type DecisionMediaKind = "image" | "video";
+/** One image or video turned into a data URL, or the reason it could not be. Same literal-discriminant rule as above. */
+export type DecisionMediaConversion = {
+    status: "ok";
+    dataUrl: string;
+} | {
+    status: "error";
+    message: string;
+};
+/** A media file read from disk, or the reason it could not be. */
+export type DecisionMediaFileRead = {
+    status: "ok";
+    buffer: Buffer;
+} | {
+    status: "error";
+    message: string;
 };
 /**
  * Why a decision call failed, normalised across vendors. TypeSafe alone

package/dist/types/providers.d.ts

@@ -322,6 +322,16 @@ export type NeurolinkCredentials = {
         apiKey?: string;
         baseURL?: string;
     };
+    /**
+     * XOR (Juspay, open weights) — the `decide` inference type. There is no
+     * built-in endpoint: `baseURL` (or XOR_BASE_URL) is required, pointing at the
+     * origin of an XOR deployment or a proxy route to one; requests go to
+     * `<baseURL>/v1/systemone`.
+     */
+    xor?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
 };
 /**
  * Voyage AI /embeddings response shape.

package/dist/utils/decisionMedia.d.ts

@@ -0,0 +1,9 @@
+import type { DecisionMediaLimits, DecisionMediaResult, DecisionMediaSource } from "../types/index.js";
+/**
+ * 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 declare function prepareDecisionMedia(request: {
+    images?: readonly DecisionMediaSource[];
+    video?: DecisionMediaSource;
+}, limits: DecisionMediaLimits | undefined, vendor: string, alternatives: readonly string[]): Promise<DecisionMediaResult>;

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)",
+        ],
+    };
+}