mirror of
https://github.com/modelcontextprotocol/servers.git
synced 2026-04-18 00:03:23 +02:00
99 lines
3.0 KiB
TypeScript
99 lines
3.0 KiB
TypeScript
import { z } from "zod";
|
|
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
|
|
import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
|
|
import {
|
|
textResource,
|
|
textResourceUri,
|
|
blobResourceUri,
|
|
blobResource,
|
|
RESOURCE_TYPE_BLOB,
|
|
RESOURCE_TYPE_TEXT,
|
|
RESOURCE_TYPES,
|
|
} from "../resources/templates.js";
|
|
|
|
// Tool input schema
|
|
const GetResourceReferenceSchema = z.object({
|
|
resourceType: z
|
|
.enum([RESOURCE_TYPE_TEXT, RESOURCE_TYPE_BLOB])
|
|
.default(RESOURCE_TYPE_TEXT),
|
|
resourceId: z
|
|
.number()
|
|
.default(1)
|
|
.describe("ID of the text resource to fetch"),
|
|
});
|
|
|
|
// Tool configuration
|
|
const name = "get-resource-reference";
|
|
const config = {
|
|
title: "Get Resource Reference Tool",
|
|
description: "Returns a resource reference that can be used by MCP clients",
|
|
inputSchema: GetResourceReferenceSchema,
|
|
};
|
|
|
|
/**
|
|
* Registers the 'get-resource-reference' tool.
|
|
*
|
|
* The registered tool validates and processes arguments for retrieving a resource
|
|
* reference. Supported resource types include predefined `RESOURCE_TYPE_TEXT` and
|
|
* `RESOURCE_TYPE_BLOB`. The retrieved resource's reference will include the resource
|
|
* ID, type, and its associated URI.
|
|
*
|
|
* The tool performs the following operations:
|
|
* 1. Validates the `resourceType` argument to ensure it matches a supported type.
|
|
* 2. Validates the `resourceId` argument to ensure it is a finite positive integer.
|
|
* 3. Constructs a URI for the resource based on its type (text or blob).
|
|
* 4. Retrieves the resource and returns it in a content block.
|
|
*
|
|
* @param {McpServer} server - The McpServer instance where the tool will be registered.
|
|
*/
|
|
export const registerGetResourceReferenceTool = (server: McpServer) => {
|
|
server.registerTool(name, config, async (args): Promise<CallToolResult> => {
|
|
// Validate resource type argument
|
|
const { resourceType } = args;
|
|
if (!RESOURCE_TYPES.includes(resourceType)) {
|
|
throw new Error(
|
|
`Invalid resourceType: ${args?.resourceType}. Must be ${RESOURCE_TYPE_TEXT} or ${RESOURCE_TYPE_BLOB}.`
|
|
);
|
|
}
|
|
|
|
// Validate resourceId argument
|
|
const resourceId = Number(args?.resourceId);
|
|
if (
|
|
!Number.isFinite(resourceId) ||
|
|
!Number.isInteger(resourceId) ||
|
|
resourceId < 1
|
|
) {
|
|
throw new Error(
|
|
`Invalid resourceId: ${args?.resourceId}. Must be a finite positive integer.`
|
|
);
|
|
}
|
|
|
|
// Get resource based on the resource type
|
|
const uri =
|
|
resourceType === RESOURCE_TYPE_TEXT
|
|
? textResourceUri(resourceId)
|
|
: blobResourceUri(resourceId);
|
|
const resource =
|
|
resourceType === RESOURCE_TYPE_TEXT
|
|
? textResource(uri, resourceId)
|
|
: blobResource(uri, resourceId);
|
|
|
|
return {
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: `Returning resource reference for Resource ${resourceId}:`,
|
|
},
|
|
{
|
|
type: "resource",
|
|
resource: resource,
|
|
},
|
|
{
|
|
type: "text",
|
|
text: `You can access this resource using the URI: ${resource.uri}`,
|
|
},
|
|
],
|
|
};
|
|
});
|
|
};
|