@mastra/mcp 0.10.5-alpha.0 → 0.10.5-alpha.2

package/src/server/server.test.ts

@@ -1347,3 +1347,436 @@ describe('MCPServer - Workflow to Tool Conversion', () => {
     expect(server.tools()['run_unique_workflow_key_789']).toBeDefined();
   });
 });
+
+describe('MCPServer - Elicitation', () => {
+  let elicitationServer: MCPServer;
+  let elicitationClient: InternalMastraMCPClient;
+  let elicitationHttpServer: http.Server;
+  const ELICITATION_PORT = 9600 + Math.floor(Math.random() * 1000);
+
+  beforeAll(async () => {
+    elicitationServer = new MCPServer({
+      name: 'ElicitationTestServer',
+      version: '1.0.0',
+      tools: {
+        testElicitationTool: {
+          description: 'A tool that uses elicitation to collect user input',
+          parameters: z.object({
+            message: z.string().describe('Message to show to user'),
+          }),
+          execute: async (context, options) => {
+            // Use the session-aware elicitation functionality
+            try {
+              const elicitation = options.elicitation;
+              const result = await elicitation.sendRequest({
+                message: context.message,
+                requestedSchema: {
+                  type: 'object',
+                  properties: {
+                    name: { type: 'string', title: 'Name' },
+                    email: { type: 'string', title: 'Email', format: 'email' },
+                  },
+                  required: ['name'],
+                },
+              });
+              return result;
+            } catch (error) {
+              console.error('Error sending elicitation request:', error);
+              return {
+                content: [
+                  {
+                    type: 'text',
+                    text: `Error collecting information: ${error}`,
+                  },
+                ],
+                isError: true,
+              };
+            }
+          },
+        },
+      },
+    });
+
+    beforeEach(async () => {
+      try {
+        await elicitationClient?.disconnect();
+      } catch (error) {
+        console.error('Error disconnecting elicitation client:', error);
+      }
+    });
+
+    elicitationHttpServer = http.createServer(async (req: http.IncomingMessage, res: http.ServerResponse) => {
+      const url = new URL(req.url || '', `http://localhost:${ELICITATION_PORT}`);
+      await elicitationServer.startHTTP({
+        url,
+        httpPath: '/http',
+        req,
+        res,
+      });
+    });
+
+    await new Promise<void>(resolve => elicitationHttpServer.listen(ELICITATION_PORT, () => resolve()));
+  });
+
+  afterAll(async () => {
+    await elicitationClient?.disconnect();
+    if (elicitationHttpServer) {
+      elicitationHttpServer.closeAllConnections?.();
+      await new Promise<void>((resolve, reject) => {
+        elicitationHttpServer.close(err => {
+          if (err) return reject(err);
+          resolve();
+        });
+      });
+    }
+    if (elicitationServer) {
+      await elicitationServer.close();
+    }
+  });
+
+  it('should have elicitation capability enabled', () => {
+    // Test that the server has elicitation functionality available
+    expect(elicitationServer.elicitation).toBeDefined();
+    expect(elicitationServer.elicitation.sendRequest).toBeDefined();
+  });
+
+  it('should handle elicitation request with accept response', async () => {
+    const mockElicitationHandler = vi.fn(async request => {
+      expect(request.message).toBe('Please provide your information');
+      expect(request.requestedSchema).toBeDefined();
+      expect(request.requestedSchema.properties.name).toBeDefined();
+
+      return {
+        action: 'accept' as const,
+        content: {
+          name: 'John Doe',
+          email: 'john@example.com',
+        },
+      };
+    });
+
+    elicitationClient = new InternalMastraMCPClient({
+      name: 'elicitation-test-client',
+      server: {
+        url: new URL(`http://localhost:${ELICITATION_PORT}/http`),
+      },
+    });
+    elicitationClient.elicitation.onRequest(mockElicitationHandler);
+    await elicitationClient.connect();
+
+    const tools = await elicitationClient.tools();
+    const tool = tools['testElicitationTool'];
+    expect(tool).toBeDefined();
+
+    const result = await tool.execute({
+      context: {
+        message: 'Please provide your information',
+      },
+    });
+
+    expect(mockElicitationHandler).toHaveBeenCalledTimes(1);
+    expect(JSON.parse(result.content[0].text)).toEqual({
+      action: 'accept',
+      content: {
+        name: 'John Doe',
+        email: 'john@example.com',
+      },
+    });
+  });
+
+  it('should handle elicitation request with reject response', async () => {
+    const mockElicitationHandler = vi.fn(async request => {
+      expect(request.message).toBe('Please provide sensitive data');
+      return { action: 'reject' as const };
+    });
+
+    elicitationClient = new InternalMastraMCPClient({
+      name: 'elicitation-reject-client',
+      server: {
+        url: new URL(`http://localhost:${ELICITATION_PORT}/http`),
+      },
+    });
+    elicitationClient.elicitation.onRequest(mockElicitationHandler);
+    await elicitationClient.connect();
+
+    const tools = await elicitationClient.tools();
+    const tool = tools['testElicitationTool'];
+
+    const result = await tool.execute({
+      context: {
+        message: 'Please provide sensitive data',
+      },
+    });
+
+    expect(mockElicitationHandler).toHaveBeenCalledTimes(1);
+    expect(JSON.parse(result.content[0].text)).toEqual({ action: 'reject' });
+  });
+
+  it('should handle elicitation request with cancel response', async () => {
+    const mockElicitationHandler = vi.fn(async () => {
+      return { action: 'cancel' as const };
+    });
+
+    elicitationClient = new InternalMastraMCPClient({
+      name: 'elicitation-cancel-client',
+      server: {
+        url: new URL(`http://localhost:${ELICITATION_PORT}/http`),
+      },
+    });
+    elicitationClient.elicitation.onRequest(mockElicitationHandler);
+    await elicitationClient.connect();
+
+    const tools = await elicitationClient.tools();
+    const tool = tools['testElicitationTool'];
+
+    const result = await tool.execute({
+      context: {
+        message: 'Please provide optional data',
+      },
+    });
+
+    expect(mockElicitationHandler).toHaveBeenCalledTimes(1);
+    expect(JSON.parse(result.content[0].text)).toEqual({ action: 'cancel' });
+  });
+
+  it('should error when elicitation handler throws error', async () => {
+    const mockElicitationHandler = vi.fn(async () => {
+      throw new Error('Handler error');
+    });
+
+    elicitationClient = new InternalMastraMCPClient({
+      name: 'elicitation-error-client',
+      server: {
+        url: new URL(`http://localhost:${ELICITATION_PORT}/http`),
+      },
+    });
+    elicitationClient.elicitation.onRequest(mockElicitationHandler);
+    await elicitationClient.connect();
+
+    const tools = await elicitationClient.tools();
+    const tool = tools['testElicitationTool'];
+
+    const result = await tool.execute({
+      context: {
+        message: 'This will cause an error',
+      },
+    });
+
+    expect(mockElicitationHandler).toHaveBeenCalledTimes(1);
+    expect(result.content[0].text).toContain('Handler error');
+  });
+
+  it('should error when client has no elicitation handler', async () => {
+    elicitationClient = new InternalMastraMCPClient({
+      name: 'no-elicitation-handler-client',
+      server: {
+        url: new URL(`http://localhost:${ELICITATION_PORT}/http`),
+        // No elicitationHandler provided
+      },
+    });
+    await elicitationClient.connect();
+
+    const tools = await elicitationClient.tools();
+    const tool = tools['testElicitationTool'];
+
+    const result = await tool.execute({
+      context: {
+        message: 'This should fail gracefully',
+      },
+    });
+
+    // When no elicitation handler is provided, the server's elicitInput should fail
+    // and the tool should return a reject response
+    expect(result.content[0].text).toContain('Method not found');
+  });
+
+  it('should validate elicitation request schema structure', async () => {
+    const mockElicitationHandler = vi.fn(async request => {
+      expect(request.message).toBe('Please provide your information');
+      expect(request.requestedSchema).toBeDefined();
+      expect(request.requestedSchema.properties.name).toBeDefined();
+
+      return {
+        action: 'accept' as const,
+        content: {
+          validated: true,
+        },
+      };
+    });
+
+    elicitationClient = new InternalMastraMCPClient({
+      name: 'elicitation-test-client',
+      server: {
+        url: new URL(`http://localhost:${ELICITATION_PORT}/http`),
+      },
+    });
+    elicitationClient.elicitation.onRequest(mockElicitationHandler);
+    await elicitationClient.connect();
+
+    const tools = await elicitationClient.tools();
+    const tool = tools['testElicitationTool'];
+    expect(tool).toBeDefined();
+
+    const result = await tool.execute({
+      context: {
+        message: 'Please provide your information',
+      },
+    });
+
+    expect(mockElicitationHandler).toHaveBeenCalledTimes(1);
+    expect(result.content[0].text).toContain('Elicitation response content does not match requested schema');
+  });
+
+  it('should isolate elicitation handlers between different client connections', async () => {
+    const client1Handler = vi.fn(async request => {
+      expect(request.message).toBe('Please provide your information');
+      expect(request.requestedSchema).toBeDefined();
+      expect(request.requestedSchema.properties.name).toBeDefined();
+
+      return {
+        action: 'accept' as const,
+        content: {
+          name: 'John Doe',
+          email: 'john@example.com',
+        },
+      };
+    });
+    const client2Handler = vi.fn(async request => {
+      expect(request.message).toBe('Please provide your information');
+      expect(request.requestedSchema).toBeDefined();
+      expect(request.requestedSchema.properties.name).toBeDefined();
+
+      return {
+        action: 'accept' as const,
+        content: {
+          name: 'John Doe',
+          email: 'john@example.com',
+        },
+      };
+    });
+
+    // Create two independent client instances
+    const elicitationClient1 = new MCPClient({
+      id: 'elicitation-isolation-client-1',
+      servers: {
+        elicitation1: {
+          url: new URL(`http://localhost:${ELICITATION_PORT}/http`),
+        },
+      },
+    });
+
+    const elicitationClient2 = new MCPClient({
+      id: 'elicitation-isolation-client-2',
+      servers: {
+        elicitation2: {
+          url: new URL(`http://localhost:${ELICITATION_PORT}/http`),
+        },
+      },
+    });
+
+    // Each client registers its own independent handler
+    elicitationClient1.elicitation.onRequest('elicitation1', client1Handler);
+    elicitationClient2.elicitation.onRequest('elicitation2', client2Handler);
+
+    const tools = await elicitationClient1.getTools();
+    const tool = tools['elicitation1_testElicitationTool'];
+    expect(tool).toBeDefined();
+    await tool.execute({
+      context: {
+        message: 'Please provide your information',
+      },
+    });
+
+    const tools2 = await elicitationClient2.getTools();
+    const tool2 = tools2['elicitation2_testElicitationTool'];
+    expect(tool2).toBeDefined();
+
+    // Verify handlers are isolated - they should not interfere with each other
+    expect(client1Handler).toHaveBeenCalled();
+    expect(client2Handler).not.toHaveBeenCalled();
+  }, 10000);
+});
+
+describe('MCPServer with Tool Output Schema', () => {
+  let serverWithOutputSchema: MCPServer;
+  let clientWithOutputSchema: MCPClient;
+  const PORT = 9600 + Math.floor(Math.random() * 1000);
+  let httpServerWithOutputSchema: http.Server;
+
+  const structuredTool: ToolsInput = {
+    structuredTool: {
+      description: 'A test tool with structured output',
+      parameters: z.object({ input: z.string() }),
+      outputSchema: z.object({
+        processedInput: z.string(),
+        timestamp: z.string(),
+      }),
+      execute: async ({ input }: { input: string }) => ({
+        structuredContent: {
+          processedInput: `processed: ${input}`,
+          timestamp: mockDateISO,
+        },
+      }),
+    },
+  };
+
+  beforeAll(async () => {
+    serverWithOutputSchema = new MCPServer({
+      name: 'Test MCP Server with OutputSchema',
+      version: '0.1.0',
+      tools: structuredTool,
+    });
+
+    httpServerWithOutputSchema = http.createServer(async (req: http.IncomingMessage, res: http.ServerResponse) => {
+      const url = new URL(req.url || '', `http://localhost:${PORT}`);
+      await serverWithOutputSchema.startHTTP({
+        url,
+        httpPath: '/http',
+        req,
+        res,
+      });
+    });
+
+    await new Promise<void>(resolve => httpServerWithOutputSchema.listen(PORT, () => resolve()));
+
+    clientWithOutputSchema = new MCPClient({
+      servers: {
+        local: {
+          url: new URL(`http://localhost:${PORT}/http`),
+        },
+      },
+    });
+  });
+
+  afterAll(async () => {
+    httpServerWithOutputSchema.closeAllConnections?.();
+    await new Promise<void>(resolve =>
+      httpServerWithOutputSchema.close(() => {
+        resolve();
+      }),
+    );
+    await serverWithOutputSchema.close();
+  });
+
+  it('should list tool with outputSchema', async () => {
+    const tools = await clientWithOutputSchema.getTools();
+    const tool = tools['local_structuredTool'];
+    expect(tool).toBeDefined();
+    expect(tool.outputSchema).toBeDefined();
+  });
+
+  it('should call tool and receive structuredContent', async () => {
+    const tools = await clientWithOutputSchema.getTools();
+    const tool = tools['local_structuredTool'];
+    const result = await tool.execute({ context: { input: 'hello' } });
+
+    expect(result).toBeDefined();
+    expect(result.structuredContent).toBeDefined();
+    expect(result.structuredContent.processedInput).toBe('processed: hello');
+    expect(result.structuredContent.timestamp).toBe(mockDateISO);
+
+    expect(result.content).toBeDefined();
+    expect(result.content[0].type).toBe('text');
+    expect(JSON.parse(result.content[0].text)).toEqual(result.structuredContent);
+  });
+});