@juspay/neurolink 13.8.17 → 13.8.18

package/dist/rag/retrieval/vectorQueryTool.js

@@ -10,6 +10,7 @@ import { ProviderFactory } from "../../factories/providerFactory.js";
 import { withSpan } from "../../telemetry/withSpan.js";
 import { tracers } from "../../telemetry/tracers.js";
 import { logger } from "../../utils/logger.js";
+import { vetRegexPattern } from "../../middleware/utils/regexSafety.js";
 import { rerank } from "../reranker/reranker.js";
 /**
  * Creates a vector query tool for semantic search
@@ -132,11 +133,19 @@ export function createVectorQueryTool(config, vectorStore) {
         },
     };
 }
+/** Longest `$regex` filter pattern accepted; a secondary cap behind vetting. */
+const MAX_FILTER_REGEX_LENGTH = 200;
+/** Longest metadata value a `$regex` filter is run against. */
+const MAX_FILTER_REGEX_SUBJECT = 10_000;
+/** Distinct patterns remembered per store before the verdict cache is reset. */
+const MAX_FILTER_REGEX_CACHE = 256;
 /**
  * In-memory vector store implementation for testing and development
  */
 export class InMemoryVectorStore {
     vectors = new Map();
+    /** Vetted `$regex` patterns: the compiled expression, or null when refused. */
+    regexFilterCache = new Map();
     /**
      * Add vectors to an index
      */
@@ -272,23 +281,14 @@ export class InMemoryVectorStore {
                         return false;
                     }
                     if ("$regex" in ops) {
-                        const pattern = ops.$regex;
-                        let regexMatches = false;
-                        // Guard against ReDoS: reject excessively long patterns and limit
-                        // the tested string length to prevent pathological backtracking.
-                        if (pattern.length <= 200) {
-                            try {
-                                const re = new RegExp(pattern);
-                                const testValue = typeof fieldValue === "string"
-                                    ? fieldValue.slice(0, 10_000)
-                                    : "";
-                                regexMatches = re.test(testValue);
-                            }
-                            catch {
-                                // Invalid regex pattern — treat as non-match
-                                regexMatches = false;
-                            }
-                        }
+                        // The pattern is chosen by the model and the value it runs on
+                        // comes from ingested documents, so both halves of a ReDoS are
+                        // attacker-influenced. A length cap alone does not bound
+                        // backtracking (`^(a+)+$` is 7 characters); `vetRegexPattern`
+                        // reads the pattern's structure and refuses the ones that can
+                        // backtrack catastrophically. A refused or invalid pattern is a
+                        // non-match, as an invalid one always was.
+                        const regexMatches = this.matchesRegexFilter(ops.$regex, fieldValue);
                         if (!regexMatches) {
                             return false;
                         }
@@ -304,6 +304,43 @@ export class InMemoryVectorStore {
         }
         return true;
     }
+    /**
+     * Evaluate a `$regex` filter operator. Patterns are vetted once per store
+     * and the verdict cached, so a refused pattern costs one analysis.
+     */
+    matchesRegexFilter(pattern, fieldValue) {
+        if (typeof pattern !== "string" ||
+            pattern.length > MAX_FILTER_REGEX_LENGTH) {
+            return false;
+        }
+        let compiled = this.regexFilterCache.get(pattern);
+        if (compiled === undefined) {
+            const verdict = vetRegexPattern(pattern);
+            if (verdict.safe) {
+                try {
+                    compiled = new RegExp(pattern);
+                }
+                catch {
+                    compiled = null;
+                }
+            }
+            else {
+                logger.debug("[InMemoryVectorStore] Refused a $regex filter pattern that could stall the process", { reason: verdict.reason });
+                compiled = null;
+            }
+            if (this.regexFilterCache.size >= MAX_FILTER_REGEX_CACHE) {
+                this.regexFilterCache.clear();
+            }
+            this.regexFilterCache.set(pattern, compiled);
+        }
+        if (compiled === null) {
+            return false;
+        }
+        const testValue = typeof fieldValue === "string"
+            ? fieldValue.slice(0, MAX_FILTER_REGEX_SUBJECT)
+            : "";
+        return compiled.test(testValue);
+    }
     /**
      * Calculate cosine similarity between two vectors
      */

package/dist/server/abstract/baseServerAdapter.d.ts

@@ -7,6 +7,8 @@ import { EventEmitter } from "events";
 import type { ExternalServerManager } from "../../mcp/externalServerManager.js";
 import type { MCPToolRegistry } from "../../mcp/toolRegistry.js";
 import type { NeuroLink } from "../../neurolink.js";
+/** The interface an adapter binds unless told otherwise: this host only. */
+export declare const DEFAULT_SERVER_HOST = "127.0.0.1";
 import type { MiddlewareDefinition, RedactionConfig, RequiredServerAdapterConfig, RequiredShutdownConfig, RouteDefinition, ServerAdapterConfig, ServerAdapterEvents, ServerCarriedContext, ServerContext, ServerLifecycleState, ServerStatus, TrackedConnection } from "../../types/index.js";
 /**
  * Abstract base class for server adapters
@@ -29,7 +31,47 @@ export declare abstract class BaseServerAdapter extends EventEmitter {
     protected activeConnections: Map<string, TrackedConnection>;
     protected readonly shutdownConfig: RequiredShutdownConfig;
     private carryRequestedByRoutes;
+    private sensitiveRoutesRegistered;
+    private sensitiveRoutesAllowedOpen;
     constructor(neurolink: NeuroLink, config?: ServerAdapterConfig);
+    /**
+     * Whether middleware marked `authenticates: true` is registered (the
+     * built-in authentication middleware marks itself). The tool and MCP
+     * execution routes ask on every request; `registerAllRoutes()` wires them.
+     */
+    hasAuthenticationMiddleware(): boolean;
+    /**
+     * Called by `registerAllRoutes()`: routes that act on the host (tool and
+     * MCP execution) are mounted, so `start()` warns when no authentication
+     * middleware guards them. The check runs at start, when the middleware set
+     * is final, so registering authentication after the routes is fine.
+     */
+    noteSensitiveRoutes(options?: {
+        allowUnauthenticated?: boolean;
+    }): void;
+    /**
+     * The warning promised by `noteSensitiveRoutes()`, always on stderr: a
+     * `logger.warn` is dropped unless debug logging is on, which would hide a
+     * notice meant for the operator who just started the server.
+     */
+    protected warnIfSensitiveRoutesUnauthenticated(): void;
+    /**
+     * Give the handler a way to notice that the client is gone or the request
+     * is over time. The controller is this request's own unless middleware
+     * already attached one that the adapter carried; `applyTimeout` arms the
+     * configured request timeout, which the caller leaves off for a streaming
+     * route (a stream legitimately outlives it, as under Hono's own timeout
+     * middleware). `release()` disarms the timer once the response is written.
+     */
+    protected attachRequestAbort(ctx: ServerContext, options: {
+        onClientClose: (listener: () => void) => void;
+        applyTimeout: boolean;
+    }): {
+        controller: AbortController;
+        deadline: Promise<never> | undefined;
+        timedOut: () => boolean;
+        release: () => void;
+    };
     /**
      * Initialize the underlying server framework
      * May be async: adapters that dynamically import their framework package
@@ -146,6 +188,7 @@ export declare abstract class BaseServerAdapter extends EventEmitter {
         query?: Record<string, string>;
         params?: Record<string, string>;
         body?: unknown;
+        remoteAddress?: string;
     }): ServerContext;
     /**
      * Register built-in middleware

package/dist/server/abstract/baseServerAdapter.js

@@ -6,10 +6,15 @@
 import { EventEmitter } from "events";
 import { getMetricsAggregator, SpanSerializer, SpanStatus, SpanType, } from "../../observability/index.js";
 import { withTimeout } from "../../utils/errorHandling.js";
+import { MAX_TIMER_MS } from "../../constants/timeouts.js";
 import { logger } from "../../utils/logger.js";
 import { markContextCarried } from "../utils/carriedContextMark.js";
+import { isLoopbackAddress } from "../utils/clientAddress.js";
+import { pathStartsWithSegment } from "../utils/pathMatch.js";
 import { tryImport } from "../../utils/tryImport.js";
-import { DrainTimeoutError, InvalidLifecycleStateError, MissingDependencyError, ServerAdapterError, ShutdownTimeoutError, } from "../errors.js";
+import { ConfigurationError, DrainTimeoutError, InvalidLifecycleStateError, MissingDependencyError, ServerAdapterError, ServerTimeoutError, ShutdownTimeoutError, } from "../errors.js";
+/** The interface an adapter binds unless told otherwise: this host only. */
+export const DEFAULT_SERVER_HOST = "127.0.0.1";
 /**
  * Abstract base class for server adapters
  * Provides common functionality and defines the interface for framework-specific implementations
@@ -37,6 +42,9 @@ export class BaseServerAdapter extends EventEmitter {
     // Set by enableMiddlewareStateCarry(); the carryMiddlewareState option is the
     // other way in.
     carryRequestedByRoutes = false;
+    // Set by noteSensitiveRoutes(); read when the server starts.
+    sensitiveRoutesRegistered = false;
+    sensitiveRoutesAllowedOpen = false;
     constructor(neurolink, config = {}) {
         super();
         this.neurolink = neurolink;
@@ -53,7 +61,9 @@ export class BaseServerAdapter extends EventEmitter {
         // Apply defaults
         this.config = {
             port: config.port ?? 3000,
-            host: config.host ?? "0.0.0.0",
+            // Loopback unless the operator names an interface: the routes run tools
+            // and remove MCP servers, so reachability is opt-in.
+            host: config.host ?? DEFAULT_SERVER_HOST,
             basePath: config.basePath ?? "/api",
             cors: {
                 enabled: config.cors?.enabled ?? true,
@@ -85,6 +95,8 @@ export class BaseServerAdapter extends EventEmitter {
                     "Too many requests, please try again later",
                 skipPaths: config.rateLimit?.skipPaths,
                 keyGenerator: config.rateLimit?.keyGenerator,
+                trustProxy: config.rateLimit?.trustProxy ?? false,
+                trustedProxies: config.rateLimit?.trustedProxies ?? [],
             },
             bodyParser: {
                 enabled: config.bodyParser?.enabled ?? true,
@@ -107,6 +119,100 @@ export class BaseServerAdapter extends EventEmitter {
             shutdown: this.shutdownConfig,
             carryMiddlewareState: config.carryMiddlewareState ?? false,
         };
+        // A wildcard origin with credentials is what the CORS specification
+        // forbids and what an adapter reflecting the request's Origin would grant:
+        // any page could make credentialed calls. Refuse it for every adapter.
+        if (this.config.cors.enabled &&
+            this.config.cors.credentials &&
+            this.config.cors.origins.includes("*")) {
+            throw new ConfigurationError('cors.credentials cannot be combined with the wildcard origin "*"; list the origins that may send credentials', { origins: this.config.cors.origins });
+        }
+    }
+    /**
+     * Whether middleware marked `authenticates: true` is registered (the
+     * built-in authentication middleware marks itself). The tool and MCP
+     * execution routes ask on every request; `registerAllRoutes()` wires them.
+     */
+    hasAuthenticationMiddleware() {
+        return this.middlewares.some((middleware) => middleware.authenticates === true);
+    }
+    /**
+     * Called by `registerAllRoutes()`: routes that act on the host (tool and
+     * MCP execution) are mounted, so `start()` warns when no authentication
+     * middleware guards them. The check runs at start, when the middleware set
+     * is final, so registering authentication after the routes is fine.
+     */
+    noteSensitiveRoutes(options) {
+        this.sensitiveRoutesRegistered = true;
+        if (options?.allowUnauthenticated) {
+            this.sensitiveRoutesAllowedOpen = true;
+        }
+    }
+    /**
+     * The warning promised by `noteSensitiveRoutes()`, always on stderr: a
+     * `logger.warn` is dropped unless debug logging is on, which would hide a
+     * notice meant for the operator who just started the server.
+     */
+    warnIfSensitiveRoutesUnauthenticated() {
+        if (!this.sensitiveRoutesRegistered ||
+            this.sensitiveRoutesAllowedOpen ||
+            this.hasAuthenticationMiddleware()) {
+            return;
+        }
+        const where = isLoopbackAddress(this.config.host)
+            ? `loopback only (${this.config.host})`
+            : `${this.config.host}, reachable from the network`;
+        logger.alwaysStderr(`[ServerAdapter] WARNING: no authentication middleware is registered and the server listens on ${where}. ` +
+            "The tool and MCP execution routes answer 403 until authentication middleware (marked authenticates: true) is registered, " +
+            "or allowUnauthenticated: true / NEUROLINK_SERVER_ALLOW_UNAUTHENTICATED=1 opts out of that gate.");
+    }
+    /**
+     * Give the handler a way to notice that the client is gone or the request
+     * is over time. The controller is this request's own unless middleware
+     * already attached one that the adapter carried; `applyTimeout` arms the
+     * configured request timeout, which the caller leaves off for a streaming
+     * route (a stream legitimately outlives it, as under Hono's own timeout
+     * middleware). `release()` disarms the timer once the response is written.
+     */
+    attachRequestAbort(ctx, options) {
+        const controller = ctx.abortController ?? new AbortController();
+        ctx.abortController = controller;
+        ctx.abortSignal = controller.signal;
+        let timedOut = false;
+        let timer;
+        const timeoutMs = this.config.timeout;
+        // Node turns an over-range delay into 1 ms; keep long request budgets
+        // at the timer limit, as the readiness deadline does through withTimeout.
+        const delayMs = timeoutMs > MAX_TIMER_MS ? MAX_TIMER_MS : timeoutMs;
+        const deadline = options.applyTimeout && timeoutMs > 0
+            ? new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    timedOut = true;
+                    const error = new ServerTimeoutError(timeoutMs, `${ctx.method} ${ctx.path}`, ctx.requestId);
+                    controller.abort(error);
+                    reject(error);
+                }, delayMs);
+            })
+            : undefined;
+        // A rejection nobody awaits (the handler won on the race) must not
+        // surface as unhandled.
+        deadline?.catch(() => undefined);
+        options.onClientClose(() => {
+            if (!controller.signal.aborted) {
+                controller.abort(new Error("Client disconnected"));
+            }
+        });
+        return {
+            controller,
+            deadline,
+            timedOut: () => timedOut,
+            release: () => {
+                if (timer) {
+                    clearTimeout(timer);
+                    timer = undefined;
+                }
+            },
+        };
     }
     /**
      * The listening Node `http.Server`, once `start()` has run and the runtime
@@ -237,11 +343,17 @@ export class BaseServerAdapter extends EventEmitter {
             }
         }
         // Register all routes in the group with prefix applied
+        const prefix = this.normalizePath(group.prefix);
+        // The group's root segment ("/api" of "/api/health"): a route whose path
+        // already lives under it is a full path, as every built-in route is.
+        // Testing only the whole prefix put `/api/version`, declared in the health
+        // group, at `/api/health/api/version`.
+        const root = `/${prefix.split("/").filter(Boolean)[0] ?? ""}`;
         for (const route of group.routes) {
-            // Only prepend prefix if route path doesn't already start with it
-            // (route definitions include full paths like /api/agent/execute)
-            const needsPrefix = !route.path.startsWith(group.prefix);
-            const prefixedPath = this.normalizePath(needsPrefix ? `${group.prefix}${route.path}` : route.path);
+            const needsPrefix = prefix !== "/" &&
+                !pathStartsWithSegment(route.path, prefix) &&
+                !pathStartsWithSegment(route.path, root);
+            const prefixedPath = this.normalizePath(needsPrefix ? `${prefix}${route.path}` : route.path);
             const prefixedRoute = {
                 ...route,
                 path: prefixedPath,
@@ -336,6 +448,7 @@ export class BaseServerAdapter extends EventEmitter {
             query: options.query ?? {},
             params: options.params ?? {},
             body: options.body,
+            remoteAddress: options.remoteAddress,
             neurolink: this.neurolink,
             toolRegistry: this.toolRegistry,
             externalServerManager: this.externalServerManager,

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

@@ -13,6 +13,7 @@ export declare class ExpressServerAdapter extends BaseServerAdapter {
     private server?;
     private frameworkInitialized;
     private sockets;
+    private warnedNoClientAddress;
     constructor(neurolink: NeuroLink, config?: ServerAdapterConfig);
     /**
      * Initialize Express framework asynchronously
@@ -22,6 +23,8 @@ export declare class ExpressServerAdapter extends BaseServerAdapter {
      * Initialize Express framework with async imports
      */
     private initializeFrameworkAsync;
