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

package/dist/server/server-adapter/routes/mcp.d.ts

@@ -25,6 +25,7 @@ export declare const MCP_ROUTES: readonly [Omit<import("@mastra/core/server").Ap
                 is_latest: boolean;
             };
             transports?: ("sse" | "streamable-http")[] | undefined;
+            events_capability?: boolean | undefined;
         }[];
         total_count: number;
         next: string | null;
@@ -57,6 +58,7 @@ export declare const MCP_ROUTES: readonly [Omit<import("@mastra/core/server").Ap
                 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>;
@@ -86,6 +88,7 @@ export declare const MCP_ROUTES: readonly [Omit<import("@mastra/core/server").Ap
         packages?: unknown[] | undefined;
         remotes?: unknown[] | undefined;
         transports?: ("sse" | "streamable-http")[] | undefined;
+        events_capability?: boolean | undefined;
     }>;
     pathParamSchema?: import("zod").ZodSchema;
     queryParamSchema?: import("zod").ZodSchema;
@@ -117,6 +120,7 @@ export declare const MCP_ROUTES: readonly [Omit<import("@mastra/core/server").Ap
             sse: "sse";
             "streamable-http": "streamable-http";
         }>>>;
+        events_capability: import("zod").ZodOptional<import("zod").ZodBoolean>;
     }, import("zod/v4/core").$strip>> | undefined;
 } & {
     readonly _mastraSchemaRoute: true;
@@ -336,6 +340,216 @@ export declare const MCP_ROUTES: readonly [Omit<import("@mastra/core/server").Ap
     }, import("zod/v4/core").$strip>> | undefined;
 } & {
     readonly _mastraSchemaRoute: true;
+}, 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;
+    } & import(".").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("../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(".").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;
+}, 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;
+    } & import(".").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("../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(".").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;
+}, 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;
+    } & import(".").ServerContext): Promise<import("./stream-types").MastraStreamReturn>;
+    pathParamSchema?: import("zod").ZodSchema;
+    queryParamSchema?: import("zod").ZodSchema;
+    bodySchema?: import("zod").ZodSchema;
+    responseSchema?: import("zod").ZodSchema;
+    openapi?: import("../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(".").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;
+}, 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>;
+    } & import(".").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("../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(".").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;
 }, Omit<import("@mastra/core/server").ApiRoute, "createHandler" | "handler" | "method" | "openapi" | "path"> & {
     method: "ALL";
     path: "/mcp/:serverId/mcp";

package/dist/server/server-adapter/routes/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../../src/server/server-adapter/routes/mcp.ts"],"names":[],"mappings":"AAaA;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0Bb,CAAC"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../../src/server/server-adapter/routes/mcp.ts"],"names":[],"mappings":"AAiBA;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCb,CAAC"}

package/dist/tools-CmFSfDMn.js

