@frontmcp/sdk 0.4.1 → 0.5.1

package/src/transport/mcp-handlers/list-tools-request.handler.d.ts

@@ -2,54 +2,39 @@ import { ListToolsRequest } from '@modelcontextprotocol/sdk/types.js';
 import { McpHandlerOptions } from './mcp-handlers.types';
 export default function ListToolsRequestHandler({ scope, }: McpHandlerOptions): {
     requestSchema: import("zod").ZodObject<{
-        params: import("zod").ZodOptional<import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+        params: import("zod").ZodOptional<import("zod").ZodObject<{
+            task: import("zod").ZodOptional<import("zod").ZodObject<{
+                ttl: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodNull]>>;
+                pollInterval: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$loose>>;
             _meta: import("zod").ZodOptional<import("zod").ZodObject<{
-                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
-            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
-                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
-            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
-                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
-            }, import("zod").ZodTypeAny, "passthrough">>>;
-        }, {
+                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                "io.modelcontextprotocol/related-task": import("zod").ZodOptional<import("zod").ZodObject<{
+                    taskId: import("zod").ZodString;
+                }, import("zod/v4/core").$loose>>;
+            }, import("zod/v4/core").$loose>>;
             cursor: import("zod").ZodOptional<import("zod").ZodString>;
-        }>, "strip", import("zod").ZodTypeAny, {
-            _meta?: import("zod").objectOutputType<{
-                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
-            }, import("zod").ZodTypeAny, "passthrough"> | undefined;
-            cursor?: string | undefined;
-        }, {
-            _meta?: import("zod").objectInputType<{
-                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
-            }, import("zod").ZodTypeAny, "passthrough"> | undefined;
-            cursor?: string | undefined;
-        }>>;
-    } & {
+        }, import("zod/v4/core").$loose>>;
         method: import("zod").ZodLiteral<"tools/list">;
-    }, "strip", import("zod").ZodTypeAny, {
-        method: "tools/list";
-        params?: {
-            _meta?: import("zod").objectOutputType<{
-                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
-            }, import("zod").ZodTypeAny, "passthrough"> | undefined;
-            cursor?: string | undefined;
-        } | undefined;
-    }, {
-        method: "tools/list";
-        params?: {
-            _meta?: import("zod").objectInputType<{
-                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>>;
-            }, import("zod").ZodTypeAny, "passthrough"> | undefined;
-            cursor?: string | undefined;
-        } | undefined;
-    }>;
+    }, import("zod/v4/core").$strip>;
     handler: (request: ListToolsRequest, ctx: import("./mcp-handlers.types").McpRequestHandler<{
         method: "tools/list";
         params?: {
+            [x: string]: unknown;
+            task?: {
+                [x: string]: unknown;
+                ttl?: number | null | undefined;
+                pollInterval?: number | undefined;
+            } | undefined;
             _meta?: {
                 [x: string]: unknown;
                 progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    [x: string]: unknown;
+                    taskId: string;
+                } | undefined;
             } | undefined;
-            cursor?: string | undefined | undefined;
+            cursor?: string | undefined;
         } | undefined;
     }, {
         method: string;
@@ -57,101 +42,28 @@ export default function ListToolsRequestHandler({ scope, }: McpHandlerOptions):
             [x: string]: unknown;
             _meta?: {
                 [x: string]: unknown;
+                "io.modelcontextprotocol/related-task"?: {
+                    [x: string]: unknown;
+                    taskId: string;
+                } | undefined;
             } | undefined;
         } | undefined;
