3309 lines
79 KiB
TypeScript
3309 lines
79 KiB
TypeScript
import { McpServer } from "./mcp.js";
|
|
import { Client } from "../client/index.js";
|
|
import { InMemoryTransport } from "../inMemory.js";
|
|
import { z } from "zod";
|
|
import {
|
|
ListToolsResultSchema,
|
|
CallToolResultSchema,
|
|
ListResourcesResultSchema,
|
|
ListResourceTemplatesResultSchema,
|
|
ReadResourceResultSchema,
|
|
ListPromptsResultSchema,
|
|
GetPromptResultSchema,
|
|
CompleteResultSchema,
|
|
LoggingMessageNotificationSchema,
|
|
Notification,
|
|
TextContent,
|
|
} from "../types.js";
|
|
import { ResourceTemplate } from "./mcp.js";
|
|
import { completable } from "./completable.js";
|
|
import { UriTemplate } from "../shared/uriTemplate.js";
|
|
|
|
describe("McpServer", () => {
|
|
/***
|
|
* Test: Basic Server Instance
|
|
*/
|
|
test("should expose underlying Server instance", () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
expect(mcpServer.server).toBeDefined();
|
|
});
|
|
|
|
/***
|
|
* Test: Notification Sending via Server
|
|
*/
|
|
test("should allow sending notifications via Server", async () => {
|
|
const mcpServer = new McpServer(
|
|
{
|
|
name: "test server",
|
|
version: "1.0",
|
|
},
|
|
{ capabilities: { logging: {} } },
|
|
);
|
|
|
|
const notifications: Notification[] = []
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification)
|
|
}
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
// This should work because we're using the underlying server
|
|
await expect(
|
|
mcpServer.server.sendLoggingMessage({
|
|
level: "info",
|
|
data: "Test log message",
|
|
}),
|
|
).resolves.not.toThrow();
|
|
|
|
expect(notifications).toMatchObject([
|
|
{
|
|
"method": "notifications/message",
|
|
params: {
|
|
level: "info",
|
|
data: "Test log message",
|
|
}
|
|
}
|
|
])
|
|
});
|
|
});
|
|
|
|
describe("ResourceTemplate", () => {
|
|
/***
|
|
* Test: ResourceTemplate Creation with String Pattern
|
|
*/
|
|
test("should create ResourceTemplate with string pattern", () => {
|
|
const template = new ResourceTemplate("test://{category}/{id}", {
|
|
list: undefined,
|
|
});
|
|
expect(template.uriTemplate.toString()).toBe("test://{category}/{id}");
|
|
expect(template.listCallback).toBeUndefined();
|
|
});
|
|
|
|
/***
|
|
* Test: ResourceTemplate Creation with UriTemplate Instance
|
|
*/
|
|
test("should create ResourceTemplate with UriTemplate", () => {
|
|
const uriTemplate = new UriTemplate("test://{category}/{id}");
|
|
const template = new ResourceTemplate(uriTemplate, { list: undefined });
|
|
expect(template.uriTemplate).toBe(uriTemplate);
|
|
expect(template.listCallback).toBeUndefined();
|
|
});
|
|
|
|
/***
|
|
* Test: ResourceTemplate with List Callback
|
|
*/
|
|
test("should create ResourceTemplate with list callback", async () => {
|
|
const list = jest.fn().mockResolvedValue({
|
|
resources: [{ name: "Test", uri: "test://example" }],
|
|
});
|
|
|
|
const template = new ResourceTemplate("test://{id}", { list });
|
|
expect(template.listCallback).toBe(list);
|
|
|
|
const abortController = new AbortController();
|
|
const result = await template.listCallback?.({
|
|
signal: abortController.signal,
|
|
requestId: 'not-implemented',
|
|
sendRequest: () => { throw new Error("Not implemented") },
|
|
sendNotification: () => { throw new Error("Not implemented") }
|
|
});
|
|
expect(result?.resources).toHaveLength(1);
|
|
expect(list).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("tool()", () => {
|
|
/***
|
|
* Test: Zero-Argument Tool Registration
|
|
*/
|
|
test("should register zero-argument tool", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const notifications: Notification[] = []
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification)
|
|
}
|
|
|
|
mcpServer.tool("test", async () => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
],
|
|
}));
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "tools/list",
|
|
},
|
|
ListToolsResultSchema,
|
|
);
|
|
|
|
expect(result.tools).toHaveLength(1);
|
|
expect(result.tools[0].name).toBe("test");
|
|
expect(result.tools[0].inputSchema).toEqual({
|
|
type: "object",
|
|
});
|
|
|
|
// Adding the tool before the connection was established means no notification was sent
|
|
expect(notifications).toHaveLength(0)
|
|
|
|
// Adding another tool triggers the update notification
|
|
mcpServer.tool("test2", async () => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
],
|
|
}));
|
|
|
|
// Yield event loop to let the notification fly
|
|
await new Promise(process.nextTick)
|
|
|
|
expect(notifications).toMatchObject([
|
|
{
|
|
method: "notifications/tools/list_changed",
|
|
}
|
|
])
|
|
});
|
|
|
|
/***
|
|
* Test: Updating Existing Tool
|
|
*/
|
|
test("should update existing tool", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const notifications: Notification[] = []
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification)
|
|
}
|
|
|
|
// Register initial tool
|
|
const tool = mcpServer.tool("test", async () => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: "Initial response",
|
|
},
|
|
],
|
|
}));
|
|
|
|
// Update the tool
|
|
tool.update({
|
|
callback: async () => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: "Updated response",
|
|
},
|
|
],
|
|
})
|
|
});
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.connect(serverTransport),
|
|
]);
|
|
|
|
// Call the tool and verify we get the updated response
|
|
const result = await client.request(
|
|
{
|
|
method: "tools/call",
|
|
params: {
|
|
name: "test",
|
|
},
|
|
},
|
|
CallToolResultSchema,
|
|
);
|
|
|
|
expect(result.content).toEqual([
|
|
{
|
|
type: "text",
|
|
text: "Updated response",
|
|
},
|
|
]);
|
|
|
|
// Update happened before transport was connected, so no notifications should be expected
|
|
expect(notifications).toHaveLength(0)
|
|
});
|
|
|
|
/***
|
|
* Test: Updating Tool with Schema
|
|
*/
|
|
test("should update tool with schema", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const notifications: Notification[] = []
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification)
|
|
}
|
|
|
|
// Register initial tool
|
|
const tool = mcpServer.tool(
|
|
"test",
|
|
{
|
|
name: z.string(),
|
|
},
|
|
async ({ name }) => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: `Initial: ${name}`,
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
// Update the tool with a different schema
|
|
tool.update({
|
|
paramsSchema: {
|
|
name: z.string(),
|
|
value: z.number(),
|
|
},
|
|
callback: async ({name, value}) => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: `Updated: ${name}, ${value}`,
|
|
},
|
|
],
|
|
})
|
|
});
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.connect(serverTransport),
|
|
]);
|
|
|
|
// Verify the schema was updated
|
|
const listResult = await client.request(
|
|
{
|
|
method: "tools/list",
|
|
},
|
|
ListToolsResultSchema,
|
|
);
|
|
|
|
expect(listResult.tools[0].inputSchema).toMatchObject({
|
|
properties: {
|
|
name: { type: "string" },
|
|
value: { type: "number" },
|
|
},
|
|
});
|
|
|
|
// Call the tool with the new schema
|
|
const callResult = await client.request(
|
|
{
|
|
method: "tools/call",
|
|
params: {
|
|
name: "test",
|
|
arguments: {
|
|
name: "test",
|
|
value: 42,
|
|
},
|
|
},
|
|
},
|
|
CallToolResultSchema,
|
|
);
|
|
|
|
expect(callResult.content).toEqual([
|
|
{
|
|
type: "text",
|
|
text: "Updated: test, 42",
|
|
},
|
|
]);
|
|
|
|
// Update happened before transport was connected, so no notifications should be expected
|
|
expect(notifications).toHaveLength(0)
|
|
});
|
|
|
|
/***
|
|
* Test: Tool List Changed Notifications
|
|
*/
|
|
test("should send tool list changed notifications when connected", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const notifications: Notification[] = []
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification)
|
|
}
|
|
|
|
// Register initial tool
|
|
const tool = mcpServer.tool("test", async () => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
],
|
|
}));
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.connect(serverTransport),
|
|
]);
|
|
|
|
expect(notifications).toHaveLength(0)
|
|
|
|
// Now update the tool
|
|
tool.update({
|
|
callback: async () => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: "Updated response",
|
|
},
|
|
],
|
|
})
|
|
});
|
|
|
|
// Yield event loop to let the notification fly
|
|
await new Promise(process.nextTick)
|
|
|
|
expect(notifications).toMatchObject([
|
|
{ method: "notifications/tools/list_changed" }
|
|
])
|
|
|
|
// Now delete the tool
|
|
tool.remove();
|
|
|
|
// Yield event loop to let the notification fly
|
|
await new Promise(process.nextTick)
|
|
|
|
expect(notifications).toMatchObject([
|
|
{ method: "notifications/tools/list_changed" },
|
|
{ method: "notifications/tools/list_changed" },
|
|
])
|
|
});
|
|
|
|
/***
|
|
* Test: Tool Registration with Parameters
|
|
*/
|
|
test("should register tool with params", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
// old api
|
|
mcpServer.tool(
|
|
"test",
|
|
{
|
|
name: z.string(),
|
|
value: z.number(),
|
|
},
|
|
async ({ name, value }) => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: `${name}: ${value}`,
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
// new api
|
|
mcpServer.tool(
|
|
"test (new api)",
|
|
{
|
|
inputSchema: { name: z.string(), value: z.number() },
|
|
callback: async ({ name, value }) => ({
|
|
content: [{ type: "text", text: `${name}: ${value}` }],
|
|
}),
|
|
}
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "tools/list",
|
|
},
|
|
ListToolsResultSchema,
|
|
);
|
|
|
|
expect(result.tools).toHaveLength(2);
|
|
expect(result.tools[0].name).toBe("test");
|
|
expect(result.tools[0].inputSchema).toMatchObject({
|
|
type: "object",
|
|
properties: {
|
|
name: { type: "string" },
|
|
value: { type: "number" },
|
|
},
|
|
});
|
|
expect(result.tools[1].name).toBe("test (new api)");
|
|
expect(result.tools[1].inputSchema).toEqual(result.tools[0].inputSchema);
|
|
});
|
|
|
|
/***
|
|
* Test: Tool Registration with Description
|
|
*/
|
|
test("should register tool with description", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
// old api
|
|
mcpServer.tool("test", "Test description", async () => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
],
|
|
}));
|
|
|
|
// new api
|
|
mcpServer.tool("test (new api)", {
|
|
description: "Test description",
|
|
callback: async () => ({
|
|
content: [
|
|
{
|
|
type: "text" as const,
|
|
text: "Test response",
|
|
},
|
|
],
|
|
})
|
|
});
|
|
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "tools/list",
|
|
},
|
|
ListToolsResultSchema,
|
|
);
|
|
|
|
expect(result.tools).toHaveLength(2);
|
|
expect(result.tools[0].name).toBe("test");
|
|
expect(result.tools[0].description).toBe("Test description");
|
|
expect(result.tools[1].name).toBe("test (new api)");
|
|
expect(result.tools[1].description).toBe("Test description");
|
|
});
|
|
|
|
/***
|
|
* Test: Tool Registration with Annotations
|
|
*/
|
|
test("should register tool with annotations", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.tool("test", { title: "Test Tool", readOnlyHint: true }, async () => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
],
|
|
}));
|
|
|
|
mcpServer.tool("test (new api)", {
|
|
annotations: { title: "Test Tool", readOnlyHint: true },
|
|
callback: async () => ({
|
|
content: [
|
|
{
|
|
type: "text" as const,
|
|
text: "Test response",
|
|
},
|
|
],
|
|
}),
|
|
});
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "tools/list",
|
|
},
|
|
ListToolsResultSchema,
|
|
);
|
|
|
|
expect(result.tools).toHaveLength(2);
|
|
expect(result.tools[0].name).toBe("test");
|
|
expect(result.tools[0].annotations).toEqual({ title: "Test Tool", readOnlyHint: true });
|
|
expect(result.tools[1].name).toBe("test (new api)");
|
|
expect(result.tools[1].annotations).toEqual({ title: "Test Tool", readOnlyHint: true });
|
|
});
|
|
|
|
/***
|
|
* Test: Tool Registration with Parameters and Annotations
|
|
*/
|
|
test("should register tool with params and annotations", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.tool(
|
|
"test",
|
|
{ name: z.string() },
|
|
{ title: "Test Tool", readOnlyHint: true },
|
|
async ({ name }) => ({
|
|
content: [{ type: "text", text: `Hello, ${name}!` }]
|
|
})
|
|
);
|
|
|
|
mcpServer.tool("test (new api)", {
|
|
inputSchema: { name: z.string() },
|
|
annotations: { title: "Test Tool", readOnlyHint: true },
|
|
callback: async ({ name }) => ({
|
|
content: [{ type: "text", text: `Hello, ${name}!` }]
|
|
})
|
|
});
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{ method: "tools/list" },
|
|
ListToolsResultSchema,
|
|
);
|
|
|
|
expect(result.tools).toHaveLength(2);
|
|
expect(result.tools[0].name).toBe("test");
|
|
expect(result.tools[0].inputSchema).toMatchObject({
|
|
type: "object",
|
|
properties: { name: { type: "string" } }
|
|
});
|
|
expect(result.tools[0].annotations).toEqual({ title: "Test Tool", readOnlyHint: true });
|
|
expect(result.tools[1].name).toBe("test (new api)");
|
|
expect(result.tools[1].inputSchema).toEqual(result.tools[0].inputSchema);
|
|
expect(result.tools[1].annotations).toEqual(result.tools[0].annotations);
|
|
});
|
|
|
|
/***
|
|
* Test: Tool Registration with Description, Parameters, and Annotations
|
|
*/
|
|
test("should register tool with description, params, and annotations", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.tool(
|
|
"test",
|
|
"A tool with everything",
|
|
{ name: z.string() },
|
|
{ title: "Complete Test Tool", readOnlyHint: true, openWorldHint: false },
|
|
async ({ name }) => ({
|
|
content: [{ type: "text", text: `Hello, ${name}!` }]
|
|
})
|
|
);
|
|
|
|
mcpServer.tool("test (new api)", {
|
|
description: "A tool with everything",
|
|
inputSchema: { name: z.string() },
|
|
annotations: { title: "Complete Test Tool", readOnlyHint: true, openWorldHint: false },
|
|
callback: async ({ name }) => ({
|
|
content: [{ type: "text", text: `Hello, ${name}!` }]
|
|
})
|
|
});
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{ method: "tools/list" },
|
|
ListToolsResultSchema,
|
|
);
|
|
|
|
expect(result.tools).toHaveLength(2);
|
|
expect(result.tools[0].name).toBe("test");
|
|
expect(result.tools[0].description).toBe("A tool with everything");
|
|
expect(result.tools[0].inputSchema).toMatchObject({
|
|
type: "object",
|
|
properties: { name: { type: "string" } }
|
|
});
|
|
expect(result.tools[0].annotations).toEqual({
|
|
title: "Complete Test Tool",
|
|
readOnlyHint: true,
|
|
openWorldHint: false
|
|
});
|
|
expect(result.tools[1].name).toBe("test (new api)");
|
|
expect(result.tools[1].description).toBe("A tool with everything");
|
|
expect(result.tools[1].inputSchema).toEqual(result.tools[0].inputSchema);
|
|
expect(result.tools[1].annotations).toEqual(result.tools[0].annotations);
|
|
});
|
|
|
|
/***
|
|
* Test: Tool Registration with Description, Empty Parameters, and Annotations
|
|
*/
|
|
test("should register tool with description, empty params, and annotations", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.tool(
|
|
"test",
|
|
"A tool with everything but empty params",
|
|
{},
|
|
{ title: "Complete Test Tool with empty params", readOnlyHint: true, openWorldHint: false },
|
|
async () => ({
|
|
content: [{ type: "text", text: "Test response" }]
|
|
})
|
|
);
|
|
|
|
mcpServer.tool("test (new api)", {
|
|
description: "A tool with everything but empty params",
|
|
inputSchema: {},
|
|
annotations: { title: "Complete Test Tool with empty params", readOnlyHint: true, openWorldHint: false },
|
|
callback: async () => ({
|
|
content: [{ type: "text" as const, text: "Test response" }]
|
|
})
|
|
});
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{ method: "tools/list" },
|
|
ListToolsResultSchema,
|
|
);
|
|
|
|
expect(result.tools).toHaveLength(2);
|
|
expect(result.tools[0].name).toBe("test");
|
|
expect(result.tools[0].description).toBe("A tool with everything but empty params");
|
|
expect(result.tools[0].inputSchema).toMatchObject({
|
|
type: "object",
|
|
properties: {}
|
|
});
|
|
expect(result.tools[0].annotations).toEqual({
|
|
title: "Complete Test Tool with empty params",
|
|
readOnlyHint: true,
|
|
openWorldHint: false
|
|
});
|
|
expect(result.tools[1].name).toBe("test (new api)");
|
|
expect(result.tools[1].description).toBe("A tool with everything but empty params");
|
|
expect(result.tools[1].inputSchema).toEqual(result.tools[0].inputSchema);
|
|
expect(result.tools[1].annotations).toEqual(result.tools[0].annotations);
|
|
});
|
|
|
|
/***
|
|
* Test: Tool Argument Validation
|
|
*/
|
|
test("should validate tool args", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
tools: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
mcpServer.tool(
|
|
"test",
|
|
{
|
|
name: z.string(),
|
|
value: z.number(),
|
|
},
|
|
async ({ name, value }) => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: `${name}: ${value}`,
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
mcpServer.tool("test (new api)", {
|
|
inputSchema: {
|
|
name: z.string(),
|
|
value: z.number(),
|
|
},
|
|
callback: async ({ name, value }) => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: `${name}: ${value}`,
|
|
},
|
|
],
|
|
}),
|
|
});
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
await expect(
|
|
client.request(
|
|
{
|
|
method: "tools/call",
|
|
params: {
|
|
name: "test",
|
|
arguments: {
|
|
name: "test",
|
|
value: "not a number",
|
|
},
|
|
},
|
|
},
|
|
CallToolResultSchema,
|
|
),
|
|
).rejects.toThrow(/Invalid arguments/);
|
|
|
|
await expect(
|
|
client.request(
|
|
{
|
|
method: "tools/call",
|
|
params: {
|
|
name: "test (new api)",
|
|
arguments: {
|
|
name: "test",
|
|
value: "not a number",
|
|
},
|
|
},
|
|
},
|
|
CallToolResultSchema,
|
|
),
|
|
).rejects.toThrow(/Invalid arguments/);
|
|
});
|
|
|
|
/***
|
|
* Test: Preventing Duplicate Tool Registration
|
|
*/
|
|
test("should prevent duplicate tool registration", () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.tool("test", async () => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
],
|
|
}));
|
|
|
|
expect(() => {
|
|
mcpServer.tool("test", async () => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: "Test response 2",
|
|
},
|
|
],
|
|
}));
|
|
}).toThrow(/already registered/);
|
|
});
|
|
|
|
/***
|
|
* Test: Multiple Tool Registration
|
|
*/
|
|
test("should allow registering multiple tools", () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
// This should succeed
|
|
mcpServer.tool("tool1", () => ({ content: [] }));
|
|
|
|
// This should also succeed and not throw about request handlers
|
|
mcpServer.tool("tool2", () => ({ content: [] }));
|
|
});
|
|
|
|
/***
|
|
* Test: Tool with Output Schema and Structured Content
|
|
*/
|
|
test("should support tool with outputSchema and structuredContent", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
tools: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
// Register a tool with outputSchema
|
|
mcpServer.tool(
|
|
"test",
|
|
{
|
|
description: "Test tool with structured output",
|
|
inputSchema: {
|
|
input: z.string(),
|
|
},
|
|
outputSchema: {
|
|
processedInput: z.string(),
|
|
resultType: z.string(),
|
|
timestamp: z.string()
|
|
},
|
|
callback: async ({ input }) => ({
|
|
structuredContent: {
|
|
processedInput: input,
|
|
resultType: "structured",
|
|
timestamp: "2023-01-01T00:00:00Z"
|
|
},
|
|
}),
|
|
},
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
// Verify the tool registration includes outputSchema
|
|
const listResult = await client.request(
|
|
{
|
|
method: "tools/list",
|
|
},
|
|
ListToolsResultSchema,
|
|
);
|
|
|
|
expect(listResult.tools).toHaveLength(1);
|
|
expect(listResult.tools[0].outputSchema).toMatchObject({
|
|
type: "object",
|
|
properties: {
|
|
processedInput: { type: "string" },
|
|
resultType: { type: "string" },
|
|
timestamp: { type: "string" }
|
|
},
|
|
required: ["processedInput", "resultType", "timestamp"]
|
|
});
|
|
|
|
// Call the tool and verify it returns valid structuredContent
|
|
const result = await client.request(
|
|
{
|
|
method: "tools/call",
|
|
params: {
|
|
name: "test",
|
|
arguments: {
|
|
input: "hello",
|
|
},
|
|
},
|
|
},
|
|
CallToolResultSchema,
|
|
);
|
|
|
|
expect(result.structuredContent).toBeDefined();
|
|
const structuredContent = result.structuredContent as {
|
|
processedInput: string;
|
|
resultType: string;
|
|
timestamp: string;
|
|
};
|
|
expect(structuredContent.processedInput).toBe("hello");
|
|
expect(structuredContent.resultType).toBe("structured");
|
|
expect(structuredContent.timestamp).toBe("2023-01-01T00:00:00Z");
|
|
|
|
// For backward compatibility, content is auto-generated from structuredContent
|
|
expect(result.content).toBeDefined();
|
|
expect(result.content!).toHaveLength(1);
|
|
expect(result.content![0]).toMatchObject({ type: "text" });
|
|
const textContent = result.content![0] as TextContent;
|
|
expect(JSON.parse(textContent.text)).toEqual(result.structuredContent);
|
|
});
|
|
|
|
/***
|
|
* Test: Schema Validation Failure for Invalid Structured Content
|
|
*/
|
|
test("should fail schema validation when tool returns invalid structuredContent", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
tools: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
// Register a tool with outputSchema that returns invalid data
|
|
mcpServer.tool(
|
|
"test",
|
|
{
|
|
description: "Test tool with invalid structured output",
|
|
inputSchema: {
|
|
input: z.string(),
|
|
},
|
|
outputSchema: {
|
|
processedInput: z.string(),
|
|
resultType: z.string(),
|
|
timestamp: z.string()
|
|
},
|
|
callback: async ({ input }) => ({
|
|
structuredContent: {
|
|
processedInput: input,
|
|
resultType: "structured",
|
|
// Missing required 'timestamp' field
|
|
someExtraField: "unexpected" // Extra field not in schema
|
|
},
|
|
}),
|
|
},
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
// First call listTools to cache the outputSchema in the client
|
|
await client.listTools();
|
|
|
|
// Call the tool and expect it to throw a validation error
|
|
await expect(
|
|
client.callTool({
|
|
name: "test",
|
|
arguments: {
|
|
input: "hello",
|
|
},
|
|
}),
|
|
).rejects.toThrow(/Structured content does not match the tool's output schema/);
|
|
});
|
|
|
|
/***
|
|
* Test: Pass Session ID to Tool Callback
|
|
*/
|
|
test("should pass sessionId to tool callback via RequestHandlerExtra", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
tools: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
let receivedSessionId: string | undefined;
|
|
mcpServer.tool("test-tool", async (extra) => {
|
|
receivedSessionId = extra.sessionId;
|
|
return {
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
],
|
|
};
|
|
});
|
|
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
// Set a test sessionId on the server transport
|
|
serverTransport.sessionId = "test-session-123";
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
await client.request(
|
|
{
|
|
method: "tools/call",
|
|
params: {
|
|
name: "test-tool",
|
|
},
|
|
},
|
|
CallToolResultSchema,
|
|
);
|
|
|
|
expect(receivedSessionId).toBe("test-session-123");
|
|
});
|
|
|
|
/***
|
|
* Test: Pass Request ID to Tool Callback
|
|
*/
|
|
test("should pass requestId to tool callback via RequestHandlerExtra", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
tools: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
let receivedRequestId: string | number | undefined;
|
|
mcpServer.tool("request-id-test", async (extra) => {
|
|
receivedRequestId = extra.requestId;
|
|
return {
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: `Received request ID: ${extra.requestId}`,
|
|
},
|
|
],
|
|
};
|
|
});
|
|
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "tools/call",
|
|
params: {
|
|
name: "request-id-test",
|
|
},
|
|
},
|
|
CallToolResultSchema,
|
|
);
|
|
|
|
expect(receivedRequestId).toBeDefined();
|
|
expect(typeof receivedRequestId === 'string' || typeof receivedRequestId === 'number').toBe(true);
|
|
expect(result.content && result.content[0].text).toContain("Received request ID:");
|
|
});
|
|
|
|
/***
|
|
* Test: Send Notification within Tool Call
|
|
*/
|
|
test("should provide sendNotification within tool call", async () => {
|
|
const mcpServer = new McpServer(
|
|
{
|
|
name: "test server",
|
|
version: "1.0",
|
|
},
|
|
{ capabilities: { logging: {} } },
|
|
);
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
tools: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
let receivedLogMessage: string | undefined;
|
|
const loggingMessage = "hello here is log message 1";
|
|
|
|
client.setNotificationHandler(LoggingMessageNotificationSchema, (notification) => {
|
|
receivedLogMessage = notification.params.data as string;
|
|
});
|
|
|
|
mcpServer.tool("test-tool", async ({ sendNotification }) => {
|
|
await sendNotification({ method: "notifications/message", params: { level: "debug", data: loggingMessage } });
|
|
return {
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
],
|
|
};
|
|
});
|
|
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
await client.request(
|
|
{
|
|
method: "tools/call",
|
|
params: {
|
|
name: "test-tool",
|
|
},
|
|
},
|
|
CallToolResultSchema,
|
|
);
|
|
expect(receivedLogMessage).toBe(loggingMessage);
|
|
});
|
|
|
|
/***
|
|
* Test: Client to Server Tool Call
|
|
*/
|
|
test("should allow client to call server tools", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
tools: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
mcpServer.tool(
|
|
"test",
|
|
"Test tool",
|
|
{
|
|
input: z.string(),
|
|
},
|
|
async ({ input }) => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: `Processed: ${input}`,
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "tools/call",
|
|
params: {
|
|
name: "test",
|
|
arguments: {
|
|
input: "hello",
|
|
},
|
|
},
|
|
},
|
|
CallToolResultSchema,
|
|
);
|
|
|
|
expect(result.content).toEqual([
|
|
{
|
|
type: "text",
|
|
text: "Processed: hello",
|
|
},
|
|
]);
|
|
});
|
|
|
|
/***
|
|
* Test: Graceful Tool Error Handling
|
|
*/
|
|
test("should handle server tool errors gracefully", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
tools: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
mcpServer.tool("error-test", async () => {
|
|
throw new Error("Tool execution failed");
|
|
});
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "tools/call",
|
|
params: {
|
|
name: "error-test",
|
|
},
|
|
},
|
|
CallToolResultSchema,
|
|
);
|
|
|
|
expect(result.isError).toBe(true);
|
|
expect(result.content).toEqual([
|
|
{
|
|
type: "text",
|
|
text: "Tool execution failed",
|
|
},
|
|
]);
|
|
});
|
|
|
|
/***
|
|
* Test: McpError for Invalid Tool Name
|
|
*/
|
|
test("should throw McpError for invalid tool name", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
tools: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
mcpServer.tool("test-tool", async () => ({
|
|
content: [
|
|
{
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
],
|
|
}));
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
await expect(
|
|
client.request(
|
|
{
|
|
method: "tools/call",
|
|
params: {
|
|
name: "nonexistent-tool",
|
|
},
|
|
},
|
|
CallToolResultSchema,
|
|
),
|
|
).rejects.toThrow(/Tool nonexistent-tool not found/);
|
|
});
|
|
});
|
|
|
|
describe("resource()", () => {
|
|
/***
|
|
* Test: Resource Registration with URI and Read Callback
|
|
*/
|
|
test("should register resource with uri and readCallback", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.resource("test", "test://resource", async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource",
|
|
text: "Test content",
|
|
},
|
|
],
|
|
}));
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "resources/list",
|
|
},
|
|
ListResourcesResultSchema,
|
|
);
|
|
|
|
expect(result.resources).toHaveLength(1);
|
|
expect(result.resources[0].name).toBe("test");
|
|
expect(result.resources[0].uri).toBe("test://resource");
|
|
});
|
|
|
|
/***
|
|
* Test: Update Resource with URI
|
|
*/
|
|
test("should update resource with uri", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const notifications: Notification[] = [];
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification);
|
|
};
|
|
|
|
// Register initial resource
|
|
const resource = mcpServer.resource("test", "test://resource", async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource",
|
|
text: "Initial content",
|
|
},
|
|
],
|
|
}));
|
|
|
|
// Update the resource
|
|
resource.update({
|
|
callback: async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource",
|
|
text: "Updated content",
|
|
},
|
|
],
|
|
})
|
|
});
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.connect(serverTransport),
|
|
]);
|
|
|
|
// Read the resource and verify we get the updated content
|
|
const result = await client.request(
|
|
{
|
|
method: "resources/read",
|
|
params: {
|
|
uri: "test://resource",
|
|
},
|
|
},
|
|
ReadResourceResultSchema,
|
|
);
|
|
|
|
expect(result.contents).toHaveLength(1);
|
|
expect(result.contents[0].text).toBe("Updated content");
|
|
|
|
// Update happened before transport was connected, so no notifications should be expected
|
|
expect(notifications).toHaveLength(0);
|
|
});
|
|
|
|
/***
|
|
* Test: Update Resource Template
|
|
*/
|
|
test("should update resource template", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const notifications: Notification[] = [];
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification);
|
|
};
|
|
|
|
// Register initial resource template
|
|
const resourceTemplate = mcpServer.resource(
|
|
"test",
|
|
new ResourceTemplate("test://resource/{id}", { list: undefined }),
|
|
async (uri) => ({
|
|
contents: [
|
|
{
|
|
uri: uri.href,
|
|
text: "Initial content",
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
// Update the resource template
|
|
resourceTemplate.update({
|
|
callback: async (uri) => ({
|
|
contents: [
|
|
{
|
|
uri: uri.href,
|
|
text: "Updated content",
|
|
},
|
|
],
|
|
})
|
|
});
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.connect(serverTransport),
|
|
]);
|
|
|
|
// Read the resource and verify we get the updated content
|
|
const result = await client.request(
|
|
{
|
|
method: "resources/read",
|
|
params: {
|
|
uri: "test://resource/123",
|
|
},
|
|
},
|
|
ReadResourceResultSchema,
|
|
);
|
|
|
|
expect(result.contents).toHaveLength(1);
|
|
expect(result.contents[0].text).toBe("Updated content");
|
|
|
|
// Update happened before transport was connected, so no notifications should be expected
|
|
expect(notifications).toHaveLength(0);
|
|
});
|
|
|
|
/***
|
|
* Test: Resource List Changed Notification
|
|
*/
|
|
test("should send resource list changed notification when connected", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const notifications: Notification[] = [];
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification);
|
|
};
|
|
|
|
// Register initial resource
|
|
const resource = mcpServer.resource("test", "test://resource", async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource",
|
|
text: "Test content",
|
|
},
|
|
],
|
|
}));
|
|
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.connect(serverTransport),
|
|
]);
|
|
|
|
expect(notifications).toHaveLength(0);
|
|
|
|
// Now update the resource while connected
|
|
resource.update({
|
|
callback: async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource",
|
|
text: "Updated content",
|
|
},
|
|
],
|
|
})
|
|
});
|
|
|
|
// Yield event loop to let the notification fly
|
|
await new Promise(process.nextTick);
|
|
|
|
expect(notifications).toMatchObject([
|
|
{ method: "notifications/resources/list_changed" }
|
|
]);
|
|
});
|
|
|
|
/***
|
|
* Test: Remove Resource and Send Notification
|
|
*/
|
|
test("should remove resource and send notification when connected", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const notifications: Notification[] = [];
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification);
|
|
};
|
|
|
|
// Register initial resources
|
|
const resource1 = mcpServer.resource("resource1", "test://resource1", async () => ({
|
|
contents: [{ uri: "test://resource1", text: "Resource 1 content" }],
|
|
}));
|
|
|
|
mcpServer.resource("resource2", "test://resource2", async () => ({
|
|
contents: [{ uri: "test://resource2", text: "Resource 2 content" }],
|
|
}));
|
|
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.connect(serverTransport),
|
|
]);
|
|
|
|
// Verify both resources are registered
|
|
let result = await client.request(
|
|
{ method: "resources/list" },
|
|
ListResourcesResultSchema,
|
|
);
|
|
|
|
expect(result.resources).toHaveLength(2);
|
|
|
|
expect(notifications).toHaveLength(0);
|
|
|
|
// Remove a resource
|
|
resource1.remove()
|
|
|
|
// Yield event loop to let the notification fly
|
|
await new Promise(process.nextTick);
|
|
|
|
// Should have sent notification
|
|
expect(notifications).toMatchObject([
|
|
{ method: "notifications/resources/list_changed" }
|
|
]);
|
|
|
|
// Verify the resource was removed
|
|
result = await client.request(
|
|
{ method: "resources/list" },
|
|
ListResourcesResultSchema,
|
|
);
|
|
|
|
expect(result.resources).toHaveLength(1);
|
|
expect(result.resources[0].uri).toBe("test://resource2");
|
|
});
|
|
|
|
/***
|
|
* Test: Remove Resource Template and Send Notification
|
|
*/
|
|
test("should remove resource template and send notification when connected", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const notifications: Notification[] = [];
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification);
|
|
};
|
|
|
|
// Register resource template
|
|
const resourceTemplate = mcpServer.resource(
|
|
"template",
|
|
new ResourceTemplate("test://resource/{id}", { list: undefined }),
|
|
async (uri) => ({
|
|
contents: [
|
|
{
|
|
uri: uri.href,
|
|
text: "Template content",
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.connect(serverTransport),
|
|
]);
|
|
|
|
// Verify template is registered
|
|
const result = await client.request(
|
|
{ method: "resources/templates/list" },
|
|
ListResourceTemplatesResultSchema,
|
|
);
|
|
|
|
expect(result.resourceTemplates).toHaveLength(1);
|
|
expect(notifications).toHaveLength(0);
|
|
|
|
// Remove the template
|
|
resourceTemplate.remove()
|
|
|
|
// Yield event loop to let the notification fly
|
|
await new Promise(process.nextTick);
|
|
|
|
// Should have sent notification
|
|
expect(notifications).toMatchObject([
|
|
{ method: "notifications/resources/list_changed" }
|
|
]);
|
|
|
|
// Verify the template was removed
|
|
const result2 = await client.request(
|
|
{ method: "resources/templates/list" },
|
|
ListResourceTemplatesResultSchema,
|
|
);
|
|
|
|
expect(result2.resourceTemplates).toHaveLength(0);
|
|
});
|
|
|
|
/***
|
|
* Test: Resource Registration with Metadata
|
|
*/
|
|
test("should register resource with metadata", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.resource(
|
|
"test",
|
|
"test://resource",
|
|
{
|
|
description: "Test resource",
|
|
mimeType: "text/plain",
|
|
},
|
|
async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource",
|
|
text: "Test content",
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "resources/list",
|
|
},
|
|
ListResourcesResultSchema,
|
|
);
|
|
|
|
expect(result.resources).toHaveLength(1);
|
|
expect(result.resources[0].description).toBe("Test resource");
|
|
expect(result.resources[0].mimeType).toBe("text/plain");
|
|
});
|
|
|
|
/***
|
|
* Test: Resource Template Registration
|
|
*/
|
|
test("should register resource template", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.resource(
|
|
"test",
|
|
new ResourceTemplate("test://resource/{id}", { list: undefined }),
|
|
async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource/123",
|
|
text: "Test content",
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "resources/templates/list",
|
|
},
|
|
ListResourceTemplatesResultSchema,
|
|
);
|
|
|
|
expect(result.resourceTemplates).toHaveLength(1);
|
|
expect(result.resourceTemplates[0].name).toBe("test");
|
|
expect(result.resourceTemplates[0].uriTemplate).toBe(
|
|
"test://resource/{id}",
|
|
);
|
|
});
|
|
|
|
/***
|
|
* Test: Resource Template with List Callback
|
|
*/
|
|
test("should register resource template with listCallback", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.resource(
|
|
"test",
|
|
new ResourceTemplate("test://resource/{id}", {
|
|
list: async () => ({
|
|
resources: [
|
|
{
|
|
name: "Resource 1",
|
|
uri: "test://resource/1",
|
|
},
|
|
{
|
|
name: "Resource 2",
|
|
uri: "test://resource/2",
|
|
},
|
|
],
|
|
}),
|
|
}),
|
|
async (uri) => ({
|
|
contents: [
|
|
{
|
|
uri: uri.href,
|
|
text: "Test content",
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "resources/list",
|
|
},
|
|
ListResourcesResultSchema,
|
|
);
|
|
|
|
expect(result.resources).toHaveLength(2);
|
|
expect(result.resources[0].name).toBe("Resource 1");
|
|
expect(result.resources[0].uri).toBe("test://resource/1");
|
|
expect(result.resources[1].name).toBe("Resource 2");
|
|
expect(result.resources[1].uri).toBe("test://resource/2");
|
|
});
|
|
|
|
/***
|
|
* Test: Template Variables to Read Callback
|
|
*/
|
|
test("should pass template variables to readCallback", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.resource(
|
|
"test",
|
|
new ResourceTemplate("test://resource/{category}/{id}", {
|
|
list: undefined,
|
|
}),
|
|
async (uri, { category, id }) => ({
|
|
contents: [
|
|
{
|
|
uri: uri.href,
|
|
text: `Category: ${category}, ID: ${id}`,
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "resources/read",
|
|
params: {
|
|
uri: "test://resource/books/123",
|
|
},
|
|
},
|
|
ReadResourceResultSchema,
|
|
);
|
|
|
|
expect(result.contents[0].text).toBe("Category: books, ID: 123");
|
|
});
|
|
|
|
/***
|
|
* Test: Preventing Duplicate Resource Registration
|
|
*/
|
|
test("should prevent duplicate resource registration", () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.resource("test", "test://resource", async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource",
|
|
text: "Test content",
|
|
},
|
|
],
|
|
}));
|
|
|
|
expect(() => {
|
|
mcpServer.resource("test2", "test://resource", async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource",
|
|
text: "Test content 2",
|
|
},
|
|
],
|
|
}));
|
|
}).toThrow(/already registered/);
|
|
});
|
|
|
|
/***
|
|
* Test: Multiple Resource Registration
|
|
*/
|
|
test("should allow registering multiple resources", () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
// This should succeed
|
|
mcpServer.resource("resource1", "test://resource1", async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource1",
|
|
text: "Test content 1",
|
|
},
|
|
],
|
|
}));
|
|
|
|
// This should also succeed and not throw about request handlers
|
|
mcpServer.resource("resource2", "test://resource2", async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource2",
|
|
text: "Test content 2",
|
|
},
|
|
],
|
|
}));
|
|
});
|
|
|
|
/***
|
|
* Test: Preventing Duplicate Resource Template Registration
|
|
*/
|
|
test("should prevent duplicate resource template registration", () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.resource(
|
|
"test",
|
|
new ResourceTemplate("test://resource/{id}", { list: undefined }),
|
|
async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource/123",
|
|
text: "Test content",
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
expect(() => {
|
|
mcpServer.resource(
|
|
"test",
|
|
new ResourceTemplate("test://resource/{id}", { list: undefined }),
|
|
async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource/123",
|
|
text: "Test content 2",
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
}).toThrow(/already registered/);
|
|
});
|
|
|
|
/***
|
|
* Test: Graceful Resource Read Error Handling
|
|
*/
|
|
test("should handle resource read errors gracefully", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.resource("error-test", "test://error", async () => {
|
|
throw new Error("Resource read failed");
|
|
});
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
await expect(
|
|
client.request(
|
|
{
|
|
method: "resources/read",
|
|
params: {
|
|
uri: "test://error",
|
|
},
|
|
},
|
|
ReadResourceResultSchema,
|
|
),
|
|
).rejects.toThrow(/Resource read failed/);
|
|
});
|
|
|
|
/***
|
|
* Test: McpError for Invalid Resource URI
|
|
*/
|
|
test("should throw McpError for invalid resource URI", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.resource("test", "test://resource", async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource",
|
|
text: "Test content",
|
|
},
|
|
],
|
|
}));
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
await expect(
|
|
client.request(
|
|
{
|
|
method: "resources/read",
|
|
params: {
|
|
uri: "test://nonexistent",
|
|
},
|
|
},
|
|
ReadResourceResultSchema,
|
|
),
|
|
).rejects.toThrow(/Resource test:\/\/nonexistent not found/);
|
|
});
|
|
|
|
/***
|
|
* Test: Resource Template Parameter Completion
|
|
*/
|
|
test("should support completion of resource template parameters", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
resources: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
mcpServer.resource(
|
|
"test",
|
|
new ResourceTemplate("test://resource/{category}", {
|
|
list: undefined,
|
|
complete: {
|
|
category: () => ["books", "movies", "music"],
|
|
},
|
|
}),
|
|
async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource/test",
|
|
text: "Test content",
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "completion/complete",
|
|
params: {
|
|
ref: {
|
|
type: "ref/resource",
|
|
uri: "test://resource/{category}",
|
|
},
|
|
argument: {
|
|
name: "category",
|
|
value: "",
|
|
},
|
|
},
|
|
},
|
|
CompleteResultSchema,
|
|
);
|
|
|
|
expect(result.completion.values).toEqual(["books", "movies", "music"]);
|
|
expect(result.completion.total).toBe(3);
|
|
});
|
|
|
|
/***
|
|
* Test: Filtered Resource Template Parameter Completion
|
|
*/
|
|
test("should support filtered completion of resource template parameters", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
resources: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
mcpServer.resource(
|
|
"test",
|
|
new ResourceTemplate("test://resource/{category}", {
|
|
list: undefined,
|
|
complete: {
|
|
category: (test: string) =>
|
|
["books", "movies", "music"].filter((value) =>
|
|
value.startsWith(test),
|
|
),
|
|
},
|
|
}),
|
|
async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource/test",
|
|
text: "Test content",
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "completion/complete",
|
|
params: {
|
|
ref: {
|
|
type: "ref/resource",
|
|
uri: "test://resource/{category}",
|
|
},
|
|
argument: {
|
|
name: "category",
|
|
value: "m",
|
|
},
|
|
},
|
|
},
|
|
CompleteResultSchema,
|
|
);
|
|
|
|
expect(result.completion.values).toEqual(["movies", "music"]);
|
|
expect(result.completion.total).toBe(2);
|
|
});
|
|
|
|
/***
|
|
* Test: Pass Request ID to Resource Callback
|
|
*/
|
|
test("should pass requestId to resource callback via RequestHandlerExtra", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
resources: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
let receivedRequestId: string | number | undefined;
|
|
mcpServer.resource("request-id-test", "test://resource", async (_uri, extra) => {
|
|
receivedRequestId = extra.requestId;
|
|
return {
|
|
contents: [
|
|
{
|
|
uri: "test://resource",
|
|
text: `Received request ID: ${extra.requestId}`,
|
|
},
|
|
],
|
|
};
|
|
});
|
|
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "resources/read",
|
|
params: {
|
|
uri: "test://resource",
|
|
},
|
|
},
|
|
ReadResourceResultSchema,
|
|
);
|
|
|
|
expect(receivedRequestId).toBeDefined();
|
|
expect(typeof receivedRequestId === 'string' || typeof receivedRequestId === 'number').toBe(true);
|
|
expect(result.contents[0].text).toContain("Received request ID:");
|
|
});
|
|
});
|
|
|
|
describe("prompt()", () => {
|
|
/***
|
|
* Test: Zero-Argument Prompt Registration
|
|
*/
|
|
test("should register zero-argument prompt", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.prompt("test", async () => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
},
|
|
],
|
|
}));
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "prompts/list",
|
|
},
|
|
ListPromptsResultSchema,
|
|
);
|
|
|
|
expect(result.prompts).toHaveLength(1);
|
|
expect(result.prompts[0].name).toBe("test");
|
|
expect(result.prompts[0].arguments).toBeUndefined();
|
|
});
|
|
/***
|
|
* Test: Updating Existing Prompt
|
|
*/
|
|
test("should update existing prompt", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const notifications: Notification[] = [];
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification);
|
|
};
|
|
|
|
// Register initial prompt
|
|
const prompt = mcpServer.prompt("test", async () => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: "Initial response",
|
|
},
|
|
},
|
|
],
|
|
}));
|
|
|
|
// Update the prompt
|
|
prompt.update({
|
|
callback: async () => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: "Updated response",
|
|
},
|
|
},
|
|
],
|
|
})
|
|
});
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.connect(serverTransport),
|
|
]);
|
|
|
|
// Call the prompt and verify we get the updated response
|
|
const result = await client.request(
|
|
{
|
|
method: "prompts/get",
|
|
params: {
|
|
name: "test",
|
|
},
|
|
},
|
|
GetPromptResultSchema,
|
|
);
|
|
|
|
expect(result.messages).toHaveLength(1);
|
|
expect(result.messages[0].content.text).toBe("Updated response");
|
|
|
|
// Update happened before transport was connected, so no notifications should be expected
|
|
expect(notifications).toHaveLength(0);
|
|
});
|
|
|
|
/***
|
|
* Test: Updating Prompt with Schema
|
|
*/
|
|
test("should update prompt with schema", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const notifications: Notification[] = [];
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification);
|
|
};
|
|
|
|
// Register initial prompt
|
|
const prompt = mcpServer.prompt(
|
|
"test",
|
|
{
|
|
name: z.string(),
|
|
},
|
|
async ({ name }) => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: `Initial: ${name}`,
|
|
},
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
// Update the prompt with a different schema
|
|
prompt.update({
|
|
argsSchema: {
|
|
name: z.string(),
|
|
value: z.string(),
|
|
},
|
|
callback: async ({name, value}) => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: `Updated: ${name}, ${value}`,
|
|
},
|
|
},
|
|
],
|
|
})
|
|
});
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.connect(serverTransport),
|
|
]);
|
|
|
|
// Verify the schema was updated
|
|
const listResult = await client.request(
|
|
{
|
|
method: "prompts/list",
|
|
},
|
|
ListPromptsResultSchema,
|
|
);
|
|
|
|
expect(listResult.prompts[0].arguments).toHaveLength(2);
|
|
expect(listResult.prompts[0].arguments?.map(a => a.name).sort()).toEqual(["name", "value"]);
|
|
|
|
// Call the prompt with the new schema
|
|
const getResult = await client.request(
|
|
{
|
|
method: "prompts/get",
|
|
params: {
|
|
name: "test",
|
|
arguments: {
|
|
name: "test",
|
|
value: "value",
|
|
},
|
|
},
|
|
},
|
|
GetPromptResultSchema,
|
|
);
|
|
|
|
expect(getResult.messages).toHaveLength(1);
|
|
expect(getResult.messages[0].content.text).toBe("Updated: test, value");
|
|
|
|
// Update happened before transport was connected, so no notifications should be expected
|
|
expect(notifications).toHaveLength(0);
|
|
});
|
|
|
|
/***
|
|
* Test: Prompt List Changed Notification
|
|
*/
|
|
test("should send prompt list changed notification when connected", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const notifications: Notification[] = [];
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification);
|
|
};
|
|
|
|
// Register initial prompt
|
|
const prompt = mcpServer.prompt("test", async () => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
},
|
|
],
|
|
}));
|
|
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.connect(serverTransport),
|
|
]);
|
|
|
|
expect(notifications).toHaveLength(0);
|
|
|
|
// Now update the prompt while connected
|
|
prompt.update({
|
|
callback: async () => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: "Updated response",
|
|
},
|
|
},
|
|
],
|
|
})
|
|
});
|
|
|
|
// Yield event loop to let the notification fly
|
|
await new Promise(process.nextTick);
|
|
|
|
expect(notifications).toMatchObject([
|
|
{ method: "notifications/prompts/list_changed" }
|
|
]);
|
|
});
|
|
|
|
/***
|
|
* Test: Remove Prompt and Send Notification
|
|
*/
|
|
test("should remove prompt and send notification when connected", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const notifications: Notification[] = [];
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
client.fallbackNotificationHandler = async (notification) => {
|
|
notifications.push(notification);
|
|
};
|
|
|
|
// Register initial prompts
|
|
const prompt1 = mcpServer.prompt("prompt1", async () => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: "Prompt 1 response",
|
|
},
|
|
},
|
|
],
|
|
}));
|
|
|
|
mcpServer.prompt("prompt2", async () => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: "Prompt 2 response",
|
|
},
|
|
},
|
|
],
|
|
}));
|
|
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.connect(serverTransport),
|
|
]);
|
|
|
|
// Verify both prompts are registered
|
|
let result = await client.request(
|
|
{ method: "prompts/list" },
|
|
ListPromptsResultSchema,
|
|
);
|
|
|
|
expect(result.prompts).toHaveLength(2);
|
|
expect(result.prompts.map(p => p.name).sort()).toEqual(["prompt1", "prompt2"]);
|
|
|
|
expect(notifications).toHaveLength(0);
|
|
|
|
// Remove a prompt
|
|
prompt1.remove()
|
|
|
|
// Yield event loop to let the notification fly
|
|
await new Promise(process.nextTick);
|
|
|
|
// Should have sent notification
|
|
expect(notifications).toMatchObject([
|
|
{ method: "notifications/prompts/list_changed" }
|
|
]);
|
|
|
|
// Verify the prompt was removed
|
|
result = await client.request(
|
|
{ method: "prompts/list" },
|
|
ListPromptsResultSchema,
|
|
);
|
|
|
|
expect(result.prompts).toHaveLength(1);
|
|
expect(result.prompts[0].name).toBe("prompt2");
|
|
});
|
|
|
|
/***
|
|
* Test: Prompt Registration with Arguments Schema
|
|
*/
|
|
test("should register prompt with args schema", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.prompt(
|
|
"test",
|
|
{
|
|
name: z.string(),
|
|
value: z.string(),
|
|
},
|
|
async ({ name, value }) => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: `${name}: ${value}`,
|
|
},
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "prompts/list",
|
|
},
|
|
ListPromptsResultSchema,
|
|
);
|
|
|
|
expect(result.prompts).toHaveLength(1);
|
|
expect(result.prompts[0].name).toBe("test");
|
|
expect(result.prompts[0].arguments).toEqual([
|
|
{ name: "name", required: true },
|
|
{ name: "value", required: true },
|
|
]);
|
|
});
|
|
|
|
/***
|
|
* Test: Prompt Registration with Description
|
|
*/
|
|
test("should register prompt with description", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
const client = new Client({
|
|
name: "test client",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.prompt("test", "Test description", async () => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
},
|
|
],
|
|
}));
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "prompts/list",
|
|
},
|
|
ListPromptsResultSchema,
|
|
);
|
|
|
|
expect(result.prompts).toHaveLength(1);
|
|
expect(result.prompts[0].name).toBe("test");
|
|
expect(result.prompts[0].description).toBe("Test description");
|
|
});
|
|
|
|
/***
|
|
* Test: Prompt Argument Validation
|
|
*/
|
|
test("should validate prompt args", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
prompts: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
mcpServer.prompt(
|
|
"test",
|
|
{
|
|
name: z.string(),
|
|
value: z.string().min(3),
|
|
},
|
|
async ({ name, value }) => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: `${name}: ${value}`,
|
|
},
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
await expect(
|
|
client.request(
|
|
{
|
|
method: "prompts/get",
|
|
params: {
|
|
name: "test",
|
|
arguments: {
|
|
name: "test",
|
|
value: "ab", // Too short
|
|
},
|
|
},
|
|
},
|
|
GetPromptResultSchema,
|
|
),
|
|
).rejects.toThrow(/Invalid arguments/);
|
|
});
|
|
|
|
/***
|
|
* Test: Preventing Duplicate Prompt Registration
|
|
*/
|
|
test("should prevent duplicate prompt registration", () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
mcpServer.prompt("test", async () => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
},
|
|
],
|
|
}));
|
|
|
|
expect(() => {
|
|
mcpServer.prompt("test", async () => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: "Test response 2",
|
|
},
|
|
},
|
|
],
|
|
}));
|
|
}).toThrow(/already registered/);
|
|
});
|
|
|
|
/***
|
|
* Test: Multiple Prompt Registration
|
|
*/
|
|
test("should allow registering multiple prompts", () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
// This should succeed
|
|
mcpServer.prompt("prompt1", async () => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: "Test response 1",
|
|
},
|
|
},
|
|
],
|
|
}));
|
|
|
|
// This should also succeed and not throw about request handlers
|
|
mcpServer.prompt("prompt2", async () => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: "Test response 2",
|
|
},
|
|
},
|
|
],
|
|
}));
|
|
});
|
|
|
|
/***
|
|
* Test: Prompt Registration with Arguments
|
|
*/
|
|
test("should allow registering prompts with arguments", () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
// This should succeed
|
|
mcpServer.prompt(
|
|
"echo",
|
|
{ message: z.string() },
|
|
({ message }) => ({
|
|
messages: [{
|
|
role: "user",
|
|
content: {
|
|
type: "text",
|
|
text: `Please process this message: ${message}`
|
|
}
|
|
}]
|
|
})
|
|
);
|
|
});
|
|
|
|
/***
|
|
* Test: Resources and Prompts with Completion Handlers
|
|
*/
|
|
test("should allow registering both resources and prompts with completion handlers", () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
// Register a resource with completion
|
|
mcpServer.resource(
|
|
"test",
|
|
new ResourceTemplate("test://resource/{category}", {
|
|
list: undefined,
|
|
complete: {
|
|
category: () => ["books", "movies", "music"],
|
|
},
|
|
}),
|
|
async () => ({
|
|
contents: [
|
|
{
|
|
uri: "test://resource/test",
|
|
text: "Test content",
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
// Register a prompt with completion
|
|
mcpServer.prompt(
|
|
"echo",
|
|
{ message: completable(z.string(), () => ["hello", "world"]) },
|
|
({ message }) => ({
|
|
messages: [{
|
|
role: "user",
|
|
content: {
|
|
type: "text",
|
|
text: `Please process this message: ${message}`
|
|
}
|
|
}]
|
|
})
|
|
);
|
|
});
|
|
|
|
/***
|
|
* Test: McpError for Invalid Prompt Name
|
|
*/
|
|
test("should throw McpError for invalid prompt name", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
prompts: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
mcpServer.prompt("test-prompt", async () => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: "Test response",
|
|
},
|
|
},
|
|
],
|
|
}));
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
await expect(
|
|
client.request(
|
|
{
|
|
method: "prompts/get",
|
|
params: {
|
|
name: "nonexistent-prompt",
|
|
},
|
|
},
|
|
GetPromptResultSchema,
|
|
),
|
|
).rejects.toThrow(/Prompt nonexistent-prompt not found/);
|
|
});
|
|
|
|
/***
|
|
* Test: Prompt Argument Completion
|
|
*/
|
|
test("should support completion of prompt arguments", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
prompts: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
mcpServer.prompt(
|
|
"test-prompt",
|
|
{
|
|
name: completable(z.string(), () => ["Alice", "Bob", "Charlie"]),
|
|
},
|
|
async ({ name }) => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: `Hello ${name}`,
|
|
},
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "completion/complete",
|
|
params: {
|
|
ref: {
|
|
type: "ref/prompt",
|
|
name: "test-prompt",
|
|
},
|
|
argument: {
|
|
name: "name",
|
|
value: "",
|
|
},
|
|
},
|
|
},
|
|
CompleteResultSchema,
|
|
);
|
|
|
|
expect(result.completion.values).toEqual(["Alice", "Bob", "Charlie"]);
|
|
expect(result.completion.total).toBe(3);
|
|
});
|
|
|
|
/***
|
|
* Test: Filtered Prompt Argument Completion
|
|
*/
|
|
test("should support filtered completion of prompt arguments", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
prompts: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
mcpServer.prompt(
|
|
"test-prompt",
|
|
{
|
|
name: completable(z.string(), (test) =>
|
|
["Alice", "Bob", "Charlie"].filter((value) => value.startsWith(test)),
|
|
),
|
|
},
|
|
async ({ name }) => ({
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: `Hello ${name}`,
|
|
},
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "completion/complete",
|
|
params: {
|
|
ref: {
|
|
type: "ref/prompt",
|
|
name: "test-prompt",
|
|
},
|
|
argument: {
|
|
name: "name",
|
|
value: "A",
|
|
},
|
|
},
|
|
},
|
|
CompleteResultSchema,
|
|
);
|
|
|
|
expect(result.completion.values).toEqual(["Alice"]);
|
|
expect(result.completion.total).toBe(1);
|
|
});
|
|
|
|
/***
|
|
* Test: Pass Request ID to Prompt Callback
|
|
*/
|
|
test("should pass requestId to prompt callback via RequestHandlerExtra", async () => {
|
|
const mcpServer = new McpServer({
|
|
name: "test server",
|
|
version: "1.0",
|
|
});
|
|
|
|
const client = new Client(
|
|
{
|
|
name: "test client",
|
|
version: "1.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
prompts: {},
|
|
},
|
|
},
|
|
);
|
|
|
|
let receivedRequestId: string | number | undefined;
|
|
mcpServer.prompt("request-id-test", async (extra) => {
|
|
receivedRequestId = extra.requestId;
|
|
return {
|
|
messages: [
|
|
{
|
|
role: "assistant",
|
|
content: {
|
|
type: "text",
|
|
text: `Received request ID: ${extra.requestId}`,
|
|
},
|
|
},
|
|
],
|
|
};
|
|
});
|
|
|
|
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
|
|
|
|
await Promise.all([
|
|
client.connect(clientTransport),
|
|
mcpServer.server.connect(serverTransport),
|
|
]);
|
|
|
|
const result = await client.request(
|
|
{
|
|
method: "prompts/get",
|
|
params: {
|
|
name: "request-id-test",
|
|
},
|
|
},
|
|
GetPromptResultSchema,
|
|
);
|
|
|
|
expect(receivedRequestId).toBeDefined();
|
|
expect(typeof receivedRequestId === 'string' || typeof receivedRequestId === 'number').toBe(true);
|
|
expect(result.messages[0].content.text).toContain("Received request ID:");
|
|
});
|
|
});
|