@mastra/clickhouse 1.8.0 → 1.9.0-alpha.1

package/dist/index.cjs

@@ -6,6 +6,7 @@ var storage = require('@mastra/core/storage');
 var base = require('@mastra/core/base');
 var agent = require('@mastra/core/agent');
 var utils = require('@mastra/core/utils');
+var features = require('@mastra/core/features');
 var evals = require('@mastra/core/evals');
 
 // src/storage/index.ts
@@ -2860,16 +2861,36 @@ time for large tables. Please ensure you have a backup before proceeding.
 var TABLE_SPAN_EVENTS = "mastra_span_events";
 var TABLE_TRACE_ROOTS = "mastra_trace_roots";
 var TABLE_TRACE_BRANCHES = "mastra_trace_branches";
+var TABLE_TRACE_ROOTS_DELTA = "mastra_trace_roots_delta";
+var TABLE_TRACE_BRANCHES_DELTA = "mastra_trace_branches_delta";
 var TABLE_METRIC_EVENTS = "mastra_metric_events";
 var TABLE_LOG_EVENTS = "mastra_log_events";
 var TABLE_SCORE_EVENTS = "mastra_score_events";
 var TABLE_FEEDBACK_EVENTS = "mastra_feedback_events";
+var TABLE_METRIC_EVENTS_DELTA = "mastra_metric_events_delta";
+var TABLE_LOG_EVENTS_DELTA = "mastra_log_events_delta";
+var TABLE_SCORE_EVENTS_DELTA = "mastra_score_events_delta";
+var TABLE_FEEDBACK_EVENTS_DELTA = "mastra_feedback_events_delta";
 var TABLE_DISCOVERY_VALUES = "mastra_discovery_values";
 var TABLE_DISCOVERY_PAIRS = "mastra_discovery_pairs";
 var MV_TRACE_ROOTS = "mastra_mv_trace_roots";
 var MV_TRACE_BRANCHES = "mastra_mv_trace_branches";
+var MV_TRACE_ROOTS_DELTA = "mastra_mv_trace_roots_delta";
+var MV_TRACE_BRANCHES_DELTA = "mastra_mv_trace_branches_delta";
+var MV_METRIC_EVENTS_DELTA = "mastra_mv_metric_events_delta";
+var MV_LOG_EVENTS_DELTA = "mastra_mv_log_events_delta";
+var MV_SCORE_EVENTS_DELTA = "mastra_mv_score_events_delta";
+var MV_FEEDBACK_EVENTS_DELTA = "mastra_mv_feedback_events_delta";
 var MV_DISCOVERY_VALUES = "mastra_mv_discovery_values";
 var MV_DISCOVERY_PAIRS = "mastra_mv_discovery_pairs";
