@prefecthq/fastmcp-ts 1.1.0 → 1.2.0

package/dist/client.d.ts

@@ -1,6 +1,7 @@
 import { CreateMessageResult, CreateMessageResultWithTools, ContentBlock, CreateMessageRequestParams, LoggingLevel, ElicitRequestParams, ElicitResult, Tool, Resource, Prompt, ResourceTemplateType, TextResourceContents, BlobResourceContents, GetPromptResult, OAuthClientMetadata as OAuthClientMetadata$1, Root, ModelPreferences, SamplingMessage, ToolChoice } from '@modelcontextprotocol/server';
 export { BlobResourceContents, ContentBlock, CreateMessageRequestParams, CreateMessageResult, CreateMessageResultWithTools, ElicitRequestParams, ElicitResult, GetPromptResult, LoggingLevel, ModelPreferences, Prompt, PromptArgument, PromptMessage, Resource, ResourceContents, ResourceTemplateType as ResourceTemplate, Root, SamplingMessage, TextResourceContents, Tool, ToolChoice, ToolResultContent, ToolUseContent } from '@modelcontextprotocol/server';
-import { OAuthClientProvider, OAuthClientMetadata, OAuthClientInformationContext, StoredOAuthClientInformation, StoredOAuthTokens, OAuthDiscoveryState, ClientAuthMethod, Transport, VersionNegotiationOptions, ProtocolEra, PriorDiscovery, InputRequiredOptions, ResponseCacheStore, Implementation, ServerCapabilities } from '@modelcontextprotocol/client';
+import { OAuthClientProvider, OAuthClientMetadata, OAuthClientInformationContext, StoredOAuthClientInformation, StoredOAuthTokens, OAuthDiscoveryState, ClientAuthMethod, Transport, ClientCapabilities, VersionNegotiationOptions, PriorDiscovery, InputRequiredOptions, ResponseCacheStore, ProtocolEra, Implementation, ServerCapabilities } from '@modelcontextprotocol/client';
+export { ClientCapabilities } from '@modelcontextprotocol/client';
 import Anthropic from '@anthropic-ai/sdk';
 import OpenAI from 'openai';
 import { GoogleGenAI } from '@google/genai';
@@ -598,115 +599,6 @@ declare class StdioTransport {
 }
 type ClientTransportInput = string | McpServerLike | McpConfig | StdioTransport | Transport;
 
