@juspay/neurolink 13.8.16 → 13.8.17

package/dist/server/adapters/expressAdapter.js

@@ -6,6 +6,7 @@ import { logger } from "../../utils/logger.js";
 import { AlreadyRunningError, ServerAdapterError, ServerStartError, ServerStopError, wrapError, } from "../errors.js";
 import { BaseServerAdapter } from "../abstract/baseServerAdapter.js";
 import { isErrorResponse } from "../utils/validation.js";
+import { createBoundedBodyParser } from "../utils/expressBody.js";
 import { isRawBodyContentType, isWebResponse, readWebResponse, } from "../utils/rawBody.js";
 /**
  * Express-specific server adapter
@@ -41,8 +42,10 @@ export class ExpressServerAdapter extends BaseServerAdapter {
             const bodyLimit = this.config.bodyParser.maxSize ||
                 this.config.bodyParser.jsonLimit ||
                 "10mb";
-            this.app.use(express.json({ limit: this.config.bodyParser.jsonLimit || bodyLimit }));
-            this.app.use(express.urlencoded({ extended: true, limit: bodyLimit }));
+            const jsonLimit = this.config.bodyParser.jsonLimit || bodyLimit;
+            // body-parser drains a body it refuses, so each is read through a bound.
+            this.app.use(createBoundedBodyParser(express.json({ limit: jsonLimit }), jsonLimit));
+            this.app.use(createBoundedBodyParser(express.urlencoded({ extended: true, limit: bodyLimit }), bodyLimit));
             // Uploads (multipart, octet-stream, audio/*) reach the route as bytes.
             this.app.use(express.raw({
                 type: (req) => isRawBodyContentType(req.headers["content-type"]),

package/dist/server/utils/expressBody.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Bounded JSON and form body reads for the Express adapter.
+ *
+ * `express.json()` and `express.urlencoded()` (body-parser) refuse a body over
+ * their limit with a 413, but only after the whole request has been taken off
+ * the socket: a declared Content-Length over the limit is seen at once and the
+ * body is still drained, and a chunked body is read to its end. Nothing has
+ * authenticated the request at that point, so a client could make the server
+ * receive any amount of data for the price of one 413.
+ *
+ * `createBoundedBodyParser` wraps a body-parser middleware so the bytes are
+ * read here, up to the limit, and handed to that same middleware to parse. Which
+ * requests are parsed, charset handling, strict JSON, the qs options and the
+ * error each failure carries all stay body-parser's, because body-parser still
+ * makes those decisions: it is asked first, from the headers alone, whether it
+ * would read the request, and then parses the bytes it is given. What changes is
+ * who reads the socket and what happens at the limit. A body over the limit is
+ * refused without reading it (declared Content-Length) or at the limit (chunked,
+ * or a compressed body that inflates past it), and the connection is closed so
+ * the client stops sending.
+ *
+ * `express.raw()` (uploads) is not wrapped.
+ *
+ * @module server/utils/expressBody
+ */
+import type { ServerNodeMiddleware } from "../../types/index.js";
+/**
+ * Wrap a body-parser middleware (`express.json()`, `express.urlencoded()`) so a
+ * body is read only as far as `limit`. `limit` is the one the middleware was
+ * built with. A limit that cannot be read as a byte count here is left to the
+ * middleware alone.
+ */
+export declare function createBoundedBodyParser(parser: ServerNodeMiddleware, limit: string | number | undefined): ServerNodeMiddleware;

package/dist/server/utils/expressBody.js