-    }>) => Promise<import("zod").objectOutputType<{
-        _meta: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
-    } & {
-        nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
-    } & {
-        tools: import("zod").ZodArray<import("zod").ZodObject<import("zod").objectUtil.extendShape<import("zod").objectUtil.extendShape<{
-            name: import("zod").ZodString;
-            title: import("zod").ZodOptional<import("zod").ZodString>;
-        }, {
-            description: import("zod").ZodOptional<import("zod").ZodString>;
-            inputSchema: import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"object">;
-                properties: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<object, import("zod").ZodTypeDef, object>>>;
-                required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
-            }, "strip", import("zod").ZodTypeAny, {
-                type: "object";
-                required?: string[] | undefined;
-                properties?: Record<string, object> | undefined;
-            }, {
-                type: "object";
-                required?: string[] | undefined;
-                properties?: Record<string, object> | undefined;
-            }>;
-            outputSchema: import("zod").ZodOptional<import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"object">;
-                properties: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<object, import("zod").ZodTypeDef, object>>>;
-                required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
-                additionalProperties: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            }, "strip", import("zod").ZodTypeAny, {
-                type: "object";
-                required?: string[] | undefined;
-                properties?: Record<string, object> | undefined;
-                additionalProperties?: boolean | undefined;
-            }, {
-                type: "object";
-                required?: string[] | undefined;
-                properties?: Record<string, object> | undefined;
-                additionalProperties?: boolean | undefined;
-            }>>;
-            annotations: import("zod").ZodOptional<import("zod").ZodObject<{
-                title: import("zod").ZodOptional<import("zod").ZodString>;
-                readOnlyHint: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                destructiveHint: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                idempotentHint: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                openWorldHint: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            }, "strip", import("zod").ZodTypeAny, {
-                title?: string | undefined;
-                readOnlyHint?: boolean | undefined;
-                destructiveHint?: boolean | undefined;
-                idempotentHint?: boolean | undefined;
-                openWorldHint?: boolean | undefined;
-            }, {
-                title?: string | undefined;
-                readOnlyHint?: boolean | undefined;
-                destructiveHint?: boolean | undefined;
-                idempotentHint?: boolean | undefined;
-                openWorldHint?: boolean | undefined;
-            }>>;
-            _meta: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
-        }>, {
-            icons: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-                src: import("zod").ZodString;
-                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
-                sizes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
-            }, "strip", import("zod").ZodTypeAny, {
-                src: string;
-                mimeType?: string | undefined;
-                sizes?: string[] | undefined;
-            }, {
-                src: string;
-                mimeType?: string | undefined;
-                sizes?: string[] | undefined;
-            }>, "many">>;
-        }>, "strip", import("zod").ZodTypeAny, {
-            name: string;
+    }>) => Promise<{
+        [x: string]: unknown;
+        tools: {
             inputSchema: {
+                [x: string]: unknown;
                 type: "object";
-                required?: string[] | undefined;
                 properties?: Record<string, object> | undefined;
+                required?: string[] | undefined;
             };
-            _meta?: Record<string, unknown> | undefined;
-            icons?: {
-                src: string;
-                mimeType?: string | undefined;
-                sizes?: string[] | undefined;
-            }[] | undefined;
-            title?: string | undefined;
+            name: string;
             description?: string | undefined;
             outputSchema?: {
+                [x: string]: unknown;
                 type: "object";
-                required?: string[] | undefined;
                 properties?: Record<string, object> | undefined;
-                additionalProperties?: boolean | undefined;
+                required?: string[] | undefined;
             } | undefined;
             annotations?: {
                 title?: string | undefined;
@@ -160,13 +72,9 @@ export default function ListToolsRequestHandler({ scope, }: McpHandlerOptions):
                 idempotentHint?: boolean | undefined;
                 openWorldHint?: boolean | undefined;
             } | undefined;
-        }, {
-            name: string;
-            inputSchema: {
-                type: "object";
-                required?: string[] | undefined;
-                properties?: Record<string, object> | undefined;
-            };
+            execution?: {
+                taskSupport?: "optional" | "required" | "forbidden" | undefined;
+            } | undefined;
             _meta?: Record<string, unknown> | undefined;
             icons?: {
                 src: string;
@@ -174,20 +82,14 @@ export default function ListToolsRequestHandler({ scope, }: McpHandlerOptions):
                 sizes?: string[] | undefined;
             }[] | undefined;
             title?: string | undefined;
-            description?: string | undefined;
-            outputSchema?: {
-                type: "object";
-                required?: string[] | undefined;
-                properties?: Record<string, object> | undefined;
-                additionalProperties?: boolean | undefined;
-            } | undefined;
-            annotations?: {
-                title?: string | undefined;
-                readOnlyHint?: boolean | undefined;
-                destructiveHint?: boolean | undefined;
-                idempotentHint?: boolean | undefined;
-                openWorldHint?: boolean | undefined;
+        }[];
+        _meta?: {
+            [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
             } | undefined;
-        }>, "many">;
-    }, import("zod").ZodTypeAny, "passthrough">>;
+        } | undefined;
+        nextCursor?: string | undefined;
+    }>;
 };

package/src/transport/mcp-handlers/logging-set-level-request.handler.d.ts

