fix default tool loading for Actors MCP server, more integration tests

Author: MQ37

src/actor/server.ts

@@ -12,8 +12,7 @@ import express from 'express';
 import log from '@apify/log';
 
 import { type ActorsMcpServer } from '../mcp/server.js';
-import { processParamsGetTools } from '../mcp/utils.js';
-import { addTool, removeTool } from '../tools/helpers.js';
+import { parseInputParamsFromUrl, processParamsGetTools } from '../mcp/utils.js';
 import { getHelpMessage, HEADER_READINESS_PROBE, Routes } from './const.js';
 import { getActorRunData } from './utils.js';
 
@@ -47,6 +46,7 @@ export function createExpressApp(
         }
         try {
             log.info(`Received GET message at: ${Routes.ROOT}`);
+            // TODO: I think we should remove this logic, root should return only help message
             const tools = await processParamsGetTools(req.url, process.env.APIFY_TOKEN as string);
             if (tools) {
                 mcpServer.updateTools(tools);
@@ -67,13 +67,12 @@ export function createExpressApp(
     app.get(Routes.SSE, async (req: Request, res: Response) => {
         try {
             log.info(`Received GET message at: ${Routes.SSE}`);
-            const tools = await processParamsGetTools(req.url, process.env.APIFY_TOKEN as string);
-            if (tools.length > 0) {
-                mcpServer.updateTools(tools);
+            const input = parseInputParamsFromUrl(req.url);
+            if (input.actors || input.enableAddingActors) {
+                await mcpServer.loadToolsFromUrl(req.url, process.env.APIFY_TOKEN as string);
             }
-            // TODO fix this - we should not be loading default tools here or provide more generic way
-            if (tools.length === 2 && tools.includes(addTool) && tools.includes(removeTool)) {
-                // We are loading default Actors (if not specified otherwise), so that we don't have "empty" tools
+            // Load default tools if no actors are specified
+            if (!input.actors) {
                 await mcpServer.loadDefaultTools(process.env.APIFY_TOKEN as string);
             }
             transportSSE = new SSEServerTransport(Routes.MESSAGE, res);

tests/integration/actor-server-test.ts

@@ -1,13 +1,66 @@
 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 type { Express } from 'express';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import log from '@apify/log';
 
 import { createExpressApp } from '../../src/actor/server.js';
-import { HelperTools } from '../../src/const.js';
+import { defaults, HelperTools } from '../../src/const.js';
 import { ActorsMcpServer } from '../../src/mcp/server.js';
+import { actorNameToToolName } from '../../src/tools/utils.js';
+
+async function createMCPClient(
+    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 SSEClientTransport(
+        url,
+        {
+            requestInit: {
+                headers: {
+                    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 });
+                },
+            // We have to cast to "any" to use it, since it's non-standard
+            } as any, // eslint-disable-line @typescript-eslint/no-explicit-any
+        },
+    );
+
+    const client = new Client({
+        name: 'sse-client',
+        version: '1.0.0',
+    });
+    await client.connect(transport);
+
+    return client;
+}
 
 describe('Actors MCP Server', {
     concurrent: false, // Run test serially to prevent port already in use
@@ -67,4 +120,163 @@ describe('Actors MCP Server', {
             HelperTools.REMOVE_ACTOR,
         ]);
     });
+
+    it('default tools list', async () => {
+        const client = await createMCPClient(`${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 createMCPClient(`${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 via SSE client', async () => {
+        const actors = ['apify/rag-web-browser', 'apify/instagram-scraper'];
+        const client = await createMCPClient(`${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 createMCPClient(`${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 createMCPClient(`${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();
+    });
 });

tests/integration/stdio.ts

@@ -164,4 +164,33 @@ describe('MCP STDIO', () => {
 
         await client.close();
     });
+
+    it('should remove Actor from tools list', async () => {
+        const actor = 'apify/python-example';
+        const selectedToolName = actorNameToToolName(actor);
+        const client = await createMCPClient({
+            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();
+    });
 });