@@ -0,0 +1,353 @@
+/**
+ * Bounded JSON and form body reads for the Express adapter.
+ *
+ * `express.json()` and `express.urlencoded()` (body-parser) refuse a body over
+ * their limit with a 413, but only after the whole request has been taken off
+ * the socket: a declared Content-Length over the limit is seen at once and the
+ * body is still drained, and a chunked body is read to its end. Nothing has
+ * authenticated the request at that point, so a client could make the server
+ * receive any amount of data for the price of one 413.
+ *
+ * `createBoundedBodyParser` wraps a body-parser middleware so the bytes are
+ * read here, up to the limit, and handed to that same middleware to parse. Which
+ * requests are parsed, charset handling, strict JSON, the qs options and the
+ * error each failure carries all stay body-parser's, because body-parser still
+ * makes those decisions: it is asked first, from the headers alone, whether it
+ * would read the request, and then parses the bytes it is given. What changes is
+ * who reads the socket and what happens at the limit. A body over the limit is
+ * refused without reading it (declared Content-Length) or at the limit (chunked,
+ * or a compressed body that inflates past it), and the connection is closed so
+ * the client stops sending.
+ *
+ * `express.raw()` (uploads) is not wrapped.
+ *
+ * @module server/utils/expressBody
+ */
+import { Readable } from "node:stream";
+import * as zlib from "node:zlib";
+import { tryParseByteLimit } from "./rawBody.js";
+const noop = () => undefined;
+/** The error body-parser raises for an over-limit body, which the adapter's error handler answers 413. */
+function bodyParserError(status, message, type, details = {}) {
+    return Object.assign(new Error(message), {
+        status,
+        statusCode: status,
+        expose: status < 500,
+        type,
+        ...details,
+    });
+}
+const entityTooLarge = (limit, received) => bodyParserError(413, "request entity too large", "entity.too.large", {
+    limit,
+    ...(received === undefined ? {} : { received }),
+});
+/** A Content-Encoding body-parser inflates, and nothing else. */
+function decompressorFor(encoding) {
+    switch (encoding) {
+        case "gzip":
+            return zlib.createGunzip;
+        case "deflate":
+            return zlib.createInflate;
+        case "br":
+            return zlib.createBrotliDecompress;
+        case "zstd":
+            // Node 22.15 and later.
+            return typeof zlib.createZstdDecompress === "function"
+                ? zlib.createZstdDecompress
+                : undefined;
+        default:
+            return undefined;
+    }
+}
+/** body-parser's own "already handled" test: the request has been read off, or cannot be. */
+const isRequestFinished = (req) => ("upgrade" in req && req.upgrade === true) ||
+    !req.socket?.readable ||
+    (req.complete && !req.readable);
+/** A request that is already in memory, to hand a body-parser middleware in place of the socket. */
+function bufferedRequest(headers, bytes, body) {
+    let pushed = false;
+    const stream = new Readable({
+        read() {
+            if (!pushed) {
+                pushed = true;
+                if (bytes.length > 0) {
+                    this.push(bytes);
+                }
+                this.push(null);
+            }
+        },
+    });
+    return Object.assign(stream, { headers, body });
+}
+/**
+ * Ask a body-parser middleware what it would do with this request, without
+ * giving it a body. It is run on an empty one: what it decides from the headers
+ * (not a body, not its type, a charset it refuses) comes back as it would
+ * have, and so does what it only finds out when it starts to read (a charset
+ * the decoder lacks). The Content-Encoding is left off because inflating is
+ * done here, and the Content-Length is zeroed so the declared size, which is
+ * checked here, does not stand in the way.
+ */
+function askParser(parser, req, res) {
+    const headers = { ...req.headers };
+    delete headers["content-encoding"];
+    delete headers["transfer-encoding"];
+    if (req.headers["transfer-encoding"] !== undefined ||
+        req.headers["content-length"] !== undefined) {
+        headers["content-length"] = "0";
+    }
+    const before = "body" in req ? req.body : undefined;
+    const probe = bufferedRequest(headers, Buffer.alloc(0), before);
+    return new Promise((resolve) => {
+        let synchronous = true;
+        parser(probe, res, (error) => {
+            if (error !== undefined) {
+                resolve({ kind: "reject", error, beforeRead: synchronous });
+            }
+            else if (probe.body !== before) {
+                resolve({ kind: "parse" });
+            }
+            else {
+                resolve({ kind: "skip", body: probe.body });
+            }
+        });
+        synchronous = false;
+    });
+}
+/**
+ * How far past the limit the raw bytes of a compressed body may run. The limit
+ * is on what a body inflates to, but the bytes on the wire are capped too:
+ * empty gzip members inflate to nothing, and so do the zeros Node lets follow a
+ * complete gzip stream, so without a cap a stream of either is read until the
+ * client stops. The slack covers the framing a real encoder adds (deflate's
+ * stored blocks carry 5 bytes per 64 KiB).
+ */
+const COMPRESSED_WIRE_SLACK = 64 * 1024;
+/**
+ * Read a request body, refusing more than `maxBytes` (of what is inflated, when
+ * the request is compressed, with the raw bytes capped at `maxBytes` plus
+ * {@link COMPRESSED_WIRE_SLACK}). Reading stops at the limit and the request is
+ * left paused, not drained. Events rather than `for await`: leaving an async
+ * iterator early destroys the request, and its socket with it, before an answer
+ * can be sent.
+ */
+function readBounded(req, maxBytes, decompressor) {
+    return new Promise((resolve, reject) => {
+        const source = decompressor ?? req;
+        const chunks = [];
+        const wireCap = maxBytes + COMPRESSED_WIRE_SLACK;
+        let received = 0;
+        let wire = 0;
+        // A compressed body is complete; the rest of the request is being read off.
+        let draining = false;
+        let settled = false;
+        const release = () => {
+            source.off("data", onData);
+            source.off("end", onEnd);
+            source.off("error", onFail);
+            req.off("data", onWire);
+            req.off("end", onRequestEnd);
+            req.off("error", onFail);
+            req.off("close", onClose);
+        };
+        const detachDecompressor = () => {
+            if (decompressor) {
+                req.unpipe(decompressor);
+                decompressor.on("error", noop);
+                decompressor.destroy();
+            }
+        };
+        const stop = () => {
+            detachDecompressor();
+            req.pause();
+        };
+        const settle = (outcome) => {
+            if (!settled) {
+                settled = true;
+                release();
+                outcome();
+            }
+        };
+        const finish = (closeConnection) => {
+            settle(() => resolve({ bytes: Buffer.concat(chunks), closeConnection }));
+        };
+        const aborted = () => bodyParserError(400, "request aborted", "request.aborted", {
+            code: "ECONNABORTED",
+            received,
+        });
+        function onData(chunk) {
+            const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+            received += buffer.length;
+            if (received > maxBytes) {
+                settle(() => {
+                    stop();
+                    reject(entityTooLarge(maxBytes, received));
+                });
+                return;
+            }
+            chunks.push(buffer);
+        }
+        function onWire(chunk) {
+            wire += chunk.length;
+            if (wire <= wireCap) {
+                return;
+            }
+            if (draining) {
+                // The body is whole; what keeps arriving is not part of it.
+                req.pause();
+                finish(true);
+                return;
+            }
+            settle(() => {
+                stop();
+                reject(entityTooLarge(maxBytes, wire));
+            });
+        }
+        function onEnd() {
+            if (!decompressor) {
+                finish(false);
+                return;
+            }
+            // The rest of the request, if any, is not part of the body: read it off
+            // up to the cap, so the connection can be kept.
+            detachDecompressor();
+            if (req.complete) {
+                req.resume();
+                finish(false);
+                return;
+            }
+            draining = true;
+            source.off("data", onData);
+            source.off("end", onEnd);
+            source.off("error", onFail);
+            req.on("end", onRequestEnd);
+            req.resume();
+        }
+        function onRequestEnd() {
+            finish(false);
+        }
+        function onFail(error) {
+            if (draining) {
+                finish(true);
+                return;
+            }
+            settle(() => {
+                stop();
+                reject(error);
+            });
+        }
+        function onClose() {
+            // A request that arrived whole closes once it has been read, which for a
+            // compressed one can be before the inflating has finished.
+            if (req.complete) {
+                return;
+            }
+            if (draining) {
+                finish(true);
+                return;
+            }
+            settle(() => {
+                stop();
+                reject(aborted());
+            });
+        }
+        if (req.destroyed && !req.complete) {
+            settle(() => reject(aborted()));
+            return;
+        }
+        source.on("data", onData);
+        source.on("end", onEnd);
+        source.on("error", onFail);
+        req.on("close", onClose);
+        if (decompressor) {
+            req.on("error", onFail);
+            req.on("data", onWire);
+            req.pipe(decompressor);
+        }
+    });
+}
+/** Answer the request with `error` and close the connection, so a client still sending stops. */
+function refuse(res, next, error) {
+    if (!res.headersSent) {
+        res.setHeader("Connection", "close");
+    }
+    next(error);
+}
+async function parseBounded(parser, maxBytes, req, res, next) {
+    try {
+        if (isRequestFinished(req)) {
+            next();
+            return;
+        }
+        const verdict = await askParser(parser, req, res);
+        if (verdict.kind === "skip") {
+            req.body = verdict.body;
+            next();
+            return;
+        }
+        if (verdict.kind === "reject" && verdict.beforeRead) {
+            refuse(res, next, verdict.error);
+            return;
+        }
+        const encoding = (req.headers["content-encoding"] || "identity").toLowerCase();
+        const inflate = encoding === "identity" ? undefined : decompressorFor(encoding);
+        if (encoding !== "identity" && !inflate) {
+            refuse(res, next, bodyParserError(415, `unsupported content encoding "${encoding}"`, "encoding.unsupported", { encoding }));
+            return;
+        }
+        // Compressed, the declared length is the compressed size, which says
+        // nothing about the body.
+        const declared = Number.parseInt(String(req.headers["content-length"]), 10);
+        if (!inflate && declared > maxBytes) {
+            refuse(res, next, entityTooLarge(maxBytes));
+            return;
+        }
+        if (verdict.kind === "reject") {
+            refuse(res, next, verdict.error);
+            return;
+        }
+        const before = "body" in req ? req.body : undefined;
+        let read;
+        try {
+            read = await readBounded(req, maxBytes, inflate?.());
+        }
+        catch (error) {
+            refuse(res, next, error);
+            return;
+        }
+        if (read.closeConnection && !res.headersSent) {
+            res.setHeader("Connection", "close");
+        }
+        const { bytes } = read;
+        const headers = { ...req.headers, "content-length": String(bytes.length) };
+        delete headers["content-encoding"];
+        delete headers["transfer-encoding"];
+        const replay = bufferedRequest(headers, bytes, before);
+        parser(replay, res, (error) => {
+            if (error !== undefined) {
+                next(error);
+                return;
+            }
+            req.body = replay.body;
+            next();
+        });
+    }
+    catch (error) {
+        next(error);
+    }
+}
+/**
+ * Wrap a body-parser middleware (`express.json()`, `express.urlencoded()`) so a
+ * body is read only as far as `limit`. `limit` is the one the middleware was
+ * built with. A limit that cannot be read as a byte count here is left to the
+ * middleware alone.
+ */
+export function createBoundedBodyParser(parser, limit) {
+    const maxBytes = tryParseByteLimit(limit);
+    if (maxBytes === undefined) {
+        return parser;
+    }
+    return (req, res, next) => {
+        void parseBounded(parser, maxBytes, req, res, next);
+    };
+}

