@andrewcaires/api 5.2.3 → 5.3.1

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 /*!
- * @andrewcaires/api v5.2.3
+ * @andrewcaires/api v5.3.1
  * Simple api for small applications using express, jsonwebtoken, sequelize and websocket
  * (c) 2026 Andrew Caires
  * @license: MIT
  */
-import { Context, Application as Application$1, ExpressOptions, IStore } from '@andrewcaires/express';
+import { Context, Application as Application$1, ExpressOptions, IStore, ResponseError } from '@andrewcaires/express';
 import { Hash, Env as Env$1 } from '@andrewcaires/node';
 import { ModelFindOptions, ModelUpdateOptions, Model as Model$1, Sequelize } from '@andrewcaires/sequelize';
-import { TypeAnyObject, TypeObjectString, TypeAnyFunction, TypeAnyConstructor, EventEmitter, TypeObject, ValidationBase } from '@andrewcaires/utils.js';
+import { TypeAnyObject, TypeObjectString, TypeAnyFunction, TypeAnyConstructor, EventEmitter, TypeObject, ValidationBase, ValidationShape } from '@andrewcaires/utils.js';
 import { WebSocketServer } from 'ws';
 import { Model, CreateOptions, Attributes, FindOptions, IncludeOptions, FindAttributeOptions, ModelStatic } from 'sequelize';
 import { Store, SessionData } from 'express-session';
@@ -103,6 +103,15 @@ declare module "express-serve-static-core" {
     }
 }
 