@@ -0,0 +1,66 @@
+import { SetLevelRequest, EmptyResult } from '@modelcontextprotocol/sdk/types.js';
+import { McpHandlerOptions } from './mcp-handlers.types';
+/**
+ * Handler for the logging/setLevel MCP request.
+ * Per MCP 2025-11-25 spec, this allows clients to set the minimum log level
+ * for log messages sent via notifications/message.
+ */
+export default function LoggingSetLevelRequestHandler({ scope }: McpHandlerOptions): {
+    requestSchema: import("zod").ZodObject<{
+        method: import("zod").ZodLiteral<"logging/setLevel">;
+        params: import("zod").ZodObject<{
+            task: import("zod").ZodOptional<import("zod").ZodObject<{
+                ttl: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodNull]>>;
+                pollInterval: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$loose>>;
+            _meta: import("zod").ZodOptional<import("zod").ZodObject<{
+                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                "io.modelcontextprotocol/related-task": import("zod").ZodOptional<import("zod").ZodObject<{
+                    taskId: import("zod").ZodString;
+                }, import("zod/v4/core").$loose>>;
+            }, import("zod/v4/core").$loose>>;
+            level: import("zod").ZodEnum<{
+                error: "error";
+                debug: "debug";
+                info: "info";
+                notice: "notice";
+                warning: "warning";
+                critical: "critical";
+                alert: "alert";
+                emergency: "emergency";
+            }>;
+        }, import("zod/v4/core").$loose>;
+    }, import("zod/v4/core").$strip>;
+    handler: (request: SetLevelRequest, ctx: import("./mcp-handlers.types").McpRequestHandler<{
+        method: "logging/setLevel";
+        params: {
+            [x: string]: unknown;
+            level: "error" | "debug" | "info" | "warning" | "notice" | "critical" | "alert" | "emergency";
+            task?: {
+                [x: string]: unknown;
+                ttl?: number | null | undefined;
+                pollInterval?: number | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    [x: string]: unknown;
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        };
+    }, {
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                "io.modelcontextprotocol/related-task"?: {
+                    [x: string]: unknown;
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }>) => Promise<EmptyResult>;
+};

package/src/transport/mcp-handlers/logging-set-level-request.handler.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = LoggingSetLevelRequestHandler;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+/**
+ * Handler for the logging/setLevel MCP request.
+ * Per MCP 2025-11-25 spec, this allows clients to set the minimum log level
+ * for log messages sent via notifications/message.
+ */
+function LoggingSetLevelRequestHandler({ scope }) {
+    return {
+        requestSchema: types_js_1.SetLevelRequestSchema,
+        handler: async (request, ctx) => {
+            const { level } = request.params;
+            // Get session ID from auth context
+            const sessionId = ctx.authInfo?.sessionId;
+            if (!sessionId) {
+                scope.logger.warn('logging/setLevel: No session ID found in request context');
+                return {};
+            }
+            // Set the log level for this session
+            const success = scope.notifications.setLogLevel(sessionId, level);
+            if (!success) {
+                scope.logger.warn(`logging/setLevel: Failed to set log level for session ${sessionId.slice(0, 20)}...`);
+            }
+            else {
+                scope.logger.verbose(`logging/setLevel: Set level to '${level}' for session ${sessionId.slice(0, 20)}...`);
+            }
+            // Per MCP spec, return empty result
+            return {};
+        },
+    };
+}
+//# sourceMappingURL=logging-set-level-request.handler.js.map

package/src/transport/mcp-handlers/logging-set-level-request.handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging-set-level-request.handler.js","sourceRoot":"","sources":["../../../../src/transport/mcp-handlers/logging-set-level-request.handler.ts"],"names":[],"mappings":";;AAQA,gDA0BC;AAlCD,iEAAyG;AAGzG;;;;GAIG;AACH,SAAwB,6BAA6B,CAAC,EAAE,KAAK,EAAqB;IAChF,OAAO;QACL,aAAa,EAAE,gCAAqB;QACpC,OAAO,EAAE,KAAK,EAAE,OAAwB,EAAE,GAAG,EAAwB,EAAE;YACrE,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;YAEjC,mCAAmC;YACnC,MAAM,SAAS,GAAG,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC;YAC1C,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,0DAA0D,CAAC,CAAC;gBAC9E,OAAO,EAAE,CAAC;YACZ,CAAC;YAED,qCAAqC;YACrC,MAAM,OAAO,GAAG,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;YAElE,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,yDAAyD,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;YAC1G,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,mCAAmC,KAAK,iBAAiB,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;YAC7G,CAAC;YAED,oCAAoC;YACpC,OAAO,EAAE,CAAC;QACZ,CAAC;KACiD,CAAC;AACvD,CAAC","sourcesContent":["import { SetLevelRequestSchema, SetLevelRequest, EmptyResult } from '@modelcontextprotocol/sdk/types.js';\nimport { McpHandler, McpHandlerOptions } from './mcp-handlers.types';\n\n/**\n * Handler for the logging/setLevel MCP request.\n * Per MCP 2025-11-25 spec, this allows clients to set the minimum log level\n * for log messages sent via notifications/message.\n */\nexport default function LoggingSetLevelRequestHandler({ scope }: McpHandlerOptions) {\n  return {\n    requestSchema: SetLevelRequestSchema,\n    handler: async (request: SetLevelRequest, ctx): Promise<EmptyResult> => {\n      const { level } = request.params;\n\n      // Get session ID from auth context\n      const sessionId = ctx.authInfo?.sessionId;\n      if (!sessionId) {\n        scope.logger.warn('logging/setLevel: No session ID found in request context');\n        return {};\n      }\n\n      // Set the log level for this session\n      const success = scope.notifications.setLogLevel(sessionId, level);\n\n      if (!success) {\n        scope.logger.warn(`logging/setLevel: Failed to set log level for session ${sessionId.slice(0, 20)}...`);\n      } else {\n        scope.logger.verbose(`logging/setLevel: Set level to '${level}' for session ${sessionId.slice(0, 20)}...`);\n      }\n\n      // Per MCP spec, return empty result\n      return {};\n    },\n  } satisfies McpHandler<SetLevelRequest, EmptyResult>;\n}\n"]}

package/src/transport/mcp-handlers/mcp-handlers.types.d.ts

@@ -1,4 +1,4 @@
-import { z, ZodTypeAny, ZodObject, ZodLiteral } from 'zod';
+import { z, ZodType } from 'zod';
 import { Notification, Request, Result } from '@modelcontextprotocol/sdk/types.js';
 import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';
@@ -10,12 +10,8 @@ type Primitive = string | number | boolean | bigint | null | undefined;
 type Flatten<T> = T extends Primitive ? T : T extends Array<infer U> ? Array<Flatten<U>> : T extends Set<infer U> ? Set<Flatten<U>> : T extends Map<infer K, infer V> ? Map<Flatten<K>, Flatten<V>> : T extends object ? {
     [K in keyof T]: Flatten<T[K]>;
 } : T;
-type Infer<Schema extends ZodTypeAny> = Flatten<z.infer<Schema>>;
-export interface McpHandler<HandlerRequest extends Request = Request, HandlerResult extends Result = Result, In extends ZodObject<{
-    method: ZodLiteral<string>;
-}> = ZodObject<{
-    method: ZodLiteral<string>;
-}>, Out extends ZodObject<any> = ZodObject<any>, HandlerNotification extends Notification = Notification> {
+type Infer<Schema extends ZodType> = Flatten<z.infer<Schema>>;
+export interface McpHandler<HandlerRequest extends Request = Request, HandlerResult extends Result = Result, In extends z.ZodObject<any> = z.ZodObject<any>, Out extends z.ZodObject<any> = z.ZodObject<any>, HandlerNotification extends Notification = Notification> {
     when?: (request: Infer<In>) => boolean;
     requestSchema: In;
     responseSchema?: Out;

package/src/transport/mcp-handlers/mcp-handlers.types.js.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-handlers.types.js","sourceRoot":"","sources":["../../../../src/transport/mcp-handlers/mcp-handlers.types.ts"],"names":[],"mappings":"","sourcesContent":["import { z, ZodTypeAny, ZodObject, ZodLiteral } from 'zod';\nimport { Notification, Request, Result } from '@modelcontextprotocol/sdk/types.js';\nimport { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';\nimport { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';\nimport { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';\nimport { LocalTransporter } from '../transport.local';\nimport { Authorization } from '../../common';\nimport { Scope } from '../../scope';\n\ntype Primitive = string | number | boolean | bigint | null | undefined;\ntype Flatten<T> = T extends Primitive\n  ? T\n  : T extends Array<infer U>\n  ? Array<Flatten<U>>\n  : T extends Set<infer U>\n  ? Set<Flatten<U>>\n  : T extends Map<infer K, infer V>\n  ? Map<Flatten<K>, Flatten<V>>\n  : T extends object\n  ? {\n      [K in keyof T]: Flatten<T[K]>;\n    }\n  : T;\ntype Infer<Schema extends ZodTypeAny> = Flatten<z.infer<Schema>>;\n\nexport interface McpHandler<\n  HandlerRequest extends Request = Request,\n  HandlerResult extends Result = Result,\n  In extends ZodObject<{ method: ZodLiteral<string> }> = ZodObject<{ method: ZodLiteral<string> }>,\n  Out extends ZodObject<any> = ZodObject<any>,\n  HandlerNotification extends Notification = Notification,\n> {\n  when?: (request: Infer<In>) => boolean;\n  requestSchema: In;\n  responseSchema?: Out;\n\n  handler: (\n    request: HandlerRequest,\n    ctx: McpRequestHandler<HandlerRequest, HandlerNotification>,\n  ) => Promise<HandlerResult> | HandlerResult;\n}\n\nexport type McpHandlerOptions = {\n  scope: Scope;\n  serverOptions: ServerOptions;\n};\n\nexport type McpRequestHandler<\n  SendRequestT extends Request,\n  SendNotificationT extends Notification,\n> = RequestHandlerExtra<SendRequestT, SendNotificationT> & {\n  authInfo?: AuthInfo & {\n    extra?: {\n      [key: string]: unknown;\n      transport: LocalTransporter;\n      authSession: Authorization;\n    };\n  };\n};\n"]}
+{"version":3,"file":"mcp-handlers.types.js","sourceRoot":"","sources":["../../../../src/transport/mcp-handlers/mcp-handlers.types.ts"],"names":[],"mappings":"","sourcesContent":["import { z, ZodType, ZodLiteral } from 'zod';\nimport { Notification, Request, Result } from '@modelcontextprotocol/sdk/types.js';\nimport { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';\nimport { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';\nimport { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';\nimport { LocalTransporter } from '../transport.local';\nimport { Authorization } from '../../common';\nimport { Scope } from '../../scope';\n\ntype Primitive = string | number | boolean | bigint | null | undefined;\ntype Flatten<T> = T extends Primitive\n  ? T\n  : T extends Array<infer U>\n  ? Array<Flatten<U>>\n  : T extends Set<infer U>\n  ? Set<Flatten<U>>\n  : T extends Map<infer K, infer V>\n  ? Map<Flatten<K>, Flatten<V>>\n  : T extends object\n  ? {\n      [K in keyof T]: Flatten<T[K]>;\n    }\n  : T;\ntype Infer<Schema extends ZodType> = Flatten<z.infer<Schema>>;\n\nexport interface McpHandler<\n  HandlerRequest extends Request = Request,\n  HandlerResult extends Result = Result,\n  In extends z.ZodObject<any> = z.ZodObject<any>,\n  Out extends z.ZodObject<any> = z.ZodObject<any>,\n  HandlerNotification extends Notification = Notification,\n> {\n  when?: (request: Infer<In>) => boolean;\n  requestSchema: In;\n  responseSchema?: Out;\n\n  handler: (\n    request: HandlerRequest,\n    ctx: McpRequestHandler<HandlerRequest, HandlerNotification>,\n  ) => Promise<HandlerResult> | HandlerResult;\n}\n\nexport type McpHandlerOptions = {\n  scope: Scope;\n  serverOptions: ServerOptions;\n};\n\nexport type McpRequestHandler<\n  SendRequestT extends Request,\n  SendNotificationT extends Notification,\n> = RequestHandlerExtra<SendRequestT, SendNotificationT> & {\n  authInfo?: AuthInfo & {\n    extra?: {\n      [key: string]: unknown;\n      transport: LocalTransporter;\n      authSession: Authorization;\n    };\n  };\n};\n"]}

package/src/transport/mcp-handlers/read-resource-request.handler.d.ts

@@ -0,0 +1,72 @@
+import { ReadResourceRequest } from '@modelcontextprotocol/sdk/types.js';
+import { McpHandlerOptions } from './mcp-handlers.types';
+export default function readResourceRequestHandler({ scope }: McpHandlerOptions): {
+    requestSchema: import("zod").ZodObject<{
+        method: import("zod").ZodLiteral<"resources/read">;
+        params: import("zod").ZodObject<{
+            task: import("zod").ZodOptional<import("zod").ZodObject<{
+                ttl: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodNull]>>;
+                pollInterval: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$loose>>;
+            _meta: import("zod").ZodOptional<import("zod").ZodObject<{
+                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                "io.modelcontextprotocol/related-task": import("zod").ZodOptional<import("zod").ZodObject<{
+                    taskId: import("zod").ZodString;
+                }, import("zod/v4/core").$loose>>;
+            }, import("zod/v4/core").$loose>>;
+            uri: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+    }, import("zod/v4/core").$strip>;
+    handler: (request: ReadResourceRequest, ctx: import("./mcp-handlers.types").McpRequestHandler<{
+        method: "resources/read";
+        params: {
+            [x: string]: unknown;
+            uri: string;
+            task?: {
+                [x: string]: unknown;
+                ttl?: number | null | undefined;
+                pollInterval?: number | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    [x: string]: unknown;
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        };
+    }, {
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                "io.modelcontextprotocol/related-task"?: {
+                    [x: string]: unknown;
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }>) => Promise<{
+        [x: string]: unknown;
+        contents: ({
+            uri: string;
+            text: string;
+            mimeType?: string | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            uri: string;
+            blob: string;
+            mimeType?: string | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        })[];
+        _meta?: {
+            [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+};

package/src/transport/mcp-handlers/read-resource-request.handler.js

@@ -0,0 +1,12 @@
+"use strict";
+// file: libs/sdk/src/transport/mcp-handlers/read-resource-request.handler.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = readResourceRequestHandler;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+function readResourceRequestHandler({ scope }) {
+    return {
+        requestSchema: types_js_1.ReadResourceRequestSchema,
+        handler: (request, ctx) => scope.runFlowForOutput('resources:read-resource', { request, ctx }),
+    };
+}
+//# sourceMappingURL=read-resource-request.handler.js.map

package/src/transport/mcp-handlers/read-resource-request.handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-resource-request.handler.js","sourceRoot":"","sources":["../../../../src/transport/mcp-handlers/read-resource-request.handler.ts"],"names":[],"mappings":";AAAA,6EAA6E;;AAK7E,6CAKC;AARD,iEAAwH;AAGxH,SAAwB,0BAA0B,CAAC,EAAE,KAAK,EAAqB;IAC7E,OAAO;QACL,aAAa,EAAE,oCAAyB;QACxC,OAAO,EAAE,CAAC,OAA4B,EAAE,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,gBAAgB,CAAC,yBAAyB,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC;KACtD,CAAC;AAClE,CAAC","sourcesContent":["// file: libs/sdk/src/transport/mcp-handlers/read-resource-request.handler.ts\n\nimport { ReadResourceRequestSchema, ReadResourceRequest, ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';\nimport { McpHandler, McpHandlerOptions } from './mcp-handlers.types';\n\nexport default function readResourceRequestHandler({ scope }: McpHandlerOptions) {\n  return {\n    requestSchema: ReadResourceRequestSchema,\n    handler: (request: ReadResourceRequest, ctx) => scope.runFlowForOutput('resources:read-resource', { request, ctx }),\n  } satisfies McpHandler<ReadResourceRequest, ReadResourceResult>;\n}\n"]}

package/src/transport/mcp-handlers/roots-list-changed-notification.handler.d.ts

@@ -0,0 +1,11 @@
+import { Result } from '@modelcontextprotocol/sdk/types.js';
+import { McpHandler, McpHandlerOptions } from './mcp-handlers.types';
+import type { RootsListChangedNotification } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Handler for `notifications/roots/list_changed` notification from the client.
+ *
+ * Per MCP 2025-11-25 spec, this notification is sent by clients that support
+ * roots to indicate that the list of roots has changed. When received, the
+ * server should invalidate any cached roots and optionally re-fetch them.
+ */
+export default function rootsListChangedNotificationHandler({ scope, }: McpHandlerOptions): McpHandler<RootsListChangedNotification, Result>;

package/src/transport/mcp-handlers/roots-list-changed-notification.handler.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rootsListChangedNotificationHandler;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+/**
+ * Handler for `notifications/roots/list_changed` notification from the client.
+ *
+ * Per MCP 2025-11-25 spec, this notification is sent by clients that support
+ * roots to indicate that the list of roots has changed. When received, the
+ * server should invalidate any cached roots and optionally re-fetch them.
+ */
+function rootsListChangedNotificationHandler({ scope, }) {
+    return {
+        requestSchema: types_js_1.RootsListChangedNotificationSchema,
+        handler: async (request, ctx) => {
+            const sessionId = ctx.authInfo?.sessionId;
+            if (sessionId) {
+                // Invalidate cached roots for this session
+                scope.notifications.invalidateRootsCache(sessionId);
+            }
+            // Notifications don't return a response body
+            return {};
+        },
+    };
+}
+//# sourceMappingURL=roots-list-changed-notification.handler.js.map

package/src/transport/mcp-handlers/roots-list-changed-notification.handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"roots-list-changed-notification.handler.js","sourceRoot":"","sources":["../../../../src/transport/mcp-handlers/roots-list-changed-notification.handler.ts"],"names":[],"mappings":";;AAWA,sDAeC;AA1BD,iEAAgG;AAIhG;;;;;;GAMG;AACH,SAAwB,mCAAmC,CAAC,EAC1D,KAAK,GACa;IAClB,OAAO;QACL,aAAa,EAAE,6CAAkC;QACjD,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAmB,EAAE;YAC/C,MAAM,SAAS,GAAG,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC;YAC1C,IAAI,SAAS,EAAE,CAAC;gBACd,2CAA2C;gBAC3C,KAAK,CAAC,aAAa,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAC;YACtD,CAAC;YACD,6CAA6C;YAC7C,OAAO,EAAE,CAAC;QACZ,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { RootsListChangedNotificationSchema, Result } from '@modelcontextprotocol/sdk/types.js';\nimport { McpHandler, McpHandlerOptions } from './mcp-handlers.types';\nimport type { RootsListChangedNotification } from '@modelcontextprotocol/sdk/types.js';\n\n/**\n * Handler for `notifications/roots/list_changed` notification from the client.\n *\n * Per MCP 2025-11-25 spec, this notification is sent by clients that support\n * roots to indicate that the list of roots has changed. When received, the\n * server should invalidate any cached roots and optionally re-fetch them.\n */\nexport default function rootsListChangedNotificationHandler({\n  scope,\n}: McpHandlerOptions): McpHandler<RootsListChangedNotification, Result> {\n  return {\n    requestSchema: RootsListChangedNotificationSchema,\n    handler: async (request, ctx): Promise<Result> => {\n      const sessionId = ctx.authInfo?.sessionId;\n      if (sessionId) {\n        // Invalidate cached roots for this session\n        scope.notifications.invalidateRootsCache(sessionId);\n      }\n      // Notifications don't return a response body\n      return {};\n    },\n  };\n}\n"]}

package/src/transport/mcp-handlers/subscribe-request.handler.d.ts

@@ -0,0 +1,57 @@
+import { SubscribeRequest, EmptyResult } from '@modelcontextprotocol/sdk/types.js';
+import { McpHandlerOptions } from './mcp-handlers.types';
+/**
+ * Handler for the resources/subscribe MCP request.
+ * Per MCP 2025-11-25 spec, this allows clients to subscribe to receive
+ * notifications when a specific resource changes.
+ */
+export default function SubscribeRequestHandler({ scope }: McpHandlerOptions): {
+    requestSchema: import("zod").ZodObject<{
+        method: import("zod").ZodLiteral<"resources/subscribe">;
+        params: import("zod").ZodObject<{
+            task: import("zod").ZodOptional<import("zod").ZodObject<{
+                ttl: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodNull]>>;
+                pollInterval: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$loose>>;
+            _meta: import("zod").ZodOptional<import("zod").ZodObject<{
+                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                "io.modelcontextprotocol/related-task": import("zod").ZodOptional<import("zod").ZodObject<{
+                    taskId: import("zod").ZodString;
+                }, import("zod/v4/core").$loose>>;
+            }, import("zod/v4/core").$loose>>;
+            uri: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+    }, import("zod/v4/core").$strip>;
+    handler: (request: SubscribeRequest, ctx: import("./mcp-handlers.types").McpRequestHandler<{
+        method: "resources/subscribe";
+        params: {
+            [x: string]: unknown;
+            uri: string;
+            task?: {
+                [x: string]: unknown;
+                ttl?: number | null | undefined;
+                pollInterval?: number | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    [x: string]: unknown;
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        };
+    }, {
+        method: string;
+        params?: {
+            [x: string]: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                "io.modelcontextprotocol/related-task"?: {
+                    [x: string]: unknown;
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }>) => Promise<EmptyResult>;
+};

package/src/transport/mcp-handlers/subscribe-request.handler.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = SubscribeRequestHandler;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+/**
+ * Handler for the resources/subscribe MCP request.
+ * Per MCP 2025-11-25 spec, this allows clients to subscribe to receive
+ * notifications when a specific resource changes.
+ */
+function SubscribeRequestHandler({ scope }) {
+    return {
+        requestSchema: types_js_1.SubscribeRequestSchema,
+        handler: async (request, ctx) => {
+            const { uri } = request.params;
+            // Get session ID from auth context
+            const sessionId = ctx.authInfo?.sessionId;
+            if (!sessionId) {
+                scope.logger.warn('resources/subscribe: No session ID found in request context');
+                return {};
+            }
+            // Subscribe the session to the resource
+            const isNew = scope.notifications.subscribeResource(sessionId, uri);
+            if (isNew) {
+                scope.logger.verbose(`resources/subscribe: Session ${sessionId.slice(0, 20)}... subscribed to ${uri}`);
+            }
+            else {
+                scope.logger.verbose(`resources/subscribe: Session ${sessionId.slice(0, 20)}... already subscribed to ${uri}`);
+            }
+            // Per MCP spec, return empty result
+            return {};
+        },
+    };
+}
+//# sourceMappingURL=subscribe-request.handler.js.map

package/src/transport/mcp-handlers/subscribe-request.handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe-request.handler.js","sourceRoot":"","sources":["../../../../src/transport/mcp-handlers/subscribe-request.handler.ts"],"names":[],"mappings":";;AAQA,0CA0BC;AAlCD,iEAA2G;AAG3G;;;;GAIG;AACH,SAAwB,uBAAuB,CAAC,EAAE,KAAK,EAAqB;IAC1E,OAAO;QACL,aAAa,EAAE,iCAAsB;QACrC,OAAO,EAAE,KAAK,EAAE,OAAyB,EAAE,GAAG,EAAwB,EAAE;YACtE,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;YAE/B,mCAAmC;YACnC,MAAM,SAAS,GAAG,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC;YAC1C,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,6DAA6D,CAAC,CAAC;gBACjF,OAAO,EAAE,CAAC;YACZ,CAAC;YAED,wCAAwC;YACxC,MAAM,KAAK,GAAG,KAAK,CAAC,aAAa,CAAC,iBAAiB,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;YAEpE,IAAI,KAAK,EAAE,CAAC;gBACV,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,gCAAgC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,qBAAqB,GAAG,EAAE,CAAC,CAAC;YACzG,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,gCAAgC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,6BAA6B,GAAG,EAAE,CAAC,CAAC;YACjH,CAAC;YAED,oCAAoC;YACpC,OAAO,EAAE,CAAC;QACZ,CAAC;KACkD,CAAC;AACxD,CAAC","sourcesContent":["import { SubscribeRequestSchema, SubscribeRequest, EmptyResult } from '@modelcontextprotocol/sdk/types.js';\nimport { McpHandler, McpHandlerOptions } from './mcp-handlers.types';\n\n/**\n * Handler for the resources/subscribe MCP request.\n * Per MCP 2025-11-25 spec, this allows clients to subscribe to receive\n * notifications when a specific resource changes.\n */\nexport default function SubscribeRequestHandler({ scope }: McpHandlerOptions) {\n  return {\n    requestSchema: SubscribeRequestSchema,\n    handler: async (request: SubscribeRequest, ctx): Promise<EmptyResult> => {\n      const { uri } = request.params;\n\n      // Get session ID from auth context\n      const sessionId = ctx.authInfo?.sessionId;\n      if (!sessionId) {\n        scope.logger.warn('resources/subscribe: No session ID found in request context');\n        return {};\n      }\n\n      // Subscribe the session to the resource\n      const isNew = scope.notifications.subscribeResource(sessionId, uri);\n\n      if (isNew) {\n        scope.logger.verbose(`resources/subscribe: Session ${sessionId.slice(0, 20)}... subscribed to ${uri}`);\n      } else {\n        scope.logger.verbose(`resources/subscribe: Session ${sessionId.slice(0, 20)}... already subscribed to ${uri}`);\n      }\n\n      // Per MCP spec, return empty result\n      return {};\n    },\n  } satisfies McpHandler<SubscribeRequest, EmptyResult>;\n}\n"]}