package/dist/types/server.d.ts

@@ -2,6 +2,8 @@
  * Server Adapter Types
  * Comprehensive type system for NeuroLink server adapters
  */
+import type { IncomingHttpHeaders, IncomingMessage, ServerResponse as NodeServerResponse } from "node:http";
+import type { Readable } from "node:stream";
 import type { ExternalServerManager } from "../mcp/externalServerManager.js";
 import type { MCPToolRegistry } from "../mcp/toolRegistry.js";
 import type { NeuroLink } from "../neurolink.js";
@@ -185,6 +187,53 @@ export type RequiredBodyParserConfig = {
     rawMaxSize: string;
     urlEncoded: boolean;
 };
+/**
+ * The request a body-parser middleware is handed in place of the real one: a
+ * stream of bytes that were already read, with the headers the parser decides
+ * from. `body` is where the parser leaves its result, as on a real request.
+ */
+export type ServerBufferedRequest = Readable & {
+    headers: IncomingHttpHeaders;
+    body: unknown;
+};
+/**
+ * A body read as far as its limit: the bytes, and whether the connection is to
+ * be closed after the answer. That is the case when a compressed body was
+ * complete but the request kept sending past the cap on raw bytes, which are
+ * then left unread.
+ */
+export type ServerBoundedBodyRead = {
+    bytes: Buffer;
+    closeConnection: boolean;
+};
+/** A Node request as a body-parser middleware sees it: `body` is where it leaves what it parsed. */
+export type ServerParsedNodeRequest = IncomingMessage & {
+    body?: unknown;
+};
+/**
+ * A body-parser middleware (`express.json()`, `express.urlencoded()`) as
+ * body-parser types it: Node's request and response, and a `next` that takes
+ * an error. Typed without Express, which is an optional peer, so the published
+ * declarations do not import it.
+ */
+export type ServerNodeMiddleware = (req: ServerParsedNodeRequest, res: NodeServerResponse, next: (error?: unknown) => void) => void;
+/**
+ * What a body-parser middleware decides about a request, asked before any of
+ * its body is read: leave it alone, parse it, or refuse it. A refusal made
+ * before the parser would read anything has `beforeRead` set; one the parser
+ * only reaches once it starts to read (a charset the decoder cannot handle)
+ * has not.
+ */
+export type ServerBodyParserVerdict = {
+    kind: "skip";
+    body: unknown;
+} | {
+    kind: "parse";
+} | {
+    kind: "reject";
+    error: unknown;
+    beforeRead: boolean;
+};
 /**
  * Logging configuration
  */

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

@@ -7811,7 +7811,7 @@
 {"objectID":"dee68d2efd01a80eb4a442ec7f72d40d414182b8ee8036638126c7e48f9a745c","title":"4. Respect Retry-After Headers","url":"/docs/guides/server-adapters/errors#4-respect-retry-after-headers","content":"When handling RateLimitError, honor the retryAfterMs:","hierarchy":{"lvl0":"Guides","lvl1":"Error Handling","lvl2":"4. Respect Retry-After Headers","lvl3":""}},
 {"objectID":"af5a0269b91a605247991a222cba64afe694b0045fa4a74aa70a7aba01040a9c","title":"5. Log Appropriately by Severity","url":"/docs/guides/server-adapters/errors#5-log-appropriately-by-severity","content":"5. Log Appropriately by Severity","hierarchy":{"lvl0":"Guides","lvl1":"Error Handling","lvl2":"5. Log Appropriately by Severity","lvl3":""}},
 {"objectID":"6de13080daf8a055a6de3bee97117d3618cbc7b3f61be0c48f17e957ff0b4a88","title":"Related Documentation","url":"/docs/guides/server-adapters/errors#related-documentation","content":"Server Adapters Overview - Getting started with server adapters\nSecurity Best Practices - Authentication and authorization\nConfiguration Reference - Full configuration options\nDeployment Guide - Production deployment strategies","hierarchy":{"lvl0":"Guides","lvl1":"Error Handling","lvl2":"Related Documentation","lvl3":""}},
