@frontmcp/sdk 0.3.0 → 0.4.0

package/src/common/tokens/tool.tokens.js.map

@@ -1 +1 @@
-{"version":3,"file":"tool.tokens.js","sourceRoot":"","sources":["../../../../src/common/tokens/tool.tokens.ts"],"names":[],"mappings":";;;AAAA,+CAA6C;AAIhC,QAAA,kBAAkB,GAAG;IAChC,IAAI,EAAE,0BAAY,CAAC,IAAI,CAAC,MAAM,CAAC;IAC/B,EAAE,EAAE,0BAAY,CAAC,IAAI,CAAC,IAAI,CAAC;IAC3B,IAAI,EAAE,0BAAY,CAAC,IAAI,CAAC,MAAM,CAAC;IAC/B,WAAW,EAAE,0BAAY,CAAC,IAAI,CAAC,aAAa,CAAC;IAC7C,WAAW,EAAE,0BAAY,CAAC,IAAI,CAAC,aAAa,CAAC;IAC7C,cAAc,EAAE,0BAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC;IACnD,YAAY,EAAE,0BAAY,CAAC,IAAI,CAAC,cAAc,CAAC;IAC/C,IAAI,EAAE,0BAAY,CAAC,IAAI,CAAC,MAAM,CAAC;IAC/B,WAAW,EAAE,0BAAY,CAAC,IAAI,CAAC,aAAa,CAAC;IAC7C,iBAAiB,EAAE,0BAAY,CAAC,IAAI,CAAC,mBAAmB,CAAC;IACzD,QAAQ,EAAE,0BAAY,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,gCAAgC;CACI,CAAC;AAEnE,QAAA,oBAAoB,GAAG,0BAAY,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC","sourcesContent":["import { tokenFactory } from './base.tokens';\nimport { RawMetadataShape } from '../types';\nimport { ToolMetadata } from '../metadata';\n\nexport const FrontMcpToolTokens = {\n  type: tokenFactory.type('tool'),\n  id: tokenFactory.meta('id'),\n  name: tokenFactory.meta('name'),\n  description: tokenFactory.meta('description'),\n  inputSchema: tokenFactory.meta('inputSchema'),\n  rawInputSchema: tokenFactory.meta('rawInputSchema'),\n  outputSchema: tokenFactory.meta('outputSchema'),\n  tags: tokenFactory.meta('tags'),\n  annotations: tokenFactory.meta('annotations'),\n  hideFromDiscovery: tokenFactory.meta('hideFromDiscovery'),\n  metadata: tokenFactory.meta('metadata'), // used in tool({}) construction\n} as const satisfies RawMetadataShape<ToolMetadata, ExtendFrontMcpToolMetadata>;\n\nexport const extendedToolMetadata = tokenFactory.meta('extendedToolMetadata');"]}
+{"version":3,"file":"tool.tokens.js","sourceRoot":"","sources":["../../../../src/common/tokens/tool.tokens.ts"],"names":[],"mappings":";;;AAAA,+CAA6C;AAIhC,QAAA,kBAAkB,GAAG;IAChC,IAAI,EAAE,0BAAY,CAAC,IAAI,CAAC,MAAM,CAAC;IAC/B,EAAE,EAAE,0BAAY,CAAC,IAAI,CAAC,IAAI,CAAC;IAC3B,IAAI,EAAE,0BAAY,CAAC,IAAI,CAAC,MAAM,CAAC;IAC/B,WAAW,EAAE,0BAAY,CAAC,IAAI,CAAC,aAAa,CAAC;IAC7C,WAAW,EAAE,0BAAY,CAAC,IAAI,CAAC,aAAa,CAAC;IAC7C,cAAc,EAAE,0BAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC;IACnD,YAAY,EAAE,0BAAY,CAAC,IAAI,CAAC,cAAc,CAAC;IAC/C,IAAI,EAAE,0BAAY,CAAC,IAAI,CAAC,MAAM,CAAC;IAC/B,WAAW,EAAE,0BAAY,CAAC,IAAI,CAAC,aAAa,CAAC;IAC7C,iBAAiB,EAAE,0BAAY,CAAC,IAAI,CAAC,mBAAmB,CAAC;IACzD,QAAQ,EAAE,0BAAY,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,gCAAgC;CACI,CAAC;AAEnE,QAAA,oBAAoB,GAAG,0BAAY,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC","sourcesContent":["import { tokenFactory } from './base.tokens';\nimport { RawMetadataShape } from '../types';\nimport { ToolMetadata } from '../metadata';\n\nexport const FrontMcpToolTokens = {\n  type: tokenFactory.type('tool'),\n  id: tokenFactory.meta('id'),\n  name: tokenFactory.meta('name'),\n  description: tokenFactory.meta('description'),\n  inputSchema: tokenFactory.meta('inputSchema'),\n  rawInputSchema: tokenFactory.meta('rawInputSchema'),\n  outputSchema: tokenFactory.meta('outputSchema'),\n  tags: tokenFactory.meta('tags'),\n  annotations: tokenFactory.meta('annotations'),\n  hideFromDiscovery: tokenFactory.meta('hideFromDiscovery'),\n  metadata: tokenFactory.meta('metadata'), // used in tool({}) construction\n} as const satisfies RawMetadataShape<ToolMetadata, ExtendFrontMcpToolMetadata>;\n\nexport const extendedToolMetadata = tokenFactory.meta('extendedToolMetadata');\n"]}

