@juspay/neurolink 9.54.6 → 9.54.8

package/dist/rag/reranker/reranker.js

@@ -4,6 +4,8 @@
  * Multi-factor scoring system for reranking retrieval results.
  * Combines semantic relevance (LLM-based), vector similarity, and position.
  */
+import { withSpan } from "../../telemetry/withSpan.js";
+import { tracers } from "../../telemetry/tracers.js";
 import { logger } from "../../utils/logger.js";
 /**
  * Default scoring weights
@@ -28,60 +30,73 @@ const DEFAULT_WEIGHTS = {
  * @returns Reranked results with detailed scores
  */
 export async function rerank(results, query, model, options) {
-    const { queryEmbedding: _queryEmbedding, topK = 3, weights = DEFAULT_WEIGHTS, } = options || {};
-    if (results.length === 0) {
-        return [];
-    }
-    // Validate weights sum to 1.0
-    const totalWeight = (weights.semantic || DEFAULT_WEIGHTS.semantic) +
-        (weights.vector || DEFAULT_WEIGHTS.vector) +
-        (weights.position || DEFAULT_WEIGHTS.position);
-    if (Math.abs(totalWeight - 1.0) > 0.01) {
-        logger.warn("[Reranker] Weights do not sum to 1.0, normalizing", {
-            original: weights,
-            total: totalWeight,
-        });
-    }
-    const normalizedWeights = {
-        semantic: (weights.semantic || DEFAULT_WEIGHTS.semantic) / totalWeight,
-        vector: (weights.vector || DEFAULT_WEIGHTS.vector) / totalWeight,
-        position: (weights.position || DEFAULT_WEIGHTS.position) / totalWeight,
-    };
-    const rerankedResults = [];
-    // Process results in parallel batches for efficiency
-    const batchSize = 5;
-    for (let i = 0; i < results.length; i += batchSize) {
-        const batch = results.slice(i, i + batchSize);
-        const batchPromises = batch.map(async (result, batchIndex) => {
-            const globalIndex = i + batchIndex;
-            // Calculate vector score (use existing score or 0)
-            const vectorScore = result.score ?? 0;
-            // Calculate position score (inverse of position)
-            const positionScore = 1 - globalIndex / results.length;
-            // Calculate semantic score using LLM
-            const semanticResult = await calculateSemanticScore(query, result.text || result.metadata?.text || "", model);
-            // Combine scores
-            const combinedScore = normalizedWeights.semantic * semanticResult.score +
-                normalizedWeights.vector * vectorScore +
-                normalizedWeights.position * positionScore;
-            return {
-                result,
-                score: combinedScore,
-                details: {
-                    semantic: semanticResult.score,
-                    vector: vectorScore,
-                    position: positionScore,
-                    queryAnalysis: semanticResult.analysis,
-                },
-            };
-        });
-        const batchResults = await Promise.all(batchPromises);
-        rerankedResults.push(...batchResults);
-    }
-    // Sort by combined score descending
-    rerankedResults.sort((a, b) => b.score - a.score);
-    // Return top K results
-    return rerankedResults.slice(0, topK);
+    return withSpan({
+        name: "neurolink.rag.rerank",
+        tracer: tracers.rag,
+        attributes: {
+            "rag.reranker.input_count": results.length,
+            "rag.reranker.top_k": options?.topK ?? 3,
+            "rag.reranker.query_length": query.length,
+        },
+    }, async (span) => {
+        const { queryEmbedding: _queryEmbedding, topK = 3, weights = DEFAULT_WEIGHTS, } = options || {};
+        if (results.length === 0) {
+            span.setAttribute("rag.reranker.output_count", 0);
+            return [];
+        }
+        // Validate weights sum to 1.0
+        const totalWeight = (weights.semantic || DEFAULT_WEIGHTS.semantic) +
+            (weights.vector || DEFAULT_WEIGHTS.vector) +
+            (weights.position || DEFAULT_WEIGHTS.position);
+        if (Math.abs(totalWeight - 1.0) > 0.01) {
+            logger.warn("[Reranker] Weights do not sum to 1.0, normalizing", {
+                original: weights,
+                total: totalWeight,
+            });
+        }
+        const normalizedWeights = {
+            semantic: (weights.semantic || DEFAULT_WEIGHTS.semantic) / totalWeight,
+            vector: (weights.vector || DEFAULT_WEIGHTS.vector) / totalWeight,
+            position: (weights.position || DEFAULT_WEIGHTS.position) / totalWeight,
+        };
+        const rerankedResults = [];
+        // Process results in parallel batches for efficiency
+        const batchSize = 5;
+        for (let i = 0; i < results.length; i += batchSize) {
+            const batch = results.slice(i, i + batchSize);
+            const batchPromises = batch.map(async (result, batchIndex) => {
+                const globalIndex = i + batchIndex;
+                // Calculate vector score (use existing score or 0)
+                const vectorScore = result.score ?? 0;
+                // Calculate position score (inverse of position)
+                const positionScore = 1 - globalIndex / results.length;
+                // Calculate semantic score using LLM
+                const semanticResult = await calculateSemanticScore(query, result.text || result.metadata?.text || "", model);
+                // Combine scores
+                const combinedScore = normalizedWeights.semantic * semanticResult.score +
+                    normalizedWeights.vector * vectorScore +
+                    normalizedWeights.position * positionScore;
+                return {
+                    result,
+                    score: combinedScore,
+                    details: {
+                        semantic: semanticResult.score,
+                        vector: vectorScore,
+                        position: positionScore,
+                        queryAnalysis: semanticResult.analysis,
+                    },
+                };
+            });
+            const batchResults = await Promise.all(batchPromises);
+            rerankedResults.push(...batchResults);
+        }
+        // Sort by combined score descending
+        rerankedResults.sort((a, b) => b.score - a.score);
+        // Return top K results
+        const output = rerankedResults.slice(0, topK);
+        span.setAttribute("rag.reranker.output_count", output.length);
+        return output;
+    }); // end withSpan
 }
 /**
  * Calculate semantic relevance score using LLM
@@ -135,24 +150,35 @@ Score:`;
  * @returns Reranked results
  */
 export async function batchRerank(results, query, model, options) {
-    const { topK = 3, weights = DEFAULT_WEIGHTS } = options || {};
-    if (results.length === 0) {
-        return [];
-    }
-    // Normalize weights
-    const totalWeight = (weights.semantic || DEFAULT_WEIGHTS.semantic) +
-        (weights.vector || DEFAULT_WEIGHTS.vector) +
-        (weights.position || DEFAULT_WEIGHTS.position);
-    const normalizedWeights = {
-        semantic: (weights.semantic || DEFAULT_WEIGHTS.semantic) / totalWeight,
-        vector: (weights.vector || DEFAULT_WEIGHTS.vector) / totalWeight,
-        position: (weights.position || DEFAULT_WEIGHTS.position) / totalWeight,
-    };
-    // Build batch scoring prompt
-    const documentsText = results
-        .map((r, i) => `[${i + 1}] ${(r.text || r.metadata?.text || "").slice(0, 300)}`)
-        .join("\n\n");
-    const prompt = `Rate the relevance of each document to the query on a scale of 0 to 1.
+    return withSpan({
+        name: "neurolink.rag.batchRerank",
+        tracer: tracers.rag,
+        attributes: {
+            "rag.reranker.input_count": results.length,
+            "rag.reranker.top_k": options?.topK ?? 3,
+            "rag.reranker.query_length": query.length,
+            "rag.reranker.batch": true,
+        },
+    }, async (span) => {
+        const { topK = 3, weights = DEFAULT_WEIGHTS } = options || {};
+        if (results.length === 0) {
+            span.setAttribute("rag.reranker.output_count", 0);
+            return [];
+        }
+        // Normalize weights
+        const totalWeight = (weights.semantic || DEFAULT_WEIGHTS.semantic) +
+            (weights.vector || DEFAULT_WEIGHTS.vector) +
+            (weights.position || DEFAULT_WEIGHTS.position);
+        const normalizedWeights = {
+            semantic: (weights.semantic || DEFAULT_WEIGHTS.semantic) / totalWeight,
+            vector: (weights.vector || DEFAULT_WEIGHTS.vector) / totalWeight,
+            position: (weights.position || DEFAULT_WEIGHTS.position) / totalWeight,
+        };
+        // Build batch scoring prompt
+        const documentsText = results
+            .map((r, i) => `[${i + 1}] ${(r.text || r.metadata?.text || "").slice(0, 300)}`)
+            .join("\n\n");
+        const prompt = `Rate the relevance of each document to the query on a scale of 0 to 1.
 
 Query: ${query}
 
@@ -161,58 +187,61 @@ ${documentsText}
 
 For each document, provide a score between 0 and 1.
 Respond with only the scores, one per line, in order:`;
-    try {
-        const result = await model.generate({
-            prompt,
-            maxTokens: 50,
-            temperature: 0,
-        });
-        // Parse scores from response
-        const scoreLines = (result?.content || "")
-            .trim()
-            .split("\n")
-            .map((line) => line.trim())
-            .filter((line) => line.length > 0);
-        const semanticScores = [];
-        for (let i = 0; i < results.length; i++) {
-            const scoreLine = scoreLines[i];
-            if (scoreLine) {
-                const score = parseFloat(scoreLine.match(/[\d.]+/)?.[0] || "0.5");
-                semanticScores.push(isNaN(score) || score < 0 || score > 1 ? 0.5 : score);
-            }
-            else {
-                semanticScores.push(0.5);
+        try {
+            const result = await model.generate({
+                prompt,
+                maxTokens: 50,
+                temperature: 0,
+            });
+            // Parse scores from response
+            const scoreLines = (result?.content || "")
+                .trim()
+                .split("\n")
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+            const semanticScores = [];
+            for (let i = 0; i < results.length; i++) {
+                const scoreLine = scoreLines[i];
+                if (scoreLine) {
+                    const score = parseFloat(scoreLine.match(/[\d.]+/)?.[0] || "0.5");
+                    semanticScores.push(isNaN(score) || score < 0 || score > 1 ? 0.5 : score);
+                }
+                else {
+                    semanticScores.push(0.5);
+                }
             }
+            // Calculate combined scores
+            const rerankedResults = results.map((result, i) => {
+                const vectorScore = result.score ?? 0;
+                const positionScore = 1 - i / results.length;
+                const semanticScore = semanticScores[i] ?? 0.5;
+                const combinedScore = normalizedWeights.semantic * semanticScore +
+                    normalizedWeights.vector * vectorScore +
+                    normalizedWeights.position * positionScore;
+                return {
+                    result,
+                    score: combinedScore,
+                    details: {
+                        semantic: semanticScore,
+                        vector: vectorScore,
+                        position: positionScore,
+                    },
+                };
+            });
+            // Sort and return top K
+            rerankedResults.sort((a, b) => b.score - a.score);
+            const output = rerankedResults.slice(0, topK);
+            span.setAttribute("rag.reranker.output_count", output.length);
+            return output;
         }
-        // Calculate combined scores
-        const rerankedResults = results.map((result, i) => {
-            const vectorScore = result.score ?? 0;
-            const positionScore = 1 - i / results.length;
-            const semanticScore = semanticScores[i] ?? 0.5;
-            const combinedScore = normalizedWeights.semantic * semanticScore +
-                normalizedWeights.vector * vectorScore +
-                normalizedWeights.position * positionScore;
-            return {
-                result,
-                score: combinedScore,
-                details: {
-                    semantic: semanticScore,
-                    vector: vectorScore,
-                    position: positionScore,
-                },
-            };
-        });
-        // Sort and return top K
-        rerankedResults.sort((a, b) => b.score - a.score);
-        return rerankedResults.slice(0, topK);
-    }
-    catch (error) {
-        logger.warn("[Reranker] Batch scoring failed, using individual scoring", {
-            error: error instanceof Error ? error.message : String(error),
-        });
-        // Fall back to individual scoring
-        return rerank(results, query, model, options);
-    }
+        catch (error) {
+            logger.warn("[Reranker] Batch scoring failed, using individual scoring", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Fall back to individual scoring
+            return rerank(results, query, model, options);
+        }
+    }); // end withSpan
 }
 /**
  * Simple position-based reranker (no LLM required)

package/dist/rag/retrieval/vectorQueryTool.js

@@ -7,6 +7,8 @@
 import { randomUUID } from "crypto";
 import { z } from "zod";
 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 { rerank } from "../reranker/reranker.js";
 /**
@@ -46,75 +48,87 @@ export function createVectorQueryTool(config, vectorStore) {
          * @returns Query results with relevant context
          */
         execute: async (params, context) => {
-            const startTime = Date.now();
-            try {
-                // Resolve vector store if it's a function
-                const store = typeof vectorStore === "function"
-                    ? vectorStore(context || {})
-                    : vectorStore;
-                // Generate query embedding
-                const embeddingProvider = await ProviderFactory.createProvider(embeddingModel.provider, embeddingModel.modelName);
-                // Check if provider has embed method
-                if (typeof embeddingProvider.embed !==
-                    "function") {
-                    throw new Error(`Provider ${embeddingModel.provider} does not support embeddings`);
-                }
-                const queryEmbedding = await embeddingProvider.embed(params.query);
-                // Query the vector store
-                let results = await store.query({
-                    indexName,
-                    queryVector: queryEmbedding,
-                    topK: params.topK || topK,
-                    filter: params.filter,
-                    includeVectors,
-                    ...providerOptions,
-                });
-                let reranked = false;
-                // Apply reranking if configured
-                if (rerankerConfig && results.length > 0) {
-                    const rerankerModel = await ProviderFactory.createProvider(typeof rerankerConfig.model === "object"
-                        ? rerankerConfig.model.provider
-                        : rerankerConfig.model, typeof rerankerConfig.model === "object"
-                        ? rerankerConfig.model.modelName
-                        : rerankerConfig.model);
-                    const rerankedResults = await rerank(results, params.query, rerankerModel, {
-                        weights: rerankerConfig.weights,
-                        topK: rerankerConfig.topK,
-                        queryEmbedding,
+            return withSpan({
+                name: "neurolink.rag.vectorQuery",
+                tracer: tracers.rag,
+                attributes: {
+                    "rag.vector.index": indexName,
+                    "rag.vector.top_k": params.topK ?? topK,
+                    "rag.vector.query_length": params.query.length,
+                },
+            }, async (span) => {
+                const startTime = Date.now();
+                try {
+                    // Resolve vector store if it's a function
+                    const store = typeof vectorStore === "function"
+                        ? vectorStore(context || {})
+                        : vectorStore;
+                    // Generate query embedding
+                    const embeddingProvider = await ProviderFactory.createProvider(embeddingModel.provider, embeddingModel.modelName);
+                    // Check if provider has embed method
+                    if (typeof embeddingProvider
+                        .embed !== "function") {
+                        throw new Error(`Provider ${embeddingModel.provider} does not support embeddings`);
+                    }
+                    const queryEmbedding = await embeddingProvider.embed(params.query);
+                    // Query the vector store
+                    let results = await store.query({
+                        indexName,
+                        queryVector: queryEmbedding,
+                        topK: params.topK || topK,
+                        filter: params.filter,
+                        includeVectors,
+                        ...providerOptions,
                     });
-                    results = rerankedResults.map((r) => r.result);
-                    reranked = true;
-                }
-                // Format results
-                const relevantContext = results
-                    .map((r, i) => `[${i + 1}] ${r.metadata?.text || r.text || ""}`)
-                    .join("\n\n");
-                const queryTime = Date.now() - startTime;
-                logger.info("[VectorQueryTool] Query completed", {
-                    query: params.query.slice(0, 50),
-                    resultsCount: results.length,
-                    queryTime,
-                    reranked,
-                    filtered: !!params.filter,
-                });
-                return {
-                    relevantContext,
-                    sources: includeSources ? results : [],
-                    totalResults: results.length,
-                    metadata: {
+                    let reranked = false;
+                    // Apply reranking if configured
+                    if (rerankerConfig && results.length > 0) {
+                        const rerankerModel = await ProviderFactory.createProvider(typeof rerankerConfig.model === "object"
+                            ? rerankerConfig.model.provider
+                            : rerankerConfig.model, typeof rerankerConfig.model === "object"
+                            ? rerankerConfig.model.modelName
+                            : rerankerConfig.model);
+                        const rerankedResults = await rerank(results, params.query, rerankerModel, {
+                            weights: rerankerConfig.weights,
+                            topK: rerankerConfig.topK,
+                            queryEmbedding,
+                        });
+                        results = rerankedResults.map((r) => r.result);
+                        reranked = true;
+                    }
+                    // Format results
+                    const relevantContext = results
+                        .map((r, i) => `[${i + 1}] ${r.metadata?.text || r.text || ""}`)
+                        .join("\n\n");
+                    const queryTime = Date.now() - startTime;
+                    logger.info("[VectorQueryTool] Query completed", {
+                        query: params.query.slice(0, 50),
+                        resultsCount: results.length,
                         queryTime,
                         reranked,
                         filtered: !!params.filter,
-                    },
-                };
-            }
-            catch (error) {
-                logger.error("[VectorQueryTool] Query failed", {
-                    query: params.query.slice(0, 50),
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                throw error;
-            }
+                    });
+                    span.setAttribute("rag.vector.result_count", results.length);
+                    span.setAttribute("rag.vector.reranked", reranked);
+                    return {
+                        relevantContext,
+                        sources: includeSources ? results : [],
+                        totalResults: results.length,
+                        metadata: {
+                            queryTime,
+                            reranked,
+                            filtered: !!params.filter,
+                        },
+                    };
+                }
+                catch (error) {
+                    logger.error("[VectorQueryTool] Query failed", {
+                        query: params.query.slice(0, 50),
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    throw error;
+                }
+            }); // end withSpan
         },
     };
 }

package/dist/sdk/toolRegistration.d.ts

@@ -3,7 +3,7 @@
  * Simple interface for developers to register custom tools
  */
 import { z } from "zod";
-import type { MCPServerInfo, MCPServerCategory, JsonValue, ToolArgs, SimpleTool as CoreSimpleTool, ZodUnknownSchema, SDKToolContext } from "../types/index.js";
+import type { JsonValue, MCPServerCategory, MCPServerInfo, SDKToolContext, SdkSimpleTool, ZodUnknownSchema } from "../types/index.js";
 /**
  * Enhanced validation configuration
  */
@@ -16,44 +16,10 @@ declare const VALIDATION_CONFIG: {
     readonly RECOMMENDED_PATTERNS: readonly ["get_data", "fetch_info", "calculate_value", "send_message", "create_item", "update_record", "delete_file", "validate_input"];
     readonly COMPILED_PATTERN_REGEXES: RegExp[];
 };
-/**
- * Context provided to tools during execution
- * Type alias for backward compatibility
- */
-type ToolContext = SDKToolContext;
-/**
- * Simple tool interface for SDK users
- * Extends the core SimpleTool with specific types
- */
-type SimpleTool<TArgs = ToolArgs, TResult = JsonValue> = Omit<CoreSimpleTool<TArgs, TResult>, "execute"> & {
-    /**
-     * Tool description that helps AI understand when to use it
-     */
-    description: string;
-    /**
-     * Parameters schema using Zod (optional)
-     */
-    parameters?: ZodUnknownSchema;
-    /**
-     * Tool execution function
-     */
-    execute: (params: TArgs, context?: ToolContext) => Promise<TResult>;
-    /**
-     * Optional metadata
-     */
-    metadata?: {
-        category?: string;
-        version?: string;
-        author?: string;
-        tags?: string[];
-        documentation?: string;
-        [key: string]: JsonValue | undefined;
-    };
-};
 /**
  * Creates a MCPServerInfo from a set of tools
  */
-export declare function createMCPServerFromTools(serverId: string, tools: Record<string, SimpleTool>, metadata?: {
+export declare function createMCPServerFromTools(serverId: string, tools: Record<string, SdkSimpleTool>, metadata?: {
     title?: string;
     description?: string;
     category?: MCPServerCategory;
@@ -64,29 +30,29 @@ export declare function createMCPServerFromTools(serverId: string, tools: Record
 /**
  * Helper to create a tool with type safety
  */
-export declare function createTool(config: SimpleTool): SimpleTool;
+export declare function createTool(config: SdkSimpleTool): SdkSimpleTool;
 /**
  * Helper to create a validated tool with suggested improvements
  */
-export declare function createValidatedTool(name: string, config: SimpleTool, options?: {
+export declare function createValidatedTool(name: string, config: SdkSimpleTool, options?: {
     strict?: boolean;
     suggestions?: boolean;
-}): SimpleTool;
+}): SdkSimpleTool;
 /**
  * Helper to create a tool with typed parameters
  */
-export declare function createTypedTool<TParams extends ZodUnknownSchema>(config: Omit<SimpleTool, "execute"> & {
+export declare function createTypedTool<TParams extends ZodUnknownSchema>(config: Omit<SdkSimpleTool, "execute"> & {
     parameters: TParams;
-    execute: (params: z.infer<TParams>, context?: ToolContext) => Promise<JsonValue> | JsonValue;
-}): SimpleTool;
+    execute: (params: z.infer<TParams>, context?: SDKToolContext) => Promise<JsonValue> | JsonValue;
+}): SdkSimpleTool;
 /**
  * Validate tool configuration with detailed error messages
  */
-export declare function validateTool(name: string, tool: SimpleTool): void;
+export declare function validateTool(name: string, tool: SdkSimpleTool): void;
 /**
  * Utility to validate multiple tools at once
  */
-export declare function validateTools(tools: Record<string, SimpleTool>): {
+export declare function validateTools(tools: Record<string, SdkSimpleTool>): {
     valid: string[];
     invalid: Array<{
         name: string;

package/dist/sdk/toolRegistration.js

@@ -168,7 +168,7 @@ function provideToolSuggestions(name, tool) {
  * Helper to create a tool with typed parameters
  */
 export function createTypedTool(config) {
-    // Wrap the typed execute to match SimpleTool's signature.
+    // Wrap the typed execute to match SdkSimpleTool's signature.
     // The Zod schema validates params at runtime, so the cast within the wrapper is safe.
     const wrappedExecute = async (params, context) => {
         const result = await config.execute(params, context);

package/dist/server/middleware/abortSignal.d.ts

@@ -2,16 +2,7 @@
  * Abort Signal Middleware
  * Provides client disconnection handling for long-running requests
  */
-import type { MiddlewareDefinition, ServerContext } from "../../types/index.js";
-/**
- * Abort signal middleware options
- */
-type AbortSignalMiddlewareOptions = {
-    /** Callback when abort is triggered */
-    onAbort?: (ctx: ServerContext) => void;
-    /** Request timeout in milliseconds */
-    timeout?: number;
-};
+import type { AbortSignalMiddlewareOptions, MiddlewareDefinition } from "../../types/index.js";
 /**
  * Create abort signal middleware for handling client disconnections.
  *
@@ -59,4 +50,3 @@ export declare function createExpressAbortMiddleware(options?: AbortSignalMiddle
     writableFinished?: boolean;
     locals: Record<string, unknown>;
 }, next: () => void) => void;
-export {};

package/dist/server/middleware/auth.d.ts

@@ -2,8 +2,7 @@
  * Authentication Middleware
  * Provides flexible authentication support for server adapters
  */
-import type { MiddlewareDefinition, AuthenticatedUser, ServerServerAuthConfig } from "../../types/index.js";
-import type { AuthResult } from "../../types/index.js";
+import type { ApiKeyAuthOptions, AuthResult, AuthenticatedUser, BearerAuthOptions, MiddlewareDefinition, ServerServerAuthConfig, TokenValidator } from "../../types/index.js";
 /**
  * Check if request is from development playground.
  * Detects playground requests via special headers for development mode.
@@ -111,18 +110,6 @@ export declare class ApiKeyStore {
 /**
  * Options for bearer auth middleware
  */
-type BearerAuthOptions = {
-    /** Whether authentication is required (default: true) */
-    required?: boolean;
-    /** Header name (default: "authorization") */
-    headerName?: string;
-    /** Paths to skip authentication */
-    skipPaths?: string[];
-};
-/**
- * Token validation function type
- */
-type TokenValidator = (token: string) => Promise<AuthenticatedUser | null> | AuthenticatedUser | null;
 /**
  * Create bearer token authentication middleware
  *
@@ -141,12 +128,6 @@ export declare function createBearerAuthMiddleware(validate: TokenValidator, opt
 /**
  * Options for API key auth middleware
  */
-type ApiKeyAuthOptions = {
-    /** Header name (default: "x-api-key") */
-    headerName?: string;
-    /** Paths to skip authentication */
-    skipPaths?: string[];
-};
 /**
  * Create API key authentication middleware
  *
@@ -183,4 +164,3 @@ export declare function createRoleAuthMiddleware(requiredRoles: string[], option
 export declare function createPermissionAuthMiddleware(requiredPermissions: string[], options?: {
     requireAll?: boolean;
 }): MiddlewareDefinition;
-export {};