-{"objectID":"d86a2f773105827bac17ead4d527ff7188a4489c218c4208152663b89b14565c","title":"Express Adapter","url":"/docs/guides/server-adapters/express","content":"Express Adapter\n\nThe most popular Node.js web framework\n\nExpress is a minimal and flexible Node.js web framework that provides a robust set of features for building web applications and APIs. It has the largest ecosystem of middleware and is widely used in production.\n\nWhy Express?\n\n| Feature               | Benefit                                         |\n| --------------------- | ----------------------------------------------- |\n| Mature ecosystem  | Thousands of middleware packages available      |\n| Well-documented   | Extensive documentation and community resources |\n| Familiar API      | Most Node.js developers already know Express    |\n| Flexible          | Unopinionated, adapt to any architecture        |\n| Production-proven | Powers millions of applications worldwide       |\n| Easy migration    | Integrate NeuroLink into existing Express apps  |\n\nExpress is ideal when you have an existing Express application or prefer its familiar middleware patterns.\n\nCLI Usage\n\nStart an Express server via CLI:\n\nQuick Start\n\nInstallation\n\nExpress must be installed separately alongside NeuroLink:\n\nBasic Usage\n\nTest the Server\n\nAccessing the Express App\n\nFor advanced customization, you can access the underlying Express application:\n\nConfiguration Options\n\nFull Configuration Example\n\nMiddleware Integration\n\nUsing NeuroLink Middleware\n\nUsing Express-Native Middleware\n\nStreaming Responses\n\nExpress supports streaming through Server-Sent Events (SSE):\n\nCustom Streaming Route\n\nAbort Signal Handling\n\nThe abort signal middleware allows detecting when clients disconnect during long-running requests. NeuroLink provides both a universal middleware and an Express-specific implementation.\n\nUsing Abort Signal Middleware\n\nUse Cases\n\nThe abort signal middleware is useful for:\nLong-running AI generation - Cancel generation when client disconnects\nStreaming responses - Stop producing chunks when client leaves\nDatabase queries - Cancel queries that support abort signals\nExternal API calls - Pass signal to fetch/axios for cancellation\n\nNative Express Approach\n\nFor simpler cases, you can use Express's native socket events:\n\nFor streaming requests, the adapter automatically detects client disconnection and stops the stream to avoid unnecessary processing.\n\nError Handling\n\nCustom Error Handler\n\nIntegrating with Existing Express Apps\n\nIf you already have an Express application, you can integrate NeuroLink routes:\n\nTesting\n\nUnit Testing with Supertest\n\nProduction Checklist\n[ ] Configure environment variables securely\n[ ] Set appropriate CORS origins (not *)\n[ ] Enable rate limiting with reasonable limits\n[ ] Add authentication middleware\n[ ] Configure request timeouts\n[ ] Set body size limits\n[ ] Enable compression (gzip/brotli)\n[ ] Add security headers (helmet)\n[ ] Configure logging with appropriate level\n[ ] Set up health check monitoring\n[ ] Configure error tracking (Sentry, etc.)\n[ ] Use a process manager (PM2, systemd)\n\nRelated Documentation\nServer Adapters Overview - Getting started with server adapters\nConfiguration Reference - Full configuration options\nHono Adapter - Compare with Hono adapter\nFastify Adapter - Compare with Fastify adapter\nSecurity Best Practices - Authentication patterns\n\nAdditional Resources\nExpress Documentation - Official Express documentation\nExpress Middleware - Popular middleware packages\nExpress Security Best Practices - Security guidelines\n\nNeed Help? Join our GitHub Discussions or open an issue.","hierarchy":{"lvl0":"Guides","lvl1":"Express Adapter","lvl2":"","lvl3":""}},
+{"objectID":"d86a2f773105827bac17ead4d527ff7188a4489c218c4208152663b89b14565c","title":"Express Adapter","url":"/docs/guides/server-adapters/express","content":"Express Adapter\n\nThe most popular Node.js web framework\n\nExpress is a minimal and flexible Node.js web framework that provides a robust set of features for building web applications and APIs. It has the largest ecosystem of middleware and is widely used in production.\n\nWhy Express?\n\n| Feature               | Benefit                                         |\n| --------------------- | ----------------------------------------------- |\n| Mature ecosystem  | Thousands of middleware packages available      |\n| Well-documented   | Extensive documentation and community resources |\n| Familiar API      | Most Node.js developers already know Express    |\n| Flexible          | Unopinionated, adapt to any architecture        |\n| Production-proven | Powers millions of applications worldwide       |\n| Easy migration    | Integrate NeuroLink into existing Express apps  |\n\nExpress is ideal when you have an existing Express application or prefer its familiar middleware patterns.\n\nCLI Usage\n\nStart an Express server via CLI:\n\nQuick Start\n\nInstallation\n\nExpress must be installed separately alongside NeuroLink:\n\nBasic Usage\n\nTest the Server\n\nAccessing the Express App\n\nFor advanced customization, you can access the underlying Express application:\n\nConfiguration Options\n\nFull Configuration Example\n\nRequest body limits\n\nbodyParser.jsonLimit bounds JSON bodies and bodyParser.maxSize bounds url-encoded forms. Both default to 10mb, and raising either one is honoured. Uploads (multipart/form-data, application/octet-stream, audio/*) are bounded by bodyParser.rawMaxSize, which defaults to maxSize when that is set and to 64mb otherwise.\n\nA JSON or url-encoded form body over its limit is answered 413 with error.code set to PAYLOAD_TOO_LARGE and error.message set to request entity too large, before any middleware or route runs, and the connection is closed so the client stops sending. The body is not read past the limit: a declared Content-Length over the limit is refused without reading the body, and a body sent without one (chunked) is read only as far as the limit. For a compressed body (Content-Encoding: gzip, deflate, br or zstd) the limit applies to the inflated size, and reading stops once the body has inflated past it.\n\nThe bytes are still parsed by express.json() and express.urlencoded() (body-parser), so which requests are parsed, how charsets are decoded, strict JSON, and the qs parsing of forms are unchanged. Anything body-parser refuses other than a body that is too large (a malformed or scalar JSON body, an unsupported charset or Content-Encoding, too many form parameters) is answered 500 with error.code set to INTERNAL_ERROR, as before.\n\nMiddleware Integration\n\nUsing NeuroLink Middleware\n\nUsing Express-Native Middleware\n\nStreaming Responses\n\nExpress supports streaming through Server-Sent Events (SSE):\n\nCustom Streaming Route\n\nAbort Signal Handling\n\nThe abort signal middleware allows detecting when clients disconnect during long-running requests. NeuroLink provides both a universal middleware and an Express-specific implementation.\n\nUsing Abort Signal Middleware\n\nUse Cases\n\nThe abort signal middleware is useful for:\nLong-running AI generation - Cancel generation when client disconnects\nStreaming responses - Stop producing chunks when client leaves\nDatabase queries - Cancel queries that support abort signals\nExternal API calls - Pass signal to fetch/axios for cancellation\n\nNative Express Approach\n\nFor simpler cases, you can use Express's native socket events:\n\nFor streaming requests, the adapter automatically detects client disconnection and stops the stream to avoid unnecessary processing.\n\nError Handling\n\nCustom Error Handler\n\nIntegrating with Existing Express Apps\n\nIf you already have an Express application, you can integrate NeuroLink routes:\n\nTesting\n\nUnit Testing with Supertest\n\nProduction Checklist\n[ ] Configure environment variables securely\n[ ] Set appropriate CORS origins (not *)\n[ ] Enable rate limiting with reasonable limits\n[ ] Add authentication middleware\n[ ] Configure request timeouts\n[ ] Set body size limits\n[ ] Enable compression (gzip/brotli)\n[ ] Add security headers (helmet)\n[ ] Configure logging with appropriate level\n[ ] Set up health check monitoring\n[ ] Configure error tracking (Sentry, etc.)\n[ ] Use a process manager (PM2, systemd)\n\nRelated Documentation\nServer Adapters Overview - Getting started with server adapters\nConfiguration Reference - Full configuration options\nHono Adapter - Compare with Hono adapter\nFastify Adapter - Compare with Fastify adapter\nSecurity Best Practices - Authentication patterns\n\nAdditional Resources\nExpress Documentation - Official Express documentation\nExpress Middleware - Popular middleware packages\nExpress Security Best Practices - Security guidelines\n\nNeed Help? Join our GitHub Discussions or open an issue.","hierarchy":{"lvl0":"Guides","lvl1":"Express Adapter","lvl2":"","lvl3":""}},
 {"objectID":"3a0b46a625e8077c402e2fae808252ee0b790e25915b781aab36e0043e0c95ff","title":"Express Adapter","url":"/docs/guides/server-adapters/express#express-adapter","content":"The most popular Node.js web framework\n\nExpress is a minimal and flexible Node.js web framework that provides a robust set of features for building web applications and APIs. It has the largest ecosystem of middleware and is widely used in production.","hierarchy":{"lvl0":"Guides","lvl1":"Express Adapter","lvl2":"Express Adapter","lvl3":""}},
 {"objectID":"05122ccefbae0eefb95cc5da06fccfdf4d33b0d5afa177ae7b75f9745d2a23cf","title":"Why Express?","url":"/docs/guides/server-adapters/express#why-express","content":"| Feature               | Benefit                                         |\n| --------------------- | ----------------------------------------------- |\n| Mature ecosystem  | Thousands of middleware packages available      |\n| Well-documented   | Extensive documentation and community resources |\n| Familiar API      | Most Node.js developers already know Express    |\n| Flexible          | Unopinionated, adapt to any architecture        |\n| Production-proven | Powers millions of applications worldwide       |\n| Easy migration    | Integrate NeuroLink into existing Express apps  |\n\nExpress is ideal when you have an existing Express application or prefer its familiar middleware patterns.","hierarchy":{"lvl0":"Guides","lvl1":"Express Adapter","lvl2":"Why Express?","lvl3":""}},
 {"objectID":"a509b1b55a5ad6b22c14631c5be63ad50e2d0c1fd7895d7fc7ed3e89c96b31de","title":"CLI Usage","url":"/docs/guides/server-adapters/express#cli-usage","content":"Start an Express server via CLI:","hierarchy":{"lvl0":"Guides","lvl1":"Express Adapter","lvl2":"CLI Usage","lvl3":""}},