+    /** The address a request is counted against; `undefined` when there is none. */
+    private clientKeyFor;
     /**
      * Override initialize to ensure async framework setup
      */

package/dist/server/adapters/expressAdapter.js

@@ -5,9 +5,14 @@
 import { logger } from "../../utils/logger.js";
 import { AlreadyRunningError, ServerAdapterError, ServerStartError, ServerStopError, wrapError, } from "../errors.js";
 import { BaseServerAdapter } from "../abstract/baseServerAdapter.js";
+import { resolveClientAddress } from "../utils/clientAddress.js";
+import { shapeRouteError } from "../utils/clientError.js";
+import { pathMatchesAny } from "../utils/pathMatch.js";
 import { isErrorResponse } from "../utils/validation.js";
 import { createBoundedBodyParser } from "../utils/expressBody.js";
 import { isRawBodyContentType, isWebResponse, readWebResponse, } from "../utils/rawBody.js";
+/** How long `listen()` may take; `config.timeout` is the per-request budget. */
+const STARTUP_TIMEOUT_MS = 30_000;
 /**
  * Express-specific server adapter
  */
@@ -16,6 +21,8 @@ export class ExpressServerAdapter extends BaseServerAdapter {
     server;
     frameworkInitialized = false;
     sockets = new Set();
+    // The rate limiter counts nothing it cannot attribute, and says so once.
+    warnedNoClientAddress = false;
     constructor(neurolink, config = {}) {
         super(neurolink, config);
     }
@@ -77,6 +84,13 @@ export class ExpressServerAdapter extends BaseServerAdapter {
             const limiter = rateLimit({
                 windowMs,
                 max: this.config.rateLimit.maxRequests,
+                // The key is resolved here, from the TCP peer or, behind a declared
+                // proxy, the client it reports; the library's own reading of the
+                // request (and its warnings about it) is not used. A request with no
+                // attributable address passes rather than share a bucket.
+                validate: false,
+                keyGenerator: (req) => this.clientKeyFor(req) ?? "",
+                skip: (req) => this.clientKeyFor(req) === undefined,
                 message: {
                     error: {
                         code: "RATE_LIMIT_EXCEEDED",
@@ -128,6 +142,20 @@ export class ExpressServerAdapter extends BaseServerAdapter {
         }
         this.frameworkInitialized = true;
     }
+    /** The address a request is counted against; `undefined` when there is none. */
+    clientKeyFor(req) {
+        const key = resolveClientAddress({
+            remoteAddress: req.socket?.remoteAddress,
+            forwardedFor: req.headers["x-forwarded-for"],
+            trustProxy: this.config.rateLimit.trustProxy,
+            trustedProxies: this.config.rateLimit.trustedProxies,
+        });
+        if (key === undefined && !this.warnedNoClientAddress) {
+            this.warnedNoClientAddress = true;
+            logger.alwaysStderr("[ExpressAdapter] A request arrived with no peer address, so the rate limiter cannot count it; configure rateLimit.keyGenerator to limit by another key.");
+        }
+        return key;
+    }
     /**
      * Override initialize to ensure async framework setup
      */
@@ -152,7 +180,7 @@ export class ExpressServerAdapter extends BaseServerAdapter {
      */
     registerFrameworkRoute(route) {
         const method = route.method.toLowerCase();
-        this.app[method](route.path, async (req, res, next) => {
+        this.app[method](route.path, async (req, res, _next) => {
             const requestId = req.headers["x-request-id"];
             const startTime = Date.now();
             // Create server context
@@ -164,12 +192,24 @@ export class ExpressServerAdapter extends BaseServerAdapter {
                 query: req.query,
                 params: req.params,
                 body: req.body,
+                remoteAddress: req.socket?.remoteAddress,
             });
             // Copy response headers from middleware (stored in res.locals by middleware)
             if (res.locals.responseHeaders) {
                 ctx.responseHeaders = { ...res.locals.responseHeaders };
             }
             this.restoreCarriedContext(ctx, res.locals.carriedContext);
+            // The handler learns of a client that went away, and a request over
+            // `config.timeout` is answered 504 and its work aborted. Express used
+            // to apply that timeout only to its own listen().
+            const abort = this.attachRequestAbort(ctx, {
+                onClientClose: (listener) => res.on("close", () => {
+                    if (!res.writableFinished) {
+                        listener();
+                    }
+                }),
+                applyTimeout: !route.streaming?.enabled,
+            });
             // Emit request event
             this.emit("request", {
                 requestId,
@@ -183,7 +223,9 @@ export class ExpressServerAdapter extends BaseServerAdapter {
                     return this.handleStreamingResponse(res, ctx, route);
                 }
                 // Execute handler
-                const result = await route.handler(ctx);
+                const result = abort.deadline
+                    ? await Promise.race([route.handler(ctx), abort.deadline])
+                    : await route.handler(ctx);
                 const duration = Date.now() - startTime;
                 // A route that answers in its own wire format returns a web Response.
                 if (isWebResponse(result)) {
@@ -255,7 +297,31 @@ export class ExpressServerAdapter extends BaseServerAdapter {
                 });
             }
             catch (error) {
-                next(error);
+                // The exception's text stays in the log under this request id; the
+                // client gets a fixed message for its category.
+                const shaped = shapeRouteError("ExpressAdapter", requestId, error);
+                this.emitRequestError({
+                    requestId,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    timestamp: new Date(),
+                });
+                this.emit("response", {
+                    requestId,
+                    statusCode: shaped.status,
+                    duration: Date.now() - startTime,
+                    timestamp: new Date(),
+                });
+                if (res.headersSent) {
+                    res.end();
+                    return;
+                }
+                res.status(shaped.status).json({
+                    error: { code: shaped.code, message: shaped.message },
+                    metadata: { requestId, timestamp: new Date().toISOString() },
+                });
+            }
+            finally {
+                abort.release();
             }
         });
         // Error handling middleware (should be registered once after all routes)
@@ -335,9 +401,13 @@ export class ExpressServerAdapter extends BaseServerAdapter {
             res.end();
         }
         catch (error) {
+            const shaped = shapeRouteError("ExpressAdapter", ctx.requestId, error);
             res.write(`event: error\n`);
             res.write(`data: ${JSON.stringify({
-                error: error instanceof Error ? error.message : "Stream error",
+                error: shaped.message,
+                code: shaped.code,
+                status: shaped.status,
+                requestId: ctx.requestId,
             })}\n\n`);
             res.end();
         }
@@ -350,7 +420,7 @@ export class ExpressServerAdapter extends BaseServerAdapter {
         for (const path of paths) {
             this.app.use(path, async (req, res, next) => {
                 // Skip excluded paths
-                if (middleware.excludePaths?.some((p) => req.path.startsWith(p))) {
+                if (pathMatchesAny(req.path, middleware.excludePaths)) {
                     return next();
                 }
                 // Initialize response headers storage in res.locals if not present
@@ -367,6 +437,7 @@ export class ExpressServerAdapter extends BaseServerAdapter {
                     query: req.query,
                     params: req.params,
                     body: req.body,
+                    remoteAddress: req.socket?.remoteAddress,
                 });
                 // Copy existing response headers to context
                 ctx.responseHeaders = { ...res.locals.responseHeaders };
@@ -408,13 +479,14 @@ export class ExpressServerAdapter extends BaseServerAdapter {
         }
         this.lifecycleState = "starting";
         const { port, host } = this.config;
-        const startupTimeout = this.config.timeout || 30000;
+        const startupTimeout = STARTUP_TIMEOUT_MS;
         const startPromise = new Promise((resolve, reject) => {
             try {
                 this.server = this.app.listen(port, host, () => {
                     this.isRunning = true;
                     this.startTime = new Date();
                     this.lifecycleState = "running";
+                    this.warnIfSensitiveRoutesUnauthenticated();
                     // Track connections for graceful shutdown
                     this.server?.on("connection", (socket) => {
                         const connectionId = `conn-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;

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

@@ -13,6 +13,7 @@ import type { MiddlewareDefinition, RouteDefinition, ServerAdapterConfig } from
 export declare class FastifyServerAdapter extends BaseServerAdapter {
     private app;
     private frameworkInitialized;
+    private warnedNoClientAddress;
     private connectionIds;
     constructor(neurolink: NeuroLink, config?: ServerAdapterConfig);
     /**
@@ -24,6 +25,8 @@ export declare class FastifyServerAdapter extends BaseServerAdapter {
      * Initialize Fastify framework with async imports
      */
     private initializeFrameworkAsync;
+    /** The address a request is counted against; `undefined` when there is none. */
+    private clientKeyFor;
     /**
      * Parse body limit string to number (bytes)
      */