@antonytm/mcp-sitecore-server 1.3.2 → 1.3.3

package/dist/bundle.js

@@ -4575,16 +4575,11 @@ const config = {
     authorizationHeader: ENV$1.AUTORIZATION_HEADER || "",
 };
 
-const LATEST_PROTOCOL_VERSION = "2025-06-18";
-const DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
-const SUPPORTED_PROTOCOL_VERSIONS = [
-    LATEST_PROTOCOL_VERSION,
-    "2025-03-26",
-    "2024-11-05",
-    "2024-10-07",
-];
+const LATEST_PROTOCOL_VERSION = '2025-06-18';
+const DEFAULT_NEGOTIATED_PROTOCOL_VERSION = '2025-03-26';
+const SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, '2025-03-26', '2024-11-05', '2024-10-07'];
 /* JSON-RPC types */
-const JSONRPC_VERSION = "2.0";
+const JSONRPC_VERSION = '2.0';
 /**
  * A progress token, used to associate progress notifications with the original request.
  */
@@ -4597,35 +4592,35 @@ const RequestMetaSchema = objectType({
     /**
      * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
      */
-    progressToken: optionalType(ProgressTokenSchema),
+    progressToken: optionalType(ProgressTokenSchema)
 })
     .passthrough();
 const BaseRequestParamsSchema = objectType({
-    _meta: optionalType(RequestMetaSchema),
+    _meta: optionalType(RequestMetaSchema)
 })
     .passthrough();
 const RequestSchema = objectType({
     method: stringType(),
-    params: optionalType(BaseRequestParamsSchema),
+    params: optionalType(BaseRequestParamsSchema)
 });
 const BaseNotificationParamsSchema = objectType({
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: optionalType(objectType({}).passthrough()),
+    _meta: optionalType(objectType({}).passthrough())
 })
     .passthrough();
 const NotificationSchema = objectType({
     method: stringType(),
-    params: optionalType(BaseNotificationParamsSchema),
+    params: optionalType(BaseNotificationParamsSchema)
 });
 const ResultSchema = objectType({
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: optionalType(objectType({}).passthrough()),
+    _meta: optionalType(objectType({}).passthrough())
 })
     .passthrough();
 /**
@@ -4637,7 +4632,7 @@ const RequestIdSchema = unionType([stringType(), numberType().int()]);
  */
 const JSONRPCRequestSchema = objectType({
     jsonrpc: literalType(JSONRPC_VERSION),
-    id: RequestIdSchema,
+    id: RequestIdSchema
 })
     .merge(RequestSchema)
     .strict();
@@ -4646,7 +4641,7 @@ const isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).succes
  * A notification which does not expect a response.
  */
 const JSONRPCNotificationSchema = objectType({
-    jsonrpc: literalType(JSONRPC_VERSION),
+    jsonrpc: literalType(JSONRPC_VERSION)
 })
     .merge(NotificationSchema)
     .strict();
@@ -4657,7 +4652,7 @@ const isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(val
 const JSONRPCResponseSchema = objectType({
     jsonrpc: literalType(JSONRPC_VERSION),
     id: RequestIdSchema,
-    result: ResultSchema,
+    result: ResultSchema
 })
     .strict();
 const isJSONRPCResponse = (value) => JSONRPCResponseSchema.safeParse(value).success;
@@ -4694,17 +4689,12 @@ const JSONRPCErrorSchema = objectType({
         /**
          * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.).
          */
-        data: optionalType(unknownType()),
-    }),
+        data: optionalType(unknownType())
+    })
 })
     .strict();
 const isJSONRPCError = (value) => JSONRPCErrorSchema.safeParse(value).success;
-const JSONRPCMessageSchema = unionType([
-    JSONRPCRequestSchema,
-    JSONRPCNotificationSchema,
-    JSONRPCResponseSchema,
-    JSONRPCErrorSchema,
-]);
+const JSONRPCMessageSchema = unionType([JSONRPCRequestSchema, JSONRPCNotificationSchema, JSONRPCResponseSchema, JSONRPCErrorSchema]);
 /* Empty result */
 /**
  * A response that indicates success but carries no data.
@@ -4721,7 +4711,7 @@ const EmptyResultSchema = ResultSchema.strict();
  * A client MUST NOT attempt to cancel its `initialize` request.
  */
 const CancelledNotificationSchema = NotificationSchema.extend({
-    method: literalType("notifications/cancelled"),
+    method: literalType('notifications/cancelled'),
     params: BaseNotificationParamsSchema.extend({
         /**
          * The ID of the request to cancel.
@@ -4732,8 +4722,8 @@ const CancelledNotificationSchema = NotificationSchema.extend({
         /**
          * An optional string describing the reason for the cancellation. This MAY be logged or presented to the user.
          */
-        reason: stringType().optional(),
-    }),
+        reason: stringType().optional()
+    })
 });
 /* Base Metadata */
 /**
@@ -4749,9 +4739,31 @@ const IconSchema = objectType({
      */
     mimeType: optionalType(stringType()),
     /**
-     * Optional string specifying icon dimensions (e.g., "48x48 96x96").
+     * Optional array of strings that specify sizes at which the icon can be used.
+     * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
+     *
+     * If not provided, the client should assume that the icon can be used at any size.
      */
-    sizes: optionalType(stringType()),
+    sizes: optionalType(arrayType(stringType()))
+})
+    .passthrough();
+/**
+ * Base schema to add `icons` property.
+ *
+ */
+const IconsSchema = objectType({
+    /**
+     * Optional set of sized icons that the client can display in a user interface.
+     *
+     * Clients that support rendering icons MUST support at least the following MIME types:
+     * - `image/png` - PNG images (safe, universal compatibility)
+     * - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility)
+     *
+     * Clients that support rendering icons SHOULD also support:
+     * - `image/svg+xml` - SVG images (scalable but requires security precautions)
+     * - `image/webp` - WebP images (modern, efficient format)
+     */
+    icons: arrayType(IconSchema).optional()
 })
     .passthrough();
 /**
@@ -4761,14 +4773,14 @@ const BaseMetadataSchema = objectType({
     /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */
     name: stringType(),
     /**
-    * Intended for UI and end-user contexts — optimized to be human-readable and easily understood,
-    * even by those unfamiliar with domain-specific terminology.
-    *
-    * If not provided, the name should be used for display (except for Tool,
-    * where `annotations.title` should be given precedence over using `name`,
-    * if present).
-    */
-    title: optionalType(stringType()),
+     * Intended for UI and end-user contexts — optimized to be human-readable and easily understood,
+     * even by those unfamiliar with domain-specific terminology.
+     *
+     * If not provided, the name should be used for display (except for Tool,
+     * where `annotations.title` should be given precedence over using `name`,
+     * if present).
+     */
+    title: optionalType(stringType())
 })
     .passthrough();
 /* Initialization */
@@ -4780,17 +4792,8 @@ const ImplementationSchema = BaseMetadataSchema.extend({
     /**
      * An optional URL of the website for this implementation.
      */
-    websiteUrl: optionalType(stringType()),
-    /**
-     * An optional list of icons for this implementation.
-     * This can be used by clients to display the implementation in a user interface.
-     * Each icon should have a `kind` property that specifies whether it is a data representation or a URL source, a `src` property that points to the icon file or data representation, and may also include a `mimeType` and `sizes` property.
-     * The `mimeType` property should be a valid MIME type for the icon file, such as "image/png" or "image/svg+xml".
-     * The `sizes` property should be a string that specifies one or more sizes at which the icon file can be used, such as "48x48" or "any" for scalable formats like SVG.
-     * The `sizes` property is optional, and if not provided, the client should assume that the icon can be used at any size.
-     */
-    icons: optionalType(arrayType(IconSchema)),
-});
+    websiteUrl: optionalType(stringType())
+}).merge(IconsSchema);
 /**
  * Capabilities a client may support. Known capabilities are defined here, in this schema, but this is not a closed set: any client can define its own, additional capabilities.
  */
@@ -4814,24 +4817,24 @@ const ClientCapabilitiesSchema = objectType({
         /**
          * Whether the client supports issuing notifications for changes to the roots list.
          */
-        listChanged: optionalType(booleanType()),
+        listChanged: optionalType(booleanType())
     })
-        .passthrough()),
+        .passthrough())
 })
     .passthrough();
 /**
  * This request is sent from the client to the server when it first connects, asking it to begin initialization.
  */
 const InitializeRequestSchema = RequestSchema.extend({
-    method: literalType("initialize"),
+    method: literalType('initialize'),
     params: BaseRequestParamsSchema.extend({
         /**
          * The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well.
          */
         protocolVersion: stringType(),
         capabilities: ClientCapabilitiesSchema,
-        clientInfo: ImplementationSchema,
-    }),
+        clientInfo: ImplementationSchema
+    })
 });
 const isInitializeRequest = (value) => InitializeRequestSchema.safeParse(value).success;
 /**
@@ -4857,7 +4860,7 @@ const ServerCapabilitiesSchema = objectType({
         /**
          * Whether this server supports issuing notifications for changes to the prompt list.
          */
-        listChanged: optionalType(booleanType()),
+        listChanged: optionalType(booleanType())
     })
         .passthrough()),
     /**
@@ -4871,7 +4874,7 @@ const ServerCapabilitiesSchema = objectType({
         /**
          * Whether this server supports issuing notifications for changes to the resource list.
          */
-        listChanged: optionalType(booleanType()),
+        listChanged: optionalType(booleanType())
     })
         .passthrough()),
     /**
@@ -4881,9 +4884,9 @@ const ServerCapabilitiesSchema = objectType({
         /**
          * Whether this server supports issuing notifications for changes to the tool list.
          */
-        listChanged: optionalType(booleanType()),
+        listChanged: optionalType(booleanType())
     })
-        .passthrough()),
+        .passthrough())
 })
     .passthrough();
 /**
@@ -4901,20 +4904,20 @@ const InitializeResultSchema = ResultSchema.extend({
      *
      * This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt.
      */
-    instructions: optionalType(stringType()),
+    instructions: optionalType(stringType())
 });
 /**
  * This notification is sent from the client to the server after initialization has finished.
  */
 const InitializedNotificationSchema = NotificationSchema.extend({
-    method: literalType("notifications/initialized"),
+    method: literalType('notifications/initialized')
 });
 /* Ping */
 /**
  * A ping, issued by either the server or the client, to check that the other party is still alive. The receiver must promptly respond, or else may be disconnected.
  */
 const PingRequestSchema = RequestSchema.extend({
-    method: literalType("ping"),
+    method: literalType('ping')
 });
 /* Progress notifications */
 const ProgressSchema = objectType({
@@ -4929,20 +4932,20 @@ const ProgressSchema = objectType({
     /**
      * An optional message describing the current progress.
      */
-    message: optionalType(stringType()),
+    message: optionalType(stringType())
 })
     .passthrough();
 /**
  * An out-of-band notification used to inform the receiver of a progress update for a long-running request.
  */
 const ProgressNotificationSchema = NotificationSchema.extend({
-    method: literalType("notifications/progress"),
+    method: literalType('notifications/progress'),
     params: BaseNotificationParamsSchema.merge(ProgressSchema).extend({
         /**
          * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding.
          */
-        progressToken: ProgressTokenSchema,
-    }),
+        progressToken: ProgressTokenSchema
+    })
 });
 /* Pagination */
 const PaginatedRequestSchema = RequestSchema.extend({
@@ -4951,15 +4954,15 @@ const PaginatedRequestSchema = RequestSchema.extend({
          * An opaque token representing the current pagination position.
          * If provided, the server should return results starting after this cursor.
          */
-        cursor: optionalType(CursorSchema),
-    }).optional(),
+        cursor: optionalType(CursorSchema)
+    }).optional()
 });
 const PaginatedResultSchema = ResultSchema.extend({
     /**
      * An opaque token representing the pagination position after the last returned result.
      * If present, there may be more results available.
      */
-    nextCursor: optionalType(CursorSchema),
+    nextCursor: optionalType(CursorSchema)
 });
 /* Resources */
 /**
@@ -4978,21 +4981,21 @@ const ResourceContentsSchema = objectType({
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: optionalType(objectType({}).passthrough()),
+    _meta: optionalType(objectType({}).passthrough())
 })
     .passthrough();
 const TextResourceContentsSchema = ResourceContentsSchema.extend({
     /**
      * The text of the item. This must only be set if the item can actually be represented as text (not binary data).
      */
-    text: stringType(),
+    text: stringType()
 });
 /**
  * A Zod schema for validating Base64 strings that is more performant and
  * robust for very large inputs than the default regex-based check. It avoids
  * stack overflows by using the native `atob` function for validation.
  */
-const Base64Schema = stringType().refine((val) => {
+const Base64Schema = stringType().refine(val => {
     try {
         // atob throws a DOMException if the string contains characters
         // that are not part of the Base64 character set.
@@ -5002,12 +5005,12 @@ const Base64Schema = stringType().refine((val) => {
     catch (_a) {
         return false;
     }
-}, { message: "Invalid Base64 string" });
+}, { message: 'Invalid Base64 string' });
 const BlobResourceContentsSchema = ResourceContentsSchema.extend({
     /**
      * A base64-encoded string representing the binary data of the item.
      */
-    blob: Base64Schema,
+    blob: Base64Schema
 });
 /**
  * A known resource that the server is capable of reading.
@@ -5027,16 +5030,12 @@ const ResourceSchema = BaseMetadataSchema.extend({
      * The MIME type of this resource, if known.
      */
     mimeType: optionalType(stringType()),
-    /**
-     * An optional list of icons for this resource.
-     */
-    icons: optionalType(arrayType(IconSchema)),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: optionalType(objectType({}).passthrough()),
-});
+    _meta: optionalType(objectType({}).passthrough())
+}).merge(IconsSchema);
 /**
  * A template description for resources available on the server.
  */