@@ -7820,6 +7820,7 @@
 {"objectID":"c8665ba8299a709bf777f2fea4a5c30034f120434206161f412de05e70046f83","title":"Test the Server","url":"/docs/guides/server-adapters/express#test-the-server","content":"Test the Server","hierarchy":{"lvl0":"Guides","lvl1":"Express Adapter","lvl2":"Test the Server","lvl3":""}},
 {"objectID":"43d29d1695eb139f97358faa91162964159fb4687d5ab7d49a961cec1a6c257e","title":"Accessing the Express App","url":"/docs/guides/server-adapters/express#accessing-the-express-app","content":"For advanced customization, you can access the underlying Express application:","hierarchy":{"lvl0":"Guides","lvl1":"Express Adapter","lvl2":"Accessing the Express App","lvl3":""}},
 {"objectID":"e287cd8271a5e9e82a98ba6038721c91c3d49b8a7c6fd588f9b5309953f1c489","title":"Full Configuration Example","url":"/docs/guides/server-adapters/express#full-configuration-example","content":"Full Configuration Example","hierarchy":{"lvl0":"Guides","lvl1":"Express Adapter","lvl2":"Full Configuration Example","lvl3":""}},
+{"objectID":"27bf2e9da638509164e8ac21d64b5e36f101deaa75f464fcadcb3e4f4057ced2","title":"Request body limits","url":"/docs/guides/server-adapters/express#request-body-limits","content":"bodyParser.jsonLimit bounds JSON bodies and bodyParser.maxSize bounds url-encoded forms. Both default to 10mb, and raising either one is honoured. Uploads (multipart/form-data, application/octet-stream, audio/*) are bounded by bodyParser.rawMaxSize, which defaults to maxSize when that is set and to 64mb otherwise.\n\nA JSON or url-encoded form body over its limit is answered 413 with error.code set to PAYLOAD_TOO_LARGE and error.message set to request entity too large, before any middleware or route runs, and the connection is closed so the client stops sending. The body is not read past the limit: a declared Content-Length over the limit is refused without reading the body, and a body sent without one (chunked) is read only as far as the limit. For a compressed body (Content-Encoding: gzip, deflate, br or zstd) the limit applies to the inflated size, and reading stops once the body has inflated past it.\n\nThe bytes are still parsed by express.json() and express.urlencoded() (body-parser), so which requests are parsed, how charsets are decoded, strict JSON, and the qs parsing of forms are unchanged. Anything body-parser refuses other than a body that is too large (a malformed or scalar JSON body, an unsupported charset or Content-Encoding, too many form parameters) is answered 500 with error.code set to INTERNAL_ERROR, as before.","hierarchy":{"lvl0":"Guides","lvl1":"Express Adapter","lvl2":"Request body limits","lvl3":""}},
 {"objectID":"05db65d092e325a4ae7bbd23890cc3f6ca3e61561a196d00f3199c158851cc4e","title":"Using NeuroLink Middleware","url":"/docs/guides/server-adapters/express#using-neurolink-middleware","content":"Using NeuroLink Middleware","hierarchy":{"lvl0":"Guides","lvl1":"Express Adapter","lvl2":"Using NeuroLink Middleware","lvl3":""}},
 {"objectID":"b4c7f350e63e32f17c10ecaade63856d9baac07c72d93a07083e10c1cac4fc01","title":"Using Express-Native Middleware","url":"/docs/guides/server-adapters/express#using-express-native-middleware","content":"Using Express-Native Middleware","hierarchy":{"lvl0":"Guides","lvl1":"Express Adapter","lvl2":"Using Express-Native Middleware","lvl3":""}},
 {"objectID":"3ef5b221323ada6a9627c762b6f84cad3c88454030f6b5496da6a84dba4801a0","title":"Streaming Responses","url":"/docs/guides/server-adapters/express#streaming-responses","content":"Express supports streaming through Server-Sent Events (SSE):","hierarchy":{"lvl0":"Guides","lvl1":"Express Adapter","lvl2":"Streaming Responses","lvl3":""}},
