@mastra/server 1.79.0-alpha.10 → 1.79.0-alpha.12

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

@@ -5,6 +5,7 @@ import type { SetMcpRequestAuth } from '../server-adapter/mcp-auth.js';
 export interface MCPServerInfoResponse extends ServerInfo {
     /** Endpoints served under `/mcp/:serverId`; 2026-07-28 servers speak Streamable HTTP only. */
     transports: MCPServerTransport[];
+    events_capability?: boolean;
 }
 export declare const LIST_MCP_SERVERS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "createHandler" | "handler" | "method" | "openapi" | "path"> & {
     method: "GET";
@@ -27,6 +28,7 @@ export declare const LIST_MCP_SERVERS_ROUTE: Omit<import("@mastra/core/server").
                 is_latest: boolean;
             };
             transports?: ("sse" | "streamable-http")[] | undefined;
+            events_capability?: boolean | undefined;
         }[];
         total_count: number;
         next: string | null;
@@ -59,6 +61,7 @@ export declare const LIST_MCP_SERVERS_ROUTE: Omit<import("@mastra/core/server").
                 sse: "sse";
                 "streamable-http": "streamable-http";
             }>>>;
+            events_capability: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, import("zod/v4/core").$strip>>;
         total_count: import("zod").ZodNumber;
         next: import("zod").ZodNullable<import("zod").ZodString>;
@@ -89,6 +92,7 @@ export declare const GET_MCP_SERVER_DETAIL_ROUTE: Omit<import("@mastra/core/serv
         packages?: unknown[] | undefined;
         remotes?: unknown[] | undefined;
         transports?: ("sse" | "streamable-http")[] | undefined;
+        events_capability?: boolean | undefined;
     }>;
     pathParamSchema?: import("zod").ZodSchema;
     queryParamSchema?: import("zod").ZodSchema;
@@ -120,6 +124,7 @@ export declare const GET_MCP_SERVER_DETAIL_ROUTE: Omit<import("@mastra/core/serv
             sse: "sse";
             "streamable-http": "streamable-http";
         }>>>;
