feat: add MCP resources support

ahonn · ahonn · commit 72f36996bbab · 2025-09-24T15:55:08.000+10:00
- Add listResources, readResource, and listResourceTemplates methods to MCP client
- Implement resource handlers in server with proper error handling and retry logic
- Add resources directory with remote proxy functionality
- Enable resources capability in server initialization
- Update README documentation
diff --git a/README.md b/README.md
@@ -113,7 +113,6 @@ If your MCP client doesn't support HTTP servers directly, you can use [mcp-remot
 > **Note**: Option 1 provides local PDF upload capabilities, while Option 2 only supports PDF processing via URLs (no local file uploads).
 
 
-
 ## License
 
 This project is licensed under the terms of the MIT open source license. Please refer to [MIT](./LICENSE) for the full terms.
diff --git a/src/client/mcp-client.ts b/src/client/mcp-client.ts
@@ -5,7 +5,12 @@ import {
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type {
+  CallToolResult,
+  ListResourcesResult,
+  ListResourceTemplatesResult,
+  ReadResourceResult,
+} from '@modelcontextprotocol/sdk/types.js';
 import pRetry from 'p-retry';
 import { CONFIG } from '../config.js';
 import { PageIndexOAuthProvider } from './oauth-provider.js';
@@ -192,6 +197,84 @@ export class PageIndexMcpClient {
     return tools;
   }
 
+  /**
+   * List available resources on the remote server
+   */
+  async listResources(): Promise<ListResourcesResult> {
+    return pRetry(
+      async () => {
+        if (!this.client) {
+          throw new Error('Client not available');
+        }
+        const result = await this.client.listResources();
+        return result as ListResourcesResult;
+      },
+      {
+        retries: 2,
+        factor: 1.5,
+        minTimeout: 500,
+        maxTimeout: 3000,
+        onFailedAttempt: (error) => {
+          console.error(
+            `List resources attempt ${error.attemptNumber} failed. ${error.retriesLeft} retries left.\n`,
+          );
+        },
+      },
+    );
+  }
+
+  /**
+   * Read a specific resource from the remote server
+   */
+  async readResource(uri: string): Promise<ReadResourceResult> {
+    return pRetry(
+      async () => {
+        if (!this.client) {
+          throw new Error('Client not available');
+        }
+        const result = await this.client.readResource({ uri });
+        return result as ReadResourceResult;
+      },
+      {
+        retries: 2,
+        factor: 1.5,
+        minTimeout: 500,
+        maxTimeout: 3000,
+        onFailedAttempt: (error) => {
+          console.error(
+            `Read resource "${uri}" attempt ${error.attemptNumber} failed. ${error.retriesLeft} retries left.\n`,
+          );
+        },
+      },
+    );
+  }
+
+  /**
+   * List resource templates from the remote server
+   */
+  async listResourceTemplates(): Promise<ListResourceTemplatesResult> {
+    return pRetry(
+      async () => {
+        if (!this.client) {
+          throw new Error('Client not available');
+        }
+        const result = await this.client.listResourceTemplates();
+        return result as ListResourceTemplatesResult;
+      },
+      {
+        retries: 2,
+        factor: 1.5,
+        minTimeout: 500,
+        maxTimeout: 3000,
+        onFailedAttempt: (error) => {
+          console.error(
+            `List resource templates attempt ${error.attemptNumber} failed. ${error.retriesLeft} retries left.\n`,
+          );
+        },
+      },
+    );
+  }
+
   /**
    * Reconnect to the server
    */
diff --git a/src/resources/index.ts b/src/resources/index.ts
@@ -0,0 +1,99 @@
+import type {
+  ListResourcesRequest,
+  ListResourcesResult,
+  ListResourceTemplatesResult,
+  ReadResourceRequest,
+  ReadResourceResult,
+} from '@modelcontextprotocol/sdk/types.js';
+import type { PageIndexMcpClient } from '../client/mcp-client.js';
+import { RemoteResourcesProxy } from './remote-proxy.js';
+
+// Global resources proxy instance
+let remoteResourcesProxy: RemoteResourcesProxy | null = null;
+
+/**
+ * Update the remote resources proxy with a connected MCP client
+ */
+export function updateResourcesWithRemote(mcpClient: PageIndexMcpClient): void {
+  remoteResourcesProxy = new RemoteResourcesProxy(mcpClient);
+}
+
+/**
+ * List available resources from the remote PageIndex server
+ */
+export async function listResources(
+  _params?: ListResourcesRequest['params'],
+): Promise<ListResourcesResult> {
+  if (!remoteResourcesProxy) {
+    throw new Error('Remote resources proxy not initialized');
+  }
+
+  try {
+    const resources = await remoteResourcesProxy.fetchRemoteResources();
+    return { resources };
+  } catch (error) {
+    const errorMessage =
+      error instanceof Error ? error.message : 'Failed to list resources';
+    throw new Error(`Failed to list resources: ${errorMessage}`);
+  }
+}
+
+/**
+ * Read a specific resource from the remote PageIndex server
+ */
+export async function readResource(
+  params: ReadResourceRequest['params'],
+): Promise<ReadResourceResult> {
+  if (!remoteResourcesProxy) {
+    throw new Error('Remote resources proxy not initialized');
+  }
+
+  try {
+    // Read resource from remote server (let remote server handle URI validation)
+    return await remoteResourcesProxy.readRemoteResource(params.uri);
+  } catch (error) {
+    const errorMessage =
+      error instanceof Error ? error.message : 'Failed to read resource';
+
+    // Return appropriate error codes based on error type
+    if (
+      errorMessage.includes('not found') ||
+      errorMessage.includes('Resource not found')
+    ) {
+      throw {
+        code: -32002,
+        message: errorMessage,
+        data: { uri: params.uri },
+      };
+    }
+
+    throw {
+      code: -32603,
+      message: errorMessage,
+      data: { uri: params.uri },
+    };
+  }
+}
+
+/**
+ * List available resource templates from remote server
+ */
+export async function listResourceTemplates(): Promise<ListResourceTemplatesResult> {
+  if (!remoteResourcesProxy) {
+    throw new Error('Remote resources proxy not initialized');
+  }
+
+  try {
+    const resourceTemplates =
+      await remoteResourcesProxy.fetchRemoteResourceTemplates();
+    return { resourceTemplates };
+  } catch (error) {
+    const errorMessage =
+      error instanceof Error
+        ? error.message
+        : 'Failed to list resource templates';
+    throw new Error(`Failed to list resource templates: ${errorMessage}`);
+  }
+}
+
+export { RemoteResourcesProxy } from './remote-proxy.js';
diff --git a/src/resources/remote-proxy.ts b/src/resources/remote-proxy.ts
@@ -0,0 +1,54 @@
+import type {
+  ListResourceTemplatesResult,
+  ReadResourceResult,
+  Resource,
+} from '@modelcontextprotocol/sdk/types.js';
+import type { PageIndexMcpClient } from '../client/mcp-client.js';
+
+/**
+ * Proxy for managing remote PageIndex MCP resources
+ */
+export class RemoteResourcesProxy {
+  constructor(private mcpClient: PageIndexMcpClient) {}
+
+  /**
+   * Fetch available resources from remote PageIndex server
+   */
+  async fetchRemoteResources(): Promise<Resource[]> {
+    try {
+      // List resources from remote server
+      const remoteResources = await this.mcpClient.listResources();
+      return remoteResources.resources;
+    } catch (error) {
+      console.error('Failed to fetch remote resources:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Read resource content from remote PageIndex server
+   */
+  async readRemoteResource(uri: string): Promise<ReadResourceResult> {
+    try {
+      return await this.mcpClient.readResource(uri);
+    } catch (error) {
+      console.error(`Failed to read remote resource ${uri}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get resource templates from remote server
+   */
+  async fetchRemoteResourceTemplates(): Promise<
+    ListResourceTemplatesResult['resourceTemplates']
+  > {
+    try {
+      const remoteTemplates = await this.mcpClient.listResourceTemplates();
+      return remoteTemplates.resourceTemplates;
+    } catch (error) {
+      console.error('Failed to fetch remote resource templates:', error);
+      return [];
+    }
+  }
+}
diff --git a/src/server.ts b/src/server.ts
@@ -2,10 +2,19 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import {
   CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
   ListToolsRequestSchema,
+  ReadResourceRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import { PageIndexMcpClient } from './client/mcp-client.js';
+import {
+  listResources,
+  listResourceTemplates,
+  readResource,
+  updateResourcesWithRemote,
+} from './resources/index.js';
 import {
   executeTool,
   getTools,
@@ -30,6 +39,7 @@ class PageIndexStdioServer {
       {
         capabilities: {
           tools: {},
+          resources: {},
         },
       },
     );
@@ -94,6 +104,89 @@ class PageIndexStdioServer {
       }
     });
 
+    // Resource handlers
+    this.server.setRequestHandler(
+      ListResourcesRequestSchema,
+      async (request) => {
+        // Initialize remote connection on first list resources request
+        if (!this.mcpClient) {
+          await this.connectToRemoteServer();
+        }
+
+        // biome-ignore lint/style/noNonNullAssertion: mcpClient is ensured to be non-null here
+        updateResourcesWithRemote(this.mcpClient!);
+
+        try {
+          return await listResources(request.params);
+        } catch (error) {
+          throw {
+            code: -32603,
+            message:
+              error instanceof Error
+                ? error.message
+                : 'Failed to list resources',
+            data: { cursor: request.params?.cursor },
+          };
+        }
+      },
+    );
+
+    this.server.setRequestHandler(
+      ReadResourceRequestSchema,
+      async (request) => {
+        // Ensure connection is established
+        if (!this.mcpClient) {
+          await this.connectToRemoteServer();
+        }
+
+        // biome-ignore lint/style/noNonNullAssertion: mcpClient is ensured to be non-null here
+        updateResourcesWithRemote(this.mcpClient!);
+
+        try {
+          return await readResource(request.params);
+        } catch (error) {
+          // Re-throw MCP-formatted errors directly
+          if (typeof error === 'object' && error !== null && 'code' in error) {
+            throw error;
+          }
+
+          throw {
+            code: -32603,
+            message:
+              error instanceof Error
+                ? error.message
+                : 'Failed to read resource',
+            data: { uri: request.params.uri },
+          };
+        }
+      },
+    );
+
+    this.server.setRequestHandler(
+      ListResourceTemplatesRequestSchema,
+      async () => {
+        // Ensure connection is established
+        if (!this.mcpClient) {
+          await this.connectToRemoteServer();
+        }
+
+        // biome-ignore lint/style/noNonNullAssertion: mcpClient is ensured to be non-null here
+        updateResourcesWithRemote(this.mcpClient!);
+
+        try {
+          return await listResourceTemplates();
+        } catch (error) {
+          throw {
+            code: -32603,
+            message:
+              error instanceof Error
+                ? error.message
+                : 'Failed to list resource templates',
+          };
+        }
+      },
+    );
+
     this.server.onerror = (error) => {
       console.error(`MCP Server error: ${error}\n`);
     };
