@mastra/duckdb 1.1.0-alpha.2 → 1.1.0

package/dist/{observability-AMG7NSKE.cjs → observability-XVQ3ST7G.cjs}

@@ -568,6 +568,187 @@ function parseJsonArray(value) {
 }
 
 // src/storage/domains/observability/feedback.ts
+var FEEDBACK_GROUP_BY_COLUMNS = /* @__PURE__ */ new Set([
+  "timestamp",
+  "traceId",
+  "spanId",
+  "experimentId",
+  "entityType",
+  "entityId",
+  "entityName",
+  "parentEntityType",
+  "parentEntityId",
+  "parentEntityName",
+  "rootEntityType",
+  "rootEntityId",
+  "rootEntityName",
+  "userId",
+  "organizationId",
+  "resourceId",
+  "runId",
+  "sessionId",
+  "threadId",
+  "requestId",
+  "environment",
+  "executionSource",
+  "serviceName",
+  "feedbackUserId",
+  "sourceId",
+  "feedbackSource",
+  "feedbackType",
+  "value",
+  "comment"
+]);
+function getAggregationSql(aggregation, measure = "TRY_CAST(value AS DOUBLE)") {
+  switch (aggregation) {
+    case "sum":
+      return `SUM(${measure})`;
+    case "avg":
+      return `AVG(${measure})`;
+    case "min":
+      return `MIN(${measure})`;
+    case "max":
+      return `MAX(${measure})`;
+    case "count":
+      return `CAST(COUNT(${measure}) AS DOUBLE)`;
+    case "last":
+      return `arg_max(${measure}, timestamp)`;
+    default:
+      return `SUM(${measure})`;
+  }
+}
+function getIntervalSql(interval) {
+  switch (interval) {
+    case "1m":
+      return "1 minute";
+    case "5m":
+      return "5 minutes";
+    case "15m":
+      return "15 minutes";
+    case "1h":
+      return "1 hour";
+    case "1d":
+      return "1 day";
+    default:
+      return "1 hour";
+  }
+}
+function getValidatedPercentiles(percentiles) {
+  if (!Array.isArray(percentiles) || percentiles.length === 0) {
+    throw new Error("Percentiles must include at least one value between 0 and 1.");
+  }
+  return percentiles.map((percentile) => {
+    if (!Number.isFinite(percentile) || percentile < 0 || percentile > 1) {
+      throw new Error("Percentiles must be finite numbers between 0 and 1.");
+    }
+    return percentile;
+  });
+}
+function buildFeedbackWhereClause(args, includeNumericGuard = false) {
+  const conditions = ["feedbackType = ?"];
+  const params = [args.feedbackType];
+  if (args.feedbackSource !== void 0) {
+    conditions.push("feedbackSource = ?");
+    params.push(args.feedbackSource);
+  }
+  const { clause: filterClause, params: filterParams } = buildWhereClause(
+    args.filters,
+    { source: "feedbackSource" }
+  );
+  if (filterClause) {
+    conditions.push(filterClause.replace("WHERE ", ""));
+    params.push(...filterParams);
+  }
+  if (includeNumericGuard) {
+    conditions.push("TRY_CAST(value AS DOUBLE) IS NOT NULL");
+  }
+  return { clause: `WHERE ${conditions.join(" AND ")}`, params };
+}
+function resolveFeedbackGroupBy(groupBy) {
+  return groupBy.map((key, index) => {
+    const column = utils.parseFieldKey(key);
+    if (!FEEDBACK_GROUP_BY_COLUMNS.has(column)) {
+      throw new Error(`Invalid groupBy column(s): ${key}`);
+    }
+    const alias = `group_by_${index}`;
+    return {
+      key,
+      selectSql: `${column} AS ${alias}`,
+      groupSql: alias
+    };
+  });
+}
+function toSeriesName(values) {
+  return values.map((value) => value === null || value === void 0 ? "" : String(value)).join("|");
+}
+function rowToFeedbackRecord(row) {
+  const rawValue = row.value;
+  let value = rawValue;
+  const numValue = Number(rawValue);
+  if (!isNaN(numValue)) value = numValue;
+  return {
+    timestamp: toDate(row.timestamp),
+    traceId: row.traceId,
+    spanId: row.spanId ?? null,
+    experimentId: row.experimentId ?? null,
+    entityType: row.entityType ?? null,
+    entityId: row.entityId ?? null,
+    entityName: row.entityName ?? null,
+    parentEntityType: row.parentEntityType ?? null,
+    parentEntityId: row.parentEntityId ?? null,
+    parentEntityName: row.parentEntityName ?? null,
+    rootEntityType: row.rootEntityType ?? null,
+    rootEntityId: row.rootEntityId ?? null,
+    rootEntityName: row.rootEntityName ?? null,
+    userId: row.userId ?? null,
+    organizationId: row.organizationId ?? null,
+    resourceId: row.resourceId ?? null,
+    runId: row.runId ?? null,
+    sessionId: row.sessionId ?? null,
+    threadId: row.threadId ?? null,
+    requestId: row.requestId ?? null,
+    environment: row.environment ?? null,
+    executionSource: row.executionSource ?? null,
+    serviceName: row.serviceName ?? null,
+    feedbackUserId: row.feedbackUserId ?? null,
+    sourceId: row.sourceId ?? null,
+    source: row.feedbackSource,
+    feedbackSource: row.feedbackSource,
+    feedbackType: row.feedbackType,
+    value,
+    comment: row.comment ?? null,
+    tags: parseJsonArray(row.tags),
+    metadata: parseJson(row.metadata),
+    scope: parseJson(row.scope)
+  };
+}
+function getComparisonDateRange(comparePeriod, timestamp) {
+  if (!timestamp.start || !timestamp.end) return null;
+  const duration = timestamp.end.getTime() - timestamp.start.getTime();
+  switch (comparePeriod) {
+    case "previous_period":
+      return {
+        start: new Date(timestamp.start.getTime() - duration),
+        end: new Date(timestamp.end.getTime() - duration),
+        startExclusive: timestamp.startExclusive,
+        endExclusive: timestamp.endExclusive
+      };
+    case "previous_day":
+      return {
+        start: new Date(timestamp.start.getTime() - 864e5),
+        end: new Date(timestamp.end.getTime() - 864e5),
+        startExclusive: timestamp.startExclusive,
+        endExclusive: timestamp.endExclusive
+      };
+    case "previous_week":
+      return {
+        start: new Date(timestamp.start.getTime() - 6048e5),
+        end: new Date(timestamp.end.getTime() - 6048e5),
+        startExclusive: timestamp.startExclusive,
+        endExclusive: timestamp.endExclusive
+      };
+  }
+}
 async function createFeedback(db, args) {
   const f = args.feedback;
   const feedbackSource = f.feedbackSource ?? f.source ?? "";
@@ -681,57 +862,142 @@ async function listFeedback(db, args) {
     filterParams
   );
   const total = Number(countResult[0]?.total ?? 0);
-  const rows = await db.query(`SELECT * FROM feedback_events ${filterClause} ${orderByClause} ${paginationClause}`, [
-    ...filterParams,
-    ...paginationParams
-  ]);
-  const feedback = rows.map((row) => {
-    const r = row;
-    const rawValue = r.value;
-    let value = rawValue;
-    const numValue = Number(rawValue);
-    if (!isNaN(numValue)) value = numValue;
-    return {
-      timestamp: toDate(r.timestamp),
-      traceId: r.traceId,
-      spanId: r.spanId ?? null,
-      experimentId: r.experimentId ?? null,
-      entityType: r.entityType ?? null,
-      entityId: r.entityId ?? null,
-      entityName: r.entityName ?? null,
-      parentEntityType: r.parentEntityType ?? null,
-      parentEntityId: r.parentEntityId ?? null,
-      parentEntityName: r.parentEntityName ?? null,
-      rootEntityType: r.rootEntityType ?? null,
-      rootEntityId: r.rootEntityId ?? null,
-      rootEntityName: r.rootEntityName ?? null,
-      userId: r.userId ?? null,
-      organizationId: r.organizationId ?? null,
-      resourceId: r.resourceId ?? null,
-      runId: r.runId ?? null,
-      sessionId: r.sessionId ?? null,
-      threadId: r.threadId ?? null,
-      requestId: r.requestId ?? null,
-      environment: r.environment ?? null,
-      executionSource: r.executionSource ?? null,
-      serviceName: r.serviceName ?? null,
-      feedbackUserId: r.feedbackUserId ?? null,
-      sourceId: r.sourceId ?? null,
-      source: r.feedbackSource,
-      feedbackSource: r.feedbackSource,
-      feedbackType: r.feedbackType,
-      value,
-      comment: r.comment ?? null,
-      tags: parseJsonArray(r.tags),
-      metadata: parseJson(r.metadata),
-      scope: parseJson(r.scope)
-    };
-  });
+  const rows = await db.query(
+    `SELECT * FROM feedback_events ${filterClause} ${orderByClause} ${paginationClause}`,
+    [...filterParams, ...paginationParams]
+  );
   return {
     pagination: { total, page, perPage, hasMore: (page + 1) * perPage < total },
-    feedback
+    feedback: rows.map((row) => rowToFeedbackRecord(row))
+  };
+}
+async function getFeedbackAggregate(db, args) {
+  const aggSql = getAggregationSql(args.aggregation);
+  const { clause, params } = buildFeedbackWhereClause(args, true);
+  const rows = await db.query(
+    `SELECT ${aggSql} AS value FROM feedback_events ${clause}`,
+    params
+  );
+  const value = rows[0]?.value === null || rows[0]?.value === void 0 ? null : Number(rows[0]?.value);
+  if (args.comparePeriod && args.filters?.timestamp) {
+    const previousTimestamp = getComparisonDateRange(args.comparePeriod, args.filters.timestamp);
+    if (previousTimestamp) {
+      const previousWhere = buildFeedbackWhereClause(
+        {
+          ...args,
+          filters: { ...args.filters ?? {}, timestamp: previousTimestamp }
+        },
+        true
+      );
+      const prevRows = await db.query(
+        `SELECT ${aggSql} AS value FROM feedback_events ${previousWhere.clause}`,
+        previousWhere.params
+      );
+      const previousValue = prevRows[0]?.value === null || prevRows[0]?.value === void 0 ? null : Number(prevRows[0]?.value);
+      let changePercent = null;
+      if (previousValue !== null && previousValue !== 0 && value !== null) {
+        changePercent = (value - previousValue) / Math.abs(previousValue) * 100;
+      }
+      return { value, previousValue, changePercent };
+    }
+  }
+  return { value };
+}
+async function getFeedbackBreakdown(db, args) {
+  const aggSql = getAggregationSql(args.aggregation);
+  const { clause, params } = buildFeedbackWhereClause(args, true);
+  const resolvedGroupBy = resolveFeedbackGroupBy(args.groupBy);
+  const sql = `SELECT ${resolvedGroupBy.map((entry) => entry.selectSql).join(", ")}, ${aggSql} AS value FROM feedback_events ${clause} GROUP BY ${resolvedGroupBy.map((entry) => entry.groupSql).join(", ")} ORDER BY value DESC`;
+  const rows = await db.query(sql, params);
+  return {
+    groups: rows.map((row) => ({
+      dimensions: Object.fromEntries(
+        resolvedGroupBy.map((entry, index) => {
+          const value = row[`group_by_${index}`];
+          return [entry.key, value === null || value === void 0 ? null : String(value)];
+        })
+      ),
+      value: Number(row.value ?? 0)
+    }))
+  };
+}
+async function getFeedbackTimeSeries(db, args) {
+  const aggSql = getAggregationSql(args.aggregation);
+  const intervalSql = getIntervalSql(args.interval);
+  const { clause, params } = buildFeedbackWhereClause(args, true);
+  if (args.groupBy && args.groupBy.length > 0) {
+    const resolvedGroupBy = resolveFeedbackGroupBy(args.groupBy);
+    const sql = `
+      SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+             ${resolvedGroupBy.map((entry) => entry.selectSql).join(", ")},
+             ${aggSql} AS value
+      FROM feedback_events ${clause}
+      GROUP BY bucket, ${resolvedGroupBy.map((entry) => entry.groupSql).join(", ")}
+      ORDER BY bucket
+    `;
+    const rows2 = await db.query(sql, params);
+    const seriesMap = /* @__PURE__ */ new Map();
+    for (const row of rows2) {
+      const groupValues = resolvedGroupBy.map((_, index) => row[`group_by_${index}`]);
+      const key = JSON.stringify(groupValues);
+      if (!seriesMap.has(key)) {
+        seriesMap.set(key, { name: toSeriesName(groupValues), points: [] });
+      }
+      seriesMap.get(key).points.push({
+        timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+        value: Number(row.value ?? 0)
+      });
+    }
+    return { series: Array.from(seriesMap.values()) };
+  }
+  const rows = await db.query(
+    `
+      SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+             ${aggSql} AS value
+      FROM feedback_events ${clause}
+      GROUP BY bucket
+      ORDER BY bucket
+    `,
+    params
+  );
+  return {
+    series: [
+      {
+        name: args.feedbackSource ? `${args.feedbackType}|${args.feedbackSource}` : args.feedbackType,
+        points: rows.map((row) => ({
+          timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+          value: Number(row.value ?? 0)
+        }))
+      }
+    ]
   };
 }
