fix: deduplicate error logs, use info for 404/400 errors, fix ajv validate when it contains $ref

Author: jirispilka

src/tools/actor.ts

@@ -244,6 +244,14 @@ async function getMCPServersAsTools(
                 return [];
             }
             return await getMCPServerTools(actorId, client, mcpServerUrl);
+        } catch (error) {
+            // Server error - log and continue processing other actors
+            log.error('Failed to connect to MCP server', {
+                actorFullName: actorInfo.actorDefinitionPruned.actorFullName,
+                actorId,
+                error,
+            });
+            return [];
         } finally {
             if (client) await client.close();
         }
@@ -273,17 +281,26 @@ export async function getActorsAsTools(
                 } as ActorInfo;
             }
 
-            const actorDefinitionPruned = await getActorDefinition(actorIdOrName, apifyClient);
-            if (!actorDefinitionPruned) {
-                log.error('Actor not found or definition is not available', { actorName: actorIdOrName });
+            try {
+                const actorDefinitionPruned = await getActorDefinition(actorIdOrName, apifyClient);
+                if (!actorDefinitionPruned) {
+                    log.info('Actor not found or definition is not available', { actorName: actorIdOrName });
+                    return null;
+                }
+                // Cache the pruned Actor definition
+                actorDefinitionPrunedCache.set(actorIdOrName, actorDefinitionPruned);
+                return {
+                    actorDefinitionPruned,
+                    webServerMcpPath: getActorMCPServerPath(actorDefinitionPruned),
+                } as ActorInfo;
+            } catch (error) {
+                // Server error - log and continue processing other actors
+                log.error('Failed to fetch Actor definition', {
+                    actorName: actorIdOrName,
+                    error,
+                });
                 return null;
             }
-            // Cache the pruned Actor definition
-            actorDefinitionPrunedCache.set(actorIdOrName, actorDefinitionPruned);
-            return {
-                actorDefinitionPruned,
-                webServerMcpPath: getActorMCPServerPath(actorDefinitionPruned),
-            } as ActorInfo;
         }),
     );
 

src/tools/build.ts

@@ -1,8 +1,6 @@
 import { z } from 'zod';
 import zodToJsonSchema from 'zod-to-json-schema';
 
-import log from '@apify/log';
-
 import { ApifyClient } from '../apify-client.js';
 import { ACTOR_README_MAX_LENGTH, HelperTools } from '../const.js';
 import type {
@@ -32,7 +30,7 @@ export async function getActorDefinition(
 ): Promise<ActorDefinitionPruned | null> {
     const actorClient = apifyClient.actor(actorIdOrName);
     try {
-        // Fetch actor details
+        // Fetch Actor details
         const actor = await actorClient.get();
         if (!actor) {
             return null;
@@ -53,9 +51,20 @@ export async function getActorDefinition(
         }
         return null;
     } catch (error) {
-        const errorMessage = `Failed to fetch input schema for Actor: ${actorIdOrName} with error ${error}.`;
-        log.error(errorMessage);
-        throw new Error(errorMessage);
+        // Check if it's a "not found" error (404 or 400 status codes)
+        const isNotFound = typeof error === 'object'
+            && error !== null
+            && 'statusCode' in error
+            && (error.statusCode === 404 || error.statusCode === 400);
+
+        if (isNotFound) {
+            // Return null for not found - caller will log appropriately
+            return null;
+        }
+
+        // For server errors, throw the original error (preserve error type)
+        // Caller should catch and log
+        throw error;
     }
 }
 function pruneActorDefinition(response: ActorDefinitionWithDesc): ActorDefinitionPruned {
@@ -121,14 +130,23 @@ export const actorDefinitionTool: ToolEntry = {
 
         const parsed = getActorDefinitionArgsSchema.parse(args);
         const apifyClient = new ApifyClient({ token: apifyToken });
-        const v = await getActorDefinition(parsed.actorName, apifyClient, parsed.limit);
-        if (!v) {
-            return { content: [{ type: 'text', text: `Actor '${parsed.actorName}' not found.` }] };
-        }
-        if (v && v.input && 'properties' in v.input && v.input) {
-            const properties = filterSchemaProperties(v.input.properties as { [key: string]: ISchemaProperties });
-            v.input.properties = shortenProperties(properties);
+        try {
+            const v = await getActorDefinition(parsed.actorName, apifyClient, parsed.limit);
+            if (!v) {
+                return { content: [{ type: 'text', text: `Actor '${parsed.actorName}' not found.` }] };
+            }
+            if (v && v.input && 'properties' in v.input && v.input) {
+                const properties = filterSchemaProperties(v.input.properties as { [key: string]: ISchemaProperties });
+                v.input.properties = shortenProperties(properties);
+            }
+            return { content: [{ type: 'text', text: `\`\`\`json\n${JSON.stringify(v)}\n\`\`\`` }] };
+        } catch (error) {
+            return {
+                content: [{
+                    type: 'text',
+                    text: `Failed to fetch Actor definition: ${error instanceof Error ? error.message : String(error)}`,
+                }],
+            };
         }
-        return { content: [{ type: 'text', text: `\`\`\`json\n${JSON.stringify(v)}\n\`\`\`` }] };
     },
 } as const;

src/tools/utils.ts

@@ -180,6 +180,16 @@ export function buildActorInputSchema(actorFullName: string, input: IActorInputS
         delete working.schemaVersion;
     }
 
+    // Remove $ref and $schema fields if present
+    // since AJV cannot resolve external schema references
+    // $ref and $schema are present in apify/website-content-crawler input schema
+    if ('$ref' in working) {
+        delete (working as { $ref?: string }).$ref;
+    }
+    if ('$schema' in working) {
+        delete (working as { $schema?: string }).$schema;
+    }
+
     let finalSchema = working;
     if (isRag) {
         finalSchema = pruneSchemaPropertiesByWhitelist(finalSchema, RAG_WEB_BROWSER_WHITELISTED_FIELDS);

src/utils/actor.ts

@@ -20,16 +20,32 @@ export async function getActorMcpUrlCached(
         return cached as string | false;
     }
 
-    const actorDefinitionPruned = await getActorDefinition(actorIdOrName, apifyClient);
-    const mcpPath = actorDefinitionPruned && getActorMCPServerPath(actorDefinitionPruned);
-    if (actorDefinitionPruned && mcpPath) {
-        const url = await getActorMCPServerURL(actorDefinitionPruned.id, mcpPath);
-        mcpServerCache.set(actorIdOrName, url);
-        return url;
-    }
+    try {
+        const actorDefinitionPruned = await getActorDefinition(actorIdOrName, apifyClient);
+        const mcpPath = actorDefinitionPruned && getActorMCPServerPath(actorDefinitionPruned);
+        if (actorDefinitionPruned && mcpPath) {
+            const url = await getActorMCPServerURL(actorDefinitionPruned.id, mcpPath);
+            mcpServerCache.set(actorIdOrName, url);
+            return url;
+        }
+
+        mcpServerCache.set(actorIdOrName, false);
+        return false;
+    } catch (error) {
+        // Check if it's a "not found" error (404 or 400 status codes)
+        const isNotFound = typeof error === 'object'
+            && error !== null
+            && 'statusCode' in error
+            && (error.statusCode === 404 || error.statusCode === 400);
 
-    mcpServerCache.set(actorIdOrName, false);
-    return false;
+        if (isNotFound) {
+            // Actor doesn't exist - cache false and return false
+            mcpServerCache.set(actorIdOrName, false);
+            return false;
+        }
+        // Real server error - don't cache, let it propagate
+        throw error;
+    }
 }
 
 /**