refactor: remove unused HelperTool type references from tools and server modules

Author: MQ37

src/mcp/server.ts

@@ -37,7 +37,7 @@ import {
 import { prompts } from '../prompts/index.js';
 import { callActorGetDataset, defaultTools, getActorsAsTools, toolCategories } from '../tools/index.js';
 import { decodeDotPropertyNames } from '../tools/utils.js';
-import type { ActorMcpTool, ActorTool, HelperTool, ToolEntry } from '../types.js';
+import type { ToolEntry } from '../types.js';
 import { buildActorResponseContent } from '../utils/actor-response.js';
 import { buildMCPResponse } from '../utils/mcp.js';
 import { createProgressTracker } from '../utils/progress.js';
@@ -142,7 +142,7 @@ export class ActorsMcpServer {
     private listInternalToolNames(): string[] {
         return Array.from(this.tools.values())
             .filter((tool) => tool.type === 'internal')
-            .map((tool) => (tool as HelperTool).name);
+            .map((tool) => tool.name);
     }
 
     /**
@@ -152,7 +152,7 @@ export class ActorsMcpServer {
     public listActorToolNames(): string[] {
         return Array.from(this.tools.values())
             .filter((tool) => tool.type === 'actor')
-            .map((tool) => (tool as ActorTool).actorFullName);
+            .map((tool) => tool.actorFullName);
     }
 
     /**
@@ -162,7 +162,7 @@ export class ActorsMcpServer {
     private listActorMcpServerToolIds(): string[] {
         const ids = Array.from(this.tools.values())
             .filter((tool: ToolEntry) => tool.type === 'actor-mcp')
-            .map((tool: ToolEntry) => (tool as ActorMcpTool).actorId);
+            .map((tool) => tool.actorId);
         // Ensure uniqueness
         return Array.from(new Set(ids));
     }
@@ -504,7 +504,7 @@ export class ActorsMcpServer {
             // TODO - if connection is /mcp client will not receive notification on tool change
             // Find tool by name or actor full name
             const tool = Array.from(this.tools.values())
-                .find((t) => t.name === name || (t.type === 'actor' && (t as ActorTool).actorFullName === name));
+                .find((t) => t.name === name || (t.type === 'actor' && t.actorFullName === name));
             if (!tool) {
                 const msg = `Tool ${name} not found. Available tools: ${this.listToolNames().join(', ')}`;
                 log.error(msg);
@@ -540,15 +540,13 @@ export class ActorsMcpServer {
             try {
                 // Handle internal tool
                 if (tool.type === 'internal') {
-                    const internalTool = tool as HelperTool;
-
                     // Only create progress tracker for call-actor tool
-                    const progressTracker = internalTool.name === 'call-actor'
+                    const progressTracker = tool.name === 'call-actor'
                         ? createProgressTracker(progressToken, extra.sendNotification)
                         : null;
 
-                    log.info('Calling internal tool', { name: internalTool.name, input: args });
-                    const res = await internalTool.call({
+                    log.info('Calling internal tool', { name: tool.name, input: args });
+                    const res = await tool.call({
                         args,
                         extra,
                         apifyMcpServer: this,
@@ -566,12 +564,11 @@ export class ActorsMcpServer {
                 }
 
                 if (tool.type === 'actor-mcp') {
-                    const serverTool = tool as ActorMcpTool;
                     let client: Client | null = null;
                     try {
-                        client = await connectMCPClient(serverTool.serverUrl, apifyToken);
+                        client = await connectMCPClient(tool.serverUrl, apifyToken);
                         if (!client) {
-                            const msg = `Failed to connect to MCP server ${serverTool.serverUrl}`;
+                            const msg = `Failed to connect to MCP server ${tool.serverUrl}`;
                             log.error(msg);
                             await this.server.sendLoggingMessage({ level: 'error', data: msg });
                             return {
@@ -597,9 +594,9 @@ export class ActorsMcpServer {
                             }
                         }
 
-                        log.info('Calling Actor-MCP', { actorId: serverTool.actorId, toolName: serverTool.originToolName, input: args });
+                        log.info('Calling Actor-MCP', { actorId: tool.actorId, toolName: tool.originToolName, input: args });
                         const res = await client.callTool({
-                            name: serverTool.originToolName,
+                            name: tool.originToolName,
                             arguments: args,
                             _meta: {
                                 progressToken,
@@ -627,12 +624,10 @@ export class ActorsMcpServer {
                         };
                     }
 
-                    const actorTool = tool as ActorTool;
-
                     // Create progress tracker if progressToken is available
                     const progressTracker = createProgressTracker(progressToken, extra.sendNotification);
 
-                    const callOptions: ActorCallOptions = { memory: actorTool.memoryMbytes };
+                    const callOptions: ActorCallOptions = { memory: tool.memoryMbytes };
 
                     /**
                      * Create Apify token, for Skyfire mode use `skyfire-pay-id` and for normal mode use `apifyToken`.
@@ -643,9 +638,9 @@ export class ActorsMcpServer {
                         : new ApifyClient({ token: apifyToken });
 
                     try {
-                        log.info('Calling Actor', { actorName: actorTool.actorFullName, input: actorArgs });
+                        log.info('Calling Actor', { actorName: tool.actorFullName, input: actorArgs });
                         const callResult = await callActorGetDataset(
-                            actorTool.actorFullName,
+                            tool.actorFullName,
                             actorArgs,
                             apifyClient,
                             callOptions,
@@ -659,7 +654,7 @@ export class ActorsMcpServer {
                             return { };
                         }
 
-                        const content = buildActorResponseContent(actorTool.actorFullName, callResult);
+                        const content = buildActorResponseContent(tool.actorFullName, callResult);
                         return { content };
                     } finally {
                         if (progressTracker) {

src/utils/tools-loader.ts

@@ -14,7 +14,7 @@ import { callActor } from '../tools/actor.js';
 import { getActorOutput } from '../tools/get-actor-output.js';
 import { addTool } from '../tools/helpers.js';
 import { getActorsAsTools, toolCategories, toolCategoriesEnabledByDefault } from '../tools/index.js';
-import type { HelperTool, Input, InternalToolArgs, ToolCategory, ToolEntry } from '../types.js';
+import type { Input, InternalToolArgs, ToolCategory, ToolEntry } from '../types.js';
 import { getExpectedToolsByCategories } from './tools.js';
 
 // Lazily-computed cache of internal tools by name to avoid circular init issues.
@@ -163,7 +163,7 @@ export async function loadToolsFromInput(
     const toolFunctions = new Map<string, { ajvValidate?: ValidateFunction<unknown>; call?:(args: InternalToolArgs) => Promise<object> }>();
     for (const entry of filtered) {
         if (entry.type === 'internal') {
-            toolFunctions.set(entry.name, { ajvValidate: entry.ajvValidate, call: (entry as HelperTool).call });
+            toolFunctions.set(entry.name, { ajvValidate: entry.ajvValidate, call: entry.call });
         } else {
             toolFunctions.set(entry.name, { ajvValidate: entry.ajvValidate });
         }
@@ -182,7 +182,7 @@ export async function loadToolsFromInput(
                 entry.ajvValidate = funcs.ajvValidate;
             }
             if (entry.type === 'internal' && funcs.call) {
-                (entry as HelperTool).call = funcs.call;
+                entry.call = funcs.call;
             }
         }
     }

src/utils/tools.ts

@@ -1,5 +1,5 @@
 import { toolCategories } from '../tools/index.js';
-import type { HelperTool, ToolBase, ToolCategory, ToolEntry } from '../types.js';
+import type { ToolBase, ToolCategory, ToolEntry } from '../types.js';
 
 /**
  * Returns a public version of the tool containing only fields that should be exposed publicly.
@@ -35,7 +35,7 @@ export function getExpectedToolNamesByCategories(categories: ToolCategory[]): st
 export function cloneToolEntry(toolEntry: ToolEntry): ToolEntry {
     // Store the original functions
     const originalAjvValidate = toolEntry.ajvValidate;
-    const originalCall = toolEntry.type === 'internal' ? (toolEntry as HelperTool).call : undefined;
+    const originalCall = toolEntry.type === 'internal' ? toolEntry.call : undefined;
 
     // Create a deep copy using JSON serialization (excluding functions)
     const cloned = JSON.parse(JSON.stringify(toolEntry, (key, value) => {
@@ -46,7 +46,7 @@ export function cloneToolEntry(toolEntry: ToolEntry): ToolEntry {
     // Restore the original functions
     cloned.ajvValidate = originalAjvValidate;
     if (toolEntry.type === 'internal' && originalCall) {
-        (cloned as HelperTool).call = originalCall;
+        cloned.call = originalCall;
     }
 
     return cloned;