@mastra/mcp 1.18.1-alpha.2 → 2.0.0-alpha.4

package/dist/server/server.d.ts

@@ -1,51 +1,46 @@
 import type * as http from 'node:http';
-import type { ToolsInput, Agent } from '@mastra/core/agent';
+import type { Agent, ToolsInput } from '@mastra/core/agent';
 import { MCPServerBase } from '@mastra/core/mcp';
-import type { MCPServerConfig, ServerInfo, ServerDetailInfo, MCPServerHonoSSEOptions, MCPServerSSEOptions } from '@mastra/core/mcp';
+import type { MCPServerConfig as CoreMCPServerConfig, MCPToolExecutionResultV2, ServerDetailInfo, ServerInfo } from '@mastra/core/mcp';
 import { RequestContext } from '@mastra/core/request-context';
 import type { InternalCoreTool, MCPToolType } from '@mastra/core/tools';
 import type { Workflow } from '@mastra/core/workflows';
-import type { StreamableHTTPServerTransportOptions } from '@modelcontextprotocol/node';
-import { Server } from '@modelcontextprotocol/server';
-import type { Resource, LoggingLevel, jsonSchemaValidator } from '@modelcontextprotocol/server';
-import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
-import { SSEServerTransport } from '@modelcontextprotocol/server-legacy/sse';
-import type { Context } from '../_types/hono/dist/types/index.js';
-import type { SSEStreamingApi } from '../_types/hono/dist/types/helper/streaming/index.js';
-import { SSETransport } from '../_types/hono-mcp-server-sse-transport/build/index.js';
-import { ServerPromptActions } from './promptActions.js';
-import { ServerResourceActions } from './resourceActions.js';
-import { ServerToolActions } from './toolActions.js';
-import type { MCPServerPrompts, MCPServerResources, ElicitationActions, AppResources, MCPServerProtocolVersion, MCPServerCacheHints } from './types.js';
-type HonoSSEStreamingApi = {
-    readonly closed: boolean;
-    abort(): void;
-    onAbort(listener: () => void | Promise<void>): void;
-    sleep(ms: number): Promise<unknown>;
-    write(input: Uint8Array | string): Promise<unknown>;
-    writeSSE(message: Parameters<SSEStreamingApi['writeSSE']>[0]): Promise<void>;
-};
-type HonoSSEContext = {
-    req: Pick<Context['req'], 'header' | 'json'>;
-    text: Context['text'];
-};
-type HonoSSETransport = Omit<SSETransport, 'handlePostMessage'> & {
-    handlePostMessage(context: HonoSSEContext): Promise<Response>;
-};
-type MCPServerStreamableHTTPOptions = Partial<StreamableHTTPServerTransportOptions> & {
-    serverless?: boolean;
-    /**
-     * Opt into request-scoped SSE streaming for legacy serverless requests.
-     *
-     * The `2026-07-28` handler accepts `true` as a compatibility declaration because
-     * its automatic response mode already streams request-scoped messages when needed.
-     */
-    serverlessStreaming?: boolean;
+import type { Resource, jsonSchemaValidator } from '@modelcontextprotocol/server';
+import { ServerPromptActions, ServerResourceActions, ServerToolActions } from './actions.js';
+import type { AppResources, MCPServerCacheHints, MCPServerHTTPRequestOptions, MCPServerPrompts, MCPServerRequestStateOptions, MCPServerResources } from './types.js';
+export interface MCPServerConfig extends CoreMCPServerConfig {
+    resources?: MCPServerResources;
+    prompts?: MCPServerPrompts;
+    /** MCP Apps (SEP-1865) HTML resources served under `ui://`. */
+    appResources?: AppResources;
+    /** Custom JSON Schema validator, for runtimes where the SDK default is unavailable. */
+    jsonSchemaValidator?: jsonSchemaValidator;
+    cacheHints?: MCPServerCacheHints;
+    /** Integrity protection for `input_required` continuation state. */
+    requestState?: MCPServerRequestStateOptions;
+}
+export interface MCPServerHTTPOptions {
+    url: URL;
+    httpPath: string;
+    req: http.IncomingMessage;
+    res: http.ServerResponse<http.IncomingMessage>;
+    options?: MCPServerHTTPRequestOptions;
+}
+/** Tool description served over Mastra's REST routes; `id` is what Studio keys tools by. */
+type ToolInfo = {
+    id: string;
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    toolType?: MCPToolType;
+    _meta?: Record<string, unknown>;
 };
 /**
- * Exposes Mastra tools, agents, and workflows to Model Context Protocol (MCP) clients.
- * Supports stdio, SSE, and Streamable HTTP transports; start or mount a transport
- * to accept client connections.
+ * Exposes Mastra tools, agents, workflows, resources and prompts to Model Context
+ * Protocol (MCP) clients using protocol revision 2026-07-28: self-contained requests
+ * over Streamable HTTP or stdio, native `input_required` continuation and
+ * per-request logging.
  *
  * @example
  * `yourTool` is a tool you have already configured.
@@ -58,6 +53,7 @@ type MCPServerStreamableHTTPOptions = Partial<StreamableHTTPServerTransportOptio
  *   version: '1.0.0',
  *   tools: { yourTool },
  * });
+ * await server.startStdio();
  * ```
  *
  * @see For documentation bundled with your installed package, locate
@@ -69,789 +65,103 @@ type MCPServerStreamableHTTPOptions = Partial<StreamableHTTPServerTransportOptio
  * if packaged docs are unavailable.
  */
 export declare class MCPServer extends MCPServerBase {
-    private server;
-    private stdioTransport?;
-    private sseTransport?;
-    private sseHonoTransports;
-    /** Auth info for the in-flight Hono SSE message POST, keyed by session id. */
-    private sseHonoAuthInfo;
-    private streamableHTTPTransports;
-    private httpServerInstances;
-    private resourceOptions?;
-    private hasUiResources;
-    private promptOptions?;
-    private jsonSchemaValidator?;
-    private mapAuthInfoToUser?;
-    private fga?;
-    private subscriptionsByInstance;
-    private loggingLevels;
-    private protocolVersion?;
-    private cacheHints?;
-    private modernEraHandler?;
-    private modernEraNodeHandler?;
-    private stdioHandle?;
-    private stdioServerInstance?;
-    /**
-     * Provides methods to notify clients about resource changes.
-     *
-     * @example
-     * ```typescript
-     * // Notify that a specific resource was updated
-     * await server.resources.notifyUpdated({ uri: 'file://data.txt' });
-     *
-     * // Notify that the resource list changed
-     * await server.resources.notifyListChanged();
-     * ```
-     */
+    readonly mcpVersion: 2;
     readonly resources: ServerResourceActions;
-    /**
-     * Provides methods to notify clients about prompt changes.
-     *
-     * @example
-     * ```typescript
-     * // Notify that the prompt list changed
-     * await server.prompts.notifyListChanged();
-     * ```
-     */
     readonly prompts: ServerPromptActions;
-    /**
-     * Provides methods to dynamically manage tools and notify clients about
-     * tool list changes. Named `toolActions` because `tools()` is the tool
-     * registry getter inherited from `MCPServerBase`.
-     *
-     * @example
-     * ```typescript
-     * // Register a new tool at runtime and notify clients
-     * await server.toolActions.add({ myNewTool });
-     *
-     * // Remove a tool and notify clients
-     * await server.toolActions.remove(['myNewTool']);
-     *
-     * // Notify that the tool list changed (e.g. authorization changes)
-     * await server.toolActions.notifyListChanged();
-     * ```
-     */
     readonly toolActions: ServerToolActions;
+    private readonly resourceOptions?;
+    private readonly promptOptions?;
+    private readonly appResourceList;
+    private readonly appResourceHtml;
+    private readonly jsonSchemaValidator?;
+    private readonly cacheHints?;
+    private readonly mapAuthInfoToUser?;
+    private readonly fga?;
+    private readonly requestStateCodec;
+    private httpHandler?;
+    private nodeHandler?;
+    private stdioHandle?;
+    private stdioInstance?;
+    constructor(config: MCPServerConfig);
+    private createRequestStateCodec;
+    convertTools(tools: ToolsInput, agents?: Record<string, Agent>, workflows?: Record<string, Workflow>): Record<string, InternalCoreTool>;
     /**
-     * Provides methods for interactive user input collection during tool execution.
-     *
-     * @example
-     * ```typescript
-     * // Within a tool's execute function
-     * const result = await options.elicitation.sendRequest({
-     *   message: 'Please provide your email address',
-     *   requestedSchema: {
-     *     type: 'object',
-     *     properties: {
-     *       email: { type: 'string', format: 'email' }
-     *     },
-     *     required: ['email']
-     *   }
-     * });
-     * ```
-     */
-    readonly elicitation: ElicitationActions;
-    /**
-     * Gets the stdio transport instance if the server was started using stdio.
-     *
-     * This is primarily for internal checks or testing purposes.
-     *
-     * @returns The stdio transport instance, or undefined if not using stdio transport
-     */
-    getStdioTransport(): StdioServerTransport | undefined;
-    /**
-     * Gets the SSE transport instance if the server was started using SSE.
-     *
-     * This is primarily for internal checks or testing purposes.
-     *
-     * @returns The SSE transport instance, or undefined if not using SSE transport
-     */
-    getSseTransport(): SSEServerTransport | undefined;
-    /**
-     * Gets the Hono SSE transport instance for a specific session.
-     *
-     * This is primarily for internal checks or testing purposes.
-     *
-     * @param sessionId - The session identifier
-     * @returns The Hono SSE transport instance, or undefined if session not found
-     */
-    getSseHonoTransport(sessionId: string): HonoSSETransport | undefined;
-    /**
-     * Gets the underlying MCP Server instance.
-     *
-     * This provides access to the low-level server instance for advanced use cases.
-     *
-     * @returns The Server instance from @modelcontextprotocol/server
-     */
-    getServer(): Server;
-    /**
-     * Creates a new MCPServer instance.
-     *
-     * The server exposes tools, agents, and workflows to MCP clients. Agents are automatically
-     * converted to tools named `ask_<agentKey>`, and workflows become tools named `run_<workflowKey>`.
-     *
-     * @param opts - Configuration options for the server
-     * @param opts.name - Descriptive name for the server (e.g., 'My Weather Server')
-     * @param opts.version - Semantic version of the server (e.g., '1.0.0')
-     * @param opts.tools - Object mapping tool names to tool definitions
-     * @param opts.agents - Optional object mapping agent identifiers to Agent instances
-     * @param opts.workflows - Optional object mapping workflow identifiers to Workflow instances
-     * @param opts.resources - Optional resource configuration for exposing data and content
-     * @param opts.prompts - Optional prompt configuration for exposing reusable templates
-     * @param opts.id - Optional unique identifier (generated if not provided)
-     * @param opts.description - Optional description of what the server does
-     * @param opts.mapAuthInfoToUser - Optional mapper from MCP `extra.authInfo` to the FGA user context
-     *
-     * @example
-     * ```typescript
-     * import { MCPServer } from '@mastra/mcp';
-     * import { Agent } from '@mastra/core/agent';
-     * import { createTool } from '@mastra/core/tools';
-     * import { z } from 'zod';
-     *
-     * const myAgent = new Agent({
-     *   id: 'helper',
-     *   name: 'Helper Agent',
-     *   description: 'A helpful assistant',
-     *   instructions: 'You are helpful.',
-     *   model: 'openai/gpt-4o-mini',
-     * });
-     *
-     * const server = new MCPServer({
-     *   name: 'My Server',
-     *   version: '1.0.0',
-     *   tools: {
-     *     weatherTool: createTool({
-     *       id: 'getWeather',
-     *       description: 'Gets weather',
-     *       inputSchema: z.object({ location: z.string() }),
-     *       execute: async (inputData) => `Sunny in ${inputData.location}`,
-     *     })
-     *   },
-     *   agents: { myAgent },
-     * });
-     * ```
-     */
-    constructor(opts: MCPServerConfig & {
-        resources?: MCPServerResources;
-        prompts?: MCPServerPrompts;
-        /**
-         * Optional MCP App resources configuration.
-         *
-         * Registers `ui://` resources that serve interactive HTML UIs as defined
-         * by the MCP Apps extension (SEP-1865). These are automatically merged
-         * into the resource system and served alongside any user-provided resources.
-         *
-         * @example
-         * ```typescript
-         * const server = new MCPServer({
-         *   name: 'My Server',
-         *   version: '1.0.0',
-         *   tools: { ... },
-         *   appResources: {
-         *     'ui://weather/dashboard': {
-         *       name: 'Weather Dashboard',
-         *       html: '<html>...</html>',
-         *       meta: { csp: { connectDomains: ['https://api.weather.com'] } },
-         *     },
-         *   },
-         * });
-         * ```
-         */
-        appResources?: AppResources;
-        /**
-         * Optional custom JSON Schema validator forwarded to the underlying MCP
-         * server. Use this to opt into a non-default validator implementation.
-         *
-         * Pass `CfWorkerJsonSchemaValidator` (from
-         * `@modelcontextprotocol/server/validators/cf-worker`) when running in
-         * Cloudflare Workers / V8 isolates: the default
-         * `AjvJsonSchemaValidator` compiles validators with `new Function(...)`,
-         * which workerd refuses to evaluate when a registered tool has an
-         * `outputSchema`.
-         *
-         * @example
-         * ```typescript
-         * import { MCPServer } from '@mastra/mcp';
-         * import { CfWorkerJsonSchemaValidator } from '@modelcontextprotocol/server/validators/cf-worker';
-         *
-         * const server = new MCPServer({
-         *   name: 'My Server',
-         *   version: '1.0.0',
-         *   tools: { ... },
-         *   jsonSchemaValidator: new CfWorkerJsonSchemaValidator(),
-         * });
-         * ```
-         */
-        jsonSchemaValidator?: jsonSchemaValidator;
-        /**
-         * Opt-in MCP protocol revision.
-         *
-         * Omitted (or `'2025-11-25'`) keeps today's behavior exactly. Set to
-         * `'2026-07-28'` to serve the stateless MCP revision: HTTP and serverless
-         * requests go through the SDK's dual-era handler (modern clients served
-         * natively, legacy clients via the built-in stateless fallback on the same
-         * endpoint), and stdio serves both eras via the `server/discover` probe.
-         *
-         * @example
-         * ```typescript
-         * const server = new MCPServer({
-         *   name: 'My Server',
-         *   version: '1.0.0',
-         *   tools: { ... },
-         *   protocolVersion: '2026-07-28',
-         * });
-         * ```
-         */
-        protocolVersion?: MCPServerProtocolVersion;
-        /**
-         * Cache hints (`ttlMs` / `cacheScope`) advertised on cacheable results of the
-         * `2026-07-28` protocol revision, keyed by operation (e.g. `'tools/list'`).
-         * Only applied when `protocolVersion: '2026-07-28'` is set; legacy responses
-         * are never affected.
-         *
-         * @example
-         * ```typescript
-         * const server = new MCPServer({
-         *   name: 'My Server',
-         *   version: '1.0.0',
-         *   tools: { ... },
-         *   protocolVersion: '2026-07-28',
-         *   cacheHints: { 'tools/list': { ttlMs: 60_000, cacheScope: 'private' } },
-         * });
-         * ```
-         */
-        cacheHints?: MCPServerCacheHints;
-    });
-    /**
-     * Returns every connected SDK server instance: the main instance (stdio/SSE
-     * transports) plus one instance per streamable HTTP session. Used to
-     * broadcast notifications to all connected clients. Instances without a
-     * connected transport are skipped.
-     *
-     * Note: stateless/serverless requests use transient server instances and
-     * cannot receive notifications.
-     */
-    private getAllSdkServers;
-    /**
-     * Whether the server is pinned to the `2026-07-28` protocol revision.
-     * When false (the default), all behavior is byte-identical to the legacy era.
-     */
-    private servesModernEra;
-    private assertModernEraHTTPOptions;
-    private validateHTTPRequestHeaders;
-    /**
-     * Lazily creates the dual-era HTTP handler used when `protocolVersion: '2026-07-28'`
-     * is set: modern (per-request envelope) clients are served natively and legacy
-     * clients are served through the SDK's built-in stateless fallback, both from the
-     * same endpoint. Each request gets a fresh server instance from
-     * `createServerInstance()`, so all registered handlers apply to both eras.
-     */
-    private getModernEraHandler;
-    /**
-     * Node `(req, res)` adapter over the dual-era handler's web-standard `fetch`.
-     */
-    private getModernEraNodeHandler;
-    /**
-     * Determines whether a log message at the given level should be sent to the
-     * client connected to the given server instance, honoring the minimum level
-     * the client set via `logging/setLevel` (RFC 5424 severity ordering).
-     * When the client never set a level, all messages are sent.
+     * A suspended handler's `resumeSchema` becomes the form the client fills in, and
+     * the protocol only allows a flat object of primitives there. Checked at registration
+     * so a tool cannot suspend into a request no client can answer.
      */
-    private shouldSendLog;
+    private assertFormRepresentable;
     /**
-     * Sends a `notifications/message` log notification to connected clients.
-     *
-     * The notification is broadcast to every active server instance, honoring
-     * the minimum logging level each client set via `logging/setLevel`.
-     *
-     * @param params - Log message parameters
-     * @param params.level - Log severity level
-     * @param params.data - Arbitrary JSON-serializable data to log
-     * @param params.logger - Optional logger name
-     * @throws {MastraError} If sending the notification fails on all eligible server instances
-     *
-     * @example
-     * ```typescript
-     * await server.sendLoggingMessage({
-     *   level: 'info',
-     *   data: { message: 'Sync completed', itemsProcessed: 42 },
-     * });
-     * ```
+     * Input-request forms are a restricted flat-object subset of JSON Schema, so
+     * the dialect declaration is left off the requested schema.
      */
-    sendLoggingMessage(params: {
-        level: LoggingLevel;
-        data: unknown;
-        logger?: string;
-    }): Promise<void>;
+    private formSchema;
     /**
-     * Registers new tools on the running server. Tools are merged into both the
-     * converted tool registry (used by list/call handlers) and the original
-     * tools config so they survive tool re-conversion when the server is
-     * registered with a Mastra instance.
+     * Converts a tool schema to JSON Schema 2020-12, the dialect MCP 2026-07-28
+     * assumes when none is declared. The dialect declaration is kept so validators
+     * that dispatch on `$schema` pick the same draft on both sides.
      */
+    private jsonSchema;
     private addTools;
-    /**
-     * Removes tools from the running server by tool ID.
-     *
-     * @returns The IDs of the tools that were actually removed
-     */
     private removeTools;
-    /**
-     * The key a tool is registered under in the Mastra instance's tool
-     * registry: the tool's intrinsic ID when present (avoids collisions across
-     * MCP servers), falling back to its record key. Mirrors __registerMastra.
-     */
+    /** Mirrors `__registerMastra`: the tool's intrinsic id when it has one, else its key. */
     private mastraToolKey;
-    /**
-     * Handle an elicitation request by sending it to the connected client.
-     * This method sends an elicitation/create request to the client and waits for the response.
-     *
-     * @param request - The elicitation request containing message and schema
-     * @param serverInstance - Optional server instance to use; defaults to main server for backward compatibility
-     * @param options - Optional request options (timeout, signal, etc.)
-     * @returns Promise that resolves to the client's response
-     */
-    private handleElicitationRequest;
-    /**
-     * Reads and parses the JSON body from an HTTP request.
-     * If the request body was already parsed by middleware (e.g., express.json()),
-     * it uses the pre-parsed body from req.body. Otherwise, it reads from the stream.
-     *
-     * This allows the MCP server to work with Express apps that use express.json()
-     * globally without requiring special route exclusions.
-     *
-     * @param req - The incoming HTTP request
-     * @param options - Optional configuration
-     * @param options.preParsedOnly - If true, only return pre-parsed body from middleware,
-     *   returning undefined if not available. This allows the caller to fall back to
-     *   their own body reading logic (e.g., SDK's getRawBody with size limits).
-     */
-    private readJsonBody;
-    /**
-     * Merges appResources into the resource system alongside any user-provided resources.
-     *
-     * App resources are auto-registered as `ui://` resources with the MCP Apps MIME type.
-     * If the user also provides a `resources` config, the two are merged — user callbacks
-     * take precedence for overlapping URIs.
-     */
-    private mergeAppResources;
-    /**
-     * Creates a new Server instance configured with all handlers for HTTP sessions.
-     * Each HTTP client connection gets its own Server instance to avoid routing conflicts.
-     */
+    /** Schema-less tools advertise an open empty object rather than the default validator schema. */
+    private hasInputSchema;
+    private resumeSchemaOf;
+    /**
+     * Prefers the tool's own schema over the converted core tool's, which has
+     * already been lowered to draft-07, so 2020-12 shapes survive advertisement.
+     */
+    private advertisedSchema;
+    private toolInfo;
+    /** Builds the wire tool description, validated against the spec schema. */
+    private toMCPTool;
+    private hasUiMetadata;
+    private capabilities;
     private createServerInstance;
-    /**
-     * Registers all MCP handlers on a given server instance.
-     * This allows us to create multiple server instances with identical functionality.
-     */
-    private registerHandlersOnServer;
-    /**
-     * Registers resource-related handlers on a server instance.
-     */
-    private registerResourceHandlersOnServer;
-    /**
-     * Registers prompt-related handlers on a server instance.
-     */
-    private registerPromptHandlersOnServer;
-    private convertAgentsToTools;
-    private convertWorkflowsToTools;
-    /**
-     * Convert and validate all provided tools, logging registration status.
-     * Also converts agents and workflows into tools.
-     * @param tools Tool definitions
-     * @param agentsConfig Agent definitions to be converted to tools, expected from MCPServerConfig
-     * @param workflowsConfig Workflow definitions to be converted to tools, expected from MCPServerConfig
-     * @returns Converted tools registry
-     */
-    convertTools(tools: ToolsInput, agentsConfig?: Record<string, Agent>, workflowsConfig?: Record<string, Workflow>): Record<string, InternalCoreTool>;
-    /**
-     * Starts the MCP server using standard input/output (stdio) transport.
-     *
-     * This is typically used when running the server as a command-line program that MCP clients
-     * spawn as a subprocess (e.g., integration with Windsurf, Cursor, or Claude Desktop).
-     *
-     * @throws {MastraError} If the stdio connection fails
-     *
-     * @example
-     * ```typescript
-     * const server = new MCPServer({
-     *   name: 'My Server',
-     *   version: '1.0.0',
-     *   tools: { weatherTool },
-     * });
-     *
-     * await server.startStdio();
-     * ```
-     */
+    /** Answers a suspended round: one keyed form derived from the handler's `resumeSchema`. */
+    private inputRequired;
+    private serverRequest;
+    private registerToolHandlers;
+    /**
+     * Runs one round of a tool. The tool sees the same `suspend` / `resumeData` /
+     * `suspendPayload` vocabulary as under an agent or workflow; nothing else is
+     * carried between rounds.
+     */
+    private runTool;
+    private toCallToolResult;
+    private registerResourceHandlers;
+    private resourceContents;
+    private registerPromptHandlers;
+    private loadAppResources;
+    private enforceToolExecutionFGA;
+    private authorizedToolEntries;
+    private notifier;
+    private getNodeHandler;
+    /** Serves the current process's stdio. Legacy openings are rejected. */
     startStdio(): Promise<void>;
     /**
-     * Integrates the MCP server with an existing HTTP server using Server-Sent Events (SSE).
-     *
-     * Call this method from your web server's request handler for both the SSE and message paths.
-     * This enables web-based MCP clients to connect to your server.
-     *
-     * @param options - Configuration for SSE integration
-     * @param options.url - Parsed URL of the incoming request
-     * @param options.ssePath - Path for establishing SSE connection (e.g., '/sse')
-     * @param options.messagePath - Path for POSTing client messages (e.g., '/message')
-     * @param options.req - Incoming HTTP request object
-     * @param options.res - HTTP response object (must support .write/.end)
-     *
-     * @throws {MastraError} If SSE connection setup fails
-     *
-     * @example
-     * ```typescript
-     * import http from 'node:http';
-     *
-     * const httpServer = http.createServer(async (req, res) => {
-     *   await server.startSSE({
-     *     url: new URL(req.url || '', `http://localhost:1234`),
-     *     ssePath: '/sse',
-     *     messagePath: '/message',
-     *     req,
-     *     res,
-     *   });
-     * });
-     *
-     * httpServer.listen(1234, () => {
-     *   console.log('MCP server listening on http://localhost:1234/sse');
-     * });
-     * ```
-     */
-    startSSE({ url, ssePath, messagePath, req, res }: MCPServerSSEOptions): Promise<void>;
-    /**
-     * Integrates the MCP server with a Hono web framework using Server-Sent Events (SSE).
-     *
-     * Call this method from your Hono server's request handler for both the SSE and message paths.
-     * This enables Hono-based web applications to expose MCP servers.
-     *
-     * @param options - Configuration for Hono SSE integration
-     * @param options.url - Parsed URL of the incoming request
-     * @param options.ssePath - Path for establishing SSE connection (e.g., '/hono-sse')
-     * @param options.messagePath - Path for POSTing client messages (e.g., '/message')
-     * @param options.context - Hono context object
-     *
-     * @throws {MastraError} If Hono SSE connection setup fails
-     *
-     * @example
-     * ```typescript
-     * import { Hono } from 'hono';
-     *
-     * const app = new Hono();
-     *
-     * app.all('*', async (c) => {
-     *   const url = new URL(c.req.url);
-     *   return await server.startHonoSSE({
-     *     url,
-     *     ssePath: '/hono-sse',
-     *     messagePath: '/message',
-     *     context: c,
-     *   });
-     * });
-     *
-     * export default app;
-     * ```
-     */
-    startHonoSSE({ url, ssePath, messagePath, context, authInfo }: MCPServerHonoSSEOptions): Promise<Response>;
-    /**
-     * Integrates the MCP server with an existing HTTP server using streamable HTTP transport.
-     *
-     * This is the recommended modern transport method, providing better session management and
-     * reliability compared to SSE. Call this from your HTTP server's request handler.
-     *
-     * @param options - Configuration for HTTP integration
-     * @param options.url - Parsed URL of the incoming request
-     * @param options.httpPath - Path for the MCP endpoint (e.g., '/mcp')
-     * @param options.req - Incoming HTTP request (http.IncomingMessage)
-     * @param options.res - HTTP response object (http.ServerResponse)
-     * @param options.options - Optional transport options
-     * @param options.options.sessionIdGenerator - Function to generate unique session IDs (defaults to randomUUID)
-     * @param options.options.onsessioninitialized - Callback when a new session is initialized
-     * @param options.options.enableJsonResponse - If true, return JSON instead of SSE streaming
-     * @param options.options.eventStore - Event store for message resumability
-     * @param options.options.serverless - If true, run in stateless mode without session management (ideal for serverless environments)
-     *
-     * @throws {MastraError} If HTTP connection setup fails
-     *
-     * @example
-     * ```typescript
-     * import http from 'node:http';
-     * import { randomUUID } from 'node:crypto';
-     *
-     * const httpServer = http.createServer(async (req, res) => {
-     *   await server.startHTTP({
-     *     url: new URL(req.url || '', 'http://localhost:1234'),
-     *     httpPath: '/mcp',
-     *     req,
-     *     res,
-     *     options: {
-     *       sessionIdGenerator: () => randomUUID(),
-     *       onsessioninitialized: (sessionId) => {
-     *         console.log(`New MCP session: ${sessionId}`);
-     *       },
-     *     },
-     *   });
-     * });
-     *
-     * httpServer.listen(1234);
-     * ```
-     *
-     * @example Serverless mode (Cloudflare Workers, Vercel Edge, etc.)
-     * ```typescript
-     * export default {
-     *   async fetch(request: Request) {
-     *     const url = new URL(request.url);
-     *     if (url.pathname === '/mcp') {
-     *       await server.startHTTP({
-     *         url,
-     *         httpPath: '/mcp',
-     *         req: request,
-     *         res: response,
-     *         options: { serverless: true },
-     *       });
-     *     }
-     *     return new Response('Not found', { status: 404 });
-     *   },
-     * };
-     * ```
-     */
-    startHTTP({ url, httpPath, req, res, options, }: {
-        url: URL;
-        httpPath: string;
-        req: http.IncomingMessage;
-        res: http.ServerResponse<http.IncomingMessage>;
-        /**
-         * Streamable HTTP transport options for the legacy protocol path.
-         *
-         * With `protocolVersion: '2026-07-28'`, stateless declarations and DNS rebinding
-         * protection remain supported. Session and response-mode options are rejected
-         * because they cannot configure the shared modern-era handler per request.
-         */
-        options?: MCPServerStreamableHTTPOptions;
-    }): Promise<void>;
-    /**
-     * Handles a stateless, serverless HTTP request without session management.
-     *
-     * This method bypasses all session/transport state and handles each request independently.
-     * For serverless environments (Cloudflare Workers, Vercel Edge, etc.) where
-     * persistent connections and session state cannot be maintained across requests.
-     *
-     * Each request gets a fresh transport and server instance that are discarded after the response.
-     *
-     * @param req - Incoming HTTP request
-     * @param res - HTTP response object
-     * @param options - Transport options for this request
-     * @param options.enableJsonResponse - When `true` (default), buffers and returns a single
-     *   JSON-RPC response. When `false`, the request is handled with request-scoped SSE streaming,
-     *   so in-request `notifications/progress` reach the client before the final result.
-     * @private
-     */
-    private handleServerlessRequest;
-    /**
-     * Establishes the SSE connection for the MCP server.
-     *
-     * This is a lower-level method called internally by `startSSE()`. In most cases,
-     * you should use `startSSE()` instead which handles both connection establishment
-     * and message routing.
-     *
-     * @param params - Connection parameters
-     * @param params.messagePath - Path for POST requests from the client
-     * @param params.res - HTTP response object for the SSE stream
-     * @throws {MastraError} If SSE connection establishment fails
-     *
-     * @example
-     * ```typescript
-     * // Usually called internally by startSSE()
-     * await server.connectSSE({
-     *   messagePath: '/message',
-     *   res: response
-     * });
-     * ```
-     */
-    connectSSE({ messagePath, res, }: {
-        messagePath: string;
-        res: http.ServerResponse<http.IncomingMessage>;
-    }): Promise<void>;
-    /**
-     * Establishes the Hono SSE connection for the MCP server.
-     *
-     * This is a lower-level method called internally by `startHonoSSE()`. In most cases,
-     * you should use `startHonoSSE()` instead which handles both connection establishment
-     * and message routing.
-     *
-     * @param params - Connection parameters
-     * @param params.messagePath - Path for POST requests from the client
-     * @param params.stream - Hono SSE streaming API object
-     * @throws {MastraError} If Hono SSE connection establishment fails
-     *
-     * @example
-     * ```typescript
-     * // Usually called internally by startHonoSSE()
-     * await server.connectHonoSSE({
-     *   messagePath: '/message',
-     *   stream: sseStream
-     * });
-     * ```
-     */
-    connectHonoSSE({ messagePath, stream }: {
-        messagePath: string;
-        stream: HonoSSEStreamingApi;
-    }): Promise<void>;
-    /**
-     * Closes the MCP server and releases all resources.
-     *
-     * This method cleanly shuts down all active transports (stdio, SSE, HTTP) and their
-     * associated connections. Call this when your application is shutting down.
-     *
-     * @throws {MastraError} If closing the server fails
-     *
-     * @example
-     * ```typescript
-     * // Graceful shutdown
-     * process.on('SIGTERM', async () => {
-     *   await server.close();
-     *   process.exit(0);
-     * });
-     * ```
+     * Handles one Streamable HTTP request at `httpPath`. Every request is
+     * self-contained; requests without a 2026-07-28 envelope are rejected.
      */
+    startHTTP({ url, httpPath, req, res, options }: MCPServerHTTPOptions): Promise<void>;
     close(): Promise<void>;
-    /**
-     * Gets basic information about the server.
-     *
-     * Returns metadata including server ID, name, description, repository, and version details.
-     * This information conforms to the MCP Server schema.
-     *
-     * @returns Server information object
-     *
-     * @example
-     * ```typescript
-     * const info = server.getServerInfo();
-     * console.log(`${info.name} v${info.version_detail.version}`);
-     * // Output: My Weather Server v1.0.0
-     * ```
-     */
     getServerInfo(): ServerInfo;
-    /**
-     * Gets detailed information about the server including packaging and deployment metadata.
-     *
-     * Returns extended server information with package details, remotes, and deployment configurations.
-     * This information conforms to the MCP ServerDetail schema.
-     *
-     * @returns Detailed server information object
-     *
-     * @example
-     * ```typescript
-     * const detail = server.getServerDetail();
-     * console.log(detail.package_canonical); // 'npm'
-     * console.log(detail.packages); // Package installation info
-     * ```
-     */
     getServerDetail(): ServerDetailInfo;
-    private convertSchema;
-    private convertInputSchema;
-    /**
-     * Gets a list of all tools provided by this MCP server with their schemas.
-     *
-     * Returns information about all registered tools including explicit tools, agent-derived tools,
-     * and workflow-derived tools. Includes input/output schemas and tool types.
-     *
-     * @returns Object containing array of tool information
-     *
-     * @example
-     * ```typescript
-     * const toolList = server.getToolListInfo();
-     * toolList.tools.forEach(tool => {
-     *   console.log(`${tool.name}: ${tool.description}`);
-     *   console.log(`Type: ${tool.toolType || 'tool'}`);
-     * });
-     * ```
-     */
     getToolListInfo(requestContext?: RequestContext): {
-        tools: Array<{
-            name: string;
-            description?: string;
-            inputSchema: any;
-            outputSchema?: any;
-            toolType?: MCPToolType;
-            _meta?: Record<string, unknown>;
-        }>;
+        tools: ToolInfo[];
     } | Promise<{
-        tools: Array<{
-            name: string;
-            description?: string;
-            inputSchema: any;
-            outputSchema?: any;
-            toolType?: MCPToolType;
-            _meta?: Record<string, unknown>;
-        }>;
+        tools: ToolInfo[];
     }>;
+    getToolInfo(toolId: string): ToolInfo | undefined;
     /**
-     * Gets information for a specific tool provided by this MCP server.
-     *
-     * Returns detailed information about a single tool including its name, description, schemas, and type.
-     * Returns undefined if the tool is not found.
-     *
-     * @param toolId - The ID/name of the tool to retrieve
-     * @returns Tool information object or undefined if not found
-     *
-     * @example
-     * ```typescript
-     * const toolInfo = server.getToolInfo('getWeather');
-     * if (toolInfo) {
-     *   console.log(toolInfo.description);
-     *   console.log(toolInfo.inputSchema);
-     * }
-     * ```
-     */
-    getToolInfo(toolId: string): {
-        name: string;
-        description?: string;
-        inputSchema: any;
-        outputSchema?: any;
-        toolType?: MCPToolType;
-        _meta?: Record<string, unknown>;
-    } | undefined;
-    private createProxiedRequestContext;
-    private resolveMappedFGAUser;
-    private getAuthorizedConvertedToolEntries;
-    private enforceToolExecutionFGA;
-    private resolveToolFGAParams;
-    /**
-     * Executes a specific tool provided by this MCP server.
-     *
-     * This method validates the tool arguments against the input schema and executes the tool.
-     * If validation fails, returns an error object instead of throwing.
-     *
-     * @param toolId - The ID/name of the tool to execute
-     * @param args - The arguments to pass to the tool's execute function
-     * @param executionContext - Optional context including messages and toolCallId
-     * @returns Promise resolving to the tool execution result
-     * @throws {MastraError} If the tool is not found or execution fails
-     *
-     * @example
-     * ```typescript
-     * const result = await server.executeTool(
-     *   'getWeather',
-     *   { location: 'London' },
-     *   { toolCallId: 'call_123' }
-     * );
-     * console.log(result);
-     * ```
-     */
-    executeTool(toolId: string, args: any, executionContext?: {
-        messages?: any[];
-        toolCallId?: string;
-        requestContext?: RequestContext;
-    }): Promise<any>;
-    /**
-     * Reads the content of a resource by URI.
-     *
-     * Used by the Studio API to proxy `ui://` resource reads for MCP Apps rendering.
-     *
-     * @param uri - The resource URI to read (e.g. `ui://weather/dashboard`)
-     * @returns Promise resolving to the resource content
+     * Runs a tool without a protocol client (the Studio/REST route). A tool that
+     * suspends is reported as such; the caller continues by sending the same
+     * arguments with `resumeData` and `suspendPayload`.
      */
+    executeTool(toolId: string, args: unknown, executionContext?: Parameters<MCPServerBase['executeTool']>[2]): Promise<MCPToolExecutionResultV2>;
+    /** Reads an `ui://` app resource; application resources require a protocol request. */
     readResource(uri: string): Promise<{
         contents: Array<{
             uri: string;
@@ -859,16 +169,10 @@ export declare class MCPServer extends MCPServerBase {
             blob?: string;
         }>;
     }>;
-    /**
-     * Lists all resources available on this MCP server.
-     *
-     * Used by the Studio API to discover `ui://` resources for MCP Apps.
-     *
-     * @returns Promise resolving to the list of resources
-     */
+    /** Lists `ui://` app resources; application resources require a protocol request. */
     listResources(): Promise<{
         resources: Resource[];
     }>;
 }
-export {};
+export { ServerPromptActions, ServerResourceActions, ServerToolActions };
 //# sourceMappingURL=server.d.ts.map