@@ -5059,91 +5058,91 @@ const ResourceTemplateSchema = BaseMetadataSchema.extend({
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: optionalType(objectType({}).passthrough()),
-});
+    _meta: optionalType(objectType({}).passthrough())
+}).merge(IconsSchema);
 /**
  * Sent from the client to request a list of resources the server has.
  */
 const ListResourcesRequestSchema = PaginatedRequestSchema.extend({
-    method: literalType("resources/list"),
+    method: literalType('resources/list')
 });
 /**
  * The server's response to a resources/list request from the client.
  */
 const ListResourcesResultSchema = PaginatedResultSchema.extend({
-    resources: arrayType(ResourceSchema),
+    resources: arrayType(ResourceSchema)
 });
 /**
  * Sent from the client to request a list of resource templates the server has.
  */
 const ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({
-    method: literalType("resources/templates/list"),
+    method: literalType('resources/templates/list')
 });
 /**
  * The server's response to a resources/templates/list request from the client.
  */
 const ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({
-    resourceTemplates: arrayType(ResourceTemplateSchema),
+    resourceTemplates: arrayType(ResourceTemplateSchema)
 });
 /**
  * Sent from the client to the server, to read a specific resource URI.
  */
 const ReadResourceRequestSchema = RequestSchema.extend({
-    method: literalType("resources/read"),
+    method: literalType('resources/read'),
     params: BaseRequestParamsSchema.extend({
         /**
          * The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it.
          */
-        uri: stringType(),
-    }),
+        uri: stringType()
+    })
 });
 /**
  * The server's response to a resources/read request from the client.
  */
 const ReadResourceResultSchema = ResultSchema.extend({
-    contents: arrayType(unionType([TextResourceContentsSchema, BlobResourceContentsSchema])),
+    contents: arrayType(unionType([TextResourceContentsSchema, BlobResourceContentsSchema]))
 });
 /**
  * An optional notification from the server to the client, informing it that the list of resources it can read from has changed. This may be issued by servers without any previous subscription from the client.
  */
 const ResourceListChangedNotificationSchema = NotificationSchema.extend({
-    method: literalType("notifications/resources/list_changed"),
+    method: literalType('notifications/resources/list_changed')
 });
 /**
  * Sent from the client to request resources/updated notifications from the server whenever a particular resource changes.
  */
 const SubscribeRequestSchema = RequestSchema.extend({
-    method: literalType("resources/subscribe"),
+    method: literalType('resources/subscribe'),
     params: BaseRequestParamsSchema.extend({
         /**
          * The URI of the resource to subscribe to. The URI can use any protocol; it is up to the server how to interpret it.
          */
-        uri: stringType(),
-    }),
+        uri: stringType()
+    })
 });
 /**
  * Sent from the client to request cancellation of resources/updated notifications from the server. This should follow a previous resources/subscribe request.
  */
 const UnsubscribeRequestSchema = RequestSchema.extend({
-    method: literalType("resources/unsubscribe"),
+    method: literalType('resources/unsubscribe'),
     params: BaseRequestParamsSchema.extend({
         /**
          * The URI of the resource to unsubscribe from.
          */
-        uri: stringType(),
-    }),
+        uri: stringType()
+    })
 });
 /**
  * A notification from the server to the client, informing it that a resource has changed and may need to be read again. This should only be sent if the client previously sent a resources/subscribe request.
  */
 const ResourceUpdatedNotificationSchema = NotificationSchema.extend({
-    method: literalType("notifications/resources/updated"),
+    method: literalType('notifications/resources/updated'),
     params: BaseNotificationParamsSchema.extend({
         /**
          * The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to.
          */
-        uri: stringType(),
-    }),
+        uri: stringType()
+    })
 });
 /* Prompts */
 /**
@@ -5161,7 +5160,7 @@ const PromptArgumentSchema = objectType({
     /**
      * Whether this argument must be provided.
      */
-    required: optionalType(booleanType()),
+    required: optionalType(booleanType())
 })
     .passthrough();
 /**
@@ -5176,33 +5175,29 @@ const PromptSchema = BaseMetadataSchema.extend({
      * A list of arguments to use for templating the prompt.
      */
     arguments: optionalType(arrayType(PromptArgumentSchema)),
-    /**
-     * An optional list of icons for this prompt.
-     */
-    icons: optionalType(arrayType(IconSchema)),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: optionalType(objectType({}).passthrough()),
-});
+    _meta: optionalType(objectType({}).passthrough())
+}).merge(IconsSchema);
 /**
  * Sent from the client to request a list of prompts and prompt templates the server has.
  */
 const ListPromptsRequestSchema = PaginatedRequestSchema.extend({
-    method: literalType("prompts/list"),
+    method: literalType('prompts/list')
 });
 /**
  * The server's response to a prompts/list request from the client.
  */
 const ListPromptsResultSchema = PaginatedResultSchema.extend({
-    prompts: arrayType(PromptSchema),
+    prompts: arrayType(PromptSchema)
 });
 /**
  * Used by the client to get a prompt provided by the server.
  */
 const GetPromptRequestSchema = RequestSchema.extend({
-    method: literalType("prompts/get"),
+    method: literalType('prompts/get'),
     params: BaseRequestParamsSchema.extend({
         /**
          * The name of the prompt or prompt template.
@@ -5211,14 +5206,14 @@ const GetPromptRequestSchema = RequestSchema.extend({
         /**
          * Arguments to use for templating the prompt.
          */
-        arguments: optionalType(recordType(stringType())),
-    }),
+        arguments: optionalType(recordType(stringType()))
+    })
 });
 /**
  * Text provided to or from an LLM.
  */
 const TextContentSchema = objectType({
-    type: literalType("text"),
+    type: literalType('text'),
     /**
      * The text content of the message.
      */
@@ -5227,14 +5222,14 @@ const TextContentSchema = objectType({
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: optionalType(objectType({}).passthrough()),
+    _meta: optionalType(objectType({}).passthrough())
 })
     .passthrough();
 /**
  * An image provided to or from an LLM.
  */
 const ImageContentSchema = objectType({
-    type: literalType("image"),
+    type: literalType('image'),
     /**
      * The base64-encoded image data.
      */
@@ -5247,14 +5242,14 @@ const ImageContentSchema = objectType({
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: optionalType(objectType({}).passthrough()),
+    _meta: optionalType(objectType({}).passthrough())
 })
     .passthrough();
 /**
  * An Audio provided to or from an LLM.
  */
 const AudioContentSchema = objectType({
-    type: literalType("audio"),
+    type: literalType('audio'),
     /**
      * The base64-encoded audio data.
      */
@@ -5267,20 +5262,20 @@ const AudioContentSchema = objectType({
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: optionalType(objectType({}).passthrough()),
+    _meta: optionalType(objectType({}).passthrough())
 })
     .passthrough();
 /**
  * The contents of a resource, embedded into a prompt or tool call result.
  */
 const EmbeddedResourceSchema = objectType({
-    type: literalType("resource"),
+    type: literalType('resource'),
     resource: unionType([TextResourceContentsSchema, BlobResourceContentsSchema]),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: optionalType(objectType({}).passthrough()),
+    _meta: optionalType(objectType({}).passthrough())
 })
     .passthrough();
 /**
@@ -5289,7 +5284,7 @@ const EmbeddedResourceSchema = objectType({
  * Note: resource links returned by tools are not guaranteed to appear in the results of `resources/list` requests.
  */
 const ResourceLinkSchema = ResourceSchema.extend({
-    type: literalType("resource_link"),
+    type: literalType('resource_link')
 });
 /**
  * A content block that can be used in prompts and tool results.
@@ -5299,14 +5294,14 @@ const ContentBlockSchema = unionType([
     ImageContentSchema,
     AudioContentSchema,
     ResourceLinkSchema,
-    EmbeddedResourceSchema,
+    EmbeddedResourceSchema
 ]);
 /**
  * Describes a message returned as part of a prompt.
  */
 const PromptMessageSchema = objectType({
-    role: enumType(["user", "assistant"]),
-    content: ContentBlockSchema,
+    role: enumType(['user', 'assistant']),
+    content: ContentBlockSchema
 })
     .passthrough();
 /**
@@ -5317,13 +5312,13 @@ const GetPromptResultSchema = ResultSchema.extend({
      * An optional description for the prompt.
      */
     description: optionalType(stringType()),
-    messages: arrayType(PromptMessageSchema),
+    messages: arrayType(PromptMessageSchema)
 });
 /**
  * An optional notification from the server to the client, informing it that the list of prompts it offers has changed. This may be issued by servers without any previous subscription from the client.
  */
 const PromptListChangedNotificationSchema = NotificationSchema.extend({
-    method: literalType("notifications/prompts/list_changed"),
+    method: literalType('notifications/prompts/list_changed')
 });
 /* Tools */
 /**
@@ -5373,7 +5368,7 @@ const ToolAnnotationsSchema = objectType({
      *
      * Default: true
      */
-    openWorldHint: optionalType(booleanType()),
+    openWorldHint: optionalType(booleanType())
 })
     .passthrough();
 /**
@@ -5388,9 +5383,9 @@ const ToolSchema = BaseMetadataSchema.extend({
      * A JSON Schema object defining the expected parameters for the tool.
      */
     inputSchema: objectType({
-        type: literalType("object"),
+        type: literalType('object'),
         properties: optionalType(objectType({}).passthrough()),
-        required: optionalType(arrayType(stringType())),
+        required: optionalType(arrayType(stringType()))
     })
         .passthrough(),
     /**
@@ -5398,36 +5393,32 @@ const ToolSchema = BaseMetadataSchema.extend({
      * the structuredContent field of a CallToolResult.
      */
     outputSchema: optionalType(objectType({
-        type: literalType("object"),
+        type: literalType('object'),
         properties: optionalType(objectType({}).passthrough()),
-        required: optionalType(arrayType(stringType())),
+        required: optionalType(arrayType(stringType()))
     })
         .passthrough()),
     /**
      * Optional additional tool information.
      */
     annotations: optionalType(ToolAnnotationsSchema),
-    /**
-     * An optional list of icons for this tool.
-     */
-    icons: optionalType(arrayType(IconSchema)),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: optionalType(objectType({}).passthrough()),
-});
+    _meta: optionalType(objectType({}).passthrough())
+}).merge(IconsSchema);
 /**
  * Sent from the client to request a list of tools the server has.
  */
 const ListToolsRequestSchema = PaginatedRequestSchema.extend({
-    method: literalType("tools/list"),
+    method: literalType('tools/list')
 });
 /**
  * The server's response to a tools/list request from the client.
  */
 const ListToolsResultSchema = PaginatedResultSchema.extend({
-    tools: arrayType(ToolSchema),
+    tools: arrayType(ToolSchema)
 });
 /**
  * The server's response to a tool call.
@@ -5460,61 +5451,52 @@ const CallToolResultSchema = ResultSchema.extend({
      * server does not support tool calls, or any other exceptional conditions,
      * should be reported as an MCP error response.
      */
-    isError: optionalType(booleanType()),
+    isError: optionalType(booleanType())
 });
 /**
  * CallToolResultSchema extended with backwards compatibility to protocol version 2024-10-07.
  */
 CallToolResultSchema.or(ResultSchema.extend({
-    toolResult: unknownType(),
+    toolResult: unknownType()
 }));
 /**
  * Used by the client to invoke a tool provided by the server.
  */
 const CallToolRequestSchema = RequestSchema.extend({
-    method: literalType("tools/call"),
+    method: literalType('tools/call'),
     params: BaseRequestParamsSchema.extend({
         name: stringType(),
-        arguments: optionalType(recordType(unknownType())),
-    }),
+        arguments: optionalType(recordType(unknownType()))
+    })
 });
 /**
  * An optional notification from the server to the client, informing it that the list of tools it offers has changed. This may be issued by servers without any previous subscription from the client.
  */
 const ToolListChangedNotificationSchema = NotificationSchema.extend({
-    method: literalType("notifications/tools/list_changed"),
+    method: literalType('notifications/tools/list_changed')
 });
 /* Logging */
 /**
  * The severity of a log message.
  */
-const LoggingLevelSchema = enumType([
-    "debug",
-    "info",
-    "notice",
-    "warning",
-    "error",
-    "critical",
-    "alert",
-    "emergency",
-]);
+const LoggingLevelSchema = enumType(['debug', 'info', 'notice', 'warning', 'error', 'critical', 'alert', 'emergency']);
 /**
  * A request from the client to the server, to enable or adjust logging.
  */
 const SetLevelRequestSchema = RequestSchema.extend({
-    method: literalType("logging/setLevel"),
+    method: literalType('logging/setLevel'),
     params: BaseRequestParamsSchema.extend({
         /**
          * The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/logging/message.
          */
-        level: LoggingLevelSchema,
-    }),
+        level: LoggingLevelSchema
+    })
 });
 /**
  * Notification of a log message passed from server to client. If no logging/setLevel request has been sent from the client, the server MAY decide which messages to send automatically.
  */
 const LoggingMessageNotificationSchema = NotificationSchema.extend({
-    method: literalType("notifications/message"),
+    method: literalType('notifications/message'),
     params: BaseNotificationParamsSchema.extend({
         /**
          * The severity of this log message.
@@ -5527,8 +5509,8 @@ const LoggingMessageNotificationSchema = NotificationSchema.extend({
         /**
          * The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here.
          */
-        data: unknownType(),
-    }),
+        data: unknownType()
+    })
 });
 /* Sampling */
 /**
@@ -5538,7 +5520,7 @@ const ModelHintSchema = objectType({
     /**
      * A hint for a model name.
      */
-    name: stringType().optional(),
+    name: stringType().optional()
 })
     .passthrough();
 /**
@@ -5560,22 +5542,22 @@ const ModelPreferencesSchema = objectType({
     /**
      * How much to prioritize intelligence and capabilities when selecting a model.
      */
-    intelligencePriority: optionalType(numberType().min(0).max(1)),
+    intelligencePriority: optionalType(numberType().min(0).max(1))
 })
     .passthrough();
 /**
  * Describes a message issued to or received from an LLM API.
  */
 const SamplingMessageSchema = objectType({
-    role: enumType(["user", "assistant"]),
-    content: unionType([TextContentSchema, ImageContentSchema, AudioContentSchema]),
+    role: enumType(['user', 'assistant']),
+    content: unionType([TextContentSchema, ImageContentSchema, AudioContentSchema])
 })
     .passthrough();
 /**
  * A request from the server to sample an LLM via the client. The client has full discretion over which model to select. The client should also inform the user before beginning sampling, to allow them to inspect the request (human in the loop) and decide whether to approve it.
  */
 const CreateMessageRequestSchema = RequestSchema.extend({
-    method: literalType("sampling/createMessage"),
+    method: literalType('sampling/createMessage'),
     params: BaseRequestParamsSchema.extend({
         messages: arrayType(SamplingMessageSchema),
         /**
@@ -5585,7 +5567,7 @@ const CreateMessageRequestSchema = RequestSchema.extend({
         /**
          * A request to include context from one or more MCP servers (including the caller), to be attached to the prompt. The client MAY ignore this request.
          */
-        includeContext: optionalType(enumType(["none", "thisServer", "allServers"])),
+        includeContext: optionalType(enumType(['none', 'thisServer', 'allServers'])),
         temperature: optionalType(numberType()),
         /**
          * The maximum number of tokens to sample, as requested by the server. The client MAY choose to sample fewer tokens than requested.
@@ -5599,8 +5581,8 @@ const CreateMessageRequestSchema = RequestSchema.extend({
         /**
          * The server's preferences for which model to select.
          */
-        modelPreferences: optionalType(ModelPreferencesSchema),
-    }),
+        modelPreferences: optionalType(ModelPreferencesSchema)
+    })
 });
 /**
  * The client's response to a sampling/create_message request from the server. The client should inform the user before returning the sampled message, to allow them to inspect the response (human in the loop) and decide whether to allow the server to see it.
@@ -5613,74 +5595,65 @@ const CreateMessageResultSchema = ResultSchema.extend({
     /**
      * The reason why sampling stopped.
      */