@@ -7859,7 +7860,7 @@
 {"objectID":"ce64f640074b8e60ee4bd472c5c1e5a246d0c373e06b5c046eae0db635733ba5","title":"Production Checklist","url":"/docs/guides/server-adapters/fastify#production-checklist","content":"[ ] Configure environment variables securely\n[ ] Set appropriate CORS origins (not *)\n[ ] Enable rate limiting with reasonable limits\n[ ] Add authentication middleware\n[ ] Configure request timeouts\n[ ] Set body size limits\n[ ] Enable compression (@fastify/compress)\n[ ] Add security headers (@fastify/helmet)\n[ ] Configure logging with appropriate level\n[ ] Set up health check monitoring\n[ ] Configure error tracking (Sentry, etc.)\n[ ] Use schema validation for all routes\n[ ] Enable JSON schema compilation caching","hierarchy":{"lvl0":"Guides","lvl1":"Fastify Adapter","lvl2":"Production Checklist","lvl3":""}},
 {"objectID":"96060a0ae3f9dfb112daf783ff1f49d405316b318d40fdb38c9e9b3a3f4dc377","title":"Related Documentation","url":"/docs/guides/server-adapters/fastify#related-documentation","content":"Server Adapters Overview - Getting started with server adapters\nConfiguration Reference - Full configuration options\nHono Adapter - Compare with Hono adapter\nExpress Adapter - Compare with Express adapter\nSecurity Best Practices - Authentication patterns","hierarchy":{"lvl0":"Guides","lvl1":"Fastify Adapter","lvl2":"Related Documentation","lvl3":""}},
 {"objectID":"84a68aab0ea6da1d4500a0e89cffad25af13dfb8f7c11c0466d2a5cc2160f2c2","title":"Additional Resources","url":"/docs/guides/server-adapters/fastify#additional-resources","content":"Fastify Documentation - Official Fastify documentation\nFastify Plugins - Official and community plugins\nFastify Performance - Performance tuning\n\nNeed Help? Join our GitHub Discussions or open an issue.","hierarchy":{"lvl0":"Guides","lvl1":"Fastify Adapter","lvl2":"Additional Resources","lvl3":""}},