package/src/common/types/options/logging.options.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { LogTransportType } from "../../interfaces";
+import { LogTransportType } from '../../interfaces';
 export declare enum LogLevel {
     Debug = 0,
     VERBOSE = 1,
@@ -9,7 +9,6 @@ export declare enum LogLevel {
     Off = 100
 }
 export declare const LogLevelName: Record<LogLevel, string>;
-export declare const LogLevelValue: Record<string, LogLevel>;
 export type LoggingOptions = {
     level?: LogLevel;
     enableConsole?: boolean;

package/src/common/types/options/logging.options.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loggingOptionsSchema = exports.LogLevelValue = exports.LogLevelName = exports.LogLevel = void 0;
+exports.loggingOptionsSchema = exports.LogLevelName = exports.LogLevel = void 0;
 const zod_1 = require("zod");
 const schemas_1 = require("../../schemas");
 var LogLevel;
@@ -20,14 +20,6 @@ exports.LogLevelName = {
     [LogLevel.Error]: 'error',
     [LogLevel.Off]: 'off',
 };
-exports.LogLevelValue = {
-    'debug': LogLevel.Debug,
-    'verbose': LogLevel.VERBOSE,
-    'info': LogLevel.Info,
-    'warn': LogLevel.Warn,
-    'error': LogLevel.Error,
-    'off': LogLevel.Off,
-};
 exports.loggingOptionsSchema = zod_1.z.object({
     level: zod_1.z.nativeEnum(LogLevel).optional().default(LogLevel.Info),
     prefix: zod_1.z.string().optional(),

package/src/common/types/options/logging.options.js.map

@@ -1 +1 @@
-{"version":3,"file":"logging.options.js","sourceRoot":"","sources":["../../../../../src/common/types/options/logging.options.ts"],"names":[],"mappings":";;;AAAA,6BAAsB;AACtB,2CAA4D;AAI5D,IAAY,QAOX;AAPD,WAAY,QAAQ;IAClB,yCAAS,CAAA;IACT,6CAAW,CAAA;IACX,uCAAQ,CAAA;IACR,uCAAQ,CAAA;IACR,yCAAS,CAAA;IACT,uCAAS,CAAA;AACX,CAAC,EAPW,QAAQ,wBAAR,QAAQ,QAOnB;AAEY,QAAA,YAAY,GAA6B;IACpD,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO;IACzB,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS;IAC7B,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM;IACvB,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM;IACvB,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO;IACzB,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,KAAK;CACtB,CAAC;AAEW,QAAA,aAAa,GAA6B;IACrD,OAAO,EAAE,QAAQ,CAAC,KAAK;IACvB,SAAS,EAAE,QAAQ,CAAC,OAAO;IAC3B,MAAM,EAAE,QAAQ,CAAC,IAAI;IACrB,MAAM,EAAE,QAAQ,CAAC,IAAI;IACrB,OAAO,EAAE,QAAQ,CAAC,KAAK;IACvB,KAAK,EAAE,QAAQ,CAAC,GAAG;CACpB,CAAC;AAcW,QAAA,oBAAoB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC3C,KAAK,EAAE,OAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC/D,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC7B,aAAa,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IACnD,UAAU,EAAE,OAAC,CAAC,KAAK,CAAC,uCAA6B,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;CACpC,CAAC,CAAC","sourcesContent":["import {z} from 'zod';\nimport {annotatedFrontMcpLoggerSchema} from '../../schemas';\nimport {LogTransportType} from \"../../interfaces\";\nimport {RawZodShape} from \"../common.types\";\n\nexport enum LogLevel {\n  Debug = 0,\n  VERBOSE = 1,\n  Info = 2,\n  Warn = 3,\n  Error = 4,\n  Off = 100, // never log\n}\n\nexport const LogLevelName: Record<LogLevel, string> = {\n  [LogLevel.Debug]: 'debug',\n  [LogLevel.VERBOSE]: 'verbose',\n  [LogLevel.Info]: 'info',\n  [LogLevel.Warn]: 'warn',\n  [LogLevel.Error]: 'error',\n  [LogLevel.Off]: 'off',\n};\n\nexport const LogLevelValue: Record<string, LogLevel> = {\n  'debug': LogLevel.Debug,\n  'verbose': LogLevel.VERBOSE,\n  'info': LogLevel.Info,\n  'warn': LogLevel.Warn,\n  'error': LogLevel.Error,\n  'off': LogLevel.Off,\n};\n\n\nexport type LoggingOptions = {\n  level?: LogLevel; // default to 'info'\n  enableConsole?: boolean;\n  prefix?: string;\n  /**\n   * Additional custom LogTransport types to register.\n   * @default []\n   */\n  transports?: LogTransportType[]\n};\n\nexport const loggingOptionsSchema = z.object({\n  level: z.nativeEnum(LogLevel).optional().default(LogLevel.Info),\n  prefix: z.string().optional(),\n  enableConsole: z.boolean().optional().default(true),\n  transports: z.array(annotatedFrontMcpLoggerSchema).optional().default([]),\n} satisfies RawZodShape<LoggingOptions>);\n\n\nexport type LoggingConfigType = Omit<z.infer<typeof loggingOptionsSchema>, 'transports'>;"]}
+{"version":3,"file":"logging.options.js","sourceRoot":"","sources":["../../../../../src/common/types/options/logging.options.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,2CAA8D;AAI9D,IAAY,QAOX;AAPD,WAAY,QAAQ;IAClB,yCAAS,CAAA;IACT,6CAAW,CAAA;IACX,uCAAQ,CAAA;IACR,uCAAQ,CAAA;IACR,yCAAS,CAAA;IACT,uCAAS,CAAA;AACX,CAAC,EAPW,QAAQ,wBAAR,QAAQ,QAOnB;AAEY,QAAA,YAAY,GAA6B;IACpD,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO;IACzB,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS;IAC7B,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM;IACvB,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM;IACvB,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO;IACzB,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,KAAK;CACtB,CAAC;AAaW,QAAA,oBAAoB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC3C,KAAK,EAAE,OAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC/D,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC7B,aAAa,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IACnD,UAAU,EAAE,OAAC,CAAC,KAAK,CAAC,uCAA6B,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;CACpC,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport { annotatedFrontMcpLoggerSchema } from '../../schemas';\nimport { LogTransportType } from '../../interfaces';\nimport { RawZodShape } from '../common.types';\n\nexport enum LogLevel {\n  Debug = 0,\n  VERBOSE = 1,\n  Info = 2,\n  Warn = 3,\n  Error = 4,\n  Off = 100, // never log\n}\n\nexport const LogLevelName: Record<LogLevel, string> = {\n  [LogLevel.Debug]: 'debug',\n  [LogLevel.VERBOSE]: 'verbose',\n  [LogLevel.Info]: 'info',\n  [LogLevel.Warn]: 'warn',\n  [LogLevel.Error]: 'error',\n  [LogLevel.Off]: 'off',\n};\n\nexport type LoggingOptions = {\n  level?: LogLevel; // default to 'info'\n  enableConsole?: boolean;\n  prefix?: string;\n  /**\n   * Additional custom LogTransport types to register.\n   * @default []\n   */\n  transports?: LogTransportType[];\n};\n\nexport const loggingOptionsSchema = z.object({\n  level: z.nativeEnum(LogLevel).optional().default(LogLevel.Info),\n  prefix: z.string().optional(),\n  enableConsole: z.boolean().optional().default(true),\n  transports: z.array(annotatedFrontMcpLoggerSchema).optional().default([]),\n} satisfies RawZodShape<LoggingOptions>);\n\nexport type LoggingConfigType = Omit<z.infer<typeof loggingOptionsSchema>, 'transports'>;\n"]}

package/src/common/types/options/server-info.options.d.ts

@@ -16,33 +16,33 @@ export declare const serverInfoOptionsSchema: z.ZodObject<{
         src: z.ZodString;
         mimeType: z.ZodOptional<z.ZodString>;
         sizes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        src: z.ZodString;
-        mimeType: z.ZodOptional<z.ZodString>;
-        sizes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        src: z.ZodString;
-        mimeType: z.ZodOptional<z.ZodString>;
-        sizes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, z.ZodTypeAny, "passthrough">>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        src: string;
+        mimeType?: string | undefined;
+        sizes?: string[] | undefined;
+    }, {
+        src: string;
+        mimeType?: string | undefined;
+        sizes?: string[] | undefined;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     version: string;
     title?: string | undefined;
-    icons?: z.objectOutputType<{
-        src: z.ZodString;
-        mimeType: z.ZodOptional<z.ZodString>;
-        sizes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, z.ZodTypeAny, "passthrough">[] | undefined;
+    icons?: {
+        src: string;
+        mimeType?: string | undefined;
+        sizes?: string[] | undefined;
+    }[] | undefined;
     websiteUrl?: string | undefined;
 }, {
     name: string;
     version: string;
     title?: string | undefined;
-    icons?: z.objectInputType<{
-        src: z.ZodString;
-        mimeType: z.ZodOptional<z.ZodString>;
-        sizes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, z.ZodTypeAny, "passthrough">[] | undefined;
+    icons?: {
+        src: string;
+        mimeType?: string | undefined;
+        sizes?: string[] | undefined;
+    }[] | undefined;
     websiteUrl?: string | undefined;
 }>;

package/src/errors/error-handler.d.ts

@@ -0,0 +1,65 @@
+export interface ErrorHandlerOptions {
+    /**
+     * Whether to include stack traces in error responses
+     */
+    isDevelopment?: boolean;
+    /**
+     * Logger function for error logging
+     */
+    logger?: {
+        error: (message: string, meta?: any) => void;
+        warn: (message: string, meta?: any) => void;
+    };
+    /**
+     * Custom error transformer
+     */
+    errorTransformer?: (error: any) => any;
+}
+/**
+ * Handle errors in MCP flows and format them appropriately
+ */
+export declare class ErrorHandler {
+    private isDevelopment;
+    private logger?;
+    private errorTransformer?;
+    constructor(options?: ErrorHandlerOptions);
+    /**
+     * Handle an error and return a formatted MCP response
+     */
+    handle(error: any, context?: {
+        flowName?: string;
+        toolName?: string;
+    }): {
+        content: Array<{
+            type: "text";
+            text: string;
+        }>;
+        isError: true;
+        _meta?: {
+            errorId: string;
+            code: string;
+            timestamp: string;
+            stack?: string;
+        };
+    };
+    /**
+     * Log error with appropriate level
+     */
+    private logError;
+    /**
+     * Wrap a function with error handling
+     */
+    wrap<T extends (...args: any[]) => any>(fn: T): T;
+    /**
+     * Transform any error to MCP error
+     */
+    private transformToMcpError;
+}
+/**
+ * Create a global error handler instance
+ */
+export declare function createErrorHandler(options?: ErrorHandlerOptions): ErrorHandler;
+/**
+ * Helper to check if an error should stop execution
+ */
+export declare function shouldStopExecution(error: any): boolean;

package/src/errors/error-handler.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandler = void 0;
+exports.createErrorHandler = createErrorHandler;
+exports.shouldStopExecution = shouldStopExecution;
+// errors/error-handler.ts
+const common_1 = require("../common");
+const mcp_error_1 = require("./mcp.error");
+/**
+ * Handle errors in MCP flows and format them appropriately
+ */
+class ErrorHandler {
+    isDevelopment;
+    logger;
+    errorTransformer;
+    constructor(options = {}) {
+        this.isDevelopment = options.isDevelopment ?? process.env['NODE_ENV'] !== 'production';
+        this['logger'] = options.logger;
+        this.errorTransformer = options.errorTransformer;
+    }
+    /**
+     * Handle an error and return a formatted MCP response
+     */
+    handle(error, context) {
+        // Transform error if transformer is provided
+        const transformedError = this.errorTransformer ? this.errorTransformer(error) : error;
+        // Log the error
+        this.logError(transformedError, context);
+        // Format for MCP response
+        return (0, mcp_error_1.formatMcpErrorResponse)(transformedError, this.isDevelopment);
+    }
+    /**
+     * Log error with appropriate level
+     */
+    logError(error, context) {
+        if (!this.logger)
+            return;
+        const meta = {
+            ...context,
+            errorId: error instanceof mcp_error_1.McpError ? error.errorId : undefined,
+            code: error instanceof mcp_error_1.McpError ? error.code : undefined,
+            stack: this.isDevelopment ? error.stack : undefined,
+        };
+        if (error instanceof mcp_error_1.McpError) {
+            if (error.isPublic) {
+                this.logger.warn(`Public error: ${error.getInternalMessage()}`, meta);
+            }
+            else {
+                this.logger.error(`Internal error: ${error.getInternalMessage()}`, meta);
+            }
+        }
+        else {
+            this.logger.error(`Unexpected error: ${error.message || String(error)}`, meta);
+        }
+    }
+    /**
+     * Wrap a function with error handling
+     */
+    wrap(fn) {
+        return ((...args) => {
+            try {
+                const result = fn(...args);
+                if (result instanceof Promise) {
+                    return result.catch((error) => {
+                        throw this.transformToMcpError(error);
+                    });
+                }
+                return result;
+            }
+            catch (error) {
+                throw this.transformToMcpError(error);
+            }
+        });
+    }
+    /**
+     * Transform any error to MCP error
+     */
+    transformToMcpError(error) {
+        if (error instanceof mcp_error_1.McpError) {
+            return error;
+        }
+        if (this.errorTransformer) {
+            const transformed = this.errorTransformer(error);
+            if (transformed instanceof mcp_error_1.McpError) {
+                return transformed;
+            }
+        }
+        return (0, mcp_error_1.toMcpError)(error);
+    }
+}
+exports.ErrorHandler = ErrorHandler;
+/**
+ * Create a global error handler instance
+ */
+function createErrorHandler(options = {}) {
+    return new ErrorHandler(options);
+}
+/**
+ * Helper to check if an error should stop execution
+ */
+function shouldStopExecution(error) {
+    if (error instanceof common_1.FlowControl) {
+        return ['fail', 'abort'].includes(error.type);
+    }
+    return true;
+}
+//# sourceMappingURL=error-handler.js.map

package/src/errors/error-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handler.js","sourceRoot":"","sources":["../../../src/errors/error-handler.ts"],"names":[],"mappings":";;;AAqHA,gDAEC;AAKD,kDAKC;AAjID,0BAA0B;AAC1B,sCAAwC;AACxC,2CAA0E;AAsB1E;;GAEG;AACH,MAAa,YAAY;IACf,aAAa,CAAU;IACvB,MAAM,CAAiC;IACvC,gBAAgB,CAA2C;IAEnE,YAAY,UAA+B,EAAE;QAC3C,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,YAAY,CAAC;QACvF,IAAI,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;QAChC,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IACnD,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAU,EAAE,OAAkD;QACnE,6CAA6C;QAC7C,MAAM,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAEtF,gBAAgB;QAChB,IAAI,CAAC,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;QAEzC,0BAA0B;QAC1B,OAAO,IAAA,kCAAsB,EAAC,gBAAgB,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;IACtE,CAAC;IAED;;OAEG;IACK,QAAQ,CAAC,KAAU,EAAE,OAAkD;QAC7E,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO;QAEzB,MAAM,IAAI,GAAG;YACX,GAAG,OAAO;YACV,OAAO,EAAE,KAAK,YAAY,oBAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;YAC9D,IAAI,EAAE,KAAK,YAAY,oBAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;YACxD,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS;SACpD,CAAC;QAEF,IAAI,KAAK,YAAY,oBAAQ,EAAE,CAAC;YAC9B,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;gBACnB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,iBAAiB,KAAK,CAAC,kBAAkB,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;YACxE,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mBAAmB,KAAK,CAAC,kBAAkB,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;YAC3E,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qBAAqB,KAAK,CAAC,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QACjF,CAAC;IACH,CAAC;IAED;;OAEG;IACH,IAAI,CAAoC,EAAK;QAC3C,OAAO,CAAC,CAAC,GAAG,IAAW,EAAE,EAAE;YACzB,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;gBAC3B,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;oBAC9B,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;wBAC5B,MAAM,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;oBACxC,CAAC,CAAC,CAAC;gBACL,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;YACxC,CAAC;QACH,CAAC,CAAM,CAAC;IACV,CAAC;IAED;;OAEG;IACK,mBAAmB,CAAC,KAAU;QACpC,IAAI,KAAK,YAAY,oBAAQ,EAAE,CAAC;YAC9B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,MAAM,WAAW,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;YACjD,IAAI,WAAW,YAAY,oBAAQ,EAAE,CAAC;gBACpC,OAAO,WAAW,CAAC;YACrB,CAAC;QACH,CAAC;QAED,OAAO,IAAA,sBAAU,EAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;CACF;AArFD,oCAqFC;AAED;;GAEG;AACH,SAAgB,kBAAkB,CAAC,UAA+B,EAAE;IAClE,OAAO,IAAI,YAAY,CAAC,OAAO,CAAC,CAAC;AACnC,CAAC;AAED;;GAEG;AACH,SAAgB,mBAAmB,CAAC,KAAU;IAC5C,IAAI,KAAK,YAAY,oBAAW,EAAE,CAAC;QACjC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAChD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["// errors/error-handler.ts\nimport { FlowControl } from '../common';\nimport { McpError, formatMcpErrorResponse, toMcpError} from './mcp.error';\n\nexport interface ErrorHandlerOptions {\n  /**\n   * Whether to include stack traces in error responses\n   */\n  isDevelopment?: boolean;\n\n  /**\n   * Logger function for error logging\n   */\n  logger?: {\n    error: (message: string, meta?: any) => void;\n    warn: (message: string, meta?: any) => void;\n  };\n\n  /**\n   * Custom error transformer\n   */\n  errorTransformer?: (error: any) => any;\n}\n\n/**\n * Handle errors in MCP flows and format them appropriately\n */\nexport class ErrorHandler {\n  private isDevelopment: boolean;\n  private logger?: ErrorHandlerOptions['logger'];\n  private errorTransformer?: ErrorHandlerOptions['errorTransformer'];\n\n  constructor(options: ErrorHandlerOptions = {}) {\n    this.isDevelopment = options.isDevelopment ?? process.env['NODE_ENV'] !== 'production';\n    this['logger'] = options.logger;\n    this.errorTransformer = options.errorTransformer;\n  }\n\n  /**\n   * Handle an error and return a formatted MCP response\n   */\n  handle(error: any, context?: { flowName?: string; toolName?: string }) {\n    // Transform error if transformer is provided\n    const transformedError = this.errorTransformer ? this.errorTransformer(error) : error;\n\n    // Log the error\n    this.logError(transformedError, context);\n\n    // Format for MCP response\n    return formatMcpErrorResponse(transformedError, this.isDevelopment);\n  }\n\n  /**\n   * Log error with appropriate level\n   */\n  private logError(error: any, context?: { flowName?: string; toolName?: string }) {\n    if (!this.logger) return;\n\n    const meta = {\n      ...context,\n      errorId: error instanceof McpError ? error.errorId : undefined,\n      code: error instanceof McpError ? error.code : undefined,\n      stack: this.isDevelopment ? error.stack : undefined,\n    };\n\n    if (error instanceof McpError) {\n      if (error.isPublic) {\n        this.logger.warn(`Public error: ${error.getInternalMessage()}`, meta);\n      } else {\n        this.logger.error(`Internal error: ${error.getInternalMessage()}`, meta);\n      }\n    } else {\n      this.logger.error(`Unexpected error: ${error.message || String(error)}`, meta);\n    }\n  }\n\n  /**\n   * Wrap a function with error handling\n   */\n  wrap<T extends (...args: any[]) => any>(fn: T): T {\n    return ((...args: any[]) => {\n      try {\n        const result = fn(...args);\n        if (result instanceof Promise) {\n          return result.catch((error) => {\n            throw this.transformToMcpError(error);\n          });\n        }\n        return result;\n      } catch (error) {\n        throw this.transformToMcpError(error);\n      }\n    }) as T;\n  }\n\n  /**\n   * Transform any error to MCP error\n   */\n  private transformToMcpError(error: any): McpError {\n    if (error instanceof McpError) {\n      return error;\n    }\n\n    if (this.errorTransformer) {\n      const transformed = this.errorTransformer(error);\n      if (transformed instanceof McpError) {\n        return transformed;\n      }\n    }\n\n    return toMcpError(error);\n  }\n}\n\n/**\n * Create a global error handler instance\n */\nexport function createErrorHandler(options: ErrorHandlerOptions = {}): ErrorHandler {\n  return new ErrorHandler(options);\n}\n\n/**\n * Helper to check if an error should stop execution\n */\nexport function shouldStopExecution(error: any): boolean {\n  if (error instanceof FlowControl) {\n    return ['fail', 'abort'].includes(error.type);\n  }\n  return true;\n}\n"]}

package/src/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { McpError, PublicMcpError, InternalMcpError, ToolNotFoundError, InvalidInputError, InvalidOutputError, InvalidMethodError, ToolExecutionError, RateLimitError, QuotaExceededError, UnauthorizedError, GenericServerError, isPublicError, toMcpError, formatMcpErrorResponse, } from './mcp.error';
+export { ErrorHandler, ErrorHandlerOptions, createErrorHandler, shouldStopExecution } from './error-handler';

package/src/errors/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldStopExecution = exports.createErrorHandler = exports.ErrorHandler = exports.formatMcpErrorResponse = exports.toMcpError = exports.isPublicError = exports.GenericServerError = exports.UnauthorizedError = exports.QuotaExceededError = exports.RateLimitError = exports.ToolExecutionError = exports.InvalidMethodError = exports.InvalidOutputError = exports.InvalidInputError = exports.ToolNotFoundError = exports.InternalMcpError = exports.PublicMcpError = exports.McpError = void 0;
+// Export all error classes
+var mcp_error_1 = require("./mcp.error");
+Object.defineProperty(exports, "McpError", { enumerable: true, get: function () { return mcp_error_1.McpError; } });
+Object.defineProperty(exports, "PublicMcpError", { enumerable: true, get: function () { return mcp_error_1.PublicMcpError; } });
+Object.defineProperty(exports, "InternalMcpError", { enumerable: true, get: function () { return mcp_error_1.InternalMcpError; } });
+Object.defineProperty(exports, "ToolNotFoundError", { enumerable: true, get: function () { return mcp_error_1.ToolNotFoundError; } });
+Object.defineProperty(exports, "InvalidInputError", { enumerable: true, get: function () { return mcp_error_1.InvalidInputError; } });
+Object.defineProperty(exports, "InvalidOutputError", { enumerable: true, get: function () { return mcp_error_1.InvalidOutputError; } });
+Object.defineProperty(exports, "InvalidMethodError", { enumerable: true, get: function () { return mcp_error_1.InvalidMethodError; } });
+Object.defineProperty(exports, "ToolExecutionError", { enumerable: true, get: function () { return mcp_error_1.ToolExecutionError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return mcp_error_1.RateLimitError; } });
+Object.defineProperty(exports, "QuotaExceededError", { enumerable: true, get: function () { return mcp_error_1.QuotaExceededError; } });
+Object.defineProperty(exports, "UnauthorizedError", { enumerable: true, get: function () { return mcp_error_1.UnauthorizedError; } });
+Object.defineProperty(exports, "GenericServerError", { enumerable: true, get: function () { return mcp_error_1.GenericServerError; } });
+Object.defineProperty(exports, "isPublicError", { enumerable: true, get: function () { return mcp_error_1.isPublicError; } });
+Object.defineProperty(exports, "toMcpError", { enumerable: true, get: function () { return mcp_error_1.toMcpError; } });
+Object.defineProperty(exports, "formatMcpErrorResponse", { enumerable: true, get: function () { return mcp_error_1.formatMcpErrorResponse; } });
+// Export error handler utilities
+var error_handler_1 = require("./error-handler");
+Object.defineProperty(exports, "ErrorHandler", { enumerable: true, get: function () { return error_handler_1.ErrorHandler; } });
+Object.defineProperty(exports, "createErrorHandler", { enumerable: true, get: function () { return error_handler_1.createErrorHandler; } });
+Object.defineProperty(exports, "shouldStopExecution", { enumerable: true, get: function () { return error_handler_1.shouldStopExecution; } });
+//# sourceMappingURL=index.js.map

package/src/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/errors/index.ts"],"names":[],"mappings":";;;AAAA,2BAA2B;AAC3B,yCAgBqB;AAfnB,qGAAA,QAAQ,OAAA;AACR,2GAAA,cAAc,OAAA;AACd,6GAAA,gBAAgB,OAAA;AAChB,8GAAA,iBAAiB,OAAA;AACjB,8GAAA,iBAAiB,OAAA;AACjB,+GAAA,kBAAkB,OAAA;AAClB,+GAAA,kBAAkB,OAAA;AAClB,+GAAA,kBAAkB,OAAA;AAClB,2GAAA,cAAc,OAAA;AACd,+GAAA,kBAAkB,OAAA;AAClB,8GAAA,iBAAiB,OAAA;AACjB,+GAAA,kBAAkB,OAAA;AAClB,0GAAA,aAAa,OAAA;AACb,uGAAA,UAAU,OAAA;AACV,mHAAA,sBAAsB,OAAA;AAGxB,iCAAiC;AACjC,iDAA6G;AAApG,6GAAA,YAAY,OAAA;AAAuB,mHAAA,kBAAkB,OAAA;AAAE,oHAAA,mBAAmB,OAAA","sourcesContent":["// Export all error classes\nexport {\n  McpError,\n  PublicMcpError,\n  InternalMcpError,\n  ToolNotFoundError,\n  InvalidInputError,\n  InvalidOutputError,\n  InvalidMethodError,\n  ToolExecutionError,\n  RateLimitError,\n  QuotaExceededError,\n  UnauthorizedError,\n  GenericServerError,\n  isPublicError,\n  toMcpError,\n  formatMcpErrorResponse,\n} from './mcp.error';\n\n// Export error handler utilities\nexport { ErrorHandler, ErrorHandlerOptions, createErrorHandler, shouldStopExecution } from './error-handler';\n"]}

package/src/errors/mcp.error.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Base class for all MCP-related errors
+ */
+export declare abstract class McpError extends Error {
+    /**
+     * Unique error ID for tracking in logs
+     */
+    errorId: string;
+    /**
+     * Whether this error should expose details to the client
+     */
+    abstract readonly isPublic: boolean;
+    /**
+     * HTTP status code equivalent (for reference)
+     */
+    abstract readonly statusCode: number;
+    /**
+     * Error code for categorization
+     */
+    abstract readonly code: string;
+    protected constructor(message: string, errorId?: string);
+    private generateErrorId;
+    /**
+     * Get the public-facing error message
+     */
+    abstract getPublicMessage(): string;
+    /**
+     * Get the internal error message (for logging)
+     */
+    getInternalMessage(): string;
+    /**
+     * Convert to MCP error response format
+     */
+    toMcpError(isDevelopment?: boolean): {
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+        isError: true;
+        _meta?: {
+            errorId: string;
+            code: string;
+            timestamp: string;
+            stack?: string;
+        };
+    };
+}
+/**
+ * Public errors - safe to expose to clients
+ * These include validation errors, not found errors, etc.
+ */
+export declare class PublicMcpError extends McpError {
+    readonly isPublic = true;
+    readonly statusCode: number;
+    readonly code: string;
+    constructor(message: string, code?: string, statusCode?: number);
+    getPublicMessage(): string;
+}
+/**
+ * Internal errors - should not expose details to clients
+ * These are server errors, unexpected failures, etc.
+ */
+export declare class InternalMcpError extends McpError {
+    readonly isPublic = false;
+    readonly statusCode = 500;
+    readonly code: string;
+    constructor(message: string, code?: string);
+    getPublicMessage(): string;
+}
+/**
+ * Tool didn't find an error
+ */
+export declare class ToolNotFoundError extends PublicMcpError {
+    constructor(toolName: string);
+}
+/**
+ * Invalid input validation error
+ */
+export declare class InvalidInputError extends PublicMcpError {
+    readonly validationErrors?: any;
+    constructor(message?: string, validationErrors?: any);
+    getInternalMessage(): string;
+    getPublicMessage(): string;
+}
+/**
+ * Invalid output validation error (internal - don't expose schema details)
+ */
+export declare class InvalidOutputError extends InternalMcpError {
+    private readonly hasCustomErrorId;
+    constructor(errorId?: string);
+    getPublicMessage(): string;
+}
+/**
+ * Invalid method error
+ */
+export declare class InvalidMethodError extends PublicMcpError {
+    constructor(method: string, expected: string);
+}
+/**
+ * Tool execution error (internal)
+ */
+export declare class ToolExecutionError extends InternalMcpError {
+    readonly originalError?: Error;
+    constructor(toolName: string, originalError?: Error);
+    getInternalMessage(): string;
+}
+/**
+ * Rate limit error
+ */
+export declare class RateLimitError extends PublicMcpError {
+    constructor(retryAfter?: number);
+}
+/**
+ * Quota exceeded error
+ */
+export declare class QuotaExceededError extends PublicMcpError {
+    constructor(quotaType?: string);
+}
+/**
+ * Unauthorized error
+ */
+export declare class UnauthorizedError extends PublicMcpError {
+    constructor(message?: string);
+}
+/**
+ * Generic server error wrapper
+ */
+export declare class GenericServerError extends InternalMcpError {
+    readonly originalError?: Error;
+    constructor(message: string, originalError?: Error);
+    getInternalMessage(): string;
+}
+/**
+ * Check if the error is a public error that can be safely shown to users
+ */
+export declare function isPublicError(error: any): error is PublicMcpError;
+/**
+ * Convert any error to an MCP error
+ */
+export declare function toMcpError(error: any): McpError;
+/**
+ * Format error for MCP response
+ */
+export declare function formatMcpErrorResponse(error: any, isDevelopment?: boolean): {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError: true;
+    _meta?: {
+        errorId: string;
+        code: string;
+        timestamp: string;
+        stack?: string;
+    };
+};