cache Actor definition and real Actor ID API calls

Author: MQ37

src/mcp/actors.ts

@@ -1,3 +1,4 @@
+import { log } from 'apify';
 import type { ActorDefinition } from 'apify-client';
 
 import { ApifyClient, getApifyAPIBaseUrl } from '../apify-client.js';
@@ -8,7 +9,7 @@ export async function isActorMCPServer(actorID: string, apifyToken: string): Pro
 }
 
 export async function getActorsMCPServerPath(actorID: string, apifyToken: string): Promise<string | undefined> {
-    const actorDefinition = await getActorDefinition(actorID, apifyToken);
+    const actorDefinition = await getFullActorDefinition(actorID, apifyToken);
 
     if ('webServerMcpPath' in actorDefinition && typeof actorDefinition.webServerMcpPath === 'string') {
         return actorDefinition.webServerMcpPath;
@@ -26,20 +27,32 @@ export async function getActorsMCPServerURL(actorID: string, apifyToken: string)
     return `${standbyUrl}${mcpPath}`;
 }
 
+// ID does not change, so no TTL
+export const actorIDCache: Record<string, string> = {};
 /**
 * Gets Actor ID from the Actor object.
 *
 * @param actorID
 * @param apifyToken
 */
 export async function getRealActorID(actorID: string, apifyToken: string): Promise<string> {
+    if (actorIDCache[actorID]) {
+        log.debug(`Actor ${actorID} ID cache hit`);
+        return actorIDCache[actorID];
+    }
+    log.debug(`Actor ${actorID} ID cache miss`);
+
     const apifyClient = new ApifyClient({ token: apifyToken });
 
     const actor = apifyClient.actor(actorID);
     const info = await actor.get();
     if (!info) {
         throw new Error(`Actor ${actorID} not found`);
     }
+
+    if (!actorIDCache[actorID]) {
+        actorIDCache[actorID] = info.id;
+    }
     return info.id;
 }
 
@@ -56,7 +69,29 @@ export async function getActorStandbyURL(actorID: string, apifyToken: string, st
     return `https://${actorRealID}.${standbyBaseUrl}`;
 }
 
-export async function getActorDefinition(actorID: string, apifyToken: string): Promise<ActorDefinition> {
+export const actorDefinitionCache: Record<string, {
+    timestamp: number;
+    definition: ActorDefinition;
+}> = {};
+export const ACTOR_DEFINITION_CACHE_TTL_MS = 1000 * 60 * 60; // 1 hour
+/**
+* Gets full Actor definition from the Apify API.
+*/
+export async function getFullActorDefinition(actorID: string, apifyToken: string): Promise<ActorDefinition> {
+    const cacheInTTL = Date.now() - (actorDefinitionCache[actorID]?.timestamp || 0) < ACTOR_DEFINITION_CACHE_TTL_MS;
+    // Hit the cache
+    if (actorDefinitionCache[actorID]
+        && cacheInTTL) {
+        log.debug(`Actor ${actorID} definition cache hit`);
+        return actorDefinitionCache[actorID].definition;
+    }
+    // Refresh the cache after TTL expired
+    if (actorDefinitionCache[actorID] && !cacheInTTL) {
+        log.debug(`Actor ${actorID} definition cache TTL expired, re-fetching`);
+    } else {
+        log.debug(`Actor ${actorID} definition cache miss`);
+    }
+
     const apifyClient = new ApifyClient({ token: apifyToken });
     const actor = apifyClient.actor(actorID);
     const info = await actor.get();
@@ -84,5 +119,14 @@ export async function getActorDefinition(actorID: string, apifyToken: string): P
         throw new Error(`Actor default build ${actorID} does not have Actor definition`);
     }
 
+    // If the Actor is public, we cache the definition
+    // This code branch is executed only on cache miss, so we know the cache entry is empty
+    if (info.isPublic) {
+        actorDefinitionCache[actorID] = {
+            timestamp: Date.now(),
+            definition: actorDefinition,
+        };
+    }
+
     return actorDefinition;
 }

src/tools/actor.ts

@@ -125,6 +125,7 @@ async function getMCPServersAsTools(
 ): Promise<ToolWrap[]> {
     const actorsMCPServerTools: ToolWrap[] = [];
     for (const actorID of actors) {
+        // getFullActorDefinition uses cache, so we can call it twice (this is the second time)
         const serverUrl = await getActorsMCPServerURL(actorID, apifyToken);
         log.info(`ActorID: ${actorID} MCP server URL: ${serverUrl}`);
 
@@ -150,7 +151,7 @@ export async function getActorsAsTools(
     // Actorized MCP servers
     const actorsMCPServers: string[] = [];
     for (const actorID of actors) {
-        // TODO: rework, we are fetching actor definition from API twice - in the getMCPServerTools
+        // getFullActorDefinition uses cache, so we can call it twice (second time in the getMCPServerTools)
         if (await isActorMCPServer(actorID, apifyToken)) {
             actorsMCPServers.push(actorID);
         }