-interface MultiServerOptions {
-    handlers?: ClientHandlers;
-    /** file:// URIs to advertise to all servers as accessible roots. */
-    roots?: string[];
-    defaultOptions?: ClientDefaultOptions;
-    /**
-     * Protocol version negotiation, applied identically to every server in the
-     * config (protocol revision 2026-07-28 and later). See
-     * `ClientOptions.versionNegotiation` on the single-server `Client` — same
-     * semantics, just applied per sub-client here since each connected server
-     * negotiates its own era independently. Default `{ mode: 'auto' }`: each
-     * sub-client probes its server once and falls back to legacy when the
-     * server offers no modern era; `{ mode: 'legacy' }` opts every connection
-     * out of the probe.
-     */
-    versionNegotiation?: VersionNegotiationOptions;
-}
-declare class MultiServerClient implements IClient {
-    private _clients;
-    private _connectPromise;
-    private _connected;
-    /** URI (or namespaced template URI) → server name, populated by list calls */
-    private _uriMap;
-    private readonly _config;
-    private readonly _handlers;
-    private readonly _roots;
-    private readonly _defaultOptions;
-    private readonly _versionNegotiation;
-    private _resourceSubscriptions;
-    /** Modern-era (2026-07-28) subscriptions/listen streams, one per server that
-     * currently has active resource subscriptions — see Client's own field of the
-     * same purpose for the full rationale. Keyed by server name since each
-     * connected server negotiates its own era independently. */
-    private _resourceListenSubscriptions;
-    /** Per-server log level set by setLogLevel() for servers negotiated to modern
-     * era — see Client's own field of the same purpose for the full rationale.
-     * Keyed by server name since each connected server negotiates its own era
-     * independently and may therefore need (or not need) meta-threading. */
-    private _logLevels;
-    constructor(config: McpConfig, options?: MultiServerOptions);
-    connect(): Promise<void>;
-    private _doConnect;
-    close(): Promise<void>;
-    [Symbol.asyncDispose](): Promise<void>;
-    isConnected(): boolean;
-    static connect(config: McpConfig, options?: MultiServerOptions): Promise<MultiServerClient>;
-    /**
-     * The protocol era negotiated with a specific named server: `'modern'` for
-     * 2026-07-28, `'legacy'` for 2025-11-25 and earlier, `undefined` if the
-     * server name is unknown or not yet connected. See
-     * `MultiServerOptions.versionNegotiation` — the same mode is requested of
-     * every server, but each negotiates (and may land on) its own era
-     * independently, so this is necessarily per-server rather than a single
-     * client-wide value.
-     */
-    getProtocolEra(serverName: string): ProtocolEra | undefined;
-    /** See Client.ping's docs — the same era-routing applies here, per server,
-     * since each connected server negotiates its own era independently. */
-    ping(options?: RequestOptions): Promise<boolean>;
-    listTools(options?: RequestOptions): Promise<Tool[]>;
-    callTool<TData = unknown>(name: string, args?: Record<string, unknown>, options?: CallToolOptions): Promise<CallToolResult<TData>>;
-    callToolRaw<TData = unknown>(name: string, args?: Record<string, unknown>, options?: CallToolOptions): Promise<CallToolResult<TData>>;
-    listResources(options?: RequestOptions): Promise<Resource[]>;
-    listResourceTemplates(options?: RequestOptions): Promise<ResourceTemplateType[]>;
-    readResource(uri: string, options?: RequestOptions): Promise<Array<TextResourceContents | BlobResourceContents>>;
-    listPrompts(options?: RequestOptions): Promise<Prompt[]>;
-    getPrompt(name: string, args?: Record<string, string>, options?: RequestOptions): Promise<GetPromptResult>;
-    /** See Client.subscribeResource's docs — the same era-routing applies here,
-     * per server, since each connected server negotiates its own era. */
-    subscribeResource(uri: string, handler: ResourceUpdateHandler, options?: RequestOptions): Promise<void>;
-    unsubscribeResource(uri: string, options?: RequestOptions): Promise<void>;
-    /** Re-opens server-scoped listen stream for its currently-subscribed URIs — see
-     * Client's own private method of the same purpose for the full rationale. */
-    private _refreshResourceListenSubscriptionForServer;
-    complete(ref: {
-        type: 'ref/prompt';
-        name: string;
-    } | {
-        type: 'ref/resource';
-        uri: string;
-    }, argument: {
-        name: string;
-        value: string;
-    }, context?: {
-        arguments?: Record<string, string>;
-    }, options?: RequestOptions): Promise<CompletionResult>;
-    /** See Client.setLogLevel's docs — the same era-routing applies here, per
-     * server: legacy sends the real `logging/setLevel` RPC; modern records the
-     * level and threads it into `_meta` on that server's subsequent requests via
-     * `_metaParamsFor`, since `logging/setLevel` is absent from the modern wire
-     * registry (SEP-2577). */
-    setLogLevel(level: LoggingLevel, options?: RequestOptions): Promise<void>;
-    private _assertConnected;
-    private _parseNamespacedName;
-    private _sdkForServer;
-    private _buildSdkClient;
-    private _buildCapabilities;
-    private _registerHandlers;
-    /** See Client._metaParams's docs — the same purpose, per server name, since
-     * each connected server may be on a different era and have a different
-     * recorded log level (or none). */
-    private _metaParamsFor;
-    private _toSdkOptions;
-}
-
-declare class ToolCallError extends Error {
-    readonly content: ContentBlock[];
-    constructor(message: string, content: ContentBlock[]);
-}
 interface ClientDefaultOptions {
     /** Global fallback timeout in seconds for all requests. */
     timeout?: number;
@@ -735,6 +627,11 @@ interface ClientOptions {
      */
     auth?: BearerAuth | OAuth | AsyncHeaderAuth | string;
     handlers?: ClientHandlers;
+    /**
+     * Additional capabilities to advertise to the server. FastMCP preserves
+     * their settings while adding capabilities inferred from handlers and roots.
+     */
+    capabilities?: ClientCapabilities;
     /**
      * Filesystem roots to advertise to the server.
      * Accepts a static array of strings / Root objects, or an async callback
@@ -815,6 +712,121 @@ interface ClientOptions {
      */
     legacySSE?: boolean;
 }
+
+interface MultiServerOptions {
+    handlers?: ClientHandlers;
+    /**
+     * Additional capabilities to advertise to every server. FastMCP combines
+     * them with capabilities inferred from handlers and roots.
+     */
+    capabilities?: ClientCapabilities;
+    /** file:// URIs to advertise to all servers as accessible roots. */
+    roots?: string[];
+    defaultOptions?: ClientDefaultOptions;
+    /**
+     * Protocol version negotiation, applied identically to every server in the
+     * config (protocol revision 2026-07-28 and later). See
+     * `ClientOptions.versionNegotiation` on the single-server `Client` — same
+     * semantics, just applied per sub-client here since each connected server
+     * negotiates its own era independently. Default `{ mode: 'auto' }`: each
+     * sub-client probes its server once and falls back to legacy when the
+     * server offers no modern era; `{ mode: 'legacy' }` opts every connection
+     * out of the probe.
+     */
+    versionNegotiation?: VersionNegotiationOptions;
+}
+declare class MultiServerClient implements IClient {
+    private _clients;
+    private _connectPromise;
+    private _connected;
+    /** URI (or namespaced template URI) → server name, populated by list calls */
+    private _uriMap;
+    private readonly _config;
+    private readonly _handlers;
+    private readonly _roots;
+    private readonly _capabilities;
+    private readonly _defaultOptions;
+    private readonly _versionNegotiation;
+    private _resourceSubscriptions;
+    /** Modern-era (2026-07-28) subscriptions/listen streams, one per server that
+     * currently has active resource subscriptions — see Client's own field of the
+     * same purpose for the full rationale. Keyed by server name since each
+     * connected server negotiates its own era independently. */
+    private _resourceListenSubscriptions;
+    /** Per-server log level set by setLogLevel() for servers negotiated to modern
+     * era — see Client's own field of the same purpose for the full rationale.
+     * Keyed by server name since each connected server negotiates its own era
+     * independently and may therefore need (or not need) meta-threading. */
+    private _logLevels;
+    constructor(config: McpConfig, options?: MultiServerOptions);
+    connect(): Promise<void>;
+    private _doConnect;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    isConnected(): boolean;
+    static connect(config: McpConfig, options?: MultiServerOptions): Promise<MultiServerClient>;
+    /**
+     * The protocol era negotiated with a specific named server: `'modern'` for
+     * 2026-07-28, `'legacy'` for 2025-11-25 and earlier, `undefined` if the
+     * server name is unknown or not yet connected. See
+     * `MultiServerOptions.versionNegotiation` — the same mode is requested of
+     * every server, but each negotiates (and may land on) its own era
+     * independently, so this is necessarily per-server rather than a single
+     * client-wide value.
+     */
+    getProtocolEra(serverName: string): ProtocolEra | undefined;
+    /** See Client.ping's docs — the same era-routing applies here, per server,
+     * since each connected server negotiates its own era independently. */
+    ping(options?: RequestOptions): Promise<boolean>;
+    listTools(options?: RequestOptions): Promise<Tool[]>;
+    callTool<TData = unknown>(name: string, args?: Record<string, unknown>, options?: CallToolOptions): Promise<CallToolResult<TData>>;
+    callToolRaw<TData = unknown>(name: string, args?: Record<string, unknown>, options?: CallToolOptions): Promise<CallToolResult<TData>>;
+    listResources(options?: RequestOptions): Promise<Resource[]>;
+    listResourceTemplates(options?: RequestOptions): Promise<ResourceTemplateType[]>;
+    readResource(uri: string, options?: RequestOptions): Promise<Array<TextResourceContents | BlobResourceContents>>;
+    listPrompts(options?: RequestOptions): Promise<Prompt[]>;
+    getPrompt(name: string, args?: Record<string, string>, options?: RequestOptions): Promise<GetPromptResult>;
+    /** See Client.subscribeResource's docs — the same era-routing applies here,
+     * per server, since each connected server negotiates its own era. */
+    subscribeResource(uri: string, handler: ResourceUpdateHandler, options?: RequestOptions): Promise<void>;
+    unsubscribeResource(uri: string, options?: RequestOptions): Promise<void>;
+    /** Re-opens server-scoped listen stream for its currently-subscribed URIs — see
+     * Client's own private method of the same purpose for the full rationale. */
+    private _refreshResourceListenSubscriptionForServer;
+    complete(ref: {
+        type: 'ref/prompt';
+        name: string;
+    } | {
+        type: 'ref/resource';
+        uri: string;
+    }, argument: {
+        name: string;
+        value: string;
+    }, context?: {
+        arguments?: Record<string, string>;
+    }, options?: RequestOptions): Promise<CompletionResult>;
+    /** See Client.setLogLevel's docs — the same era-routing applies here, per
+     * server: legacy sends the real `logging/setLevel` RPC; modern records the
+     * level and threads it into `_meta` on that server's subsequent requests via
+     * `_metaParamsFor`, since `logging/setLevel` is absent from the modern wire
+     * registry (SEP-2577). */
+    setLogLevel(level: LoggingLevel, options?: RequestOptions): Promise<void>;
+    private _assertConnected;
+    private _parseNamespacedName;
+    private _sdkForServer;
+    private _buildSdkClient;
+    private _registerHandlers;
+    /** See Client._metaParams's docs — the same purpose, per server name, since
+     * each connected server may be on a different era and have a different
+     * recorded log level (or none). */
+    private _metaParamsFor;
+    private _toSdkOptions;
+}
+
+declare class ToolCallError extends Error {
+    readonly content: ContentBlock[];
+    constructor(message: string, content: ContentBlock[]);
+}
 declare class Client implements IClient {
     private _sdkClient;
     private _refCount;
@@ -842,6 +854,7 @@ declare class Client implements IClient {
     private readonly _auth;
     private readonly _handlers;
     private readonly _roots;
+    private readonly _capabilities;
     private readonly _autoInitialize;
     private readonly _versionNegotiation;
     private readonly _prior;
@@ -1085,7 +1098,6 @@ declare class Client implements IClient {
      */
     private _metaParams;
     private _toSdkOptions;
-    private _buildCapabilities;
     private _buildListChangedConfig;
     private _registerHandlers;
     /**

package/dist/client.js

@@ -916,6 +916,28 @@ async function resolveTransport(input, auth, options) {
 // src/client/client.ts
 import { UnauthorizedError, Client as SdkClient2, LOG_LEVEL_META_KEY as LOG_LEVEL_META_KEY2 } from "@modelcontextprotocol/client";
 
+// src/client/capabilities.ts
+function buildClientCapabilities(supplied, inferred) {
+  const capabilities = { ...supplied };
+  if (inferred.sampling) {
+    capabilities.sampling = {
+      ...supplied?.sampling,
+      tools: supplied?.sampling?.tools ?? {}
+    };
+  }
+  if (inferred.elicitation) {
+    const elicitation = supplied?.elicitation;
+    capabilities.elicitation = elicitation ? { ...elicitation, form: elicitation.form ?? {} } : {};
+  }
+  if (inferred.rootsListChanged !== void 0) {
+    capabilities.roots = {
+      ...supplied?.roots,
+      listChanged: inferred.rootsListChanged
+    };
+  }
+  return capabilities;
+}
+
 // src/client/multi-server.ts
 import { Client as SdkClient, LOG_LEVEL_META_KEY } from "@modelcontextprotocol/client";
 var MultiServerClient = class _MultiServerClient {
@@ -927,6 +949,7 @@ var MultiServerClient = class _MultiServerClient {
   _config;
   _handlers;
   _roots;
+  _capabilities;
   _defaultOptions;
   _versionNegotiation;
   _resourceSubscriptions = /* @__PURE__ */ new Map();
@@ -950,6 +973,11 @@ var MultiServerClient = class _MultiServerClient {
     };
     this._versionNegotiation = options?.versionNegotiation ?? { mode: "auto" };
     this._roots = options?.roots;
+    this._capabilities = buildClientCapabilities(options?.capabilities, {
+      sampling: this._handlers.sampling !== void 0,
+      elicitation: this._handlers.elicitation !== void 0,
+      rootsListChanged: this._roots === void 0 ? void 0 : false
+    });
     this._defaultOptions = options?.defaultOptions ?? {};
   }
   // -------------------------------------------------------------------------
@@ -1361,18 +1389,11 @@ ${errors.map(String).join("\n")}`);
     return new SdkClient(
       { name: "fastmcp-ts", version: "1.0.0" },
       {
-        capabilities: this._buildCapabilities(),
+        capabilities: this._capabilities,
         versionNegotiation: this._versionNegotiation
       }
     );
   }
-  _buildCapabilities() {
-    return {
-      ...this._handlers.sampling ? { sampling: { tools: {} } } : {},
-      ...this._handlers.elicitation ? { elicitation: {} } : {},
-      ...this._roots ? { roots: { listChanged: false } } : {}
-    };
-  }
   _registerHandlers(sdk) {
     sdk.setNotificationHandler("notifications/message", (notification) => {
       void this._handlers.log({
@@ -1459,6 +1480,7 @@ var Client = class _Client {
   _auth;
   _handlers;
   _roots;
+  _capabilities;
   _autoInitialize;
   _versionNegotiation;
   _prior;
@@ -1486,6 +1508,11 @@ var Client = class _Client {
       onPromptsListChanged: options?.handlers?.onPromptsListChanged
     };
     this._roots = options?.roots ? normalizeRootsOption(options.roots) : void 0;
+    this._capabilities = buildClientCapabilities(options?.capabilities, {
+      sampling: this._handlers.sampling !== void 0,
+      elicitation: this._handlers.elicitation !== void 0,
+      rootsListChanged: this._roots === void 0 ? void 0 : true
+    });
     this._autoInitialize = options?.autoInitialize ?? true;
     this._versionNegotiation = options?.versionNegotiation ?? { mode: "auto" };
     this._prior = options?.prior;
@@ -1520,7 +1547,7 @@ var Client = class _Client {
     const sdkClient = new SdkClient2(
       { name: "fastmcp-ts", version: "1.0.0" },
       {
-        capabilities: this._buildCapabilities(),
+        capabilities: this._capabilities,
         listChanged: this._buildListChangedConfig(),
         versionNegotiation: this._versionNegotiation,
         ...this._inputRequired ? { inputRequired: this._inputRequired } : {},
@@ -1992,13 +2019,6 @@ var Client = class _Client {
     }
     return sdkOptions;
   }
-  _buildCapabilities() {
-    return {
-      ...this._handlers.sampling ? { sampling: { tools: {} } } : {},
-      ...this._handlers.elicitation ? { elicitation: {} } : {},
-      ...this._roots ? { roots: { listChanged: true } } : {}
-    };
-  }
   _buildListChangedConfig() {
     const { onToolsListChanged, onResourcesListChanged, onPromptsListChanged } = this._handlers;
     if (!onToolsListChanged && !onResourcesListChanged && !onPromptsListChanged) return void 0;