+        events_capability: import("zod").ZodOptional<import("zod").ZodBoolean>;
     }, import("zod/v4/core").$strip>> | undefined;
 } & {
     readonly _mastraSchemaRoute: true;
@@ -345,6 +350,220 @@ export declare const READ_MCP_SERVER_RESOURCE_ROUTE: Omit<import("@mastra/core/s
 } & {
     readonly _mastraSchemaRoute: true;
 };
+export declare const LIST_MCP_SERVER_EVENTS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "createHandler" | "handler" | "method" | "openapi" | "path"> & {
+    method: "GET";
+    path: "/mcp/:serverId/events";
+    responseType: "json";
+    streamFormat?: 'sse' | 'stream';
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        serverId: string;
+    } & ServerContext): Promise<{
+        events: {
+            name: string;
+            description?: string | undefined;
+            delivery: ("poll" | "push" | "webhook")[];
+            inputSchema?: Record<string, unknown> | undefined;
+            payloadSchema?: Record<string, unknown> | undefined;
+            emittable: boolean;
+        }[];
+        testEmit: boolean;
+    }>;
+    pathParamSchema?: import("zod").ZodSchema;
+    queryParamSchema?: import("zod").ZodSchema;
+    bodySchema?: import("zod").ZodSchema;
+    responseSchema?: import("zod").ZodSchema;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<import("zod").ZodObject<{
+        serverId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
+        events: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            delivery: import("zod").ZodArray<import("zod").ZodEnum<{
+                poll: "poll";
+                push: "push";
+                webhook: "webhook";
+            }>>;
+            inputSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            payloadSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            emittable: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>>;
+        testEmit: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const POLL_MCP_SERVER_EVENT_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "createHandler" | "handler" | "method" | "openapi" | "path"> & {
+    method: "POST";
+    path: "/mcp/:serverId/events/:eventName/poll";
+    responseType: "json";
+    streamFormat?: 'sse' | 'stream';
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        serverId: string;
+        eventName: string;
+    } & {
+        arguments?: Record<string, unknown> | undefined;
+        cursor?: string | null | undefined;
+        maxEvents?: number | undefined;
+    } & ServerContext): Promise<{
+        events: {
+            eventId: string;
+            name: string;
+            timestamp: string;
+            data: Record<string, unknown>;
+            cursor?: string | null | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        }[];
+        cursor: string | null;
+        hasMore?: boolean | undefined;
+        truncated?: boolean | undefined;
+        nextPollMs?: number | undefined;
+    }>;
+    pathParamSchema?: import("zod").ZodSchema;
+    queryParamSchema?: import("zod").ZodSchema;
+    bodySchema?: import("zod").ZodSchema;
+    responseSchema?: import("zod").ZodSchema;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<import("zod").ZodObject<{
+        serverId: import("zod").ZodString;
+        eventName: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+        arguments: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        cursor: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        maxEvents: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        events: import("zod").ZodArray<import("zod").ZodObject<{
+            eventId: import("zod").ZodString;
+            name: import("zod").ZodString;
+            timestamp: import("zod").ZodString;
+            data: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            cursor: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            _meta: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, import("zod/v4/core").$strip>>;
+        cursor: import("zod").ZodNullable<import("zod").ZodString>;
+        hasMore: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        nextPollMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const STREAM_MCP_SERVER_EVENT_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "createHandler" | "handler" | "method" | "openapi" | "path"> & {
+    method: "POST";
+    path: "/mcp/:serverId/events/:eventName/stream";
+    responseType: "stream";
+    streamFormat?: 'sse' | 'stream';
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        serverId: string;
+        eventName: string;
+    } & {
+        arguments?: Record<string, unknown> | undefined;
+        cursor?: string | null | undefined;
+    } & ServerContext): Promise<import("../server-adapter/routes/stream-types").MastraStreamReturn>;
+    pathParamSchema?: import("zod").ZodSchema;
+    queryParamSchema?: import("zod").ZodSchema;
+    bodySchema?: import("zod").ZodSchema;
+    responseSchema?: import("zod").ZodSchema;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<import("zod").ZodObject<{
+        serverId: import("zod").ZodString;
+        eventName: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+        arguments: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        cursor: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+        cursor: import("zod").ZodNullable<import("zod").ZodString>;
+        truncated: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"event">;
+        occurrence: import("zod").ZodObject<{
+            eventId: import("zod").ZodString;
+            name: import("zod").ZodString;
+            timestamp: import("zod").ZodString;
+            data: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            cursor: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            _meta: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"heartbeat">;
+        cursor: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"error">;
+        message: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"terminated">;
+    }, import("zod/v4/core").$strip>], "type">> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const EMIT_MCP_SERVER_EVENT_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "createHandler" | "handler" | "method" | "openapi" | "path"> & {
+    method: "POST";
+    path: "/mcp/:serverId/events/:eventName/emit";
+    responseType: "json";
+    streamFormat?: 'sse' | 'stream';
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        serverId: string;
+        eventName: string;
+    } & {
+        data: Record<string, unknown>;
+    } & ServerContext): Promise<{
+        occurrence: {
+            eventId: string;
+            name: string;
+            timestamp: string;
+            data: Record<string, unknown>;
+            cursor?: string | null | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        };
+    }>;
+    pathParamSchema?: import("zod").ZodSchema;
+    queryParamSchema?: import("zod").ZodSchema;
+    bodySchema?: import("zod").ZodSchema;
+    responseSchema?: import("zod").ZodSchema;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<import("zod").ZodObject<{
+        serverId: import("zod").ZodString;
+        eventName: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+        data: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        occurrence: import("zod").ZodObject<{
+            eventId: import("zod").ZodString;
+            name: import("zod").ZodString;
+            timestamp: import("zod").ZodString;
+            data: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            cursor: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            _meta: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
 /**
  * MCP transport options that can be passed to startHTTP() or startSSE().
  * Includes serverless mode for running in stateless environments like Cloudflare Workers or Vercel Edge.

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

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/mcp.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,IAAI,6BAA6B,EAE9C,UAAU,EACX,MAAM,kBAAkB,CAAC;AAmB1B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAepE,MAAM,WAAW,qBAAsB,SAAQ,UAAU;IACvD,8FAA8F;IAC9F,UAAU,EAAE,kBAAkB,EAAE,CAAC;CAClC;AAMD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFjC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCtC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BtC,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgC3C,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkExC,CAAC;AAMH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B1C,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCzC,CAAC;AAMH;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,MAAM,CAAC;IAClC;;;OAGG;IACH,cAAc,CAAC,EAAE,iBAAiB,CAAC;CACpC;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,6BAA6B,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,UAAU,CAAC,EAAE,mBAAmB,CAAC;CAClC;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,4FAA4F;IAC5F,MAAM,EAAE,6BAA6B,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;CAyBnC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;CA8BlC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CAUjC,CAAC"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/mcp.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,aAAa,IAAI,6BAA6B,EAI9C,UAAU,EACX,MAAM,kBAAkB,CAAC;AA2B1B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAepE,MAAM,WAAW,qBAAsB,SAAQ,UAAU;IACvD,8FAA8F;IAC9F,UAAU,EAAE,kBAAkB,EAAE,CAAC;IACjC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAMD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiFjC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCtC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BtC,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgC3C,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkExC,CAAC;AAMH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B1C,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCzC,CAAC;AAkEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAevC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCtC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuFxC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BtC,CAAC;AAMH;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,MAAM,CAAC;IAClC;;;OAGG;IACH,cAAc,CAAC,EAAE,iBAAiB,CAAC;CACpC;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,6BAA6B,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,UAAU,CAAC,EAAE,mBAAmB,CAAC;CAClC;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,4FAA4F;IAC5F,MAAM,EAAE,6BAA6B,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;CAyBnC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;CA8BlC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CAUjC,CAAC"}

package/dist/server/handlers/mcp.js

@@ -1,274 +1 @@
-import { r as __exportAll } from "../../rolldown-runtime-maW3aOIk.js";
-import { t as HTTPException } from "../../http-exception-CyfxZB6W.js";
-import { n as createRoute } from "../../route-builder-BfQYtclb.js";
-import { a as listMcpServerToolsResponseSchema, c as listResourcesResponseSchema, d as mcpServerResourcePathParams, f as mcpServerToolPathParams, g as serverDetailSchema, h as readResourceResponseSchema, l as mcpServerDetailPathParams, m as readResourceBodySchema, n as executeToolResponseSchema, o as listMcpServersQuerySchema, p as mcpToolInfoSchema, r as getMcpServerDetailQuerySchema, s as listMcpServersResponseSchema, t as executeToolBodySchema, u as mcpServerIdPathParams } from "../../mcp-DzpwLXEY.js";
-import { MastraError } from "@mastra/core/error";
-//#region src/server/handlers/mcp.ts
-var mcp_exports = /* @__PURE__ */ __exportAll({
-	EXECUTE_MCP_SERVER_TOOL_ROUTE: () => EXECUTE_MCP_SERVER_TOOL_ROUTE,
-	GET_MCP_SERVER_DETAIL_ROUTE: () => GET_MCP_SERVER_DETAIL_ROUTE,
-	GET_MCP_SERVER_TOOL_DETAIL_ROUTE: () => GET_MCP_SERVER_TOOL_DETAIL_ROUTE,
-	LIST_MCP_SERVERS_ROUTE: () => LIST_MCP_SERVERS_ROUTE,
-	LIST_MCP_SERVER_RESOURCES_ROUTE: () => LIST_MCP_SERVER_RESOURCES_ROUTE,
-	LIST_MCP_SERVER_TOOLS_ROUTE: () => LIST_MCP_SERVER_TOOLS_ROUTE,
-	MCP_HTTP_TRANSPORT_ROUTE: () => MCP_HTTP_TRANSPORT_ROUTE,
-	MCP_SSE_MESSAGES_ROUTE: () => MCP_SSE_MESSAGES_ROUTE,
-	MCP_SSE_TRANSPORT_ROUTE: () => MCP_SSE_TRANSPORT_ROUTE,
-	READ_MCP_SERVER_RESOURCE_ROUTE: () => READ_MCP_SERVER_RESOURCE_ROUTE
-});
-/**
-* Only `@mastra/mcp` 1.x servers implement the standalone HTTP+SSE transport; on a
-* 2026-07-28 server the inherited `startSSE`/`startHonoSSE` throw.
-*/
-function hasSSETransport(server) {
-	return server.mcpVersion !== 2;
-}
-function transportsOf(server) {
-	return hasSSETransport(server) ? ["streamable-http", "sse"] : ["streamable-http"];
-}
-const LIST_MCP_SERVERS_ROUTE = createRoute({
-	method: "GET",
-	path: "/mcp/v0/servers",
-	responseType: "json",
-	queryParamSchema: listMcpServersQuerySchema,
-	responseSchema: listMcpServersResponseSchema,
-	summary: "List MCP servers",
-	description: "Returns a list of registered MCP servers with pagination support",
-	tags: ["MCP"],
-	requiresAuth: true,
-	handler: async ({ mastra, routePrefix, page, perPage, limit, offset }) => {
-		if (!mastra || typeof mastra.listMCPServers !== "function") throw new HTTPException(500, { message: "Mastra instance or listMCPServers method not available" });
-		const servers = mastra.listMCPServers();
-		if (!servers) return {
-			servers: [],
-			total_count: 0,
-			next: null
-		};
-		const serverList = Object.values(servers);
-		const totalCount = serverList.length;
-		const useLegacyFormat = (limit !== void 0 || offset !== void 0) && page === void 0 && perPage === void 0;
-		const finalPerPage = perPage ?? limit;
-		let finalPage = page;
-		if (finalPage === void 0 && offset !== void 0 && finalPerPage !== void 0 && finalPerPage > 0) finalPage = Math.floor(offset / finalPerPage);
-		const actualOffset = finalPage !== void 0 && finalPerPage !== void 0 ? finalPage * finalPerPage : 0;
-		let paginatedServers = serverList;
-		let nextUrl = null;
-		if (finalPerPage !== void 0) {
-			paginatedServers = serverList.slice(actualOffset, actualOffset + finalPerPage);
-			if (actualOffset + finalPerPage < totalCount) {
-				const nextPage = (finalPage ?? 0) + 1;
-				const prefix = routePrefix ?? "";
-				if (useLegacyFormat) nextUrl = `${prefix}/mcp/v0/servers?limit=${finalPerPage}&offset=${actualOffset + finalPerPage}`;
-				else nextUrl = `${prefix}/mcp/v0/servers?perPage=${finalPerPage}&page=${nextPage}`;
-			}
-		}
-		return {
-			servers: paginatedServers.map((server) => ({
-				...server.getServerInfo(),
-				transports: transportsOf(server)
-			})),
-			total_count: totalCount,
-			next: nextUrl
-		};
-	}
-});
-const GET_MCP_SERVER_DETAIL_ROUTE = createRoute({
-	method: "GET",
-	path: "/mcp/v0/servers/:id",
-	responseType: "json",
-	pathParamSchema: mcpServerDetailPathParams,
-	queryParamSchema: getMcpServerDetailQuerySchema,
-	responseSchema: serverDetailSchema,
-	summary: "Get MCP server details",
-	description: "Returns detailed information about a specific MCP server",
-	tags: ["MCP"],
-	requiresAuth: true,
-	handler: async ({ mastra, id, version }) => {
-		if (!mastra || typeof mastra.getMCPServerById !== "function") throw new HTTPException(500, { message: "Mastra instance or getMCPServerById method not available" });
-		const server = mastra.getMCPServerById(id);
-		if (!server) throw new HTTPException(404, { message: `MCP server with ID '${id}' not found` });
-		const serverDetail = {
-			...server.getServerDetail(),
-			transports: transportsOf(server)
-		};
-		if (version && serverDetail.version_detail.version !== version) throw new HTTPException(404, { message: `MCP server with ID '${id}' found, but not version '${version}'. Available version: ${serverDetail.version_detail.version}` });
-		return serverDetail;
-	}
-});
-const LIST_MCP_SERVER_TOOLS_ROUTE = createRoute({
-	method: "GET",
-	path: "/mcp/:serverId/tools",
-	responseType: "json",
-	pathParamSchema: mcpServerIdPathParams,
-	responseSchema: listMcpServerToolsResponseSchema,
-	summary: "List MCP server tools",
-	description: "Returns a list of tools available on the specified MCP server",
-	tags: ["MCP"],
-	requiresAuth: true,
-	handler: async ({ mastra, serverId, requestContext }) => {
-		if (!mastra || typeof mastra.getMCPServerById !== "function") throw new HTTPException(500, { message: "Mastra instance or getMCPServerById method not available" });
-		const server = mastra.getMCPServerById(serverId);
-		if (!server) throw new HTTPException(404, { message: `MCP server with ID '${serverId}' not found` });
-		if (typeof server.getToolListInfo !== "function") throw new HTTPException(501, { message: `Server '${serverId}' cannot list tools in this way.` });
-		return await server.getToolListInfo(requestContext);
-	}
-});
-const GET_MCP_SERVER_TOOL_DETAIL_ROUTE = createRoute({
-	method: "GET",
-	path: "/mcp/:serverId/tools/:toolId",
-	responseType: "json",
-	pathParamSchema: mcpServerToolPathParams,
-	responseSchema: mcpToolInfoSchema,
-	summary: "Get MCP server tool details",
-	description: "Returns detailed information about a specific tool on the MCP server",
-	tags: ["MCP"],
-	requiresAuth: true,
-	handler: async ({ mastra, serverId, toolId }) => {
-		if (!mastra || typeof mastra.getMCPServerById !== "function") throw new HTTPException(500, { message: "Mastra instance or getMCPServerById method not available" });
-		const server = mastra.getMCPServerById(serverId);
-		if (!server) throw new HTTPException(404, { message: `MCP server with ID '${serverId}' not found` });
-		if (typeof server.getToolInfo !== "function") throw new HTTPException(501, { message: `Server '${serverId}' cannot provide tool details in this way.` });
-		const toolInfo = await server.getToolInfo(toolId);
-		if (!toolInfo) throw new HTTPException(404, { message: `Tool with ID '${toolId}' not found on MCP server '${serverId}'` });
-		return toolInfo;
-	}
-});
-const EXECUTE_MCP_SERVER_TOOL_ROUTE = createRoute({
-	method: "POST",
-	path: "/mcp/:serverId/tools/:toolId/execute",
-	responseType: "json",
-	pathParamSchema: mcpServerToolPathParams,
-	bodySchema: executeToolBodySchema,
-	responseSchema: executeToolResponseSchema,
-	summary: "Execute MCP server tool",
-	description: "Executes a tool on the specified MCP server with the provided arguments",
-	tags: ["MCP"],
-	requiresAuth: true,
-	handler: async ({ mastra, serverId, toolId, data, resumeData, suspendPayload, requestContext }) => {
-		if (!mastra || typeof mastra.getMCPServerById !== "function") throw new HTTPException(500, { message: "Mastra instance or getMCPServerById method not available" });
-		const server = mastra.getMCPServerById(serverId);
-		if (!server) throw new HTTPException(404, { message: `MCP server with ID '${serverId}' not found` });
-		if (typeof server.executeTool !== "function") throw new HTTPException(501, { message: `Server '${serverId}' cannot execute tools in this way.` });
-		if (server.mcpVersion === 2) {
-			let execution;
-			try {
-				execution = await server.executeTool(toolId, data, {
-					requestContext,
-					resumeData,
-					suspendPayload
-				});
-			} catch (error) {
-				if (error instanceof MastraError && error.id === "MCP_SERVER_TOOL_INVALID_INPUT") throw new HTTPException(400, {
-					message: error.message,
-					cause: error
-				});
-				throw error;
-			}
-			if (execution.status === "suspended") return {
-				status: "suspended",
-				suspendPayload: execution.suspendPayload,
-				resumeSchema: execution.resumeSchema
-			};
-			return { result: execution.output };
-		}
-		return { result: await server.executeTool(toolId, data, { requestContext }) };
-	}
-});
-const LIST_MCP_SERVER_RESOURCES_ROUTE = createRoute({
-	method: "GET",
-	path: "/mcp/:serverId/resources",
-	responseType: "json",
-	pathParamSchema: mcpServerResourcePathParams,
-	responseSchema: listResourcesResponseSchema,
-	summary: "List MCP server resources",
-	description: "Returns a list of resources available on the MCP server, including ui:// app resources",
-	tags: ["MCP"],
-	requiresAuth: true,
-	handler: async ({ mastra, serverId }) => {
-		if (!mastra || typeof mastra.getMCPServerById !== "function") throw new HTTPException(500, { message: "Mastra instance or getMCPServerById method not available" });
-		const server = mastra.getMCPServerById(serverId);
-		if (!server) throw new HTTPException(404, { message: `MCP server with ID '${serverId}' not found` });
-		if (typeof server.listResources !== "function") return { resources: [] };
-		return server.listResources();
-	}
-});
-const READ_MCP_SERVER_RESOURCE_ROUTE = createRoute({
-	method: "POST",
-	path: "/mcp/:serverId/resources/read",
-	responseType: "json",
-	pathParamSchema: mcpServerResourcePathParams,
-	bodySchema: readResourceBodySchema,
-	responseSchema: readResourceResponseSchema,
-	summary: "Read MCP server resource content",
-	description: "Reads the content of a resource by URI, used for rendering MCP App ui:// resources",
-	tags: ["MCP"],
-	requiresAuth: true,
-	handler: async ({ mastra, serverId, uri }) => {
-		if (!mastra || typeof mastra.getMCPServerById !== "function") throw new HTTPException(500, { message: "Mastra instance or getMCPServerById method not available" });
-		const server = mastra.getMCPServerById(serverId);
-		if (!server) throw new HTTPException(404, { message: `MCP server with ID '${serverId}' not found` });
-		if (typeof server.readResource !== "function") throw new HTTPException(501, { message: `Server '${serverId}' does not support reading resources` });
-		try {
-			return await server.readResource(uri);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			if (message.includes("not found") || message.includes("not configured")) throw new HTTPException(404, { message: `Resource '${uri}' not found on server '${serverId}'` });
-			throw error;
-		}
-	}
-});
-const MCP_HTTP_TRANSPORT_ROUTE = createRoute({
-	method: "ALL",
-	path: "/mcp/:serverId/mcp",
-	responseType: "mcp-http",
-	pathParamSchema: mcpServerIdPathParams,
-	summary: "MCP HTTP Transport",
-	description: "Streamable HTTP transport endpoint for MCP protocol communication",
-	tags: ["MCP"],
-	requiresAuth: true,
-	handler: async ({ mastra, serverId }) => {
-		if (!mastra || typeof mastra.getMCPServerById !== "function") throw new HTTPException(500, { message: "Mastra instance or getMCPServerById method not available" });
-		const server = mastra.getMCPServerById(serverId);
-		if (!server) throw new HTTPException(404, { message: `MCP server '${serverId}' not found` });
-		return {
-			server,
-			httpPath: `/mcp/${serverId}/mcp`
-		};
-	}
-});
-const MCP_SSE_TRANSPORT_ROUTE = createRoute({
-	method: "ALL",
-	path: "/mcp/:serverId/sse",
-	responseType: "mcp-sse",
-	pathParamSchema: mcpServerIdPathParams,
-	summary: "MCP SSE Transport",
-	description: "SSE transport endpoint for MCP protocol communication",
-	tags: ["MCP"],
-	requiresAuth: true,
-	handler: async ({ mastra, serverId }) => {
-		if (!mastra || typeof mastra.getMCPServerById !== "function") throw new HTTPException(500, { message: "Mastra instance or getMCPServerById method not available" });
-		const server = mastra.getMCPServerById(serverId);
-		if (!server) throw new HTTPException(404, { message: `MCP server '${serverId}' not found` });
-		if (!hasSSETransport(server)) throw new HTTPException(404, { message: "Legacy SSE transport is unavailable for MCP v2 servers" });
-		return {
-			server,
-			ssePath: `/mcp/${serverId}/sse`,
-			messagePath: `/mcp/${serverId}/messages`
-		};
-	}
-});
-const MCP_SSE_MESSAGES_ROUTE = createRoute({
-	method: "POST",
-	path: "/mcp/:serverId/messages",
-	responseType: "mcp-sse",
-	pathParamSchema: mcpServerIdPathParams,
-	summary: "MCP SSE Messages",
-	description: "Message endpoint for SSE transport (posts messages to active SSE streams)",
-	tags: ["MCP"],
-	requiresAuth: true,
-	handler: MCP_SSE_TRANSPORT_ROUTE.handler
-});
-//#endregion
-export { EXECUTE_MCP_SERVER_TOOL_ROUTE, GET_MCP_SERVER_DETAIL_ROUTE, GET_MCP_SERVER_TOOL_DETAIL_ROUTE, LIST_MCP_SERVERS_ROUTE, LIST_MCP_SERVER_RESOURCES_ROUTE, LIST_MCP_SERVER_TOOLS_ROUTE, MCP_HTTP_TRANSPORT_ROUTE, MCP_SSE_MESSAGES_ROUTE, MCP_SSE_TRANSPORT_ROUTE, READ_MCP_SERVER_RESOURCE_ROUTE, mcp_exports as t };
-
-//# sourceMappingURL=mcp.js.map
+export { t as EMIT_MCP_SERVER_EVENT_ROUTE, n as EXECUTE_MCP_SERVER_TOOL_ROUTE, r as GET_MCP_SERVER_DETAIL_ROUTE, i as GET_MCP_SERVER_TOOL_DETAIL_ROUTE, a as LIST_MCP_SERVERS_ROUTE, o as LIST_MCP_SERVER_EVENTS_ROUTE, s as LIST_MCP_SERVER_RESOURCES_ROUTE, c as LIST_MCP_SERVER_TOOLS_ROUTE, l as MCP_HTTP_TRANSPORT_ROUTE, u as MCP_SSE_MESSAGES_ROUTE, d as MCP_SSE_TRANSPORT_ROUTE, f as POLL_MCP_SERVER_EVENT_ROUTE, p as READ_MCP_SERVER_RESOURCE_ROUTE, m as STREAM_MCP_SERVER_EVENT_ROUTE } from "../../mcp-CWDfSu7w.js";