@@ -0,0 +1,256 @@
+import { r as __exportAll } from "./rolldown-runtime-D3Hj5m0v.js";
+import { t as HTTPException } from "./http-exception-CyfxZB6W.js";
+import { o as optionalRunIdSchema } from "./common-Y30XtCyr.js";
+import { $ as toolIdPathParams, E as listToolsResponseSchema, b as executeToolContextBodySchema, l as agentToolPathParams, q as serializedToolSchema, x as executeToolResponseSchema, y as executeToolBodySchema } from "./agents-BHLTMBff.js";
+import { n as standardSchemaToJSONSchema, r as toStandardSchema } from "./schema-CzbEIyhE-BsMcj9Ws.js";
+import { n as createRoute } from "./route-builder-CjkWxv4E.js";
+import { l as stringify } from "./utils-aoLN3Wfi.js";
+import { handleError } from "./server/handlers/error.js";
+import { g as MastraFGAPermissions, p as validateBody } from "./utils-BBJlS81s.js";
+import { stripInjectedToolOverrideFields } from "./server/handlers/tool-schema-overrides.js";
+import { W as getAgentFromSystem } from "./agents-DRQ3ScbX.js";
+import { isProviderDefinedTool, isVercelTool } from "@mastra/core/tools";
+//#region src/server/handlers/tools.ts
+var tools_exports = /* @__PURE__ */ __exportAll({
+	EXECUTE_AGENT_TOOL_ROUTE: () => EXECUTE_AGENT_TOOL_ROUTE,
+	EXECUTE_TOOL_ROUTE: () => EXECUTE_TOOL_ROUTE,
+	GET_AGENT_TOOL_ROUTE: () => GET_AGENT_TOOL_ROUTE,
+	GET_TOOL_BY_ID_ROUTE: () => GET_TOOL_BY_ID_ROUTE,
+	LIST_TOOLS_ROUTE: () => LIST_TOOLS_ROUTE
+});
+/**
+* Resolves a schema that may be a lazy function (e.g. AI SDK provider tools).
+* Recursively resolves until a non-function value is returned.
+* Skips functions that are themselves valid schemas (e.g. ArkType types are
+* callable but also implement StandardSchema via ~standard).
+*/
+function resolveLazySchema(schema) {
+	if (typeof schema === "function" && !("~standard" in schema)) return resolveLazySchema(schema());
+	return schema;
+}
+function schemaToJsonSchema(schema) {
+	if (!schema) return;
+	return standardSchemaToJSONSchema(toStandardSchema(schema), { target: "draft-2020-12" });
+}
+function serializeSchema(schema, options) {
+	const jsonSchema = schemaToJsonSchema(resolveLazySchema(schema));
+	if (jsonSchema === void 0) return void 0;
+	return stringify(options?.stripInjectedOverrides ? stripInjectedToolOverrideFields(jsonSchema) : jsonSchema);
+}
+/**
+* Searches dynamically-resolved agent tools (provided via `toolsResolver` /
+* function-based `tools`) for a tool with the given id. Used as a fallback
+* after the static tool registry (`registeredTools` + `mastra.getToolById`)
+* misses, so global tool routes can resolve tools that only exist on agents.
+*
+* Errors thrown by an individual agent's `listTools()` are logged and
+* skipped so a single broken resolver doesn't take down the whole lookup.
+*/
+async function findToolInAgents(mastra, toolId, requestContext) {
+	const agents = mastra.listAgents() || {};
+	for (const agent of Object.values(agents)) try {
+		const agentTools = await agent.listTools({ requestContext });
+		const found = Object.values(agentTools || {}).find((t) => t.id === toolId);
+		if (found) return found;
+	} catch (error) {
+		mastra.getLogger?.()?.warn?.("Failed to list tools for agent while resolving tool by id", {
+			agentId: agent?.id,
+			toolId,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+/**
+* Serializes a tool for API responses, handling both regular tools (with Zod schemas)
+* and provider-defined tools (with AI SDK lazy schemas).
+*/
+function serializeTool(tool) {
+	if (isProviderDefinedTool(tool)) {
+		const resolvedInput = resolveLazySchema(tool.inputSchema);
+		const resolvedOutput = resolveLazySchema(tool.outputSchema);
+		return {
+			...tool,
+			inputSchema: resolvedInput && typeof resolvedInput === "object" && "jsonSchema" in resolvedInput ? stringify(resolvedInput.jsonSchema) : void 0,
+			outputSchema: resolvedOutput && typeof resolvedOutput === "object" && "jsonSchema" in resolvedOutput ? stringify(resolvedOutput.jsonSchema) : void 0
+		};
+	}
+	return {
+		...tool,
+		inputSchema: serializeSchema(tool.inputSchema, { stripInjectedOverrides: true }),
+		outputSchema: serializeSchema(tool.outputSchema),
+		requestContextSchema: serializeSchema(tool.requestContextSchema)
+	};
+}
+const LIST_TOOLS_ROUTE = createRoute({
+	method: "GET",
+	path: "/tools",
+	responseType: "json",
+	responseSchema: listToolsResponseSchema,
+	summary: "List all tools",
+	description: "Returns a list of all available tools in the system",
+	tags: ["Tools"],
+	requiresAuth: true,
+	handler: async ({ mastra, registeredTools, requestContext }) => {
+		try {
+			const registered = registeredTools && Object.keys(registeredTools).length > 0 ? registeredTools : {};
+			const allTools = {};
+			const seenToolIds = /* @__PURE__ */ new Map();
+			for (const [key, tool] of Object.entries(registered)) {
+				const toolId = typeof tool?.id === "string" ? tool.id : void 0;
+				if (toolId !== void 0) seenToolIds.set(toolId, key);
+				allTools[key] = tool;
+			}
+			for (const [key, tool] of Object.entries(mastra.listTools() ?? {})) {
+				const toolId = typeof tool?.id === "string" ? tool.id : void 0;
+				if (toolId !== void 0 && seenToolIds.has(toolId)) continue;
+				if (toolId !== void 0) seenToolIds.set(toolId, key);
+				allTools[key] = tool;
+			}
+			const serializedTools = Object.entries(allTools).reduce((acc, [id, _tool]) => {
+				acc[id] = serializeTool(_tool);
+				return acc;
+			}, {});
+			const fgaProvider = mastra.getServer?.()?.fga;
+			const user = requestContext?.get("user");
+			if (fgaProvider && user) {
+				const toolList = Object.entries(serializedTools).map(([id, t]) => ({
+					id,
+					...t
+				}));
+				const accessible = await fgaProvider.filterAccessible(user, toolList, "tool", MastraFGAPermissions.TOOLS_READ);
+				const accessibleSet = new Set(accessible.map((t) => t.id));
+				for (const id of Object.keys(serializedTools)) if (!accessibleSet.has(id)) delete serializedTools[id];
+			}
+			return serializedTools;
+		} catch (error) {
+			return handleError(error, "Error getting tools");
+		}
+	}
+});
+const GET_TOOL_BY_ID_ROUTE = createRoute({
+	method: "GET",
+	path: "/tools/:toolId",
+	responseType: "json",
+	pathParamSchema: toolIdPathParams,
+	responseSchema: serializedToolSchema,
+	summary: "Get tool by ID",
+	description: "Returns details for a specific tool including its schema and configuration",
+	tags: ["Tools"],
+	requiresAuth: true,
+	handler: async ({ mastra, registeredTools, toolId, requestContext }) => {
+		try {
+			let tool;
+			if (registeredTools && Object.keys(registeredTools).length > 0) tool = Object.values(registeredTools).find((t) => t.id === toolId);
+			if (!tool) try {
+				tool = mastra.getToolById(toolId);
+			} catch {}
+			if (!tool) tool = await findToolInAgents(mastra, toolId, requestContext);
+			if (!tool) throw new HTTPException(404, { message: "Tool not found" });
+			return serializeTool(tool);
+		} catch (error) {
+			return handleError(error, "Error getting tool");
+		}
+	}
+});
+const EXECUTE_TOOL_ROUTE = createRoute({
+	method: "POST",
+	path: "/tools/:toolId/execute",
+	responseType: "json",
+	pathParamSchema: toolIdPathParams,
+	queryParamSchema: optionalRunIdSchema,
+	bodySchema: executeToolContextBodySchema,
+	responseSchema: executeToolResponseSchema,
+	summary: "Execute tool",
+	description: "Executes a specific tool with the provided input data",
+	tags: ["Tools"],
+	requiresAuth: true,
+	handler: async ({ mastra, runId, toolId, registeredTools, requestContext, ...bodyParams }) => {
+		try {
+			if (!toolId) throw new HTTPException(400, { message: "Tool ID is required" });
+			let tool;
+			if (registeredTools && Object.keys(registeredTools).length > 0) tool = Object.values(registeredTools).find((t) => t.id === toolId);
+			if (!tool) try {
+				tool = mastra.getToolById(toolId);
+			} catch {}
+			if (!tool) tool = await findToolInAgents(mastra, toolId, requestContext);
+			if (!tool) throw new HTTPException(404, { message: "Tool not found" });
+			if (!tool?.execute) throw new HTTPException(400, { message: "Tool is not executable" });
+			const { data } = bodyParams;
+			validateBody({ data });
+			let result;
+			if (isVercelTool(tool)) result = await tool.execute(data);
+			else result = await tool.execute(data, {
+				mastra,
+				requestContext,
+				tracingContext: { currentSpan: void 0 },
+				...runId ? { workflow: {
+					runId,
+					suspend: async () => {}
+				} } : {}
+			});
+			return result;
+		} catch (error) {
+			return handleError(error, "Error executing tool");
+		}
+	}
+});
+const GET_AGENT_TOOL_ROUTE = createRoute({
+	method: "GET",
+	path: "/agents/:agentId/tools/:toolId",
+	responseType: "json",
+	pathParamSchema: agentToolPathParams,
+	responseSchema: serializedToolSchema,
+	summary: "Get agent tool",
+	description: "Returns details for a specific tool assigned to the agent",
+	tags: ["Agents", "Tools"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, toolId, requestContext }) => {
+		try {
+			if (!agentId) throw new HTTPException(400, { message: "Agent ID is required" });
+			const agentTools = await (await getAgentFromSystem({
+				mastra,
+				agentId
+			})).listTools({ requestContext });
+			const tool = Object.values(agentTools || {}).find((tool) => tool.id === toolId);
+			if (!tool) throw new HTTPException(404, { message: "Tool not found" });
+			return serializeTool(tool);
+		} catch (error) {
+			return handleError(error, "Error getting agent tool");
+		}
+	}
+});
+const EXECUTE_AGENT_TOOL_ROUTE = createRoute({
+	method: "POST",
+	path: "/agents/:agentId/tools/:toolId/execute",
+	responseType: "json",
+	pathParamSchema: agentToolPathParams,
+	bodySchema: executeToolBodySchema,
+	responseSchema: executeToolResponseSchema,
+	summary: "Execute agent tool",
+	description: "Executes a specific tool assigned to the agent with the provided input data",
+	tags: ["Agents", "Tools"],
+	requiresAuth: true,
+	handler: async ({ mastra, agentId, toolId, data, requestContext }) => {
+		try {
+			if (!agentId) throw new HTTPException(400, { message: "Agent ID is required" });
+			const agentTools = await (await getAgentFromSystem({
+				mastra,
+				agentId
+			})).listTools({ requestContext });
+			const tool = Object.values(agentTools || {}).find((tool) => tool.id === toolId);
+			if (!tool) throw new HTTPException(404, { message: "Tool not found" });
+			if (!tool?.execute) throw new HTTPException(400, { message: "Tool is not executable" });
+			return await tool.execute(data, {
+				mastra,
+				requestContext,
+				tracingContext: { currentSpan: void 0 }
+			});
+		} catch (error) {
+			return handleError(error, "Error executing agent tool");
+		}
+	}
+});
+//#endregion
+export { LIST_TOOLS_ROUTE as a, GET_TOOL_BY_ID_ROUTE as i, EXECUTE_TOOL_ROUTE as n, tools_exports as o, GET_AGENT_TOOL_ROUTE as r, EXECUTE_AGENT_TOOL_ROUTE as t };
+
+//# sourceMappingURL=tools-CmFSfDMn.js.map

package/dist/tools-CmFSfDMn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools-CmFSfDMn.js","names":[],"sources":["../src/server/handlers/tools.ts"],"sourcesContent":["import { isVercelTool, isProviderDefinedTool } from '@mastra/core/tools';\nimport { toStandardSchema, standardSchemaToJSONSchema } from '@mastra/schema-compat/schema';\nimport type { PublicSchema } from '@mastra/schema-compat/schema';\nimport { stringify } from 'superjson';\nimport { MastraFGAPermissions } from '../fga-permissions';\nimport { HTTPException } from '../http-exception';\nimport {\n  executeToolContextBodySchema,\n  executeToolResponseSchema,\n  listToolsResponseSchema,\n  serializedToolSchema,\n  toolIdPathParams,\n  agentToolPathParams,\n  executeToolBodySchema,\n} from '../schemas/agents';\nimport { optionalRunIdSchema } from '../schemas/common';\nimport { createRoute } from '../server-adapter/routes/route-builder';\n\nimport { getAgentFromSystem } from './agents';\nimport { handleError } from './error';\nimport { stripInjectedToolOverrideFields } from './tool-schema-overrides';\nimport { validateBody } from './utils';\n\n/**\n * Resolves a schema that may be a lazy function (e.g. AI SDK provider tools).\n * Recursively resolves until a non-function value is returned.\n * Skips functions that are themselves valid schemas (e.g. ArkType types are\n * callable but also implement StandardSchema via ~standard).\n */\nfunction resolveLazySchema(schema: unknown): unknown {\n  if (typeof schema === 'function' && !('~standard' in schema)) {\n    return resolveLazySchema(schema());\n  }\n  return schema;\n}\n\nfunction schemaToJsonSchema(schema: PublicSchema<unknown> | undefined) {\n  if (!schema) {\n    return undefined;\n  }\n\n  return standardSchemaToJSONSchema(toStandardSchema(schema), { target: 'draft-2020-12' });\n}\n\nfunction serializeSchema(schema: unknown, options?: { stripInjectedOverrides?: boolean }): string | undefined {\n  const jsonSchema = schemaToJsonSchema(resolveLazySchema(schema) as PublicSchema<unknown> | undefined);\n  if (jsonSchema === undefined) return undefined;\n  return stringify(options?.stripInjectedOverrides ? stripInjectedToolOverrideFields(jsonSchema) : jsonSchema);\n}\n\n/**\n * Searches dynamically-resolved agent tools (provided via `toolsResolver` /\n * function-based `tools`) for a tool with the given id. Used as a fallback\n * after the static tool registry (`registeredTools` + `mastra.getToolById`)\n * misses, so global tool routes can resolve tools that only exist on agents.\n *\n * Errors thrown by an individual agent's `listTools()` are logged and\n * skipped so a single broken resolver doesn't take down the whole lookup.\n */\nasync function findToolInAgents(mastra: any, toolId: string, requestContext: any): Promise<any | undefined> {\n  const agents = mastra.listAgents() || {};\n  for (const agent of Object.values(agents) as any[]) {\n    try {\n      const agentTools = await agent.listTools({ requestContext });\n      const found = Object.values(agentTools || {}).find((t: any) => t.id === toolId);\n      if (found) return found;\n    } catch (error) {\n      mastra.getLogger?.()?.warn?.('Failed to list tools for agent while resolving tool by id', {\n        agentId: agent?.id,\n        toolId,\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n  return undefined;\n}\n\n/**\n * Serializes a tool for API responses, handling both regular tools (with Zod schemas)\n * and provider-defined tools (with AI SDK lazy schemas).\n */\nfunction serializeTool(tool: any): any {\n  // Provider-defined tools (e.g. google.tools.googleSearch(), openai.tools.webSearch())\n  // have lazy inputSchema functions that return AI SDK Schema objects, not Zod schemas.\n  // We resolve them and use the jsonSchema property directly.\n  if (isProviderDefinedTool(tool)) {\n    const resolvedInput = resolveLazySchema(tool.inputSchema);\n    const resolvedOutput = resolveLazySchema(tool.outputSchema);\n    return {\n      ...tool,\n      inputSchema:\n        resolvedInput && typeof resolvedInput === 'object' && 'jsonSchema' in resolvedInput\n          ? stringify(resolvedInput.jsonSchema)\n          : undefined,\n      outputSchema:\n        resolvedOutput && typeof resolvedOutput === 'object' && 'jsonSchema' in resolvedOutput\n          ? stringify(resolvedOutput.jsonSchema)\n          : undefined,\n    };\n  }\n\n  return {\n    ...tool,\n    inputSchema: serializeSchema(tool.inputSchema, { stripInjectedOverrides: true }),\n    outputSchema: serializeSchema(tool.outputSchema),\n    requestContextSchema: serializeSchema(tool.requestContextSchema),\n  };\n}\n\n// ============================================================================\n// Route Definitions (new pattern - handlers defined inline with createRoute)\n// ============================================================================\n\nexport const LIST_TOOLS_ROUTE = createRoute({\n  method: 'GET',\n  path: '/tools',\n  responseType: 'json',\n  responseSchema: listToolsResponseSchema,\n  summary: 'List all tools',\n  description: 'Returns a list of all available tools in the system',\n  tags: ['Tools'],\n  requiresAuth: true,\n  handler: async ({ mastra, registeredTools, requestContext }) => {\n    try {\n      // Merge tools from two sources: mastra.listTools() includes dynamically created tools\n      // (e.g. MCP tools, or agent tools registered by their intrinsic id), while registeredTools\n      // includes tools discovered by the CLI bundler (keyed by export name).\n      //\n      // The same tool instance can appear in both maps under different keys (e.g. an agent\n      // registers it by `tool.id` while the bundler registers it by export name). Dedupe by\n      // `tool.id`, preferring the registeredTools (bundler) key, so each tool appears once.\n      const registered = registeredTools && Object.keys(registeredTools).length > 0 ? registeredTools : {};\n\n      const allTools: Record<string, any> = {};\n      const seenToolIds = new Map<string, string>();\n\n      // registeredTools first so their key wins for a given tool.id.\n      for (const [key, tool] of Object.entries(registered)) {\n        const toolId = typeof (tool as any)?.id === 'string' ? (tool as any).id : undefined;\n        if (toolId !== undefined) seenToolIds.set(toolId, key);\n        allTools[key] = tool;\n      }\n\n      for (const [key, tool] of Object.entries(mastra.listTools() ?? {})) {\n        const toolId = typeof (tool as any)?.id === 'string' ? (tool as any).id : undefined;\n        // Skip if this exact tool.id was already registered (under any key) by registeredTools.\n        if (toolId !== undefined && seenToolIds.has(toolId)) continue;\n        if (toolId !== undefined) seenToolIds.set(toolId, key);\n        allTools[key] = tool;\n      }\n\n      const serializedTools = Object.entries(allTools).reduce(\n        (acc, [id, _tool]) => {\n          acc[id] = serializeTool(_tool);\n          return acc;\n        },\n        {} as Record<string, any>,\n      );\n\n      // Filter tools by FGA if configured\n      const fgaProvider = mastra.getServer?.()?.fga;\n      const user = requestContext?.get('user');\n      if (fgaProvider && user) {\n        const toolList = Object.entries(serializedTools).map(([id, t]) => ({ id, ...t }));\n        const accessible = await fgaProvider.filterAccessible(user, toolList, 'tool', MastraFGAPermissions.TOOLS_READ);\n        const accessibleSet = new Set(accessible.map((t: any) => t.id));\n        for (const id of Object.keys(serializedTools)) {\n          if (!accessibleSet.has(id)) {\n            delete serializedTools[id];\n          }\n        }\n      }\n\n      return serializedTools;\n    } catch (error) {\n      return handleError(error, 'Error getting tools');\n    }\n  },\n});\n\nexport const GET_TOOL_BY_ID_ROUTE = createRoute({\n  method: 'GET',\n  path: '/tools/:toolId',\n  responseType: 'json',\n  pathParamSchema: toolIdPathParams,\n  responseSchema: serializedToolSchema,\n  summary: 'Get tool by ID',\n  description: 'Returns details for a specific tool including its schema and configuration',\n  tags: ['Tools'],\n  requiresAuth: true,\n  handler: async ({ mastra, registeredTools, toolId, requestContext }) => {\n    try {\n      let tool: any;\n\n      // Try explicit registeredTools first, then fallback to mastra\n      if (registeredTools && Object.keys(registeredTools).length > 0) {\n        tool = Object.values(registeredTools).find((t: any) => t.id === toolId);\n      }\n      if (!tool) {\n        try {\n          tool = mastra.getToolById(toolId);\n        } catch {\n          // tool not found in global registry, continue to agent fallback\n        }\n      }\n\n      // Fallback: search dynamically-resolved agent tools (toolsResolver)\n      if (!tool) {\n        tool = await findToolInAgents(mastra, toolId, requestContext);\n      }\n\n      if (!tool) {\n        throw new HTTPException(404, { message: 'Tool not found' });\n      }\n\n      return serializeTool(tool);\n    } catch (error) {\n      return handleError(error, 'Error getting tool');\n    }\n  },\n});\n\nexport const EXECUTE_TOOL_ROUTE = createRoute({\n  method: 'POST',\n  path: '/tools/:toolId/execute',\n  responseType: 'json',\n  pathParamSchema: toolIdPathParams,\n  queryParamSchema: optionalRunIdSchema,\n  bodySchema: executeToolContextBodySchema,\n  responseSchema: executeToolResponseSchema,\n  summary: 'Execute tool',\n  description: 'Executes a specific tool with the provided input data',\n  tags: ['Tools'],\n  requiresAuth: true,\n  handler: async ({ mastra, runId, toolId, registeredTools, requestContext, ...bodyParams }) => {\n    try {\n      if (!toolId) {\n        throw new HTTPException(400, { message: 'Tool ID is required' });\n      }\n\n      let tool: any;\n\n      // Try explicit registeredTools first, then fallback to mastra\n      if (registeredTools && Object.keys(registeredTools).length > 0) {\n        tool = Object.values(registeredTools).find((t: any) => t.id === toolId);\n      }\n      if (!tool) {\n        try {\n          tool = mastra.getToolById(toolId);\n        } catch {\n          // tool not found in global registry, continue to agent fallback\n        }\n      }\n\n      // Fallback: search dynamically-resolved agent tools (toolsResolver)\n      if (!tool) {\n        tool = await findToolInAgents(mastra, toolId, requestContext);\n      }\n\n      if (!tool) {\n        throw new HTTPException(404, { message: 'Tool not found' });\n      }\n\n      if (!tool?.execute) {\n        throw new HTTPException(400, { message: 'Tool is not executable' });\n      }\n\n      const { data } = bodyParams;\n\n      validateBody({ data });\n\n      let result;\n      if (isVercelTool(tool)) {\n        result = await (tool as any).execute(data);\n      } else {\n        result = await tool.execute(data!, {\n          mastra,\n          requestContext,\n          // TODO: Pass proper tracing context when server API supports tracing\n          tracingContext: { currentSpan: undefined },\n          ...(runId\n            ? {\n                workflow: {\n                  runId,\n                  suspend: async () => {},\n                },\n              }\n            : {}),\n        });\n      }\n\n      return result;\n    } catch (error) {\n      return handleError(error, 'Error executing tool');\n    }\n  },\n});\n\n// ============================================================================\n// Agent Tool Routes\n// ============================================================================\n\nexport const GET_AGENT_TOOL_ROUTE = createRoute({\n  method: 'GET',\n  path: '/agents/:agentId/tools/:toolId',\n  responseType: 'json',\n  pathParamSchema: agentToolPathParams,\n  responseSchema: serializedToolSchema,\n  summary: 'Get agent tool',\n  description: 'Returns details for a specific tool assigned to the agent',\n  tags: ['Agents', 'Tools'],\n  requiresAuth: true,\n  handler: async ({ mastra, agentId, toolId, requestContext }) => {\n    try {\n      if (!agentId) {\n        throw new HTTPException(400, { message: 'Agent ID is required' });\n      }\n      const agent = await getAgentFromSystem({ mastra, agentId });\n\n      const agentTools = await agent.listTools({ requestContext });\n\n      const tool = Object.values(agentTools || {}).find((tool: any) => tool.id === toolId) as any;\n\n      if (!tool) {\n        throw new HTTPException(404, { message: 'Tool not found' });\n      }\n\n      return serializeTool(tool);\n    } catch (error) {\n      return handleError(error, 'Error getting agent tool');\n    }\n  },\n});\n\nexport const EXECUTE_AGENT_TOOL_ROUTE = createRoute({\n  method: 'POST',\n  path: '/agents/:agentId/tools/:toolId/execute',\n  responseType: 'json',\n  pathParamSchema: agentToolPathParams,\n  bodySchema: executeToolBodySchema,\n  responseSchema: executeToolResponseSchema,\n  summary: 'Execute agent tool',\n  description: 'Executes a specific tool assigned to the agent with the provided input data',\n  tags: ['Agents', 'Tools'],\n  requiresAuth: true,\n  handler: async ({ mastra, agentId, toolId, data, requestContext }) => {\n    try {\n      if (!agentId) {\n        throw new HTTPException(400, { message: 'Agent ID is required' });\n      }\n      const agent = await getAgentFromSystem({ mastra, agentId });\n\n      const agentTools = await agent.listTools({ requestContext });\n\n      const tool = Object.values(agentTools || {}).find((tool: any) => tool.id === toolId) as any;\n\n      if (!tool) {\n        throw new HTTPException(404, { message: 'Tool not found' });\n      }\n\n      if (!tool?.execute) {\n        throw new HTTPException(400, { message: 'Tool is not executable' });\n      }\n\n      const result = await tool.execute(data, {\n        mastra,\n        requestContext,\n        // TODO: Pass proper tracing context when server API supports tracing\n        tracingContext: { currentSpan: undefined },\n      });\n\n      return result;\n    } catch (error) {\n      return handleError(error, 'Error executing agent tool');\n    }\n  },\n});\n"],"mappings":"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"}