fix tests and logic to adhere to the new spec

MQ37 · MQ37 · commit 662aba14423d · 2025-08-20T21:58:35.000+02:00
diff --git a/src/input.ts b/src/input.ts
@@ -33,7 +33,8 @@ export function processInput(originalInput: Partial<Input>): Input {
             log.warning('enableActorAutoLoading is deprecated, use enableAddingActors instead');
             input.enableAddingActors = input.enableActorAutoLoading === true || input.enableActorAutoLoading === 'true';
         } else {
-            input.enableAddingActors = true;
+            // Default: do NOT enable add-actor unless explicitly requested
+            input.enableAddingActors = false;
         }
     } else {
         input.enableAddingActors = input.enableAddingActors === true || input.enableAddingActors === 'true';
@@ -50,14 +51,20 @@ export function processInput(originalInput: Partial<Input>): Input {
         input.tools = [] as unknown as ToolSelector[];
     }
 
-    // Backward compatibility: if tools is explicitly specified, merge also actors into tools selectors
-    // This keeps previous semantics when tools is undefined (defaults categories apply).
-    if (input.tools !== undefined && Array.isArray(input.actors) && input.actors.length > 0) {
-        let currentTools: ToolSelector[] = [];
-        if (input.tools !== undefined) {
-            currentTools = Array.isArray(input.tools) ? input.tools : [input.tools as ToolSelector];
+    // Merge actors into tools selectors so that specifying only actors disables
+    // default internal tools/categories. If tools are not provided, treat actors
+    // as the only tool selectors. If tools are provided, append actors to tools.
+    if (Array.isArray(input.actors) && input.actors.length > 0) {
+        if (input.tools === undefined) {
+            input.tools = [...input.actors] as ToolSelector[];
+            // Treat as if only tools were specified; clear actors to avoid duplicate semantics
+            input.actors = undefined as unknown as string[];
+        } else {
+            const currentTools: ToolSelector[] = Array.isArray(input.tools)
+                ? input.tools
+                : [input.tools as ToolSelector];
+            input.tools = [...currentTools, ...input.actors] as ToolSelector[];
         }
-        input.tools = [...currentTools, ...input.actors] as ToolSelector[];
     }
     return input;
 }
diff --git a/src/stdio.ts b/src/stdio.ts
@@ -55,12 +55,12 @@ const argv = yargs(hideBin(process.argv))
     })
     .option('enable-adding-actors', {
         type: 'boolean',
-        default: true,
+        default: false,
         describe: 'Enable dynamically adding Actors as tools based on user requests.',
     })
     .option('enableActorAutoLoading', {
         type: 'boolean',
-        default: true,
+        default: false,
         hidden: true,
         describe: 'Deprecated: use enable-adding-actors instead.',
     })
@@ -91,7 +91,8 @@ Note: Tools that enable you to search Actors from the Apify Store and get their
     .epilogue('For more information, visit https://mcp.apify.com or https://github.com/apify/actors-mcp-server')
     .parseSync() as CliArgs;
 
-const enableAddingActors = argv.enableAddingActors && argv.enableActorAutoLoading;
+// Respect either the new flag or the deprecated one
+const enableAddingActors = Boolean(argv.enableAddingActors || argv.enableActorAutoLoading);
 // Split actors argument, trim whitespace, and filter out empty strings
 const actorList = argv.actors !== undefined
     ? argv.actors.split(',').map((a: string) => a.trim()).filter((a: string) => a.length > 0)
diff --git a/src/utils/tools-loader.ts b/src/utils/tools-loader.ts
@@ -71,15 +71,23 @@ export async function loadToolsFromInput(
     }
 
     let actorNamesToLoad: string[] = [];
+    const toolSelectorsProvided = toolSelectors !== undefined;
+    const toolSelectorsIsEmpty = Array.isArray(toolSelectors) && toolSelectors.length === 0;
+    const addActorEnabled = input.enableAddingActors === true;
     if (actorsFromInputField !== undefined) {
         actorNamesToLoad = actorsFromInputField;
     } else if (actorSelectorsFromTools.length > 0) {
         // If no explicit `actors` were provided, but `tools` includes actor names,
         // load exactly those instead of defaults
         actorNamesToLoad = actorSelectorsFromTools;
+    } else if (!toolSelectorsProvided) {
+        // Tools not provided
+        // If add-actor is enabled and nothing else specified, do not load default actors
+        actorNamesToLoad = addActorEnabled ? [] : defaults.actors;
     } else {
-        // Use default actors if nothing specified anywhere
-        actorNamesToLoad = defaults.actors;
+        // Tools are provided (non-empty) but do not specify any actor names
+        // => do not load default actors
+        actorNamesToLoad = [];
     }
 
     // If both fields specify actors, merge them
