feat: refactor and unify input handling, remove unnecessary logic

Author: MQ37

src/actor/server.ts

@@ -17,11 +17,6 @@ import { getActorRunData } from './utils.js';
 
 export function createExpressApp(
     host: string,
-    mcpServerOptions: {
-        enableAddingActors?: boolean;
-        enableDefaultActors?: boolean;
-        actors?: string[];
-    },
 ): express.Express {
     const app = express();
     const mcpServers: { [sessionId: string]: ActorsMcpServer } = {};
@@ -74,7 +69,7 @@ export function createExpressApp(
                 rt: Routes.SSE,
                 tr: TransportType.SSE,
             });
-            const mcpServer = new ActorsMcpServer(mcpServerOptions, false);
+            const mcpServer = new ActorsMcpServer(false);
             const transport = new SSEServerTransport(Routes.MESSAGE, res);
 
             // Load MCP server tools
@@ -157,7 +152,7 @@ export function createExpressApp(
                     sessionIdGenerator: () => randomUUID(),
                     enableJsonResponse: false, // Use SSE response mode
                 });
-                const mcpServer = new ActorsMcpServer(mcpServerOptions, false);
+                const mcpServer = new ActorsMcpServer(false);
 
                 // Load MCP server tools
                 const apifyToken = process.env.APIFY_TOKEN as string;

src/main.ts

