address review comments

Author: MQ37

README.md

@@ -180,36 +180,50 @@ When no query parameters are provided, the MCP server loads the following `tools
 - `docs`
 - `apify/rag-web-browser`
 
-It is thus the same as if you configured the `tools` parameter like this:
+If the tools parameter is specified, only the listed tools or categories will be enabled - no default tools will be included.
+
+> **Easy configuration:**
+>
+> Use the [UI configurator](https://mcp.apify.com/) to configure your server, then copy the configuration to your client.
+
+**Configuring the hosted server:**
+
+The hosted server can be configured using query parameters in the URL. For example, to load the default tools, use:
 
-**For the hosted server:**
 ```
 https://mcp.apify.com?tools=actors,docs,apify/rag-web-browser
 ```
 
-**For the CLI:**
+For minimal configuration, if you want to use only a single Actor tool - without any discovery or generic calling tools, the server can be configured as follows:
+
+```
+https://mcp.apify.com?tools=apify/my-actor
+```
+
+This setup exposes only the specified Actor (`apify/my-actor`) as a tool. No other tools will be available.
+
+**Configuring the CLI:**
+
+The CLI can be configured using command-line flags. For example, to load the same tools as in the hosted server configuration, use:
+
 ```bash
 npx @apify/actors-mcp-server --tools actors,docs,apify/rag-web-browser
 ```
 
-If the tools parameter is specified, only the listed tools or categories will be enabled - no default tools will be included.
+The minimal configuration is similar to the hosted server configuration:
+
+```bash
+npx @apify/actors-mcp-server --tools apify/my-actor
+```
+
+As above, this exposes only the specified Actor (`apify/my-actor`) as a tool. No other tools will be available.
 
 > **⚠️ Important recommendation**
 > 
 > **The default tools configuration may change in future versions.** When no `tools` parameter is specified, the server currently loads default tools, but this behavior is subject to change.
 > 
 > **For production use and stable interfaces, always explicitly specify the `tools` parameter** to ensure your configuration remains consistent across updates.
 
-**Minimal configuration**
-
-For example, to use only a single Actor tool - without any discovery or generic calling tools, the server can be configured like this:
-
-```
-https://mcp.apify.com?tools=apify/my-actor
-```
-
-This setup exposes only the specified Actor (`apify/my-actor`) as a tool. No other tools will be available.
-
 ### Backward compatibility
 
 The v2 configuration preserves backward compatibility with v1 usage. Notes:

src/input.ts

@@ -11,15 +11,15 @@ import type { Input, ToolSelector } from './types.js';
 
 // Helpers
 // Normalize booleans that may arrive as strings or be undefined.
-function toBoolean(value: unknown, defaultValue: boolean): boolean {
+export function toBoolean(value: unknown, defaultValue: boolean): boolean {
     if (value === undefined) return defaultValue;
     if (typeof value === 'boolean') return value;
     if (typeof value === 'string') return value.toLowerCase() === 'true';
     return defaultValue;
 }
 
 // Normalize lists from comma-separated strings or arrays.
-function normalizeList(value: string | string[] | undefined): string[] | undefined {
+export function normalizeList(value: string | unknown[] | undefined): string[] | undefined {
     if (value === undefined) return undefined;
     if (Array.isArray(value)) return value.map((s) => String(s).trim()).filter((s) => s !== '');
     const trimmed = String(value).trim();

src/mcp/server.ts

@@ -170,11 +170,23 @@ export class ActorsMcpServer {
         }
 
         if (actorsToLoad.length > 0) {
-            const actorTools = await getActorsAsTools(actorsToLoad, apifyToken);
-            if (actorTools.length > 0) {
-                this.upsertTools(actorTools);
-            }
+            await this.loadActorsAsTools(actorsToLoad, apifyToken);
+        }
+    }
+
+    /**
+     * Load actors as tools, upsert them to the server, and return the tool entries.
+     * This is a public method that wraps getActorsAsTools and handles the upsert operation.
+     * @param actorIdsOrNames - Array of actor IDs or names to load as tools
+     * @param apifyToken - Apify API token for authentication
+     * @returns Promise<ToolEntry[]> - Array of loaded tool entries
+     */
+    public async loadActorsAsTools(actorIdsOrNames: string[], apifyToken: string): Promise<ToolEntry[]> {
+        const actorTools = await getActorsAsTools(actorIdsOrNames, apifyToken);
+        if (actorTools.length > 0) {
+            this.upsertTools(actorTools, true);
         }
+        return actorTools;
     }
 
     /**
@@ -401,8 +413,6 @@ export class ActorsMcpServer {
                         apifyToken,
                         userRentedActorIds,
                         progressTracker,
-                        // Passing as argument to prevent circular dependency
-                        getActorsAsTools,
                     }) as object;
 
                     if (progressTracker) {

src/stdio.ts

@@ -70,7 +70,7 @@ Deprecated: use tools experimental category instead.`,
         type: 'string',
         describe: `Comma-separated list of tools to enable. Can be either a tool category, a specific tool, or an Apify Actor. For example: --tools actors,docs,apify/rag-web-browser.
 
-For more details visit https://github.com/apify/actors-mcp-server`,
+For more details visit https://mcp.apify.com`,
         example: 'actors,docs,apify/rag-web-browser',
     })
     .help('help')

