add streamable Actor server tests, improve consistency with real setup

MQ37 · MQ37 · commit c72676df152a · 2025-05-01T21:56:09.000+02:00
diff --git a/src/actor/server.ts b/src/actor/server.ts
@@ -125,10 +125,12 @@ export function createExpressApp(
                 });
                 // Load MCP server tools
                 // TODO using query parameters in POST request is not standard
-                const urlSearchParams = new URLSearchParams(req.url.split('?')[1]);
-                if (urlSearchParams.get('actors')) {
+                const input = parseInputParamsFromUrl(req.url);
+                if (input.actors || input.enableAddingActors) {
                     await mcpServer.loadToolsFromUrl(req.url, process.env.APIFY_TOKEN as string);
-                } else {
+                }
+                // Load default tools if no actors are specified
+                if (!input.actors) {
                     await mcpServer.loadDefaultTools(process.env.APIFY_TOKEN as string);
                 }
 
diff --git a/src/mcp/server.ts b/src/mcp/server.ts
@@ -295,4 +295,8 @@ export class ActorsMcpServer {
     async connect(transport: Transport): Promise<void> {
         await this.server.connect(transport);
     }
+
+    async close(): Promise<void> {
+        await this.server.close();
+    }
 }
diff --git a/tests/integration/actor.server.test.ts b/tests/integration/actor.server.test.ts
@@ -2,6 +2,7 @@ import type { Server as HttpServer } from 'node:http';
 
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import type { Express } from 'express';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
@@ -12,7 +13,7 @@ import { defaults, HelperTools } from '../../src/const.js';
 import { ActorsMcpServer } from '../../src/mcp/server.js';
 import { actorNameToToolName } from '../../src/tools/utils.js';
 
-async function createMCPClient(
+async function createMCPSSEClient(
     serverUrl: string,
     options?: {
         actors?: string[];
@@ -39,17 +40,45 @@ async function createMCPClient(
                     authorization: `Bearer ${process.env.APIFY_TOKEN}`,
                 },
             },
-            eventSourceInit: {
-                // The EventSource package augments EventSourceInit with a "fetch" parameter.
-                // You can use this to set additional headers on the outgoing request.
-                // Based on this example: https://github.com/modelcontextprotocol/typescript-sdk/issues/118
-                async fetch(input: Request | URL | string, init?: RequestInit) {
-                    const headers = new Headers(init?.headers || {});
-                    headers.set('authorization', `Bearer ${process.env.APIFY_TOKEN}`);
-                    return fetch(input, { ...init, headers });
+        },
+    );
+
+    const client = new Client({
+        name: 'sse-client',
+        version: '1.0.0',
+    });
+    await client.connect(transport);
+
+    return client;
+}
+
+async function createMCPStreamableClient(
+    serverUrl: string,
+    options?: {
+        actors?: string[];
+        enableAddingActors?: boolean;
+    },
+): Promise<Client> {
+    if (!process.env.APIFY_TOKEN) {
+        throw new Error('APIFY_TOKEN environment variable is not set.');
+    }
+    const url = new URL(serverUrl);
+    const { actors, enableAddingActors } = options || {};
+    if (actors) {
+        url.searchParams.append('actors', actors.join(','));
+    }
+    if (enableAddingActors) {
+        url.searchParams.append('enableAddingActors', 'true');
+    }
+
+    const transport = new StreamableHTTPClientTransport(
+        url,
+        {
+            requestInit: {
+                headers: {
+                    authorization: `Bearer ${process.env.APIFY_TOKEN}`,
                 },
-            // We have to cast to "any" to use it, since it's non-standard
-            } as any, // eslint-disable-line @typescript-eslint/no-explicit-any
+            },
         },
     );
 
@@ -62,17 +91,22 @@ async function createMCPClient(
     return client;
 }
 
-describe('Actors MCP Server', {
+describe('Actors MCP Server SSE', {
     concurrent: false, // Run test serially to prevent port already in use
 }, () => {
     let app: Express;
     let server: ActorsMcpServer;
     let httpServer: HttpServer;
-    const testPort = 7357;
+    const testPort = 50000;
     const testHost = `http://localhost:${testPort}`;
 
     beforeEach(async () => {
-        server = new ActorsMcpServer();
+        // same as in main.ts
+        // TODO: unify
+        server = new ActorsMcpServer({
+            enableAddingActors: false,
+            enableDefaultActors: false,
+        });
         log.setLevel(log.LEVELS.OFF);
 
         // Create express app using the proper server setup
@@ -82,9 +116,13 @@ describe('Actors MCP Server', {
         await new Promise<void>((resolve) => {
             httpServer = app.listen(testPort, () => resolve());
         });
+
+        // TODO: figure out why this is needed
+        await new Promise<void>((resolve) => { setTimeout(resolve, 1000); });
     });
 
     afterEach(async () => {
+        await server.close();
         await new Promise<void>((resolve) => {
             httpServer.close(() => resolve());
         });
@@ -122,7 +160,203 @@ describe('Actors MCP Server', {
     });
 
     it('default tools list', async () => {
-        const client = await createMCPClient(`${testHost}/sse`);
+        const client = await createMCPSSEClient(`${testHost}/sse`);
+
+        const tools = await client.listTools();
+        const names = tools.tools.map((tool) => tool.name);
+        expect(names.length).toEqual(defaults.helperTools.length + defaults.actors.length);
+        for (const tool of defaults.helperTools) {
+            expect(names).toContain(tool);
+        }
+        for (const actorTool of defaults.actors) {
+            expect(names).toContain(actorNameToToolName(actorTool));
+        }
+
+        await client.close();
+    });
+
+    it('use only specific Actor and call it', async () => {
+        const actorName = 'apify/python-example';
+        const selectedToolName = actorNameToToolName(actorName);
+        const client = await createMCPSSEClient(`${testHost}/sse`, {
+            actors: [actorName],
+            enableAddingActors: false,
+        });
+
+        const tools = await client.listTools();
+        const names = tools.tools.map((tool) => tool.name);
+        expect(names.length).toEqual(defaults.helperTools.length + 1);
+        for (const tool of defaults.helperTools) {
+            expect(names).toContain(tool);
+        }
+        expect(names).toContain(selectedToolName);
+
+        const result = await client.callTool({
+            name: selectedToolName,
+            arguments: {
+                first_number: 1,
+                second_number: 2,
+            },
+        });
+
+        expect(result).toEqual({
+            content: [{
+                text: JSON.stringify({
+                    first_number: 1,
+                    second_number: 2,
+                    sum: 3,
+                }),
+                type: 'text',
+            }],
+        });
+
+        await client.close();
+    });
+
+    it('load Actors from parameters', async () => {
+        const actors = ['apify/rag-web-browser', 'apify/instagram-scraper'];
+        const client = await createMCPSSEClient(`${testHost}/sse`, {
+            actors,
+            enableAddingActors: false,
+        });
+
+        const tools = await client.listTools();
+        const names = tools.tools.map((tool) => tool.name);
+        expect(names.length).toEqual(defaults.helperTools.length + actors.length);
+        for (const tool of defaults.helperTools) {
+            expect(names).toContain(tool);
+        }
+        for (const actor of actors) {
+            expect(names).toContain(actorNameToToolName(actor));
+        }
+
+        await client.close();
+    });
+
+    it('load Actor dynamically and call it', async () => {
+        const actor = 'apify/python-example';
+        const selectedToolName = actorNameToToolName(actor);
+        const client = await createMCPSSEClient(`${testHost}/sse`, {
+            enableAddingActors: true,
+        });
+
+        const tools = await client.listTools();
+        const names = tools.tools.map((tool) => tool.name);
+        expect(names.length).toEqual(defaults.helperTools.length + defaults.actorAddingTools.length + defaults.actors.length);
+        for (const tool of defaults.helperTools) {
+            expect(names).toContain(tool);
+        }
+        for (const tool of defaults.actorAddingTools) {
+            expect(names).toContain(tool);
+        }
+        for (const actorTool of defaults.actors) {
+            expect(names).toContain(actorNameToToolName(actorTool));
+        }
+
+        // Add Actor dynamically
+        await client.callTool({
+            name: HelperTools.ADD_ACTOR,
+            arguments: {
+                actorName: actor,
+            },
+        });
+
+        // Check if tools was added
+        const toolsAfterAdd = await client.listTools();
+        const namesAfterAdd = toolsAfterAdd.tools.map((tool) => tool.name);
+        expect(namesAfterAdd.length).toEqual(defaults.helperTools.length + defaults.actorAddingTools.length + defaults.actors.length + 1);
+        expect(namesAfterAdd).toContain(selectedToolName);
+
+        const result = await client.callTool({
+            name: selectedToolName,
+            arguments: {
+                first_number: 1,
+                second_number: 2,
+            },
+        });
+
+        expect(result).toEqual({
+            content: [{
+                text: JSON.stringify({
+                    first_number: 1,
+                    second_number: 2,
+                    sum: 3,
+                }),
+                type: 'text',
+            }],
+        });
+
+        await client.close();
+    });
+
+    it('should remove Actor from tools list', async () => {
+        const actor = 'apify/python-example';
+        const selectedToolName = actorNameToToolName(actor);
+        const client = await createMCPSSEClient(`${testHost}/sse`, {
+            actors: [actor],
+            enableAddingActors: true,
+        });
+
+        // Verify actor is in the tools list
+        const toolsBefore = await client.listTools();
+        const namesBefore = toolsBefore.tools.map((tool) => tool.name);
+        expect(namesBefore).toContain(selectedToolName);
+
+        // Remove the actor
+        await client.callTool({
+            name: HelperTools.REMOVE_ACTOR,
+            arguments: {
+                toolName: selectedToolName,
+            },
+        });
+
+        // Verify actor is removed
+        const toolsAfter = await client.listTools();
+        const namesAfter = toolsAfter.tools.map((tool) => tool.name);
+        expect(namesAfter).not.toContain(selectedToolName);
+
+        await client.close();
+    });
+});
+
+describe('Actors MCP Server Streamable HTTP', {
+    concurrent: false, // Run test serially to prevent port already in use
+}, () => {
+    let app: Express;
+    let server: ActorsMcpServer;
+    let httpServer: HttpServer;
+    const testPort = 50001;
+    const testHost = `http://localhost:${testPort}`;
+
+    beforeEach(async () => {
+        // same as in main.ts
+        // TODO: unify
+        server = new ActorsMcpServer({
+            enableAddingActors: false,
+            enableDefaultActors: false,
+        });
+        log.setLevel(log.LEVELS.OFF);
+
+        // Create express app using the proper server setup
+        app = createExpressApp(testHost, server);
+
+        // Start test server
+        await new Promise<void>((resolve) => {
+            httpServer = app.listen(testPort, () => resolve());
+        });
+
+        // TODO: figure out why this is needed
+        await new Promise<void>((resolve) => { setTimeout(resolve, 1000); });
+    });
+
+    afterEach(async () => {
+        await new Promise<void>((resolve) => {
+            httpServer.close(() => resolve());
+        });
+    });
+
+    it('default tools list', async () => {
+        const client = await createMCPStreamableClient(`${testHost}/mcp`);
 
         const tools = await client.listTools();
         const names = tools.tools.map((tool) => tool.name);
@@ -140,7 +374,7 @@ describe('Actors MCP Server', {
     it('use only specific Actor and call it', async () => {
         const actorName = 'apify/python-example';
         const selectedToolName = actorNameToToolName(actorName);
-        const client = await createMCPClient(`${testHost}/sse`, {
+        const client = await createMCPStreamableClient(`${testHost}/mcp`, {
             actors: [actorName],
             enableAddingActors: false,
         });
@@ -175,9 +409,9 @@ describe('Actors MCP Server', {
         await client.close();
     });
 
-    it('load Actors from parameters via SSE client', async () => {
+    it('load Actors from parameters', async () => {
         const actors = ['apify/rag-web-browser', 'apify/instagram-scraper'];
-        const client = await createMCPClient(`${testHost}/sse`, {
+        const client = await createMCPStreamableClient(`${testHost}/mcp`, {
             actors,
             enableAddingActors: false,
         });
@@ -198,7 +432,7 @@ describe('Actors MCP Server', {
     it('load Actor dynamically and call it', async () => {
         const actor = 'apify/python-example';
         const selectedToolName = actorNameToToolName(actor);
-        const client = await createMCPClient(`${testHost}/sse`, {
+        const client = await createMCPStreamableClient(`${testHost}/mcp`, {
             enableAddingActors: true,
         });
 
@@ -254,7 +488,7 @@ describe('Actors MCP Server', {
     it('should remove Actor from tools list', async () => {
         const actor = 'apify/python-example';
         const selectedToolName = actorNameToToolName(actor);
-        const client = await createMCPClient(`${testHost}/sse`, {
+        const client = await createMCPStreamableClient(`${testHost}/mcp`, {
             actors: [actor],
             enableAddingActors: true,
         });

Original file line number	Diff line number	Diff line change
`@@ -295,4 +295,8 @@ export class ActorsMcpServer {`
`295`	`295`	`async connect(transport: Transport): Promise<void> {`
`296`	`296`	`await this.server.connect(transport);`
`297`	`297`	`}`
	`298`	`+`
	`299`	`+ async close(): Promise<void> {`
	`300`	`+ await this.server.close();`
	`301`	`+ }`
`298`	`302`	`}`