+declare module "express-serve-static-core" {
+    interface Request {
+        tenants?: Array<{
+            id: string;
+            name: string;
+        }>;
+    }
+}
+
 declare module "express-serve-static-core" {
     interface Request {
         user?: UserModel;
@@ -171,12 +180,25 @@ declare enum AuditTypes {
     UPDATE = "UPDATE"
 }
 
-declare enum Loglevels {
+declare enum GroupTypes {
+    SYSTEM = "system",
+    TENANT = "tenant"
+}
+
+declare enum LogLevels {
     INFO = "info",
     WARN = "warn",
     ERROR = "error"
 }
 
+declare enum TenantStatus {
+    ACTIVE = "active",
+    PENDING = "pending",
+    SUSPENDED = "suspended",
+    DISABLED = "disabled",
+    ARCHIVED = "archived"
+}
+
 declare enum UserStatus {
     ACTIVE = "active",
     PENDING = "pending",
@@ -215,6 +237,7 @@ declare class PermissionModel extends Model$1 {
     name: string;
     description: string;
     active: boolean;
+    metadata: TypeAnyObject;
     readonly created_at: Date;
     readonly updated_at: Date;
     readonly deleted_at: Date | null;
@@ -234,7 +257,9 @@ declare class GroupModel extends Model$1 {
     readonly id: string;
     name: string;
     description: string;
+    type: GroupTypes;
     active: boolean;
+    metadata: TypeAnyObject;
     readonly created_at: Date;
     readonly updated_at: Date;
     readonly deleted_at: Date | null;
@@ -242,6 +267,26 @@ declare class GroupModel extends Model$1 {
     groups_Permission: Array<GroupPermissionModel>;
 }
 
+declare class UserTenantModel extends Model$1 {
+    readonly id: string;
+    readonly created_at: Date;
+    tenant_id: string;
+    tenant: TenantModel;
+    user_id: string;
+    user: UserModel;
+}
+
+declare class TenantModel extends Model$1 {
+    readonly id: string;
+    name: string;
+    status: TenantStatus;
+    metadata: TypeAnyObject;
+    readonly created_at: Date;
+    readonly updated_at: Date;
+    readonly deleted_at: Date | null;
+    users_tenants: Array<UserTenantModel>;
+}
+
 declare class UserGroupModel extends Model$1 {
     readonly id: string;
     readonly created_at: Date;
@@ -249,6 +294,8 @@ declare class UserGroupModel extends Model$1 {
     group: GroupModel;
     user_id: string;
     user: UserModel;
+    tenant_id: string;
+    tenant: TenantModel;
 }
 
 declare class UserPasswordModel extends Model$1 {
@@ -278,6 +325,7 @@ declare class UserModel extends Model$1 {
     registers: Array<RegisterModel>;
     users_groups: Array<UserGroupModel>;
     users_passwords: Array<UserPasswordModel>;
+    users_tenants: Array<UserTenantModel>;
 }
 
 declare class AuditModel extends Model$1 {
@@ -322,7 +370,7 @@ declare class ForgotModel extends Model$1 {
 
 declare class LogModel extends Model$1 {
     readonly id: string;
-    level: Loglevels;
+    level: LogLevels;
     message: string;
     source: string;
     readonly created_at: Date;
@@ -423,10 +471,12 @@ declare class ModelService<M extends Model<any>> extends Service {
 declare class UserService extends Service {
     private hashOptions;
     createPassword(user_id: string, value: string, ctx?: Context): Promise<void>;
-    private findAllPermission;
-    getGroups(user_id: string): Promise<Array<string>>;
-    getGroupsPermissions(user_id: string): Promise<TypeAnyObject>;
-    getPermissions(user_id: string): Promise<Array<string>>;
+    getGroups(user_id: string, tenant_id?: string | null): Promise<Array<string>>;
+    getPermissions(user_id: string, tenant_id?: string | null): Promise<Array<string>>;
+    getTenants(user_id: string): Promise<Array<{
+        id: string;
+        name: string;
+    }>>;
 }
 
 declare class Application<T extends ApplicationEvents = ApplicationEvents> extends Application$1<T> {
@@ -499,14 +549,14 @@ declare abstract class CrudController<M extends Model<any>, T extends TypeAnyObj
     protected del(ctx: Context): Promise<void>;
     protected get(ctx: Context): Promise<void>;
     protected set(ctx: Context): Promise<void>;
-    protected validate(ctx: Context, obj: TypeObject<ValidationBase>): Promise<void>;
-    protected validateCreate(ctx: Context): Promise<void>;
-    protected validateUpdate(ctx: Context): Promise<void>;
+    protected validate(ctx: Context, obj: TypeObject<ValidationBase>): void;
+    protected validateCreate(ctx: Context): void;
+    protected validateUpdate(ctx: Context): void;
 }
 
 declare class FilesController extends BaseController {
     protected readonly directory: string;
-    protected readonly permissions: Array<string>;
+    protected readonly permissions: string[];
     protected files(ctx: Context): Promise<TypeAnyObject | void>;
     private info;
     name(): string;
@@ -541,10 +591,29 @@ declare class HealthController {
 
 declare class LogsController extends ModelController<LogModel> {
     protected readonly model: typeof LogModel;
-    protected readonly permissions: Array<string>;
+    protected readonly permissions: string[];
     protected all(ctx: Context): Promise<void>;
 }
 
+declare class McpController extends BaseController {
+    private readonly tools;
+    private toolsRegistered;
+    private readonly handler;
+    private readonly rateLimiter;
+    sync(app?: Application): Promise<void>;
+    protected options(ctx: Context): Promise<void>;
+    protected post(ctx: Context): Promise<void>;
+    protected delete(ctx: Context): Promise<void>;
+    private getMcpToolMetadata;
+    private discoverMcpTools;
+    private createMcpToolFromMetadata;
+    private request;
+    private isJsonParseError;
+    private isMcpEndpoint;
+    private jsonParseErrorResponse;
+    private respond;
+}
+
 declare class PermissionsController extends CrudController<PermissionModel> {
     protected readonly model: typeof PermissionModel;
     private schemaCreate;
@@ -565,6 +634,301 @@ declare class SetupController extends BaseController {
     protected setup(ctx: Context): Promise<void>;
 }
 
+declare const McpErrorCode: {
+    readonly ParseError: -32700;
+    readonly InvalidRequest: -32600;
+    readonly MethodNotFound: -32601;
+    readonly InvalidParams: -32602;
+    readonly InternalError: -32603;
+    readonly ServerError: -32000;
+    readonly InvalidSession: -32001;
+};
+type McpErrorCode = typeof McpErrorCode[keyof typeof McpErrorCode];
+declare class McpError extends ResponseError {
+    readonly code: McpErrorCode;
+    readonly data?: unknown;
+    constructor(message: string, code?: McpErrorCode, status?: number, data?: unknown);
+}
+declare class McpParseError extends McpError {
+    constructor(message?: string, data?: unknown);
+}
+declare class McpInvalidRequestError extends McpError {
+    constructor(message?: string, data?: unknown);
+}
+declare class McpMethodNotFoundError extends McpError {
+    constructor(method: string);
+}
+declare class McpInvalidParamsError extends McpError {
+    constructor(message?: string, data?: unknown);
+}
+declare class McpInternalError extends McpError {
+    constructor(message?: string, data?: unknown);
+}
+declare class McpServerError extends McpError {
+    constructor(message?: string, data?: unknown);
+}
+declare class McpInvalidSessionError extends McpError {
+    constructor(message?: string, status?: number);
+}
+declare class McpToolNotFoundError extends McpError {
+    constructor(toolName: string);
+}
+
+declare const MCP_SUPPORTED_PROTOCOL_VERSIONS: readonly ["2025-11-25", "2025-06-18"];
+declare const MCP_DEFAULT_PROTOCOL_VERSION: "2025-11-25";
+declare const MCP_PROTOCOL_VERSION_HEADER = "MCP-Protocol-Version";
+declare const MCP_SESSION_ID_HEADER = "MCP-Session-Id";
+type McpProtocolVersion = typeof MCP_SUPPORTED_PROTOCOL_VERSIONS[number];
+type McpJsonRpcId = string | number;
+interface McpJsonRpcRequest {
+    jsonrpc: "2.0";
+    id?: McpJsonRpcId;
+    method: string;
+    params?: unknown;
+}
+interface McpJsonRpcErrorBody {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+interface McpJsonRpcResult {
+    jsonrpc: "2.0";
+    id: McpJsonRpcId;
+    result: unknown;
+}
+interface McpJsonRpcErrorResult {
+    jsonrpc: "2.0";
+    id: McpJsonRpcId | null;
+    error: McpJsonRpcErrorBody;
+}
+interface McpSessionContext {
+    auth?: unknown;
+    groups?: unknown;
+    permissions?: unknown;
+    profile?: unknown;
+    user?: unknown;
+    userId?: string | number;
+}
+interface McpSession extends McpSessionContext {
+    sessionId: string;
+    createdAt: number;
+    expiresAt: number;
+    protocolVersion: McpProtocolVersion;
+    initialized: boolean;
+}
+interface McpToolDefinition {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+}
+interface McpToolDeclaration {
+    name: string;
+    title: string;
+    description: string;
+    input?: ValidationShape;
+    output?: ValidationShape;
+}
+interface McpToolContext extends McpSessionContext {
+    session: McpSession;
+}
+type McpToolInput = Record<string, unknown>;
+type McpToolOutput = unknown;
+interface McpCallToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent?: unknown;
+    isError?: boolean;
+}
+type McpToolHandlerResult = McpCallToolResult | McpToolOutput;
+interface McpRegisteredTool extends McpToolDeclaration {
+    run(_argumentsValue: McpToolInput, _context: McpToolContext): Promise<McpToolHandlerResult> | McpToolHandlerResult;
+}
+interface McpHttpRequest {
+    body: unknown;
+    headers: Record<string, string | undefined>;
+    context?: McpSessionContext;
+    ip?: string;
+}
+interface McpHttpResponse {
+    status: number;
+    headers?: Record<string, string>;
+    body?: unknown;
+}
+interface McpToolCallLog {
+    sessionId: string;
+    userId?: string | number;
+    toolName: string;
+    durationMs: number;
+    success: boolean;
+    error?: string;
+}
+interface McpLogger {
+    toolCall(_log: McpToolCallLog): void | Promise<void>;
+}
+
+declare class McpSessionStore {
+    private readonly sessions;
+    private readonly ttl;
+    private readonly now;
+    constructor(ttl?: number, now?: () => number);
+    create(protocolVersion: McpProtocolVersion, context?: McpSessionContext): McpSession;
+    get(sessionId: string): McpSession | undefined;
+    require(sessionId: string): McpSession;
+    markInitialized(sessionId: string): McpSession;
+    delete(sessionId: string): boolean;
+    cleanup(): void;
+    size(): number;
+    private isExpired;
+}
+
+interface McpNormalizedValidation {
+    schema: TypeAnyObject;
+    validation?: ValidationBase;
+}
+declare class McpToolRegistry {
+    private readonly tools;
+    constructor(tools?: Array<McpRegisteredTool>);
+    register(tool: McpRegisteredTool): void;
+    list(): Array<McpToolDefinition>;
+    call(name: string, argumentsValue: unknown, session: McpSession): Promise<McpCallToolResult>;
+    private isCallToolResult;
+    private normalizeMcpValidation;
+    private outputValidationError;
+    private toolInputValidationError;
+    private validateAdditionalProperties;
+}
+
+interface McpHttpHandlerOptions {
+    sessions: McpSessionStore;
+    tools: McpToolRegistry;
+    allowedOrigins?: Array<string>;
+    logger?: McpLogger;
+    serverName?: string;
+    serverVersion?: string;
+}
+declare const MCP_HTTP_ALLOWED_METHODS: readonly ["POST", "DELETE", "OPTIONS"];
+declare const MCP_HTTP_ALLOW: string;
+declare const isJsonParseError: (error: unknown) => error is Error & {
+    status?: number;
+    statusCode?: number;
+    type?: string;
+};
+declare const jsonParseErrorResponse: (error: unknown) => McpHttpResponse | undefined;
+declare class McpHttpHandler {
+    private readonly sessions;
+    private readonly tools;
+    private readonly allowedOrigins;
+    private readonly logger?;
+    private readonly serverName;
+    private readonly serverVersion;
+    constructor(options: McpHttpHandlerOptions);
+    post(request: McpHttpRequest): Promise<McpHttpResponse>;
+    delete(request: McpHttpRequest): McpHttpResponse;
+    get(request: McpHttpRequest): McpHttpResponse;
+    options(request: McpHttpRequest): McpHttpResponse;
+    private initialize;
+    private initialized;
+    private callTool;
+    private requireRequestId;
+    private withSession;
+    private withInitializedSession;
+    private requireSession;
+    private validateProtocolHeader;
+    private negotiateProtocolVersion;
+    private parseToolCallParams;
+    private validateObjectParams;
+    private validateOrigin;
+    private withTransportHeaders;
+    private transportHeaders;
+    private getAllowedOrigin;
+    private getSessionHeader;
+    private getHeader;
+    private errorResponse;
+}
+
+declare const isJsonRpcId: (value: unknown) => value is McpJsonRpcId;
+declare const jsonRpcResult: (id: McpJsonRpcId, result: unknown) => McpJsonRpcResult;
+declare const jsonRpcError: (id: McpJsonRpcId | null, error: McpError) => McpJsonRpcErrorResult;
+declare const jsonRpcErrorFromCode: (id: McpJsonRpcId | null, code: McpErrorCode, message: string, data?: unknown) => McpJsonRpcErrorResult;
+declare const parseJsonRpcRequest: (body: unknown) => McpJsonRpcRequest;
+
+declare class McpRateLimiter {
+    private readonly entries;
+    private readonly max;
+    private readonly windowMs;
+    private readonly now;
+    constructor(max?: number, windowMs?: number, now?: () => number);
+    consume(key: string): boolean;
+}
+
+declare const MCP_TOOL_METADATA: unique symbol;
+interface McpToolMetadata extends McpToolDeclaration {
+    propertyKey: string | symbol;
+}
+type McpDecoratedToolHandler = (_argumentsValue: Record<string, unknown>, _context: McpToolContext) => ReturnType<McpRegisteredTool["run"]>;
+declare const assertValidMcpToolDefinition: (definition: McpToolDeclaration) => void;
+
+declare class TestController extends BaseController {
+    protected json(ctx: Context): Promise<void>;
+    protected sum(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        value: number;
+    }>;
+    protected multiply(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        value: number;
+    }>;
+    protected average(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        value: number;
+        count: number;
+    }>;
+    protected validationString(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        length: number;
+        normalized: string;
+    }>;
+    protected validationNumber(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        doubled: number;
+    }>;
+    protected validationBoolean(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        active: any;
+    }>;
+    protected validationArray(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        count: number;
+    }>;
+    protected validationObject(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        summary: {
+            name: any;
+            adult: boolean;
+        };
+    }>;
+    protected validationEnum(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        status: any;
+    }>;
+    protected validationDate(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        iso: string;
+        timestamp: number;
+    }>;
+    protected validationOptional(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        nickname?: string | undefined;
+        name: any;
+        hasNickname: boolean;
+    }>;
+    protected validationDefaults(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        name: any;
+        limit: any;
+    }>;
+    protected validationParse(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        active: any;
+        amount: any;
+    }>;
+    protected validationNested(args: TypeAnyObject, _context: McpToolContext): Promise<{
+        userId: any;
+        scoreCount: number;
+    }>;
+}
+
 declare class UsersController extends ModelController<UserModel> {
     protected readonly model: typeof UserModel;
     path: string;
@@ -616,6 +980,9 @@ declare const ReqPermissions: (key?: string) => ParameterDecorator;
 
 declare const ReqUser: (key?: string) => ParameterDecorator;
 
+type McpToolOptions = Omit<McpToolMetadata, "propertyKey">;
+declare const McpTool: (options: McpToolOptions) => MethodDecorator;
+
 declare const Audit: (active?: boolean) => ClassDecorator;
 
 declare class Env extends Env$1 {
@@ -627,11 +994,18 @@ declare class Env extends Env$1 {
     static readonly DATABASE_PREFIX: string;
     static readonly DATABASE_TIMEZONE: string;
     static readonly HTTP_CROSS: string;
+    static readonly HTTP_PORT: number;
+    static readonly HTTP_PUBLIC: string;
     static readonly HTTP_TLS_CA: Buffer<ArrayBufferLike> | null;
     static readonly HTTP_TLS_CRT: Buffer<ArrayBufferLike> | null;
     static readonly HTTP_TLS_KEY: Buffer<ArrayBufferLike> | null;
+    static readonly KEY_HEADER: string;
     static readonly MODEL_LIMIT: number;
     static readonly MODEL_LIMIT_MAX: number;
+    static readonly MCP_ALLOWED_ORIGINS: string;
+    static readonly MCP_RATE_LIMIT_MAX: number;
+    static readonly MCP_RATE_LIMIT_WINDOW: number;
+    static readonly MCP_SESSION_TTL: number;
     static readonly PASSWORD_ALGORITHM: number;
     static readonly PASSWORD_MEMORY_COST: number;
     static readonly PASSWORD_PARALLELISM: number;
@@ -640,33 +1014,31 @@ declare class Env extends Env$1 {
     static readonly SLEEP_AUTH: number;
     static readonly SLEEP_FORGOT: number;
     static readonly SLEEP_REGISTRY: number;
+    static readonly TENANT_HEADER: string;
     static readonly TOKEN_CRT: Buffer<ArrayBufferLike> | null;
+    static readonly TOKEN_HEADER: string;
     static readonly TOKEN_KEY: Buffer<ArrayBufferLike> | null;
     static readonly TOKEN_TTL: number;
+    static readonly TOKEN_TTL_FORGOT: number;
+    static readonly TOKEN_TTL_RENEW: number;
     static readonly TOKEN_TYPE: string;
     static readonly API_BODYPARSER_STRICT: boolean;
     static readonly API_BODYPARSER_INFLATE: boolean;
     static readonly API_BODYPARSER_LIMIT: string;
     static readonly API_BODYPARSER_TYPE: string;
-    static readonly API_HTTP_PORT: number;
-    static readonly API_HTTP_PUBLIC: string;
     static readonly API_HTTP_HYBRID: boolean;
     static readonly API_HTTP_NOTFOUND: string;
     static readonly API_HTTP_PATH: string;
     static readonly API_HTTP_REDIRECT: string;
     static readonly API_KEY_HASH: string;
-    static readonly API_KEY_HEADER: string;
     static readonly API_SESSION_NAME: string;
     static readonly API_SESSION_LIFETIME: number;
     static readonly API_SESSION_SECRET: string;
     static readonly API_TOKEN_COOKIE: string;
     static readonly API_TOKEN_COOKIE_SET: boolean;
-    static readonly API_TOKEN_FORGOT: number;
-    static readonly API_TOKEN_HEADER: string;
-    static readonly API_TOKEN_RENEW: number;
     static readonly API_USER_HISTORY: boolean;
     static readonly API_WEBSOCKET_START: boolean;
 }
 
-export { Application, Audit, AuditModel, AuditTypes, AuditsController, AuthController, AuthService, BaseController, CanCreate, CanDelete, CanRead, CanUpdate, Config, ConfigModel, CrudController, Env, FilesController, ForgotController, ForgotModel, GroupModel, GroupPermissionModel, GroupsController, GroupsPermissionsController, HasGroups, HasPermissions, HealthController, IsAuthenticated, Log, LogModel, Loggable, Loglevels, LogsController, MigrationModel, ModelController, ModelService, PermissionModel, PermissionsController, RegisterController, RegisterModel, ReqAuth, ReqGroup, ReqGroups, ReqPermission, ReqPermissions, ReqUser, Service, SessionModel, SessionStore, SetupController, UserAuthModel, UserGroupModel, UserModel, UserPasswordModel, UserService, UserStatus, UsersController, UsersGroupsController, canFactory, sequelize };
-export type { ApplicationEvents, AuthEvents, ForgotEvents, IAuthParameters, ModelArgumentsBase, ModelArgumentsCount, ModelArgumentsCreate, ModelArgumentsDelete, ModelArgumentsFindAll, ModelArgumentsFindOne, ModelArgumentsInclude, ModelArgumentsUpdate, ModelCallbackFindAll, ModelCallbackFindOne, ModelOptions, ModelResultFindAll, RegisterEvents };
+export { Application, Audit, AuditModel, AuditTypes, AuditsController, AuthController, AuthService, BaseController, CanCreate, CanDelete, CanRead, CanUpdate, Config, ConfigModel, CrudController, Env, FilesController, ForgotController, ForgotModel, GroupModel, GroupPermissionModel, GroupTypes, GroupsController, GroupsPermissionsController, HasGroups, HasPermissions, HealthController, IsAuthenticated, Log, LogLevels, LogModel, Loggable, LogsController, MCP_DEFAULT_PROTOCOL_VERSION, MCP_HTTP_ALLOW, MCP_HTTP_ALLOWED_METHODS, MCP_PROTOCOL_VERSION_HEADER, MCP_SESSION_ID_HEADER, MCP_SUPPORTED_PROTOCOL_VERSIONS, MCP_TOOL_METADATA, McpController, McpError, McpErrorCode, McpHttpHandler, McpInternalError, McpInvalidParamsError, McpInvalidRequestError, McpInvalidSessionError, McpMethodNotFoundError, McpParseError, McpRateLimiter, McpServerError, McpSessionStore, McpTool, McpToolNotFoundError, McpToolRegistry, MigrationModel, ModelController, ModelService, PermissionModel, PermissionsController, RegisterController, RegisterModel, ReqAuth, ReqGroup, ReqGroups, ReqPermission, ReqPermissions, ReqUser, Service, SessionModel, SessionStore, SetupController, TenantModel, TenantStatus, TestController, UserAuthModel, UserGroupModel, UserModel, UserPasswordModel, UserService, UserStatus, UserTenantModel, UsersController, UsersGroupsController, assertValidMcpToolDefinition, canFactory, isJsonParseError, isJsonRpcId, jsonParseErrorResponse, jsonRpcError, jsonRpcErrorFromCode, jsonRpcResult, parseJsonRpcRequest, sequelize };
+export type { ApplicationEvents, AuthEvents, ForgotEvents, IAuthParameters, McpCallToolResult, McpDecoratedToolHandler, McpHttpHandlerOptions, McpHttpRequest, McpHttpResponse, McpJsonRpcErrorBody, McpJsonRpcErrorResult, McpJsonRpcId, McpJsonRpcRequest, McpJsonRpcResult, McpLogger, McpNormalizedValidation, McpProtocolVersion, McpRegisteredTool, McpSession, McpSessionContext, McpToolCallLog, McpToolContext, McpToolDeclaration, McpToolDefinition, McpToolHandlerResult, McpToolInput, McpToolMetadata, McpToolOptions, McpToolOutput, ModelArgumentsBase, ModelArgumentsCount, ModelArgumentsCreate, ModelArgumentsDelete, ModelArgumentsFindAll, ModelArgumentsFindOne, ModelArgumentsInclude, ModelArgumentsUpdate, ModelCallbackFindAll, ModelCallbackFindOne, ModelOptions, ModelResultFindAll, RegisterEvents };