src/tools/actor.ts

@@ -307,8 +307,6 @@ The step parameter enforces this workflow - you cannot call an Actor without fir
                     }
                     return {
                         content: [
-                            { type: 'text', text: `**Actor card**:\n${details.actorCard}` },
-                            { type: 'text', text: `**README:**\n${details.readme}` },
                             { type: 'text', text: `**Input Schema:**\n${JSON.stringify(details.inputSchema, null, 0)}` },
                         ],
                     };

src/tools/helpers.ts

@@ -48,7 +48,7 @@ export const addTool: ToolEntry = {
         ajvValidate: ajv.compile(zodToJsonSchema(addToolArgsSchema)),
         // TODO: I don't like that we are passing apifyMcpServer and mcpServer to the tool
         call: async (toolArgs) => {
-            const { apifyMcpServer, apifyToken, args, extra: { sendNotification }, getActorsAsTools } = toolArgs;
+            const { apifyMcpServer, apifyToken, args, extra: { sendNotification } } = toolArgs;
             const parsed = addToolArgsSchema.parse(args);
             if (apifyMcpServer.listAllToolNames().includes(parsed.actor)) {
                 return {
@@ -58,14 +58,12 @@ export const addTool: ToolEntry = {
                     }],
                 };
             }
-            if (!getActorsAsTools) {
-                throw new Error('Internal configuration error: getActorsAsTools must be passed via InternalToolArgs from the MCP server');
-            }
-            const tools = await getActorsAsTools([parsed.actor], apifyToken);
+
+            const tools = await apifyMcpServer.loadActorsAsTools([parsed.actor], apifyToken);
             /**
              * If no tools were found, return a message that the Actor was not found
              * instead of returning that non existent tool was added since the
-             * getActorsAsTools function returns an empty array and does not throw an error.
+             * loadActorsAsTools method returns an empty array and does not throw an error.
              */
             if (tools.length === 0) {
                 return {
@@ -75,14 +73,14 @@ export const addTool: ToolEntry = {
                     }],
                 };
             }
-            const toolsAdded = apifyMcpServer.upsertTools(tools, true);
+
             await sendNotification({ method: 'notifications/tools/list_changed' });
 
             return {
                 content: [{
                     type: 'text',
                     text: `Actor ${parsed.actor} has been added. Newly available tools: ${
-                        toolsAdded.map(
+                        tools.map(
                             (t) => `${t.tool.name}`,
                         ).join(', ')
                     }.`,

src/types.ts

@@ -108,13 +108,6 @@ export type InternalToolArgs = {
     userRentedActorIds?: string[];
     /** Optional progress tracker for long running internal tools, like call-actor */
     progressTracker?: ProgressTracker | null;
-    /**
-     * Injected dependency for turning Actor names/IDs into tools.
-     * Passing it from the server avoids a stdio-only circular import that made the
-     * add-actor tool null during module initialization.
-     */
-    // eslint-disable-next-line no-use-before-define
-    getActorsAsTools?: (actorIdsOrNames: string[], apifyToken: string) => Promise<ToolEntry[]>;
 }
 
 /**

tests/integration/suite.ts

@@ -357,7 +357,6 @@ export function createIntegrationTestsSuite(
 
             expect(infoResult.content).toBeDefined();
             const content = infoResult.content as { text: string }[];
-            expect(content.some((item) => item.text.includes('Actor card'))).toBe(true);
             expect(content.some((item) => item.text.includes('Input Schema'))).toBe(true);
 
             // Step 2: Call with proper input (should work)