-    stopReason: optionalType(enumType(["endTurn", "stopSequence", "maxTokens"]).or(stringType())),
-    role: enumType(["user", "assistant"]),
-    content: discriminatedUnionType("type", [
-        TextContentSchema,
-        ImageContentSchema,
-        AudioContentSchema
-    ]),
+    stopReason: optionalType(enumType(['endTurn', 'stopSequence', 'maxTokens']).or(stringType())),
+    role: enumType(['user', 'assistant']),
+    content: discriminatedUnionType('type', [TextContentSchema, ImageContentSchema, AudioContentSchema])
 });
 /* Elicitation */
 /**
  * Primitive schema definition for boolean fields.
  */
 const BooleanSchemaSchema = objectType({
-    type: literalType("boolean"),
+    type: literalType('boolean'),
     title: optionalType(stringType()),
     description: optionalType(stringType()),
-    default: optionalType(booleanType()),
+    default: optionalType(booleanType())
 })
     .passthrough();
 /**
  * Primitive schema definition for string fields.
  */
 const StringSchemaSchema = objectType({
-    type: literalType("string"),
+    type: literalType('string'),
     title: optionalType(stringType()),
     description: optionalType(stringType()),
     minLength: optionalType(numberType()),
     maxLength: optionalType(numberType()),
-    format: optionalType(enumType(["email", "uri", "date", "date-time"])),
+    format: optionalType(enumType(['email', 'uri', 'date', 'date-time']))
 })
     .passthrough();
 /**
  * Primitive schema definition for number fields.
  */
 const NumberSchemaSchema = objectType({
-    type: enumType(["number", "integer"]),
+    type: enumType(['number', 'integer']),
     title: optionalType(stringType()),
     description: optionalType(stringType()),
     minimum: optionalType(numberType()),
-    maximum: optionalType(numberType()),
+    maximum: optionalType(numberType())
 })
     .passthrough();
 /**
  * Primitive schema definition for enum fields.
  */
 const EnumSchemaSchema = objectType({
-    type: literalType("string"),
+    type: literalType('string'),
     title: optionalType(stringType()),
     description: optionalType(stringType()),
     enum: arrayType(stringType()),
-    enumNames: optionalType(arrayType(stringType())),
+    enumNames: optionalType(arrayType(stringType()))
 })
     .passthrough();
 /**
  * Union of all primitive schema definitions.
  */
-const PrimitiveSchemaDefinitionSchema = unionType([
-    BooleanSchemaSchema,
-    StringSchemaSchema,
-    NumberSchemaSchema,
-    EnumSchemaSchema,
-]);
+const PrimitiveSchemaDefinitionSchema = unionType([BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema, EnumSchemaSchema]);
 /**
  * A request from the server to elicit user input via the client.
  * The client should present the message and form fields to the user.
  */
 const ElicitRequestSchema = RequestSchema.extend({
-    method: literalType("elicitation/create"),
+    method: literalType('elicitation/create'),
     params: BaseRequestParamsSchema.extend({
         /**
          * The message to present to the user.
@@ -5690,12 +5663,12 @@ const ElicitRequestSchema = RequestSchema.extend({
          * The schema for the requested user input.
          */
         requestedSchema: objectType({
-            type: literalType("object"),
+            type: literalType('object'),
             properties: recordType(stringType(), PrimitiveSchemaDefinitionSchema),
-            required: optionalType(arrayType(stringType())),
+            required: optionalType(arrayType(stringType()))
         })
-            .passthrough(),
-    }),
+            .passthrough()
+    })
 });
 /**
  * The client's response to an elicitation/create request from the server.
@@ -5704,40 +5677,40 @@ const ElicitResultSchema = ResultSchema.extend({
     /**
      * The user's response action.
      */
-    action: enumType(["accept", "decline", "cancel"]),
+    action: enumType(['accept', 'decline', 'cancel']),
     /**
      * The collected user input content (only present if action is "accept").
      */
-    content: optionalType(recordType(stringType(), unknownType())),
+    content: optionalType(recordType(stringType(), unknownType()))
 });
 /* Autocomplete */
 /**
  * A reference to a resource or resource template definition.
  */
 const ResourceTemplateReferenceSchema = objectType({
-    type: literalType("ref/resource"),
+    type: literalType('ref/resource'),
     /**
      * The URI or URI template of the resource.
      */
-    uri: stringType(),
+    uri: stringType()
 })
     .passthrough();
 /**
  * Identifies a prompt.
  */
 const PromptReferenceSchema = objectType({
-    type: literalType("ref/prompt"),
+    type: literalType('ref/prompt'),
     /**
      * The name of the prompt or prompt template
      */
-    name: stringType(),
+    name: stringType()
 })
     .passthrough();
 /**
  * A request from the client to the server, to ask for completion options.
  */
 const CompleteRequestSchema = RequestSchema.extend({
-    method: literalType("completion/complete"),
+    method: literalType('completion/complete'),
     params: BaseRequestParamsSchema.extend({
         ref: unionType([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
         /**
@@ -5751,16 +5724,16 @@ const CompleteRequestSchema = RequestSchema.extend({
             /**
              * The value of the argument to use for completion matching.
              */
-            value: stringType(),
+            value: stringType()
         })
             .passthrough(),
         context: optionalType(objectType({
             /**
              * Previously-resolved variables in a URI template or prompt.
              */
-            arguments: optionalType(recordType(stringType(), stringType())),
-        })),
-    }),
+            arguments: optionalType(recordType(stringType(), stringType()))
+        }))
+    })
 });
 /**
  * The server's response to a completion/complete request
@@ -5778,9 +5751,9 @@ const CompleteResultSchema = ResultSchema.extend({
         /**
          * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
          */
-        hasMore: optionalType(booleanType()),
+        hasMore: optionalType(booleanType())
     })
-        .passthrough(),
+        .passthrough()
 });
 /* Roots */
 /**
@@ -5790,7 +5763,7 @@ const RootSchema = objectType({
     /**
      * The URI identifying the root. This *must* start with file:// for now.
      */
-    uri: stringType().startsWith("file://"),
+    uri: stringType().startsWith('file://'),
     /**
      * An optional name for the root.
      */