@@ -93,20 +101,34 @@ export async function loadToolsFromInput(
         tools = await getActorsAsTools(actorNamesToLoad, apifyToken);
     }
 
-    // Add tool for dynamically adding actors if enabled
-    if (input.enableAddingActors) {
+    // Add tool for dynamically adding actors if enabled.
+    // Respect explicit empty tools array or explicitly empty actors list
+    const actorsExplicitlyEmpty = (Array.isArray(input.actors) && input.actors.length === 0) || input.actors === '';
+    if (addActorEnabled && !toolSelectorsIsEmpty && !actorsExplicitlyEmpty) {
         tools.push(addTool);
     }
 
     // Add internal tools from categories/tool names or defaults when `tools` unspecified
     if (toolSelectors !== undefined) {
-        // Respect disable flag: do not include add-actor even if explicitly requested
-        const filteredInternal = input.enableAddingActors
+        // Respect disable flag, but if 'experimental' category is explicitly requested,
+        // or the add-actor tool is selected directly, include add-actor even when enableAddingActors=false
+        const list = toolSelectors as (string | ToolCategory)[];
+        const experimentalExplicitlySelected = Array.isArray(list)
+            && list.includes('experimental');
+        const addActorSelectedDirectly = Array.isArray(list)
+            && list.includes(addTool.tool.name);
+        const allowAddActor = addActorEnabled || experimentalExplicitlySelected || addActorSelectedDirectly;
+        const filteredInternal = allowAddActor
             ? internalCategoryEntries
             : internalCategoryEntries.filter((entry) => entry.tool.name !== addTool.tool.name);
         tools.push(...filteredInternal);
     } else {
-        tools.push(...getExpectedToolsByCategories(toolCategoriesEnabledByDefault));
+        // When tools are not provided:
+        // - If add-actor is enabled: do not include default internal categories
+        // - If actors are explicitly empty: do not include defaults either
+        if (!addActorEnabled && !actorsExplicitlyEmpty) {
+            tools.push(...getExpectedToolsByCategories(toolCategoriesEnabledByDefault));
+        }
     }
 
     // De-duplicate by tool name
diff --git a/tests/integration/internals.test.ts b/tests/integration/internals.test.ts
@@ -30,10 +30,9 @@ describe('MCP server internals integration tests', () => {
 
         // Store the tool name list
         const names = actorsMcpServer.listAllToolNames();
+        // With enableAddingActors=true and no tools/actors, we should only have add-actor initially
         const expectedToolNames = [
-            ...defaults.actors,
             addTool.tool.name,
-            ...defaultTools.map((tool) => tool.tool.name),
             ACTOR_PYTHON_EXAMPLE,
         ];
         expectArrayWeakEquals(expectedToolNames, names);
@@ -51,7 +50,8 @@ describe('MCP server internals integration tests', () => {
 
     it('should notify tools changed handler on tool modifications', async () => {
         let latestTools: string[] = [];
-        const numberOfTools = 1 + defaults.actors.length + defaultTools.length;
+        // With enableAddingActors=true and no tools/actors, seeded set contains only add-actor
+        const numberOfTools = 1;
 
         let toolNotificationCount = 0;
         const onToolsChanged = (tools: string[]) => {
@@ -74,9 +74,7 @@ describe('MCP server internals integration tests', () => {
         expect(latestTools.length).toBe(numberOfTools + 1);
         expect(latestTools).toContain(actor);
         expect(latestTools).toContain(addTool.tool.name);
-        for (const tool of defaults.actors) {
-            expect(latestTools).toContain(tool);
-        }
+        // No default actors are present when only add-actor is enabled by default
 
         // Remove the Actor
         actorsMCPServer.removeToolsByName([actorNameToToolName(actor)], true);
@@ -86,15 +84,13 @@ describe('MCP server internals integration tests', () => {
         expect(latestTools.length).toBe(numberOfTools);
         expect(latestTools).not.toContain(actor);
         expect(latestTools).toContain(addTool.tool.name);
-        for (const tool of defaults.actors) {
-            expect(latestTools).toContain(tool);
-        }
+        // No default actors are present by default in this mode
     });
 
     it('should stop notifying after unregistering tools changed handler', async () => {
         let latestTools: string[] = [];
         let notificationCount = 0;
-        const numberOfTools = 1 + defaults.actors.length + defaultTools.length;
+        const numberOfTools = 1;
         const onToolsChanged = (tools: string[]) => {
             latestTools = tools;
             notificationCount++;
diff --git a/tests/integration/suite.ts b/tests/integration/suite.ts
@@ -97,14 +97,11 @@ export function createIntegrationTestsSuite(
             await client.close();
         });
 
-        it('should list all default tools and Actors, with add/remove tools', async () => {
+        it('should list only add-actor when add/remove tools are enabled and no tools/actors specified', async () => {
             const client = await createClientFn({ enableAddingActors: true });
             const names = getToolNames(await client.listTools());
-            expect(names.length).toEqual(defaultTools.length + defaults.actors.length + 1);
-
-            expectToolNamesToContain(names, DEFAULT_TOOL_NAMES);
-            expectToolNamesToContain(names, DEFAULT_ACTOR_NAMES);
-            expectToolNamesToContain(names, [addTool.tool.name]);
+            expect(names.length).toEqual(1);
+            expect(names).toContain(addTool.tool.name);
             await client.close();
         });
 
@@ -157,11 +154,10 @@ export function createIntegrationTestsSuite(
             await client.close();
         });
 
-        it.only('should load only specified Actors via tools selectors when actors param omitted', async () => {
+        it('should load only specified Actors via tools selectors when actors param omitted', async () => {
             const actors = ['apify/python-example'];
             const client = await createClientFn({ tools: actors });
             const names = getToolNames(await client.listTools());
-            console.log(names);
             // Only the Actor should be loaded
             expect(names).toHaveLength(actors.length);
             expect(names).toContain(actorNameToToolName(actors[0]));
@@ -198,11 +194,10 @@ export function createIntegrationTestsSuite(
             await client.close();
         });
 
-        it('should not add any internal tools when tools param is empty', async () => {
+        it('should not add any tools when tools param is empty and actors omitted', async () => {
             const client = await createClientFn({ tools: [] });
             const names = getToolNames(await client.listTools());
-            expect(names.length).toEqual(defaults.actors.length);
-            expectToolNamesToContain(names, defaults.actors.map((actor) => actorNameToToolName(actor)));
+            expect(names.length).toEqual(0);
             await client.close();
         });
 
@@ -453,7 +448,7 @@ export function createIntegrationTestsSuite(
             }
         });
 
-        it('should NOT include add-actor when disabled even if experimental category is selected', async () => {
+        it('should include add-actor when experimental category is selected even if add/remove tools are disabled', async () => {
             const client = await createClientFn({
                 enableAddingActors: false,
                 tools: ['experimental'],
@@ -462,18 +457,12 @@ export function createIntegrationTestsSuite(
             const loadedTools = await client.listTools();
             const toolNames = getToolNames(loadedTools);
 
-            // Default actors still load when actors are omitted
-            const expectedActorNames = defaults.actors.map((actor) => actorNameToToolName(actor));
-            for (const n of expectedActorNames) {
-                expect(toolNames).toContain(n);
-            }
-            // Must not include add-actor
-            expect(toolNames).not.toContain(addTool.tool.name);
+            expect(toolNames).toContain(addTool.tool.name);
 
             await client.close();
         });
 
-        it('should NOT include add-actor when disabled even if tool is selected directly', async () => {
+        it('should include add-actor when enableAddingActors disabled and tool add-actor selected directly', async () => {
             const client = await createClientFn({
                 enableAddingActors: false,
                 tools: [addTool.tool.name],
@@ -482,13 +471,8 @@ export function createIntegrationTestsSuite(
             const loadedTools = await client.listTools();
             const toolNames = getToolNames(loadedTools);
 
-            // Default actors still load when actors are omitted
-            const expectedActorNames = defaults.actors.map((actor) => actorNameToToolName(actor));
-            for (const n of expectedActorNames) {
-                expect(toolNames).toContain(n);
-            }
-            // Must not include add-actor
-            expect(toolNames).not.toContain(addTool.tool.name);
+            // Must include add-actor since it was selected directly
+            expect(toolNames).toContain(addTool.tool.name);
 
             await client.close();
         });
diff --git a/tests/unit/input.test.ts b/tests/unit/input.test.ts
@@ -4,20 +4,22 @@ import { processInput } from '../../src/input.js';
 import type { Input } from '../../src/types.js';
 
 describe('processInput', () => {
-    it('should handle string actors input and convert to array', async () => {
+    it('should handle string actors input and convert to tools selectors', async () => {
         const input: Partial<Input> = {
             actors: 'actor1, actor2,actor3',
         };
         const processed = processInput(input);
-        expect(processed.actors).toEqual(['actor1', 'actor2', 'actor3']);
+        expect(processed.tools).toEqual(['actor1', 'actor2', 'actor3']);
+        expect(processed.actors).toBeUndefined();
     });
 
-    it('should keep array actors input unchanged', async () => {
+    it('should move array actors input into tools selectors', async () => {
         const input: Partial<Input> = {
             actors: ['actor1', 'actor2', 'actor3'],
         };
         const processed = processInput(input);
-        expect(processed.actors).toEqual(['actor1', 'actor2', 'actor3']);
+        expect(processed.tools).toEqual(['actor1', 'actor2', 'actor3']);
+        expect(processed.actors).toBeUndefined();
     });
 
     it('should handle enableActorAutoLoading to set enableAddingActors', async () => {
@@ -39,12 +41,12 @@ describe('processInput', () => {
         expect(processed.enableAddingActors).toBe(false);
     });
 
-    it('should default enableAddingActors to true when not provided', async () => {
+    it('should default enableAddingActors to false when not provided', async () => {
         const input: Partial<Input> = {
             actors: ['actor1'],
         };
         const processed = processInput(input);
-        expect(processed.enableAddingActors).toBe(true);
+        expect(processed.enableAddingActors).toBe(false);
     });
 
     it('should keep tools as array of valid featureTools keys', async () => {
@@ -63,12 +65,13 @@ describe('processInput', () => {
         expect(processed.tools).toEqual([]);
     });
 
-    it('should handle missing tools field (undefined)', async () => {
+    it('should handle missing tools field (undefined) by moving actors into tools', async () => {
         const input: Partial<Input> = {
             actors: ['actor1'],
         };
         const processed = processInput(input);
-        expect(processed.tools).toBeUndefined();
+        expect(processed.tools).toEqual(['actor1']);
+        expect(processed.actors).toBeUndefined();
     });
 
     it('should include all keys, even invalid ones', async () => {
diff --git a/tests/unit/mcp.utils.test.ts b/tests/unit/mcp.utils.test.ts
@@ -3,16 +3,18 @@ import { describe, expect, it } from 'vitest';
 import { parseInputParamsFromUrl } from '../../src/mcp/utils.js';
 
 describe('parseInputParamsFromUrl', () => {
-    it('should parse Actors from URL query params', () => {
+    it('should parse Actors from URL query params (as tools selectors)', () => {
         const url = 'https://actors-mcp-server.apify.actor?token=123&actors=apify/web-scraper';
         const result = parseInputParamsFromUrl(url);
-        expect(result.actors).toEqual(['apify/web-scraper']);
+        expect(result.tools).toEqual(['apify/web-scraper']);
+        expect(result.actors).toBeUndefined();
     });
 
-    it('should parse multiple Actors from URL', () => {
+    it('should parse multiple Actors from URL (as tools selectors)', () => {
         const url = 'https://actors-mcp-server.apify.actor?actors=apify/instagram-scraper,lukaskrivka/google-maps';
         const result = parseInputParamsFromUrl(url);
-        expect(result.actors).toEqual(['apify/instagram-scraper', 'lukaskrivka/google-maps']);
+        expect(result.tools).toEqual(['apify/instagram-scraper', 'lukaskrivka/google-maps']);
+        expect(result.actors).toBeUndefined();
     });
 
     it('should handle URL without query params', () => {
@@ -39,9 +41,10 @@ describe('parseInputParamsFromUrl', () => {
         expect(result.enableAddingActors).toBe(false);
     });
 
-    it('should handle Actors as string parameter', () => {
+    it('should handle Actors as string parameter (as tools selectors)', () => {
         const url = 'https://actors-mcp-server.apify.actor?actors=apify/rag-web-browser';
         const result = parseInputParamsFromUrl(url);
-        expect(result.actors).toEqual(['apify/rag-web-browser']);
+        expect(result.tools).toEqual(['apify/rag-web-browser']);
+        expect(result.actors).toBeUndefined();
     });
 });
