RSS3 MCP Server

Instructions

Implementation Reference

• index.js:150-223 (handler)

  This handler executes all dynamic tools derived from OpenAPI specs, including 'API-getNetworkActivities'. It looks up the operation by tool name in openApiLookup and calls the HttpClient to perform the API request, 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)

  This handler lists all available tools, dynamically generating entries for each OpenAPI operation as 'toolName-methodName' (truncated), including 'API-getNetworkActivities' if present in the spec, and prepends the schema getter tool.

  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:156-175 (schema)

  Special case within the handler for the 'API-get-input-schema' tool, which returns the exact input schema from the OpenAPI spec for any dynamic tool, including 'API-getNetworkActivities'.

  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`);
  }

• index.js:78-84 (helper)

  Creates the MCP tools definitions and associates them with their HttpClients by converting OpenAPI specs to MCP tools, enabling dynamic tool handling including 'API-getNetworkActivities'.

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