@apify/actors-mcp-server 0.12.1-beta.3 → 0.13.1-beta.0

package/dist/mcp/server.d.ts

@@ -1,91 +1,134 @@
 /**
  * Model Context Protocol (MCP) server for Apify Actors
  */
-import type { TaskStore } from '@modelcontextprotocol/sdk/experimental/tasks/interfaces.js';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { InitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { ApifyClient } from '../apify_client.js';
-import type { ActorsMcpServerOptions, ActorStore, Input, TelemetryEnv, ToolEntry } from '../types.js';
+import { createPromptService } from '../prompts/prompt_service.js';
+import { createResourceService } from '../resources/resource_service.js';
+import type { ActorsMcpServerOptions, ActorStore, ApifyRequestParams, Input, TelemetryEnv, ToolEntry } from '../types.js';
 import { SERVER_MODE } from '../types.js';
+import type { McpClientContext } from './client_context.js';
+import type { LegacyMcpServerHost } from './legacy_server.js';
+import type { StatelessMcpServerHost, StatelessRequestSnapshot } from './stateless_server.js';
 /**
- * Create Apify MCP server
+ * The shared-Apify-behavior facade: owns the tool registry + loaders, server-mode resolution,
+ * telemetry config, widgets, prompt/resource services, and token/client resolution. Constructs
+ * exactly one {@link LegacyMcpServer} (2025-era adapter) and delegates all v1 protocol work to it.
+ * Implements {@link StatelessMcpServerHost} for the 2026-07-28 adapter too, but does not construct
+ * it — `createStatelessServer` builds one per request from a snapshot this facade hands out.
  */
-export declare class ActorsMcpServer {
-    readonly server: Server;
+export declare class ActorsMcpServer implements LegacyMcpServerHost, StatelessMcpServerHost {
+    /**
+     * The resolved tool map the instance's own (stateful) connection serves, composed from
+     * `toolSources` once the handshake makes mode and client known. A stateless request never
+     * reads it — its snapshot re-composes from the sources ({@link createRequestSnapshot}).
+     */
     readonly tools: Map<string, ToolEntry>;
-    private sigintHandler;
-    private currentLogLevel;
     readonly options: ActorsMcpServerOptions;
-    readonly taskStore: TaskStore;
     readonly actorStore?: ActorStore;
-    private clientContext;
+    private _clientContext;
     /**
      * Resolved server mode. Preliminary value at construction (`'auto'` → `DEFAULT`).
-     * Finalized inside the `initialize` request handler (see constructor) once the
+     * Finalized inside the `initialize` request handler (see {@link applyInitialize}) once the
      * client's capabilities are known. Effectively set-once per connection.
      */
-    serverMode: SERVER_MODE;
+    private _serverMode;
     /**
      * Raw option captured from `options.serverMode` (or the legacy `uiMode`). Re-resolved
      * inside the initialize handler when set to `'auto'`; explicit `'default'`/`'apps'`
      * values bypass auto-detect.
      */
     private readonly serverModeOption;
-    /** True once the server mode is final: at construction for explicit `default`/`apps`, or after
-     *  the initialize handler resolves `'auto'`. Composing before this in `'auto'` mode would use
-     *  the preliminary DEFAULT mode and produce the wrong (non-widget) tool variants, so composition
-     *  waits for it. Distinct from {@link clientKnown}, which only withholds client-gated tools. */
+    /** True once the server mode is final (at construction, or after initialize resolves `'auto'`).
+     *  Composition waits for it — composing earlier in `'auto'` mode would produce the wrong tool
+     *  variants. Distinct from {@link clientKnown}, which only withholds client-gated tools. */
     private serverModeResolved;
     /**
-     * Tool sources queued until composition is possible. Enqueued when the mode is not yet resolved
-     * (`'auto'` before initialize), and re-composed by the initialize flush — which is also when the
-     * client becomes known, so any client-gated tools withheld by an eager compose are added then.
-     * We capture the exact actor-tool slice fetched for each request so the flush composes every
-     * entry against *its own* actor list rather than the accumulated union across unrelated requests.
+     * Tool sources queued until composition is possible (`'auto'` mode before initialize),
+     * re-composed by the initialize flush once mode and client are known. Each entry keeps the
+     * exact actor-tool slice fetched for its input, so the flush composes it against its own list.
+     * Keyed like {@link toolSources}: a stateless-only facade never drains this queue, so a reload
+     * replaces its entry instead of appending, keeping the queue bounded by distinct inputs.
      */
-    private pendingToolsUntilClientKnown;
+    private readonly pendingToolsUntilClientKnown;
+    /**
+     * The unresolved inputs `tools` is composed from — not a second tool registry. Retained (never
+     * drained) so a stateless request, whose identity arrives per request, can compose its own
+     * resolved set from the same inputs without touching `tools`. Keyed by input because nothing
+     * drains it: a reload replaces its entry instead of appending, bounding the map by distinct
+     * inputs instead of growing per reload for the facade's lifetime.
+     */
+    private readonly toolSources;
     readonly telemetryEnabled: boolean;
     readonly telemetryEnv: TelemetryEnv;
+    readonly promptService: ReturnType<typeof createPromptService>;
+    readonly resourceService: ReturnType<typeof createResourceService>;
     private availableWidgets;
+    /**
+     * In-flight or successfully settled widget resolution, memoized so the disk scan runs once. A
+     * failed attempt is dropped rather than kept (see {@link resolveWidgetsForMode}).
+     */
+    private widgetsResolution;
     /** Set in the initialize handler once client capabilities are known. */
     clientSupportsUi: boolean;
+    private readonly legacyServer;
+    get clientContext(): McpClientContext | undefined;
+    get serverMode(): SERVER_MODE;
+    /** The instance's own view: what a stateful connection composes and gates against. */
+    private get servingContext();
     constructor(options?: ActorsMcpServerOptions);
     /**
      * Telemetry configuration with precedence: explicit options > env vars > defaults
      */
     private setupTelemetry;
     /**
-     * Override the SDK's `initialize` request handler to run mode resolution and
-     * pending-source flush before `InitializeResult` is sent. Delegates boilerplate
-     * (protocolVersion, capabilities, instructions) to the SDK's captured `_oninitialize`.
-     *
-     * Not using `server.oninitialized`: the SDK dispatches notification handlers
-     * fire-and-forget (separate microtask), so a follow-up `tools/list` can race past them.
-     * The request handler guarantees tools are final before the response and the first `tools/list`.
+     * The shared initialize steps the legacy adapter delegates to before returning
+     * `InitializeResult`: refresh client context, capture the raw request for session recovery,
+     * resolve `'auto'` mode against client capabilities, flush pending tool sources, resolve
+     * widgets. Ordering is load-bearing: mode before compose, compose before instructions, so tool
+     * presence reflects the final composed set.
      */
-    private setupInitializeHandler;
+    applyInitialize(request: InitializeRequest): Promise<void>;
+    /**
+     * Server instructions for the current connection: mode plus whether report-problem is loaded.
+     * Read by the legacy adapter after `applyInitialize`, when the tool set is final.
+     */
+    getServerInstructions(): string;
+    /**
+     * Instructions for a stateless serving unit. The SDK answers `server/discover` from them before
+     * any request's envelope is seen, so they are configuration-level: no report-problem mention
+     * (that tool's presence is decided per request) and the configured mode only. Reads
+     * `serverModeOption`, never `_serverMode` — one facade serves both eras, and a legacy
+     * `initialize` rewrites `_serverMode`, which must not leak into later stateless requests.
+     */
+    getStatelessServerInstructions(): string;
+    /**
+     * Build the read-only view one stateless (2026-07-28) request is served from: mode and tool set
+     * resolved against *that request's* declared identity, and a resource service bound to both.
+     * Nothing request-specific is written back to the facade, so concurrent requests with different
+     * identities cannot contaminate each other.
+     */
+    createRequestSnapshot(clientContext: McpClientContext | undefined): Promise<StatelessRequestSnapshot>;
     /** True once the connecting client is known (set in the initialize handler, or hydrated by a
      *  recovery path). Only client-gated tools wait for this so the per-client blocklist can be
      *  applied; client-agnostic tools compose regardless. */
     private get clientKnown();
     /**
-     * Compose the tool list for the current connection: resolve mode-specific tools, then drop
-     * report-problem unless it is currently servable (see {@link isReportProblemServable}).
-     * report-problem is a default-injected tool (via tools_loader) rather than a category member,
-     * gated here by servability. Every other tool composes eagerly, so a recovery/rehydration load
-     * without an initialize still restores them. report-problem is withheld until the client is known
-     * and re-added by the initialize flush. Used by every input-driven load path and the flush.
-     * (Actor tools are never gated, so they need no filtering.)
+     * Compose one source's tool list against `view`: resolve mode-specific tools, then drop
+     * report-problem unless servable for that view ({@link isReportProblemServable}). Load paths
+     * and the initialize flush pass the instance's own {@link servingContext};
+     * {@link createRequestSnapshot} passes a view derived from one stateless request.
      */
     private composeToolsForClient;
     /**
-     * Whether report-problem may be served on this connection right now:
-     * - Its only function is forwarding submissions via telemetry, so it is never servable when
-     *   telemetry is disabled (it would just fake an acknowledgement into the void).
-     * - It cannot be judged until the connecting client is known, so it is withheld until then;
-     *   the initialize flush re-composes and adds it if the client allows.
-     * Every other tool is unconditionally servable, so recovery loads compose them eagerly and they
-     * survive a load that never sees an initialize.
+     * Whether report-problem may be served against `view`. Never without telemetry (submissions
+     * would vanish into the void) and never before a client context exists — on a stateful
+     * connection the initialize flush re-adds it once the handshake supplies one.
+     *
+     * The stateless envelope requires protocol and capability metadata but not `clientInfo`. A
+     * request declaring no client name matches no blocked substring and is served the tool by
+     * policy.
      */
     private isReportProblemServable;
     private composePendingToolsForClient;
@@ -111,12 +154,10 @@ export declare class ActorsMcpServer {
      */
     listAllToolNames(): string[];
     /**
-     * Buffer-or-compose gate shared by the actor-tools loaders. If the server mode isn't resolved
-     * yet ('auto' before initialize), queue the whole source for `composePendingToolsForClient` and
-     * (if non-empty) upsert the mode-agnostic actor tools immediately.
-     * Once the mode is resolved, compose the client-specific set via `composeToolsForClient` (which
-     * withholds report-problem until the client is known) and upsert it; if the client still isn't
-     * known, queue the source so the initialize flush re-composes and adds the client-gated tools.
+     * Buffer-or-compose gate shared by the actor-tools loaders. Mode not resolved yet: queue the
+     * source for the initialize flush, upserting the mode-agnostic actor tools immediately. Mode
+     * resolved: compose and upsert now; if the client is still unknown, also queue the source so
+     * the flush adds the client-gated tools.
      */
     private registerFetchedActorTools;
     /**
@@ -127,63 +168,46 @@ export declare class ActorsMcpServer {
     /** Load tools from URL params. Used by SSE and HTTP entry points. */
     loadToolsFromUrl(url: string, apifyClient: ApifyClient): Promise<void>;
     /**
-     * Two-phase: getActors (async, client-agnostic Apify fetch) then composeToolsForClient
-     * (sync compose + servability filter). If the mode isn't resolved yet ('auto' before initialize)
-     * the whole source is queued for the flush. Otherwise tools compose immediately; client-gated
-     * tools are withheld until the client is known, and the source is queued so the flush adds them.
-     *
-     * Don't move the getActors await into the initialize handler — clients time out
-     * waiting for InitializeResult. The queue buffers already-fetched data, not network
-     * work. See #721.
+     * Two-phase: getActors (async, client-agnostic fetch) then the buffer-or-compose gate.
+     * Don't move the getActors await into the initialize handler — clients time out waiting for
+     * InitializeResult; the queue buffers already-fetched data, not network work. See #721.
      */
     loadToolsFromInput(input: Input, apifyClient: ApifyClient): Promise<void>;
-    /** Delete tools from the server. */
-    removeToolsByName(toolNames: string[]): string[];
     /**
-     * Upsert new tools.
-     * @param tools - Array of tool wrappers to add or update
-     * @returns Array of added/updated tool wrappers
+     * Upsert new tools. Writes the shared tool map directly, bypassing the retained load sources,
+     * so a tool added only this way reaches no stateless snapshot. Load through `loadToolsFrom*` /
+     * `loadToolsByName` instead to serve a tool on both protocol eras.
      */
     upsertTools(tools: ToolEntry[]): ToolEntry[];
-    private removeToolByName;
-    private setupErrorHandling;
-    private setupLoggingProxy;
-    private setupLoggingHandlers;
+    private toStoredTool;
     /**
      * Token sources in order: per-request `_meta.apifyToken` (stdio inline) > server-instance
      * option (set by the transport from `Authorization` header or stdio env). No env fallback:
      * dev_server / production must extract the token from request headers so payment
      * mode (no token) behaves identically to production.
      */
-    private resolveApifyToken;
+    resolveApifyToken(meta?: ApifyRequestParams['_meta']): string | undefined;
     /**
      * Token-scoped client for resources/read (the API proxy needs auth). Deliberately token-only:
      * unlike the CallTool path it does NOT forward provider/payment headers, so a payment-only
      * session (x402/Skyfire, no Apify token) has no client and every read fails by design.
      * Still carries the request-origin tag from the client context captured by this point.
      */
-    private resolveApifyClient;
-    private setupResourceHandlers;
-    /**
-     * Sets up MCP request handlers for prompts. The prompt service throws domain errors; the
-     * boundary maps them to `McpError` so wire output is unchanged.
-     */
-    private setupPromptHandlers;
-    /**
-     * Fetches a task by ID, softFail-logging and throwing a client-facing McpError if it doesn't exist.
-     */
-    private getTaskOrThrow;
+    resolveApifyClient(params: ApifyRequestParams): ApifyClient | undefined;
+    /** The one place a request-scoped Apify client is constructed, on either protocol era. */
+    private createApifyClient;
     /**
-     * Sets up MCP request handlers for long-running tasks.
-     * Each handler reads `_meta.mcpSessionId` (injected at the transport layer) to isolate
-     * per-session task stores.
+     * Widgets servable in `mode`: none outside apps mode, otherwise the disk registry. A successful
+     * scan is memoized per facade (a widget file appearing later is not picked up); a failed one is
+     * dropped so the next caller retries. Touches no per-connection state, so a per-request caller
+     * cannot disturb a concurrent one.
      */
-    private setupTaskHandlers;
-    private setupToolHandlers;
+    private resolveWidgetsForMode;
     /**
-     * Resolves widgets and determines which ones are ready to be served.
+     * Resolve the instance's own widget map for this connection's mode. The only writer of that
+     * field — per-request callers take the map `resolveWidgetsForMode` returns instead.
      */
-    private resolveWidgets;
+    private resolveInstanceWidgets;
     connect(transport: Transport): Promise<void>;
     close(): Promise<void>;
 }

package/dist/mcp/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"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"}