@@ -5799,26 +5772,26 @@ const RootSchema = objectType({
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: optionalType(objectType({}).passthrough()),
+    _meta: optionalType(objectType({}).passthrough())
 })
     .passthrough();
 /**
  * Sent from the server to request a list of root URIs from the client.
  */
 const ListRootsRequestSchema = RequestSchema.extend({
-    method: literalType("roots/list"),
+    method: literalType('roots/list')
 });
 /**
  * The client's response to a roots/list request from the server.
  */
 const ListRootsResultSchema = ResultSchema.extend({
-    roots: arrayType(RootSchema),
+    roots: arrayType(RootSchema)
 });
 /**
  * A notification from the client to the server, informing it that the list of roots has changed.
  */
 const RootsListChangedNotificationSchema = NotificationSchema.extend({
-    method: literalType("notifications/roots/list_changed"),
+    method: literalType('notifications/roots/list_changed')
 });
 /* Client messages */
 unionType([
@@ -5834,27 +5807,17 @@ unionType([
     SubscribeRequestSchema,
     UnsubscribeRequestSchema,
     CallToolRequestSchema,
-    ListToolsRequestSchema,
+    ListToolsRequestSchema
 ]);
 unionType([
     CancelledNotificationSchema,
     ProgressNotificationSchema,
     InitializedNotificationSchema,
-    RootsListChangedNotificationSchema,
-]);
-unionType([
-    EmptyResultSchema,
-    CreateMessageResultSchema,
-    ElicitResultSchema,
-    ListRootsResultSchema,
+    RootsListChangedNotificationSchema
 ]);
+unionType([EmptyResultSchema, CreateMessageResultSchema, ElicitResultSchema, ListRootsResultSchema]);
 /* Server messages */
-unionType([
-    PingRequestSchema,
-    CreateMessageRequestSchema,
-    ElicitRequestSchema,
-    ListRootsRequestSchema,
-]);
+unionType([PingRequestSchema, CreateMessageRequestSchema, ElicitRequestSchema, ListRootsRequestSchema]);
 unionType([
     CancelledNotificationSchema,
     ProgressNotificationSchema,
@@ -5862,7 +5825,7 @@ unionType([
     ResourceUpdatedNotificationSchema,
     ResourceListChangedNotificationSchema,
     ToolListChangedNotificationSchema,
-    PromptListChangedNotificationSchema,
+    PromptListChangedNotificationSchema
 ]);
 unionType([
     EmptyResultSchema,
@@ -5874,14 +5837,14 @@ unionType([
     ListResourceTemplatesResultSchema,
     ReadResourceResultSchema,
     CallToolResultSchema,
-    ListToolsResultSchema,
+    ListToolsResultSchema
 ]);
 class McpError extends Error {
     constructor(code, message, data) {
         super(`MCP error ${code}: ${message}`);
         this.code = code;
         this.data = data;
-        this.name = "McpError";
+        this.name = 'McpError';
     }
 }
 
@@ -5896,11 +5859,11 @@ class ReadBuffer {
         if (!this._buffer) {
             return null;
         }
-        const index = this._buffer.indexOf("\n");
+        const index = this._buffer.indexOf('\n');
         if (index === -1) {
             return null;
         }
-        const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, '');
+        const line = this._buffer.toString('utf8', 0, index).replace(/\r$/, '');
         this._buffer = this._buffer.subarray(index + 1);
         return deserializeMessage(line);
     }
@@ -5912,7 +5875,7 @@ function deserializeMessage(line) {
     return JSONRPCMessageSchema.parse(JSON.parse(line));
 }
 function serializeMessage(message) {
-    return JSON.stringify(message) + "\n";
+    return JSON.stringify(message) + '\n';
 }
 
 /**
@@ -5941,11 +5904,11 @@ class StdioServerTransport {
      */
     async start() {
         if (this._started) {
-            throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
+            throw new Error('StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.');
         }
         this._started = true;
-        this._stdin.on("data", this._ondata);
-        this._stdin.on("error", this._onerror);
+        this._stdin.on('data', this._ondata);
+        this._stdin.on('error', this._onerror);
     }
     processReadBuffer() {
         var _a, _b;
@@ -5965,8 +5928,8 @@ class StdioServerTransport {
     async close() {
         var _a;
         // Remove our event listeners first
-        this._stdin.off("data", this._ondata);
-        this._stdin.off("error", this._onerror);
+        this._stdin.off('data', this._ondata);
+        this._stdin.off('error', this._onerror);
         // Check if we were the only data listener
         const remainingDataListeners = this._stdin.listenerCount('data');
         if (remainingDataListeners === 0) {
@@ -5979,13 +5942,13 @@ class StdioServerTransport {
         (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
     }
     send(message) {
-        return new Promise((resolve) => {
+        return new Promise(resolve => {
             const json = serializeMessage(message);
             if (this._stdout.write(json)) {
                 resolve();
             }
             else {
-                this._stdout.once("drain", resolve);
+                this._stdout.once('drain', resolve);
             }
         });
     }
@@ -6010,16 +5973,16 @@ class Protocol {
         this._progressHandlers = new Map();
         this._timeoutInfo = new Map();
         this._pendingDebouncedNotifications = new Set();
-        this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
+        this.setNotificationHandler(CancelledNotificationSchema, notification => {
             const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
             controller === null || controller === void 0 ? void 0 : controller.abort(notification.params.reason);
         });
-        this.setNotificationHandler(ProgressNotificationSchema, (notification) => {
+        this.setNotificationHandler(ProgressNotificationSchema, notification => {
             this._onprogress(notification);
         });
         this.setRequestHandler(PingRequestSchema, 
         // Automatic pong by default.
-        (_request) => ({}));
+        _request => ({}));
     }
     _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
         this._timeoutInfo.set(messageId, {
@@ -6038,7 +6001,10 @@ class Protocol {
         const totalElapsed = Date.now() - info.startTime;
         if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) {
             this._timeoutInfo.delete(messageId);
-            throw new McpError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", { maxTotalTimeout: info.maxTotalTimeout, totalElapsed });
+            throw new McpError(ErrorCode.RequestTimeout, 'Maximum total timeout exceeded', {
+                maxTotalTimeout: info.maxTotalTimeout,
+                totalElapsed
+            });
         }
         clearTimeout(info.timeoutId);
         info.timeoutId = setTimeout(info.onTimeout, info.timeout);
@@ -6095,7 +6061,7 @@ class Protocol {
         this._pendingDebouncedNotifications.clear();
         this._transport = undefined;
         (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
-        const error = new McpError(ErrorCode.ConnectionClosed, "Connection closed");
+        const error = new McpError(ErrorCode.ConnectionClosed, 'Connection closed');
         for (const handler of responseHandlers.values()) {
             handler(error);
         }
@@ -6114,7 +6080,7 @@ class Protocol {
         // Starting with Promise.resolve() puts any synchronous errors into the monad as well.
         Promise.resolve()
             .then(() => handler(notification))
-            .catch((error) => this._onerror(new Error(`Uncaught error in notification handler: ${error}`)));
+            .catch(error => this._onerror(new Error(`Uncaught error in notification handler: ${error}`)));
     }
     _onrequest(request, extra) {
         var _a, _b;
@@ -6123,13 +6089,13 @@ class Protocol {
         const capturedTransport = this._transport;
         if (handler === undefined) {
             capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
-                jsonrpc: "2.0",
+                jsonrpc: '2.0',
                 id: request.id,
                 error: {
                     code: ErrorCode.MethodNotFound,
-                    message: "Method not found",
-                },
-            }).catch((error) => this._onerror(new Error(`Failed to send an error response: ${error}`)));
+                    message: 'Method not found'
+                }
+            }).catch(error => this._onerror(new Error(`Failed to send an error response: ${error}`)));
             return;
         }
         const abortController = new AbortController();
@@ -6138,7 +6104,7 @@ class Protocol {
             signal: abortController.signal,
             sessionId: capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId,
             _meta: (_b = request.params) === null || _b === void 0 ? void 0 : _b._meta,
-            sendNotification: (notification) => this.notification(notification, { relatedRequestId: request.id }),
+            sendNotification: notification => this.notification(notification, { relatedRequestId: request.id }),
             sendRequest: (r, resultSchema, options) => this.request(r, resultSchema, { ...options, relatedRequestId: request.id }),
             authInfo: extra === null || extra === void 0 ? void 0 : extra.authInfo,
             requestId: request.id,
@@ -6147,32 +6113,30 @@ class Protocol {
         // Starting with Promise.resolve() puts any synchronous errors into the monad as well.
         Promise.resolve()
             .then(() => handler(request, fullExtra))
-            .then((result) => {
+            .then(result => {
             if (abortController.signal.aborted) {
                 return;
             }
             return capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
                 result,
-                jsonrpc: "2.0",
-                id: request.id,
+                jsonrpc: '2.0',
+                id: request.id
             });
-        }, (error) => {
+        }, error => {
             var _a;
             if (abortController.signal.aborted) {
                 return;
             }
             return capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
-                jsonrpc: "2.0",
+                jsonrpc: '2.0',
                 id: request.id,
                 error: {
-                    code: Number.isSafeInteger(error["code"])
-                        ? error["code"]
-                        : ErrorCode.InternalError,
-                    message: (_a = error.message) !== null && _a !== void 0 ? _a : "Internal error",
-                },
+                    code: Number.isSafeInteger(error['code']) ? error['code'] : ErrorCode.InternalError,
+                    message: (_a = error.message) !== null && _a !== void 0 ? _a : 'Internal error'
+                }
             });
         })
-            .catch((error) => this._onerror(new Error(`Failed to send response: ${error}`)))
+            .catch(error => this._onerror(new Error(`Failed to send response: ${error}`)))
             .finally(() => {
             this._requestHandlerAbortControllers.delete(request.id);
         });
@@ -6236,7 +6200,7 @@ class Protocol {
         return new Promise((resolve, reject) => {
             var _a, _b, _c, _d, _e, _f;
             if (!this._transport) {
-                reject(new Error("Not connected"));
+                reject(new Error('Not connected'));
                 return;
             }
             if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.enforceStrictCapabilities) === true) {
@@ -6246,8 +6210,8 @@ class Protocol {
             const messageId = this._requestMessageId++;
             const jsonrpcRequest = {
                 ...request,
-                jsonrpc: "2.0",
-                id: messageId,
+                jsonrpc: '2.0',
+                id: messageId
             };
             if (options === null || options === void 0 ? void 0 : options.onprogress) {
                 this._progressHandlers.set(messageId, options.onprogress);
@@ -6256,7 +6220,7 @@ class Protocol {
                     _meta: {
                         ...(((_c = request.params) === null || _c === void 0 ? void 0 : _c._meta) || {}),
                         progressToken: messageId
-                    },
+                    }
                 };
             }
             const cancel = (reason) => {
@@ -6265,16 +6229,16 @@ class Protocol {
                 this._progressHandlers.delete(messageId);
                 this._cleanupTimeout(messageId);
                 (_a = this._transport) === null || _a === void 0 ? void 0 : _a.send({
-                    jsonrpc: "2.0",
-                    method: "notifications/cancelled",
+                    jsonrpc: '2.0',
+                    method: 'notifications/cancelled',
                     params: {
                         requestId: messageId,
-                        reason: String(reason),
-                    },
-                }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error) => this._onerror(new Error(`Failed to send cancellation: ${error}`)));
+                        reason: String(reason)
+                    }
+                }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch(error => this._onerror(new Error(`Failed to send cancellation: ${error}`)));
                 reject(reason);
             };
-            this._responseHandlers.set(messageId, (response) => {
+            this._responseHandlers.set(messageId, response => {
                 var _a;
                 if ((_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
                     return;
@@ -6290,14 +6254,14 @@ class Protocol {
                     reject(error);
                 }
             });
-            (_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.addEventListener("abort", () => {
+            (_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.addEventListener('abort', () => {
                 var _a;
                 cancel((_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.reason);
             });
             const timeout = (_e = options === null || options === void 0 ? void 0 : options.timeout) !== null && _e !== void 0 ? _e : DEFAULT_REQUEST_TIMEOUT_MSEC;
-            const timeoutHandler = () => cancel(new McpError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
+            const timeoutHandler = () => cancel(new McpError(ErrorCode.RequestTimeout, 'Request timed out', { timeout }));
             this._setupTimeout(messageId, timeout, options === null || options === void 0 ? void 0 : options.maxTotalTimeout, timeoutHandler, (_f = options === null || options === void 0 ? void 0 : options.resetTimeoutOnProgress) !== null && _f !== void 0 ? _f : false);
-            this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error) => {
+            this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch(error => {
                 this._cleanupTimeout(messageId);
                 reject(error);
             });
@@ -6309,15 +6273,13 @@ class Protocol {
     async notification(notification, options) {
         var _a, _b;
         if (!this._transport) {
-            throw new Error("Not connected");
+            throw new Error('Not connected');
         }
         this.assertNotificationCapability(notification.method);
         const debouncedMethods = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.debouncedNotificationMethods) !== null && _b !== void 0 ? _b : [];
         // A notification can only be debounced if it's in the list AND it's "simple"
         // (i.e., has no parameters and no related request ID that could be lost).
-        const canDebounce = debouncedMethods.includes(notification.method)
-            && !notification.params
-            && !(options === null || options === void 0 ? void 0 : options.relatedRequestId);
+        const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !(options === null || options === void 0 ? void 0 : options.relatedRequestId);
         if (canDebounce) {
             // If a notification of this type is already scheduled, do nothing.
             if (this._pendingDebouncedNotifications.has(notification.method)) {
@@ -6337,7 +6299,7 @@ class Protocol {
                 }
                 const jsonrpcNotification = {
                     ...notification,
-                    jsonrpc: "2.0",
+                    jsonrpc: '2.0'
                 };
                 // Send the notification, but don't await it here to avoid blocking.
                 // Handle potential errors with a .catch().
@@ -6348,7 +6310,7 @@ class Protocol {
         }
         const jsonrpcNotification = {
             ...notification,
-            jsonrpc: "2.0",
+            jsonrpc: '2.0'
         };
         await this._transport.send(jsonrpcNotification, options);
     }
@@ -6384,7 +6346,7 @@ class Protocol {
      * Note that this will replace any previous notification handler for the same method.
      */
     setNotificationHandler(notificationSchema, handler) {
-        this._notificationHandlers.set(notificationSchema.shape.method.value, (notification) => Promise.resolve(handler(notificationSchema.parse(notification))));
+        this._notificationHandlers.set(notificationSchema.shape.method.value, notification => Promise.resolve(handler(notificationSchema.parse(notification))));
     }
     /**
      * Removes the notification handler for the given method.
@@ -6395,7 +6357,7 @@ class Protocol {
 }
 function mergeCapabilities(base, additional) {
     return Object.entries(additional).reduce((acc, [key, value]) => {
-        if (value && typeof value === "object") {
+        if (value && typeof value === 'object') {
             acc[key] = acc[key] ? { ...acc[key], ...value } : value;
         }
         else {
@@ -13948,13 +13910,11 @@ class Server extends Protocol {
         // Is a message with the given level ignored in the log level set for the given session id?
         this.isMessageIgnored = (level, sessionId) => {
             const currentLevel = this._loggingLevels.get(sessionId);
-            return (currentLevel)
-                ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel)
-                : false;
+            return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
         };
         this._capabilities = (_a = options === null || options === void 0 ? void 0 : options.capabilities) !== null && _a !== void 0 ? _a : {};
         this._instructions = options === null || options === void 0 ? void 0 : options.instructions;
-        this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
+        this.setRequestHandler(InitializeRequestSchema, request => this._oninitialize(request));
         this.setNotificationHandler(InitializedNotificationSchema, () => { var _a; return (_a = this.oninitialized) === null || _a === void 0 ? void 0 : _a.call(this); });
         if (this._capabilities.logging) {
             this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
@@ -13976,24 +13936,24 @@ class Server extends Protocol {
      */
     registerCapabilities(capabilities) {
         if (this.transport) {
-            throw new Error("Cannot register capabilities after connecting to transport");
+            throw new Error('Cannot register capabilities after connecting to transport');
         }
         this._capabilities = mergeCapabilities(this._capabilities, capabilities);
     }
     assertCapabilityForMethod(method) {
         var _a, _b, _c;
         switch (method) {
-            case "sampling/createMessage":
+            case 'sampling/createMessage':
                 if (!((_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.sampling)) {
                     throw new Error(`Client does not support sampling (required for ${method})`);
                 }
                 break;
-            case "elicitation/create":
+            case 'elicitation/create':
                 if (!((_b = this._clientCapabilities) === null || _b === void 0 ? void 0 : _b.elicitation)) {
                     throw new Error(`Client does not support elicitation (required for ${method})`);
                 }
                 break;
-            case "roots/list":
+            case 'roots/list':
                 if (!((_c = this._clientCapabilities) === null || _c === void 0 ? void 0 : _c.roots)) {
                     throw new Error(`Client does not support listing roots (required for ${method})`);
                 }
@@ -14002,23 +13962,23 @@ class Server extends Protocol {
     }
     assertNotificationCapability(method) {
         switch (method) {
-            case "notifications/message":
+            case 'notifications/message':
                 if (!this._capabilities.logging) {
                     throw new Error(`Server does not support logging (required for ${method})`);
                 }
                 break;
-            case "notifications/resources/updated":
-            case "notifications/resources/list_changed":
+            case 'notifications/resources/updated':
+            case 'notifications/resources/list_changed':
                 if (!this._capabilities.resources) {
                     throw new Error(`Server does not support notifying about resources (required for ${method})`);
                 }
                 break;
-            case "notifications/tools/list_changed":
+            case 'notifications/tools/list_changed':
                 if (!this._capabilities.tools) {
                     throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);
                 }
                 break;
-            case "notifications/prompts/list_changed":
+            case 'notifications/prompts/list_changed':
                 if (!this._capabilities.prompts) {
                     throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
                 }
@@ -14027,31 +13987,31 @@ class Server extends Protocol {
     }
     assertRequestHandlerCapability(method) {
         switch (method) {
-            case "sampling/createMessage":
+            case 'sampling/createMessage':
                 if (!this._capabilities.sampling) {
                     throw new Error(`Server does not support sampling (required for ${method})`);
                 }
                 break;
-            case "logging/setLevel":
+            case 'logging/setLevel':
                 if (!this._capabilities.logging) {
                     throw new Error(`Server does not support logging (required for ${method})`);
                 }
                 break;
-            case "prompts/get":
-            case "prompts/list":
+            case 'prompts/get':
+            case 'prompts/list':
                 if (!this._capabilities.prompts) {
                     throw new Error(`Server does not support prompts (required for ${method})`);
                 }
                 break;
-            case "resources/list":
-            case "resources/templates/list":
-            case "resources/read":
+            case 'resources/list':
+            case 'resources/templates/list':
+            case 'resources/read':
                 if (!this._capabilities.resources) {
                     throw new Error(`Server does not support resources (required for ${method})`);
                 }
                 break;
-            case "tools/call":
-            case "tools/list":
+            case 'tools/call':
+            case 'tools/list':
                 if (!this._capabilities.tools) {
                     throw new Error(`Server does not support tools (required for ${method})`);
                 }
@@ -14062,14 +14022,12 @@ class Server extends Protocol {
         const requestedVersion = request.params.protocolVersion;
         this._clientCapabilities = request.params.capabilities;
         this._clientVersion = request.params.clientInfo;
-        const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion)
-            ? requestedVersion
-            : LATEST_PROTOCOL_VERSION;
+        const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
         return {
             protocolVersion,
             capabilities: this.getCapabilities(),
             serverInfo: this._serverInfo,
-            ...(this._instructions && { instructions: this._instructions }),
+            ...(this._instructions && { instructions: this._instructions })
         };
     }
     /**
@@ -14088,15 +14046,15 @@ class Server extends Protocol {
         return this._capabilities;
     }
     async ping() {
-        return this.request({ method: "ping" }, EmptyResultSchema);
+        return this.request({ method: 'ping' }, EmptyResultSchema);
     }
     async createMessage(params, options) {
-        return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options);
+        return this.request({ method: 'sampling/createMessage', params }, CreateMessageResultSchema, options);
     }
     async elicitInput(params, options) {
-        const result = await this.request({ method: "elicitation/create", params }, ElicitResultSchema, options);
+        const result = await this.request({ method: 'elicitation/create', params }, ElicitResultSchema, options);
         // Validate the response content against the requested schema if action is "accept"
-        if (result.action === "accept" && result.content) {
+        if (result.action === 'accept' && result.content) {
             try {
                 const ajv = new Ajv();
                 const validate = ajv.compile(params.requestedSchema);
@@ -14115,7 +14073,7 @@ class Server extends Protocol {
         return result;
     }
     async listRoots(params, options) {
-        return this.request({ method: "roots/list", params }, ListRootsResultSchema, options);
+        return this.request({ method: 'roots/list', params }, ListRootsResultSchema, options);
     }
     /**
      * Sends a logging message to the client, if connected.
@@ -14127,26 +14085,26 @@ class Server extends Protocol {
     async sendLoggingMessage(params, sessionId) {
         if (this._capabilities.logging) {
             if (!this.isMessageIgnored(params.level, sessionId)) {
-                return this.notification({ method: "notifications/message", params });
+                return this.notification({ method: 'notifications/message', params });
             }
         }
     }
     async sendResourceUpdated(params) {
         return this.notification({
-            method: "notifications/resources/updated",
-            params,
+            method: 'notifications/resources/updated',
+            params
         });
     }
     async sendResourceListChanged() {
         return this.notification({
-            method: "notifications/resources/list_changed",
+            method: 'notifications/resources/list_changed'
         });
     }
     async sendToolListChanged() {
-        return this.notification({ method: "notifications/tools/list_changed" });
+        return this.notification({ method: 'notifications/tools/list_changed' });
     }
     async sendPromptListChanged() {
-        return this.notification({ method: "notifications/prompts/list_changed" });
+        return this.notification({ method: 'notifications/prompts/list_changed' });
     }
 }
 
@@ -15516,7 +15474,7 @@ class Completable extends ZodType {
         return this._def.type._parse({
             data,
             path: ctx.path,
-            parent: ctx,
+            parent: ctx
         });
     }
     unwrap() {
@@ -15528,7 +15486,7 @@ Completable.create = (type, params) => {
         type,
         typeName: McpZodTypeKind.Completable,
         complete: params.complete,
-        ...processCreateParams(params),
+        ...processCreateParams(params)
     });
 };
 // Not sure why this isn't exported from Zod:
@@ -15545,13 +15503,13 @@ function processCreateParams(params) {
     const customMap = (iss, ctx) => {
         var _a, _b;
         const { message } = params;
-        if (iss.code === "invalid_enum_value") {
+        if (iss.code === 'invalid_enum_value') {
             return { message: message !== null && message !== void 0 ? message : ctx.defaultError };
         }
-        if (typeof ctx.data === "undefined") {
+        if (typeof ctx.data === 'undefined') {
             return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError };
         }
-        if (iss.code !== "invalid_type")
+        if (iss.code !== 'invalid_type')
             return { message: ctx.defaultError };
         return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError };
     };
@@ -15601,7 +15559,9 @@ class McpServer {
             }
         });
         this.server.setRequestHandler(ListToolsRequestSchema, () => ({
-            tools: Object.entries(this._registeredTools).filter(([, tool]) => tool.enabled).map(([name, tool]) => {
+            tools: Object.entries(this._registeredTools)
+                .filter(([, tool]) => tool.enabled)
+                .map(([name, tool]) => {
                 const toolDefinition = {
                     name,
                     title: tool.title,
@@ -15609,16 +15569,20 @@ class McpServer {
                     inputSchema: tool.inputSchema
                         ? zodToJsonSchema(tool.inputSchema, {
                             strictUnions: true,
+                            pipeStrategy: 'input'
                         })
                         : EMPTY_OBJECT_JSON_SCHEMA,
                     annotations: tool.annotations,
-                    _meta: tool._meta,
+                    _meta: tool._meta
                 };
                 if (tool.outputSchema) {
-                    toolDefinition.outputSchema = zodToJsonSchema(tool.outputSchema, { strictUnions: true });
+                    toolDefinition.outputSchema = zodToJsonSchema(tool.outputSchema, {
+                        strictUnions: true,
+                        pipeStrategy: 'output'
+                    });
                 }
                 return toolDefinition;
-            }),
+            })
         }));
         this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
             const tool = this._registeredTools[request.params.name];
@@ -15643,11 +15607,11 @@ class McpServer {
                     result = {
                         content: [
                             {
-                                type: "text",
-                                text: error instanceof Error ? error.message : String(error),
-                            },
+                                type: 'text',
+                                text: error instanceof Error ? error.message : String(error)
+                            }
                         ],
-                        isError: true,
+                        isError: true
                     };
                 }
             }
@@ -15660,11 +15624,11 @@ class McpServer {
                     result = {
                         content: [
                             {
-                                type: "text",
-                                text: error instanceof Error ? error.message : String(error),
-                            },
+                                type: 'text',
+                                text: error instanceof Error ? error.message : String(error)
+                            }
                         ],
-                        isError: true,
+                        isError: true
                     };
                 }
             }
@@ -15688,13 +15652,13 @@ class McpServer {
         }
         this.server.assertCanSetRequestHandler(CompleteRequestSchema.shape.method.value);
         this.server.registerCapabilities({
-            completions: {},
+            completions: {}
         });
         this.server.setRequestHandler(CompleteRequestSchema, async (request) => {
             switch (request.params.ref.type) {
-                case "ref/prompt":
+                case 'ref/prompt':
                     return this.handlePromptCompletion(request, request.params.ref);
-                case "ref/resource":
+                case 'ref/resource':
                     return this.handleResourceCompletion(request, request.params.ref);
                 default:
                     throw new McpError(ErrorCode.InvalidParams, `Invalid completion reference: ${request.params.ref}`);
@@ -15722,7 +15686,7 @@ class McpServer {
         return createCompletionResult(suggestions);
     }
     async handleResourceCompletion(request, ref) {
-        const template = Object.values(this._registeredResourceTemplates).find((t) => t.resourceTemplate.uriTemplate.toString() === ref.uri);
+        const template = Object.values(this._registeredResourceTemplates).find(t => t.resourceTemplate.uriTemplate.toString() === ref.uri);
         if (!template) {
             if (this._registeredResources[ref.uri]) {
                 // Attempting to autocomplete a fixed resource URI is not an error in the spec (but probably should be).
@@ -15750,10 +15714,12 @@ class McpServer {
             }
         });
         this.server.setRequestHandler(ListResourcesRequestSchema, async (request, extra) => {
-            const resources = Object.entries(this._registeredResources).filter(([_, resource]) => resource.enabled).map(([uri, resource]) => ({
+            const resources = Object.entries(this._registeredResources)
+                .filter(([_, resource]) => resource.enabled)
+                .map(([uri, resource]) => ({
                 uri,
                 name: resource.name,
-                ...resource.metadata,
+                ...resource.metadata
             }));
             const templateResources = [];
             for (const template of Object.values(this._registeredResourceTemplates)) {
@@ -15765,7 +15731,7 @@ class McpServer {
                     templateResources.push({
                         ...template.metadata,
                         // the defined resource metadata should override the template metadata if present
-                        ...resource,
+                        ...resource
                     });
                 }
             }
@@ -15775,7 +15741,7 @@ class McpServer {
             const resourceTemplates = Object.entries(this._registeredResourceTemplates).map(([name, template]) => ({
                 name,
                 uriTemplate: template.resourceTemplate.uriTemplate.toString(),
-                ...template.metadata,
+                ...template.metadata
             }));
             return { resourceTemplates };
         });
@@ -15813,16 +15779,16 @@ class McpServer {
             }
         });
         this.server.setRequestHandler(ListPromptsRequestSchema, () => ({
-            prompts: Object.entries(this._registeredPrompts).filter(([, prompt]) => prompt.enabled).map(([name, prompt]) => {
+            prompts: Object.entries(this._registeredPrompts)
+                .filter(([, prompt]) => prompt.enabled)
+                .map(([name, prompt]) => {
                 return {
                     name,
                     title: prompt.title,
                     description: prompt.description,
-                    arguments: prompt.argsSchema
-                        ? promptArgumentsFromSchema(prompt.argsSchema)
-                        : undefined,
+                    arguments: prompt.argsSchema ? promptArgumentsFromSchema(prompt.argsSchema) : undefined
                 };
-            }),
+            })
         }));
         this.server.setRequestHandler(GetPromptRequestSchema, async (request, extra) => {
             const prompt = this._registeredPrompts[request.params.name];
@@ -15851,11 +15817,11 @@ class McpServer {
     }
     resource(name, uriOrTemplate, ...rest) {
         let metadata;
-        if (typeof rest[0] === "object") {
+        if (typeof rest[0] === 'object') {
             metadata = rest.shift();
         }
         const readCallback = rest[0];
-        if (typeof uriOrTemplate === "string") {
+        if (typeof uriOrTemplate === 'string') {
             if (this._registeredResources[uriOrTemplate]) {
                 throw new Error(`Resource ${uriOrTemplate} is already registered`);
             }
@@ -15875,7 +15841,7 @@ class McpServer {
         }
     }
     registerResource(name, uriOrTemplate, config, readCallback) {
-        if (typeof uriOrTemplate === "string") {
+        if (typeof uriOrTemplate === 'string') {
             if (this._registeredResources[uriOrTemplate]) {
                 throw new Error(`Resource ${uriOrTemplate} is already registered`);
             }
@@ -15904,24 +15870,24 @@ class McpServer {
             disable: () => registeredResource.update({ enabled: false }),
             enable: () => registeredResource.update({ enabled: true }),
             remove: () => registeredResource.update({ uri: null }),
-            update: (updates) => {
-                if (typeof updates.uri !== "undefined" && updates.uri !== uri) {
+            update: updates => {
+                if (typeof updates.uri !== 'undefined' && updates.uri !== uri) {
                     delete this._registeredResources[uri];
                     if (updates.uri)
                         this._registeredResources[updates.uri] = registeredResource;
                 }
-                if (typeof updates.name !== "undefined")
+                if (typeof updates.name !== 'undefined')
                     registeredResource.name = updates.name;
-                if (typeof updates.title !== "undefined")
+                if (typeof updates.title !== 'undefined')
                     registeredResource.title = updates.title;
-                if (typeof updates.metadata !== "undefined")
+                if (typeof updates.metadata !== 'undefined')
                     registeredResource.metadata = updates.metadata;
-                if (typeof updates.callback !== "undefined")
+                if (typeof updates.callback !== 'undefined')
                     registeredResource.readCallback = updates.callback;
-                if (typeof updates.enabled !== "undefined")
+                if (typeof updates.enabled !== 'undefined')
                     registeredResource.enabled = updates.enabled;
                 this.sendResourceListChanged();
-            },
+            }
         };
         this._registeredResources[uri] = registeredResource;
         return registeredResource;
@@ -15936,24 +15902,24 @@ class McpServer {
             disable: () => registeredResourceTemplate.update({ enabled: false }),
             enable: () => registeredResourceTemplate.update({ enabled: true }),
             remove: () => registeredResourceTemplate.update({ name: null }),
-            update: (updates) => {
-                if (typeof updates.name !== "undefined" && updates.name !== name) {
+            update: updates => {
+                if (typeof updates.name !== 'undefined' && updates.name !== name) {
                     delete this._registeredResourceTemplates[name];
                     if (updates.name)
                         this._registeredResourceTemplates[updates.name] = registeredResourceTemplate;
                 }
-                if (typeof updates.title !== "undefined")
+                if (typeof updates.title !== 'undefined')
                     registeredResourceTemplate.title = updates.title;
-                if (typeof updates.template !== "undefined")
+                if (typeof updates.template !== 'undefined')
                     registeredResourceTemplate.resourceTemplate = updates.template;
-                if (typeof updates.metadata !== "undefined")
+                if (typeof updates.metadata !== 'undefined')
                     registeredResourceTemplate.metadata = updates.metadata;
-                if (typeof updates.callback !== "undefined")
+                if (typeof updates.callback !== 'undefined')
                     registeredResourceTemplate.readCallback = updates.callback;
-                if (typeof updates.enabled !== "undefined")
+                if (typeof updates.enabled !== 'undefined')
                     registeredResourceTemplate.enabled = updates.enabled;
                 this.sendResourceListChanged();
-            },
+            }
         };
         this._registeredResourceTemplates[name] = registeredResourceTemplate;
         return registeredResourceTemplate;
@@ -15968,24 +15934,24 @@ class McpServer {
             disable: () => registeredPrompt.update({ enabled: false }),
             enable: () => registeredPrompt.update({ enabled: true }),
             remove: () => registeredPrompt.update({ name: null }),
-            update: (updates) => {
-                if (typeof updates.name !== "undefined" && updates.name !== name) {
+            update: updates => {
+                if (typeof updates.name !== 'undefined' && updates.name !== name) {
                     delete this._registeredPrompts[name];
                     if (updates.name)
                         this._registeredPrompts[updates.name] = registeredPrompt;
                 }
-                if (typeof updates.title !== "undefined")
+                if (typeof updates.title !== 'undefined')
                     registeredPrompt.title = updates.title;
-                if (typeof updates.description !== "undefined")
+                if (typeof updates.description !== 'undefined')
                     registeredPrompt.description = updates.description;
-                if (typeof updates.argsSchema !== "undefined")
+                if (typeof updates.argsSchema !== 'undefined')
                     registeredPrompt.argsSchema = objectType(updates.argsSchema);
-                if (typeof updates.callback !== "undefined")
+                if (typeof updates.callback !== 'undefined')
                     registeredPrompt.callback = updates.callback;
-                if (typeof updates.enabled !== "undefined")
+                if (typeof updates.enabled !== 'undefined')
                     registeredPrompt.enabled = updates.enabled;
                 this.sendPromptListChanged();
-            },
+            }
         };
         this._registeredPrompts[name] = registeredPrompt;
         return registeredPrompt;
@@ -16003,28 +15969,28 @@ class McpServer {
             disable: () => registeredTool.update({ enabled: false }),
             enable: () => registeredTool.update({ enabled: true }),
             remove: () => registeredTool.update({ name: null }),
-            update: (updates) => {
-                if (typeof updates.name !== "undefined" && updates.name !== name) {
+            update: updates => {
+                if (typeof updates.name !== 'undefined' && updates.name !== name) {
                     delete this._registeredTools[name];
                     if (updates.name)
                         this._registeredTools[updates.name] = registeredTool;
                 }
-                if (typeof updates.title !== "undefined")
+                if (typeof updates.title !== 'undefined')
                     registeredTool.title = updates.title;
-                if (typeof updates.description !== "undefined")
+                if (typeof updates.description !== 'undefined')
                     registeredTool.description = updates.description;
-                if (typeof updates.paramsSchema !== "undefined")
+                if (typeof updates.paramsSchema !== 'undefined')
                     registeredTool.inputSchema = objectType(updates.paramsSchema);
-                if (typeof updates.callback !== "undefined")
+                if (typeof updates.callback !== 'undefined')
                     registeredTool.callback = updates.callback;
-                if (typeof updates.annotations !== "undefined")
+                if (typeof updates.annotations !== 'undefined')
                     registeredTool.annotations = updates.annotations;
-                if (typeof updates._meta !== "undefined")
+                if (typeof updates._meta !== 'undefined')
                     registeredTool._meta = updates._meta;
-                if (typeof updates.enabled !== "undefined")
+                if (typeof updates.enabled !== 'undefined')
                     registeredTool.enabled = updates.enabled;
                 this.sendToolListChanged();
-            },
+            }
         };
         this._registeredTools[name] = registeredTool;
         this.setToolRequestHandlers();
@@ -16045,7 +16011,7 @@ class McpServer {
         // Tool properties are passed as separate arguments, with omissions allowed.
         // Support for this style is frozen as of protocol version 2025-03-26. Future additions
         // to tool definition should *NOT* be added.
-        if (typeof rest[0] === "string") {
+        if (typeof rest[0] === 'string') {
             description = rest.shift();
         }
         // Handle the different overload combinations
@@ -16056,13 +16022,13 @@ class McpServer {
                 // We have a params schema as the first arg
                 inputSchema = rest.shift();
                 // Check if the next arg is potentially annotations
-                if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !(isZodRawShape(rest[0]))) {
+                if (rest.length > 1 && typeof rest[0] === 'object' && rest[0] !== null && !isZodRawShape(rest[0])) {
                     // Case: tool(name, paramsSchema, annotations, cb)
                     // Or: tool(name, description, paramsSchema, annotations, cb)
                     annotations = rest.shift();
                 }
             }
-            else if (typeof firstArg === "object" && firstArg !== null) {
+            else if (typeof firstArg === 'object' && firstArg !== null) {
                 // Not a ZodRawShape, so must be annotations in this position
                 // Case: tool(name, annotations, cb)
                 // Or: tool(name, description, annotations, cb)
@@ -16087,7 +16053,7 @@ class McpServer {
             throw new Error(`Prompt ${name} is already registered`);
         }
         let description;
-        if (typeof rest[0] === "string") {
+        if (typeof rest[0] === 'string') {
             description = rest.shift();
         }
         let argsSchema;
@@ -16156,12 +16122,12 @@ class McpServer {
     }
 }
 const EMPTY_OBJECT_JSON_SCHEMA = {
-    type: "object",
-    properties: {},
+    type: 'object',
+    properties: {}
 };
 // Helper to check if an object is a Zod schema (ZodRawShape)
 function isZodRawShape(obj) {
-    if (typeof obj !== "object" || obj === null)
+    if (typeof obj !== 'object' || obj === null)
         return false;
     const isEmptyObject = Object.keys(obj).length === 0;
     // Check if object is empty or at least one property is a ZodType instance
@@ -16169,16 +16135,18 @@ function isZodRawShape(obj) {
     return isEmptyObject || Object.values(obj).some(isZodTypeLike);
 }
 function isZodTypeLike(value) {
-    return value !== null &&
+    return (value !== null &&
         typeof value === 'object' &&
-        'parse' in value && typeof value.parse === 'function' &&
-        'safeParse' in value && typeof value.safeParse === 'function';
+        'parse' in value &&
+        typeof value.parse === 'function' &&
+        'safeParse' in value &&
+        typeof value.safeParse === 'function');
 }
 function promptArgumentsFromSchema(schema) {
     return Object.entries(schema.shape).map(([name, field]) => ({
         name,
         description: field.description,
-        required: !field.isOptional(),
+        required: !field.isOptional()
     }));
 }
 function createCompletionResult(suggestions) {
@@ -16186,15 +16154,15 @@ function createCompletionResult(suggestions) {
         completion: {
             values: suggestions.slice(0, 100),
             total: suggestions.length,
-            hasMore: suggestions.length > 100,
-        },
+            hasMore: suggestions.length > 100
+        }
     };
 }
 const EMPTY_COMPLETION_RESULT = {
     completion: {
         values: [],
-        hasMore: false,
-    },
+        hasMore: false
+    }
 };
 
 async function safeMcpResponse(exec) {
@@ -31235,244 +31203,370 @@ class XmlNode{
   }
 }
 
-//TODO: handle comments
-function readDocType(xmlData, i){
+class DocTypeReader{
+    constructor(processEntities){
+        this.suppressValidationErr = !processEntities;
+    }
     
-    const entities = {};
-    if( xmlData[i + 3] === 'O' &&
-         xmlData[i + 4] === 'C' &&
-         xmlData[i + 5] === 'T' &&
-         xmlData[i + 6] === 'Y' &&
-         xmlData[i + 7] === 'P' &&
-         xmlData[i + 8] === 'E')
-    {    
-        i = i+9;
-        let angleBracketsCount = 1;
-        let hasBody = false, comment = false;
-        let exp = "";
-        for(;i<xmlData.length;i++){
-            if (xmlData[i] === '<' && !comment) { //Determine the tag type
-                if( hasBody && hasSeq(xmlData, "!ENTITY",i)){
-                    i += 7; 
-                    let entityName, val;
-                    [entityName, val,i] = readEntityExp(xmlData,i+1);
-                    if(val.indexOf("&") === -1) //Parameter entities are not supported
-                        entities[ entityName ] = {
-                            regx : RegExp( `&${entityName};`,"g"),
-                            val: val
-                        };
-                }
-                else if( hasBody && hasSeq(xmlData, "!ELEMENT",i))  {
-                    i += 8;//Not supported
-                    const {index} = readElementExp(xmlData,i+1);
-                    i = index;
-                }else if( hasBody && hasSeq(xmlData, "!ATTLIST",i)){
-                    i += 8;//Not supported
-                    // const {index} = readAttlistExp(xmlData,i+1);
-                    // i = index;
-                }else if( hasBody && hasSeq(xmlData, "!NOTATION",i)) {
-                    i += 9;//Not supported
-                    const {index} = readNotationExp(xmlData,i+1);
-                    i = index;
-                }else if( hasSeq(xmlData, "!--",i) ) comment = true;
-                else throw new Error(`Invalid DOCTYPE`);
-
-                angleBracketsCount++;
-                exp = "";
-            } else if (xmlData[i] === '>') { //Read tag content
-                if(comment){
-                    if( xmlData[i - 1] === "-" && xmlData[i - 2] === "-"){
-                        comment = false;
+    readDocType(xmlData, i){
+    
+        const entities = {};
+        if( xmlData[i + 3] === 'O' &&
+            xmlData[i + 4] === 'C' &&
+            xmlData[i + 5] === 'T' &&
+            xmlData[i + 6] === 'Y' &&
+            xmlData[i + 7] === 'P' &&
+            xmlData[i + 8] === 'E')
+        {    
+            i = i+9;
+            let angleBracketsCount = 1;
+            let hasBody = false, comment = false;
+            let exp = "";
+            for(;i<xmlData.length;i++){
+                if (xmlData[i] === '<' && !comment) { //Determine the tag type
+                    if( hasBody && hasSeq(xmlData, "!ENTITY",i)){
+                        i += 7; 
+                        let entityName, val;
+                        [entityName, val,i] = this.readEntityExp(xmlData,i+1,this.suppressValidationErr);
+                        if(val.indexOf("&") === -1) //Parameter entities are not supported
+                            entities[ entityName ] = {
+                                regx : RegExp( `&${entityName};`,"g"),
+                                val: val
+                            };
+                    }
+                    else if( hasBody && hasSeq(xmlData, "!ELEMENT",i))  {
+                        i += 8;//Not supported
+                        const {index} = this.readElementExp(xmlData,i+1);
+                        i = index;
+                    }else if( hasBody && hasSeq(xmlData, "!ATTLIST",i)){
+                        i += 8;//Not supported
+                        // const {index} = this.readAttlistExp(xmlData,i+1);
+                        // i = index;
+                    }else if( hasBody && hasSeq(xmlData, "!NOTATION",i)) {
+                        i += 9;//Not supported
+                        const {index} = this.readNotationExp(xmlData,i+1,this.suppressValidationErr);
+                        i = index;
+                    }else if( hasSeq(xmlData, "!--",i) ) comment = true;
+                    else throw new Error(`Invalid DOCTYPE`);
+
+                    angleBracketsCount++;
+                    exp = "";
+                } else if (xmlData[i] === '>') { //Read tag content
+                    if(comment){
+                        if( xmlData[i - 1] === "-" && xmlData[i - 2] === "-"){
+                            comment = false;
+                            angleBracketsCount--;
+                        }
+                    }else {
                         angleBracketsCount--;
                     }
+                    if (angleBracketsCount === 0) {
+                    break;
+                    }
+                }else if( xmlData[i] === '['){
+                    hasBody = true;
                 }else {
-                    angleBracketsCount--;
-                }
-                if (angleBracketsCount === 0) {
-                  break;
+                    exp += xmlData[i];
                 }
-            }else if( xmlData[i] === '['){
-                hasBody = true;
-            }else {
-                exp += xmlData[i];
             }
+            if(angleBracketsCount !== 0){
+                throw new Error(`Unclosed DOCTYPE`);
+            }
+        }else {
+            throw new Error(`Invalid Tag instead of DOCTYPE`);
         }
-        if(angleBracketsCount !== 0){
-            throw new Error(`Unclosed DOCTYPE`);
-        }
-    }else {
-        throw new Error(`Invalid Tag instead of DOCTYPE`);
+        return {entities, i};
     }
-    return {entities, i};
-}
+    readEntityExp(xmlData, i) {    
+        //External entities are not supported
+        //    <!ENTITY ext SYSTEM "http://normal-website.com" >
 
-const skipWhitespace = (data, index) => {
-    while (index < data.length && /\s/.test(data[index])) {
-        index++;
-    }
-    return index;
-};
+        //Parameter entities are not supported
+        //    <!ENTITY entityname "&anotherElement;">
 
-function readEntityExp(xmlData, i) {    
-    //External entities are not supported
-    //    <!ENTITY ext SYSTEM "http://normal-website.com" >
+        //Internal entities are supported
+        //    <!ENTITY entityname "replacement text">
 
-    //Parameter entities are not supported
-    //    <!ENTITY entityname "&anotherElement;">
+        // Skip leading whitespace after <!ENTITY
+        i = skipWhitespace(xmlData, i);
 
-    //Internal entities are supported
-    //    <!ENTITY entityname "replacement text">
+        // Read entity name
+        let entityName = "";
+        while (i < xmlData.length && !/\s/.test(xmlData[i]) && xmlData[i] !== '"' && xmlData[i] !== "'") {
+            entityName += xmlData[i];
+            i++;
+        }
+        validateEntityName(entityName);
 
-    // Skip leading whitespace after <!ENTITY
-    i = skipWhitespace(xmlData, i);
+        // Skip whitespace after entity name
+        i = skipWhitespace(xmlData, i);
 
-    // Read entity name
-    let entityName = "";
-    while (i < xmlData.length && !/\s/.test(xmlData[i]) && xmlData[i] !== '"' && xmlData[i] !== "'") {
-        entityName += xmlData[i];
-        i++;
+        // Check for unsupported constructs (external entities or parameter entities)
+        if(!this.suppressValidationErr){
+            if (xmlData.substring(i, i + 6).toUpperCase() === "SYSTEM") {
+                throw new Error("External entities are not supported");
+            }else if (xmlData[i] === "%") {
+                throw new Error("Parameter entities are not supported");
+            }
+        }
+
+        // Read entity value (internal entity)
+        let entityValue = "";
+        [i, entityValue] = this.readIdentifierVal(xmlData, i, "entity");
+        i--;
+        return [entityName, entityValue, i ];
     }
-    validateEntityName(entityName);
 
-    // Skip whitespace after entity name
-    i = skipWhitespace(xmlData, i);
+    readNotationExp(xmlData, i) {
+        // Skip leading whitespace after <!NOTATION
+        i = skipWhitespace(xmlData, i);
 
-    // Check for unsupported constructs (external entities or parameter entities)
-    if (xmlData.substring(i, i + 6).toUpperCase() === "SYSTEM") {
-        throw new Error("External entities are not supported");
-    }else if (xmlData[i] === "%") {
-        throw new Error("Parameter entities are not supported");
+        // Read notation name
+        let notationName = "";
+        while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+            notationName += xmlData[i];
+            i++;
+        }
+        !this.suppressValidationErr && validateEntityName(notationName);
+
+        // Skip whitespace after notation name
+        i = skipWhitespace(xmlData, i);
+
+        // Check identifier type (SYSTEM or PUBLIC)
+        const identifierType = xmlData.substring(i, i + 6).toUpperCase();
+        if (!this.suppressValidationErr && identifierType !== "SYSTEM" && identifierType !== "PUBLIC") {
+            throw new Error(`Expected SYSTEM or PUBLIC, found "${identifierType}"`);
+        }
+        i += identifierType.length;
+
+        // Skip whitespace after identifier type
+        i = skipWhitespace(xmlData, i);
+
+        // Read public identifier (if PUBLIC)
+        let publicIdentifier = null;
+        let systemIdentifier = null;
+
+        if (identifierType === "PUBLIC") {
+            [i, publicIdentifier ] = this.readIdentifierVal(xmlData, i, "publicIdentifier");
+
+            // Skip whitespace after public identifier
+            i = skipWhitespace(xmlData, i);
+
+            // Optionally read system identifier
+            if (xmlData[i] === '"' || xmlData[i] === "'") {
+                [i, systemIdentifier ] = this.readIdentifierVal(xmlData, i,"systemIdentifier");
+            }
+        } else if (identifierType === "SYSTEM") {
+            // Read system identifier (mandatory for SYSTEM)
+            [i, systemIdentifier ] = this.readIdentifierVal(xmlData, i, "systemIdentifier");
+
+            if (!this.suppressValidationErr && !systemIdentifier) {
+                throw new Error("Missing mandatory system identifier for SYSTEM notation");
+            }
+        }
+        
+        return {notationName, publicIdentifier, systemIdentifier, index: --i};
     }
 
-    // Read entity value (internal entity)
-    let entityValue = "";
-    [i, entityValue] = readIdentifierVal(xmlData, i, "entity");
-    i--;
-    return [entityName, entityValue, i ];
-}
+    readIdentifierVal(xmlData, i, type) {
+        let identifierVal = "";
+        const startChar = xmlData[i];
+        if (startChar !== '"' && startChar !== "'") {
+            throw new Error(`Expected quoted string, found "${startChar}"`);
+        }
+        i++;
 
-function readNotationExp(xmlData, i) {
-    // Skip leading whitespace after <!NOTATION
-    i = skipWhitespace(xmlData, i);
+        while (i < xmlData.length && xmlData[i] !== startChar) {
+            identifierVal += xmlData[i];
+            i++;
+        }
 
-    // Read notation name
-    let notationName = "";
-    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-        notationName += xmlData[i];
+        if (xmlData[i] !== startChar) {
+            throw new Error(`Unterminated ${type} value`);
+        }
         i++;
+        return [i, identifierVal];
     }
-    validateEntityName(notationName);
 
-    // Skip whitespace after notation name
-    i = skipWhitespace(xmlData, i);
+    readElementExp(xmlData, i) {
+        // <!ELEMENT br EMPTY>
+        // <!ELEMENT div ANY>
+        // <!ELEMENT title (#PCDATA)>
+        // <!ELEMENT book (title, author+)>
+        // <!ELEMENT name (content-model)>
+        
+        // Skip leading whitespace after <!ELEMENT
+        i = skipWhitespace(xmlData, i);
+
+        // Read element name
+        let elementName = "";
+        while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+            elementName += xmlData[i];
+            i++;
+        }
+
+        // Validate element name
+        if (!this.suppressValidationErr && !isName(elementName)) {
+            throw new Error(`Invalid element name: "${elementName}"`);
+        }
+
+        // Skip whitespace after element name
+        i = skipWhitespace(xmlData, i);
+        let contentModel = "";
+        // Expect '(' to start content model
+        if(xmlData[i] === "E" && hasSeq(xmlData, "MPTY",i)) i+=4;
+        else if(xmlData[i] === "A" && hasSeq(xmlData, "NY",i)) i+=2;
+        else if (xmlData[i] === "(") {
+            i++; // Move past '('
+
+            // Read content model
+            while (i < xmlData.length && xmlData[i] !== ")") {
+                contentModel += xmlData[i];
+                i++;
+            }
+            if (xmlData[i] !== ")") {
+                throw new Error("Unterminated content model");
+            }
 
-    // Check identifier type (SYSTEM or PUBLIC)
-    const identifierType = xmlData.substring(i, i + 6).toUpperCase();
-    if (identifierType !== "SYSTEM" && identifierType !== "PUBLIC") {
-        throw new Error(`Expected SYSTEM or PUBLIC, found "${identifierType}"`);
+        }else if(!this.suppressValidationErr){
+            throw new Error(`Invalid Element Expression, found "${xmlData[i]}"`);
+        }
+        
+        return {
+            elementName,
+            contentModel: contentModel.trim(),
+            index: i
+        };
     }
-    i += identifierType.length;
 
-    // Skip whitespace after identifier type
-    i = skipWhitespace(xmlData, i);
+    readAttlistExp(xmlData, i) {
+        // Skip leading whitespace after <!ATTLIST
+        i = skipWhitespace(xmlData, i);
 
-    // Read public identifier (if PUBLIC)
-    let publicIdentifier = null;
-    let systemIdentifier = null;
+        // Read element name
+        let elementName = "";
+        while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+            elementName += xmlData[i];
+            i++;
+        }
 
-    if (identifierType === "PUBLIC") {
-        [i, publicIdentifier ] = readIdentifierVal(xmlData, i, "publicIdentifier");
+        // Validate element name
+        validateEntityName(elementName);
 
-        // Skip whitespace after public identifier
+        // Skip whitespace after element name
         i = skipWhitespace(xmlData, i);
 
-        // Optionally read system identifier
-        if (xmlData[i] === '"' || xmlData[i] === "'") {
-            [i, systemIdentifier ] = readIdentifierVal(xmlData, i,"systemIdentifier");
+        // Read attribute name
+        let attributeName = "";
+        while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+            attributeName += xmlData[i];
+            i++;
         }
-    } else if (identifierType === "SYSTEM") {
-        // Read system identifier (mandatory for SYSTEM)
-        [i, systemIdentifier ] = readIdentifierVal(xmlData, i, "systemIdentifier");
 
-        if (!systemIdentifier) {
-            throw new Error("Missing mandatory system identifier for SYSTEM notation");
+        // Validate attribute name
+        if (!validateEntityName(attributeName)) {
+            throw new Error(`Invalid attribute name: "${attributeName}"`);
         }
-    }
-    
-    return {notationName, publicIdentifier, systemIdentifier, index: --i};
-}
 
-function readIdentifierVal(xmlData, i, type) {
-    let identifierVal = "";
-    const startChar = xmlData[i];
-    if (startChar !== '"' && startChar !== "'") {
-        throw new Error(`Expected quoted string, found "${startChar}"`);
-    }
-    i++;
+        // Skip whitespace after attribute name
+        i = skipWhitespace(xmlData, i);
 
-    while (i < xmlData.length && xmlData[i] !== startChar) {
-        identifierVal += xmlData[i];
-        i++;
-    }
+        // Read attribute type
+        let attributeType = "";
+        if (xmlData.substring(i, i + 8).toUpperCase() === "NOTATION") {
+            attributeType = "NOTATION";
+            i += 8; // Move past "NOTATION"
 
-    if (xmlData[i] !== startChar) {
-        throw new Error(`Unterminated ${type} value`);
-    }
-    i++;
-    return [i, identifierVal];
-}
+            // Skip whitespace after "NOTATION"
+            i = skipWhitespace(xmlData, i);
 
-function readElementExp(xmlData, i) {
-    // <!ELEMENT br EMPTY>
-    // <!ELEMENT div ANY>
-    // <!ELEMENT title (#PCDATA)>
-    // <!ELEMENT book (title, author+)>
-    // <!ELEMENT name (content-model)>
-    
-    // Skip leading whitespace after <!ELEMENT
-    i = skipWhitespace(xmlData, i);
+            // Expect '(' to start the list of notations
+            if (xmlData[i] !== "(") {
+                throw new Error(`Expected '(', found "${xmlData[i]}"`);
+            }
+            i++; // Move past '('
 
-    // Read element name
-    let elementName = "";
-    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-        elementName += xmlData[i];
-        i++;
-    }
+            // Read the list of allowed notations
+            let allowedNotations = [];
+            while (i < xmlData.length && xmlData[i] !== ")") {
+                let notation = "";
+                while (i < xmlData.length && xmlData[i] !== "|" && xmlData[i] !== ")") {
+                    notation += xmlData[i];
+                    i++;
+                }
 
-    // Validate element name
-    if (!validateEntityName(elementName)) {
-        throw new Error(`Invalid element name: "${elementName}"`);
-    }
+                // Validate notation name
+                notation = notation.trim();
+                if (!validateEntityName(notation)) {
+                    throw new Error(`Invalid notation name: "${notation}"`);
+                }
 
-    // Skip whitespace after element name
-    i = skipWhitespace(xmlData, i);
-    let contentModel = "";
-    // Expect '(' to start content model
-    if(xmlData[i] === "E" && hasSeq(xmlData, "MPTY",i)) i+=4;
-    else if(xmlData[i] === "A" && hasSeq(xmlData, "NY",i)) i+=2;
-    else if (xmlData[i] === "(") {
-        i++; // Move past '('
+                allowedNotations.push(notation);
 
-        // Read content model
-        while (i < xmlData.length && xmlData[i] !== ")") {
-            contentModel += xmlData[i];
-            i++;
+                // Skip '|' separator or exit loop
+                if (xmlData[i] === "|") {
+                    i++; // Move past '|'
+                    i = skipWhitespace(xmlData, i); // Skip optional whitespace after '|'
+                }
+            }
+
+            if (xmlData[i] !== ")") {
+                throw new Error("Unterminated list of notations");
+            }
+            i++; // Move past ')'
+
+            // Store the allowed notations as part of the attribute type
+            attributeType += " (" + allowedNotations.join("|") + ")";
+        } else {
+            // Handle simple types (e.g., CDATA, ID, IDREF, etc.)
+            while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+                attributeType += xmlData[i];
+                i++;
+            }
+
+            // Validate simple attribute type
+            const validTypes = ["CDATA", "ID", "IDREF", "IDREFS", "ENTITY", "ENTITIES", "NMTOKEN", "NMTOKENS"];
+            if (!this.suppressValidationErr && !validTypes.includes(attributeType.toUpperCase())) {
+                throw new Error(`Invalid attribute type: "${attributeType}"`);
+            }
         }
-        if (xmlData[i] !== ")") {
-            throw new Error("Unterminated content model");
+
+        // Skip whitespace after attribute type
+        i = skipWhitespace(xmlData, i);
+
+        // Read default value
+        let defaultValue = "";
+        if (xmlData.substring(i, i + 8).toUpperCase() === "#REQUIRED") {
+            defaultValue = "#REQUIRED";
+            i += 8;
+        } else if (xmlData.substring(i, i + 7).toUpperCase() === "#IMPLIED") {
+            defaultValue = "#IMPLIED";
+            i += 7;
+        } else {
+            [i, defaultValue] = this.readIdentifierVal(xmlData, i, "ATTLIST");
         }
 
-    }else {
-        throw new Error(`Invalid Element Expression, found "${xmlData[i]}"`);
+        return {
+            elementName,
+            attributeName,
+            attributeType,
+            defaultValue,
+            index: i
+        }
     }
-    
-    return {
-        elementName,
-        contentModel: contentModel.trim(),
-        index: i
-    };
 }
 
+
+
+const skipWhitespace = (data, index) => {
+    while (index < data.length && /\s/.test(data[index])) {
+        index++;
+    }
+    return index;
+};
+
+
+
 function hasSeq(data, seq,i){
     for(let j=0;j<seq.length;j++){
         if(seq[j]!==data[i+j+1]) return false;
@@ -31482,7 +31576,7 @@ function hasSeq(data, seq,i){
 
 function validateEntityName(name){
     if (isName(name))
-	return name;
+	    return name;
     else
         throw new Error(`Invalid entity name ${name}`);
 }
@@ -31818,6 +31912,7 @@ const parseXml = function(xmlData) {
   let currentNode = xmlObj;
   let textData = "";
   let jPath = "";
+  const docTypeReader = new DocTypeReader(this.options.processEntities);
   for(let i=0; i< xmlData.length; i++){//for each char in XML data
     const ch = xmlData[i];
     if(ch === '<'){
@@ -31889,7 +31984,7 @@ const parseXml = function(xmlData) {
         }
         i = endIndex;
       } else if( xmlData.substr(i + 1, 2) === '!D') {
-        const result = readDocType(xmlData, i);
+        const result = docTypeReader.readDocType(xmlData, i);
         this.docTypeEntities = result.entities;
         i = result.i;
       }else if(xmlData.substr(i + 1, 2) === '![') {
@@ -32356,15 +32451,16 @@ class XMLParser{
     }
     /**
      * Parse XML dats to JS object 
-     * @param {string|Buffer} xmlData 
+     * @param {string|Uint8Array} xmlData 
      * @param {boolean|Object} validationOption 
      */
     parse(xmlData,validationOption){
-        if(typeof xmlData === "string");else if( xmlData.toString){
+        if(typeof xmlData !== "string" && xmlData.toString){
             xmlData = xmlData.toString();
-        }else {
+        }else if(typeof xmlData !== "string"){
             throw new Error("XML data is accepted in String or Bytes[] form.")
         }
+        
         if( validationOption){
             if(validationOption === true) validationOption = {}; //validate with default options
             
@@ -35788,7 +35884,7 @@ function addRenderingByIdPowershellTool(server, config) {
     server.tool("presentation-add-rendering-by-id", "Adds a rendering to presentation of an item specified by item ID.", {
         itemId: stringType().describe("The ID of the item to add the rendering to."),
         renderingId: stringType().describe("The ID of the rendering to add."),
-        database: stringType().describe("The context database.").default("master").optional(),
+        database: stringType().describe("The context database.").optional().default("master"),
         placeHolder: stringType().describe("The placeholder to add the rendering to.").optional(),
         dataSource: stringType().describe("The rendering data source.").optional(),
         finalLayout: booleanType()
@@ -35851,7 +35947,7 @@ function setRenderingByIdPowershellTool(server, config) {
     server.tool("presentation-set-rendering-by-id", "Updates rendering specified by item ID with new values.", {
         itemId: stringType().describe("The ID of the item holding the rendering."),
         uniqueId: stringType().describe("The unique ID of the rendering."),
-        database: stringType().describe("The context database.").default("master").optional(),
+        database: stringType().describe("The context database.").optional().default("master"),
         placeholder: stringType().describe("New rendering placeholder value if specified.").optional(),
         dataSource: stringType().describe("New rendering data source if specified.").optional(),
         finalLayout: booleanType()
@@ -35888,7 +35984,7 @@ function switchRenderingByIdPowershellTool(server, config) {
         itemId: stringType().describe("The ID of the item holding the renderings."),
         oldRenderingId: stringType().describe("The ID of the rendering to switch."),
         newRenderingId: stringType().describe("The ID of the new rendering."),
-        database: stringType().describe("The context database.").default("master").optional(),
+        database: stringType().describe("The context database.").optional().default("master"),
         finalLayout: booleanType()
             .describe("Specifies the layout to update the rendering. If 'true', the final layout is used, otherwise - shared layout.")
             .optional(),
@@ -35957,7 +36053,7 @@ function switchRenderingByUniqueIdPowershellTool(server, config) {
         itemId: stringType().describe("The ID of the item holding the rendering."),
         uniqueId: stringType().describe("The unique ID of the rendering to switch."),
         newRenderingId: stringType().describe("The ID of the new rendering."),
-        database: stringType().describe("The context database.").default("master").optional(),
+        database: stringType().describe("The context database.").optional().default("master"),
         finalLayout: booleanType()
             .describe("Specifies the layout to update the rendering. If 'true', the final layout is used, otherwise - shared layout.")
             .optional(),
@@ -36027,7 +36123,7 @@ function addPlaceholderSettingByIdPowershellTool(server, config) {
         itemId: stringType().describe("The ID of the item to add the placeholder setting to."),
         placeholderSettingId: stringType().describe("The ID of the placeholder setting to add."),
         key: stringType().describe("The key of the placeholder setting to add."),
-        database: stringType().describe("The context database.").default("master").optional(),
+        database: stringType().describe("The context database.").optional().default("master"),
         finalLayout: booleanType()
             .describe("Specifies layout to add the rendering placeholder setting to. If 'true', the final layout is used, otherwise - shared layout.")
             .optional(),
@@ -36391,18 +36487,19 @@ function formatDate(date) {
 function getLogsPowerShellTool(server, config) {
     server.tool(`logging-get-logs`, `Retrieves Sitecore logs from the log directory.`, {
         name: stringType()
-            .default("log")
             .optional()
+            .default("log")
             .describe(`The name of the log file to retrieve. If not provided, defaults to log.*. Possible options: ${logFilePrefixes.join(", ")}.`),
         level: enumType(Object.values(LogLevel))
+            .optional()
             .default(LogLevel.DEBUG)
-            .optional(),
+            .describe("The level of the log to retrieve. Defaults to DEBUG."),
         date: stringType()
             .optional()
             .describe(`The date of the log file to retrieve. If not provided, defaults to today. Date format should be in ISO 8601 format (e.g., '2023-10-01T00:00:00Z'`),
         tail: numberType()
-            .default(500)
             .optional()
+            .default(500)
             .describe("The number of lines to retrieve from the end of the log file. Defaults to 500."),
     }, async (params) => {
         const stringDate = formatDate(params.date);
@@ -49483,7 +49580,7 @@ function requireRawBody () {
 var rawBodyExports = requireRawBody();
 var getRawBody = /*@__PURE__*/getDefaultExportFromCjs(rawBodyExports);
 
-const MAXIMUM_MESSAGE_SIZE$1 = "4mb";
+const MAXIMUM_MESSAGE_SIZE$1 = '4mb';
 /**
  * Server transport for SSE: this will send messages over an SSE connection and receive messages from HTTP POST requests.
  *
@@ -49531,12 +49628,12 @@ class SSEServerTransport {
      */
     async start() {
         if (this._sseResponse) {
-            throw new Error("SSEServerTransport already started! If using Server class, note that connect() calls start() automatically.");
+            throw new Error('SSEServerTransport already started! If using Server class, note that connect() calls start() automatically.');
         }
         this.res.writeHead(200, {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache, no-transform",
-            Connection: "keep-alive",
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache, no-transform',
+            Connection: 'keep-alive'
         });
         // Send the endpoint event
         // Use a dummy base URL because this._endpoint is relative.
@@ -49548,7 +49645,7 @@ class SSEServerTransport {
         const relativeUrlWithSession = endpointUrl.pathname + endpointUrl.search + endpointUrl.hash;
         this.res.write(`event: endpoint\ndata: ${relativeUrlWithSession}\n\n`);
         this._sseResponse = this.res;
-        this.res.on("close", () => {
+        this.res.on('close', () => {
             var _a;
             this._sseResponse = undefined;
             (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
@@ -49562,7 +49659,7 @@ class SSEServerTransport {
     async handlePostMessage(req, res, parsedBody) {
         var _a, _b, _c, _d;
         if (!this._sseResponse) {
-            const message = "SSE connection not established";
+            const message = 'SSE connection not established';
             res.writeHead(500).end(message);
             throw new Error(message);
         }
@@ -49577,14 +49674,15 @@ class SSEServerTransport {
         const requestInfo = { headers: req.headers };
         let body;
         try {
-            const ct = contentType.parse((_b = req.headers["content-type"]) !== null && _b !== void 0 ? _b : "");
-            if (ct.type !== "application/json") {
+            const ct = contentType.parse((_b = req.headers['content-type']) !== null && _b !== void 0 ? _b : '');
+            if (ct.type !== 'application/json') {
                 throw new Error(`Unsupported content-type: ${ct.type}`);
             }
-            body = parsedBody !== null && parsedBody !== void 0 ? parsedBody : await getRawBody(req, {
-                limit: MAXIMUM_MESSAGE_SIZE$1,
-                encoding: (_c = ct.parameters.charset) !== null && _c !== void 0 ? _c : "utf-8",
-            });
+            body =
+                parsedBody !== null && parsedBody !== void 0 ? parsedBody : (await getRawBody(req, {
+                    limit: MAXIMUM_MESSAGE_SIZE$1,
+                    encoding: (_c = ct.parameters.charset) !== null && _c !== void 0 ? _c : 'utf-8'
+                }));
         }
         catch (error) {
             res.writeHead(400).end(String(error));
@@ -49598,7 +49696,7 @@ class SSEServerTransport {
             res.writeHead(400).end(`Invalid message: ${body}`);
             return;
         }
-        res.writeHead(202).end("Accepted");
+        res.writeHead(202).end('Accepted');
     }
     /**
      * Handle a client message, regardless of how it arrived. This can be used to inform the server of messages that arrive via a means different than HTTP POST.
@@ -49623,7 +49721,7 @@ class SSEServerTransport {
     }
     async send(message) {
         if (!this._sseResponse) {
-            throw new Error("Not connected");
+            throw new Error('Not connected');
         }
         this._sseResponse.write(`event: message\ndata: ${JSON.stringify(message)}\n\n`);
     }
@@ -49682,7 +49780,7 @@ async function startSSE() {
     app.listen(3001);
 }
 
-const MAXIMUM_MESSAGE_SIZE = "4mb";
+const MAXIMUM_MESSAGE_SIZE = '4mb';
 /**
  * Server transport for Streamable HTTP: this implements the MCP Streamable HTTP transport specification.
  * It supports both SSE streaming and direct HTTP responses.
@@ -49742,7 +49840,7 @@ class StreamableHTTPServerTransport {
      */
     async start() {
         if (this._started) {
-            throw new Error("Transport already started");
+            throw new Error('Transport already started');
         }
         this._started = true;
     }
@@ -49780,7 +49878,7 @@ class StreamableHTTPServerTransport {
         const validationError = this.validateRequestHeaders(req);
         if (validationError) {
             res.writeHead(403).end(JSON.stringify({
-                jsonrpc: "2.0",
+                jsonrpc: '2.0',
                 error: {
                     code: -32e3,
                     message: validationError
@@ -49790,13 +49888,13 @@ class StreamableHTTPServerTransport {
             (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, new Error(validationError));
             return;
         }
-        if (req.method === "POST") {
+        if (req.method === 'POST') {
             await this.handlePostRequest(req, res, parsedBody);
         }
-        else if (req.method === "GET") {
+        else if (req.method === 'GET') {
             await this.handleGetRequest(req, res);
         }
-        else if (req.method === "DELETE") {
+        else if (req.method === 'DELETE') {
             await this.handleDeleteRequest(req, res);
         }
         else {
@@ -49809,12 +49907,12 @@ class StreamableHTTPServerTransport {
     async handleGetRequest(req, res) {
         // The client MUST include an Accept header, listing text/event-stream as a supported content type.
         const acceptHeader = req.headers.accept;
-        if (!(acceptHeader === null || acceptHeader === void 0 ? void 0 : acceptHeader.includes("text/event-stream"))) {
+        if (!(acceptHeader === null || acceptHeader === void 0 ? void 0 : acceptHeader.includes('text/event-stream'))) {
             res.writeHead(406).end(JSON.stringify({
-                jsonrpc: "2.0",
+                jsonrpc: '2.0',
                 error: {
                     code: -32e3,
-                    message: "Not Acceptable: Client must accept text/event-stream"
+                    message: 'Not Acceptable: Client must accept text/event-stream'
                 },
                 id: null
             }));
@@ -49840,22 +49938,22 @@ class StreamableHTTPServerTransport {
         // The server MUST either return Content-Type: text/event-stream in response to this HTTP GET,
         // or else return HTTP 405 Method Not Allowed
         const headers = {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache, no-transform",
-            Connection: "keep-alive",
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache, no-transform',
+            Connection: 'keep-alive'
         };
         // After initialization, always include the session ID if we have one
         if (this.sessionId !== undefined) {
-            headers["mcp-session-id"] = this.sessionId;
+            headers['mcp-session-id'] = this.sessionId;
         }
         // Check if there's already an active standalone SSE stream for this session
         if (this._streamMapping.get(this._standaloneSseStreamId) !== undefined) {
             // Only one GET SSE stream is allowed per session
             res.writeHead(409).end(JSON.stringify({
-                jsonrpc: "2.0",
+                jsonrpc: '2.0',
                 error: {
                     code: -32e3,
-                    message: "Conflict: Only one SSE stream is allowed per session"
+                    message: 'Conflict: Only one SSE stream is allowed per session'
                 },
                 id: null
             }));
@@ -49867,9 +49965,14 @@ class StreamableHTTPServerTransport {
         // Assign the response to the standalone SSE stream
         this._streamMapping.set(this._standaloneSseStreamId, res);
         // Set up close handler for client disconnects
-        res.on("close", () => {
+        res.on('close', () => {
             this._streamMapping.delete(this._standaloneSseStreamId);
         });
+        // Add error handler for standalone SSE stream
+        res.on('error', error => {
+            var _a;
+            (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+        });
     }
     /**
      * Replays events that would have been sent after the specified event ID
@@ -49882,24 +49985,29 @@ class StreamableHTTPServerTransport {
         }
         try {
             const headers = {
-                "Content-Type": "text/event-stream",
-                "Cache-Control": "no-cache, no-transform",
-                Connection: "keep-alive",
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache, no-transform',
+                Connection: 'keep-alive'
             };
             if (this.sessionId !== undefined) {
-                headers["mcp-session-id"] = this.sessionId;
+                headers['mcp-session-id'] = this.sessionId;
             }
             res.writeHead(200, headers).flushHeaders();
             const streamId = await ((_a = this._eventStore) === null || _a === void 0 ? void 0 : _a.replayEventsAfter(lastEventId, {
                 send: async (eventId, message) => {
                     var _a;
                     if (!this.writeSSEEvent(res, message, eventId)) {
-                        (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, new Error("Failed replay events"));
+                        (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, new Error('Failed replay events'));
                         res.end();
                     }
                 }
             }));
             this._streamMapping.set(streamId, res);
+            // Add error handler for replay stream
+            res.on('error', error => {
+                var _a;
+                (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+            });
         }
         catch (error) {
             (_b = this.onerror) === null || _b === void 0 ? void 0 : _b.call(this, error);
@@ -49922,12 +50030,12 @@ class StreamableHTTPServerTransport {
      */
     async handleUnsupportedRequest(res) {
         res.writeHead(405, {
-            "Allow": "GET, POST, DELETE"
+            Allow: 'GET, POST, DELETE'
         }).end(JSON.stringify({
-            jsonrpc: "2.0",
+            jsonrpc: '2.0',
             error: {
                 code: -32e3,
-                message: "Method not allowed."
+                message: 'Method not allowed.'
             },
             id: null
         }));
@@ -49941,24 +50049,24 @@ class StreamableHTTPServerTransport {
             // Validate the Accept header
             const acceptHeader = req.headers.accept;
             // The client MUST include an Accept header, listing both application/json and text/event-stream as supported content types.
-            if (!(acceptHeader === null || acceptHeader === void 0 ? void 0 : acceptHeader.includes("application/json")) || !acceptHeader.includes("text/event-stream")) {
+            if (!(acceptHeader === null || acceptHeader === void 0 ? void 0 : acceptHeader.includes('application/json')) || !acceptHeader.includes('text/event-stream')) {
                 res.writeHead(406).end(JSON.stringify({
-                    jsonrpc: "2.0",
+                    jsonrpc: '2.0',
                     error: {
                         code: -32000,
-                        message: "Not Acceptable: Client must accept both application/json and text/event-stream"
+                        message: 'Not Acceptable: Client must accept both application/json and text/event-stream'
                     },
                     id: null
                 }));
                 return;
             }
-            const ct = req.headers["content-type"];
-            if (!ct || !ct.includes("application/json")) {
+            const ct = req.headers['content-type'];
+            if (!ct || !ct.includes('application/json')) {
                 res.writeHead(415).end(JSON.stringify({
-                    jsonrpc: "2.0",
+                    jsonrpc: '2.0',
                     error: {
                         code: -32000,
-                        message: "Unsupported Media Type: Content-Type must be application/json"
+                        message: 'Unsupported Media Type: Content-Type must be application/json'
                     },
                     id: null
                 }));
@@ -49974,7 +50082,7 @@ class StreamableHTTPServerTransport {
                 const parsedCt = contentType.parse(ct);
                 const body = await getRawBody(req, {
                     limit: MAXIMUM_MESSAGE_SIZE,
-                    encoding: (_a = parsedCt.parameters.charset) !== null && _a !== void 0 ? _a : "utf-8",
+                    encoding: (_a = parsedCt.parameters.charset) !== null && _a !== void 0 ? _a : 'utf-8'
                 });
                 rawMessage = JSON.parse(body.toString());
             }
@@ -49994,10 +50102,10 @@ class StreamableHTTPServerTransport {
                 // to avoid re-initialization.
                 if (this._initialized && this.sessionId !== undefined) {
                     res.writeHead(400).end(JSON.stringify({
-                        jsonrpc: "2.0",
+                        jsonrpc: '2.0',
                         error: {
                             code: -32600,
-                            message: "Invalid Request: Server already initialized"
+                            message: 'Invalid Request: Server already initialized'
                         },
                         id: null
                     }));
@@ -50005,10 +50113,10 @@ class StreamableHTTPServerTransport {
                 }
                 if (messages.length > 1) {
                     res.writeHead(400).end(JSON.stringify({
-                        jsonrpc: "2.0",
+                        jsonrpc: '2.0',
                         error: {
                             code: -32600,
-                            message: "Invalid Request: Only one initialization request is allowed"
+                            message: 'Invalid Request: Only one initialization request is allowed'
                         },
                         id: null
                     }));
@@ -50024,7 +50132,7 @@ class StreamableHTTPServerTransport {
             }
             if (!isInitializationRequest) {
                 // If an Mcp-Session-Id is returned by the server during initialization,
-                // clients using the Streamable HTTP transport MUST include it 
+                // clients using the Streamable HTTP transport MUST include it
                 // in the Mcp-Session-Id header on all of their subsequent HTTP requests.
                 if (!this.validateSession(req, res)) {
                     return;
@@ -50050,13 +50158,13 @@ class StreamableHTTPServerTransport {
                 const streamId = randomUUID();
                 if (!this._enableJsonResponse) {
                     const headers = {
-                        "Content-Type": "text/event-stream",
-                        "Cache-Control": "no-cache",
-                        Connection: "keep-alive",
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                        Connection: 'keep-alive'
                     };
                     // After initialization, always include the session ID if we have one
                     if (this.sessionId !== undefined) {
-                        headers["mcp-session-id"] = this.sessionId;
+                        headers['mcp-session-id'] = this.sessionId;
                     }
                     res.writeHead(200, headers);
                 }
@@ -50069,9 +50177,14 @@ class StreamableHTTPServerTransport {
                     }
                 }
                 // Set up close handler for client disconnects
-                res.on("close", () => {
+                res.on('close', () => {
                     this._streamMapping.delete(streamId);
                 });
+                // Add error handler for stream write errors
+                res.on('error', error => {
+                    var _a;
+                    (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+                });
                 // handle each message
                 for (const message of messages) {
                     (_d = this.onmessage) === null || _d === void 0 ? void 0 : _d.call(this, message, { authInfo, requestInfo });
@@ -50083,10 +50196,10 @@ class StreamableHTTPServerTransport {
         catch (error) {
             // return JSON-RPC formatted error
             res.writeHead(400).end(JSON.stringify({
-                jsonrpc: "2.0",
+                jsonrpc: '2.0',
                 error: {
                     code: -32700,
-                    message: "Parse error",
+                    message: 'Parse error',
                     data: String(error)
                 },
                 id: null
@@ -50122,23 +50235,23 @@ class StreamableHTTPServerTransport {
         if (!this._initialized) {
             // If the server has not been initialized yet, reject all requests
             res.writeHead(400).end(JSON.stringify({
-                jsonrpc: "2.0",
+                jsonrpc: '2.0',
                 error: {
                     code: -32e3,
-                    message: "Bad Request: Server not initialized"
+                    message: 'Bad Request: Server not initialized'
                 },
                 id: null
             }));
             return false;
         }
-        const sessionId = req.headers["mcp-session-id"];
+        const sessionId = req.headers['mcp-session-id'];
         if (!sessionId) {
             // Non-initialization requests without a session ID should return 400 Bad Request
             res.writeHead(400).end(JSON.stringify({
-                jsonrpc: "2.0",
+                jsonrpc: '2.0',
                 error: {
                     code: -32e3,
-                    message: "Bad Request: Mcp-Session-Id header is required"
+                    message: 'Bad Request: Mcp-Session-Id header is required'
                 },
                 id: null
             }));
@@ -50146,10 +50259,10 @@ class StreamableHTTPServerTransport {
         }
         else if (Array.isArray(sessionId)) {
             res.writeHead(400).end(JSON.stringify({
-                jsonrpc: "2.0",
+                jsonrpc: '2.0',
                 error: {
                     code: -32e3,
-                    message: "Bad Request: Mcp-Session-Id header must be a single value"
+                    message: 'Bad Request: Mcp-Session-Id header must be a single value'
                 },
                 id: null
             }));
@@ -50158,10 +50271,10 @@ class StreamableHTTPServerTransport {
         else if (sessionId !== this.sessionId) {
             // Reject requests with invalid session ID with 404 Not Found
             res.writeHead(404).end(JSON.stringify({
-                jsonrpc: "2.0",
+                jsonrpc: '2.0',
                 error: {
                     code: -32001,
-                    message: "Session not found"
+                    message: 'Session not found'
                 },
                 id: null
             }));
@@ -50171,16 +50284,16 @@ class StreamableHTTPServerTransport {
     }
     validateProtocolVersion(req, res) {
         var _a;
-        let protocolVersion = (_a = req.headers["mcp-protocol-version"]) !== null && _a !== void 0 ? _a : DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
+        let protocolVersion = (_a = req.headers['mcp-protocol-version']) !== null && _a !== void 0 ? _a : DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
         if (Array.isArray(protocolVersion)) {
             protocolVersion = protocolVersion[protocolVersion.length - 1];
         }
         if (!SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {
             res.writeHead(400).end(JSON.stringify({
-                jsonrpc: "2.0",
+                jsonrpc: '2.0',
                 error: {
                     code: -32e3,
-                    message: `Bad Request: Unsupported protocol version (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`
+                    message: `Bad Request: Unsupported protocol version (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(', ')})`
                 },
                 id: null
             }));
@@ -50191,7 +50304,7 @@ class StreamableHTTPServerTransport {
     async close() {
         var _a;
         // Close all SSE connections
-        this._streamMapping.forEach((response) => {
+        this._streamMapping.forEach(response => {
             response.end();
         });
         this._streamMapping.clear();
@@ -50211,7 +50324,7 @@ class StreamableHTTPServerTransport {
         if (requestId === undefined) {
             // For standalone SSE streams, we can only send requests and notifications
             if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
-                throw new Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");
+                throw new Error('Cannot send a response on a standalone SSE stream unless resuming a previous client request');
             }
             const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId);
             if (standaloneSse === undefined) {
@@ -50259,13 +50372,12 @@ class StreamableHTTPServerTransport {
                 if (this._enableJsonResponse) {
                     // All responses ready, send as JSON
                     const headers = {
-                        'Content-Type': 'application/json',
+                        'Content-Type': 'application/json'
                     };
                     if (this.sessionId !== undefined) {
                         headers['mcp-session-id'] = this.sessionId;
                     }
-                    const responses = relatedIds
-                        .map(id => this._requestResponseMap.get(id));
+                    const responses = relatedIds.map(id => this._requestResponseMap.get(id));
                     response.writeHead(200, headers);
                     if (responses.length === 1) {
                         response.end(JSON.stringify(responses[0]));