+async function getFeedbackPercentiles(db, args) {
+  const intervalSql = getIntervalSql(args.interval);
+  const { clause, params } = buildFeedbackWhereClause(args, true);
+  const percentiles = getValidatedPercentiles(args.percentiles);
+  const series = [];
+  for (const percentile of percentiles) {
+    const rows = await db.query(
+      `
+        SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+               percentile_cont(${percentile}) WITHIN GROUP (ORDER BY TRY_CAST(value AS DOUBLE)) AS pvalue
+        FROM feedback_events ${clause}
+        GROUP BY bucket
+        ORDER BY bucket
+      `,
+      params
+    );
+    series.push({
+      percentile,
+      points: rows.map((row) => ({
+        timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+        value: Number(row.pvalue ?? 0)
+      }))
+    });
+  }
+  return { series };
+}
 
 // src/storage/domains/observability/logs.ts
 var COLUMNS = [
@@ -859,7 +1125,7 @@ async function listLogs(db, args) {
     logs
   };
 }
-function getAggregationSql(aggregation, measure = "value") {
+function getAggregationSql2(aggregation, measure = "value") {
   switch (aggregation) {
     case "sum":
       return `SUM(${measure})`;
@@ -877,7 +1143,7 @@ function getAggregationSql(aggregation, measure = "value") {
       return `SUM(${measure})`;
   }
 }
-function getIntervalSql(interval) {
+function getIntervalSql2(interval) {
   switch (interval) {
     case "1m":
       return "1 minute";
@@ -1102,7 +1368,7 @@ async function listMetrics(db, args) {
   };
 }
 async function getMetricAggregate(db, args) {
-  const aggSql = getAggregationSql(args.aggregation);
+  const aggSql = getAggregationSql2(args.aggregation);
   const { clause: nameClause, params: nameParams } = buildMetricNameFilter(args.name);
   const { clause: filterClause, params: filterParams } = buildWhereClause(
     args.filters
@@ -1186,7 +1452,7 @@ async function getMetricAggregate(db, args) {
   return { value, estimatedCost: costSummary.estimatedCost, costUnit: costSummary.costUnit };
 }
 async function getMetricBreakdown(db, args) {
-  const aggSql = getAggregationSql(args.aggregation);
+  const aggSql = getAggregationSql2(args.aggregation);
   const { clause: nameClause, params: nameParams } = buildMetricNameFilter(args.name);
   const { clause: filterClause, params: filterParams } = buildWhereClause(
     args.filters
@@ -1219,8 +1485,8 @@ async function getMetricBreakdown(db, args) {
   return { groups };
 }
 async function getMetricTimeSeries(db, args) {
-  const aggSql = getAggregationSql(args.aggregation);
-  const intervalSql = getIntervalSql(args.interval);
+  const aggSql = getAggregationSql2(args.aggregation);
+  const intervalSql = getIntervalSql2(args.interval);
   const { clause: nameClause, params: nameParams } = buildMetricNameFilter(args.name);
   const { clause: filterClause, params: filterParams } = buildWhereClause(
     args.filters
@@ -1306,7 +1572,7 @@ async function getMetricTimeSeries(db, args) {
   };
 }
 async function getMetricPercentiles(db, args) {
-  const intervalSql = getIntervalSql(args.interval);
+  const intervalSql = getIntervalSql2(args.interval);
   const { clause: filterClause, params: filterParams } = buildWhereClause(
     args.filters
   );
@@ -1376,8 +1642,180 @@ async function getMetricLabelValues(db, args) {
   );
   return { values: rows.map((r) => r.val) };
 }
-
-// src/storage/domains/observability/scores.ts
+var SCORE_GROUP_BY_COLUMNS = /* @__PURE__ */ new Set([
+  "timestamp",
+  "traceId",
+  "spanId",
+  "experimentId",
+  "scoreTraceId",
+  "entityType",
+  "entityId",
+  "entityName",
+  "parentEntityType",
+  "parentEntityId",
+  "parentEntityName",
+  "rootEntityType",
+  "rootEntityId",
+  "rootEntityName",
+  "userId",
+  "organizationId",
+  "resourceId",
+  "runId",
+  "sessionId",
+  "threadId",
+  "requestId",
+  "environment",
+  "executionSource",
+  "serviceName",
+  "scorerId",
+  "scorerVersion",
+  "scoreSource",
+  "score",
+  "reason"
+]);
+function getAggregationSql3(aggregation, measure = "score") {
+  switch (aggregation) {
+    case "sum":
+      return `SUM(${measure})`;
+    case "avg":
+      return `AVG(${measure})`;
+    case "min":
+      return `MIN(${measure})`;
+    case "max":
+      return `MAX(${measure})`;
+    case "count":
+      return `CAST(COUNT(${measure}) AS DOUBLE)`;
+    case "last":
+      return `arg_max(${measure}, timestamp)`;
+    default:
+      return `SUM(${measure})`;
+  }
+}
+function getIntervalSql3(interval) {
+  switch (interval) {
+    case "1m":
+      return "1 minute";
+    case "5m":
+      return "5 minutes";
+    case "15m":
+      return "15 minutes";
+    case "1h":
+      return "1 hour";
+    case "1d":
+      return "1 day";
+    default:
+      return "1 hour";
+  }
+}
+function getValidatedPercentiles2(percentiles) {
+  if (!Array.isArray(percentiles) || percentiles.length === 0) {
+    throw new Error("Percentiles must include at least one value between 0 and 1.");
+  }
+  return percentiles.map((percentile) => {
+    if (!Number.isFinite(percentile) || percentile < 0 || percentile > 1) {
+      throw new Error("Percentiles must be finite numbers between 0 and 1.");
+    }
+    return percentile;
+  });
+}
+function buildScoreWhereClause(args) {
+  const conditions = ["scorerId = ?"];
+  const params = [args.scorerId];
+  if (args.scoreSource !== void 0) {
+    conditions.push("scoreSource = ?");
+    params.push(args.scoreSource);
+  }
+  const { clause: filterClause, params: filterParams } = buildWhereClause(
+    args.filters,
+    { source: "scoreSource" }
+  );
+  if (filterClause) {
+    conditions.push(filterClause.replace("WHERE ", ""));
+    params.push(...filterParams);
+  }
+  return { clause: `WHERE ${conditions.join(" AND ")}`, params };
+}
+function resolveScoreGroupBy(groupBy) {
+  return groupBy.map((key, index) => {
+    const column = utils.parseFieldKey(key);
+    if (!SCORE_GROUP_BY_COLUMNS.has(column)) {
+      throw new Error(`Invalid groupBy column(s): ${key}`);
+    }
+    const alias = `group_by_${index}`;
+    return {
+      key,
+      selectSql: `${column} AS ${alias}`,
+      groupSql: alias
+    };
+  });
+}
+function toSeriesName2(values) {
+  return values.map((value) => value === null || value === void 0 ? "" : String(value)).join("|");
+}
+function rowToScoreRecord(row) {
+  return {
+    timestamp: toDate(row.timestamp),
+    traceId: row.traceId,
+    spanId: row.spanId ?? null,
+    experimentId: row.experimentId ?? null,
+    scoreTraceId: row.scoreTraceId ?? null,
+    entityType: row.entityType ?? null,
+    entityId: row.entityId ?? null,
+    entityName: row.entityName ?? null,
+    parentEntityType: row.parentEntityType ?? null,
+    parentEntityId: row.parentEntityId ?? null,
+    parentEntityName: row.parentEntityName ?? null,
+    rootEntityType: row.rootEntityType ?? null,
+    rootEntityId: row.rootEntityId ?? null,
+    rootEntityName: row.rootEntityName ?? null,
+    userId: row.userId ?? null,
+    organizationId: row.organizationId ?? null,
+    resourceId: row.resourceId ?? null,
+    runId: row.runId ?? null,
+    sessionId: row.sessionId ?? null,
+    threadId: row.threadId ?? null,
+    requestId: row.requestId ?? null,
+    environment: row.environment ?? null,
+    executionSource: row.executionSource ?? null,
+    serviceName: row.serviceName ?? null,
+    scorerId: row.scorerId,
+    scorerVersion: row.scorerVersion ?? null,
+    source: row.scoreSource ?? null,
+    scoreSource: row.scoreSource ?? null,
+    score: Number(row.score),
+    reason: row.reason ?? null,
+    tags: parseJsonArray(row.tags),
+    metadata: parseJson(row.metadata),
+    scope: parseJson(row.scope)
+  };
+}
+function getComparisonDateRange2(comparePeriod, timestamp) {
+  if (!timestamp.start || !timestamp.end) return null;
+  const duration = timestamp.end.getTime() - timestamp.start.getTime();
+  switch (comparePeriod) {
+    case "previous_period":
+      return {
+        start: new Date(timestamp.start.getTime() - duration),
+        end: new Date(timestamp.end.getTime() - duration),
+        startExclusive: timestamp.startExclusive,
+        endExclusive: timestamp.endExclusive
+      };
+    case "previous_day":
+      return {
+        start: new Date(timestamp.start.getTime() - 864e5),
+        end: new Date(timestamp.end.getTime() - 864e5),
+        startExclusive: timestamp.startExclusive,
+        endExclusive: timestamp.endExclusive
+      };
+    case "previous_week":
+      return {
+        start: new Date(timestamp.start.getTime() - 6048e5),
+        end: new Date(timestamp.end.getTime() - 6048e5),
+        startExclusive: timestamp.startExclusive,
+        endExclusive: timestamp.endExclusive
+      };
+  }
+}
 async function createScore(db, args) {
   const s = args.score;
   const scoreSource = s.scoreSource ?? s.source ?? null;
@@ -1489,53 +1927,138 @@ async function listScores(db, args) {
     filterParams
   );
   const total = Number(countResult[0]?.total ?? 0);
-  const rows = await db.query(`SELECT * FROM score_events ${filterClause} ${orderByClause} ${paginationClause}`, [
-    ...filterParams,
-    ...paginationParams
-  ]);
-  const scores = rows.map((row) => {
-    const r = row;
-    return {
-      timestamp: toDate(r.timestamp),
-      traceId: r.traceId,
-      spanId: r.spanId ?? null,
-      experimentId: r.experimentId ?? null,
-      scoreTraceId: r.scoreTraceId ?? null,
-      entityType: r.entityType ?? null,
-      entityId: r.entityId ?? null,
-      entityName: r.entityName ?? null,
-      parentEntityType: r.parentEntityType ?? null,
-      parentEntityId: r.parentEntityId ?? null,
-      parentEntityName: r.parentEntityName ?? null,
-      rootEntityType: r.rootEntityType ?? null,
-      rootEntityId: r.rootEntityId ?? null,
-      rootEntityName: r.rootEntityName ?? null,
-      userId: r.userId ?? null,
-      organizationId: r.organizationId ?? null,
-      resourceId: r.resourceId ?? null,
-      runId: r.runId ?? null,
-      sessionId: r.sessionId ?? null,
-      threadId: r.threadId ?? null,
-      requestId: r.requestId ?? null,
-      environment: r.environment ?? null,
-      executionSource: r.executionSource ?? null,
-      serviceName: r.serviceName ?? null,
-      scorerId: r.scorerId,
-      scorerVersion: r.scorerVersion ?? null,
-      source: r.scoreSource ?? null,
-      scoreSource: r.scoreSource ?? null,
-      score: Number(r.score),
-      reason: r.reason ?? null,
-      tags: parseJsonArray(r.tags),
-      metadata: parseJson(r.metadata),
-      scope: parseJson(r.scope)
-    };
-  });
+  const rows = await db.query(
+    `SELECT * FROM score_events ${filterClause} ${orderByClause} ${paginationClause}`,
+    [...filterParams, ...paginationParams]
+  );
   return {
     pagination: { total, page, perPage, hasMore: (page + 1) * perPage < total },
-    scores
+    scores: rows.map((row) => rowToScoreRecord(row))
   };
 }
+async function getScoreAggregate(db, args) {
+  const aggSql = getAggregationSql3(args.aggregation);
+  const { clause, params } = buildScoreWhereClause(args);
+  const rows = await db.query(`SELECT ${aggSql} AS value FROM score_events ${clause}`, params);
+  const value = rows[0]?.value === null || rows[0]?.value === void 0 ? null : Number(rows[0]?.value);
+  if (args.comparePeriod && args.filters?.timestamp) {
+    const previousTimestamp = getComparisonDateRange2(args.comparePeriod, args.filters.timestamp);
+    if (previousTimestamp) {
+      const prevRows = await db.query(
+        `SELECT ${aggSql} AS value FROM score_events ${buildScoreWhereClause({
+          ...args,
+          filters: { ...args.filters ?? {}, timestamp: previousTimestamp }
+        }).clause}`,
+        buildScoreWhereClause({
+          ...args,
+          filters: { ...args.filters ?? {}, timestamp: previousTimestamp }
+        }).params
+      );
+      const previousValue = prevRows[0]?.value === null || prevRows[0]?.value === void 0 ? null : Number(prevRows[0]?.value);
+      let changePercent = null;
+      if (previousValue !== null && previousValue !== 0 && value !== null) {
+        changePercent = (value - previousValue) / Math.abs(previousValue) * 100;
+      }
+      return { value, previousValue, changePercent };
+    }
+  }
+  return { value };
+}
+async function getScoreBreakdown(db, args) {
+  const aggSql = getAggregationSql3(args.aggregation);
+  const { clause, params } = buildScoreWhereClause(args);
+  const resolvedGroupBy = resolveScoreGroupBy(args.groupBy);
+  const sql = `SELECT ${resolvedGroupBy.map((entry) => entry.selectSql).join(", ")}, ${aggSql} AS value FROM score_events ${clause} GROUP BY ${resolvedGroupBy.map((entry) => entry.groupSql).join(", ")} ORDER BY value DESC`;
+  const rows = await db.query(sql, params);
+  return {
+    groups: rows.map((row) => ({
+      dimensions: Object.fromEntries(
+        resolvedGroupBy.map((entry, index) => {
+          const value = row[`group_by_${index}`];
+          return [entry.key, value === null || value === void 0 ? null : String(value)];
+        })
+      ),
+      value: Number(row.value ?? 0)
+    }))
+  };
+}
+async function getScoreTimeSeries(db, args) {
+  const aggSql = getAggregationSql3(args.aggregation);
+  const intervalSql = getIntervalSql3(args.interval);
+  const { clause, params } = buildScoreWhereClause(args);
+  if (args.groupBy && args.groupBy.length > 0) {
+    const resolvedGroupBy = resolveScoreGroupBy(args.groupBy);
+    const sql = `
+      SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+             ${resolvedGroupBy.map((entry) => entry.selectSql).join(", ")},
+             ${aggSql} AS value
+      FROM score_events ${clause}
+      GROUP BY bucket, ${resolvedGroupBy.map((entry) => entry.groupSql).join(", ")}
+      ORDER BY bucket
+    `;
+    const rows2 = await db.query(sql, params);
+    const seriesMap = /* @__PURE__ */ new Map();
+    for (const row of rows2) {
+      const groupValues = resolvedGroupBy.map((_, index) => row[`group_by_${index}`]);
+      const key = JSON.stringify(groupValues);
+      if (!seriesMap.has(key)) {
+        seriesMap.set(key, { name: toSeriesName2(groupValues), points: [] });
+      }
+      seriesMap.get(key).points.push({
+        timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+        value: Number(row.value ?? 0)
+      });
+    }
+    return { series: Array.from(seriesMap.values()) };
+  }
+  const rows = await db.query(
+    `
+      SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+             ${aggSql} AS value
+      FROM score_events ${clause}
+      GROUP BY bucket
+      ORDER BY bucket
+    `,
+    params
+  );
+  return {
+    series: [
+      {
+        name: args.scoreSource ? `${args.scorerId}|${args.scoreSource}` : args.scorerId,
+        points: rows.map((row) => ({
+          timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+          value: Number(row.value ?? 0)
+        }))
+      }
+    ]
+  };
+}
+async function getScorePercentiles(db, args) {
+  const intervalSql = getIntervalSql3(args.interval);
+  const { clause, params } = buildScoreWhereClause(args);
+  const percentiles = getValidatedPercentiles2(args.percentiles);
+  const series = [];
+  for (const percentile of percentiles) {
+    const rows = await db.query(
+      `
+        SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+               percentile_cont(${percentile}) WITHIN GROUP (ORDER BY score) AS pvalue
+        FROM score_events ${clause}
+        GROUP BY bucket
+        ORDER BY bucket
+      `,
+      params
+    );
+    series.push({
+      percentile,
+      points: rows.map((row) => ({
+        timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+        value: Number(row.pvalue ?? 0)
+      }))
+    });
+  }
+  return { series };
+}
 var COLUMNS2 = [
   "eventType",
   "timestamp",
@@ -1969,6 +2492,18 @@ var ObservabilityStorageDuckDB = class extends storage.ObservabilityStorage {
   async listScores(args) {
     return listScores(this.db, args);
   }
+  async getScoreAggregate(args) {
+    return getScoreAggregate(this.db, args);
+  }
+  async getScoreBreakdown(args) {
+    return getScoreBreakdown(this.db, args);
+  }
+  async getScoreTimeSeries(args) {
+    return getScoreTimeSeries(this.db, args);
+  }
+  async getScorePercentiles(args) {
+    return getScorePercentiles(this.db, args);
+  }
   // Feedback
   async createFeedback(args) {
     return createFeedback(this.db, args);
@@ -1979,8 +2514,20 @@ var ObservabilityStorageDuckDB = class extends storage.ObservabilityStorage {
   async listFeedback(args) {
     return listFeedback(this.db, args);
   }
+  async getFeedbackAggregate(args) {
+    return getFeedbackAggregate(this.db, args);
+  }
+  async getFeedbackBreakdown(args) {
+    return getFeedbackBreakdown(this.db, args);
+  }
+  async getFeedbackTimeSeries(args) {
+    return getFeedbackTimeSeries(this.db, args);
+  }
+  async getFeedbackPercentiles(args) {
+    return getFeedbackPercentiles(this.db, args);
+  }
 };
 
 exports.ObservabilityStorageDuckDB = ObservabilityStorageDuckDB;
-//# sourceMappingURL=observability-AMG7NSKE.cjs.map
-//# sourceMappingURL=observability-AMG7NSKE.cjs.map
+//# sourceMappingURL=observability-XVQ3ST7G.cjs.map
+//# sourceMappingURL=observability-XVQ3ST7G.cjs.map