@mastra/core 1.13.3-alpha.1 → 1.14.0-alpha.2

package/dist/chunk-GVQJCS5O.js

@@ -0,0 +1,812 @@
+import { z } from 'zod/v4';
+
+// src/observability/types/core.ts
+var SamplingStrategyType = /* @__PURE__ */ ((SamplingStrategyType2) => {
+  SamplingStrategyType2["ALWAYS"] = "always";
+  SamplingStrategyType2["NEVER"] = "never";
+  SamplingStrategyType2["RATIO"] = "ratio";
+  SamplingStrategyType2["CUSTOM"] = "custom";
+  return SamplingStrategyType2;
+})(SamplingStrategyType || {});
+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 || {});
+var createdAtField = z.date().describe("Database record creation time");
+var updatedAtField = z.date().describe("Database record last update time");
+var dbTimestamps = {
+  createdAt: createdAtField,
+  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");
+var logRecordInputSchema = z.object({
+  level: logLevelSchema,
+  message: messageField,
+  data: logDataField.optional(),
+  tags: tagsField.optional()
+}).describe("User-provided log input");
+var createLogRecordSchema = logRecordSchema;
+var batchCreateLogsArgsSchema = 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");
+var listLogsArgsSchema = 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");
+var scoreInputSchema = 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;
+var createScoreArgsSchema = 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");
+var batchCreateScoresArgsSchema = 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");
+var listScoresArgsSchema = 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");
+var feedbackInputSchema = 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;
+var createFeedbackArgsSchema = 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");
+var batchCreateFeedbackArgsSchema = 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");
+var listFeedbackArgsSchema = 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)
+});
+var metricTypeSchema = 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");
+var metricInputSchema = z.object({
+  name: metricNameField,
+  value: metricValueField,
+  labels: labelsField.optional()
+}).describe("User-provided metric input");
+var createMetricRecordSchema = metricRecordSchema;
+var batchCreateMetricsArgsSchema = 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"]);
+var metricsAggregationSchema = 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")
+});
+var getEntityTypesArgsSchema = 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")
+});
+var getServiceNamesArgsSchema = z.object({}).describe("Arguments for getting service names");
+var getServiceNamesResponseSchema = z.object({
+  serviceNames: z.array(z.string()).describe("Distinct service names")
+});
+var getEnvironmentsArgsSchema = 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")
+});
+
+// src/observability/types/tracing.ts
+var SpanType = /* @__PURE__ */ ((SpanType2) => {
+  SpanType2["AGENT_RUN"] = "agent_run";
+  SpanType2["GENERIC"] = "generic";
+  SpanType2["MODEL_GENERATION"] = "model_generation";
+  SpanType2["MODEL_STEP"] = "model_step";
+  SpanType2["MODEL_CHUNK"] = "model_chunk";
+  SpanType2["MCP_TOOL_CALL"] = "mcp_tool_call";
+  SpanType2["PROCESSOR_RUN"] = "processor_run";
+  SpanType2["TOOL_CALL"] = "tool_call";
+  SpanType2["WORKFLOW_RUN"] = "workflow_run";
+  SpanType2["WORKFLOW_STEP"] = "workflow_step";
+  SpanType2["WORKFLOW_CONDITIONAL"] = "workflow_conditional";
+  SpanType2["WORKFLOW_CONDITIONAL_EVAL"] = "workflow_conditional_eval";
+  SpanType2["WORKFLOW_PARALLEL"] = "workflow_parallel";
+  SpanType2["WORKFLOW_LOOP"] = "workflow_loop";
+  SpanType2["WORKFLOW_SLEEP"] = "workflow_sleep";
+  SpanType2["WORKFLOW_WAIT_EVENT"] = "workflow_wait_event";
+  return SpanType2;
+})(SpanType || {});
+var InternalSpans = /* @__PURE__ */ ((InternalSpans2) => {
+  InternalSpans2[InternalSpans2["NONE"] = 0] = "NONE";
+  InternalSpans2[InternalSpans2["WORKFLOW"] = 1] = "WORKFLOW";
+  InternalSpans2[InternalSpans2["AGENT"] = 2] = "AGENT";
+  InternalSpans2[InternalSpans2["TOOL"] = 4] = "TOOL";
+  InternalSpans2[InternalSpans2["MODEL"] = 8] = "MODEL";
+  InternalSpans2[InternalSpans2["ALL"] = 15] = "ALL";
+  return InternalSpans2;
+})(InternalSpans || {});
+var TracingEventType = /* @__PURE__ */ ((TracingEventType2) => {
+  TracingEventType2["SPAN_STARTED"] = "span_started";
+  TracingEventType2["SPAN_UPDATED"] = "span_updated";
+  TracingEventType2["SPAN_ENDED"] = "span_ended";
+  return TracingEventType2;
+})(TracingEventType || {});
+
+// src/observability/types/metrics.ts
+var DEFAULT_BLOCKED_LABELS = [
+  "trace_id",
+  "span_id",
+  "run_id",
+  "request_id",
+  "user_id",
+  "resource_id",
+  "session_id",
+  "thread_id"
+];
+
+// src/observability/no-op.ts
+var noOpCounter = {
+  add() {
+  }
+};
+var noOpGauge = {
+  set() {
+  }
+};
+var noOpHistogram = {
+  record() {
+  }
+};
+var noOpTracingContext = {
+  currentSpan: void 0
+};
+var noOpLoggerContext = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  },
+  fatal() {
+  }
+};
+var noOpMetricsContext = {
+  emit() {
+  },
+  counter() {
+    return noOpCounter;
+  },
+  gauge() {
+    return noOpGauge;
+  },
+  histogram() {
+    return noOpHistogram;
+  }
+};
+var NoOpObservability = class {
+  setMastraContext(_options) {
+    return;
+  }
+  setLogger(_options) {
+    return;
+  }
+  getSelectedInstance(_options) {
+    return;
+  }
+  registerInstance(_name, _instance, _isDefault = false) {
+    return;
+  }
+  getInstance(_name) {
+    return;
+  }
+  getDefaultInstance() {
+    return;
+  }
+  listInstances() {
+    return /* @__PURE__ */ new Map();
+  }
+  unregisterInstance(_name) {
+    return false;
+  }
+  hasInstance(_name) {
+    return false;
+  }
+  setConfigSelector(_selector) {
+    return;
+  }
+  clear() {
+    return;
+  }
+  async shutdown() {
+    return;
+  }
+};
+
+// src/observability/utils.ts
+function getOrCreateSpan(options) {
+  const { type, attributes, tracingContext, requestContext, tracingOptions, ...rest } = options;
+  const metadata = {
+    ...rest.metadata ?? {},
+    ...tracingOptions?.metadata ?? {}
+  };
+  if (tracingContext?.currentSpan) {
+    return tracingContext.currentSpan.createChildSpan({
+      type,
+      attributes,
+      ...rest,
+      metadata,
+      requestContext
+    });
+  }
+  const instance = options.mastra?.observability?.getSelectedInstance({ requestContext });
+  return instance?.startSpan({
+    type,
+    attributes,
+    ...rest,
+    metadata,
+    requestContext,
+    tracingOptions,
+    traceId: tracingOptions?.traceId,
+    parentSpanId: tracingOptions?.parentSpanId,
+    customSamplerOptions: {
+      requestContext,
+      metadata
+    }
+  });
+}
+async function executeWithContext(params) {
+  const { span, fn } = params;
+  if (span?.executeInContext) {
+    return span.executeInContext(fn);
+  }
+  return fn();
+}
+function executeWithContextSync(params) {
+  const { span, fn } = params;
+  if (span?.executeInContextSync) {
+    return span.executeInContextSync(fn);
+  }
+  return fn();
+}
+
+// src/observability/context-factory.ts
+function deriveLoggerContext(tracing) {
+  const span = tracing.currentSpan;
+  return span?.observabilityInstance?.getLoggerContext?.(span) ?? noOpLoggerContext;
+}
+function deriveMetricsContext(tracing) {
+  const span = tracing.currentSpan;
+  return span?.observabilityInstance?.getMetricsContext?.(span) ?? noOpMetricsContext;
+}
+function createObservabilityContext(tracingContext) {
+  const tracing = tracingContext ?? noOpTracingContext;
+  return {
+    tracing,
+    loggerVNext: deriveLoggerContext(tracing),
+    metrics: deriveMetricsContext(tracing),
+    tracingContext: tracing
+    // alias — preferred at forwarding sites
+  };
+}
+function resolveObservabilityContext(partial) {
+  const tracing = partial.tracing ?? partial.tracingContext ?? noOpTracingContext;
+  return {
+    tracing,
+    loggerVNext: partial.loggerVNext ?? deriveLoggerContext(tracing),
+    metrics: partial.metrics ?? deriveMetricsContext(tracing),
+    tracingContext: tracing
+    // alias — preferred at forwarding sites
+  };
+}
+
+// src/observability/context.ts
+var AGENT_GETTERS = ["getAgent", "getAgentById"];
+var AGENT_METHODS_TO_WRAP = ["generate", "stream", "generateLegacy", "streamLegacy"];
+var WORKFLOW_GETTERS = ["getWorkflow", "getWorkflowById"];
+var WORKFLOW_METHODS_TO_WRAP = ["execute", "createRun", "createRun"];
+function isNoOpSpan(span) {
+  return span.constructor.name === "NoOpSpan" || span.__isNoOp === true;
+}
+function isMastra(mastra) {
+  const hasAgentGetters = AGENT_GETTERS.every((method) => typeof mastra?.[method] === "function");
+  const hasWorkflowGetters = WORKFLOW_GETTERS.every((method) => typeof mastra?.[method] === "function");
+  return hasAgentGetters && hasWorkflowGetters;
+}
+function wrapMastra(mastra, tracingContext) {
+  if (!tracingContext.currentSpan || isNoOpSpan(tracingContext.currentSpan)) {
+    return mastra;
+  }
+  if (!isMastra(mastra)) {
+    return mastra;
+  }
+  try {
+    return new Proxy(mastra, {
+      get(target, prop) {
+        try {
+          if (AGENT_GETTERS.includes(prop)) {
+            return (...args) => {
+              const agent = target[prop](...args);
+              return wrapAgent(agent, tracingContext);
+            };
+          }
+          if (WORKFLOW_GETTERS.includes(prop)) {
+            return (...args) => {
+              const workflow = target[prop](...args);
+              return wrapWorkflow(workflow, tracingContext);
+            };
+          }
+          const value = target[prop];
+          return typeof value === "function" ? value.bind(target) : value;
+        } catch (error) {
+          console.warn("Tracing: Failed to wrap method, falling back to original", error);
+          const value = target[prop];
+          return typeof value === "function" ? value.bind(target) : value;
+        }
+      }
+    });
+  } catch (error) {
+    console.warn("Tracing: Failed to create proxy, using original Mastra instance", error);
+    return mastra;
+  }
+}
+function wrapAgent(agent, tracingContext) {
+  if (!tracingContext.currentSpan || isNoOpSpan(tracingContext.currentSpan)) {
+    return agent;
+  }
+  try {
+    return new Proxy(agent, {
+      get(target, prop) {
+        try {
+          if (AGENT_METHODS_TO_WRAP.includes(prop)) {
+            return (input, options = {}) => {
+              return target[prop](input, {
+                ...options,
+                ...createObservabilityContext(tracingContext)
+              });
+            };
+          }
+          const value = target[prop];
+          return typeof value === "function" ? value.bind(target) : value;
+        } catch (error) {
+          console.warn("Tracing: Failed to wrap agent method, falling back to original", error);
+          const value = target[prop];
+          return typeof value === "function" ? value.bind(target) : value;
+        }
+      }
+    });
+  } catch (error) {
+    console.warn("Tracing: Failed to create agent proxy, using original instance", error);
+    return agent;
+  }
+}
+function wrapWorkflow(workflow, tracingContext) {
+  if (!tracingContext.currentSpan || isNoOpSpan(tracingContext.currentSpan)) {
+    return workflow;
+  }
+  try {
+    return new Proxy(workflow, {
+      get(target, prop) {
+        try {
+          if (WORKFLOW_METHODS_TO_WRAP.includes(prop)) {
+            if (prop === "createRun" || prop === "createRun") {
+              return async (options = {}) => {
+                const run = await target[prop](options);
+                return run ? wrapRun(run, tracingContext) : run;
+              };
+            }
+            return (input, options = {}) => {
+              return target[prop](input, {
+                ...options,
+                ...createObservabilityContext(tracingContext)
+              });
+            };
+          }
+          const value = target[prop];
+          return typeof value === "function" ? value.bind(target) : value;
+        } catch (error) {
+          console.warn("Tracing: Failed to wrap workflow method, falling back to original", error);
+          const value = target[prop];
+          return typeof value === "function" ? value.bind(target) : value;
+        }
+      }
+    });
+  } catch (error) {
+    console.warn("Tracing: Failed to create workflow proxy, using original instance", error);
+    return workflow;
+  }
+}
+function wrapRun(run, tracingContext) {
+  if (!tracingContext.currentSpan || isNoOpSpan(tracingContext.currentSpan)) {
+    return run;
+  }
+  try {
+    return new Proxy(run, {
+      get(target, prop) {
+        try {
+          if (prop === "start") {
+            return (startOptions = {}) => {
+              return target.start({
+                ...startOptions,
+                ...createObservabilityContext(startOptions.tracingContext ?? tracingContext)
+              });
+            };
+          }
+          const value = target[prop];
+          return typeof value === "function" ? value.bind(target) : value;
+        } catch (error) {
+          console.warn("Tracing: Failed to wrap run method, falling back to original", error);
+          const value = target[prop];
+          return typeof value === "function" ? value.bind(target) : value;
+        }
+      }
+    });
+  } catch (error) {
+    console.warn("Tracing: Failed to create run proxy, using original instance", error);
+    return run;
+  }
+}
+
+export { DEFAULT_BLOCKED_LABELS, EntityType, InternalSpans, NoOpObservability, SamplingStrategyType, SpanType, TracingEventType, aggregationIntervalSchema, aggregationTypeSchema, batchCreateFeedbackArgsSchema, batchCreateLogsArgsSchema, batchCreateMetricsArgsSchema, batchCreateScoresArgsSchema, commonFilterFields, comparePeriodSchema, contextFields, createFeedbackArgsSchema, createFeedbackBodySchema, createFeedbackRecordSchema, createFeedbackResponseSchema, createLogRecordSchema, createMetricRecordSchema, createObservabilityContext, createScoreArgsSchema, createScoreBodySchema, createScoreRecordSchema, createScoreResponseSchema, createdAtField, dateRangeSchema, dbTimestamps, entityIdField, entityNameField, entityTypeField, environmentField, executeWithContext, executeWithContextSync, experimentIdField, feedbackFilterSchema, feedbackInputSchema, feedbackOrderByFieldSchema, feedbackOrderBySchema, feedbackRecordSchema, getEntityNamesArgsSchema, getEntityNamesResponseSchema, getEntityTypesArgsSchema, getEntityTypesResponseSchema, getEnvironmentsArgsSchema, getEnvironmentsResponseSchema, getMetricAggregateArgsSchema, getMetricAggregateResponseSchema, getMetricBreakdownArgsSchema, getMetricBreakdownResponseSchema, getMetricLabelKeysArgsSchema, getMetricLabelKeysResponseSchema, getMetricLabelValuesArgsSchema, getMetricLabelValuesResponseSchema, getMetricNamesArgsSchema, getMetricNamesResponseSchema, getMetricPercentilesArgsSchema, getMetricPercentilesResponseSchema, getMetricTimeSeriesArgsSchema, getMetricTimeSeriesResponseSchema, getOrCreateSpan, getServiceNamesArgsSchema, getServiceNamesResponseSchema, getTagsArgsSchema, getTagsResponseSchema, listFeedbackArgsSchema, listFeedbackResponseSchema, listLogsArgsSchema, listLogsResponseSchema, listScoresArgsSchema, listScoresResponseSchema, logLevelSchema, logRecordInputSchema, logRecordSchema, logsFilterSchema, logsOrderByFieldSchema, logsOrderBySchema, metadataField, metricInputSchema, metricRecordSchema, metricTypeSchema, metricsAggregationSchema, metricsFilterSchema, noOpLoggerContext, noOpMetricsContext, noOpTracingContext, organizationIdField, paginationArgsSchema, paginationInfoSchema, parentEntityIdField, parentEntityNameField, parentEntityTypeField, requestIdField, resolveObservabilityContext, resourceIdField, rootEntityIdField, rootEntityNameField, rootEntityTypeField, runIdField, scopeField, scoreInputSchema, scoreRecordSchema, scoresFilterSchema, scoresOrderByFieldSchema, scoresOrderBySchema, serviceNameField, sessionIdField, sortDirectionSchema, sourceField, spanIdField, tagsField, threadIdField, traceIdField, updatedAtField, userIdField, wrapMastra };
+//# sourceMappingURL=chunk-GVQJCS5O.js.map
+//# sourceMappingURL=chunk-GVQJCS5O.js.map