+var DELTA_MV_NAMES = [
+  MV_TRACE_ROOTS_DELTA,
+  MV_TRACE_BRANCHES_DELTA,
+  MV_METRIC_EVENTS_DELTA,
+  MV_LOG_EVENTS_DELTA,
+  MV_SCORE_EVENTS_DELTA,
+  MV_FEEDBACK_EVENTS_DELTA
+];
 var BRANCH_SPAN_TYPE_VALUES = [
   "agent_run",
   "workflow_run",
@@ -3093,6 +3114,103 @@ SELECT *
 FROM ${TABLE_SPAN_EVENTS}
 WHERE spanType IN (${BRANCH_SPAN_TYPE_VALUES.map((v) => `'${v}'`).join(", ")})
 `;
+var DELTA_INGESTED_AT_TYPE = `DateTime64(9, 'UTC')`;
+var DELTA_CURSOR_EPOCH_MS = 17778528e5;
+var DELTA_CURSOR_SUFFIX_BITS = 26;
+var DELTA_CURSOR_SUFFIX_MASK = 67108863;
+function buildFallbackCursorExpr(stableKeyExpr) {
+  return `bitOr(
+    bitShiftLeft(
+      toUInt64(toUnixTimestamp64Milli(ingestedAt) - ${DELTA_CURSOR_EPOCH_MS}),
+      ${DELTA_CURSOR_SUFFIX_BITS}
+    ),
+    bitAnd(farmFingerprint64(toString(${stableKeyExpr})), toUInt64(${DELTA_CURSOR_SUFFIX_MASK}))
+  )`;
+}
+function buildDeltaCursorExpr(strategy, counterName, stableKeyExpr) {
+  if (strategy === "serial") {
+    return `generateSerialID('${counterName}')`;
+  }
+  return buildFallbackCursorExpr(stableKeyExpr);
+}
+function buildTraceRootsDeltaDDL() {
+  return `
+CREATE TABLE IF NOT EXISTS ${TABLE_TRACE_ROOTS_DELTA} (
+  cursorId           UInt64,
+  ingestedAt         ${DELTA_INGESTED_AT_TYPE},
+  startedAt          DateTime64(3, 'UTC'),
+  traceId            String,
+  dedupeKey          String
+)
+ENGINE = MergeTree
+PARTITION BY toDate(ingestedAt)
+ORDER BY (cursorId)
+TTL ingestedAt + toIntervalDay(2)
+`;
+}
+function buildTraceRootsDeltaMvDDL(strategy) {
+  return `
+CREATE MATERIALIZED VIEW IF NOT EXISTS ${MV_TRACE_ROOTS_DELTA}
+TO ${TABLE_TRACE_ROOTS_DELTA}
+AS
+SELECT
+  ${buildDeltaCursorExpr(strategy, "mastra_trace_roots_delta_cursor", "dedupeKey")} AS cursorId,
+  ingestedAt,
+  startedAt,
+  traceId,
+  dedupeKey
+FROM (
+  SELECT
+    now64(9, 'UTC') AS ingestedAt,
+    startedAt,
+    traceId,
+    dedupeKey
+  FROM ${TABLE_TRACE_ROOTS}
+)
+`;
+}
+function buildTraceBranchesDeltaDDL() {
+  return `
+CREATE TABLE IF NOT EXISTS ${TABLE_TRACE_BRANCHES_DELTA} (
+  cursorId           UInt64,
+  ingestedAt         ${DELTA_INGESTED_AT_TYPE},
+  spanType           LowCardinality(String),
+  startedAt          DateTime64(3, 'UTC'),
+  traceId            String,
+  spanId             String,
+  dedupeKey          String
+)
+ENGINE = MergeTree
+PARTITION BY toDate(ingestedAt)
+ORDER BY (cursorId)
+TTL ingestedAt + toIntervalDay(2)
+`;
+}
+function buildTraceBranchesDeltaMvDDL(strategy) {
+  return `
+CREATE MATERIALIZED VIEW IF NOT EXISTS ${MV_TRACE_BRANCHES_DELTA}
+TO ${TABLE_TRACE_BRANCHES_DELTA}
+AS
+SELECT
+  ${buildDeltaCursorExpr(strategy, "mastra_trace_branches_delta_cursor", "dedupeKey")} AS cursorId,
+  ingestedAt,
+  spanType,
+  startedAt,
+  traceId,
+  spanId,
+  dedupeKey
+FROM (
+  SELECT
+    now64(9, 'UTC') AS ingestedAt,
+    spanType,
+    startedAt,
+    traceId,
+    spanId,
+    dedupeKey
+  FROM ${TABLE_TRACE_BRANCHES}
+)
+`;
+}
 var METRIC_EVENTS_DDL = `
 CREATE TABLE IF NOT EXISTS ${TABLE_METRIC_EVENTS} (
   -- Timestamp
@@ -3219,6 +3337,39 @@ ENGINE = ReplacingMergeTree
 PARTITION BY toDate(timestamp)
 ORDER BY (timestamp, logId)
 `;
+function buildLogEventsDeltaDDL() {
+  return `
+CREATE TABLE IF NOT EXISTS ${TABLE_LOG_EVENTS_DELTA} (
+  cursorId           UInt64,
+  ingestedAt         ${DELTA_INGESTED_AT_TYPE},
+  timestamp          DateTime64(3, 'UTC'),
+  logId              String
+)
+ENGINE = MergeTree
+PARTITION BY toDate(ingestedAt)
+ORDER BY (cursorId)
+TTL ingestedAt + toIntervalDay(2)
+`;
+}
+function buildLogEventsDeltaMvDDL(strategy) {
+  return `
+CREATE MATERIALIZED VIEW IF NOT EXISTS ${MV_LOG_EVENTS_DELTA}
+TO ${TABLE_LOG_EVENTS_DELTA}
+AS
+SELECT
+  ${buildDeltaCursorExpr(strategy, "mastra_log_events_delta_cursor", "logId")} AS cursorId,
+  ingestedAt,
+  timestamp,
+  logId
+FROM (
+  SELECT
+    now64(9, 'UTC') AS ingestedAt,
+    timestamp,
+    logId
+  FROM ${TABLE_LOG_EVENTS}
+)
+`;
+}
 var SCORE_EVENTS_DDL = `
 CREATE TABLE IF NOT EXISTS ${TABLE_SCORE_EVENTS} (
   -- Timestamp
@@ -3280,6 +3431,43 @@ PARTITION BY toDate(timestamp)
 ORDER BY (traceId, timestamp, scoreId)
 SETTINGS allow_nullable_key = 1
 `;
+function buildScoreEventsDeltaDDL() {
+  return `
+CREATE TABLE IF NOT EXISTS ${TABLE_SCORE_EVENTS_DELTA} (
+  cursorId           UInt64,
+  ingestedAt         ${DELTA_INGESTED_AT_TYPE},
+  traceId            Nullable(String),
+  timestamp          DateTime64(3, 'UTC'),
+  scoreId            String
+)
+ENGINE = MergeTree
+PARTITION BY toDate(ingestedAt)
+ORDER BY (cursorId)
+TTL ingestedAt + toIntervalDay(2)
+SETTINGS allow_nullable_key = 1
+`;
+}
+function buildScoreEventsDeltaMvDDL(strategy) {
+  return `
+CREATE MATERIALIZED VIEW IF NOT EXISTS ${MV_SCORE_EVENTS_DELTA}
+TO ${TABLE_SCORE_EVENTS_DELTA}
+AS
+SELECT
+  ${buildDeltaCursorExpr(strategy, "mastra_score_events_delta_cursor", "scoreId")} AS cursorId,
+  ingestedAt,
+  traceId,
+  timestamp,
+  scoreId
+FROM (
+  SELECT
+    now64(9, 'UTC') AS ingestedAt,
+    traceId,
+    timestamp,
+    scoreId
+  FROM ${TABLE_SCORE_EVENTS}
+)
+`;
+}
 var FEEDBACK_EVENTS_DDL = `
 CREATE TABLE IF NOT EXISTS ${TABLE_FEEDBACK_EVENTS} (
   -- Timestamp
@@ -3344,13 +3532,86 @@ PARTITION BY toDate(timestamp)
 ORDER BY (traceId, timestamp, feedbackId)
 SETTINGS allow_nullable_key = 1
 `;
+function buildFeedbackEventsDeltaDDL() {
+  return `
+CREATE TABLE IF NOT EXISTS ${TABLE_FEEDBACK_EVENTS_DELTA} (
+  cursorId           UInt64,
+  ingestedAt         ${DELTA_INGESTED_AT_TYPE},
+  traceId            Nullable(String),
+  timestamp          DateTime64(3, 'UTC'),
+  feedbackId         String
+)
+ENGINE = MergeTree
+PARTITION BY toDate(ingestedAt)
+ORDER BY (cursorId)
+TTL ingestedAt + toIntervalDay(2)
+SETTINGS allow_nullable_key = 1
+`;
+}
+function buildFeedbackEventsDeltaMvDDL(strategy) {
+  return `
+CREATE MATERIALIZED VIEW IF NOT EXISTS ${MV_FEEDBACK_EVENTS_DELTA}
+TO ${TABLE_FEEDBACK_EVENTS_DELTA}
+AS
+SELECT
+  ${buildDeltaCursorExpr(strategy, "mastra_feedback_events_delta_cursor", "feedbackId")} AS cursorId,
+  ingestedAt,
+  traceId,
+  timestamp,
+  feedbackId
+FROM (
+  SELECT
+    now64(9, 'UTC') AS ingestedAt,
+    traceId,
+    timestamp,
+    feedbackId
+  FROM ${TABLE_FEEDBACK_EVENTS}
+)
+`;
+}
+function buildMetricEventsDeltaDDL() {
+  return `
+CREATE TABLE IF NOT EXISTS ${TABLE_METRIC_EVENTS_DELTA} (
+  cursorId           UInt64,
+  ingestedAt         ${DELTA_INGESTED_AT_TYPE},
+  name               LowCardinality(String),
+  timestamp          DateTime64(3, 'UTC'),
+  metricId           String
+)
+ENGINE = MergeTree
+PARTITION BY toDate(ingestedAt)
+ORDER BY (cursorId)
+TTL ingestedAt + toIntervalDay(2)
+`;
+}
+function buildMetricEventsDeltaMvDDL(strategy) {
+  return `
+CREATE MATERIALIZED VIEW IF NOT EXISTS ${MV_METRIC_EVENTS_DELTA}
+TO ${TABLE_METRIC_EVENTS_DELTA}
+AS
+SELECT
+  ${buildDeltaCursorExpr(strategy, "mastra_metric_events_delta_cursor", "metricId")} AS cursorId,
+  ingestedAt,
+  name,
+  timestamp,
+  metricId
+FROM (
+  SELECT
+    now64(9, 'UTC') AS ingestedAt,
+    name,
+    timestamp,
+    metricId
+  FROM ${TABLE_METRIC_EVENTS}
+)
+`;
+}
 var DISCOVERY_VALUES_DDL = `
 CREATE TABLE IF NOT EXISTS ${TABLE_DISCOVERY_VALUES} (
   kind               LowCardinality(String),
   key1               String,
   value              String
 )
-ENGINE = MergeTree
+ENGINE = ReplacingMergeTree
 ORDER BY (kind, key1, value)
 `;
 var DISCOVERY_PAIRS_DDL = `
@@ -3360,7 +3621,7 @@ CREATE TABLE IF NOT EXISTS ${TABLE_DISCOVERY_PAIRS} (
   key2               String,
   value              String
 )
-ENGINE = MergeTree
+ENGINE = ReplacingMergeTree
 ORDER BY (kind, key1, key2, value)
 `;
 var SIGNAL_TABLES = [TABLE_SPAN_EVENTS, TABLE_METRIC_EVENTS, TABLE_LOG_EVENTS];
@@ -3412,7 +3673,7 @@ SELECT DISTINCT kind, key1, key2, value FROM (
   WHERE name != '' AND labelKey != '' AND labels[labelKey] != ''
 )
 `;
-var ALL_TABLE_DDL = [
+var BASE_TABLE_DDL = [
   SPAN_EVENTS_DDL,
   TRACE_ROOTS_DDL,
   TRACE_BRANCHES_DDL,
@@ -3423,7 +3684,33 @@ var ALL_TABLE_DDL = [
   DISCOVERY_VALUES_DDL,
   DISCOVERY_PAIRS_DDL
 ];
-var ALL_MV_DDL = [TRACE_ROOTS_MV_DDL, TRACE_BRANCHES_MV_DDL];
+function buildDeltaTableDDL() {
+  return [
+    buildTraceRootsDeltaDDL(),
+    buildTraceBranchesDeltaDDL(),
+    buildMetricEventsDeltaDDL(),
+    buildLogEventsDeltaDDL(),
+    buildScoreEventsDeltaDDL(),
+    buildFeedbackEventsDeltaDDL()
+  ];
+}
+function buildAllTableDDL() {
+  return [...BASE_TABLE_DDL, ...buildDeltaTableDDL()];
+}
+var BASE_MV_DDL = [TRACE_ROOTS_MV_DDL, TRACE_BRANCHES_MV_DDL];
+function buildDeltaMvDDL(strategy) {
+  return [
+    buildTraceRootsDeltaMvDDL(strategy),
+    buildTraceBranchesDeltaMvDDL(strategy),
+    buildMetricEventsDeltaMvDDL(strategy),
+    buildLogEventsDeltaMvDDL(strategy),
+    buildScoreEventsDeltaMvDDL(strategy),
+    buildFeedbackEventsDeltaMvDDL(strategy)
+  ];
+}
+function buildAllMvDDL(strategy) {
+  return [...BASE_MV_DDL, ...buildDeltaMvDDL(strategy)];
+}
 var DISCOVERY_MV_DDL = [DISCOVERY_VALUES_MV_DDL, DISCOVERY_PAIRS_MV_DDL];
 var addColumn = (table, name, type) => ({
   kind: "column",
@@ -3480,10 +3767,16 @@ var ALL_TABLE_NAMES = [
   TABLE_SPAN_EVENTS,
   TABLE_TRACE_ROOTS,
   TABLE_TRACE_BRANCHES,
+  TABLE_TRACE_ROOTS_DELTA,
+  TABLE_TRACE_BRANCHES_DELTA,
   TABLE_METRIC_EVENTS,
   TABLE_LOG_EVENTS,
   TABLE_SCORE_EVENTS,
   TABLE_FEEDBACK_EVENTS,
+  TABLE_METRIC_EVENTS_DELTA,
+  TABLE_LOG_EVENTS_DELTA,
+  TABLE_SCORE_EVENTS_DELTA,
+  TABLE_FEEDBACK_EVENTS_DELTA,
   TABLE_DISCOVERY_VALUES,
   TABLE_DISCOVERY_PAIRS
 ];
@@ -4098,7 +4391,7 @@ async function queryJson(client, query, params = {}) {
 async function getEntityTypes(client, _args) {
   const rows = await queryJson(
     client,
-    `SELECT value FROM ${TABLE_DISCOVERY_VALUES} WHERE kind = 'entityType' ORDER BY value`
+    `SELECT DISTINCT value FROM ${TABLE_DISCOVERY_VALUES} WHERE kind = 'entityType' ORDER BY value`
   );
   const validTypes = new Set(Object.values(storage.EntityType));
   const entityTypes = [];
@@ -4118,7 +4411,7 @@ async function getEntityNames(client, args) {
   }
   const rows = await queryJson(
     client,
-    `SELECT value FROM ${TABLE_DISCOVERY_PAIRS} WHERE ${conditions.join(" AND ")} ORDER BY value`,
+    `SELECT DISTINCT value FROM ${TABLE_DISCOVERY_PAIRS} WHERE ${conditions.join(" AND ")} ORDER BY value`,
     params
   );
   return { names: rows.map((r) => r.value) };
@@ -4126,14 +4419,14 @@ async function getEntityNames(client, args) {
 async function getServiceNames(client, _args) {
   const rows = await queryJson(
     client,
-    `SELECT value FROM ${TABLE_DISCOVERY_VALUES} WHERE kind = 'serviceName' ORDER BY value`
+    `SELECT DISTINCT value FROM ${TABLE_DISCOVERY_VALUES} WHERE kind = 'serviceName' ORDER BY value`
   );
   return { serviceNames: rows.map((r) => r.value) };
 }
 async function getEnvironments(client, _args) {
   const rows = await queryJson(
     client,
-    `SELECT value FROM ${TABLE_DISCOVERY_VALUES} WHERE kind = 'environment' ORDER BY value`
+    `SELECT DISTINCT value FROM ${TABLE_DISCOVERY_VALUES} WHERE kind = 'environment' ORDER BY value`
   );
   return { environments: rows.map((r) => r.value) };
 }
@@ -4146,7 +4439,7 @@ async function getTags(client, args) {
   }
   const rows = await queryJson(
     client,
-    `SELECT value FROM ${TABLE_DISCOVERY_VALUES} WHERE ${conditions.join(" AND ")} ORDER BY value`,
+    `SELECT DISTINCT value FROM ${TABLE_DISCOVERY_VALUES} WHERE ${conditions.join(" AND ")} ORDER BY value`,
     params
   );
   return { tags: rows.map((r) => r.value) };
@@ -4354,6 +4647,35 @@ function buildPaginationClause(pagination) {
     offset: page * perPage
   };
 }
+var OBSERVABILITY_DELTA_POLLING_FEATURE = "observability-delta-polling";
+function deltaPollingFeatureEnabled() {
+  return features.coreFeatures.has(OBSERVABILITY_DELTA_POLLING_FEATURE);
+}
+function deltaPollingSupported(strategy) {
+  return deltaPollingFeatureEnabled() && strategy !== null;
+}
+function assertDeltaPollingSupported(strategy) {
+  if (deltaPollingSupported(strategy)) {
+    return;
+  }
+  throw new error.MastraError({
+    id: "OBSERVABILITY_DELTA_POLLING_NOT_SUPPORTED",
+    domain: error.ErrorDomain.MASTRA_OBSERVABILITY,
+    category: error.ErrorCategory.SYSTEM,
+    text: "This storage provider does not support observability delta polling"
+  });
+}
+function validateCursorId(cursor) {
+  if (/^\d+$/.test(cursor)) {
+    return cursor;
+  }
+  throw new error.MastraError({
+    id: "OBSERVABILITY_INVALID_DELTA_CURSOR",
+    domain: error.ErrorDomain.MASTRA_OBSERVABILITY,
+    category: error.ErrorCategory.USER,
+    text: "Invalid observability delta cursor"
+  });
+}
 
 // src/storage/domains/observability/v-next/feedback.ts
 var FEEDBACK_TYPED_COLUMNS = /* @__PURE__ */ new Set([
@@ -4480,12 +4802,33 @@ async function batchCreateFeedback(client, args) {
     clickhouse_settings: CH_INSERT_SETTINGS
   });
 }
-async function listFeedback(client, args) {
+async function listFeedback(client, args, strategy) {
   const parsed = storage.listFeedbackArgsSchema.parse(args);
+  const deltaCursorEnabled = deltaPollingSupported(strategy);
   const filter = buildFeedbackFilterConditions(parsed.filters, "f");
   const pagination = buildPaginationClause(parsed.pagination);
   const orderBy = buildSignalOrderByClause(["timestamp"], parsed.orderBy, "f");
   const whereClause = filter.conditions.length ? `WHERE ${filter.conditions.join(" AND ")}` : "";
+  if (parsed.mode === "delta") {
+    assertDeltaPollingSupported(strategy);
+    const streamHeadCursor = await getStreamHeadCursor(client);
+    if (parsed.after === void 0) {
+      return {
+        feedback: [],
+        delta: { limit: parsed.limit, hasMore: false },
+        deltaCursor: streamHeadCursor
+      };
+    }
+    const afterCursor = validateCursorId(parsed.after);
+    const rows2 = await queryFeedbackAfterCursor(client, whereClause, filter.params, parsed.limit, afterCursor);
+    const visibleRows = rows2.slice(0, parsed.limit);
+    return {
+      feedback: visibleRows.map(rowToFeedbackRecord),
+      delta: { limit: parsed.limit, hasMore: rows2.length > parsed.limit },
+      deltaCursor: visibleRows.length > 0 ? buildFeedbackCursor(visibleRows[visibleRows.length - 1]) : streamHeadCursor
+    };
+  }
+  const currentDeltaCursor = deltaCursorEnabled ? await getDeltaCursor(client, whereClause, filter.params) : void 0;
   const countResult = await queryJson2(
     client,
     `SELECT count() AS total FROM ${TABLE_FEEDBACK_EVENTS} AS f ${whereClause}`,
@@ -4504,9 +4847,68 @@ async function listFeedback(client, args) {
       perPage: pagination.perPage,
       hasMore: (pagination.page + 1) * pagination.perPage < total
     },
-    feedback: rows.map(rowToFeedbackRecord)
+    feedback: rows.map(rowToFeedbackRecord),
+    ...deltaCursorEnabled ? { deltaCursor: currentDeltaCursor } : {}
   };
 }
+async function queryFeedbackAfterCursor(client, whereClause, params, limit, cursorId) {
+  return await queryJson2(
+    client,
+    `
+      SELECT
+        f.* EXCEPT(traceId, timestamp, feedbackId),
+        f.traceId AS traceId,
+        f.timestamp AS timestamp,
+        f.feedbackId AS feedbackId,
+        toString(d.cursorId) AS cursorId
+      FROM ${TABLE_FEEDBACK_EVENTS_DELTA} d
+      INNER JOIN ${TABLE_FEEDBACK_EVENTS} f
+        ON ((f.traceId = d.traceId) OR (f.traceId IS NULL AND d.traceId IS NULL))
+       AND f.timestamp = d.timestamp
+       AND f.feedbackId = d.feedbackId
+      ${whereClause ? `${whereClause} AND d.cursorId > {afterCursor:UInt64}` : "WHERE d.cursorId > {afterCursor:UInt64}"}
+      ORDER BY d.cursorId ASC
+      LIMIT {fetchLimit:UInt32}
+    `,
+    { ...params, afterCursor: cursorId, fetchLimit: limit + 1 }
+  );
+}
+async function getDeltaCursor(client, whereClause, params) {
+  const rows = await queryJson2(
+    client,
+    `
+      SELECT toString(max(d.cursorId)) AS cursorId
+      FROM ${TABLE_FEEDBACK_EVENTS_DELTA} d
+      INNER JOIN ${TABLE_FEEDBACK_EVENTS} f
+        ON ((f.traceId = d.traceId) OR (f.traceId IS NULL AND d.traceId IS NULL))
+       AND f.timestamp = d.timestamp
+       AND f.feedbackId = d.feedbackId
+      ${whereClause}
+    `,
+    params
+  );
+  const cursorId = rows[0]?.cursorId ?? null;
+  if (cursorId) {
+    return cursorId;
+  }
+  const streamRows = await queryJson2(
+    client,
+    `SELECT toString(max(cursorId)) AS cursorId FROM ${TABLE_FEEDBACK_EVENTS_DELTA}`,
+    {}
+  );
+  return streamRows[0]?.cursorId ?? "0";
+}
+async function getStreamHeadCursor(client) {
+  const streamRows = await queryJson2(
+    client,
+    `SELECT toString(max(cursorId)) AS cursorId FROM ${TABLE_FEEDBACK_EVENTS_DELTA}`,
+    {}
+  );
+  return streamRows[0]?.cursorId ?? "0";
+}
+function buildFeedbackCursor(row) {
+  return row.cursorId ?? "0";
+}
 async function getFeedbackAggregate(client, args) {
   const aggSql = getAggregationSql(args.aggregation);
   const identity = buildFeedbackIdentityFilter(args);
@@ -4676,12 +5078,33 @@ async function batchCreateLogs(client, args) {
     clickhouse_settings: CH_INSERT_SETTINGS
   });
 }
-async function listLogs(client, args) {
+async function listLogs(client, args, strategy) {
   const parsed = storage.listLogsArgsSchema.parse(args);
+  const deltaCursorEnabled = deltaPollingSupported(strategy);
   const filter = buildLogsFilterConditions(parsed.filters, "l");
   const pagination = buildPaginationClause(parsed.pagination);
   const orderBy = buildSignalOrderByClause(["timestamp"], parsed.orderBy, "l");
   const whereClause = filter.conditions.length ? `WHERE ${filter.conditions.join(" AND ")}` : "";
+  if (parsed.mode === "delta") {
+    assertDeltaPollingSupported(strategy);
+    const streamHeadCursor = await getStreamHeadCursor2(client);
+    if (parsed.after === void 0) {
+      return {
+        logs: [],
+        delta: { limit: parsed.limit, hasMore: false },
+        deltaCursor: streamHeadCursor
+      };
+    }
+    const afterCursor = validateCursorId(parsed.after);
+    const rows2 = await queryLogsAfterCursor(client, whereClause, filter.params, parsed.limit, afterCursor);
+    const visibleRows = rows2.slice(0, parsed.limit);
+    return {
+      logs: visibleRows.map(rowToLogRecord),
+      delta: { limit: parsed.limit, hasMore: rows2.length > parsed.limit },
+      deltaCursor: visibleRows.length > 0 ? buildLogsCursor(visibleRows[visibleRows.length - 1]) : streamHeadCursor
+    };
+  }
+  const currentDeltaCursor = deltaCursorEnabled ? await getDeltaCursor2(client, whereClause, filter.params) : void 0;
   const countResult = await (await client.query({
     query: `SELECT count() AS total FROM ${TABLE_LOG_EVENTS} AS l ${whereClause}`,
     query_params: filter.params,
@@ -4712,9 +5135,71 @@ async function listLogs(client, args) {
       perPage: pagination.perPage,
       hasMore: (pagination.page + 1) * pagination.perPage < total
     },
-    logs: rows.map(rowToLogRecord)
+    logs: rows.map(rowToLogRecord),
+    ...deltaCursorEnabled ? { deltaCursor: currentDeltaCursor } : {}
   };
 }
+async function queryLogsAfterCursor(client, whereClause, params, limit, cursorId) {
+  return await (await client.query({
+    query: `
+        SELECT
+          l.* EXCEPT(timestamp, logId),
+          l.timestamp AS timestamp,
+          l.logId AS logId,
+          toString(d.cursorId) AS cursorId
+        FROM ${TABLE_LOG_EVENTS_DELTA} d
+        INNER JOIN ${TABLE_LOG_EVENTS} l
+          ON l.timestamp = d.timestamp
+         AND l.logId = d.logId
+        ${whereClause ? `${whereClause} AND d.cursorId > {afterCursor:UInt64}` : "WHERE d.cursorId > {afterCursor:UInt64}"}
+        ORDER BY d.cursorId ASC
+        LIMIT {fetchLimit:UInt32}
+      `,
+    query_params: {
+      ...params,
+      afterCursor: cursorId,
+      fetchLimit: limit + 1
+    },
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  })).json();
+}
+async function getDeltaCursor2(client, whereClause, params) {
+  const rows = await (await client.query({
+    query: `
+        SELECT toString(max(d.cursorId)) AS cursorId
+        FROM ${TABLE_LOG_EVENTS_DELTA} d
+        INNER JOIN ${TABLE_LOG_EVENTS} l
+          ON l.timestamp = d.timestamp
+         AND l.logId = d.logId
+        ${whereClause}
+      `,
+    query_params: params,
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  })).json();
+  const cursorId = rows[0]?.cursorId ?? null;
+  if (cursorId) {
+    return cursorId;
+  }
+  const streamRows = await (await client.query({
+    query: `SELECT toString(max(cursorId)) AS cursorId FROM ${TABLE_LOG_EVENTS_DELTA}`,
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  })).json();
+  return streamRows[0]?.cursorId ?? "0";
+}
+async function getStreamHeadCursor2(client) {
+  const streamRows = await (await client.query({
+    query: `SELECT toString(max(cursorId)) AS cursorId FROM ${TABLE_LOG_EVENTS_DELTA}`,
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  })).json();
+  return streamRows[0]?.cursorId ?? "0";
+}
+function buildLogsCursor(row) {
+  return row.cursorId ?? "0";
+}
 var METRIC_TYPED_COLUMNS = /* @__PURE__ */ new Set([
   "timestamp",
   "name",
@@ -4884,12 +5369,33 @@ async function batchCreateMetrics(client, args) {
     clickhouse_settings: CH_INSERT_SETTINGS
   });
 }
-async function listMetrics(client, args) {
+async function listMetrics(client, args, strategy) {
   const parsed = storage.listMetricsArgsSchema.parse(args);
+  const deltaCursorEnabled = deltaPollingSupported(strategy);
   const filter = buildMetricsFilterConditions(parsed.filters, "m");
   const pagination = buildPaginationClause(parsed.pagination);
   const orderBy = buildSignalOrderByClause(["timestamp"], parsed.orderBy, "m");
   const whereClause = filter.conditions.length ? `WHERE ${filter.conditions.join(" AND ")}` : "";
+  if (parsed.mode === "delta") {
+    assertDeltaPollingSupported(strategy);
+    const streamHeadCursor = await getStreamHeadCursor3(client);
+    if (parsed.after === void 0) {
+      return {
+        metrics: [],
+        delta: { limit: parsed.limit, hasMore: false },
+        deltaCursor: streamHeadCursor
+      };
+    }
+    const afterCursor = validateCursorId(parsed.after);
+    const rows2 = await queryMetricsAfterCursor(client, whereClause, filter.params, parsed.limit, afterCursor);
+    const visibleRows = rows2.slice(0, parsed.limit);
+    return {
+      metrics: visibleRows.map(rowToMetricRecord),
+      delta: { limit: parsed.limit, hasMore: rows2.length > parsed.limit },
+      deltaCursor: visibleRows.length > 0 ? buildMetricsCursor(visibleRows[visibleRows.length - 1]) : streamHeadCursor
+    };
+  }
+  const currentDeltaCursor = deltaCursorEnabled ? await getDeltaCursor3(client, whereClause, filter.params) : void 0;
   const countResult = await queryJson3(
     client,
     `SELECT count() AS total FROM ${TABLE_METRIC_EVENTS} AS m ${whereClause}`,
@@ -4908,9 +5414,68 @@ async function listMetrics(client, args) {
       perPage: pagination.perPage,
       hasMore: (pagination.page + 1) * pagination.perPage < total
     },
-    metrics: rows.map(rowToMetricRecord)
+    metrics: rows.map(rowToMetricRecord),
+    ...deltaCursorEnabled ? { deltaCursor: currentDeltaCursor } : {}
   };
 }
+async function queryMetricsAfterCursor(client, whereClause, params, limit, cursorId) {
+  return await queryJson3(
+    client,
+    `
+      SELECT
+        m.* EXCEPT(name, timestamp, metricId),
+        m.name AS name,
+        m.timestamp AS timestamp,
+        m.metricId AS metricId,
+        toString(d.cursorId) AS cursorId
+      FROM ${TABLE_METRIC_EVENTS_DELTA} d
+      INNER JOIN ${TABLE_METRIC_EVENTS} m
+        ON m.name = d.name
+       AND m.timestamp = d.timestamp
+       AND m.metricId = d.metricId
+      ${whereClause ? `${whereClause} AND d.cursorId > {afterCursor:UInt64}` : "WHERE d.cursorId > {afterCursor:UInt64}"}
+      ORDER BY d.cursorId ASC
+      LIMIT {fetchLimit:UInt32}
+    `,
+    { ...params, afterCursor: cursorId, fetchLimit: limit + 1 }
+  );
+}
+async function getDeltaCursor3(client, whereClause, params) {
+  const rows = await queryJson3(
+    client,
+    `
+      SELECT toString(max(d.cursorId)) AS cursorId
+      FROM ${TABLE_METRIC_EVENTS_DELTA} d
+      INNER JOIN ${TABLE_METRIC_EVENTS} m
+        ON m.name = d.name
+       AND m.timestamp = d.timestamp
+       AND m.metricId = d.metricId
+      ${whereClause}
+    `,
+    params
+  );
+  const cursorId = rows[0]?.cursorId ?? null;
+  if (cursorId) {
+    return cursorId;
+  }
+  const streamRows = await queryJson3(
+    client,
+    `SELECT toString(max(cursorId)) AS cursorId FROM ${TABLE_METRIC_EVENTS_DELTA}`,
+    {}
+  );
+  return streamRows[0]?.cursorId ?? "0";
+}
+async function getStreamHeadCursor3(client) {
+  const streamRows = await queryJson3(
+    client,
+    `SELECT toString(max(cursorId)) AS cursorId FROM ${TABLE_METRIC_EVENTS_DELTA}`,
+    {}
+  );
+  return streamRows[0]?.cursorId ?? "0";
+}
+function buildMetricsCursor(row) {
+  return row.cursorId ?? "0";
+}
 async function getMetricAggregate(client, args) {
   const aggSql = getAggregationSql2(args.aggregation, "value", args.distinctColumn);
   const nameFilter = buildMetricNameFilter(args.name);
@@ -5154,7 +5719,7 @@ async function getMetricNames(client, args) {
   if (args.limit) params.nameLimit = args.limit;
   const rows = await queryJson3(
     client,
-    `SELECT value FROM ${TABLE_DISCOVERY_VALUES} WHERE ${conditions.join(" AND ")} ORDER BY value ${limitClause}`,
+    `SELECT DISTINCT value FROM ${TABLE_DISCOVERY_VALUES} WHERE ${conditions.join(" AND ")} ORDER BY value ${limitClause}`,
     params
   );
   return { names: rows.map((r) => r.value) };
@@ -5162,7 +5727,7 @@ async function getMetricNames(client, args) {
 async function getMetricLabelKeys(client, args) {
   const rows = await queryJson3(
     client,
-    `SELECT value FROM ${TABLE_DISCOVERY_VALUES} WHERE kind = 'metricLabelKey' AND key1 = {metricName:String} ORDER BY value`,
+    `SELECT DISTINCT value FROM ${TABLE_DISCOVERY_VALUES} WHERE kind = 'metricLabelKey' AND key1 = {metricName:String} ORDER BY value`,
     { metricName: args.metricName }
   );
   return { keys: rows.map((r) => r.value) };
@@ -5181,7 +5746,7 @@ async function getMetricLabelValues(client, args) {
   if (args.limit) params.valLimit = args.limit;
   const rows = await queryJson3(
     client,
-    `SELECT value FROM ${TABLE_DISCOVERY_PAIRS} WHERE ${conditions.join(" AND ")} ORDER BY value ${limitClause}`,
+    `SELECT DISTINCT value FROM ${TABLE_DISCOVERY_PAIRS} WHERE ${conditions.join(" AND ")} ORDER BY value ${limitClause}`,
     params
   );
   return { values: rows.map((r) => r.value) };
@@ -5399,12 +5964,33 @@ async function batchCreateScores(client, args) {
     clickhouse_settings: CH_INSERT_SETTINGS
   });
 }
-async function listScores(client, args) {
+async function listScores(client, args, strategy) {
   const parsed = storage.listScoresArgsSchema.parse(args);
+  const deltaCursorEnabled = deltaPollingSupported(strategy);
   const filter = buildScoresFilterConditions(parsed.filters, "s");
   const pagination = buildPaginationClause(parsed.pagination);
   const orderBy = buildSignalOrderByClause(["timestamp", "score"], parsed.orderBy, "s");
   const whereClause = filter.conditions.length ? `WHERE ${filter.conditions.join(" AND ")}` : "";
+  if (parsed.mode === "delta") {
+    assertDeltaPollingSupported(strategy);
+    const streamHeadCursor = await getStreamHeadCursor4(client);
+    if (parsed.after === void 0) {
+      return {
+        scores: [],
+        delta: { limit: parsed.limit, hasMore: false },
+        deltaCursor: streamHeadCursor
+      };
+    }
+    const afterCursor = validateCursorId(parsed.after);
+    const rows2 = await queryScoresAfterCursor(client, whereClause, filter.params, parsed.limit, afterCursor);
+    const visibleRows = rows2.slice(0, parsed.limit);
+    return {
+      scores: visibleRows.map(rowToScoreRecord),
+      delta: { limit: parsed.limit, hasMore: rows2.length > parsed.limit },
+      deltaCursor: visibleRows.length > 0 ? buildScoresCursor(visibleRows[visibleRows.length - 1]) : streamHeadCursor
+    };
+  }
+  const currentDeltaCursor = deltaCursorEnabled ? await getDeltaCursor4(client, whereClause, filter.params) : void 0;
   const countResult = await queryJson4(
     client,
     `SELECT count() AS total FROM ${TABLE_SCORE_EVENTS} AS s ${whereClause}`,
@@ -5423,9 +6009,68 @@ async function listScores(client, args) {
       perPage: pagination.perPage,
       hasMore: (pagination.page + 1) * pagination.perPage < total
     },
-    scores: rows.map(rowToScoreRecord)
+    scores: rows.map(rowToScoreRecord),
+    ...deltaCursorEnabled ? { deltaCursor: currentDeltaCursor } : {}
   };
 }
+async function queryScoresAfterCursor(client, whereClause, params, limit, cursorId) {
+  return await queryJson4(
+    client,
+    `
+      SELECT
+        s.* EXCEPT(traceId, timestamp, scoreId),
+        s.traceId AS traceId,
+        s.timestamp AS timestamp,
+        s.scoreId AS scoreId,
+        toString(d.cursorId) AS cursorId
+      FROM ${TABLE_SCORE_EVENTS_DELTA} d
+      INNER JOIN ${TABLE_SCORE_EVENTS} s
+        ON ((s.traceId = d.traceId) OR (s.traceId IS NULL AND d.traceId IS NULL))
+       AND s.timestamp = d.timestamp
+       AND s.scoreId = d.scoreId
+      ${whereClause ? `${whereClause} AND d.cursorId > {afterCursor:UInt64}` : "WHERE d.cursorId > {afterCursor:UInt64}"}
+      ORDER BY d.cursorId ASC
+      LIMIT {fetchLimit:UInt32}
+    `,
+    { ...params, afterCursor: cursorId, fetchLimit: limit + 1 }
+  );
+}
+async function getDeltaCursor4(client, whereClause, params) {
+  const rows = await queryJson4(
+    client,
+    `
+      SELECT toString(max(d.cursorId)) AS cursorId
+      FROM ${TABLE_SCORE_EVENTS_DELTA} d
+      INNER JOIN ${TABLE_SCORE_EVENTS} s
+        ON ((s.traceId = d.traceId) OR (s.traceId IS NULL AND d.traceId IS NULL))
+       AND s.timestamp = d.timestamp
+       AND s.scoreId = d.scoreId
+      ${whereClause}
+    `,
+    params
+  );
+  const cursorId = rows[0]?.cursorId ?? null;
+  if (cursorId) {
+    return cursorId;
+  }
+  const streamRows = await queryJson4(
+    client,
+    `SELECT toString(max(cursorId)) AS cursorId FROM ${TABLE_SCORE_EVENTS_DELTA}`,
+    {}
+  );
+  return streamRows[0]?.cursorId ?? "0";
+}
+async function getStreamHeadCursor4(client) {
+  const streamRows = await queryJson4(
+    client,
+    `SELECT toString(max(cursorId)) AS cursorId FROM ${TABLE_SCORE_EVENTS_DELTA}`,
+    {}
+  );
+  return streamRows[0]?.cursorId ?? "0";
+}
+function buildScoresCursor(row) {
+  return row.cursorId ?? "0";
+}
 async function getScoreById(client, scoreId) {
   const rows = await queryJson4(
     client,
@@ -5688,8 +6333,107 @@ async function listTraceRows(client, args, selectClause, mapRows) {
     spans: mapRows(rows)
   };
 }
-async function listTraces(client, args) {
-  return listTraceRows(client, args, "*", (rows) => storage.toTraceSpans(rows.map(rowToSpanRecord)));
+async function listTraces(client, args, strategy) {
+  const { mode, filters, pagination, orderBy, after, limit } = storage.listTracesArgsSchema.parse(args);
+  const page = pagination?.page ?? 0;
+  const perPage = pagination?.perPage ?? 10;
+  const { conditions, params } = buildTraceFilterConditions(filters, "r");
+  if (filters?.hasChildError != null) {
+    if (filters.hasChildError) {
+      conditions.push(`EXISTS (
+        SELECT 1 FROM ${TABLE_SPAN_EVENTS} c
+        WHERE c.traceId = r.traceId
+          AND c.parentSpanId IS NOT NULL
+          AND c.error IS NOT NULL
+      )`);
+    } else {
+      conditions.push(`NOT EXISTS (
+        SELECT 1 FROM ${TABLE_SPAN_EVENTS} c
+        WHERE c.traceId = r.traceId
+          AND c.parentSpanId IS NOT NULL
+          AND c.error IS NOT NULL
+      )`);
+    }
+  }
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const deltaCursorEnabled = deltaPollingSupported(strategy);
+  if (mode === "delta") {
+    assertDeltaPollingSupported(strategy);
+    const streamHeadCursor = await getStreamHeadCursor5(client);
+    if (after === void 0) {
+      return {
+        spans: [],
+        delta: { limit, hasMore: false },
+        deltaCursor: streamHeadCursor
+      };
+    }
+    const afterCursor = validateCursorId(after);
+    const rows2 = await queryTracesAfterCursor(client, whereClause, params, limit, afterCursor);
+    const visibleRows = rows2.slice(0, limit);
+    return {
+      spans: storage.toTraceSpans(visibleRows.map(rowToSpanRecord)),
+      delta: { limit, hasMore: rows2.length > limit },
+      deltaCursor: visibleRows.length > 0 ? buildTraceCursor(visibleRows[visibleRows.length - 1]) : streamHeadCursor
+    };
+  }
+  const orderClause = buildTraceOrderByClause(orderBy);
+  const currentDeltaCursor = deltaCursorEnabled ? await getDeltaCursor5(client, whereClause, params) : void 0;
+  const countResult = await client.query({
+    query: `
+      SELECT count() as cnt FROM (
+        SELECT dedupeKey
+        FROM ${TABLE_TRACE_ROOTS} r
+        ${whereClause}
+        ORDER BY dedupeKey
+        LIMIT 1 BY dedupeKey
+      )
+    `,
+    query_params: params,
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  });
+  const countRows = await countResult.json();
+  const total = Number(countRows[0]?.cnt ?? 0);
+  if (total === 0) {
+    return {
+      pagination: { total: 0, page, perPage, hasMore: false },
+      spans: [],
+      ...deltaCursorEnabled ? { deltaCursor: currentDeltaCursor } : {}
+    };
+  }
+  const dataResult = await client.query({
+    query: `
+      SELECT * FROM (
+        SELECT *
+        FROM ${TABLE_TRACE_ROOTS} r
+        ${whereClause}
+        ORDER BY dedupeKey
+        LIMIT 1 BY dedupeKey
+      )
+      ORDER BY ${orderClause}
+      LIMIT {limit:UInt32}
+      OFFSET {offset:UInt32}
+    `,
+    query_params: {
+      ...params,
+      limit: perPage,
+      offset: page * perPage
+    },
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  });
+  const rows = await dataResult.json();
+  const spans = rows.map(rowToSpanRecord);
+  return {
+    pagination: {
+      total,
+      page,
+      perPage,
+      hasMore: (page + 1) * perPage < total
+    },
+    spans: storage.toTraceSpans(spans),
+    ...deltaCursorEnabled ? { deltaCursor: currentDeltaCursor } : {}
+  };
 }
 var LIGHT_TRACE_ROOT_COLUMNS = [
   "traceId",
@@ -5708,6 +6452,70 @@ var LIGHT_TRACE_ROOT_COLUMNS = [
 async function listTracesLight(client, args) {
   return listTraceRows(client, args, LIGHT_TRACE_ROOT_COLUMNS, (rows) => rows.map(rowToLightSpanRecord));
 }
+async function queryTracesAfterCursor(client, whereClause, params, limit, cursorId) {
+  return await (await client.query({
+    query: `
+        SELECT
+          r.* EXCEPT(startedAt, traceId, dedupeKey),
+          r.startedAt AS startedAt,
+          r.traceId AS traceId,
+          r.dedupeKey AS dedupeKey,
+          toString(d.cursorId) AS cursorId
+        FROM ${TABLE_TRACE_ROOTS_DELTA} d
+        INNER JOIN ${TABLE_TRACE_ROOTS} r
+          ON r.startedAt = d.startedAt
+         AND r.traceId = d.traceId
+         AND r.dedupeKey = d.dedupeKey
+        ${whereClause ? `${whereClause} AND d.cursorId > {afterCursor:UInt64}` : "WHERE d.cursorId > {afterCursor:UInt64}"}
+        ORDER BY d.cursorId ASC
+        LIMIT {fetchLimit:UInt32}
+      `,
+    query_params: {
+      ...params,
+      afterCursor: cursorId,
+      fetchLimit: limit + 1
+    },
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  })).json();
+}
+async function getDeltaCursor5(client, whereClause, params) {
+  const rows = await (await client.query({
+    query: `
+        SELECT toString(max(d.cursorId)) AS cursorId
+        FROM ${TABLE_TRACE_ROOTS_DELTA} d
+        INNER JOIN ${TABLE_TRACE_ROOTS} r
+          ON r.startedAt = d.startedAt
+         AND r.traceId = d.traceId
+         AND r.dedupeKey = d.dedupeKey
+        ${whereClause}
+      `,
+    query_params: params,
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  })).json();
+  const cursorId = rows[0]?.cursorId ?? null;
+  if (cursorId) {
+    return cursorId;
+  }
+  const streamRows = await (await client.query({
+    query: `SELECT toString(max(cursorId)) AS cursorId FROM ${TABLE_TRACE_ROOTS_DELTA}`,
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  })).json();
+  return streamRows[0]?.cursorId ?? "0";
+}
+async function getStreamHeadCursor5(client) {
+  const streamRows = await (await client.query({
+    query: `SELECT toString(max(cursorId)) AS cursorId FROM ${TABLE_TRACE_ROOTS_DELTA}`,
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  })).json();
+  return streamRows[0]?.cursorId ?? "0";
+}
+function buildTraceCursor(row) {
+  return row.cursorId ?? "0";
+}
 var BRANCH_SPAN_TYPE_SQL_LIST = storage.BRANCH_SPAN_TYPES.map((t) => `'${t}'`).join(", ");
 async function createSpan(client, args) {
   const row = spanRecordToRow(args.span);
@@ -5839,36 +6647,36 @@ async function batchDeleteTraces(client, args) {
     })
   ]);
 }
-async function listBranches(client, args) {
-  const { filters, pagination, orderBy } = storage.listBranchesArgsSchema.parse(args);
+async function listBranches(client, args, strategy) {
+  const { mode, filters, pagination, orderBy, after, limit } = storage.listBranchesArgsSchema.parse(args);
   const page = pagination?.page ?? 0;
   const perPage = pagination?.perPage ?? 10;
   const conditions = [];
   const params = {};
   if (filters?.spanType) {
-    conditions.push(`spanType = {spanType:String}`);
+    conditions.push(`b.spanType = {spanType:String}`);
     params.spanType = filters.spanType;
   } else {
-    conditions.push(`spanType IN (${BRANCH_SPAN_TYPE_SQL_LIST})`);
+    conditions.push(`b.spanType IN (${BRANCH_SPAN_TYPE_SQL_LIST})`);
   }
   if (filters?.startedAt?.start) {
     const op = filters.startedAt.startExclusive ? ">" : ">=";
-    conditions.push(`startedAt ${op} {startedAtStart:DateTime64(3)}`);
+    conditions.push(`b.startedAt ${op} {startedAtStart:DateTime64(3)}`);
     params.startedAtStart = filters.startedAt.start.getTime();
   }
   if (filters?.startedAt?.end) {
     const op = filters.startedAt.endExclusive ? "<" : "<=";
-    conditions.push(`startedAt ${op} {startedAtEnd:DateTime64(3)}`);
+    conditions.push(`b.startedAt ${op} {startedAtEnd:DateTime64(3)}`);
     params.startedAtEnd = filters.startedAt.end.getTime();
   }
   if (filters?.endedAt?.start) {
     const op = filters.endedAt.startExclusive ? ">" : ">=";
-    conditions.push(`endedAt ${op} {endedAtStart:DateTime64(3)}`);
+    conditions.push(`b.endedAt ${op} {endedAtStart:DateTime64(3)}`);
     params.endedAtStart = filters.endedAt.start.getTime();
   }
   if (filters?.endedAt?.end) {
     const op = filters.endedAt.endExclusive ? "<" : "<=";
-    conditions.push(`endedAt ${op} {endedAtEnd:DateTime64(3)}`);
+    conditions.push(`b.endedAt ${op} {endedAtEnd:DateTime64(3)}`);
     params.endedAtEnd = filters.endedAt.end.getTime();
   }
   const eq = [
@@ -5899,7 +6707,7 @@ async function listBranches(client, args) {
   ];
   for (const { col, value, param } of eq) {
     if (value == null) continue;
-    conditions.push(`${col} = {${param}:String}`);
+    conditions.push(`b.${col} = {${param}:String}`);
     params[param] = value;
   }
   if (filters?.tags && filters.tags.length > 0) {
@@ -5907,7 +6715,7 @@ async function listBranches(client, args) {
       const tag = filters.tags[i];
       if (typeof tag !== "string" || tag.trim() === "") continue;
       const param = `tag_${i}`;
-      conditions.push(`has(tags, {${param}:String})`);
+      conditions.push(`has(b.tags, {${param}:String})`);
       params[param] = tag;
     }
   }
@@ -5917,7 +6725,7 @@ async function listBranches(client, args) {
       if (typeof value !== "string") continue;
       const keyParam = `meta_k_${i}`;
       const valParam = `meta_v_${i}`;
-      conditions.push(`metadataSearch[{${keyParam}:String}] = {${valParam}:String}`);
+      conditions.push(`b.metadataSearch[{${keyParam}:String}] = {${valParam}:String}`);
       params[keyParam] = key;
       params[valParam] = value;
       i++;
@@ -5931,30 +6739,51 @@ async function listBranches(client, args) {
       if (normalized == null) continue;
       const keyParam = `scope_k_${i}`;
       const valParam = `scope_v_${i}`;
-      conditions.push(`JSONExtractString(scope, {${keyParam}:String}) = {${valParam}:String}`);
+      conditions.push(`JSONExtractString(b.scope, {${keyParam}:String}) = {${valParam}:String}`);
       params[keyParam] = key;
       params[valParam] = normalized;
       i++;
     }
   }
   if (filters?.status === storage.TraceStatus.ERROR) {
-    conditions.push(`error IS NOT NULL`);
+    conditions.push(`b.error IS NOT NULL`);
   } else if (filters?.status === storage.TraceStatus.SUCCESS) {
-    conditions.push(`error IS NULL`);
+    conditions.push(`b.error IS NULL`);
   } else if (filters?.status === storage.TraceStatus.RUNNING) {
     conditions.push("1 = 0");
   }
   const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const deltaCursorEnabled = deltaPollingSupported(strategy);
+  if (mode === "delta") {
+    assertDeltaPollingSupported(strategy);
+    const streamHeadCursor = await getStreamHeadCursor6(client);
+    if (after === void 0) {
+      return {
+        branches: [],
+        delta: { limit, hasMore: false },
+        deltaCursor: streamHeadCursor
+      };
+    }
+    const afterCursor = validateCursorId(after);
+    const rows2 = await queryBranchesAfterCursor(client, whereClause, params, limit, afterCursor);
+    const visibleRows = rows2.slice(0, limit);
+    return {
+      branches: storage.toTraceSpans(visibleRows.map(rowToSpanRecord)),
+      delta: { limit, hasMore: rows2.length > limit },
+      deltaCursor: visibleRows.length > 0 ? buildBranchCursor(visibleRows[visibleRows.length - 1]) : streamHeadCursor
+    };
+  }
   const sortField = orderBy?.field === "endedAt" ? "endedAt" : "startedAt";
   const sortDirection = orderBy?.direction === "ASC" ? "ASC" : "DESC";
+  const currentDeltaCursor = deltaCursorEnabled ? await getDeltaCursor6(client, whereClause, params) : void 0;
   const countResult = await client.query({
     query: `
       SELECT count() as cnt FROM (
         SELECT dedupeKey
-        FROM ${TABLE_TRACE_BRANCHES}
+        FROM ${TABLE_TRACE_BRANCHES} b
         ${whereClause}
-        ORDER BY dedupeKey
-        LIMIT 1 BY dedupeKey
+        ORDER BY b.dedupeKey
+        LIMIT 1 BY b.dedupeKey
       )
     `,
     query_params: params,
@@ -5966,17 +6795,18 @@ async function listBranches(client, args) {
   if (total === 0) {
     return {
       pagination: { total: 0, page, perPage, hasMore: false },
-      branches: []
+      branches: [],
+      ...deltaCursorEnabled ? { deltaCursor: currentDeltaCursor } : {}
     };
   }
   const dataResult = await client.query({
     query: `
       SELECT * FROM (
         SELECT *
-        FROM ${TABLE_TRACE_BRANCHES}
+        FROM ${TABLE_TRACE_BRANCHES} b
         ${whereClause}
-        ORDER BY dedupeKey
-        LIMIT 1 BY dedupeKey
+        ORDER BY b.dedupeKey
+        LIMIT 1 BY b.dedupeKey
       )
       ORDER BY ${sortField} ${sortDirection}, dedupeKey ASC
       LIMIT {limit:UInt32}
@@ -5999,9 +6829,80 @@ async function listBranches(client, args) {
       perPage,
       hasMore: (page + 1) * perPage < total
     },
-    branches: storage.toTraceSpans(spans)
+    branches: storage.toTraceSpans(spans),
+    ...deltaCursorEnabled ? { deltaCursor: currentDeltaCursor } : {}
   };
 }
+async function queryBranchesAfterCursor(client, whereClause, params, limit, cursorId) {
+  return await (await client.query({
+    query: `
+        SELECT
+          b.* EXCEPT(spanType, startedAt, traceId, spanId, dedupeKey),
+          b.spanType AS spanType,
+          b.startedAt AS startedAt,
+          b.traceId AS traceId,
+          b.spanId AS spanId,
+          b.dedupeKey AS dedupeKey,
+          toString(d.cursorId) AS cursorId
+        FROM ${TABLE_TRACE_BRANCHES_DELTA} d
+        INNER JOIN ${TABLE_TRACE_BRANCHES} b
+          ON b.spanType = d.spanType
+         AND b.startedAt = d.startedAt
+         AND b.traceId = d.traceId
+         AND b.spanId = d.spanId
+         AND b.dedupeKey = d.dedupeKey
+        ${whereClause ? `${whereClause} AND d.cursorId > {afterCursor:UInt64}` : "WHERE d.cursorId > {afterCursor:UInt64}"}
+        ORDER BY d.cursorId ASC
+        LIMIT {fetchLimit:UInt32}
+      `,
+    query_params: {
+      ...params,
+      afterCursor: cursorId,
+      fetchLimit: limit + 1
+    },
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  })).json();
+}
+async function getDeltaCursor6(client, whereClause, params) {
+  const rows = await (await client.query({
+    query: `
+        SELECT toString(max(d.cursorId)) AS cursorId
+        FROM ${TABLE_TRACE_BRANCHES_DELTA} d
+        INNER JOIN ${TABLE_TRACE_BRANCHES} b
+          ON b.spanType = d.spanType
+         AND b.startedAt = d.startedAt
+         AND b.traceId = d.traceId
+         AND b.spanId = d.spanId
+         AND b.dedupeKey = d.dedupeKey
+        ${whereClause}
+      `,
+    query_params: params,
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  })).json();
+  const cursorId = rows[0]?.cursorId ?? null;
+  if (cursorId) {
+    return cursorId;
+  }
+  const streamRows = await (await client.query({
+    query: `SELECT toString(max(cursorId)) AS cursorId FROM ${TABLE_TRACE_BRANCHES_DELTA}`,
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  })).json();
+  return streamRows[0]?.cursorId ?? "0";
+}
+async function getStreamHeadCursor6(client) {
+  const streamRows = await (await client.query({
+    query: `SELECT toString(max(cursorId)) AS cursorId FROM ${TABLE_TRACE_BRANCHES_DELTA}`,
+    format: "JSONEachRow",
+    clickhouse_settings: CH_SETTINGS
+  })).json();
+  return streamRows[0]?.cursorId ?? "0";
+}
+function buildBranchCursor(row) {
+  return row.cursorId ?? "0";
+}
 
 // src/storage/domains/observability/v-next/index.ts
 function buildSignalMigrationRequiredMessage(args) {
@@ -6080,6 +6981,30 @@ async function filterAppliedRetention(client, entries) {
     return current.column !== e.column || current.days !== e.days;
   });
 }
+async function reconcileDiscoveryTables(client) {
+  let engines;
+  try {
+    const result = await client.query({
+      query: `SELECT name, engine FROM system.tables WHERE database = currentDatabase() AND name IN ({tables:Array(String)})`,
+      query_params: { tables: [TABLE_DISCOVERY_VALUES, TABLE_DISCOVERY_PAIRS] },
+      format: "JSONEachRow"
+    });
+    const rows = await result.json();
+    engines = new Map(rows.map((r) => [r.name, r.engine]));
+  } catch {
+    return;
+  }
+  const targets = [
+    { table: TABLE_DISCOVERY_VALUES, mv: MV_DISCOVERY_VALUES },
+    { table: TABLE_DISCOVERY_PAIRS, mv: MV_DISCOVERY_PAIRS }
+  ];
+  for (const { table, mv } of targets) {
+    const engine = engines.get(table);
+    if (!engine || isReplacingMergeTreeEngine(engine)) continue;
+    await client.command({ query: `DROP VIEW IF EXISTS ${mv}` });
+    await client.command({ query: `DROP TABLE IF EXISTS ${table}` });
+  }
+}
 async function queryNamesByTable(client, query, tables) {
   const result = await client.query({
     query,
@@ -6098,14 +7023,72 @@ async function queryNamesByTable(client, query, tables) {
   }
   return out;
 }
+async function detectDeltaCursorStrategy(client, override, existingStrategy) {
+  if (existingStrategy && existingStrategy !== "mixed") {
+    return existingStrategy;
+  }
+  try {
+    await client.query({
+      query: `SELECT generateSerialID({counterName:String}) AS cursorId`,
+      query_params: { counterName: "mastra_observability_delta_cursor_probe" },
+      format: "JSONEachRow"
+    });
+    return "serial";
+  } catch {
+    return "fallback";
+  }
+}
+async function detectExistingDeltaCursorStrategy(client) {
+  try {
+    const mvResult = await client.query({
+      query: `
+        SELECT name, create_table_query
+        FROM system.tables
+        WHERE database = currentDatabase()
+          AND name IN ({tables:Array(String)})
+      `,
+      query_params: { tables: [...DELTA_MV_NAMES] },
+      format: "JSONEachRow"
+    });
+    const mvRows = await mvResult.json();
+    if (mvRows.length === 0) {
+      return null;
+    }
+    let sawSerialMv = false;
+    let sawFallbackMv = false;
+    for (const row of mvRows) {
+      const ddl = row.create_table_query ?? "";
+      if (ddl.includes("generateSerialID(")) {
+        sawSerialMv = true;
+      } else if (ddl.includes("farmFingerprint64(")) {
+        sawFallbackMv = true;
+      }
+    }
+    if (sawSerialMv && sawFallbackMv) {
+      return "mixed";
+    }
+    if (sawSerialMv) {
+      return "serial";
+    }
+    if (sawFallbackMv) {
+      return "fallback";
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 var ObservabilityStorageClickhouseVNext = class extends storage.ObservabilityStorage {
   #client;
   #retention;
+  #deltaCursorStrategyOverride;
+  #deltaCursorStrategy = "fallback";
   constructor(config) {
     super();
     const { client } = resolveClickhouseConfig(config);
     this.#client = client;
     this.#retention = config.retention;
+    this.#deltaCursorStrategyOverride = config.deltaCursorStrategy;
   }
   // -------------------------------------------------------------------------
   // Initialization
@@ -6124,7 +7107,22 @@ var ObservabilityStorageClickhouseVNext = class extends storage.ObservabilitySto
       });
     }
     try {
-      for (const ddl of [...ALL_TABLE_DDL, ...ALL_MV_DDL]) {
+      const existingStrategy = await detectExistingDeltaCursorStrategy(this.#client);
+      if (existingStrategy === "mixed") {
+        this.#deltaCursorStrategy = null;
+        this.logger.error(
+          "ClickHouse observability delta tables use mixed cursor schemas; delta polling has been disabled for this store instance."
+        );
+      } else if (this.#deltaCursorStrategyOverride) {
+        this.#deltaCursorStrategy = this.#deltaCursorStrategyOverride;
+      } else if (existingStrategy) {
+        this.#deltaCursorStrategy = existingStrategy;
+      } else {
+        this.#deltaCursorStrategy = await detectDeltaCursorStrategy(this.#client, void 0, existingStrategy);
+      }
+      await reconcileDiscoveryTables(this.#client);
+      const coreDdl = this.#deltaCursorStrategy === null ? [...BASE_TABLE_DDL, ...BASE_MV_DDL] : [...buildAllTableDDL(), ...buildAllMvDDL(this.#deltaCursorStrategy)];
+      for (const ddl of coreDdl) {
         await this.#client.command({ query: ddl });
       }
       const pendingMigrations = await filterAppliedMigrations(this.#client, ALL_MIGRATIONS);
@@ -6195,6 +7193,12 @@ var ObservabilityStorageClickhouseVNext = class extends storage.ObservabilitySto
       supported: ["insert-only"]
     };
   }
+  getFeatures() {
+    if (!deltaPollingSupported(this.#deltaCursorStrategy)) {
+      return void 0;
+    }
+    return ["delta-polling"];
+  }
   // -------------------------------------------------------------------------
   // Tracing — writes
   // -------------------------------------------------------------------------
@@ -6315,7 +7319,7 @@ var ObservabilityStorageClickhouseVNext = class extends storage.ObservabilitySto
   }
   async listTraces(args) {
     try {
-      return await listTraces(this.#client, args);
+      return await listTraces(this.#client, args, this.#deltaCursorStrategy);
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
@@ -6345,7 +7349,7 @@ var ObservabilityStorageClickhouseVNext = class extends storage.ObservabilitySto
   }
   async listBranches(args) {
     try {
-      return await listBranches(this.#client, args);
+      return await listBranches(this.#client, args, this.#deltaCursorStrategy);
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
@@ -6376,7 +7380,7 @@ var ObservabilityStorageClickhouseVNext = class extends storage.ObservabilitySto
   }
   async listLogs(args) {
     try {
-      return await listLogs(this.#client, args);
+      return await listLogs(this.#client, args, this.#deltaCursorStrategy);
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
@@ -6407,7 +7411,7 @@ var ObservabilityStorageClickhouseVNext = class extends storage.ObservabilitySto
   }
   async listMetrics(args) {
     try {
-      return await listMetrics(this.#client, args);
+      return await listMetrics(this.#client, args, this.#deltaCursorStrategy);
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
@@ -6453,7 +7457,7 @@ var ObservabilityStorageClickhouseVNext = class extends storage.ObservabilitySto
   }
   async listScores(args) {
     try {
-      return await listScores(this.#client, args);
+      return await listScores(this.#client, args, this.#deltaCursorStrategy);
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
@@ -6515,7 +7519,7 @@ var ObservabilityStorageClickhouseVNext = class extends storage.ObservabilitySto
   }
   async listFeedback(args) {
     try {
-      return await listFeedback(this.#client, args);
+      return await listFeedback(this.#client, args, this.#deltaCursorStrategy);
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(