@mastra/server 1.13.3-alpha.0 → 1.14.0-alpha.2

package/dist/chunk-4VGZOVOI.js

@@ -0,0 +1,656 @@
+import { NEW_ROUTE_DEFS, getObservabilityStore } from './chunk-RSIZIEPW.js';
+import { handleError } from './chunk-NA7LKQPZ.js';
+import { wrapSchemaForQueryParams, createRoute, pickParams } from './chunk-3MW2URMC.js';
+import { HTTPException } from './chunk-6QWQZI4Q.js';
+import { z } from 'zod/v4';
+import { coreFeatures } from '@mastra/core/features';
+
+var EntityType = /* @__PURE__ */ ((EntityType2) => {
+  EntityType2["AGENT"] = "agent";
+  EntityType2["EVAL"] = "eval";
+  EntityType2["INPUT_PROCESSOR"] = "input_processor";
+  EntityType2["INPUT_STEP_PROCESSOR"] = "input_step_processor";
+  EntityType2["OUTPUT_PROCESSOR"] = "output_processor";
+  EntityType2["OUTPUT_STEP_PROCESSOR"] = "output_step_processor";
+  EntityType2["WORKFLOW_STEP"] = "workflow_step";
+  EntityType2["TOOL"] = "tool";
+  EntityType2["WORKFLOW_RUN"] = "workflow_run";
+  return EntityType2;
+})(EntityType || {});
+z.date().describe("Database record creation time");
+var updatedAtField = z.date().describe("Database record last update time");
+({
+  updatedAt: updatedAtField.nullable()
+});
+var paginationArgsSchema = z.object({
+  page: z.coerce.number().int().min(0).optional().default(0).describe("Zero-indexed page number"),
+  perPage: z.coerce.number().int().min(1).max(100).optional().default(10).describe("Number of items per page")
+}).describe("Pagination options for list queries");
+var paginationInfoSchema = z.object({
+  total: z.number().describe("Total number of items available"),
+  page: z.number().describe("Current page"),
+  perPage: z.union([z.number(), z.literal(false)]).describe("Number of items per page, or false if pagination is disabled"),
+  hasMore: z.boolean().describe("True if more pages are available")
+});
+var dateRangeSchema = z.object({
+  start: z.coerce.date().optional().describe("Start of date range (inclusive by default)"),
+  end: z.coerce.date().optional().describe("End of date range (inclusive by default)"),
+  startExclusive: z.boolean().optional().describe("When true, excludes the start date from results (uses > instead of >=)"),
+  endExclusive: z.boolean().optional().describe("When true, excludes the end date from results (uses < instead of <=)")
+}).describe("Date range filter for timestamps");
+var sortDirectionSchema = z.enum(["ASC", "DESC"]).describe("Sort direction: 'ASC' | 'DESC'");
+var entityTypeField = z.nativeEnum(EntityType).describe(`Entity type (e.g., 'agent' | 'processor' | 'tool' | 'workflow')`);
+var entityIdField = z.string().describe('ID of the entity (e.g., "weatherAgent", "orderWorkflow")');
+var entityNameField = z.string().describe("Name of the entity");
+var userIdField = z.string().describe("Human end-user who triggered execution");
+var organizationIdField = z.string().describe("Multi-tenant organization/account");
+var resourceIdField = z.string().describe("Broader resource context (Mastra memory compatibility)");
+var runIdField = z.string().describe("Unique execution run identifier");
+var sessionIdField = z.string().describe("Session identifier for grouping traces");
+var threadIdField = z.string().describe("Conversation thread identifier");
+var requestIdField = z.string().describe("HTTP request ID for log correlation");
+var environmentField = z.string().describe(`Environment (e.g., "production" | "staging" | "development")`);
+var sourceField = z.string().describe(`Source of execution (e.g., "local" | "cloud" | "ci")`);
+var serviceNameField = z.string().describe("Name of the service");
+var parentEntityTypeField = z.nativeEnum(EntityType).describe("Entity type of the parent entity");
+var parentEntityIdField = z.string().describe("ID of the parent entity");
+var parentEntityNameField = z.string().describe("Name of the parent entity");
+var rootEntityTypeField = z.nativeEnum(EntityType).describe("Entity type of the root entity");
+var rootEntityIdField = z.string().describe("ID of the root entity");
+var rootEntityNameField = z.string().describe("Name of the root entity");
+var experimentIdField = z.string().describe("Experiment or eval run identifier");
+var scopeField = z.record(z.string(), z.unknown()).describe('Arbitrary package/app version info (e.g., {"core": "1.0.0", "memory": "1.0.0", "gitSha": "abcd1234"})');
+var metadataField = z.record(z.string(), z.unknown()).describe("User-defined metadata for custom filtering");
+var tagsField = z.array(z.string()).describe("Labels for filtering");
+var contextFields = {
+  // Entity identification
+  entityType: entityTypeField.nullish(),
+  entityId: entityIdField.nullish(),
+  entityName: entityNameField.nullish(),
+  // Parent entity hierarchy
+  parentEntityType: parentEntityTypeField.nullish(),
+  parentEntityId: parentEntityIdField.nullish(),
+  parentEntityName: parentEntityNameField.nullish(),
+  // Root entity hierarchy
+  rootEntityType: rootEntityTypeField.nullish(),
+  rootEntityId: rootEntityIdField.nullish(),
+  rootEntityName: rootEntityNameField.nullish(),
+  // Identity & tenancy
+  userId: userIdField.nullish(),
+  organizationId: organizationIdField.nullish(),
+  resourceId: resourceIdField.nullish(),
+  // Correlation IDs
+  runId: runIdField.nullish(),
+  sessionId: sessionIdField.nullish(),
+  threadId: threadIdField.nullish(),
+  requestId: requestIdField.nullish(),
+  // Deployment context
+  environment: environmentField.nullish(),
+  source: sourceField.nullish(),
+  serviceName: serviceNameField.nullish(),
+  scope: scopeField.nullish(),
+  // Experimentation
+  experimentId: experimentIdField.nullish()
+};
+var commonFilterFields = {
+  timestamp: dateRangeSchema.optional().describe("Filter by timestamp range"),
+  traceId: z.string().optional().describe("Filter by trace ID"),
+  spanId: z.string().optional().describe("Filter by span ID"),
+  entityType: entityTypeField.optional(),
+  entityName: entityNameField.optional(),
+  userId: userIdField.optional(),
+  organizationId: organizationIdField.optional(),
+  experimentId: experimentIdField.optional(),
+  serviceName: serviceNameField.optional(),
+  environment: environmentField.optional()
+};
+var traceIdField = z.string().describe("Unique trace identifier");
+var spanIdField = z.string().describe("Unique span identifier within a trace");
+var logLevelSchema = z.enum(["debug", "info", "warn", "error", "fatal"]);
+var messageField = z.string().describe("Log message");
+var logDataField = z.record(z.string(), z.unknown()).describe("Structured data attached to the log");
+var logRecordSchema = z.object({
+  timestamp: z.date().describe("When the log was created"),
+  level: logLevelSchema.describe("Log severity level"),
+  message: messageField,
+  data: logDataField.nullish(),
+  // Correlation
+  traceId: z.string().nullish().describe("Trace ID for correlation"),
+  spanId: z.string().nullish().describe("Span ID for correlation"),
+  // Context fields (same as tracing)
+  ...contextFields,
+  // Filtering
+  tags: tagsField.nullish(),
+  metadata: metadataField.nullish()
+}).describe("Log record as stored in the database");
+z.object({
+  level: logLevelSchema,
+  message: messageField,
+  data: logDataField.optional(),
+  tags: tagsField.optional()
+}).describe("User-provided log input");
+var createLogRecordSchema = logRecordSchema;
+z.object({
+  logs: z.array(createLogRecordSchema)
+}).describe("Arguments for batch creating logs");
+var logsFilterSchema = z.object({
+  ...commonFilterFields,
+  // Log-specific filters
+  level: z.union([logLevelSchema, z.array(logLevelSchema)]).optional().describe("Filter by log level(s)"),
+  // Extended correlation filters
+  runId: runIdField.optional(),
+  sessionId: sessionIdField.optional(),
+  threadId: threadIdField.optional(),
+  requestId: requestIdField.optional(),
+  // Parent/root entity filters
+  parentEntityType: parentEntityTypeField.optional(),
+  parentEntityName: parentEntityNameField.optional(),
+  rootEntityType: rootEntityTypeField.optional(),
+  rootEntityName: rootEntityNameField.optional(),
+  // Multi-tenancy filters
+  resourceId: resourceIdField.optional(),
+  source: sourceField.optional(),
+  // Content filters
+  search: z.string().optional().describe("Full-text search on message"),
+  tags: z.array(z.string()).optional().describe("Filter by tags (logs must have all specified tags)"),
+  dataKeys: z.array(z.string()).optional().describe("Filter logs that have specific data keys")
+}).describe("Filters for querying logs");
+var logsOrderByFieldSchema = z.enum(["timestamp"]).describe("Field to order by: 'timestamp'");
+var logsOrderBySchema = z.object({
+  field: logsOrderByFieldSchema.default("timestamp").describe("Field to order by"),
+  direction: sortDirectionSchema.default("DESC").describe("Sort direction")
+}).describe("Order by configuration");
+z.object({
+  filters: logsFilterSchema.optional().describe("Optional filters to apply"),
+  pagination: paginationArgsSchema.default({ page: 0, perPage: 10 }).describe("Pagination settings"),
+  orderBy: logsOrderBySchema.default({ field: "timestamp", direction: "DESC" }).describe("Ordering configuration (defaults to timestamp desc)")
+}).describe("Arguments for listing logs");
+var listLogsResponseSchema = z.object({
+  pagination: paginationInfoSchema,
+  logs: z.array(logRecordSchema)
+});
+var scorerIdField = z.string().describe("Identifier of the scorer (e.g., relevance, accuracy)");
+var scorerVersionField = z.string().describe("Version of the scorer");
+var sourceField2 = z.string().describe("Source of the score (e.g., manual, automated, experiment)");
+var scoreValueField = z.number().describe("Score value (range defined by scorer)");
+var scoreReasonField = z.string().describe("Explanation for the score");
+var scoreRecordSchema = z.object({
+  timestamp: z.date().describe("When the score was recorded"),
+  // Target
+  traceId: traceIdField,
+  spanId: spanIdField.nullish().describe("Span ID this score applies to"),
+  // Score data
+  scorerId: scorerIdField,
+  scorerVersion: scorerVersionField.nullish(),
+  source: sourceField2.nullish(),
+  score: scoreValueField,
+  reason: scoreReasonField.nullish(),
+  experimentId: experimentIdField.nullish(),
+  /** Trace ID of the scoring run (links to trace that generated this score) */
+  scoreTraceId: z.string().nullish().describe("Trace ID of the scoring run for debugging score generation"),
+  // User-defined metadata (context fields stored here)
+  metadata: z.record(z.string(), z.unknown()).nullish().describe("User-defined metadata")
+}).describe("Score record as stored in the database");
+z.object({
+  scorerId: scorerIdField,
+  scorerVersion: scorerVersionField.optional(),
+  source: sourceField2.optional(),
+  score: scoreValueField,
+  reason: scoreReasonField.optional(),
+  metadata: z.record(z.string(), z.unknown()).optional().describe("Additional scorer-specific metadata"),
+  experimentId: experimentIdField.optional(),
+  scoreTraceId: z.string().optional().describe("Trace ID of the scoring run for debugging score generation")
+}).describe("User-provided score input");
+var createScoreRecordSchema = scoreRecordSchema;
+z.object({
+  score: createScoreRecordSchema
+}).describe("Arguments for creating a score");
+var createScoreBodySchema = z.object({
+  score: createScoreRecordSchema.omit({ timestamp: true })
+}).describe("Arguments for creating a score");
+var createScoreResponseSchema = z.object({ success: z.boolean() }).describe("Response from creating a score");
+z.object({
+  scores: z.array(createScoreRecordSchema)
+}).describe("Arguments for batch recording scores");
+var scoresFilterSchema = z.object({
+  ...commonFilterFields,
+  // Score-specific filters
+  scorerId: z.union([z.string(), z.array(z.string())]).optional().describe("Filter by scorer ID(s)")
+}).describe("Filters for querying scores");
+var scoresOrderByFieldSchema = z.enum(["timestamp", "score"]).describe("Field to order by: 'timestamp' | 'score'");
+var scoresOrderBySchema = z.object({
+  field: scoresOrderByFieldSchema.default("timestamp").describe("Field to order by"),
+  direction: sortDirectionSchema.default("DESC").describe("Sort direction")
+}).describe("Order by configuration");
+z.object({
+  filters: scoresFilterSchema.optional().describe("Optional filters to apply"),
+  pagination: paginationArgsSchema.default({ page: 0, perPage: 10 }).describe("Pagination settings"),
+  orderBy: scoresOrderBySchema.default({ field: "timestamp", direction: "DESC" }).describe("Ordering configuration (defaults to timestamp desc)")
+}).describe("Arguments for listing scores");
+var listScoresResponseSchema = z.object({
+  pagination: paginationInfoSchema,
+  scores: z.array(scoreRecordSchema)
+});
+var feedbackSourceField = z.string().describe("Source of feedback (e.g., 'user', 'system', 'manual')");
+var feedbackTypeField = z.string().describe("Type of feedback (e.g., 'thumbs', 'rating', 'correction')");
+var feedbackValueField = z.union([z.number(), z.string()]).describe("Feedback value (rating number or correction text)");
+var feedbackCommentField = z.string().describe("Additional comment or context");
+var feedbackRecordSchema = z.object({
+  timestamp: z.date().describe("When the feedback was recorded"),
+  // Target
+  traceId: traceIdField,
+  spanId: spanIdField.nullish().describe("Span ID this feedback applies to"),
+  // Feedback data
+  source: feedbackSourceField,
+  feedbackType: feedbackTypeField,
+  value: feedbackValueField,
+  comment: feedbackCommentField.nullish(),
+  experimentId: experimentIdField.nullish(),
+  // Identity
+  userId: userIdField.nullish(),
+  // User-defined metadata (context fields stored here)
+  metadata: z.record(z.string(), z.unknown()).nullish().describe("User-defined metadata")
+}).describe("Feedback record as stored in the database");
+z.object({
+  source: feedbackSourceField,
+  feedbackType: feedbackTypeField,
+  value: feedbackValueField,
+  comment: feedbackCommentField.optional(),
+  userId: userIdField.optional(),
+  metadata: z.record(z.string(), z.unknown()).optional().describe("Additional feedback-specific metadata"),
+  experimentId: experimentIdField.optional()
+}).describe("User-provided feedback input");
+var createFeedbackRecordSchema = feedbackRecordSchema;
+z.object({
+  feedback: createFeedbackRecordSchema
+}).describe("Arguments for creating feedback");
+var createFeedbackBodySchema = z.object({
+  feedback: createFeedbackRecordSchema.omit({ timestamp: true })
+}).describe("Arguments for creating feedback");
+var createFeedbackResponseSchema = z.object({ success: z.boolean() }).describe("Response from creating feedback");
+z.object({
+  feedbacks: z.array(createFeedbackRecordSchema)
+}).describe("Arguments for batch recording feedback");
+var feedbackFilterSchema = z.object({
+  ...commonFilterFields,
+  // Feedback-specific filters
+  feedbackType: z.union([z.string(), z.array(z.string())]).optional().describe("Filter by feedback type(s)"),
+  source: z.string().optional().describe("Filter by feedback source (e.g., user, system, manual)")
+}).describe("Filters for querying feedback");
+var feedbackOrderByFieldSchema = z.enum(["timestamp"]).describe("Field to order by: 'timestamp'");
+var feedbackOrderBySchema = z.object({
+  field: feedbackOrderByFieldSchema.default("timestamp").describe("Field to order by"),
+  direction: sortDirectionSchema.default("DESC").describe("Sort direction")
+}).describe("Order by configuration");
+z.object({
+  filters: feedbackFilterSchema.optional().describe("Optional filters to apply"),
+  pagination: paginationArgsSchema.default({ page: 0, perPage: 10 }).describe("Pagination settings"),
+  orderBy: feedbackOrderBySchema.default({ field: "timestamp", direction: "DESC" }).describe("Ordering configuration (defaults to timestamp desc)")
+}).describe("Arguments for listing feedback");
+var listFeedbackResponseSchema = z.object({
+  pagination: paginationInfoSchema,
+  feedback: z.array(feedbackRecordSchema)
+});
+z.enum(["counter", "gauge", "histogram"]);
+var metricNameField = z.string().describe("Metric name (e.g., mastra_agent_duration_ms)");
+var metricValueField = z.number().describe("Metric value");
+var labelsField = z.record(z.string(), z.string()).describe("Metric labels for dimensional filtering");
+var metricRecordSchema = z.object({
+  timestamp: z.date().describe("When the metric was recorded"),
+  name: metricNameField,
+  value: metricValueField.describe("Single observation value"),
+  labels: labelsField.default({}),
+  // Correlation
+  traceId: traceIdField.nullish(),
+  spanId: spanIdField.nullish(),
+  // Context (entity hierarchy, identity, correlation, deployment, experimentation)
+  ...contextFields,
+  // User-defined metadata
+  metadata: z.record(z.string(), z.unknown()).nullish().describe("User-defined metadata")
+}).describe("Metric record as stored in the database");
+z.object({
+  name: metricNameField,
+  value: metricValueField,
+  labels: labelsField.optional()
+}).describe("User-provided metric input");
+var createMetricRecordSchema = metricRecordSchema;
+z.object({
+  metrics: z.array(createMetricRecordSchema)
+}).describe("Arguments for batch recording metrics");
+var aggregationTypeSchema = z.enum(["sum", "avg", "min", "max", "count", "last"]);
+var aggregationIntervalSchema = z.enum(["1m", "5m", "15m", "1h", "1d"]);
+z.object({
+  type: aggregationTypeSchema.describe("Aggregation function"),
+  interval: aggregationIntervalSchema.optional().describe("Time bucket interval"),
+  groupBy: z.array(z.string()).optional().describe("Label keys to group by")
+}).describe("Metrics aggregation configuration");
+var metricsFilterSchema = z.object({
+  ...commonFilterFields,
+  // Metric identification
+  name: z.array(z.string()).nonempty().optional().describe("Filter by metric name(s)"),
+  // Parent/root entity filters
+  parentEntityType: parentEntityTypeField.optional(),
+  parentEntityName: parentEntityNameField.optional(),
+  rootEntityType: rootEntityTypeField.optional(),
+  rootEntityName: rootEntityNameField.optional(),
+  // Correlation ID filters
+  runId: runIdField.optional(),
+  sessionId: sessionIdField.optional(),
+  // Label filters (exact match on label values)
+  labels: z.record(z.string(), z.string()).optional().describe("Exact match on label key-value pairs")
+}).describe("Filters for querying metrics");
+var comparePeriodSchema = z.enum(["previous_period", "previous_day", "previous_week"]).describe("Comparison period for aggregate queries");
+var getMetricAggregateArgsSchema = z.object({
+  name: z.array(z.string()).nonempty().describe("Metric name(s) to aggregate"),
+  aggregation: aggregationTypeSchema.describe("Aggregation function"),
+  filters: metricsFilterSchema.optional().describe("Optional filters"),
+  comparePeriod: comparePeriodSchema.optional().describe("Optional comparison period")
+}).describe("Arguments for getting a metric aggregate");
+var getMetricAggregateResponseSchema = z.object({
+  value: z.number().nullable().describe("Aggregated value"),
+  previousValue: z.number().nullable().optional().describe("Value from comparison period"),
+  changePercent: z.number().nullable().optional().describe("Percentage change from comparison period")
+});
+var getMetricBreakdownArgsSchema = z.object({
+  name: z.array(z.string()).nonempty().describe("Metric name(s) to break down"),
+  groupBy: z.array(z.string()).min(1).describe("Fields to group by"),
+  aggregation: aggregationTypeSchema.describe("Aggregation function"),
+  filters: metricsFilterSchema.optional().describe("Optional filters")
+}).describe("Arguments for getting a metric breakdown");
+var getMetricBreakdownResponseSchema = z.object({
+  groups: z.array(
+    z.object({
+      dimensions: z.record(z.string(), z.string().nullable()).describe("Dimension values for this group"),
+      value: z.number().describe("Aggregated value for this group")
+    })
+  )
+});
+var getMetricTimeSeriesArgsSchema = z.object({
+  name: z.array(z.string()).nonempty().describe("Metric name(s)"),
+  interval: aggregationIntervalSchema.describe("Time bucket interval"),
+  aggregation: aggregationTypeSchema.describe("Aggregation function"),
+  filters: metricsFilterSchema.optional().describe("Optional filters"),
+  groupBy: z.array(z.string()).optional().describe("Optional fields to group by")
+}).describe("Arguments for getting metric time series");
+var getMetricTimeSeriesResponseSchema = z.object({
+  series: z.array(
+    z.object({
+      name: z.string().describe("Series name (metric name or group key)"),
+      points: z.array(
+        z.object({
+          timestamp: z.date().describe("Bucket timestamp"),
+          value: z.number().describe("Aggregated value")
+        })
+      )
+    })
+  )
+});
+var getMetricPercentilesArgsSchema = z.object({
+  name: z.string().describe("Metric name"),
+  percentiles: z.array(z.number().min(0).max(1)).describe("Percentile values (0-1)"),
+  interval: aggregationIntervalSchema.describe("Time bucket interval"),
+  filters: metricsFilterSchema.optional().describe("Optional filters")
+}).describe("Arguments for getting metric percentiles");
+var getMetricPercentilesResponseSchema = z.object({
+  series: z.array(
+    z.object({
+      percentile: z.number().describe("Percentile value"),
+      points: z.array(
+        z.object({
+          timestamp: z.date().describe("Bucket timestamp"),
+          value: z.number().describe("Percentile value at this bucket")
+        })
+      )
+    })
+  )
+});
+var getMetricNamesArgsSchema = z.object({
+  prefix: z.string().optional().describe("Filter metric names by prefix"),
+  limit: z.number().int().min(1).optional().describe("Maximum number of names to return")
+}).describe("Arguments for getting metric names");
+var getMetricNamesResponseSchema = z.object({
+  names: z.array(z.string()).describe("Distinct metric names")
+});
+var getMetricLabelKeysArgsSchema = z.object({
+  metricName: z.string().describe("Metric name to get label keys for")
+}).describe("Arguments for getting metric label keys");
+var getMetricLabelKeysResponseSchema = z.object({
+  keys: z.array(z.string()).describe("Distinct label keys for the metric")
+});
+var getMetricLabelValuesArgsSchema = z.object({
+  metricName: z.string().describe("Metric name"),
+  labelKey: z.string().describe("Label key to get values for"),
+  prefix: z.string().optional().describe("Filter values by prefix"),
+  limit: z.number().int().min(1).optional().describe("Maximum number of values to return")
+}).describe("Arguments for getting label values");
+var getMetricLabelValuesResponseSchema = z.object({
+  values: z.array(z.string()).describe("Distinct label values")
+});
+z.object({}).describe("Arguments for getting entity types");
+var getEntityTypesResponseSchema = z.object({
+  entityTypes: z.array(entityTypeField).describe("Distinct entity types")
+});
+var getEntityNamesArgsSchema = z.object({
+  entityType: entityTypeField.optional().describe("Optional entity type filter")
+}).describe("Arguments for getting entity names");
+var getEntityNamesResponseSchema = z.object({
+  names: z.array(z.string()).describe("Distinct entity names")
+});
+z.object({}).describe("Arguments for getting service names");
+var getServiceNamesResponseSchema = z.object({
+  serviceNames: z.array(z.string()).describe("Distinct service names")
+});
+z.object({}).describe("Arguments for getting environments");
+var getEnvironmentsResponseSchema = z.object({
+  environments: z.array(z.string()).describe("Distinct environments")
+});
+var getTagsArgsSchema = z.object({
+  entityType: entityTypeField.optional().describe("Optional entity type filter")
+}).describe("Arguments for getting tags");
+var getTagsResponseSchema = z.object({
+  tags: z.array(z.string()).describe("Distinct tags")
+});
+function createNewRoute(def, config) {
+  const { handler, ...schemas } = config;
+  return createRoute({
+    ...def,
+    ...schemas,
+    responseType: "json",
+    tags: ["Observability"],
+    requiresAuth: true,
+    handler: (async (params) => {
+      if (!coreFeatures.has("observability:v1.13.2")) {
+        throw new HTTPException(501, {
+          message: "New observability endpoints require @mastra/core >= 1.13.3, please upgrade."
+        });
+      }
+      try {
+        return await handler(params);
+      } catch (error) {
+        return handleError(error, `Error calling: '${def.summary.toLocaleLowerCase()}'`);
+      }
+    })
+  });
+}
+var LIST_LOGS = createNewRoute(NEW_ROUTE_DEFS.LIST_LOGS, {
+  queryParamSchema: wrapSchemaForQueryParams(
+    logsFilterSchema.extend(paginationArgsSchema.shape).extend(logsOrderBySchema.shape).partial()
+  ),
+  responseSchema: listLogsResponseSchema,
+  handler: async ({ mastra, ...params }) => {
+    const filters = pickParams(logsFilterSchema, params);
+    const pagination = pickParams(paginationArgsSchema, params);
+    const orderBy = pickParams(logsOrderBySchema, params);
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.listLogs({ filters, pagination, orderBy });
+  }
+});
+var LIST_SCORES = createNewRoute(NEW_ROUTE_DEFS.LIST_SCORES, {
+  queryParamSchema: wrapSchemaForQueryParams(
+    scoresFilterSchema.extend(paginationArgsSchema.shape).extend(scoresOrderBySchema.shape).partial()
+  ),
+  responseSchema: listScoresResponseSchema,
+  handler: async ({ mastra, ...params }) => {
+    const filters = pickParams(scoresFilterSchema, params);
+    const pagination = pickParams(paginationArgsSchema, params);
+    const orderBy = pickParams(scoresOrderBySchema, params);
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.listScores({ filters, pagination, orderBy });
+  }
+});
+var CREATE_SCORE = createNewRoute(NEW_ROUTE_DEFS.CREATE_SCORE, {
+  bodySchema: createScoreBodySchema,
+  responseSchema: createScoreResponseSchema,
+  handler: async ({ mastra, score }) => {
+    const observabilityStore = await getObservabilityStore(mastra);
+    await observabilityStore.createScore({ score: { ...score, timestamp: /* @__PURE__ */ new Date() } });
+    return { success: true };
+  }
+});
+var LIST_FEEDBACK = createNewRoute(NEW_ROUTE_DEFS.LIST_FEEDBACK, {
+  queryParamSchema: wrapSchemaForQueryParams(
+    feedbackFilterSchema.extend(paginationArgsSchema.shape).extend(feedbackOrderBySchema.shape).partial()
+  ),
+  responseSchema: listFeedbackResponseSchema,
+  handler: async ({ mastra, ...params }) => {
+    const filters = pickParams(feedbackFilterSchema, params);
+    const pagination = pickParams(paginationArgsSchema, params);
+    const orderBy = pickParams(feedbackOrderBySchema, params);
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.listFeedback({ filters, pagination, orderBy });
+  }
+});
+var CREATE_FEEDBACK = createNewRoute(NEW_ROUTE_DEFS.CREATE_FEEDBACK, {
+  bodySchema: createFeedbackBodySchema,
+  responseSchema: createFeedbackResponseSchema,
+  handler: async ({ mastra, feedback }) => {
+    const observabilityStore = await getObservabilityStore(mastra);
+    await observabilityStore.createFeedback({ feedback: { ...feedback, timestamp: /* @__PURE__ */ new Date() } });
+    return { success: true };
+  }
+});
+var GET_METRIC_AGGREGATE = createNewRoute(NEW_ROUTE_DEFS.GET_METRIC_AGGREGATE, {
+  bodySchema: getMetricAggregateArgsSchema,
+  responseSchema: getMetricAggregateResponseSchema,
+  handler: async ({ mastra, ...params }) => {
+    const args = pickParams(getMetricAggregateArgsSchema, params);
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.getMetricAggregate(args);
+  }
+});
+var GET_METRIC_BREAKDOWN = createNewRoute(NEW_ROUTE_DEFS.GET_METRIC_BREAKDOWN, {
+  bodySchema: getMetricBreakdownArgsSchema,
+  responseSchema: getMetricBreakdownResponseSchema,
+  handler: async ({ mastra, ...params }) => {
+    const args = pickParams(getMetricBreakdownArgsSchema, params);
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.getMetricBreakdown(args);
+  }
+});
+var GET_METRIC_TIME_SERIES = createNewRoute(NEW_ROUTE_DEFS.GET_METRIC_TIME_SERIES, {
+  bodySchema: getMetricTimeSeriesArgsSchema,
+  responseSchema: getMetricTimeSeriesResponseSchema,
+  handler: async ({ mastra, ...params }) => {
+    const args = pickParams(getMetricTimeSeriesArgsSchema, params);
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.getMetricTimeSeries(args);
+  }
+});
+var GET_METRIC_PERCENTILES = createNewRoute(NEW_ROUTE_DEFS.GET_METRIC_PERCENTILES, {
+  bodySchema: getMetricPercentilesArgsSchema,
+  responseSchema: getMetricPercentilesResponseSchema,
+  handler: async ({ mastra, ...params }) => {
+    const args = pickParams(getMetricPercentilesArgsSchema, params);
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.getMetricPercentiles(args);
+  }
+});
+var GET_METRIC_NAMES = createNewRoute(NEW_ROUTE_DEFS.GET_METRIC_NAMES, {
+  queryParamSchema: wrapSchemaForQueryParams(getMetricNamesArgsSchema.partial()),
+  responseSchema: getMetricNamesResponseSchema,
+  handler: async ({ mastra, ...params }) => {
+    const args = getMetricNamesArgsSchema.parse(pickParams(getMetricNamesArgsSchema, params));
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.getMetricNames(args);
+  }
+});
+var GET_METRIC_LABEL_KEYS = createNewRoute(NEW_ROUTE_DEFS.GET_METRIC_LABEL_KEYS, {
+  queryParamSchema: wrapSchemaForQueryParams(getMetricLabelKeysArgsSchema),
+  responseSchema: getMetricLabelKeysResponseSchema,
+  handler: async ({ mastra, ...params }) => {
+    const args = getMetricLabelKeysArgsSchema.parse(pickParams(getMetricLabelKeysArgsSchema, params));
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.getMetricLabelKeys(args);
+  }
+});
+var GET_METRIC_LABEL_VALUES = createNewRoute(NEW_ROUTE_DEFS.GET_METRIC_LABEL_VALUES, {
+  queryParamSchema: wrapSchemaForQueryParams(getMetricLabelValuesArgsSchema),
+  responseSchema: getMetricLabelValuesResponseSchema,
+  handler: async ({ mastra, ...params }) => {
+    const args = getMetricLabelValuesArgsSchema.parse(pickParams(getMetricLabelValuesArgsSchema, params));
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.getMetricLabelValues(args);
+  }
+});
+var GET_ENTITY_TYPES = createNewRoute(NEW_ROUTE_DEFS.GET_ENTITY_TYPES, {
+  responseSchema: getEntityTypesResponseSchema,
+  handler: async ({ mastra }) => {
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.getEntityTypes({});
+  }
+});
+var GET_ENTITY_NAMES = createNewRoute(NEW_ROUTE_DEFS.GET_ENTITY_NAMES, {
+  queryParamSchema: wrapSchemaForQueryParams(getEntityNamesArgsSchema.partial()),
+  responseSchema: getEntityNamesResponseSchema,
+  handler: async ({ mastra, ...params }) => {
+    const args = getEntityNamesArgsSchema.parse(pickParams(getEntityNamesArgsSchema, params));
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.getEntityNames(args);
+  }
+});
+var GET_SERVICE_NAMES = createNewRoute(NEW_ROUTE_DEFS.GET_SERVICE_NAMES, {
+  responseSchema: getServiceNamesResponseSchema,
+  handler: async ({ mastra }) => {
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.getServiceNames({});
+  }
+});
+var GET_ENVIRONMENTS = createNewRoute(NEW_ROUTE_DEFS.GET_ENVIRONMENTS, {
+  responseSchema: getEnvironmentsResponseSchema,
+  handler: async ({ mastra }) => {
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.getEnvironments({});
+  }
+});
+var GET_TAGS = createNewRoute(NEW_ROUTE_DEFS.GET_TAGS, {
+  queryParamSchema: wrapSchemaForQueryParams(getTagsArgsSchema.partial()),
+  responseSchema: getTagsResponseSchema,
+  handler: async ({ mastra, ...params }) => {
+    const args = getTagsArgsSchema.parse(pickParams(getTagsArgsSchema, params));
+    const observabilityStore = await getObservabilityStore(mastra);
+    return await observabilityStore.getTags(args);
+  }
+});
+var NEW_ROUTES = {
+  LIST_LOGS,
+  LIST_SCORES,
+  CREATE_SCORE,
+  LIST_FEEDBACK,
+  CREATE_FEEDBACK,
+  GET_METRIC_AGGREGATE,
+  GET_METRIC_BREAKDOWN,
+  GET_METRIC_TIME_SERIES,
+  GET_METRIC_PERCENTILES,
+  GET_METRIC_NAMES,
+  GET_METRIC_LABEL_KEYS,
+  GET_METRIC_LABEL_VALUES,
+  GET_ENTITY_TYPES,
+  GET_ENTITY_NAMES,
+  GET_SERVICE_NAMES,
+  GET_ENVIRONMENTS,
+  GET_TAGS
+};
+
+export { CREATE_FEEDBACK, CREATE_SCORE, GET_ENTITY_NAMES, GET_ENTITY_TYPES, GET_ENVIRONMENTS, GET_METRIC_AGGREGATE, GET_METRIC_BREAKDOWN, GET_METRIC_LABEL_KEYS, GET_METRIC_LABEL_VALUES, GET_METRIC_NAMES, GET_METRIC_PERCENTILES, GET_METRIC_TIME_SERIES, GET_SERVICE_NAMES, GET_TAGS, LIST_FEEDBACK, LIST_LOGS, LIST_SCORES, NEW_ROUTES };
+//# sourceMappingURL=chunk-4VGZOVOI.js.map
+//# sourceMappingURL=chunk-4VGZOVOI.js.map