@apify/actors-mcp-server/dist/mcp/server.d.ts

Model Context Protocol Server for Apify

/**
 * Model Context Protocol (MCP) server for Apify Actors
 */
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
import type { ToolEntry } from '../types.js';
type ActorsMcpServerOptions = {
    enableAddingActors?: boolean;
    enableDefaultActors?: boolean;
};
/**
 * Create Apify MCP server
 */
export declare class ActorsMcpServer {
    readonly server: Server;
    readonly tools: Map<string, ToolEntry>;
    private options;
    private toolsChangedHandler;
    private sigintHandler;
    constructor(options?: ActorsMcpServerOptions, setupSigintHandler?: boolean);
    /**
     * Returns an array of tool names.
     * @returns {string[]} - An array of tool names.
     */
    listToolNames(): string[];
    /**
    * Register handler to get notified when tools change.
    * The handler receives an array of tool names that the server has after the change.
    * This is primarily used to store the tools in shared state (e.g., Redis) for recovery
    * when the server loses local state.
    * @throws {Error} - If a handler is already registered.
    * @param handler - The handler function to be called when tools change.
    */
    registerToolsChangedHandler(handler: (toolNames: string[]) => void): void;
    /**
    * Unregister the handler for tools changed event.
    * @throws {Error} - If no handler is currently registered.
    */
    unregisterToolsChangedHandler(): void;
    /**
     * Returns the list of all internal tool names
     * @returns {string[]} - Array of loaded tool IDs (e.g., 'apify/rag-web-browser')
     */
    private listInternalToolNames;
    /**
     * Returns the list of all currently loaded Actor tool IDs.
     * @returns {string[]} - Array of loaded Actor tool IDs (e.g., 'apify/rag-web-browser')
     */
    listActorToolNames(): string[];
    /**
     * Returns a list of Actor IDs that are registered as MCP servers.
     * @returns {string[]} - An array of Actor MCP server Actor IDs (e.g., 'apify/actors-mcp-server').
     */
    private listActorMcpServerToolIds;
    /**
     * Returns a list of Actor name and MCP server tool IDs.
     * @returns {string[]} - An array of Actor MCP server Actor IDs (e.g., 'apify/actors-mcp-server').
     */
    listAllToolNames(): string[];
    /**
    * Loads missing toolNames from a provided list of tool names.
    * Skips toolNames that are already loaded and loads only the missing ones.
    * @param toolNames - Array of tool names to ensure are loaded
    * @param apifyToken - Apify API token for authentication
    */
    loadToolsByName(toolNames: string[], apifyToken: string): Promise<void>;
    /**
    * Resets the server to the default state.
    * This method clears all tools and loads the default tools.
    * Used primarily for testing purposes.
    */
    reset(): Promise<void>;
    /**
     * Initialize the server with default tools if enabled
     */
    initialize(): Promise<void>;
    /**
     * Loads default tools if not already loaded.
     * @param apifyToken - Apify API token for authentication
     * @returns {Promise<void>} - A promise that resolves when the tools are loaded
     */
    loadDefaultActors(apifyToken: string): Promise<void>;
    /**
     * @deprecated Use `loadDefaultActors` instead.
     * Loads default tools if not already loaded.
     */
    loadDefaultTools(apifyToken: string): Promise<void>;
    /**
     * Loads tools from URL params.
     *
     * This method also handles enabling of Actor autoloading via the processParamsGetTools.
     *
     * Used primarily for SSE.
     */
    loadToolsFromUrl(url: string, apifyToken: string): Promise<void>;
    /**
     * Add Actors to server dynamically
     */
    enableDynamicActorTools(): void;
    disableDynamicActorTools(): void;
    /** Delete tools from the server and notify the handler.
     */
    removeToolsByName(toolNames: string[], shouldNotifyToolsChangedHandler?: boolean): string[];
    /**
     * Upsert new tools.
     * @param tools - Array of tool wrappers to add or update
     * @param shouldNotifyToolsChangedHandler - Whether to notify the tools changed handler
     * @returns Array of added/updated tool wrappers
     */
    upsertTools(tools: ToolEntry[], shouldNotifyToolsChangedHandler?: boolean): ToolEntry[];
    private notifyToolsChangedHandler;
    private removeToolByName;
    private setupErrorHandling;
    /**
     * Sets up MCP request handlers for prompts.
     */
    private setupPromptHandlers;
    private setupToolHandlers;
    connect(transport: Transport): Promise<void>;
    close(): Promise<void>;
}
export {};
//# sourceMappingURL=server.d.ts.map