feat: Actorized MCP servers proxy

src/actor/server.ts

@@ -9,8 +9,9 @@ import express from 'express';
 import log from '@apify/log';
 
 import { HEADER_READINESS_PROBE, Routes } from './const.js';
-import { type ActorsMcpServer } from '../mcp-server.js';
-import { getActorRunData, processParamsGetTools } from './utils.js';
+import { type ActorsMcpServer } from '../mcp/server.js';
+import { getActorRunData } from './utils.js';
+import { processParamsGetTools } from '../mcp/utils.js';
 
 export function createExpressApp(
     host: string,
@@ -32,7 +33,7 @@ export function createExpressApp(
             }
             try {
                 log.info(`Received GET message at: ${Routes.ROOT}`);
-                const tools = await processParamsGetTools(req.url);
+                const tools = await processParamsGetTools(req.url, process.env.APIFY_TOKEN as string);
                 if (tools) {
                     mcpServer.updateTools(tools);
                 }
@@ -53,7 +54,7 @@ export function createExpressApp(
         .get(async (req: Request, res: Response) => {
             try {
                 log.info(`Received GET message at: ${Routes.SSE}`);
-                const tools = await processParamsGetTools(req.url);
+                const tools = await processParamsGetTools(req.url, process.env.APIFY_TOKEN as string);
                 if (tools) {
                     mcpServer.updateTools(tools);
                 }

src/actor/types.ts

@@ -1,10 +1,3 @@
-export type Input = {
-    actors: string[] | string;
-    enableActorAutoLoading?: boolean;
-    maxActorMemoryBytes?: number;
-    debugActor?: string;
-    debugActorInput?: unknown;
-};
 
 export interface ActorRunData {
     id?: string;

src/actor/utils.ts

@@ -1,34 +1,7 @@
-import { parse } from 'node:querystring';
 
 import { Actor } from 'apify';
+import type { ActorRunData } from './types.js';
 
-import { processInput } from './input.js';
-import type { ActorRunData, Input } from './types.js';
-import { addTool, getActorsAsTools, removeTool } from '../tools/index.js';
-import type { ToolWrap } from '../types.js';
-
-export function parseInputParamsFromUrl(url: string): Input {
-    const query = url.split('?')[1] || '';
-    const params = parse(query) as unknown as Input;
-    return processInput(params);
-}
-
-/**
- * Process input parameters and get tools
- * If URL contains query parameter `actors`, return tools from Actors otherwise return null.
- * @param url
- */
-export async function processParamsGetTools(url: string) {
-    const input = parseInputParamsFromUrl(url);
-    let tools: ToolWrap[] = [];
-    if (input.actors) {
-        tools = await getActorsAsTools(input.actors as string[]);
-    }
-    if (input.enableActorAutoLoading) {
-        tools.push(addTool, removeTool);
-    }
-    return tools;
-}
 
 export function getActorRunData(): ActorRunData | null {
     return Actor.isAtHome() ? {

src/tools/mcp-apify-client.ts → src/apify-client.ts

@@ -3,7 +3,7 @@ import type { ApifyClientOptions } from 'apify';
 import { ApifyClient as _ApifyClient } from 'apify-client';
 import type { AxiosRequestConfig } from 'axios';
 
-import { USER_AGENT_ORIGIN } from '../const.js';
+import { USER_AGENT_ORIGIN } from './const.js';
 
 /**
  * Adds a User-Agent header to the request config.
@@ -21,7 +21,7 @@ export class ApifyClient extends _ApifyClient {
     constructor(options: ApifyClientOptions) {
         super({
             ...options,
-            baseUrl: process.env.MCP_APIFY_BASE_URL || undefined,
+            baseUrl: process.env.APIFY_API_BASE_URL || undefined,
             requestInterceptors: [addUserAgent],
         });
     }

src/const.ts

@@ -37,3 +37,5 @@ export const defaults = {
     enableActorAutoLoading: false,
     maxMemoryMbytes: 4096,
 };
+
+export const APIFY_USERNAME = 'apify';

src/index.ts

@@ -1,7 +1,8 @@
+
 /*
  This file provides essential functions and tools for MCP servers, serving as a library.
  The ActorsMcpServer should be the only class exported from the package
 */
 
-import { ActorsMcpServer } from './mcp-server.js';
+import { ActorsMcpServer } from './mcp/server.js';
 export default ActorsMcpServer;

src/main.ts

@@ -1,3 +1,4 @@
+
 /**
  * Serves as an Actor MCP SSE server entry point.
  * This file needs to be named `main.ts` to be recognized by the Apify platform.
@@ -8,11 +9,12 @@ import type { ActorCallOptions } from 'apify-client';
 
 import log from '@apify/log';
 
-import { processInput } from './actor/input.js';
+import { processInput } from './input.js';
 import { createExpressApp } from './actor/server.js';
-import type { Input } from './actor/types';
-import { ActorsMcpServer } from './mcp-server.js';
-import { actorDefinitionTool, addTool, removeTool, searchTool, callActorGetDataset } from './tools/index.js';
+import type { Input } from './types.js';
+import { ActorsMcpServer } from './mcp/server.js';
+import { actorDefinitionTool, addTool, removeTool, searchTool, callActorGetDataset, getActorsAsTools } from './tools/index.js';
+import { defaults } from './const.js';
 
 const STANDBY_MODE = Actor.getEnv().metaOrigin === 'STANDBY';
 
@@ -38,6 +40,10 @@ if (STANDBY_MODE) {
     if (input.enableActorAutoLoading) {
         tools.push(addTool, removeTool);
     }
+    const actors = input.actors ?? defaults.actors;
+    const actorsToLoad = Array.isArray(actors) ? actors : actors.split(',');
+    const actorTools = await getActorsAsTools(actorsToLoad, process.env.APIFY_TOKEN as string);
+    tools.push(...actorTools);
     mcpServer.updateTools(tools);
     app.listen(PORT, () => {
         log.info(`The Actor web server is listening for user requests at ${HOST}`);

src/mcp/actors.ts

@@ -0,0 +1,76 @@
+
+import { ActorDefinition } from "apify-client";
+import { ApifyClient } from "../apify-client.js";
+
+
+export async function isActorMCPServer(actorID: string, apifyToken: string): Promise<boolean> {
+    const mcpPath = await getActorsMCPServerPath(actorID, apifyToken);
+    return (mcpPath?.length || 0) > 0;
+}
+
+export async function getActorsMCPServerPath(actorID: string, apifyToken: string): Promise<string | undefined> {
+    const actorDefinition = await getActorDefinition(actorID, apifyToken);
+    return (actorDefinition as any).webServerMcpPath;
+}
+
+export async function getActorsMCPServerURL(actorID: string, apifyToken: string): Promise<string> {
+    // TODO: get from API instead
+    const standbyBaseUrl = process.env.HOSTNAME === 'mcp-securitybyobscurity.apify.com' ?
+        'securitybyobscurity.apify.actor' : 'apify.actor';
+    const standbyUrl = await getActorStandbyURL(actorID, apifyToken, standbyBaseUrl);
+    const mcpPath = await getActorsMCPServerPath(actorID, apifyToken);
+    return `${standbyUrl}${mcpPath}`;
+}
+
+/**
+* Gets Actor ID from the Actor object.
+*
+* @param actorID
+*/
+export async function getRealActorID(actorID: string, apifyToken: string): Promise<string> {
+    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`);
+    }
+    return info.id;
+}
+
+/**
+* Returns standby URL for given Actor ID.
+*
+* @param actorID
+* @param standbyBaseUrl
+* @returns
+*/
+export async function getActorStandbyURL(actorID: string, apifyToken: string, standbyBaseUrl = 'apify.actor'): Promise<string> {
+    const actorRealID = await getRealActorID(actorID, apifyToken);
+    return `https://${actorRealID}.${standbyBaseUrl}`;
+}
+
+export async function getActorDefinition(actorID: string, apifyToken: string): Promise<ActorDefinition> {
+    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`);
+    }
+    const latestBuildID = info.taggedBuilds?.['latest']?.buildId;
+    if (!latestBuildID) {
+        throw new Error(`Actor ${actorID} does not have a latest build`);
+    }
+    const build = apifyClient.build(latestBuildID);
+    const buildInfo = await build.get();
+    if (!buildInfo) {
+        throw new Error(`Build ${latestBuildID} not found`);
+    }
+    const actorDefinition = buildInfo.actorDefinition;
+    if (!actorDefinition) {
+        throw new Error(`Build ${latestBuildID} does not have an actor definition`);
+    }
+
+    return actorDefinition;
+}

src/mcp/client.ts

@@ -0,0 +1,41 @@
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { getMCPServerID } from "./utils.js";
+
+/**
+ * Creates and connects a ModelContextProtocol client.
+ */
+export async function createMCPClient(
+    url: string, token: string
+): Promise<Client> {
+    const transport = new SSEClientTransport(
+        new URL(url),
+        {
+            requestInit: {
+                headers: {
+                    authorization: `Bearer ${token}`,
+                },
+            },
+            eventSourceInit: {
+                // The EventSource package augments EventSourceInit with a "fetch" parameter.
+                // You can use this to set additional headers on the outgoing request.
+                // Based on this example: https://github.com/modelcontextprotocol/typescript-sdk/issues/118
+                async fetch(input: Request | URL | string, init?: RequestInit) {
+                    const headers = new Headers(init?.headers || {});
+                    headers.set('authorization', `Bearer ${token}`);
+                    return fetch(input, { ...init, headers });
+                },
+            // We have to cast to "any" to use it, since it's non-standard
+            } as any, // eslint-disable-line @typescript-eslint/no-explicit-any
+        });
+
+    const client = new Client({
+        name: getMCPServerID(url),
+        version: "1.0.0",
+    });
+
+    await client.connect(transport);
+
+    return client;
+}

src/mcp/const.ts

@@ -0,0 +1,3 @@
+
+export const MAX_TOOL_NAME_LENGTH = 64;
+export const SERVER_ID_LENGTH = 8

src/mcp/proxy.ts

@@ -0,0 +1,41 @@
+import Ajv from "ajv";
+import { ActorMCPTool, ToolWrap } from "../types.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { getMCPServerID, getProxyMCPServerToolName } from "./utils.js";
+
+export async function getMCPServerTools(
+    actorID: string,
+    client: Client,
+    // Name of the MCP server
+    serverUrl: string
+): Promise<ToolWrap[]> {
+    const res = await client.listTools();
+    const tools = res.tools;
+
+
+    const ajv = new Ajv({ coerceTypes: 'array', strict: false });
+
+    const compiledTools: ToolWrap[] = [];
+    for (const tool of tools) {
+        const mcpTool: ActorMCPTool = {
+            actorID,
+            serverId: getMCPServerID(serverUrl),
+            serverUrl,
+            originToolName: tool.name,
+
+            name: getProxyMCPServerToolName(serverUrl, tool.name),
+            description: tool.description || "",
+            inputSchema: tool.inputSchema,
+            ajvValidate: ajv.compile(tool.inputSchema)
+        }
+
+        const wrap: ToolWrap = {
+            type: 'actor-mcp',
+            tool: mcpTool,
+        }
+
+        compiledTools.push(wrap);
+    }
+
+    return compiledTools;
+}