MCP Server Framework - v1.0.0
    Preparing search index...

    Class OperationCancelledError

    Error thrown when an operation is cancelled.

    Used primarily with AbortSignal/AbortController for cancellable operations.

    signal.addEventListener('abort', () => {
      throw new OperationCancelledError('User cancelled the request', requestId);
    });

    // Check if error is cancellation
    if (error instanceof OperationCancelledError) {
      // Handle gracefully
    }

    Hierarchy (View Summary)

    Index

    Constructors

    constructor

    Properties

    cancelReason? cause? code context? errorId mcpCode message name recoveryHint? requestId? stack? statusCode timestamp stackTraceLimit

    Methods

    toDetailedString toJSON captureStackTrace fromAbortSignal fromRequest isAppError isCancellation prepareStackTrace wrap wrapWithContext

    Constructors

    Properties

    cancelReason?: string

    The reason for cancellation

    cause?: Error

    Original error that caused this error

    code: string

    Application-specific error code

    context?: Record<string, unknown>

    Additional context for debugging

    errorId: string

    Unique identifier for this error instance (for tracking/support)

    mcpCode: ErrorCode

    MCP error code for JSON-RPC responses

    message: string
    name: string
    recoveryHint?: string

    Recovery hint for users - guidance on how to resolve the error

    requestId?: string | number

    The ID of the cancelled request

    stack?: string
    statusCode: number

    HTTP status code for REST API responses

    timestamp: Date

    Timestamp when the error occurred

    stackTraceLimit: number

    The Error.stackTraceLimit property specifies the number of stack frames collected by a stack trace (whether generated by new Error().stack or Error.captureStackTrace(obj)).

    The default value is 10 but may be set to any valid JavaScript number. Changes will affect any stack trace captured after the value has been changed.

    If set to a non-number value, or set to a negative number, stack traces will not capture any frames.

    Methods

    • Creates a .stack property on targetObject, which when accessed returns a string representing the location in the code at which Error.captureStackTrace() was called.

      const myObject = {};
      Error.captureStackTrace(myObject);
      myObject.stack;  // Similar to `new Error().stack`

      The first line of the trace will be prefixed with ${myObject.name}: ${myObject.message}.

      The optional constructorOpt argument accepts a function. If given, all frames above constructorOpt, including constructorOpt, will be omitted from the generated stack trace.

      The constructorOpt argument is useful for hiding implementation details of error generation from the user. For instance:

      function a() {
        b();
      }

      function b() {
        c();
      }

      function c() {
        // Create an error without stack trace to avoid calculating the stack trace twice.
        const { stackTraceLimit } = Error;
        Error.stackTraceLimit = 0;
        const error = new Error();
        Error.stackTraceLimit = stackTraceLimit;

        // Capture the stack trace above function b
        Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
        throw error;
      }

      a();

      Parameters

      • targetObject: object
      • OptionalconstructorOpt: Function

      Returns void

    • Check if an error is a cancellation error. Handles both OperationCancelledError and native AbortError.

      Parameters

      • error: unknown

        The error to check

      Returns boolean

      True if error represents a cancellation

    • Wrap any error as a AppError. If already a AppError, returns it unchanged.

      Parameters

      • error: unknown

        The error to wrap

      • defaultMessage: string = "An unexpected error occurred"

        Message to use if error has none

      Returns AppError

      A AppError instance

    • Create a AppError from an unknown error, preserving type if already AppError. Useful for catch blocks where you want to re-throw with additional context.

      Parameters

      • error: unknown

        The error to wrap

      • context: Record<string, unknown>

        Additional context to add

      Returns AppError

      A AppError with merged context

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Methods