@juspay/neurolink 13.8.10 → 13.8.12

package/dist/cli/commands/proxy.js

@@ -13,6 +13,8 @@ import { ensureTelemetry, getLangfuseHealthStatus, } from "../../services/server
 import { logger } from "../../utils/logger.js";
 import { applyAllClients, applyClientsOnProxyStart, restoreAllClients, } from "../proxy-clients/registry.js";
 import { resolveProxyConfigPath } from "../../proxy/proxyConfig.js";
+import { readProxyRequestText } from "../../proxy/requestBodyLimit.js";
+import { RawBodyTooLargeError } from "../../server/utils/rawBody.js";
 import { redactUrlsInText, sanitizeForLog, } from "../../utils/logSanitize.js";
 import { raceWithAbort, withTimeout, } from "../../utils/async/withTimeout.js";
 import { startProxyHttpTrace } from "../../proxy/proxyTracer.js";
@@ -1511,6 +1513,13 @@ export async function createProxyStartApp(params) {
             }),
         ]);
     };
+    /** 413 in the wire format this proxy answers its other request errors in. */
+    const respondRequestTooLarge = async (c, metadata, message) => {
+        if (metadata) {
+            await recordRuntimeError(metadata, 413, "request_too_large", message);
+        }
+        return c.json({ type: "error", error: { type: "request_too_large", message } }, 413);
+    };
     app.onError(async (err, c) => {
         const errMsg = err instanceof Error ? err.message : String(err);
         logger.always(`[proxy] unhandled error: ${errMsg}`);
@@ -1703,7 +1712,13 @@ export async function createProxyStartApp(params) {
             let body;
             let rawBody;
             if (method === "post") {
-                rawBody = await c.req.text().catch(() => undefined);
+                // Bounded before it is parsed, and so before the share gate below
+                // (which needs the model), the way the server adapters bound theirs.
+                const read = await readProxyRequestText(c.req.raw, route.path);
+                if (read instanceof RawBodyTooLargeError) {
+                    return respondRequestTooLarge(c, metadata, read.message);
+                }
+                rawBody = read;
                 try {
                     body = rawBody ? JSON.parse(rawBody) : emptyBody;
                 }

package/dist/factories/providerDescriptors.js

@@ -619,16 +619,28 @@ const HAND_DESCRIPTORS = [
             astralTokensPerChar: 3,
             // Images only. Exactly four tiny images succeeded and five were refused
             // on both models. image/jpg also succeeded and is normalized to JPEG.
-            // Retain the conservative 256,000-byte encoded-body cap: on 2026-10-04
-            // both models accepted 520,000 text characters and refused 525,000 with
-            // 413/code 5021. On 2026-10-03, clef-flash accepted 262,000 and refused
-            // 270,000. Estimates are the encoded body bytes / 4, give or take one. The
-            // threshold moved from 65,527 accepted / 67,527 refused to 130,026 /
-            // 131,276 (clef) and 130,027 / 131,277 (flash); errors still print 65,536.
-            // Inference: the new interval contains 131,072 (twice the printed
-            // figure); reason unknown.
-            // On 2026-10-05 both models accepted PNG bodies up to 492,485 bytes and
-            // refused 532,505 (flash) and 532,499 (clef) with the same 413; the old 195/202 KB boundary is
+            // The 256,000-byte cap on the whole encoded body is NeuroLink's own and is
+            // the same for both models. It is well below what the service takes with
+            // images, since the 413/code 5021 gate does not count them (2026-10-24:
+            // bodies of up to 1.17 MB, images included, passed it on clef-flash). It
+            // is not below clef-flash's edge for the text: the estimate is the
+            // characters of the JSON without `images`, over four, and the refusal is
+            // past twice the window the message prints (24,576 for clef-flash, so
+            // 196,608 characters; 65,536 for clef, so 524,288). That is checked on the
+            // text alone, per model, in cloudflareClef.ts, 1,024 characters short of
+            // the edge. A text that large is out of reach of the state limit below
+            // except through the questions or control characters, which JSON writes
+            // as up to six characters each, so the margin costs a caller nothing.
+            // History: on 2026-10-04 both models accepted 520,000 text characters and
+            // refused 525,000 with 413/code 5021 (the window was then 65,536 for both).
+            // On 2026-10-03, clef-flash accepted 262,000 and refused 270,000. The
+            // threshold had moved from 65,527 accepted / 67,527 refused to 130,026 /
+            // 131,276 (clef) and 130,027 / 131,277 (flash) in a day, and the window
+            // of clef-flash has since fallen to 24,576 (by 2026-10-20), which moved
+            // its edge to 196,608. On 2026-10-05 both models accepted PNG bodies up
+            // to 492,485 bytes and refused 532,505 (flash) and 532,499 (clef) with the
+            // same 413, whose estimate (133,126) was the whole body over four, images
+            // included, which they no longer are. The old 195/202 KB boundary is
             // historical. See the guide for exact model and date coverage.
             media: { maxImages: 4, video: false, maxRequestBytes: 256_000 },
         },

package/dist/models/manifests/cloudflareClef.d.ts

@@ -3,8 +3,10 @@ import type { ProviderModelManifest } from "../../types/index.js";
  * Cloudflare Clef on Workers AI — the `decide` inference type, not text
  * generation, and not the Workers AI text models of the `cloudflare` provider.
  *
- * `contextWindow` is the figure Cloudflare documents (65,536 tokens). The
- * Workers AI endpoint ignored state text past about 2,048 tokens until
+ * `contextWindow` is the window Cloudflare's own error messages print: 65,536
+ * tokens for `clef` (the figure its model page documents) and 24,576 for
+ * `clef-flash`, which printed 65,536 on 2026-10-04 and 24,576 by 2026-10-20.
+ * The Workers AI endpoint ignored state text past about 2,048 tokens until
  * 2026-10-04 and read far more on 2026-10-07 (hosted service or model:
  * unknown), so NeuroLink enforces the limit on the descriptor's
  * `decisionLimits`, not this. `vision` describes `generate()`

package/dist/models/manifests/cloudflareClef.js

@@ -2,8 +2,10 @@
  * Cloudflare Clef on Workers AI — the `decide` inference type, not text
  * generation, and not the Workers AI text models of the `cloudflare` provider.
  *
- * `contextWindow` is the figure Cloudflare documents (65,536 tokens). The
- * Workers AI endpoint ignored state text past about 2,048 tokens until
+ * `contextWindow` is the window Cloudflare's own error messages print: 65,536
+ * tokens for `clef` (the figure its model page documents) and 24,576 for
+ * `clef-flash`, which printed 65,536 on 2026-10-04 and 24,576 by 2026-10-20.
+ * The Workers AI endpoint ignored state text past about 2,048 tokens until
  * 2026-10-04 and read far more on 2026-10-07 (hosted service or model:
  * unknown), so NeuroLink enforces the limit on the descriptor's
  * `decisionLimits`, not this. `vision` describes `generate()`
@@ -34,7 +36,7 @@ export const cloudflareClefManifest = {
         "clef-flash": {
             aliases: ["@cf/cloudflare/clef-flash"],
             displayName: "Cloudflare Clef-flash (9B)",
-            contextWindow: 65_536,
+            contextWindow: 24_576,
             maxOutputTokens: 256,
             vision: false,
             functionCalling: false,

package/dist/providers/cloudflareClef.d.ts

@@ -41,6 +41,15 @@ export declare class CloudflareClefProvider extends SystemOneDecisionProvider {
      * differs from the path.
      */
     protected buildDecisionBody(state: DecisionState, questions: Record<string, Record<string, unknown>>, model: string, media?: DecisionPreparedMedia): Record<string, unknown>;
+    /**
+     * Cloudflare's 413/code 5021 gate, applied before the request is sent: the
+     * text of the body, without its images, may not pass eight characters per
+     * token of the model's window, less a margin (see `TEXT_GATE_WINDOW_TOKENS`).
+     * Refused as `max_tokens_exceeded`, which is how Cloudflare's own 413 is
+     * classified, so a caller sees the same kind whether the refusal is made here
+     * or there.
+     */
+    protected assertWithinVendorLimits(payload: Record<string, unknown>, model: string): void;
     /** A success is `{ result: { model, answers, usage }, success: true }`. */
     protected readDecisionPayload(payload: unknown): unknown;
     protected parseDecisionError(status: number, payload: unknown, requestId: string | undefined): DecisionError;

package/dist/providers/cloudflareClef.js

@@ -15,6 +15,32 @@ const MODEL_PREFIX = "@cf/cloudflare/";
  * is merely large and retry it into the same wait.
  */
 const TIMEOUT_MS_PER_THOUSAND_STATE_TOKENS = 250;
+/**
+ * The context window each model's 413/code 5021 message prints. Cloudflare
+ * refuses a request with that code when its estimate passes twice the window,
+ * and the estimate is the characters of the request's JSON text, without its
+ * `images` array, over four: the images are not counted. Measured to the
+ * character on 2026-10-23 and 2026-10-24: clef-flash accepted a text of 196,609
+ * characters and refused 196,610 (twice 24,576, times four, is 196,608), clef
+ * accepted 524,288 and refused 524,292, with and without images of up to
+ * 1.1 MB in the body. The window of clef-flash fell from 65,536 (2026-10-04) to
+ * 24,576 (by 2026-10-20), so these are measurements to re-check, not constants
+ * of the model. A model missing from the map has no limit of this
+ * kind here: the service answers for it.
+ */
+const TEXT_GATE_WINDOW_TOKENS = new Map([
+    ["clef", 65_536],
+    ["clef-flash", 24_576],
+]);
+/** The estimate is characters / 4 and the refusal is past twice the window. */
+const TEXT_GATE_CHARACTERS_PER_WINDOW_TOKEN = 8;
+/**
+ * Kept below the measured edge. The edge is exact for the bodies that were
+ * probed (one question, an ASCII state, `JSON.stringify`), so the margin is for
+ * what they did not vary, and it is 0.5% of the smaller cap. See the
+ * descriptor for why it costs a caller nothing.
+ */
+const TEXT_GATE_MARGIN_CHARACTERS = 1_024;
 /**
  * Cloudflare account ids are 32 hex digits. The pattern is wider so that a
  * change of format needs no release, but it still keeps `/`, `.`, `?` and
@@ -320,6 +346,31 @@ export class CloudflareClefProvider extends SystemOneDecisionProvider {
             ...(images.length > 0 ? { images } : {}),
         };
     }
+    /**
+     * Cloudflare's 413/code 5021 gate, applied before the request is sent: the
+     * text of the body, without its images, may not pass eight characters per
+     * token of the model's window, less a margin (see `TEXT_GATE_WINDOW_TOKENS`).
+     * Refused as `max_tokens_exceeded`, which is how Cloudflare's own 413 is
+     * classified, so a caller sees the same kind whether the refusal is made here
+     * or there.
+     */
+    assertWithinVendorLimits(payload, model) {
+        const wire = wireModel(model);
+        const window = wire === undefined ? undefined : TEXT_GATE_WINDOW_TOKENS.get(wire);
+        if (window === undefined) {
+            return;
+        }
+        const limit = window * TEXT_GATE_CHARACTERS_PER_WINDOW_TOKEN -
+            TEXT_GATE_MARGIN_CHARACTERS;
+        const characters = JSON.stringify({ ...payload, images: undefined }).length;
+        if (characters > limit) {
+            throw this.decisionError({
+                kind: "max_tokens_exceeded",
+                message: `The request's text, without its images, is ${characters} characters; ${this.vendorLabel()}'s "${wire}" model accepts at most ${limit}. Shorten the state or ask shorter questions.`,
+                retryable: false,
+            });
+        }
+    }
     /** A success is `{ result: { model, answers, usage }, success: true }`. */
     readDecisionPayload(payload) {
         return isRecord(payload) && isRecord(payload.result)
@@ -335,7 +386,7 @@ export class CloudflareClefProvider extends SystemOneDecisionProvider {
             .slice(0, MAX_ERROR_MESSAGE_CHARS) || fallback;
         if (kind === "max_tokens_exceeded") {
             message +=
-                " Cloudflare counts the whole request, image data included, at about four characters per token.";
+                " Cloudflare counts the request's text, without its images, at about four characters per token.";
         }
         else if (parsed?.code === 7000) {
             message += `. Check the model name (Clef is served as "clef" and "clef-flash") and the base URL, which must end in /client/v4 and name your account.`;

package/dist/providers/systemOneDecision.d.ts

@@ -71,6 +71,12 @@ export declare abstract class SystemOneDecisionProvider extends BaseProvider {
     protected abstract decisionEndpoint(model: string): string;
     protected abstract decisionHeaders(): Record<string, string>;
     protected abstract buildDecisionBody(state: DecisionState, questions: Record<string, Record<string, unknown>>, model: string, media?: DecisionPreparedMedia): Record<string, unknown>;
+    /**
+     * A refusal the vendor's own gate would make on the request about to be
+     * sent, which the descriptor's limits cannot express. Throw the refusal
+     * (see `decisionError`); the default has no such gate.
+     */
+    protected assertWithinVendorLimits(_payload: Record<string, unknown>, _model: string): void;
     protected abstract parseDecisionError(status: number, payload: unknown, requestId: string | undefined): DecisionError;
     protected abstract readRequestId(headers: Headers): string | undefined;
     /**

package/dist/providers/systemOneDecision.js

@@ -141,6 +141,12 @@ export class SystemOneDecisionProvider extends BaseProvider {
     missingConfigMessage() {
         return undefined;
     }
+    /**
+     * A refusal the vendor's own gate would make on the request about to be
+     * sent, which the descriptor's limits cannot express. Throw the refusal
+     * (see `decisionError`); the default has no such gate.
+     */
+    assertWithinVendorLimits(_payload, _model) { }
     /**
      * The System One wire calls the yes/no primitive `noul`; this codebase and
      * every SDK exposing it call it `boolean`.
@@ -287,8 +293,10 @@ export class SystemOneDecisionProvider extends BaseProvider {
             this.encodeQuestion(question),
         ]));
         const media = await this.prepareMedia(request);
-        const body = JSON.stringify(this.buildDecisionBody(request.state, wireQuestions, resolvedModel, media));
+        const payload = this.buildDecisionBody(request.state, wireQuestions, resolvedModel, media);
+        const body = JSON.stringify(payload);
         this.assertWithinRequestBytes(body);
+        this.assertWithinVendorLimits(payload, resolvedModel);
         const timeoutMs = request.timeoutMs ??
             this.defaultTimeoutMs(questionEntries.length, stateTokens) ??
             this.defaultTimeout ??

package/dist/proxy/requestBodyLimit.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Request-body ceiling for the proxy's POST routes.
+ *
+ * The body is read before anything else about the request is known (the model,
+ * the share token), so it is bounded first, chunk by chunk, the way the server
+ * adapters bound theirs. Each route gets the request size limit its API
+ * documents; one environment variable overrides all of them.
+ *
+ * @module proxy/requestBodyLimit
+ */
+import { RawBodyTooLargeError } from "../server/utils/rawBody.js";
+/**
+ * Environment variable that sets the ceiling for every POST route, replacing
+ * the per-route defaults below: a byte count, or `64mb` / `512kb` / `1gb`.
+ */
+export declare const PROXY_MAX_REQUEST_BODY_ENV = "NEUROLINK_PROXY_MAX_REQUEST_BODY_BYTES";
+/**
+ * 32 MiB. The Claude Messages API and Token Counting API document a 32 MB
+ * maximum request size and answer a larger request with 413 `request_too_large`:
+ * https://platform.claude.com/docs/en/api/errors#request-size-limits
+ *
+ * Also the limit for a POST route with no upstream API of its own (the peer
+ * endpoints), which has nothing documented to follow.
+ */
+export declare const DEFAULT_PROXY_MAX_REQUEST_BODY_BYTES: number;
+/**
+ * 100 MiB. The Gemini API documents inline data as "100 MB per request or
+ * payload (50 MB for PDFs)":
+ * https://ai.google.dev/gemini-api/docs/file-input-methods
+ */
+export declare const GEMINI_PROXY_MAX_REQUEST_BODY_BYTES: number;
+/**
+ * 64 MiB. A local cap, not an OpenAI figure: OpenAI documents no general
+ * request-body limit for the Responses or Chat Completions APIs. The only
+ * per-request payload figure it states is the image input requirement, "Up to
+ * 512 MB total payload per request":
+ * https://developers.openai.com/api/docs/guides/images-vision
+ * (file inputs are separately limited to 50 MB combined:
+ * https://developers.openai.com/api/docs/guides/file-inputs). The proxy holds
+ * a body in memory while it reads it, about four times its size, so it does
+ * not take the 512 MB figure as its ceiling; a client that sends more raises
+ * `NEUROLINK_PROXY_MAX_REQUEST_BODY_BYTES`. The Codex route speaks the
+ * Responses format and documents nothing of its own, so it uses the same cap.
+ */
+export declare const OPENAI_PROXY_MAX_REQUEST_BODY_BYTES: number;
+/**
+ * The ceiling in bytes for one route: the environment override when it is a
+ * positive size, else that route's documented limit.
+ *
+ * @param routePath - The route as registered, for example `/v1/messages`.
+ */
+export declare function resolveProxyMaxRequestBodyBytes(routePath: string, env?: Record<string, string | undefined>): number;
+/**
+ * The request body as text, `undefined` when it cannot be read (a client that
+ * hung up mid-body), or the error when it is over the route's ceiling. Over the
+ * ceiling the stream is cancelled, so nothing past it is buffered.
+ *
+ * @param routePath - The route as registered, for example `/v1/messages`.
+ */
+export declare function readProxyRequestText(request: Request, routePath: string, env?: Record<string, string | undefined>): Promise<string | undefined | RawBodyTooLargeError>;

package/dist/proxy/requestBodyLimit.js

@@ -0,0 +1,97 @@
+/**
+ * Request-body ceiling for the proxy's POST routes.
+ *
+ * The body is read before anything else about the request is known (the model,
+ * the share token), so it is bounded first, chunk by chunk, the way the server
+ * adapters bound theirs. Each route gets the request size limit its API
+ * documents; one environment variable overrides all of them.
+ *
+ * @module proxy/requestBodyLimit
+ */
+import { RawBodyTooLargeError, readBoundedRequestBody, tryParseByteLimit, } from "../server/utils/rawBody.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Environment variable that sets the ceiling for every POST route, replacing
+ * the per-route defaults below: a byte count, or `64mb` / `512kb` / `1gb`.
+ */
+export const PROXY_MAX_REQUEST_BODY_ENV = "NEUROLINK_PROXY_MAX_REQUEST_BODY_BYTES";
+const MIB = 1024 * 1024;
+/**
+ * 32 MiB. The Claude Messages API and Token Counting API document a 32 MB
+ * maximum request size and answer a larger request with 413 `request_too_large`:
+ * https://platform.claude.com/docs/en/api/errors#request-size-limits
+ *
+ * Also the limit for a POST route with no upstream API of its own (the peer
+ * endpoints), which has nothing documented to follow.
+ */
+export const DEFAULT_PROXY_MAX_REQUEST_BODY_BYTES = 32 * MIB;
+/**
+ * 100 MiB. The Gemini API documents inline data as "100 MB per request or
+ * payload (50 MB for PDFs)":
+ * https://ai.google.dev/gemini-api/docs/file-input-methods
+ */
+export const GEMINI_PROXY_MAX_REQUEST_BODY_BYTES = 100 * MIB;
+/**
+ * 64 MiB. A local cap, not an OpenAI figure: OpenAI documents no general
+ * request-body limit for the Responses or Chat Completions APIs. The only
+ * per-request payload figure it states is the image input requirement, "Up to
+ * 512 MB total payload per request":
+ * https://developers.openai.com/api/docs/guides/images-vision
+ * (file inputs are separately limited to 50 MB combined:
+ * https://developers.openai.com/api/docs/guides/file-inputs). The proxy holds
+ * a body in memory while it reads it, about four times its size, so it does
+ * not take the 512 MB figure as its ceiling; a client that sends more raises
+ * `NEUROLINK_PROXY_MAX_REQUEST_BODY_BYTES`. The Codex route speaks the
+ * Responses format and documents nothing of its own, so it uses the same cap.
+ */
+export const OPENAI_PROXY_MAX_REQUEST_BODY_BYTES = 64 * MIB;
+/**
+ * Registered route path (a suffix, so a base path does not matter) to limit.
+ * The first match wins; no match means the default above.
+ */
+const ROUTE_LIMITS = [
+    [/\/v1\/messages(?:\/count_tokens)?$/, DEFAULT_PROXY_MAX_REQUEST_BODY_BYTES],
+    [/\/v1\/chat\/completions$/, OPENAI_PROXY_MAX_REQUEST_BODY_BYTES],
+    [/\/backend-api\/codex\/responses$/, OPENAI_PROXY_MAX_REQUEST_BODY_BYTES],
+    [/\/v1beta\/models\/[^/]+$/, GEMINI_PROXY_MAX_REQUEST_BODY_BYTES],
+];
+let warnedAbout;
+/**
+ * The ceiling in bytes for one route: the environment override when it is a
+ * positive size, else that route's documented limit.
+ *
+ * @param routePath - The route as registered, for example `/v1/messages`.
+ */
+export function resolveProxyMaxRequestBodyBytes(routePath, env = process.env) {
+    const raw = env[PROXY_MAX_REQUEST_BODY_ENV]?.trim();
+    if (raw) {
+        const parsed = tryParseByteLimit(raw);
+        if (parsed !== undefined && parsed > 0) {
+            return parsed;
+        }
+        if (warnedAbout !== raw) {
+            warnedAbout = raw;
+            logger.always(`[proxy] ignoring ${PROXY_MAX_REQUEST_BODY_ENV}=${JSON.stringify(raw)}: expected a positive byte count or a size such as 64mb; using each route's documented limit`);
+        }
+    }
+    return (ROUTE_LIMITS.find(([pattern]) => pattern.test(routePath))?.[1] ??
+        DEFAULT_PROXY_MAX_REQUEST_BODY_BYTES);
+}
+/**
+ * The request body as text, `undefined` when it cannot be read (a client that
+ * hung up mid-body), or the error when it is over the route's ceiling. Over the
+ * ceiling the stream is cancelled, so nothing past it is buffered.
+ *
+ * @param routePath - The route as registered, for example `/v1/messages`.
+ */
+export async function readProxyRequestText(request, routePath, env = process.env) {
+    try {
+        const bytes = await readBoundedRequestBody(request, resolveProxyMaxRequestBodyBytes(routePath, env));
+        return bytes instanceof RawBodyTooLargeError
+            ? bytes
+            : new TextDecoder().decode(bytes);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/server/adapters/honoAdapter.d.ts

@@ -6,6 +6,10 @@
 import type { NeuroLink } from "../../neurolink.js";
 import { BaseServerAdapter } from "../abstract/baseServerAdapter.js";
 import type { MiddlewareDefinition, RouteDefinition, ServerAdapterConfig } from "../../types/index.js";
+/**
+ * Hono-specific server adapter
+ * Supports multiple runtimes: Bun, Deno, Node.js
+ */
 export declare class HonoServerAdapter extends BaseServerAdapter {
     private app;
     private server?;
@@ -14,6 +18,7 @@ export declare class HonoServerAdapter extends BaseServerAdapter {
     private requestContextStore;
     private HTTPExceptionCtor;
     private streamSSEFn;
+    private parseFormBody;
     constructor(neurolink: NeuroLink, config?: ServerAdapterConfig);
     /**
      * Create rate limiter middleware for Hono
@@ -74,5 +79,13 @@ export declare class HonoServerAdapter extends BaseServerAdapter {
     getNativeServer(): unknown;
     private extractHeaders;
     private extractQuery;
+    /**
+     * A request's context, or the 413 that answers a JSON or form body over its
+     * limit. That answer is built here, before the context exists, so no
+     * middleware (an auth check included) and no route runs for the request.
+     * An upload over the limit still reaches its route as the error itself,
+     * which answers in its own wire format.
+     */
+    private createRequestContext;
     private extractBody;
 }