@mastra/server 1.68.0-alpha.0 → 1.68.0-alpha.11

package/dist/{observability-new-endpoints-I2OxQzfY.cjs → observability-new-endpoints-CDrOjmJw.cjs}

@@ -1,11 +1,12 @@
 const require_rolldown_runtime = require("./rolldown-runtime-Bd6kNlEP.cjs");
 const require_http_exception = require("./http-exception-CKDHupKw.cjs");
-const require_route_builder = require("./route-builder-DupY8fkI.cjs");
+const require_route_builder = require("./route-builder-CbCx1upL.cjs");
 const require_constants = require("./constants-4IJp_uzj.cjs");
 const require_server_handlers_error = require("./server/handlers/error.cjs");
 const require_server_handlers_observability_list_query_schemas = require("./server/handlers/observability-list-query-schemas.cjs");
 const require_server_handlers_observability_shared = require("./server/handlers/observability-shared.cjs");
 const require_server_handlers_author_enrichment = require("./server/handlers/author-enrichment.cjs");
+const require_server_handlers_authorship = require("./server/handlers/authorship.cjs");
 let zod_v4 = require("zod/v4");
 let _mastra_core_storage = require("@mastra/core/storage");
 _mastra_core_storage = require_rolldown_runtime.__toESM(_mastra_core_storage, 1);
