fix: corrected the resources implmentation

Author: MathurAditya724

packages/core/src/describe.ts

@@ -1,15 +1,11 @@
 import type { MiddlewareHandler } from "hono/types";
+import type { DescribeOptions } from "./types.js";
 import {
   McpPrimitives,
-  uniqueSymbol,
   type McpPrimitivesValue,
+  uniqueSymbol,
 } from "./utils.js";
 
-export type DescribeOptions = {
-  name?: string;
-  description?: string;
-};
-
 function describeRoute(type: McpPrimitivesValue) {
   return (docs: DescribeOptions = {}): MiddlewareHandler => {
     const middleware: MiddlewareHandler = async (_c, next) => {
@@ -18,13 +14,12 @@ function describeRoute(type: McpPrimitivesValue) {
 
     return Object.assign(middleware, {
       [uniqueSymbol]: {
-        resolver: () => docs,
+        resolver: docs,
         type,
       },
     });
   };
 }
 
 export const describePrompt = describeRoute(McpPrimitives.PROMPTS);
-export const describeResource = describeRoute(McpPrimitives.RESOURCES);
 export const describeTool = describeRoute(McpPrimitives.TOOLS);

packages/core/src/index.ts

@@ -1,6 +1,6 @@
-export * from "./validator.js";
-export * from "./resources/index.js";
+export * from "./describe.js";
 export { muppet } from "./muppet.js";
+export * from "./resources.js";
 export type * from "./types.js";
 export * from "./utils.js";
-export * from "./describe.js";
+export * from "./validator.js";

packages/core/src/muppet.ts

@@ -5,15 +5,18 @@ import {
   GetPromptRequestSchema,
   InitializeRequestSchema,
   LATEST_PROTOCOL_VERSION,
+  ReadResourceRequestSchema,
   RequestSchema,
   SUPPORTED_PROTOCOL_VERSIONS,
 } from "@modelcontextprotocol/sdk/types.js";
 import { Hono } from "hono";
 import type { BlankEnv, BlankSchema, Env, Schema } from "hono/types";
+import type { JSONSchema7 } from "json-schema";
 import type { Logger } from "pino";
 import type {
   AvailableEvents,
   ConceptConfiguration,
+  DescribeOptions,
   MuppetConfiguration,
   PromptConfiguration,
   ServerConfiguration,
@@ -80,7 +83,7 @@ export async function muppet<
 
       const hasTools = McpPrimitives.TOOLS in serverConfiguration;
       const hasPrompts = McpPrimitives.PROMPTS in serverConfiguration;
-      const hasResources = false;
+      const hasResources = McpPrimitives.RESOURCES in serverConfiguration;
 
       return c.json({
         result: {
@@ -105,6 +108,7 @@ export async function muppet<
 
   mcp.route("/tools", createToolsApp(serverConfiguration, hono));
   mcp.route("/prompts", createPromptApp(serverConfiguration, hono));
+  mcp.route("/resources", createResourceApp(config, serverConfiguration, hono));
 
   mcp.post("/notifications/:event", (c) => {
     config.events?.emit(
@@ -204,7 +208,13 @@ export async function generateSpecs<
       uniqueSymbol
     ] as ToolHandlerResponse;
 
-    const result = await resolver();
+    let result: DescribeOptions | JSONSchema7;
+
+    if (typeof resolver === "function") {
+      result = await resolver();
+    } else {
+      result = resolver ?? {};
+    }
 
     const concept = concepts[route.path];
 
@@ -266,6 +276,10 @@ export async function generateSpecs<
         arguments: args,
         path,
       };
+    } else if (concept.type === McpPrimitives.RESOURCES) {
+      if (!configuration.resources) {
+        configuration.resources = {};
+      }
     }
   }
 
@@ -374,3 +388,66 @@ function createPromptApp<
 
   return app;
 }
+
+function createResourceApp<
+  E extends Env = BlankEnv,
+  S extends Schema = BlankSchema,
+  P extends string = string,
+>(
+  muppet: MuppetConfiguration,
+  config: ServerConfiguration,
+  hono: Hono<E, S, P>,
+) {
+  const app = new Hono<BaseEnv>().use(async (_c, next) => {
+    if (!(McpPrimitives.RESOURCES in config)) {
+      throw new Error("No resources available");
+    }
+
+    await next();
+  });
+
+  app.post("/list", async (c) => {
+    const resources = await Promise.all(
+      Object.values(config.resources ?? {}).map(async ({ path }) => {
+        const res = await hono.request(path, {
+          method: "POST",
+          headers: c.req.header(),
+        });
+
+        return res.json();
+      }),
+    );
+
+    return c.json({
+      result: {
+        resources: resources.flat(),
+      },
+    });
+  });
+
+  app.post(
+    "/read",
+    sValidator("json", ReadResourceRequestSchema),
+    async (c) => {
+      const { params } = c.req.valid("json");
+
+      const protocol = params.uri.split(":")[0];
+      const handler = muppet.resources?.[protocol];
+
+      if (!handler) {
+        throw new Error(`Unable to find the handler for ${protocol} protocol!`);
+      }
+
+      const contents = handler(params.uri);
+
+      if (Array.isArray(contents))
+        return c.json({
+          result: { contents },
+        });
+
+      return c.json({ result: contents });
+    },
+  );
+
+  return app;
+}

packages/core/src/resources.ts

@@ -0,0 +1,17 @@
+import type { Env, Handler, Input } from "hono";
+import type { BlankEnv, BlankInput, TypedResponse } from "hono/types";
+import { McpPrimitives, uniqueSymbol } from "./utils";
+
+export function registerResources<
+  E extends Env = BlankEnv,
+  P extends string = string,
+  I extends Input = BlankInput,
+>(
+  handler: Handler<E, P, I, TypedResponse<"json", 200>>,
+): Handler<E, P, I, TypedResponse<"json", 200>> {
+  return Object.assign(handler, {
+    [uniqueSymbol]: {
+      type: McpPrimitives.RESOURCES,
+    },
+  });
+}

packages/core/src/resources/dynamic.ts

@@ -1,22 +1,27 @@
+import type { Emitter } from "@hono/event-emitter";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { JSONSchema7 } from "json-schema";
 import type { DestinationStream, LoggerOptions } from "pino";
 import type { McpPrimitivesValue } from "./utils";
-import type { DescribeOptions } from "./describe";
-import type { Emitter } from "@hono/event-emitter";
 
 export type HasUndefined<T> = undefined extends T ? true : false;
 
+export type DescribeOptions = {
+  name?: string;
+  description?: string;
+};
+
 export type ToolHandlerResponse = {
-  resolver: (
-    config?: Record<string, unknown>,
-  ) => Promise<DescribeOptions | JSONSchema7>;
+  resolver?:
+    | DescribeOptions
+    | ((config?: Record<string, unknown>) => Promise<JSONSchema7>);
   type?: McpPrimitivesValue;
 };
 
 export type ServerConfiguration = {
   tools?: ToolsConfiguration;
   prompts?: PromptConfiguration;
+  resources?: ResourceConfiguration;
 };
 
 export type ToolsConfiguration = Record<
@@ -32,6 +37,13 @@ export type PromptConfiguration = Record<
   }
 >;
 
+export type ResourceConfiguration = Record<
+  string,
+  {
+    path: string;
+  }
+>;
+
 export type ConceptConfiguration = Record<
   string,
   | (DescribeOptions & {
@@ -47,6 +59,8 @@ export type AvailableEvents = {
   "notifications/cancelled": undefined;
 };
 
+export type Promisify<T> = T | Promise<T>;
+
 export type MuppetConfiguration = {
   name: string;
   version: string;
@@ -56,4 +70,21 @@ export type MuppetConfiguration = {
     options?: LoggerOptions;
   };
   events?: Emitter<AvailableEvents>;
+  resources?: Record<
+    string,
+    (uri: string) => Promisify<
+      {
+        uri: string;
+        mimeType: string;
+        /**
+         * For text resources
+         */
+        text?: string;
+        /**
+         * For binary resources (base64 encoded)
+         */
+        blob?: string;
+      }[]
+    >
+  >;
 };

packages/core/src/resources/index.ts

@@ -41,8 +41,8 @@ export function mValidator<
   // @ts-expect-error not typed well
   return Object.assign(middleware, {
     [uniqueSymbol]: {
-      resolver: async (options?: Record<string, unknown>) => ({
-        schema: await toJsonSchema(schema, options),
+      resolver: async () => ({
+        schema: await toJsonSchema(schema),
       }),
     },
   });