@@ -29,21 +29,9 @@ const input = processInput((await Actor.getInput<Partial<Input>>()) ?? ({} as In
 log.info('Loaded input', { input: JSON.stringify(input) });
 
 if (STANDBY_MODE) {
-    let actorsToLoad: string[] = [];
-    // TODO: in standby mode the input loading does not actually work,
-    // we should remove this since we are using the URL query parameters to load Actors
-    // Load only Actors specified in the input
-    // If you wish to start without any Actor, create a task and leave the input empty
-    if (input.actors && input.actors.length > 0) {
-        const { actors } = input;
-        actorsToLoad = Array.isArray(actors) ? actors : actors.split(',');
-    }
-    // Include Actors to load in the MCP server options for backwards compatibility
-    const app = createExpressApp(HOST, {
-        enableAddingActors: Boolean(input.enableAddingActors),
-        enableDefaultActors: false,
-        actors: actorsToLoad,
-    });
+    // In standby mode, actors and tools are provided via URL query params per request
+    // Start express app
+    const app = createExpressApp(HOST);
     log.info('Actor is running in the STANDBY mode.');
 
     app.listen(PORT, () => {

src/mcp/server.ts

@@ -21,25 +21,19 @@ import { type ActorCallOptions, ApifyApiError } from 'apify-client';
 import log from '@apify/log';
 
 import {
-    defaults,
     SERVER_NAME,
     SERVER_VERSION,
 } from '../const.js';
 import { prompts } from '../prompts/index.js';
 import { addRemoveTools, callActorGetDataset, defaultTools, getActorsAsTools, toolCategories } from '../tools/index.js';
-import { actorNameToToolName, decodeDotPropertyNames } from '../tools/utils.js';
+import { decodeDotPropertyNames } from '../tools/utils.js';
 import type { ActorMcpTool, ActorTool, HelperTool, ToolEntry } from '../types.js';
 import { createProgressTracker } from '../utils/progress.js';
 import { getToolPublicFieldOnly } from '../utils/tools.js';
 import { connectMCPClient } from './client.js';
 import { EXTERNAL_TOOL_CALL_TIMEOUT_MSEC } from './const.js';
 import { processParamsGetTools } from './utils.js';
 
-type ActorsMcpServerOptions = {
-    enableAddingActors?: boolean;
-    enableDefaultActors?: boolean;
-};
-
 type ToolsChangedHandler = (toolNames: string[]) => void;
 
 /**
@@ -48,15 +42,10 @@ type ToolsChangedHandler = (toolNames: string[]) => void;
 export class ActorsMcpServer {
     public readonly server: Server;
     public readonly tools: Map<string, ToolEntry>;
-    private options: ActorsMcpServerOptions;
     private toolsChangedHandler: ToolsChangedHandler | undefined;
     private sigintHandler: (() => Promise<void>) | undefined;
 
-    constructor(options: ActorsMcpServerOptions = {}, setupSigintHandler = true) {
-        this.options = {
-            enableAddingActors: options.enableAddingActors ?? true,
-            enableDefaultActors: options.enableDefaultActors ?? true, // Default to true for backward compatibility
-        };
+    constructor(setupSigintHandler = true) {
         this.server = new Server(
             {
                 name: SERVER_NAME,
@@ -74,16 +63,6 @@ export class ActorsMcpServer {
         this.setupErrorHandling(setupSigintHandler);
         this.setupToolHandlers();
         this.setupPromptHandlers();
-
-        // Add tools to dynamically load Actors
-        if (this.options.enableAddingActors) {
-            this.enableDynamicActorTools();
-        }
-
-        // Initialize automatically for backward compatibility
-        this.initialize().catch((error) => {
-            log.error('Failed to initialize server', { error });
-        });
     }
 
     /**
@@ -199,47 +178,6 @@ export class ActorsMcpServer {
         }
     }
 
-    /**
-    * Resets the server to the default state.
-    * This method clears all tools and loads the default tools.
-    * Used primarily for testing purposes.
-    */
-    public async reset(): Promise<void> {
-        this.tools.clear();
-        // Unregister the tools changed handler
-        if (this.toolsChangedHandler) {
-            this.unregisterToolsChangedHandler();
-        }
-        if (this.options.enableAddingActors) {
-            this.enableDynamicActorTools();
-        }
-        // Initialize automatically for backward compatibility
-        await this.initialize();
-    }
-
-    /**
-     * Initialize the server with default tools if enabled
-     */
-    public async initialize(): Promise<void> {
-        if (this.options.enableDefaultActors) {
-            await this.loadDefaultActors(process.env.APIFY_TOKEN as string);
-        }
-    }
-
-    /**
-     * Loads default tools if not already loaded.
-     * @param apifyToken - Apify API token for authentication
-     * @returns {Promise<void>} - A promise that resolves when the tools are loaded
-     */
-    public async loadDefaultActors(apifyToken: string): Promise<void> {
-        const missingActors = defaults.actors.filter((name) => !this.tools.has(actorNameToToolName(name)));
-        const tools = await getActorsAsTools(missingActors, apifyToken);
-        if (tools.length > 0) {
-            log.debug('Loading default tools');
-            this.upsertTools(tools);
-        }
-    }
-
     /**
      * Loads tools from URL params.
      *
@@ -255,18 +193,8 @@ export class ActorsMcpServer {
         }
     }
 
-    /**
-     * Add Actors to server dynamically
-     */
-    public enableDynamicActorTools() {
-        this.options.enableAddingActors = true;
-        this.upsertTools(addRemoveTools, false);
-    }
-
-    public disableDynamicActorTools() {
-        this.options.enableAddingActors = false;
-        this.removeToolsByName(addRemoveTools.map((tool) => tool.tool.name));
-    }
+    // Methods for toggling dynamic tools have been removed; add/remove helper tools
+    // should be managed via the unified input loader.
 
     /** Delete tools from the server and notify the handler.
      */

src/stdio.ts

@@ -114,7 +114,7 @@ if (!process.env.APIFY_TOKEN) {
 }
 
 async function main() {
-    const mcpServer = new ActorsMcpServer({ enableAddingActors, enableDefaultActors: false });
+    const mcpServer = new ActorsMcpServer();
 
     // Create an Input object from CLI arguments
     const input: Input = {

tests/integration/actor.server-sse.test.ts

@@ -21,12 +21,8 @@ createIntegrationTestsSuite({
     beforeAllFn: async () => {
         log.setLevel(log.LEVELS.OFF);
 
-        // Create an express app using the proper server setup
-        const mcpServerOptions = {
-            enableAddingActors: false,
-            enableDefaultActors: false,
-        };
-        app = createExpressApp(httpServerHost, mcpServerOptions);
+        // Create an express app
+        app = createExpressApp(httpServerHost);
 
         // Start a test server
         await new Promise<void>((resolve) => {

tests/integration/actor.server-streamable.test.ts

@@ -21,12 +21,8 @@ createIntegrationTestsSuite({
     beforeAllFn: async () => {
         log.setLevel(log.LEVELS.OFF);
 
-        // Create an express app using the proper server setup
-        const mcpServerOptions = {
-            enableAddingActors: false,
-            enableDefaultActors: false,
-        };
-        app = createExpressApp(httpServerHost, mcpServerOptions);
+        // Create an express app
+        app = createExpressApp(httpServerHost);
 
         // Start a test server
         await new Promise<void>((resolve) => {

tests/integration/internals.test.ts

@@ -5,7 +5,9 @@ import log from '@apify/log';
 import { actorNameToToolName } from '../../dist/tools/utils.js';
 import { defaults } from '../../src/const.js';
 import { ActorsMcpServer } from '../../src/index.js';
-import { addRemoveTools, getActorsAsTools } from '../../src/tools/index.js';
+import { addRemoveTools, defaultTools, getActorsAsTools } from '../../src/tools/index.js';
+import type { Input } from '../../src/types.js';
+import { loadToolsFromInput } from '../../src/utils/tools-loader.js';
 import { ACTOR_PYTHON_EXAMPLE } from '../const.js';
 import { expectArrayWeakEquals } from '../helpers.js';
 
@@ -15,8 +17,11 @@ beforeAll(() => {
 
 describe('MCP server internals integration tests', () => {
     it('should load and restore tools from a tool list', async () => {
-        const actorsMcpServer = new ActorsMcpServer({ enableDefaultActors: true, enableAddingActors: true }, false);
-        await actorsMcpServer.initialize();
+        const actorsMcpServer = new ActorsMcpServer(false);
+        const initialTools = await loadToolsFromInput({
+            enableAddingActors: true,
+        } as Input, process.env.APIFY_TOKEN as string);
+        actorsMcpServer.upsertTools(initialTools);
 
         // Load new tool
         const newTool = await getActorsAsTools([ACTOR_PYTHON_EXAMPLE], process.env.APIFY_TOKEN as string);
@@ -27,7 +32,8 @@ describe('MCP server internals integration tests', () => {
         const expectedToolNames = [
             ...defaults.actors,
             ...addRemoveTools.map((tool) => tool.tool.name),
-            ...[ACTOR_PYTHON_EXAMPLE],
+            ...defaultTools.map((tool) => tool.tool.name),
+            ACTOR_PYTHON_EXAMPLE,
         ];
         expectArrayWeakEquals(expectedToolNames, names);
 
@@ -42,41 +48,19 @@ describe('MCP server internals integration tests', () => {
         expectArrayWeakEquals(actorsMcpServer.listAllToolNames(), expectedToolNames);
     });
 
-    it('should reset and restore tool state with default tools', async () => {
-        const actorsMCPServer = new ActorsMcpServer({ enableDefaultActors: true, enableAddingActors: true }, false);
-        await actorsMCPServer.initialize();
-
-        const numberOfTools = addRemoveTools.length + defaults.actors.length;
-        const toolList = actorsMCPServer.listAllToolNames();
-        expect(toolList.length).toEqual(numberOfTools);
-        // Add a new Actor
-        const newTool = await getActorsAsTools([ACTOR_PYTHON_EXAMPLE], process.env.APIFY_TOKEN as string);
-        actorsMCPServer.upsertTools(newTool);
-
-        // Store the tool name list
-        const toolListWithActor = actorsMCPServer.listAllToolNames();
-        expect(toolListWithActor.length).toEqual(numberOfTools + 1); // + 1 for the added Actor
-
-        // Remove all tools
-        await actorsMCPServer.reset();
-        // We connect second client so that the default tools are loaded
-        // if no specific list of Actors is provided
-        const toolListAfterReset = actorsMCPServer.listAllToolNames();
-        expect(toolListAfterReset.length).toEqual(numberOfTools);
-    });
-
     it('should notify tools changed handler on tool modifications', async () => {
         let latestTools: string[] = [];
-        const numberOfTools = addRemoveTools.length + defaults.actors.length;
+        const numberOfTools = addRemoveTools.length + defaults.actors.length + defaultTools.length;
 
         let toolNotificationCount = 0;
         const onToolsChanged = (tools: string[]) => {
             latestTools = tools;
             toolNotificationCount++;
         };
 
-        const actorsMCPServer = new ActorsMcpServer({ enableDefaultActors: true, enableAddingActors: true }, false);
-        await actorsMCPServer.initialize();
+        const actorsMCPServer = new ActorsMcpServer(false);
+        const seeded = await loadToolsFromInput({ enableAddingActors: true } as Input, process.env.APIFY_TOKEN as string);
+        actorsMCPServer.upsertTools(seeded);
         actorsMCPServer.registerToolsChangedHandler(onToolsChanged);
 
         // Add a new Actor
@@ -113,14 +97,15 @@ describe('MCP server internals integration tests', () => {
     it('should stop notifying after unregistering tools changed handler', async () => {
         let latestTools: string[] = [];
         let notificationCount = 0;
-        const numberOfTools = addRemoveTools.length + defaults.actors.length;
+        const numberOfTools = addRemoveTools.length + defaults.actors.length + defaultTools.length;
         const onToolsChanged = (tools: string[]) => {
             latestTools = tools;
             notificationCount++;
         };
 
-        const actorsMCPServer = new ActorsMcpServer({ enableDefaultActors: true, enableAddingActors: true }, false);
-        await actorsMCPServer.initialize();
+        const actorsMCPServer = new ActorsMcpServer(false);
+        const seeded = await loadToolsFromInput({ enableAddingActors: true } as Input, process.env.APIFY_TOKEN as string);
+        actorsMCPServer.upsertTools(seeded);
         actorsMCPServer.registerToolsChangedHandler(onToolsChanged);
 
         // Add a new Actor