@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/server/index.js

@@ -1,108 +0,0 @@
-/**
- * NeuroLink Server Adapters
- * Expose NeuroLink capabilities through HTTP APIs
- *
- * @example
- * ```typescript
- * import { NeuroLink } from "@juspay/neurolink";
- * import { createServer, createAllRoutes } from "@juspay/neurolink/server";
- *
- * const neurolink = new NeuroLink({
- *   provider: "openai",
- *   apiKey: process.env.OPENAI_API_KEY,
- * });
- *
- * // Create and start server
- * const server = await createServer(neurolink, {
- *   framework: "hono",
- *   config: { port: 3000 },
- * });
- *
- * await server.initialize();
- * await server.start();
- * ```
- */
-// ============================================
-// Abstract Base Class
-// ============================================
-export { BaseServerAdapter } from "./abstract/baseServerAdapter.js";
-export { ExpressServerAdapter } from "./adapters/expressAdapter.js";
-export { FastifyServerAdapter } from "./adapters/fastifyAdapter.js";
-// ============================================
-// Framework Adapters
-// ============================================
-export { HonoServerAdapter } from "./adapters/honoAdapter.js";
-export { KoaServerAdapter } from "./adapters/koaAdapter.js";
-// ============================================
-// Errors
-// ============================================
-export { AlreadyRunningError, 
-// Authentication/Authorization errors
-AuthenticationError, AuthorizationError, 
-// Configuration errors
-ConfigurationError, 
-// Error recovery
-ErrorRecoveryStrategies, 
-// Handler errors
-HandlerError, InvalidAuthenticationError, 
-// Dependency errors
-MissingDependencyError, NotRunningError, 
-// Rate limit errors
-RateLimitError as ServerRateLimitError, RouteConflictError, RouteNotFoundError, 
-// Base error class
-ServerAdapterError, 
-// Server lifecycle errors
-ServerStartError, ServerStopError, StreamAbortedError, 
-// Streaming errors
-StreamingError, 
-// Timeout errors
-TimeoutError, 
-// Validation errors
-ValidationError as ServerValidationError, WebSocketConnectionError, 
-// WebSocket errors
-WebSocketError, 
-// Utilities
-wrapError, } from "./errors.js";
-// ============================================
-// Factory
-// ============================================
-export { createServer, ServerAdapterFactory, } from "./factory/serverAdapterFactory.js";
-export { createAbortSignalMiddleware, createExpressAbortMiddleware, } from "./middleware/abortSignal.js";
-// ============================================
-// Middleware
-// ============================================
-export { createAuthMiddleware, createRoleMiddleware, } from "./middleware/auth.js";
-export { createCacheInvalidator, createCacheMiddleware, InMemoryCacheStore, } from "./middleware/cache.js";
-export { createCompressionMiddleware, createErrorHandlingMiddleware, createLoggingMiddleware, createRequestIdMiddleware, createSecurityHeadersMiddleware, createTimingMiddleware, } from "./middleware/common.js";
-export { createDeprecationMiddleware, } from "./middleware/deprecation.js";
-export { createMCPBodyAttachmentMiddleware, fastifyMCPBodyHook, } from "./middleware/mcpBodyAttachment.js";
-export { createRateLimitMiddleware, createSlidingWindowRateLimitMiddleware, InMemoryRateLimitStore, RateLimitError, } from "./middleware/rateLimit.js";
-export { CommonSchemas, createFieldValidator, createRequestValidationMiddleware, ValidationError, } from "./middleware/validation.js";
-// ============================================
-// OpenAPI
-// ============================================
-export { AgentExecuteRequestSchema as OpenAPIAgentExecuteRequestSchema, AgentExecuteResponseSchema, AgentInputSchema, ApiKeySecurityScheme, BasicSecurityScheme, BearerSecurityScheme, CommonParameters, ConversationMessageSchema, createApiInfo, createDeleteOperation, createErrorResponse as createOpenAPIErrorResponse, createGetOperation, createHeaderParameter, createOpenAPIGenerator, createPathParameter, createPostOperation, createQueryParameter, createServer as createOpenAPIServer, createStreamingPostOperation, createStreamingResponse, 
-// Templates
-createSuccessResponse, DefaultServers, 
-// Schemas
-ErrorResponseSchema, generateOpenAPIFromConfig, generateOpenAPISpec, HealthResponseSchema, MCPServerStatusSchema, MCPServersListResponseSchema, MCPServerToolSchema, MetricsResponseSchema, NeuroLinkApiInfo, 
-// Generator
-OpenAPIGenerator, OpenAPISchemas, ProviderInfoSchema, ReadyResponseSchema, SessionSchema, SessionsListResponseSchema, StandardErrorResponses, StandardTags, TokenUsageSchema, ToolCallSchema, ToolDefinitionSchema, ToolExecuteRequestSchema as OpenAPIToolExecuteRequestSchema, ToolExecuteResponseSchema, ToolListResponseSchema, ToolParameterSchema, } from "./openapi/index.js";
-// ============================================
-// Routes
-// ============================================
-export { createAgentRoutes, createAllRoutes, createHealthRoutes, createMCPRoutes, createMemoryRoutes, createOpenApiRoutes, createToolRoutes, registerAllRoutes, } from "./routes/index.js";
-// ============================================
-// Streaming
-// ============================================
-export { BaseDataStreamWriter, createDataStreamResponse, createDataStreamWriter, createNDJSONHeaders, createSSEHeaders, DataStreamResponse, formatSSEEvent, 
-// Helpers
-pipeAsyncIterableToDataStream, WebStreamWriter, } from "./streaming/index.js";
-// Export error constants
-export { ErrorCategory, ErrorSeverity, ServerAdapterErrorCode, } from "./types.js";
-export { createStreamRedactor, redactStreamChunk } from "./utils/redaction.js";
-export { AgentExecuteRequestSchema, createErrorResponse, ServerNameParamSchema, SessionIdParamSchema, ToolArgumentsSchema, ToolExecuteRequestSchema, ToolNameParamSchema, ToolSearchQuerySchema, validateParams, validateQuery, validateRequest, } from "./utils/validation.js";
-// ============================================
-// WebSocket
-// ============================================
-export { createAgentWebSocketHandler, WebSocketConnectionManager, WebSocketMessageRouter, } from "./websocket/index.js";