-{"objectID":"cd85d95041216458a7ff86a558a33685239f0e7c062584b10c910a1071c70385","title":"Hono Adapter","url":"/docs/guides/server-adapters/hono","content":"Hono Adapter\n\nThe recommended framework for NeuroLink server adapters\n\nHono is a lightweight, ultrafast web framework designed for the edge. It runs on virtually any JavaScript runtime including Node.js, Deno, Bun, Cloudflare Workers, and more.\n\nWhy Hono?\n\n| Feature                 | Benefit                                                                   |\n| ----------------------- | ------------------------------------------------------------------------- |\n| Multi-runtime       | Deploy to Node.js, Deno, Bun, Cloudflare Workers, Vercel Edge, AWS Lambda |\n| Ultrafast           | Minimal overhead, optimized router with RegExpRouter                      |\n| TypeScript-first    | Full type safety out of the box                                           |\n| Tiny footprint      | ~14KB minified, no dependencies                                           |\n| Built-in middleware | CORS, compression, ETag, secure headers included                          |\n| Web Standards       | Uses Fetch API, Request/Response objects                                  |\n\nHono is the default and recommended framework for NeuroLink server adapters.\n\nCLI Usage\n\nStart a Hono server via CLI:\n\nQuick Start\n\nInstallation\n\nHono is included with NeuroLink - no additional installation required.\n\nBasic Usage\n\nTest the Server\n\nAccessing the Hono App\n\nFor advanced customization, you can access the underlying Hono instance:\n\nConfiguration Options\n\nFull Configuration Example\n\nRequest body limits\n\nbodyParser.jsonLimit bounds JSON bodies and bodyParser.maxSize bounds url-encoded forms. Both default to 10mb, as on the Express, Fastify and Koa adapters, and raising either one is honoured. Uploads (multipart/form-data, application/octet-stream, audio/*) are bounded by bodyParser.rawMaxSize, which defaults to maxSize when that is set and to 64mb otherwise.\n\nA JSON or url-encoded form body over its limit is answered 413 with error.code set to PAYLOAD_TOO_LARGE, before any middleware or route runs. A declared Content-Length over the limit is refused without reading the body, and a body sent without one is read only as far as the limit. An upload over the limit still reaches its route, which answers in its own wire format.\n\nMiddleware Integration\n\nUsing NeuroLink Middleware\n\nUsing Hono Built-in Middleware\n\nStreaming Responses\n\nHono has excellent streaming support, which NeuroLink leverages for real-time AI responses:\n\nCustom Streaming Route\n\nError Handling\n\nCustom Error Handler\n\nPerformance Tips\nUse the RegExpRouter (Default)\n\nHono uses RegExpRouter by default, which is the fastest router. No configuration needed.\nEnable Compression\nUse ETag for Caching\nMinimize Middleware Chain\n\nOnly use middleware where needed:\nUse Streaming for Long Responses\n\nAlways use the streaming endpoint for AI generation to avoid timeouts:\n\nEdge Runtime Deployment\n\nCloudflare Workers\n\nVercel Edge Functions\n\nDeno Deploy\n\nTesting\n\nUnit Testing with Hono Test Client\n\nProduction Checklist\n[ ] Configure environment variables securely\n[ ] Set appropriate CORS origins (not *)\n[ ] Enable rate limiting with reasonable limits\n[ ] Add authentication middleware\n[ ] Configure request timeouts\n[ ] Set body size limits\n[ ] Enable compression\n[ ] Add security headers\n[ ] Configure logging with appropriate level\n[ ] Set up health check monitoring\n[ ] Configure error tracking (Sentry, etc.)\n\nRelated Documentation\nServer Adapters Overview - Getting started with server adapters\nConfiguration Reference - Full configuration options\nExpress Adapter - Compare with Express adapter\nSecurity Best Practices - Authentication patterns\nStreaming Guide - Real-time streaming with SSE and NDJSON\n\nAdditional Resources\nHono Documentation - Official Hono documentation\nHono Middleware - Built-in middleware\nHono Examples - Example applications\n\nNeed Help? Join our GitHub Discussions or open an issue.","hierarchy":{"lvl0":"Guides","lvl1":"Hono Adapter","lvl2":"","lvl3":""}},
+{"objectID":"cd85d95041216458a7ff86a558a33685239f0e7c062584b10c910a1071c70385","title":"Hono Adapter","url":"/docs/guides/server-adapters/hono","content":"Hono Adapter\n\nThe recommended framework for NeuroLink server adapters\n\nHono is a lightweight, ultrafast web framework designed for the edge. It runs on virtually any JavaScript runtime including Node.js, Deno, Bun, Cloudflare Workers, and more.\n\nWhy Hono?\n\n| Feature                 | Benefit                                                                   |\n| ----------------------- | ------------------------------------------------------------------------- |\n| Multi-runtime       | Deploy to Node.js, Deno, Bun, Cloudflare Workers, Vercel Edge, AWS Lambda |\n| Ultrafast           | Minimal overhead, optimized router with RegExpRouter                      |\n| TypeScript-first    | Full type safety out of the box                                           |\n| Tiny footprint      | ~14KB minified, no dependencies                                           |\n| Built-in middleware | CORS, compression, ETag, secure headers included                          |\n| Web Standards       | Uses Fetch API, Request/Response objects                                  |\n\nHono is the default and recommended framework for NeuroLink server adapters.\n\nCLI Usage\n\nStart a Hono server via CLI:\n\nQuick Start\n\nInstallation\n\nHono is included with NeuroLink - no additional installation required.\n\nBasic Usage\n\nTest the Server\n\nAccessing the Hono App\n\nFor advanced customization, you can access the underlying Hono instance:\n\nConfiguration Options\n\nFull Configuration Example\n\nRequest body limits\n\nbodyParser.jsonLimit bounds JSON bodies and bodyParser.maxSize bounds url-encoded forms. Both default to 10mb, as on the Express, Fastify and Koa adapters, and raising either one is honoured. Uploads (multipart/form-data, application/octet-stream, audio/*) are bounded by bodyParser.rawMaxSize, which defaults to maxSize when that is set and to 64mb otherwise.\n\nA JSON or url-encoded form body over its limit is answered 413 with error.code set to PAYLOAD_TOO_LARGE, before any middleware or route runs. A declared Content-Length over the limit is refused without reading the body, and a body sent without one is read only as far as the limit. An upload over the limit still reaches its route, which answers in its own wire format.\n\nThe Express adapter stops at the limit the same way (see \"Request body limits\" in its guide). Its 413 carries the message request entity too large, where Hono's names the limit in bytes.\n\nMiddleware Integration\n\nUsing NeuroLink Middleware\n\nUsing Hono Built-in Middleware\n\nStreaming Responses\n\nHono has excellent streaming support, which NeuroLink leverages for real-time AI responses:\n\nCustom Streaming Route\n\nError Handling\n\nCustom Error Handler\n\nPerformance Tips\nUse the RegExpRouter (Default)\n\nHono uses RegExpRouter by default, which is the fastest router. No configuration needed.\nEnable Compression\nUse ETag for Caching\nMinimize Middleware Chain\n\nOnly use middleware where needed:\nUse Streaming for Long Responses\n\nAlways use the streaming endpoint for AI generation to avoid timeouts:\n\nEdge Runtime Deployment\n\nCloudflare Workers\n\nVercel Edge Functions\n\nDeno Deploy\n\nTesting\n\nUnit Testing with Hono Test Client\n\nProduction Checklist\n[ ] Configure environment variables securely\n[ ] Set appropriate CORS origins (not *)\n[ ] Enable rate limiting with reasonable limits\n[ ] Add authentication middleware\n[ ] Configure request timeouts\n[ ] Set body size limits\n[ ] Enable compression\n[ ] Add security headers\n[ ] Configure logging with appropriate level\n[ ] Set up health check monitoring\n[ ] Configure error tracking (Sentry, etc.)\n\nRelated Documentation\nServer Adapters Overview - Getting started with server adapters\nConfiguration Reference - Full configuration options\nExpress Adapter - Compare with Express adapter\nSecurity Best Practices - Authentication patterns\nStreaming Guide - Real-time streaming with SSE and NDJSON\n\nAdditional Resources\nHono Documentation - Official Hono documentation\nHono Middleware - Built-in middleware\nHono Examples - Example applications\n\nNeed Help? Join our GitHub Discussions or open an issue.","hierarchy":{"lvl0":"Guides","lvl1":"Hono Adapter","lvl2":"","lvl3":""}},
 {"objectID":"4f52a63fa59e73e486b75c6e70853fb82c660686cdf13261394fc63c32c40a66","title":"Hono Adapter","url":"/docs/guides/server-adapters/hono#hono-adapter","content":"The recommended framework for NeuroLink server adapters\n\nHono is a lightweight, ultrafast web framework designed for the edge. It runs on virtually any JavaScript runtime including Node.js, Deno, Bun, Cloudflare Workers, and more.","hierarchy":{"lvl0":"Guides","lvl1":"Hono Adapter","lvl2":"Hono Adapter","lvl3":""}},
 {"objectID":"c53bb661bf4d428d1292350b9eae21f7c2d881f171414cc705135e3e360d3521","title":"Why Hono?","url":"/docs/guides/server-adapters/hono#why-hono","content":"| Feature                 | Benefit                                                                   |\n| ----------------------- | ------------------------------------------------------------------------- |\n| Multi-runtime       | Deploy to Node.js, Deno, Bun, Cloudflare Workers, Vercel Edge, AWS Lambda |\n| Ultrafast           | Minimal overhead, optimized router with RegExpRouter                      |\n| TypeScript-first    | Full type safety out of the box                                           |\n| Tiny footprint      | ~14KB minified, no dependencies                                           |\n| Built-in middleware | CORS, compression, ETag, secure headers included                          |\n| Web Standards       | Uses Fetch API, Request/Response objects                                  |\n\nHono is the default and recommended framework for NeuroLink server adapters.","hierarchy":{"lvl0":"Guides","lvl1":"Hono Adapter","lvl2":"Why Hono?","lvl3":""}},
 {"objectID":"4a6a19f4b89aa1306c9c1c381201916f7a706160c87f5e8dbf11e7f2cc60764f","title":"CLI Usage","url":"/docs/guides/server-adapters/hono#cli-usage","content":"Start a Hono server via CLI:","hierarchy":{"lvl0":"Guides","lvl1":"Hono Adapter","lvl2":"CLI Usage","lvl3":""}},
