RSS3 MCP Server

Instructions

Implementation Reference

• index.js:150-223 (handler)

  This is the core handler for executing any tool call, including 'API-getRSS3TokenTotalSupply'. It matches the tool name to an OpenAPI operation and proxies the call via HttpClient.executeOperation, handling responses and errors.

  server.setRequestHandler(CallToolRequestSchema, async (request) => {
  	// console.error("call tool", request.params);
  	const { name, arguments: params } = request.params;
  
  	console.error("name", name);
  
  	if (name === "API-get-input-schema") {
  		for (const mcpToolWithClient of mcpToolWithClients) {
  			for (const [toolName, def] of Object.entries(
  				mcpToolWithClient.mcpTools.tools,
  			)) {
  				for (const method of def.methods) {
  					const toolNameWithMethod = `${toolName}-${method.name}`;
  					const truncatedToolName = toolNameWithMethod.slice(0, 64);
  					if (truncatedToolName === params.toolName) {
  						return {
  							content: [
  								{ type: "text", text: JSON.stringify(method.inputSchema) },
  							],
  						};
  					}
  				}
  			}
  		}
  		throw new Error(`Method ${params.toolName} not found`);
  	}
  
  	// find operation
  	const mcpToolWithClient = mcpToolWithClients.find(
  		(t) => t.mcpTools.openApiLookup[name],
  	);
  	if (!mcpToolWithClient) {
  		throw new Error(`Method ${name} not found`);
  	}
  
  	const operation = mcpToolWithClient.mcpTools.openApiLookup[name];
  
  	// execute
  	try {
  		const response = await mcpToolWithClient.client.executeOperation(
  			operation,
  			params,
  		);
  		return {
  			content: [
  				{
  					type: "text", // currently this is the only type that seems to be used by mcp server
  					text: JSON.stringify(response.data), // TODO: pass through the http status code text?
  				},
  			],
  		};
  	} catch (error) {
  		console.error("Error in tool call", error);
  		if (error instanceof HttpClientError) {
  			console.error(
  				"HttpClientError encountered, returning structured error",
  				error,
  			);
  			const data = error.data?.response?.data ?? error.data ?? {};
  			return {
  				content: [
  					{
  						type: "text",
  						text: JSON.stringify({
  							status: "error", // TODO: get this from http status code?
  							...(typeof data === "object" ? data : { data: data }),
  						}),
  					},
  				],
  			};
  		}
  		throw error;
  	}
  });

• index.js:100-147 (registration)

  Dynamic tool registration/listing handler. Generates tool list from OpenAPI specs, creating names like `${toolName}-${method.name}` truncated to 64 chars. 'API-getRSS3TokenTotalSupply' would be listed here if present in the spec.

  server.setRequestHandler(ListToolsRequestSchema, async () => {
  	console.error("list tools");
  	/**
  	 * @typedef {import("@modelcontextprotocol/sdk/types.js").Tool} Tool
  	 * @type {Tool[]}
  	 */
  	const tools = [];
  
  	for (const mcpToolWithClient of mcpToolWithClients) {
  		for (const [toolName, def] of Object.entries(
  			mcpToolWithClient.mcpTools.tools,
  		)) {
  			for (const method of def.methods) {
  				console.error("method", method);
  				const toolNameWithMethod = `${toolName}-${method.name}`;
  				const truncatedToolName = toolNameWithMethod.slice(0, 64);
  				const trimmedDescription = method.description.split("Error")[0].trim();
  				tools.push({
  					name: truncatedToolName,
  					description: trimmedDescription,
  					inputSchema: {
  						type: "object",
  						properties: {},
  					},
  				});
  			}
  		}
  	}
  
  	tools.unshift({
  		name: "API-get-input-schema",
  		description:
  			"Get the input schema for a given API. We should always use this tool to get the input schema for a given API before calling the API.",
  		inputSchema: {
  			type: "object",
  			properties: {
  				toolName: {
  					type: "string",
  					description: "The name of the tool to get the input schema for",
  				},
  			},
  		},
  	});
  
  	console.error("tools", tools);
  
  	return { tools };
  });

• index.js:71-84 (helper)

  Converts OpenAPI specs to MCP tools using OpenAPIToMCPConverter, creating the openApiLookup and tools objects used for dispatching and listing 'API-getRSS3TokenTotalSupply'.

  const converterWithClients = openApiSpecs.map((o) => {
  	const converter = new OpenAPIToMCPConverter(o.spec);
  	return {
  		converter,
  		client: o.client,
  	};
  });
  const mcpToolWithClients = converterWithClients.map((cwc) => {
  	const mcpTools = cwc.converter.convertToMCPTools();
  	return {
  		mcpTools,
  		client: cwc.client,
  	};
  });

• index.js:40-69 (helper)

  Fetches OpenAPI specifications from RSS3 endpoints and initializes HttpClient instances for proxying calls to tools like 'API-getRSS3TokenTotalSupply'.

  const openApiSpecs = (
  	await Promise.allSettled([
  		fetch("https://gi.rss3.io/docs/openapi.json").then(async (res) => {
  			if (!res.ok) throw new Error(`HTTP error! status: ${res.status}`);
  			return res.json();
  		}),
  		fetch("https://ai.rss3.io/openapi.json").then(async (res) => {
  			if (!res.ok) throw new Error(`HTTP error! status: ${res.status}`);
  			return res.json();
  		}),
  	]).then((results) => {
  		return results.map((result) => {
  			if (result.status === "fulfilled") {
  				const client = new HttpClient(
  					{
  						baseUrl: result.value.servers[0].url,
  					},
  					result.value,
  				);
  				return {
  					spec: result.value,
  					client,
  				};
  			}
  
  			console.error("Failed to fetch openapi spec", result.reason);
  			return null;
  		});
  	})
  ).filter(Boolean);

• index.js:156-175 (schema)

  Handler for 'API-get-input-schema' tool, which provides the input schema for any other API tool like 'API-getRSS3TokenTotalSupply' by looking it up from the OpenAPI spec.

  if (name === "API-get-input-schema") {
  	for (const mcpToolWithClient of mcpToolWithClients) {
  		for (const [toolName, def] of Object.entries(
  			mcpToolWithClient.mcpTools.tools,
  		)) {
  			for (const method of def.methods) {
  				const toolNameWithMethod = `${toolName}-${method.name}`;
  				const truncatedToolName = toolNameWithMethod.slice(0, 64);
  				if (truncatedToolName === params.toolName) {
  					return {
  						content: [
  							{ type: "text", text: JSON.stringify(method.inputSchema) },
  						],
  					};
  				}
  			}
  		}
  	}
  	throw new Error(`Method ${params.toolName} not found`);
  }