package/dist/client/server/middleware/abortSignal.js

@@ -1,111 +0,0 @@
-/**
- * Abort Signal Middleware
- * Provides client disconnection handling for long-running requests
- */
-/**
- * Create abort signal middleware for handling client disconnections.
- *
- * This middleware creates an AbortController and attaches its signal to the context,
- * allowing route handlers to check for client disconnection during long-running operations.
- *
- * @param options - Optional configuration
- * @returns Middleware that attaches abort signal to context
- *
- * @example
- * ```typescript
- * const abortMiddleware = createAbortSignalMiddleware();
- * server.registerMiddleware(abortMiddleware);
- *
- * // In route handler:
- * const signal = ctx.abortSignal;
- * await longRunningOperation({ signal });
- * ```
- */
-export function createAbortSignalMiddleware(options) {
-    const { onAbort, timeout } = options ?? {};
-    return {
-        name: "abort-signal",
-        order: 5, // Early in middleware chain
-        handler: async (ctx, next) => {
-            const controller = new AbortController();
-            let timeoutId;
-            // Set up timeout if configured
-            if (timeout && timeout > 0) {
-                timeoutId = setTimeout(() => {
-                    controller.abort(new Error(`Request timeout after ${timeout}ms`));
-                }, timeout);
-            }
-            // Framework-specific abort handling
-            setupFrameworkAbortHandler(ctx, controller, onAbort);
-            // Attach signal to context
-            ctx.abortSignal = controller.signal;
-            ctx.abortController = controller;
-            try {
-                return await next();
-            }
-            finally {
-                // Clean up timeout
-                if (timeoutId) {
-                    clearTimeout(timeoutId);
-                }
-            }
-        },
-    };
-}
-/**
- * Set up framework-specific abort handling
- */
-function setupFrameworkAbortHandler(ctx, controller, onAbort) {
-    const frameworkResponse = ctx.rawResponse;
-    if (!frameworkResponse) {
-        return;
-    }
-    // Express: res.on('close')
-    if (typeof frameworkResponse.on === "function") {
-        const res = frameworkResponse;
-        res.on("close", () => {
-            if (!res.writableFinished) {
-                controller.abort(new Error("Client disconnected"));
-                onAbort?.(ctx);
-            }
-        });
-    }
-    // Hono/Fastify: May have different event patterns
-    // Add additional framework support as needed
-}
-/**
- * Express-specific middleware factory.
- * Use this directly with Express adapter for optimal handling.
- *
- * This is a lower-level middleware that works directly with Express
- * request/response objects rather than the unified ServerContext.
- *
- * @param options - Optional configuration
- * @returns Express middleware function
- *
- * @example
- * ```typescript
- * // In Express adapter
- * app.use(createExpressAbortMiddleware());
- *
- * // Access in route handler
- * app.get('/api/stream', (req, res) => {
- *   const signal = res.locals.abortSignal;
- *   // Use signal for cancellation
- * });
- * ```
- */
-export function createExpressAbortMiddleware(options) {
-    return (_req, res, next) => {
-        const controller = new AbortController();
-        res.on("close", () => {
-            if (!res.writableFinished) {
-                controller.abort(new Error("Client disconnected"));
-                options?.onAbort?.({});
-            }
-        });
-        res.locals.abortSignal = controller.signal;
-        res.locals.abortController = controller;
-        next();
-    };
-}

