@juspay/neurolink 12.41.2 → 12.41.4

package/dist/core/baseProvider.js

@@ -24,7 +24,7 @@ import { sanitizeErrorCause } from "../utils/logSanitize.js";
 import { createAnalytics as buildAnalytics } from "./analytics.js";
 import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
 import { duckTypedStatusCode, extractRetryAfterMsFromError, } from "../utils/providerRetry.js";
-import { hasLifecycleErrorFired, markLifecycleErrorFired, } from "../utils/lifecycleCallbacks.js";
+import { getLifecycleMiddlewareConfig, hasLifecycleErrorFired, markLifecycleErrorFired, } from "../utils/lifecycleCallbacks.js";
 import { resolveLifecycleTimeoutMs } from "../utils/lifecycleTimeout.js";
 import { logger } from "../utils/logger.js";
 import { interleaveTTSStream } from "../utils/ttsStream.js";
@@ -51,18 +51,6 @@ import { generateOnceNative } from "../utils/nativeSingleShot.js";
 import { validateExecutionControl } from "../utils/parameterValidation.js";
 import { extractTokenUsage } from "../utils/tokenUtils.js";
 import { preserveLiveStreamAccessors } from "../utils/streamResultAccessors.js";
-/**
- * Read the consumer-facing lifecycle callbacks buried inside a request's
- * middleware blob. The parameter is `unknown` on purpose: request options
- * arrive as several structurally-unrelated shapes (StreamOptions,
- * TextGenerationOptions), and the lifecycle branch is an optional add-on
- * none of them declare — a single structural view keeps the read cast-free
- * at every call site.
- */
-function getLifecycleMiddlewareConfig(options) {
-    return options?.middleware
-        ?.middlewareConfig?.lifecycle?.config;
-}
 /**
  * Abstract base class for all AI providers
  * Tools are integrated as first-class citizens - always available by default
@@ -819,9 +807,32 @@ export class BaseProvider {
                     yield chunk;
                 }
                 if (onFinish) {
+                    // Read `result.usage` / `result.finishReason` here, after the
+                    // drain loop above has fully exhausted `upstreamIterable` — the
+                    // same point native background-loop providers (Vertex's Gemini3
+                    // and Claude paths) resolve these fields by, whether they are
+                    // plain values set before `result` was returned or live getters
+                    // preserved through `withStreamModelFallback`
+                    // (`preserveLiveStreamAccessors`). Both fields are generic
+                    // `StreamResult` members for every provider, not Vertex-specific,
+                    // so this enrichment is additive for all of them: only present
+                    // when `result` actually carries a value, never a synthesized
+                    // default (a provider that never populated these fields keeps
+                    // getting the exact same bare `{text, duration}` payload as
+                    // before).
+                    const { usage, finishReason } = result;
                     await safeFire(() => onFinish({
                         text: accumulated,
                         duration: Date.now() - startTime,
+                        ...(usage
+                            ? {
+                                usage: {
+                                    promptTokens: usage.input ?? 0,
+                                    completionTokens: usage.output ?? 0,
+                                },
+                            }
+                            : {}),
+                        ...(finishReason ? { finishReason } : {}),
                     }), "onFinish");
                 }
             }

package/dist/middleware/builtin/lifecycle.js

@@ -1,6 +1,6 @@
 import { logger } from "../../utils/logger.js";
 import { isRecoverableError } from "../../utils/errorHandling.js";
-import { fireOnErrorOnce } from "../../utils/lifecycleCallbacks.js";
+import { fireOnErrorOnce, isLifecycleStreamCallbacksOwnedByBaseProvider, } from "../../utils/lifecycleCallbacks.js";
 /**
  * Normalize a thrown value to an `Error` while preserving structured
  * fields (`code`, `status`, `statusCode`, `retryAfter`, `details`,
@@ -88,19 +88,42 @@ export function createLifecycleMiddleware(config = {}) {
                 if (!config.onChunk && !config.onFinish && !config.onError) {
                     return result;
                 }
+                // BaseProvider.wrapStreamWithLifecycleCallbacks already fires
+                // onChunk/onFinish for this exact config object, from NeuroLink's
+                // own normalized stream, for every NeuroLink-internal stream() call
+                // regardless of provider/transport. When that marker is present,
+                // firing onChunk/onFinish here too would deliver each one twice —
+                // once from these raw, provider-shaped V3 chunks, once from
+                // BaseProvider's normalized ones. onError is NOT covered by this
+                // flag: it keeps its own, independent dedup via `fireOnErrorOnce`'s
+                // shared fired-marker below, unchanged.
+                const streamCallbacksOwnedByBaseProvider = isLifecycleStreamCallbacksOwnedByBaseProvider(config);
                 let sequenceNumber = 0;
                 let accumulatedText = "";
                 const transformStream = new TransformStream({
                     transform(chunk, controller) {
                         try {
-                            if (chunk.type === "text-delta") {
-                                accumulatedText += chunk.textDelta;
+                            // V3 stream parts carry the delta on `delta` (see
+                            // LanguageModelV3StreamPart in types/aiCompat.ts); `textDelta`
+                            // is a V2-era AI-SDK field that V3 providers (e.g. Bedrock's
+                            // bridge, this package's own openaiChatCompletionsBase) never
+                            // set. Reading `chunk.textDelta` alone silently produced
+                            // `undefined`, which string-concatenated into a literal
+                            // "undefined" per chunk. Falling back to `textDelta` keeps any
+                            // caller still emitting the older shape working unchanged.
+                            const textDelta = chunk.type === "text-delta"
+                                ? (chunk.delta ?? chunk.textDelta)
+                                : undefined;
+                            if (chunk.type === "text-delta" && textDelta !== undefined) {
+                                accumulatedText += textDelta;
                             }
-                            if (config.onChunk && chunk.type) {
+                            if (config.onChunk &&
+                                chunk.type &&
+                                !streamCallbacksOwnedByBaseProvider) {
                                 try {
                                     const callbackResult = config.onChunk({
                                         type: chunk.type,
-                                        textDelta: chunk.type === "text-delta" ? chunk.textDelta : undefined,
+                                        textDelta,
                                         sequenceNumber: sequenceNumber++,
                                     });
                                     Promise.resolve(callbackResult).catch((e) => {
@@ -124,7 +147,7 @@ export function createLifecycleMiddleware(config = {}) {
                         }
                     },
                     flush() {
-                        if (config.onFinish) {
+                        if (config.onFinish && !streamCallbacksOwnedByBaseProvider) {
                             try {
                                 const callbackResult = config.onFinish({
                                     text: accumulatedText,

package/dist/neurolink.js

@@ -79,7 +79,7 @@ import { tracers } from "./telemetry/tracers.js";
 import { getConversationMessages, storeConversationTurn, } from "./utils/conversationMemory.js";
 // Enhanced error handling imports
 import { CircuitBreaker, ERROR_CODES, ErrorFactory, isAbortError, isRetriableError, logStructuredError, NeuroLinkError, withRetry, withTimeout, } from "./utils/errorHandling.js";
-import { hasLifecycleErrorFired, markLifecycleErrorFired, } from "./utils/lifecycleCallbacks.js";
+import { hasLifecycleErrorFired, markLifecycleErrorFired, markLifecycleStreamCallbacksOwnedByBaseProvider, } from "./utils/lifecycleCallbacks.js";
 import { interleaveTTSStream } from "./utils/ttsStream.js";
 import { resolveLifecycleTimeoutMs } from "./utils/lifecycleTimeout.js";
 import { cloneOptionsForCallIsolation } from "./utils/cloneOptions.js";
@@ -782,6 +782,20 @@ export class NeuroLink {
         if (!options.onFinish && !options.onError && !options.onChunk) {
             return;
         }
+        const config = {
+            ...options.middleware?.middlewareConfig?.lifecycle?.config,
+            ...(options.onFinish !== undefined ? { onFinish: options.onFinish } : {}),
+            ...(options.onError !== undefined ? { onError: options.onError } : {}),
+            ...(options.onChunk !== undefined ? { onChunk: options.onChunk } : {}),
+        };
+        // BaseProvider.wrapStreamWithLifecycleCallbacks unconditionally wraps
+        // every provider's stream() result and fires onChunk/onFinish from
+        // there, reliably, for this exact config object. Stamp it so the
+        // model-level lifecycle middleware (builtin/lifecycle.ts) skips its own
+        // onChunk/onFinish firing for it instead of delivering each one twice.
+        // See markLifecycleStreamCallbacksOwnedByBaseProvider's doc comment for
+        // why generate()'s config below is never stamped this way.
+        markLifecycleStreamCallbacksOwnedByBaseProvider(config);
         options.middleware = {
             ...options.middleware,
             middlewareConfig: {
@@ -789,18 +803,7 @@ export class NeuroLink {
                 lifecycle: {
                     ...options.middleware?.middlewareConfig?.lifecycle,
                     enabled: true,
-                    config: {
-                        ...options.middleware?.middlewareConfig?.lifecycle?.config,
-                        ...(options.onFinish !== undefined
-                            ? { onFinish: options.onFinish }
-                            : {}),
-                        ...(options.onError !== undefined
-                            ? { onError: options.onError }
-                            : {}),
-                        ...(options.onChunk !== undefined
-                            ? { onChunk: options.onChunk }
-                            : {}),
-                    },
+                    config,
                 },
             },
         };

package/dist/providers/googleVertex/client.d.ts

@@ -271,6 +271,26 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * this for free via the AI SDK `wrapStream` middleware; native @google/genai
      * bypasses that wrapper, so native consumers need their lifecycle
      * callbacks invoked from here.
+     *
+     * `BaseProvider.stream()` always passes the result this method returns
+     * through `wrapStreamWithLifecycleCallbacks` afterwards too (that wrapper
+     * has "no early return when there are no callbacks" — see its own doc
+     * comment) — so unconditionally firing here double-fires onChunk/onFinish
+     * for every native Vertex stream. `isLifecycleStreamCallbacksOwnedByBaseProvider`
+     * reads the SAME nested lifecycle config off the SAME `options` object
+     * `wrapStreamWithLifecycleCallbacks` reads from (NeuroLink.applyStreamLifecycleMiddleware
+     * stamps it before either method runs), so both sites agree on which one
+     * actually fires without a second, Vertex-specific marker — and without
+     * relying on a Symbol on the `StreamResult` itself, which would not
+     * survive `withStreamModelFallback`'s rebuild of a plain forwarding object
+     * between this method and `wrapStreamWithLifecycleCallbacks`.
+     *
+     * onError is deliberately NOT gated by that marker — same precedent as
+     * `middleware/builtin/lifecycle.ts`'s `wrapStream` ("onError is NOT
+     * covered by this flag: it keeps its own, independent dedup via
+     * fireOnErrorOnce's shared fired-marker"). `fireOnErrorOnce` stamps the
+     * error so `BaseProvider`'s own catch (which checks
+     * `hasLifecycleErrorFired`) skips its own fire for the same failure.
      */
     private wrapStreamResultWithLifecycle;
     /**

package/dist/providers/googleVertex/client.js

@@ -22,6 +22,7 @@ import { FileDetector } from "../../utils/fileDetector.js";
 import { mergeMediaFileAliases, normalizeVisionImageFormats, processUnifiedFilesArray, } from "../../utils/messageBuilder.js";
 import { logger } from "../../utils/logger.js";
 import { drainDetachedPump } from "../../utils/drainDetachedPump.js";
+import { fireOnErrorOnce, getLifecycleMiddlewareConfig, isLifecycleStreamCallbacksOwnedByBaseProvider, } from "../../utils/lifecycleCallbacks.js";
 import { GEMINI_ELISION_NOTE, planGeminiLoopReclaim, previewGeminiToolResponseText, } from "../../context/geminiLoopGuard.js";
 import { ANTHROPIC_ELISION_NOTE, planAnthropicLoopReclaim, previewAnthropicToolResultText, } from "../../context/anthropicLoopGuard.js";
 import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, toVertexAnthropicModelId, } from "../../utils/modelDetection.js";
@@ -5618,24 +5619,47 @@ export class GoogleVertexProvider extends BaseProvider {
      * this for free via the AI SDK `wrapStream` middleware; native @google/genai
      * bypasses that wrapper, so native consumers need their lifecycle
      * callbacks invoked from here.
+     *
+     * `BaseProvider.stream()` always passes the result this method returns
+     * through `wrapStreamWithLifecycleCallbacks` afterwards too (that wrapper
+     * has "no early return when there are no callbacks" — see its own doc
+     * comment) — so unconditionally firing here double-fires onChunk/onFinish
+     * for every native Vertex stream. `isLifecycleStreamCallbacksOwnedByBaseProvider`
+     * reads the SAME nested lifecycle config off the SAME `options` object
+     * `wrapStreamWithLifecycleCallbacks` reads from (NeuroLink.applyStreamLifecycleMiddleware
+     * stamps it before either method runs), so both sites agree on which one
+     * actually fires without a second, Vertex-specific marker — and without
+     * relying on a Symbol on the `StreamResult` itself, which would not
+     * survive `withStreamModelFallback`'s rebuild of a plain forwarding object
+     * between this method and `wrapStreamWithLifecycleCallbacks`.
+     *
+     * onError is deliberately NOT gated by that marker — same precedent as
+     * `middleware/builtin/lifecycle.ts`'s `wrapStream` ("onError is NOT
+     * covered by this flag: it keeps its own, independent dedup via
+     * fireOnErrorOnce's shared fired-marker"). `fireOnErrorOnce` stamps the
+     * error so `BaseProvider`'s own catch (which checks
+     * `hasLifecycleErrorFired`) skips its own fire for the same failure.
      */
     wrapStreamResultWithLifecycle(options, result, startTime) {
         const onChunk = options.onChunk;
         const onFinish = options
             .onFinish;
-        const onError = options
-            .onError;
+        // `StreamOptions.onError` is already properly typed as `OnErrorCallback`
+        // (unlike the two casts above, kept from before that field existed on
+        // the type) — read directly so `fireOnErrorOnce` below gets it without
+        // a cast.
+        const onError = options.onError;
         if (typeof onChunk !== "function" &&
             typeof onFinish !== "function" &&
             typeof onError !== "function") {
             return result;
         }
+        const streamCallbacksOwnedByBaseProvider = isLifecycleStreamCallbacksOwnedByBaseProvider(getLifecycleMiddlewareConfig(options));
         const originalIterable = result.stream;
         let accumulated = "";
         let sequence = 0;
-        const provider = this.providerName;
         const fireOnChunk = (payload) => {
-            if (typeof onChunk !== "function") {
+            if (typeof onChunk !== "function" || streamCallbacksOwnedByBaseProvider) {
                 return;
             }
             try {
@@ -5647,7 +5671,8 @@ export class GoogleVertexProvider extends BaseProvider {
             }
         };
         const fireOnFinish = (payload) => {
-            if (typeof onFinish !== "function") {
+            if (typeof onFinish !== "function" ||
+                streamCallbacksOwnedByBaseProvider) {
                 return;
             }
             try {
@@ -5686,21 +5711,18 @@ export class GoogleVertexProvider extends BaseProvider {
                     });
                 }
                 catch (err) {
-                    if (typeof onError === "function") {
-                        try {
-                            const errInst = err instanceof Error ? err : new Error(String(err));
-                            const cbResult = onError({
-                                error: errInst,
-                                duration: Date.now() - startTime,
-                                recoverable: false,
-                            });
-                            Promise.resolve(cbResult).catch((e) => logger.warn(`[${provider}] onError callback rejected: ${e instanceof Error ? e.message : String(e)}`));
-                        }
-                        catch (e) {
-                            logger.warn(`[${provider}] onError callback threw: ${e instanceof Error ? e.message : String(e)}`);
-                        }
-                    }
-                    throw err;
+                    const errInst = err instanceof Error ? err : new Error(String(err));
+                    fireOnErrorOnce(onError, errInst, {
+                        error: errInst,
+                        duration: Date.now() - startTime,
+                        recoverable: false,
+                    });
+                    // Rethrow the normalized `errInst` (not the raw `err`) so the
+                    // fired-mark `fireOnErrorOnce` just stamped on it propagates to
+                    // BaseProvider's own catch (`hasLifecycleErrorFired`), which
+                    // would otherwise see an unstamped error and fire onError again
+                    // for the same logical failure.
+                    throw errInst;
                 }
             },
         };

package/dist/utils/lifecycleCallbacks.d.ts

@@ -27,7 +27,36 @@
  * structuredClone / cross-realm postMessage where a closed-over
  * WeakSet does not.
  */
-import type { LifecycleErrorPayload, OnErrorCallback } from "../types/index.js";
+import type { LifecycleErrorPayload, LifecycleMiddlewareConfig, OnErrorCallback } from "../types/index.js";
+/**
+ * Read the consumer-facing lifecycle callbacks buried inside a request's
+ * middleware blob. The parameter is `unknown` on purpose: request options
+ * arrive as several structurally-unrelated shapes (StreamOptions,
+ * TextGenerationOptions), and the lifecycle branch is an optional add-on
+ * none of them declare — a single structural view keeps the read cast-free
+ * at every call site.
+ *
+ * Shared (moved out of `BaseProvider`) because two independent firing sites
+ * now need the same read: `BaseProvider.wrapStreamWithLifecycleCallbacks`
+ * (every provider's stream) and `GoogleVertexProvider.wrapStreamResultWithLifecycle`
+ * (Vertex's own native-stream firer, which must check the SAME
+ * `isLifecycleStreamCallbacksOwnedByBaseProvider` marker on the SAME nested
+ * config object that BaseProvider's wrapper reads from `options`, so that
+ * both sites agree on who owns firing without a second marker).
+ */
+export declare function getLifecycleMiddlewareConfig(options: unknown): LifecycleMiddlewareConfig | undefined;
+/**
+ * Stamp a stream lifecycle config object with
+ * `STREAM_CALLBACKS_OWNED_BY_BASE_PROVIDER`. See that symbol's doc comment
+ * for who may call this (only `applyStreamLifecycleMiddleware`) and why.
+ */
+export declare function markLifecycleStreamCallbacksOwnedByBaseProvider(config: object): void;
+/**
+ * True when `markLifecycleStreamCallbacksOwnedByBaseProvider` already
+ * stamped this config. The model-level lifecycle middleware reads this to
+ * decide whether to fire its own onChunk/onFinish for a stream config.
+ */
+export declare function isLifecycleStreamCallbacksOwnedByBaseProvider(config: unknown): boolean;
 /**
  * Returns true when `markLifecycleErrorFired` or a previous
  * `fireOnErrorOnce` call has already stamped this error.

package/dist/utils/lifecycleCallbacks.js

@@ -28,6 +28,99 @@
  * WeakSet does not.
  */
 const ON_ERROR_FIRED = Symbol.for("neurolink.onErrorFired");
+/**
+ * Read the consumer-facing lifecycle callbacks buried inside a request's
+ * middleware blob. The parameter is `unknown` on purpose: request options
+ * arrive as several structurally-unrelated shapes (StreamOptions,
+ * TextGenerationOptions), and the lifecycle branch is an optional add-on
+ * none of them declare — a single structural view keeps the read cast-free
+ * at every call site.
+ *
+ * Shared (moved out of `BaseProvider`) because two independent firing sites
+ * now need the same read: `BaseProvider.wrapStreamWithLifecycleCallbacks`
+ * (every provider's stream) and `GoogleVertexProvider.wrapStreamResultWithLifecycle`
+ * (Vertex's own native-stream firer, which must check the SAME
+ * `isLifecycleStreamCallbacksOwnedByBaseProvider` marker on the SAME nested
+ * config object that BaseProvider's wrapper reads from `options`, so that
+ * both sites agree on who owns firing without a second marker).
+ */
+export function getLifecycleMiddlewareConfig(options) {
+    return options?.middleware
+        ?.middlewareConfig?.lifecycle?.config;
+}
+/**
+ * Marks a stream lifecycle config as "BaseProvider.wrapStreamWithLifecycleCallbacks
+ * already fires onChunk/onFinish for this config, authoritatively, from
+ * NeuroLink's own normalized stream — the model-level lifecycle middleware
+ * (middleware/builtin/lifecycle.ts) must not ALSO fire them from the raw
+ * per-provider V3 chunks it sees."
+ *
+ * Only `NeuroLink.applyStreamLifecycleMiddleware()` stamps a config with this
+ * marker, and only for stream()'s config: it is the one function that builds
+ * a lifecycle config fresh from stream()'s top-level onChunk/onFinish/onError
+ * options, for a call that unconditionally passes through
+ * `BaseProvider.wrapStreamWithLifecycleCallbacks` afterwards — see that
+ * method's doc comment ("the only point every provider's stream passes
+ * through unconditionally"). Without this marker both layers fire
+ * onChunk/onFinish for the same logical stream: once (unreliable, raw,
+ * provider-shape-dependent) from the model-level middleware, once (reliable,
+ * normalized) from BaseProvider.
+ *
+ * `NeuroLink.applyGenerateLifecycleMiddleware()` must NEVER stamp its config
+ * this way. BaseProvider has no equivalent guaranteed-delivery layer for
+ * generate()'s onFinish: `BaseProvider.finalizeNativeGenerate`'s own doc
+ * comment states onFinish is deliberately NOT fired there because "the
+ * native paths now wrap their model, so the lifecycle middleware fires it" —
+ * the model-level middleware is the SOLE firing site for every native
+ * generate loop that goes through the model wrap (sagemaker,
+ * openaiChatCompletionsBase, anthropic). The one generate path that bypasses
+ * the model wrap (GoogleVertex's native @google/genai loop) fires onFinish
+ * itself via `BaseProvider.fireGenerateOnFinish` precisely because the
+ * middleware never runs for it. Stamping the generate config would make the
+ * model-level middleware suppress its own firing with nothing left to fire
+ * it, silently breaking onFinish for every one of those providers.
+ *
+ * A config a consumer builds directly — e.g. calling the exported
+ * `createLifecycleMiddleware` and applying it to their own model via the
+ * `ai` package's `wrapLanguageModel`, entirely outside NeuroLink's
+ * BaseProvider/stream()/generate() call path — is never stamped, so that
+ * standalone use keeps firing onChunk/onFinish exactly as before (CLAUDE.md
+ * rule 5: public SDK API must not break existing callers).
+ *
+ * Symbol-stamped on the object itself (not a typed field) for the same
+ * reason as `ON_ERROR_FIRED` above: it survives across separate module
+ * copies of the same config object where a closed-over WeakSet would not.
+ */
+const STREAM_CALLBACKS_OWNED_BY_BASE_PROVIDER = Symbol.for("neurolink.lifecycleStreamCallbacksOwnedByBaseProvider");
+/**
+ * Stamp a stream lifecycle config object with
+ * `STREAM_CALLBACKS_OWNED_BY_BASE_PROVIDER`. See that symbol's doc comment
+ * for who may call this (only `applyStreamLifecycleMiddleware`) and why.
+ */
+export function markLifecycleStreamCallbacksOwnedByBaseProvider(config) {
+    try {
+        Object.defineProperty(config, STREAM_CALLBACKS_OWNED_BY_BASE_PROVIDER, {
+            value: true,
+            enumerable: false,
+            writable: false,
+            configurable: false,
+        });
+    }
+    catch {
+        // Non-extensible config object — worst case is the pre-fix double fire.
+    }
+}
+/**
+ * True when `markLifecycleStreamCallbacksOwnedByBaseProvider` already
+ * stamped this config. The model-level lifecycle middleware reads this to
+ * decide whether to fire its own onChunk/onFinish for a stream config.
+ */
+export function isLifecycleStreamCallbacksOwnedByBaseProvider(config) {
+    if (config === null || typeof config !== "object") {
+        return false;
+    }
+    return (config[STREAM_CALLBACKS_OWNED_BY_BASE_PROVIDER] === true);
+}
 function stampFired(error) {
     try {
         Object.defineProperty(error, ON_ERROR_FIRED, {

package/docs-site/static/search-index.json

@@ -7106,17 +7106,17 @@
 {"objectID":"7bc31a9a4e8ceaa9d384ce6953e41c6991344d5affeecf269a14248d769eb2f3","title":"\"xAI account has insufficient quota\"","url":"/docs/getting-started/providers/xai#xai-account-has-insufficient-quota","content":"Top up at https://console.x.ai/.","hierarchy":{"lvl0":"Getting Started","lvl1":"xAI Grok Provider Guide","lvl2":"\"xAI account has insufficient quota\"","lvl3":""}},
 {"objectID":"62c0c746ffa186a922276c344852f82e4ee3242f81c67b58a433defc4f4a4924","title":"\"Model not found\"","url":"/docs/getting-started/providers/xai#model-not-found","content":"Use one of the documented model IDs above. Custom fine-tunes are not\nexposed through the public API at this time.","hierarchy":{"lvl0":"Getting Started","lvl1":"xAI Grok Provider Guide","lvl2":"\"Model not found\"","lvl3":""}},
 {"objectID":"a55b6d892c11d17b5222d76096529452815cd15809b93c491a3c484756185910","title":"See Also","url":"/docs/getting-started/providers/xai#see-also","content":"Adding a new LLM provider — internal reference for the integration pattern this provider follows\nDeepSeek Provider — sibling OpenAI-compat provider with reasoning models\nGroq Provider — sibling OpenAI-compat provider with sub-100ms inference\n\nNeed Help? Open a GitHub Discussion or issue.","hierarchy":{"lvl0":"Getting Started","lvl1":"xAI Grok Provider Guide","lvl2":"See Also","lvl3":""}},
-{"objectID":"03a891da2cc3529b3e4bfc042e5834454a779a2d3fa9389367ba4b3d05266871","title":"XOR Provider Guide","url":"/docs/getting-started/providers/xor","content":"XOR Provider Guide\n\nA provider of decide — the same typed boolean / choice /\nscore answers as TypeSafe's Jev and Laya, from\nJuspay's open-weights model, and the one that also reads images and a video. It\nemits no text at all.\n\nOverview\n\nXOR is Juspay's Apache-2.0 decision model, post-trained from Qwen3.6-35B-A3B;\nits model id is xor-1.1. You send one state plus named, typed questions, and\noptionally images or a video. XOR answers every question in a single batched\npass and returns a typed answer for each. NeuroLink calls whatever base URL you\nconfigure — a deployment of the model, or a LiteLLM proxy with a route to one.\nThere is no built-in endpoint. The weights and setup instructions are at\nhuggingface.co/juspay/xor.\n\nKey Facts\n\n|                       |                                                                      |\n| --------------------- | -------------------------------------------------------------------- |\n| Inference type        | decide only                                                        |\n| Model                 | xor-1.1 by default; XOR_MODEL overrides it                       |\n| Media                 | up to 8 images and one video; the whole request body at most 8 MB    |\n| Input window          | about 200,000 estimated tokens of state                              |\n| Questions per request | no cap in NeuroLink; a choice or score takes 2 to 255 options    |\n| Endpoint              | <base URL>/v1/systemone; the base URL is required, with no default |\n| Precedence            | used automatically only when TypeSafe and Laya are not configured    |\n\nQuick Start\nGet an endpoint and a key\n\nRun a deployment of XOR (see\nhuggingface.co/juspay/xor), or use a\nLiteLLM proxy with a route to one. NeuroLink posts to <base URL>/v1/systemone.\nThe base URL is the origin of the deployment or of the proxy route, and a\ntrailing /v1 is accepted. On a LiteLLM proxy the key's team must be allowed\nthe xor-1.1 model; otherwise the proxy answers 403 team_model_access_denied.\nConfigure\n\nBoth the base URL and the key are required. Set them in the environment:\n\nor in the config passed to the SDK, exactly as for any other provider. Values\npassed per call override the constructor's, which override the environment:\nUse it\n\nFrom the CLI\n\nThe CLI reads the same environment variables:\n\nImages and video\n\nXOR reads images and one video alongside the state. TypeSafe and Laya do not.\n\nFrom the CLI, pass --image <path> (repeatable) and --video <path>:\n\nThe rules:\nUp to 8 images and one video per request, in images and video.\nEach is a Buffer, a local file path or a data: URL. An http(s) URL is\n  refused: NeuroLink does not fetch media for you.\nThe type comes from the bytes, not the file extension: PNG, JPEG, WebP\n  and GIF images, and MP4, MOV and WebM video. NeuroLink\n  sends a Buffer or a file to XOR as a data: URL. A data: URL you pass\n  yourself must hold base64 image or video content, and is sent as given.\nThe whole request body may be at most 8 MB. The limit applies to the\n  encoded body, so the base64 form counts, not the size of the files on disk. A\n  file over the limit is refused from its size, before it is read.\nWhat can be checked locally is refused before any request, as a\n  non-retryable invalid_request: a missing file, a directory, an empty Buffer\n  or file, bytes that are not a recognised image or video, a remote URL or any\n  other URL scheme, a string that is not a path or a data: URL, more than 8\n  images, or a body over 8 MB. Bytes with the right signature that the model\n  cannot decode are sent, and the server's refusal comes back as a server\n  error, retried once.\nTypeSafe and Laya refuse media too, before any request, and the error\n  names the providers that accept it.\nImages and a video can be sent together (up to 8 images and one video),\n  but the model does not reliably tell the two apart.\nThe result carries mediaBytes, the encoded size of the media sent. The\n  decide spans carry decision.images.count and decision.media.bytes, and\n  never any base64.\n\nWhen NeuroLink uses it\n\nEvery built-in consumer of decide — model routing, relevance-driven\ncompaction, tool routing and RAG planning — asks for the default decision\nprovider. That is the first one that is configured, in the environment or in the\ncredentials passed to the SDK, in the order TypeSafe, Laya, XOR. TypeSafe\ncounts with either of its keys, TYPESAFE_API_KEY or AI_GATEWAY_API_KEY. Laya\nand XOR each count only with both their key and their base URL. A caller can\nalways name XOR with provider: \"xor\". So:\nA TypeSafe key, or Laya's key and base URL, plus XOR's key and base URL:\n  built-in features use TypeSafe or Laya, in that order; XOR runs only where a\n  caller asks for provider: \"xor\".\nOnly XOR's key and base URL: built-in features use XOR.\nAn XOR key with no base URL: XOR is not configured. Built-in features\n  ignore it, and provider: \"xor\" fails with XOR requires a base URL.\nNone of them: everything behaves exactly as it did without a ","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"","lvl3":""}},
+{"objectID":"03a891da2cc3529b3e4bfc042e5834454a779a2d3fa9389367ba4b3d05266871","title":"XOR Provider Guide","url":"/docs/getting-started/providers/xor","content":"XOR Provider Guide\n\nA provider of decide — the same typed boolean / choice /\nscore answers as TypeSafe's Jev and Laya, from\nJuspay's open-weights model, and the one that also reads images and a video. It\nemits no text at all.\n\nOverview\n\nXOR is Juspay's Apache-2.0 decision model, post-trained from Qwen3.6-35B-A3B;\nits model id is xor-1.1. You send one state plus named, typed questions, and\noptionally images or a video. XOR answers every question in a single batched\npass and returns a typed answer for each. NeuroLink calls whatever base URL you\nconfigure — a deployment of the model, or a LiteLLM proxy with a route to one.\nThere is no built-in endpoint. The weights and setup instructions are at\nhuggingface.co/juspay/xor.\n\nKey Facts\n\n|                       |                                                                      |\n| --------------------- | -------------------------------------------------------------------- |\n| Inference type        | decide only                                                        |\n| Model                 | xor-1.1 by default; XOR_MODEL sets the name your proxy uses      |\n| Media                 | up to 8 images and one video; the whole request body at most 8 MB    |\n| Input window          | about 200,000 estimated tokens of state                              |\n| Questions per request | no cap in NeuroLink; a choice or score takes 2 to 255 options    |\n| Endpoint              | <base URL>/v1/systemone; the base URL is required, with no default |\n| Precedence            | used automatically only when TypeSafe and Laya are not configured    |\n\nQuick Start\nGet an endpoint and a key\n\nRun a deployment of XOR (see\nhuggingface.co/juspay/xor), or use a\nLiteLLM proxy with a route to one. NeuroLink posts to <base URL>/v1/systemone.\nThe base URL is the origin of the deployment or of the proxy route, and a\ntrailing /v1 is accepted. On a LiteLLM proxy the key's team must be allowed\nthe model you ask for (xor-1.1 by default); otherwise the proxy answers 403\nteam_model_access_denied, and its message lists the models the team can use. A\nproxy may serve XOR under a name of its own: set XOR_MODEL to that name.\nConfigure\n\nBoth the base URL and the key are required. Set them in the environment:\n\nor in the config passed to the SDK, exactly as for any other provider. Values\npassed per call override the constructor's, which override the environment:\nUse it\n\nFrom the CLI\n\nThe CLI reads the same environment variables:\n\nImages and video\n\nXOR reads images and one video alongside the state. TypeSafe and Laya do not.\n\nFrom the CLI, pass --image <path> (repeatable) and --video <path>:\n\nThe rules:\nUp to 8 images and one video per request, in images and video.\nEach is a Buffer, a local file path or a data: URL. An http(s) URL is\n  refused: NeuroLink does not fetch media for you.\nThe type comes from the bytes, not the file extension: PNG, JPEG, WebP\n  and GIF images, and MP4, MOV and WebM video. NeuroLink\n  sends a Buffer or a file to XOR as a data: URL. A data: URL you pass\n  yourself must hold base64 image or video content, and is sent as given.\nThe whole request body may be at most 8 MB. The limit applies to the\n  encoded body, so the base64 form counts, not the size of the files on disk. A\n  file over the limit is refused from its size, before it is read.\nWhat can be checked locally is refused before any request, as a\n  non-retryable invalid_request: a missing file, a directory, an empty Buffer\n  or file, bytes that are not a recognised image or video, a remote URL or any\n  other URL scheme, a string that is not a path or a data: URL, more than 8\n  images, or a body over 8 MB. Bytes with the right signature that the model\n  cannot decode are sent, and the server's refusal comes back as a server\n  error, retried once.\nTypeSafe and Laya refuse media too, before any request, and the error\n  names the providers that accept it.\nImages and a video can be sent together (up to 8 images and one video),\n  but the model does not reliably tell the two apart.\nThe result carries mediaBytes, the encoded size of the media sent. The\n  decide spans carry decision.images.count and decision.media.bytes, and\n  never any base64.\n\nWhen NeuroLink uses it\n\nEvery built-in consumer of decide — model routing, relevance-driven\ncompaction, tool routing and RAG planning — asks for the default decision\nprovider. That is the first one that is configured, in the environment or in the\ncredentials passed to the SDK, in the order TypeSafe, Laya, XOR. TypeSafe\ncounts with either of its keys, TYPESAFE_API_KEY or AI_GATEWAY_API_KEY. Laya\nand XOR each count only with both their key and their base URL. A caller can\nalways name XOR with provider: \"xor\". So:\nA TypeSafe key, or Laya's key and base URL, plus XOR's key and base URL:\n  built-in features use TypeSafe or Laya, in that order; XOR runs only where a\n  caller asks for provider: \"xor\".\nOnly XOR's key and base URL: built-in features use XOR.\nAn XOR key with no base URL: XOR is not configure","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"","lvl3":""}},
 {"objectID":"5ed0d5759a64d045ba6c8acb04b0b6e6fef6f00399b88df9847c053d52a8e70c","title":"XOR Provider Guide","url":"/docs/getting-started/providers/xor#xor-provider-guide","content":"A provider of decide — the same typed boolean / choice /\nscore answers as TypeSafe's Jev and Laya, from\nJuspay's open-weights model, and the one that also reads images and a video. It\nemits no text at all.","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"XOR Provider Guide","lvl3":""}},
 {"objectID":"62f1da4b03072e86ddddfcfed9098a9efa475d349ea26f88c901347eca7fc77a","title":"Overview","url":"/docs/getting-started/providers/xor#overview","content":"XOR is Juspay's Apache-2.0 decision model, post-trained from Qwen3.6-35B-A3B;\nits model id is xor-1.1. You send one state plus named, typed questions, and\noptionally images or a video. XOR answers every question in a single batched\npass and returns a typed answer for each. NeuroLink calls whatever base URL you\nconfigure — a deployment of the model, or a LiteLLM proxy with a route to one.\nThere is no built-in endpoint. The weights and setup instructions are at\nhuggingface.co/juspay/xor.","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"Overview","lvl3":""}},
-{"objectID":"2a68b1796658b1e42d1fb20868e2f28c9b9b13e9e83ebb2ac4411de95d15b8e3","title":"Key Facts","url":"/docs/getting-started/providers/xor#key-facts","content":"|                       |                                                                      |\n| --------------------- | -------------------------------------------------------------------- |\n| Inference type        | decide only                                                        |\n| Model                 | xor-1.1 by default; XOR_MODEL overrides it                       |\n| Media                 | up to 8 images and one video; the whole request body at most 8 MB    |\n| Input window          | about 200,000 estimated tokens of state                              |\n| Questions per request | no cap in NeuroLink; a choice or score takes 2 to 255 options    |\n| Endpoint              | <base URL>/v1/systemone; the base URL is required, with no default |\n| Precedence            | used automatically only when TypeSafe and Laya are not configured    |","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"Key Facts","lvl3":""}},
-{"objectID":"06cdd61cf369f5af93c8e03841be4ebddcc8e1fde819b193e35a9fabfa7db51a","title":"1. Get an endpoint and a key","url":"/docs/getting-started/providers/xor#1-get-an-endpoint-and-a-key","content":"Run a deployment of XOR (see\nhuggingface.co/juspay/xor), or use a\nLiteLLM proxy with a route to one. NeuroLink posts to <base URL>/v1/systemone.\nThe base URL is the origin of the deployment or of the proxy route, and a\ntrailing /v1 is accepted. On a LiteLLM proxy the key's team must be allowed\nthe xor-1.1 model; otherwise the proxy answers 403 team_model_access_denied.","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"1. Get an endpoint and a key","lvl3":""}},
+{"objectID":"2a68b1796658b1e42d1fb20868e2f28c9b9b13e9e83ebb2ac4411de95d15b8e3","title":"Key Facts","url":"/docs/getting-started/providers/xor#key-facts","content":"|                       |                                                                      |\n| --------------------- | -------------------------------------------------------------------- |\n| Inference type        | decide only                                                        |\n| Model                 | xor-1.1 by default; XOR_MODEL sets the name your proxy uses      |\n| Media                 | up to 8 images and one video; the whole request body at most 8 MB    |\n| Input window          | about 200,000 estimated tokens of state                              |\n| Questions per request | no cap in NeuroLink; a choice or score takes 2 to 255 options    |\n| Endpoint              | <base URL>/v1/systemone; the base URL is required, with no default |\n| Precedence            | used automatically only when TypeSafe and Laya are not configured    |","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"Key Facts","lvl3":""}},
+{"objectID":"06cdd61cf369f5af93c8e03841be4ebddcc8e1fde819b193e35a9fabfa7db51a","title":"1. Get an endpoint and a key","url":"/docs/getting-started/providers/xor#1-get-an-endpoint-and-a-key","content":"Run a deployment of XOR (see\nhuggingface.co/juspay/xor), or use a\nLiteLLM proxy with a route to one. NeuroLink posts to <base URL>/v1/systemone.\nThe base URL is the origin of the deployment or of the proxy route, and a\ntrailing /v1 is accepted. On a LiteLLM proxy the key's team must be allowed\nthe model you ask for (xor-1.1 by default); otherwise the proxy answers 403\nteam_model_access_denied, and its message lists the models the team can use. A\nproxy may serve XOR under a name of its own: set XOR_MODEL to that name.","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"1. Get an endpoint and a key","lvl3":""}},
 {"objectID":"540db8a33720c64f9e3e59c312e3d3e2476799c726c6e5729729ecaf2bbefa05","title":"2. Configure","url":"/docs/getting-started/providers/xor#2-configure","content":"Both the base URL and the key are required. Set them in the environment:\n\nor in the config passed to the SDK, exactly as for any other provider. Values\npassed per call override the constructor's, which override the environment:","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"2. Configure","lvl3":""}},
 {"objectID":"3fd4afc9a2670046c937e06586a65b3b5eadb6de1560ee1e1a3abf5f05524876","title":"From the CLI","url":"/docs/getting-started/providers/xor#from-the-cli","content":"The CLI reads the same environment variables:","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"From the CLI","lvl3":""}},
 {"objectID":"90a0f1f65868c0d5b68bb8fb5828a32f704d4ed3a164081275a6837b65a8e2f7","title":"Images and video","url":"/docs/getting-started/providers/xor#images-and-video","content":"XOR reads images and one video alongside the state. TypeSafe and Laya do not.\n\nFrom the CLI, pass --image <path> (repeatable) and --video <path>:\n\nThe rules:\nUp to 8 images and one video per request, in images and video.\nEach is a Buffer, a local file path or a data: URL. An http(s) URL is\n  refused: NeuroLink does not fetch media for you.\nThe type comes from the bytes, not the file extension: PNG, JPEG, WebP\n  and GIF images, and MP4, MOV and WebM video. NeuroLink\n  sends a Buffer or a file to XOR as a data: URL. A data: URL you pass\n  yourself must hold base64 image or video content, and is sent as given.\nThe whole request body may be at most 8 MB. The limit applies to the\n  encoded body, so the base64 form counts, not the size of the files on disk. A\n  file over the limit is refused from its size, before it is read.\nWhat can be checked locally is refused before any request, as a\n  non-retryable invalid_request: a missing file, a directory, an empty Buffer\n  or file, bytes that are not a recognised image or video, a remote URL or any\n  other URL scheme, a string that is not a path or a data: URL, more than 8\n  images, or a body over 8 MB. Bytes with the right signature that the model\n  cannot decode are sent, and the server's refusal comes back as a server\n  error, retried once.\nTypeSafe and Laya refuse media too, before any request, and the error\n  names the providers that accept it.\nImages and a video can be sent together (up to 8 images and one video),\n  but the model does not reliably tell the two apart.\nThe result carries mediaBytes, the encoded size of the media sent. The\n  decide spans carry decision.images.count and decision.media.bytes, and\n  never any base64.","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"Images and video","lvl3":""}},
 {"objectID":"4fea1eacec247a5a95e9c0d017549cb5233da507c593a841ce0e392eb2d11e2a","title":"When NeuroLink uses it","url":"/docs/getting-started/providers/xor#when-neurolink-uses-it","content":"Every built-in consumer of decide — model routing, relevance-driven\ncompaction, tool routing and RAG planning — asks for the default decision\nprovider. That is the first one that is configured, in the environment or in the\ncredentials passed to the SDK, in the order TypeSafe, Laya, XOR. TypeSafe\ncounts with either of its keys, TYPESAFE_API_KEY or AI_GATEWAY_API_KEY. Laya\nand XOR each count only with both their key and their base URL. A caller can\nalways name XOR with provider: \"xor\". So:\nA TypeSafe key, or Laya's key and base URL, plus XOR's key and base URL:\n  built-in features use TypeSafe or Laya, in that order; XOR runs only where a\n  caller asks for provider: \"xor\".\nOnly XOR's key and base URL: built-in features use XOR.\nAn XOR key with no base URL: XOR is not configured. Built-in features\n  ignore it, and provider: \"xor\" fails with XOR requires a base URL.\nNone of them: everything behaves exactly as it did without a decision\n  model.","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"When NeuroLink uses it","lvl3":""}},
-{"objectID":"20a784de9dff5b3afa1f5ee7c0c60e268a7274b7e0c2a447aca431642f8fcabc","title":"Limits","url":"/docs/getting-started/providers/xor#limits","content":"The window is large, but shared. NeuroLink allows about 200,000 estimated\ntokens of state, and refuses more before any network call, with\nmax_tokens_exceeded. The size is an estimate, not XOR's tokenizer: about four\ncharacters per token for ASCII text, and one token per character for other\nscripts, which errs toward refusing. The 200,000 figure is a conservative\ndefault under the deployment's 250,000-token prefill, and that prefill is shared\nby the state, the questions and any media. It has not been measured against a\nlive deployment. A state near the limit, or a lot of media, can therefore still\nbe refused by the server as too long. That arrives as max_tokens_exceeded\n(not retried) when the status is 413 or the message says the context was too\nlong, and otherwise as server (retried once). Built-in consumers treat a\nrefusal as \"carry on as before\".\n\nNo question cap. NeuroLink sets none. A choice or score takes 2 to 255\noptions, which the server enforces.\n\nThe default timeout is 5 seconds. Override it per call with timeoutMs, or\nwith --timeout on the CLI.","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"Limits","lvl3":""}},
-{"objectID":"d3945a40a2095e352b8f5f71228a59bbcb1cb60823696dbe20f3fafffe6b7c29","title":"Errors","url":"/docs/getting-started/providers/xor#errors","content":"| Reply                                                        | Kind                                                      | Retried   |\n| ------------------------------------------------------------ | --------------------------------------------------------- | --------- |\n| 401                                                          | authentication — the provider instance stops retrying   | no        |\n| 403 / 402                                                    | invalid_request — fixable; the instance is not disabled | no        |\n| 413, or a 5xx other than 503 saying the context was exceeded | max_tokens_exceeded                                     | no        |\n| any other 4xx (for example 422, 404)                         | invalid_request                                         | no        |\n| 429                                                          | rate_limit                                              | yes, once |\n| 503                                                          | overloaded                                              | yes, once |\n| other 5xx                                                    | server                                                  | yes, once |\n| state over the window (local)                                | max_tokens_exceeded, with no network call               | no        |\n| unusable media (local)                                       | invalid_request, with no network call                   | no        |\n| no base URL configured (local)                               | invalid_request, with no network call                   | no        |\n\nA 403 or 402 is deliberately not authentication. On a LiteLLM proxy a 403\nmeans the key's team does not allow xor-1.1 (team_model_access_denied), and\na 402 means the team has no budget. An admin can fix either, so the provider\ninstance keeps working once it is fixed and is not disabled. A 401 does disable\nthe instance: it stops sending requests after the first rejection, b","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"Errors","lvl3":""}},
+{"objectID":"20a784de9dff5b3afa1f5ee7c0c60e268a7274b7e0c2a447aca431642f8fcabc","title":"Limits","url":"/docs/getting-started/providers/xor#limits","content":"The window is large, but shared. NeuroLink allows about 200,000 estimated\ntokens of state, and refuses more before any network call, with\nmax_tokens_exceeded. The size is an estimate, not XOR's tokenizer: about four\ncharacters per token for ASCII text, and one token per character for other\nscripts, which errs toward refusing. The 200,000 figure is a conservative\ndefault under the deployment's 250,000-token prefill, and that prefill is shared\nby the state, the questions and any media.\n\nOn one live LiteLLM route, a state of about 215,000 tokens (1.2 million\ncharacters of English) was accepted, and one of about 430,000 tokens was refused\nwith a 500 whose text says the input is longer than the model's 262,144-token\ncontext length. The estimate is not exact in either direction. English averaged\nabout 5.6 characters per token there, so the estimate over-counts it. Dense JSON\naveraged about 1.8, so a large dense state can pass the local check and still be\nrefused by the server. A structured (non-string) state of 100,000 Chinese\ncharacters also passed the local check and was refused by the server.\n\nA state near the limit, or a lot of media, can therefore still be refused by the\nserver as too long. That arrives as max_tokens_exceeded (not retried) when the\nstatus is 413 or the message says the context was too long, and otherwise as\nserver (retried once). Built-in consumers treat a refusal as \"carry on as\nbefore\".\n\nA proxy may cap parallel requests. On that route the key allowed 5 at a\ntime. After a burst of rejected requests (403 and 422 replies), every request\nwas answered 429 for about half an hour. NeuroLink retries a 429 once.\n\nNo question cap. NeuroLink sets none. A choice or score takes 2 to 255\noptions, which the server enforces.\n\nThe default timeout is 5 seconds. Override it per call with timeoutMs, or\nwith --timeout on the CLI.","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"Limits","lvl3":""}},
+{"objectID":"d3945a40a2095e352b8f5f71228a59bbcb1cb60823696dbe20f3fafffe6b7c29","title":"Errors","url":"/docs/getting-started/providers/xor#errors","content":"| Reply                                                        | Kind                                                      | Retried   |\n| ------------------------------------------------------------ | --------------------------------------------------------- | --------- |\n| 401                                                          | authentication — the provider instance stops retrying   | no        |\n| 403 / 402                                                    | invalid_request — fixable; the instance is not disabled | no        |\n| 413, or a 5xx other than 503 saying the context was exceeded | max_tokens_exceeded                                     | no        |\n| any other 4xx (for example 422, 404)                         | invalid_request                                         | no        |\n| 429                                                          | rate_limit                                              | yes, once |\n| 503                                                          | overloaded                                              | yes, once |\n| other 5xx                                                    | server                                                  | yes, once |\n| state over the window (local)                                | max_tokens_exceeded, with no network call               | no        |\n| unusable media (local)                                       | invalid_request, with no network call                   | no        |\n| no base URL configured (local)                               | invalid_request, with no network call                   | no        |\n\nA 403 or 402 is deliberately not authentication. On a LiteLLM proxy a 403\nmeans the key's team does not allow the model you asked for\n(team_model_access_denied), and\na 402 means the team has no budget. An admin can fix either, so the provider\ninstance keeps working once it is fixed and is not disabled. A 401 does disable\nthe instance: it stops sending requests after the fi","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"Errors","lvl3":""}},
 {"objectID":"37466cda852e51cad898009d283cae74e18a20774a3ca0fad9f146e3efb8a5a9","title":"Troubleshooting","url":"/docs/getting-started/providers/xor#troubleshooting","content":"XOR requires a base URL — set XOR_BASE_URL, or pass\n  credentials.xor.baseURL. There is no default endpoint.\nThe XOR base URL must not carry credentials… — the base URL has a user\n  name, a password, a query string or a fragment. Set it to the origin only, for\n  example https://your-proxy.example.com, and give the key through\n  XOR_API_KEY or credentials.xor.apiKey.\nThe XOR base URL must start with https:// or http:// — the value has no\n  scheme (for example xor.internal:8080) or uses another scheme. Add\n  https:// or http://.\nThe XOR base URL is not a valid absolute URL — the value cannot be\n  parsed as a URL. Set it to an absolute origin.\nXOR requires an API key — set XOR_API_KEY, or pass\n  credentials.xor.apiKey.\nA 401 — the endpoint rejected the key. The provider instance stops\n  retrying after a rejection, so fix the key and construct a new one.\nA 403 with team_model_access_denied — the LiteLLM proxy's team for this\n  key does not allow xor-1.1. Add the model to the team; the instance works\n  again without a restart.\nmax_tokens_exceeded — the state is over about 200,000 estimated tokens,\n  or the state, the questions and the media together are more than the\n  deployment's prefill. Shorten the state, or send fewer or smaller images or a\n  shorter video.\nImages seem to be ignored — a deployment started without\n  OPENJEV_IMAGES=1 answers 200 and silently ignores images, and NeuroLink\n  cannot detect that. Send a red image and a blue image and check that the two\n  answers differ. Video is not affected.\nBuilt-in routing never uses XOR — a TypeSafe key, or Laya's key and base\n  URL, is also set and takes precedence, or XOR has no base URL.","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"Troubleshooting","lvl3":""}},
 {"objectID":"cdd6e7c83dfa23afa5cf0bb7d23081881600f72a5ac64ca56d383736c209f285","title":"See also","url":"/docs/getting-started/providers/xor#see-also","content":"TypeSafe (Jev) Provider Guide\nLaya Provider Guide\nThe decide inference type\nXOR on Hugging Face","hierarchy":{"lvl0":"Getting Started","lvl1":"XOR Provider Guide","lvl2":"See also","lvl3":""}},
 {"objectID":"b62066defb7f4f21e315563cc367d3573fb4aacd3fa38685f76f1a3b110c0437","title":"Z.AI Provider Guide","url":"/docs/getting-started/providers/z-ai","content":"Z.AI Provider Guide\n\nZ.AI is a Tier-2 catalog provider: OpenAI-wire-compatible, so its entire\nintegration is one JSON file (src/lib/providers/catalog/z-ai.json) rather\nthan hand-written code. That file is the source of truth for everything on this\npage.\n\nVerification status: this entry is docs-verified only, not yet\nlive-verified. The vendor's GET https://api.z.ai/api/paas/v4/models needs\na key (it answers HTTP 401 without one), so the model ids come from Z.AI's\npublic docs and the roster has not been checked. No account was created and no\nAPI key was used to build this entry. evidence.liveMatrix is null until\nsomeone runs the live capability matrix with a real key (see\nVerification status below).\n\nKey Facts\nProvider id: z-ai (alias zai)\nProtocol: OpenAI-compatible (/chat/completions). The\n  OpenAI Python SDK page\n  says \"Z.AI provides interfaces compatible with OpenAI API\" and adds \"In some\n  scenarios, there are still differences between Z.AI and OpenAI interfaces, but\n  this does not affect overall compatibility.\"\nBase URL: https://api.z.ai/api/paas/v4 — the\n  Introduction page calls it\n  \"Z.ai Platform's general API endpoint\". Its warning says GLM Coding Plan users\n  follow the Coding Plan tutorial to configure a dedicated endpoint, and the\n  Coding Plan Endpoint Guide lists\n  https://api.z.ai/api/coding/paas/v4 for OpenAI Chat Completions. This entry\n  uses the general endpoint; Z_AI_BASE_URL overrides it.\nDefault model: glm-5.3 — the default of the model parameter in the\n  Chat Completion reference\n  and the model in its request examples\nModels in catalog: 12, curated from the 21 ids the Chat Completion\n  reference lists (14 in its text-model enum, 7 in its vision-model enum). The\n  nine ids left out to stay inside the 12-model cap are glm-4.5-x,\n  glm-4.5-airx, glm-4.5-flash, glm-4-32b-0414-128k, glm-4.6v,\n  glm-4.6v-flash, glm-4.6v-flashx, glm-4.5v and\n  autoglm-phone-multilingual\nStreaming: supported — the\n  Streaming Messages page\n  documents stream=True with Server-Sent Events, and the Chat Completion\n  reference says the Event Stream ends with a data: [DONE] message\nTool calling: model-dependent — the\n  Function Calling page\n  documents tools and a returned tool_calls array, and the Chat Completion\n  reference says of tool_choice \"The default value is auto, and only auto is\n  supported.\" For vision models it says tools are \"Only supported by\n  GLM-5.3-Flash series, the GLM-4.6V series, and autoglm-phone-multilingual\"\nTools while streaming: supported (true) — the\n  Thinking Mode page\n  gives an Interleaved Thinking + Tool Calling example that sends tools with\n  stream=True and reads tool_calls from the streamed deltas. The\n  Tool Streaming Output page\n  documents a separate tool_stream parameter, which this entry does not set.\n  The Thinking Mode page also says \"thinking blocks should be explicitly\n  preserved and returned together with the tool results.\", and its example\n  appends an assistant message carrying reasoning_content and tool_calls\n  before the tool message; this entry does not set\n  quirks.replayReasoningContent\nStructured output: supported — the\n  Structured Output page\n  documents response_format set to {\"type\": \"json_object\"}. The Chat\n  Completion reference lists text and json_object as the response_format\n  type values, so the entry sets quirks.responseFormatDowngrade to send\n  json_object for schema requests; generate({ schema }) still validates the\n  result client-side. No request with json_schema was sent. The Chat\n  Completion reference says of response_format \"Only text models support this\n  field.\", and the\n  GLM-5.3-Flash/FlashX page\n  lists Structured Output among its Capabilities (\"Supports structured output\n  formats such as JSON for seamless system integration.\")\nStructured output + tools together: not declared (false) — no combined\n  probe was possible without credentials\nVision: glm-5.3-flash and glm-5.3-flashx — the\n  GLM-5.3-Flash/FlashX page\n  shows Input Modality \"Video / Image / Text / File\". The GLM-5.3 page says\n  \"text-only inputs\", and the pages for the other nine catalog models show\n  Input Modalities \"Text\"\nEmbeddings: not declared on this catalog entry\nThinking: not declared (false) — the entry sets none of the thinking\n  or reasoning_effort request parameters. The Chat Completion reference\n  documents both, and the\n  GLM-5.3 page says \"GLM-5.3 always\n  operates with reasoning enabled\"\nBilling: schema value free-tier, see Billing below\nKey format: none declared. The Introduction page shows the header\n  Authorization: Bearer ZAI_API_KEY\n\nQuick Start\nGet an API key\nVisit: https://z.ai/manage-apikey/apikey-list — the Quick Start says to access the Z.AI Open Platform (https://z.ai/model-api) and \"Register or Login.\", then to \"Create an API Key\" in the API Keys management page and \"Copy your API Key for use.\"\nAuthentication is HTTP Bearer: the Introduction page (https://docs.z.ai/api-reference/introduction.md) shows the header Authorization: Bearer ZAIAPIKEY\n","hierarchy":{"lvl0":"Getting Started","lvl1":"Z.AI Provider Guide","lvl2":"","lvl3":""}},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.41.2",
+  "version": "12.41.4",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {
@@ -699,7 +699,7 @@
       "brace-expansion@>=5.0.0 <5.0.12": ">=5.0.12",
       "@opentelemetry/core@>=2.0.0 <2.8.0": ">=2.8.0",
       "qs": "6.16.0",
-      "fastify": "5.12.1",
+      "fastify": "5.12.5",
       "fast-uri": "3.1.8",
       "@xmldom/xmldom": "0.9.12"
     },