@@ -36,6 +37,8 @@ let EntityType = /* @__PURE__ */ function(EntityType) {
 	EntityType["WORKFLOW_STEP"] = "workflow_step";
 	/** Tool */
 	EntityType["TOOL"] = "tool";
+	/** MCP server */
+	EntityType["MCP_SERVER"] = "mcp_server";
 	/** Workflow */
 	EntityType["WORKFLOW_RUN"] = "workflow_run";
 	/** Memory */
@@ -871,7 +874,7 @@ const listFeedbackResponseSchema = listFeedbackResponseSchema$1.extend({ feedbac
 //#endregion
 //#region src/server/handlers/observability-new-endpoints.ts
 function createNewRoute(def, config) {
-	const { handler, preserveHttpExceptions, ...schemas } = config;
+	const { handler, preserveHttpExceptions, isCoreSupported, onUnsupportedCore, ...schemas } = config;
 	return require_route_builder.createRoute({
 		...def,
 		...schemas,
@@ -880,7 +883,10 @@ function createNewRoute(def, config) {
 		requiresAuth: true,
 		handler: (async (params) => {
 			try {
-				if (!_mastra_core_features.coreFeatures.has("observability:v1.13.2")) throw new require_http_exception.HTTPException(501, { message: "New observability endpoints require @mastra/core >= 1.13.2, please upgrade." });
+				if (!_mastra_core_features.coreFeatures.has("observability:v1.13.2") || isCoreSupported && !isCoreSupported()) {
+					if (onUnsupportedCore) onUnsupportedCore();
+					throw new require_http_exception.HTTPException(501, { message: "New observability endpoints require @mastra/core >= 1.13.2, please upgrade." });
+				}
 				return await handler(params);
 			} catch (error) {
 				if (preserveHttpExceptions && error instanceof require_http_exception.HTTPException) throw error;
@@ -923,6 +929,14 @@ const traceQueryTimeoutErrorSchema = zod_v4.z.object({
 	code: zod_v4.z.literal("TRACE_QUERY_EXECUTION_TIMEOUT"),
 	message: zod_v4.z.string()
 }).strict();
+const traceQueryResourceLimitErrorSchema = zod_v4.z.object({
+	code: zod_v4.z.literal("TRACE_QUERY_RESOURCE_LIMIT"),
+	message: zod_v4.z.string()
+}).strict();
+const traceQueryDiscoveryUnsupportedErrorSchema = zod_v4.z.object({
+	code: zod_v4.z.literal("TRACE_QUERY_DISCOVERY_UNSUPPORTED"),
+	message: zod_v4.z.string()
+}).strict();
 const traceQueryValidationError = (error) => ({
 	status: 422,
 	body: {
@@ -944,22 +958,41 @@ function throwTraceQueryError(status, body) {
 		})
 	});
 }
+const throwTraceQueryDiscoveryCoreUnsupported = () => throwTraceQueryError(501, {
+	code: "TRACE_QUERY_DISCOVERY_UNSUPPORTED",
+	message: "Trace query discovery requires a newer @mastra/core. Please upgrade."
+});
 const QUERY_TRACES = createNewRoute(require_server_handlers_observability_shared.NEW_ROUTE_DEFS.QUERY_TRACES, {
 	bodySchema: _mastra_core_storage.traceQueryRequestSchema,
 	responseSchema: _mastra_core_storage.traceQueryResponseSchema,
 	onValidationError: traceQueryValidationError,
 	maxBodySize: 256 * 1024,
 	preserveHttpExceptions: true,
-	handler: async ({ mastra, timeRange, where, group, orderBy, page }) => {
+	handler: async ({ mastra, requestContext, timeRange, where, group, orderBy, page, pagination, mode, after, limit }) => {
 		let plan;
 		try {
+			const user = requestContext.get(require_constants.MASTRA_USER_KEY);
+			const userId = user && typeof user === "object" && "id" in user ? user.id : void 0;
+			const roles = requestContext.get(require_constants.MASTRA_USER_ROLES_KEY);
+			const authorizationBinding = mode === "delta" || pagination !== void 0 ? JSON.stringify({
+				userId: typeof userId === "string" || typeof userId === "number" ? userId : null,
+				resourceId: requestContext.get("mastra__resourceId") ?? null,
+				organizationId: requestContext.get("organizationId") ?? null,
+				authMode: requestContext.get("mastra__authMode") ?? null,
+				permissions: [...new Set(require_server_handlers_authorship.getCallerPermissions(requestContext))].sort(),
+				roles: Array.isArray(roles) ? [...new Set(roles.filter((role) => typeof role === "string"))].sort() : []
+			}) : void 0;
 			plan = _mastra_core_storage.planTraceQuery({
 				timeRange,
 				where,
 				group,
 				orderBy,
-				page
-			});
+				page,
+				pagination,
+				mode,
+				after,
+				limit
+			}, { authorizationBinding });
 		} catch (error) {
 			if (error instanceof _mastra_core_storage.TraceQueryValidationError) throwTraceQueryError(422, {
 				code: error.code,
@@ -976,6 +1009,7 @@ const QUERY_TRACES = createNewRoute(require_server_handlers_observability_shared
 		try {
 			observabilityStore = await require_server_handlers_observability_shared.getObservabilityStore(mastra);
 			require_server_handlers_observability_shared.assertObservabilityTraceQuerySupported(observabilityStore);
+			if (plan.paginationMode === "delta" && !observabilityStore.getFeatures()?.includes("delta-polling")) throw new require_http_exception.HTTPException(501, { message: "This storage provider does not support observability delta polling" });
 		} catch (error) {
 			if (error instanceof require_http_exception.HTTPException && error.status === 501) throwTraceQueryError(501, {
 				code: "TRACE_QUERY_UNSUPPORTED",
@@ -986,6 +1020,10 @@ const QUERY_TRACES = createNewRoute(require_server_handlers_observability_shared
 		try {
 			return await observabilityStore.queryTraces(plan);
 		} catch (error) {
+			if (error instanceof _mastra_core_storage.TraceQueryCursorError) throwTraceQueryError(error.code === "TRACE_QUERY_CURSOR_CONFLICT" ? 409 : 400, {
+				code: error.code,
+				message: error.message
+			});
 			if (error instanceof _mastra_core_storage.TraceQueryExecutionError) throwTraceQueryError(504, {
 				code: error.code,
 				message: error.message
@@ -1020,6 +1058,195 @@ if (QUERY_TRACES.openapi) {
 		content: { "application/json": { schema: traceQueryTimeoutErrorSchema } }
 	};
 }
+const GET_TRACE_QUERY_FIELDS = createNewRoute(require_server_handlers_observability_shared.NEW_ROUTE_DEFS.GET_TRACE_QUERY_FIELDS, {
+	bodySchema: _mastra_core_storage.getTraceQueryFieldsArgsSchema,
+	responseSchema: _mastra_core_storage.getTraceQueryFieldsResponseSchema,
+	onValidationError: traceQueryValidationError,
+	maxBodySize: 256 * 1024,
+	preserveHttpExceptions: true,
+	isCoreSupported: require_server_handlers_observability_shared.supportsTraceQueryDiscoveryCore,
+	onUnsupportedCore: throwTraceQueryDiscoveryCoreUnsupported,
+	handler: async ({ mastra, timeRange, predicateScope, search, limit }) => {
+		const args = {
+			timeRange,
+			predicateScope,
+			search,
+			limit
+		};
+		const plan = _mastra_core_storage.planTraceQueryObservedFields(args);
+		let observabilityStore;
+		try {
+			observabilityStore = await require_server_handlers_observability_shared.getObservabilityStore(mastra);
+			require_server_handlers_observability_shared.assertObservabilityTraceQueryDiscoverySupported(observabilityStore);
+		} catch (error) {
+			if (error instanceof require_http_exception.HTTPException && error.status === 501) throwTraceQueryError(501, {
+				code: "TRACE_QUERY_DISCOVERY_UNSUPPORTED",
+				message: error.message
+			});
+			throw error;
+		}
+		try {
+			const observed = await observabilityStore.getTraceQueryObservedFields(plan);
+			return {
+				canonicalFields: _mastra_core_storage.getTraceQueryCanonicalFieldDescriptors(predicateScope, search),
+				...observed
+			};
+		} catch (error) {
+			if (error instanceof _mastra_core_storage.TraceQueryResourceLimitError) throwTraceQueryError(503, {
+				code: error.code,
+				message: error.message
+			});
+			if (error instanceof _mastra_core_storage.TraceQueryExecutionError) throwTraceQueryError(504, {
+				code: error.code,
+				message: error.message
+			});
+			throw error;
+		}
+	}
+});
+const GET_TRACE_QUERY_VALUES = createNewRoute(require_server_handlers_observability_shared.NEW_ROUTE_DEFS.GET_TRACE_QUERY_VALUES, {
+	bodySchema: _mastra_core_storage.getTraceQueryValuesArgsSchema,
+	responseSchema: _mastra_core_storage.getTraceQueryValuesResponseSchema,
+	onValidationError: traceQueryValidationError,
+	maxBodySize: 256 * 1024,
+	preserveHttpExceptions: true,
+	isCoreSupported: require_server_handlers_observability_shared.supportsTraceQueryDiscoveryCore,
+	onUnsupportedCore: throwTraceQueryDiscoveryCoreUnsupported,
+	handler: async ({ mastra, timeRange, predicateScope, path, search, limit }) => {
+		const plan = _mastra_core_storage.planTraceQueryValues({
+			timeRange,
+			predicateScope,
+			path,
+			search,
+			limit
+		});
+		let observabilityStore;
+		try {
+			observabilityStore = await require_server_handlers_observability_shared.getObservabilityStore(mastra);
+			require_server_handlers_observability_shared.assertObservabilityTraceQueryDiscoverySupported(observabilityStore);
+		} catch (error) {
+			if (error instanceof require_http_exception.HTTPException && error.status === 501) throwTraceQueryError(501, {
+				code: "TRACE_QUERY_DISCOVERY_UNSUPPORTED",
+				message: error.message
+			});
+			throw error;
+		}
+		try {
+			return await observabilityStore.getTraceQueryValues(plan);
+		} catch (error) {
+			if (error instanceof _mastra_core_storage.TraceQueryResourceLimitError) throwTraceQueryError(503, {
+				code: error.code,
+				message: error.message
+			});
+			if (error instanceof _mastra_core_storage.TraceQueryExecutionError) throwTraceQueryError(504, {
+				code: error.code,
+				message: error.message
+			});
+			throw error;
+		}
+	}
+});
+for (const route of [GET_TRACE_QUERY_FIELDS, GET_TRACE_QUERY_VALUES]) {
+	if (!route.openapi) continue;
+	route.openapi.responses[413] = {
+		description: "Request body exceeds 256 KiB",
+		content: { "application/json": { schema: traceQueryBodyTooLargeErrorSchema } }
+	};
+	route.openapi.responses[422] = {
+		description: "Structurally or semantically invalid trace-query discovery request",
+		content: { "application/json": { schema: traceQueryValidationResponseSchema } }
+	};
+	route.openapi.responses[501] = {
+		description: "The installed Core or configured observability store does not support trace-query discovery",
+		content: { "application/json": { schema: traceQueryDiscoveryUnsupportedErrorSchema } }
+	};
+	route.openapi.responses[503] = {
+		description: "Trace-query discovery exceeded the configured database resource limit",
+		content: { "application/json": { schema: traceQueryResourceLimitErrorSchema } }
+	};
+	route.openapi.responses[504] = {
+		description: "Trace-query discovery exceeded the configured database execution timeout",
+		content: { "application/json": { schema: traceQueryTimeoutErrorSchema } }
+	};
+}
+const QUERY_THREADS = createNewRoute(require_server_handlers_observability_shared.NEW_ROUTE_DEFS.QUERY_THREADS, {
+	bodySchema: _mastra_core_storage.queryThreadsInputSchema,
+	responseSchema: _mastra_core_storage.queryThreadsResultSchema,
+	onValidationError: traceQueryValidationError,
+	maxBodySize: 256 * 1024,
+	preserveHttpExceptions: true,
+	onUnsupportedCore: () => throwTraceQueryError(501, {
+		code: "TRACE_QUERY_UNSUPPORTED",
+		message: "Thread queries require a newer @mastra/core with observability thread-query support. Please upgrade."
+	}),
+	handler: async ({ mastra, traces, where, page }) => {
+		let plan;
+		try {
+			plan = _mastra_core_storage.planThreadQuery({
+				traces,
+				where,
+				page
+			});
+		} catch (error) {
+			if (error instanceof _mastra_core_storage.TraceQueryValidationError) throwTraceQueryError(422, {
+				code: error.code,
+				message: error.message,
+				issues: error.issues
+			});
+			if (error instanceof _mastra_core_storage.TraceQueryCursorError) throwTraceQueryError(error.code === "TRACE_QUERY_CURSOR_CONFLICT" ? 409 : 400, {
+				code: error.code,
+				message: error.message
+			});
+			throw error;
+		}
+		let observabilityStore;
+		try {
+			observabilityStore = await require_server_handlers_observability_shared.getObservabilityStore(mastra);
+			require_server_handlers_observability_shared.assertObservabilityThreadQuerySupported(observabilityStore);
+		} catch (error) {
+			if (error instanceof require_http_exception.HTTPException && error.status === 501) throwTraceQueryError(501, {
+				code: "TRACE_QUERY_UNSUPPORTED",
+				message: error.message
+			});
+			throw error;
+		}
+		try {
+			return await observabilityStore.queryThreads(plan);
+		} catch (error) {
+			if (error instanceof _mastra_core_storage.TraceQueryExecutionError) throwTraceQueryError(504, {
+				code: error.code,
+				message: error.message
+			});
+			throw error;
+		}
+	}
+});
+if (QUERY_THREADS.openapi) {
+	QUERY_THREADS.openapi.responses[400] = {
+		description: "Malformed JSON or malformed cursor",
+		content: { "application/json": { schema: zod_v4.z.union([traceQueryMalformedBodyErrorSchema, traceQueryMalformedCursorErrorSchema]) } }
+	};
+	QUERY_THREADS.openapi.responses[409] = {
+		description: "Cursor does not match the normalized query",
+		content: { "application/json": { schema: traceQueryCursorConflictErrorSchema } }
+	};
+	QUERY_THREADS.openapi.responses[413] = {
+		description: "Request body exceeds 256 KiB",
+		content: { "application/json": { schema: traceQueryBodyTooLargeErrorSchema } }
+	};
+	QUERY_THREADS.openapi.responses[422] = {
+		description: "Structurally or semantically invalid thread query",
+		content: { "application/json": { schema: traceQueryValidationResponseSchema } }
+	};
+	QUERY_THREADS.openapi.responses[501] = {
+		description: "The configured observability store does not support thread queries",
+		content: { "application/json": { schema: traceQueryUnsupportedErrorSchema } }
+	};
+	QUERY_THREADS.openapi.responses[504] = {
+		description: "Thread query exceeded the configured database execution timeout",
+		content: { "application/json": { schema: traceQueryTimeoutErrorSchema } }
+	};
+}
 const LIST_LOGS = createNewRoute(require_server_handlers_observability_shared.NEW_ROUTE_DEFS.LIST_LOGS, {
 	queryParamSchema: require_server_handlers_observability_shared.createObservabilityListQuerySchema(logsFilterSchema, logsOrderBySchema),
 	responseSchema: listLogsResponseSchema,
@@ -1372,6 +1599,7 @@ const GET_TAGS = createNewRoute(require_server_handlers_observability_shared.NEW
 });
 const NEW_ROUTES = {
 	QUERY_TRACES,
+	QUERY_THREADS,
 	LIST_LOGS,
 	LIST_SCORES,
 	CREATE_SCORE,
@@ -1554,6 +1782,18 @@ Object.defineProperty(exports, "GET_TAGS", {
 		return GET_TAGS;
 	}
 });
+Object.defineProperty(exports, "GET_TRACE_QUERY_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return GET_TRACE_QUERY_FIELDS;
+	}
+});
+Object.defineProperty(exports, "GET_TRACE_QUERY_VALUES", {
+	enumerable: true,
+	get: function() {
+		return GET_TRACE_QUERY_VALUES;
+	}
+});
 Object.defineProperty(exports, "LIST_FEEDBACK", {
 	enumerable: true,
 	get: function() {
@@ -1584,6 +1824,12 @@ Object.defineProperty(exports, "NEW_ROUTES", {
 		return NEW_ROUTES;
 	}
 });
+Object.defineProperty(exports, "QUERY_THREADS", {
+	enumerable: true,
+	get: function() {
+		return QUERY_THREADS;
+	}
+});
 Object.defineProperty(exports, "QUERY_TRACES", {
 	enumerable: true,
 	get: function() {
@@ -1597,4 +1843,4 @@ Object.defineProperty(exports, "UPDATE_FEEDBACK_REVIEW_STATUS", {
 	}
 });
 
-//# sourceMappingURL=observability-new-endpoints-I2OxQzfY.cjs.map
+//# sourceMappingURL=observability-new-endpoints-CDrOjmJw.cjs.map