@@ -7868,7 +7869,7 @@
 {"objectID":"ac05717bef2259e66cdf32c6288f05234f2bcfdb7368a47650ed142a0a388a55","title":"Test the Server","url":"/docs/guides/server-adapters/hono#test-the-server","content":"Test the Server","hierarchy":{"lvl0":"Guides","lvl1":"Hono Adapter","lvl2":"Test the Server","lvl3":""}},
 {"objectID":"65a842ab7e90d7989760c8a34c85e7567c556472b5b3d94a0c62ccc93a613156","title":"Accessing the Hono App","url":"/docs/guides/server-adapters/hono#accessing-the-hono-app","content":"For advanced customization, you can access the underlying Hono instance:","hierarchy":{"lvl0":"Guides","lvl1":"Hono Adapter","lvl2":"Accessing the Hono App","lvl3":""}},
 {"objectID":"0f064fccc3e1e74bc76e8e15f3bf58fc0a6fb19c5287de8d9477a3c660a1b562","title":"Full Configuration Example","url":"/docs/guides/server-adapters/hono#full-configuration-example","content":"Full Configuration Example","hierarchy":{"lvl0":"Guides","lvl1":"Hono Adapter","lvl2":"Full Configuration Example","lvl3":""}},
-{"objectID":"f2750d8ff58dea504fb6e6d82dd41be7772022260c0badf9be197729e5921f1c","title":"Request body limits","url":"/docs/guides/server-adapters/hono#request-body-limits","content":"bodyParser.jsonLimit bounds JSON bodies and bodyParser.maxSize bounds url-encoded forms. Both default to 10mb, as on the Express, Fastify and Koa adapters, and raising either one is honoured. Uploads (multipart/form-data, application/octet-stream, audio/*) are bounded by bodyParser.rawMaxSize, which defaults to maxSize when that is set and to 64mb otherwise.\n\nA JSON or url-encoded form body over its limit is answered 413 with error.code set to PAYLOAD_TOO_LARGE, before any middleware or route runs. A declared Content-Length over the limit is refused without reading the body, and a body sent without one is read only as far as the limit. An upload over the limit still reaches its route, which answers in its own wire format.","hierarchy":{"lvl0":"Guides","lvl1":"Hono Adapter","lvl2":"Request body limits","lvl3":""}},
+{"objectID":"f2750d8ff58dea504fb6e6d82dd41be7772022260c0badf9be197729e5921f1c","title":"Request body limits","url":"/docs/guides/server-adapters/hono#request-body-limits","content":"bodyParser.jsonLimit bounds JSON bodies and bodyParser.maxSize bounds url-encoded forms. Both default to 10mb, as on the Express, Fastify and Koa adapters, and raising either one is honoured. Uploads (multipart/form-data, application/octet-stream, audio/*) are bounded by bodyParser.rawMaxSize, which defaults to maxSize when that is set and to 64mb otherwise.\n\nA JSON or url-encoded form body over its limit is answered 413 with error.code set to PAYLOAD_TOO_LARGE, before any middleware or route runs. A declared Content-Length over the limit is refused without reading the body, and a body sent without one is read only as far as the limit. An upload over the limit still reaches its route, which answers in its own wire format.\n\nThe Express adapter stops at the limit the same way (see \"Request body limits\" in its guide). Its 413 carries the message request entity too large, where Hono's names the limit in bytes.","hierarchy":{"lvl0":"Guides","lvl1":"Hono Adapter","lvl2":"Request body limits","lvl3":""}},
 {"objectID":"821ac3bdd68d125a2aef04f014beab93f8b62f2148bcece2ccc375cd2d09925b","title":"Using NeuroLink Middleware","url":"/docs/guides/server-adapters/hono#using-neurolink-middleware","content":"Using NeuroLink Middleware","hierarchy":{"lvl0":"Guides","lvl1":"Hono Adapter","lvl2":"Using NeuroLink Middleware","lvl3":""}},
 {"objectID":"354e2b56d0fe0720a8dadeb912ee44e5412ff034874daf270f8c96ce6a011b54","title":"Using Hono Built-in Middleware","url":"/docs/guides/server-adapters/hono#using-hono-built-in-middleware","content":"Using Hono Built-in Middleware","hierarchy":{"lvl0":"Guides","lvl1":"Hono Adapter","lvl2":"Using Hono Built-in Middleware","lvl3":""}},
 {"objectID":"87222251107cdbe1386180da56d88d17b161d2b7b2aafc76f031006fa81fc0dd","title":"Streaming Responses","url":"/docs/guides/server-adapters/hono#streaming-responses","content":"Hono has excellent streaming support, which NeuroLink leverages for real-time AI responses:","hierarchy":{"lvl0":"Guides","lvl1":"Hono Adapter","lvl2":"Streaming Responses","lvl3":""}},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "13.8.16",
+  "version": "13.8.17",
   "packageManager": "pnpm@10.28.2",
   "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": {