package/dist/client/server/middleware/auth.js

@@ -1,388 +0,0 @@
-/**
- * Authentication Middleware
- * Provides flexible authentication support for server adapters
- */
-import { AuthenticationError, AuthorizationError, InvalidAuthenticationError, } from "../errors.js";
-/**
- * Check if request is from development playground.
- * Detects playground requests via special headers for development mode.
- *
- * @param headers - Request headers to check
- * @returns True if request is from dev playground
- *
- * @example
- * ```typescript
- * if (isDevPlayground(ctx.headers)) {
- *   // Skip authentication for playground
- * }
- * ```
- */
-export function isDevPlayground(headers) {
-    const getHeader = (name) => {
-        const value = headers[name.toLowerCase()];
-        return Array.isArray(value) ? value[0] : value;
-    };
-    return (getHeader("x-neurolink-dev-playground") === "true" ||
-        getHeader("x-neurolink-playground") === "true");
-}
-/**
- * Default dev user for playground requests
- */
-export const DEV_PLAYGROUND_USER = {
-    id: "playground",
-    roles: ["developer"],
-};
-/**
- * Create authentication middleware
- *
- * @example
- * ```typescript
- * const authMiddleware = createAuthMiddleware({
- *   type: "bearer",
- *   validate: async (token) => {
- *     const user = await verifyJWT(token);
- *     return user ? { id: user.id, email: user.email } : null;
- *   },
- *   skipPaths: ["/api/health", "/api/ready"],
- * });
- *
- * server.registerMiddleware(authMiddleware);
- * ```
- */
-export function createAuthMiddleware(config) {
-    const { type, validate, skipPaths = [], errorMessage = "Authentication required", skipDevPlayground = true, } = config;
-    // Determine header name based on auth type
-    const headerName = config.headerName ?? getDefaultHeaderName(type);
-    return {
-        name: "authentication",
-        order: 10, // Run early but after request ID
-        excludePaths: skipPaths,
-        handler: async (ctx, next) => {
-            // Skip auth for dev playground in non-production
-            if (skipDevPlayground &&
-                process.env.NODE_ENV !== "production" &&
-                isDevPlayground(ctx.headers)) {
-                ctx.user = {
-                    id: DEV_PLAYGROUND_USER.id,
-                    email: DEV_PLAYGROUND_USER.email,
-                    roles: DEV_PLAYGROUND_USER.roles,
-                };
-                return next();
-            }
-            try {
-                // Extract token based on auth type
-                const token = extractToken(ctx, type, headerName, config.extractToken);
-                if (!token) {
-                    throw new AuthenticationError(errorMessage);
-                }
-                // Validate token
-                const result = await validate(token, ctx);
-                if (!result) {
-                    throw new InvalidAuthenticationError("Invalid authentication token");
-                }
-                // Set user information in context
-                ctx.user = {
-                    id: result.id,
-                    email: result.email,
-                    roles: result.roles,
-                };
-                // Store additional metadata
-                if (result.metadata) {
-                    ctx.metadata.auth = result.metadata;
-                }
-                return next();
-            }
-            catch (error) {
-                if (error instanceof AuthenticationError ||
-                    error instanceof InvalidAuthenticationError) {
-                    throw error;
-                }
-                throw new AuthenticationError(error instanceof Error ? error.message : "Authentication failed");
-            }
-        },
-    };
-}
-/**
- * Get default header name for auth type
- */
-function getDefaultHeaderName(type) {
-    switch (type) {
-        case "bearer":
-        case "basic":
-            return "authorization";
-        case "api-key":
-            return "x-api-key";
-        case "custom":
-            return "authorization";
-        default:
-            return "authorization";
-    }
-}
-/**
- * Extract token from request based on auth type
- */
-function extractToken(ctx, type, headerName, customExtractor) {
-    // Use custom extractor if provided
-    if (type === "custom" && customExtractor) {
-        return customExtractor(ctx);
-    }
-    const headerValue = ctx.headers[headerName.toLowerCase()];
-    if (!headerValue) {
-        return null;
-    }
-    switch (type) {
-        case "bearer": {
-            // Extract token from "Bearer <token>"
-            const match = headerValue.match(/^Bearer\s+(.+)$/i);
-            return match ? match[1] : null;
-        }
-        case "basic": {
-            // Extract credentials from "Basic <base64>"
-            const match = headerValue.match(/^Basic\s+(.+)$/i);
-            return match ? match[1] : null;
-        }
-        case "api-key":
-            // API key is the raw header value
-            return headerValue;
-        case "custom":
-            // For custom type without extractor, return raw header
-            return headerValue;
-        default:
-            return null;
-    }
-}
-/**
- * Role-based access control middleware
- * Use after authentication middleware
- *
- * @example
- * ```typescript
- * const adminOnly = createRoleMiddleware({
- *   requiredRoles: ["admin"],
- *   errorMessage: "Admin access required",
- * });
- * ```
- */
-export function createRoleMiddleware(config) {
-    const { requiredRoles, requireAll = false, errorMessage = "Insufficient permissions", } = config;
-    return {
-        name: "role-check",
-        order: 11, // Run after authentication
-        handler: async (ctx, next) => {
-            if (!ctx.user) {
-                throw new AuthenticationError("Authentication required");
-            }
-            const userRoles = ctx.user.roles || [];
-            const hasAccess = requireAll
-                ? requiredRoles.every((role) => userRoles.includes(role))
-                : requiredRoles.some((role) => userRoles.includes(role));
-            if (!hasAccess) {
-                throw new AuthorizationError(errorMessage, ctx.requestId, requiredRoles);
-            }
-            return next();
-        },
-    };
-}
-// ============================================
-// API Key Store
-// ============================================
-/**
- * In-memory API key store for managing API keys
- *
- * @example
- * ```typescript
- * const store = new ApiKeyStore();
- *
- * // Add an API key
- * store.addKey("my-api-key", { id: "user_1", email: "user@example.com" });
- *
- * // Validate a key
- * const user = store.validate("my-api-key");
- * if (user) {
- *   console.log("Valid key for user:", user.id);
- * }
- *
- * // Remove a key
- * store.removeKey("my-api-key");
- *
- * // Clear all keys
- * store.clear();
- * ```
- */
-export class ApiKeyStore {
-    keys = new Map();
-    /**
-     * Add an API key with associated user
-     */
-    addKey(apiKey, user) {
-        this.keys.set(apiKey, user);
-    }
-    /**
-     * Validate an API key
-     * @returns The user associated with the key, or null if invalid
-     */
-    validate(apiKey) {
-        return this.keys.get(apiKey) ?? null;
-    }
-    /**
-     * Remove an API key
-     */
-    removeKey(apiKey) {
-        return this.keys.delete(apiKey);
-    }
-    /**
-     * Clear all API keys
-     */
-    clear() {
-        this.keys.clear();
-    }
-    /**
-     * Get the number of stored keys
-     */
-    get size() {
-        return this.keys.size;
-    }
-}
-/**
- * Create bearer token authentication middleware
- *
- * @example
- * ```typescript
- * const authMiddleware = createBearerAuthMiddleware(
- *   async (token) => {
- *     const user = await verifyJWT(token);
- *     return user ? { id: user.id, roles: user.roles } : null;
- *   },
- *   { required: true }
- * );
- * ```
- */
-export function createBearerAuthMiddleware(validate, options = {}) {
-    const { required = true, headerName = "authorization", skipPaths = [], } = options;
-    return {
-        name: "bearer-auth",
-        order: 10,
-        excludePaths: skipPaths,
-        handler: async (ctx, next) => {
-            const authHeader = ctx.headers[headerName.toLowerCase()];
-            // Extract bearer token
-            let token = null;
-            if (authHeader) {
-                const match = authHeader.match(/^Bearer\s+(.+)$/i);
-                token = match ? match[1] : null;
-            }
-            // Handle missing token
-            if (!token) {
-                if (required) {
-                    throw new AuthenticationError("Authentication required");
-                }
-                return next();
-            }
-            // Validate token
-            const user = await validate(token);
-            if (!user) {
-                throw new AuthenticationError("Invalid authentication token");
-            }
-            // Set user in context
-            ctx.user = user;
-            return next();
-        },
-    };
-}
-/**
- * Create API key authentication middleware
- *
- * @example
- * ```typescript
- * const store = new ApiKeyStore();
- * store.addKey("my-key", { id: "user_1" });
- *
- * const authMiddleware = createApiKeyAuthMiddleware(store);
- * ```
- */
-export function createApiKeyAuthMiddleware(store, options = {}) {
-    const { headerName = "x-api-key", skipPaths = [] } = options;
-    return {
-        name: "api-key-auth",
-        order: 10,
-        excludePaths: skipPaths,
-        handler: async (ctx, next) => {
-            const apiKey = ctx.headers[headerName.toLowerCase()];
-            if (!apiKey) {
-                throw new AuthenticationError("API key required");
-            }
-            const user = store.validate(apiKey);
-            if (!user) {
-                throw new AuthenticationError("Invalid API key");
-            }
-            ctx.user = user;
-            return next();
-        },
-    };
-}
-// ============================================
-// Role-based Authorization (Simple)
-// ============================================
-/**
- * Create role-based authorization middleware (simple version)
- *
- * @example
- * ```typescript
- * const adminMiddleware = createRoleAuthMiddleware(["admin"]);
- * const editorMiddleware = createRoleAuthMiddleware(["admin", "editor"]);
- * ```
- */
-export function createRoleAuthMiddleware(requiredRoles, options = {}) {
-    const { requireAll = false } = options;
-    return {
-        name: "role-auth",
-        order: 11,
-        handler: async (ctx, next) => {
-            if (!ctx.user) {
-                throw new AuthenticationError("Authentication required");
-            }
-            const userRoles = ctx.user.roles || [];
-            const hasAccess = requireAll
-                ? requiredRoles.every((role) => userRoles.includes(role))
-                : requiredRoles.some((role) => userRoles.includes(role));
-            if (!hasAccess) {
-                throw new AuthorizationError(`Required roles: ${requiredRoles.join(", ")}. User has: ${userRoles.join(", ") || "none"}`, ctx.requestId, requiredRoles);
-            }
-            return next();
-        },
-    };
-}
-// ============================================
-// Permission-based Authorization
-// ============================================
-/**
- * Create permission-based authorization middleware
- *
- * @example
- * ```typescript
- * const canEditMiddleware = createPermissionAuthMiddleware(["posts:edit"]);
- * const canManageMiddleware = createPermissionAuthMiddleware(["users:read", "users:write"]);
- * ```
- */
-export function createPermissionAuthMiddleware(requiredPermissions, options = {}) {
-    const { requireAll = false } = options;
-    return {
-        name: "permission-auth",
-        order: 11,
-        handler: async (ctx, next) => {
-            if (!ctx.user) {
-                throw new AuthenticationError("Authentication required");
-            }
-            // Get permissions from user metadata or roles
-            const userPermissions = ctx.user
-                .permissions || [];
-            const hasAccess = requireAll
-                ? requiredPermissions.every((perm) => userPermissions.includes(perm))
-                : requiredPermissions.some((perm) => userPermissions.includes(perm));
-            if (!hasAccess) {
-                throw new AuthorizationError(`Required permissions: ${requiredPermissions.join(", ")}. User has: ${userPermissions.join(", ") || "none"}`, ctx.requestId, requiredPermissions);
-            }
-            return next();
-        },
-    };
-}